elementary: efl_ui_list change SegArray tree to Efl.Object

10 files changed, 167 insertions, 108 deletions

diff --git a/src/Makefile_Elementary.am b/src/Makefile_Elementary.am
index eee0170d3d..5b3cdb70b0 100644
--- a/src/Makefile_Elementary.am
+++ b/src/Makefile_Elementary.am
@@ -74,6 +74,7 @@ elm_public_eolian_files = \
 	lib/elementary/efl_ui_list.eo \
 	lib/elementary/efl_ui_list_model.eo \
 	lib/elementary/efl_ui_list_pan.eo \
+	lib/elementary/efl_ui_list_segarray.eo \
 	lib/elementary/efl_ui_list_relayout.eo \
 	lib/elementary/efl_ui_multibuttonentry_part.eo \
 	lib/elementary/efl_ui_panes_part.eo \
diff --git a/src/examples/elementary/efl_ui_list_example_1.c b/src/examples/elementary/efl_ui_list_example_1.c
index 4aea1e5c2f..145861e286 100644
--- a/src/examples/elementary/efl_ui_list_example_1.c
+++ b/src/examples/elementary/efl_ui_list_example_1.c
@@ -105,6 +105,7 @@ elm_main(int argc, char **argv)
    evas_object_show(win);
 
    elm_run();
+   efl_unref(model);
 
    return 0;
 }
diff --git a/src/lib/elementary/Elementary.h b/src/lib/elementary/Elementary.h
index 0880126512..54142ee83a 100644
--- a/src/lib/elementary/Elementary.h
+++ b/src/lib/elementary/Elementary.h
@@ -281,6 +281,7 @@ typedef Eo Efl_Ui_Focus_Manager;
 #ifdef EFL_EO_API_SUPPORT
 # include <efl_selection_types.eot.h>
 # include <efl_ui_list_segarray.h>
+# include <efl_ui_list_segarray.eo.h>
 # include <efl_config_global.eo.h>
 # include <efl_ui_widget.eo.h>
 # include <efl_ui_widget_part.eo.h>
diff --git a/src/lib/elementary/efl_ui_list.c b/src/lib/elementary/efl_ui_list.c
index 2d3f213126..e332d9cf40 100644
--- a/src/lib/elementary/efl_ui_list.c
+++ b/src/lib/elementary/efl_ui_list.c
@@ -721,7 +721,7 @@ _efl_ui_list_efl_object_constructor(Eo *obj, Efl_Ui_List_Data *pd)
    evas_object_smart_callbacks_descriptions_set(obj, _smart_callbacks);
    efl_access_role_set(obj, EFL_ACCESS_ROLE_LIST);
 
-   efl_ui_list_segarray_setup(&pd->segarray, 32);
+   pd->segarray = efl_add(EFL_UI_LIST_SEGARRAY_CLASS, obj, efl_ui_list_segarray_setup(efl_added, 32));
 
    manager = efl_ui_widget_focus_manager_create(obj, obj);
    efl_composite_attach(obj, manager);
@@ -735,7 +735,6 @@ _efl_ui_list_efl_object_constructor(Eo *obj, Efl_Ui_List_Data *pd)
    pd->style = eina_stringshare_add(elm_widget_style_get(obj));
 
    pd->factory = NULL;
-   pd->orient = EFL_ORIENT_DOWN;
    pd->align.h = 0;
    pd->align.v = 0;
    pd->min.w = 0;
@@ -758,8 +757,6 @@ _efl_ui_list_efl_object_destructor(Eo *obj, Efl_Ui_List_Data *pd)
    ELM_SAFE_FREE(pd->pan_obj, evas_object_del);
    efl_canvas_group_del(efl_super(obj, MY_CLASS));
 
-   efl_ui_list_segarray_flush(&pd->segarray);
-
    efl_destructor(efl_super(obj, MY_CLASS));
 }
 
@@ -789,7 +786,7 @@ _efl_ui_list_efl_ui_view_model_set(Eo *obj EINA_UNUSED, Efl_Ui_List_Data *pd, Ef
      {
         if (pd->relayout)
           efl_ui_list_relayout_model_set(pd->relayout, NULL);
-        efl_ui_list_segarray_flush(&pd->segarray);
+        efl_ui_list_segarray_flush(pd->segarray);
         efl_unref(pd->model);
         pd->model = NULL;
      }
@@ -930,7 +927,7 @@ _layout(Efl_Ui_List_Data *pd)
    if (!pd->model)
      return;
 
-   efl_ui_list_relayout_layout_do(pd->relayout, pd->obj, pd->segarray_first, &pd->segarray);
+   efl_ui_list_relayout_layout_do(pd->relayout, pd->obj, pd->segarray_first, pd->segarray);
 }
 
 static void
@@ -939,7 +936,7 @@ _children_slice_then(void * data, Efl_Event const* event)
    Efl_Ui_List_Data *pd = data;
    Eina_Accessor *acc = (Eina_Accessor*)((Efl_Future_Event_Success*)event->info)->value;
 
-   efl_ui_list_segarray_insert_accessor(&pd->segarray, pd->outstanding_slice.slice_start, acc);
+   efl_ui_list_segarray_insert_accessor(pd->segarray, pd->outstanding_slice.slice_start, acc);
 
    pd->segarray_first = pd->outstanding_slice.slice_start;
    pd->outstanding_slice.slice_start = pd->outstanding_slice.slice_count = 0;
@@ -1007,7 +1004,7 @@ _efl_ui_list_efl_ui_list_model_realize(Eo *obj, Efl_Ui_List_Data *pd, Efl_Ui_Lis
 
    evt.child = item->children;
    evt.layout = item->layout;
-   evt.index = efl_ui_list_item_index_get((Efl_Ui_List_Item *)item);
+   evt.index = efl_ui_list_item_index_get(item);
    efl_event_callback_call(obj, EFL_UI_LIST_EVENT_ITEM_REALIZED, &evt);
    efl_ui_focus_composition_dirty(obj);
 
@@ -1033,7 +1030,7 @@ _efl_ui_list_efl_ui_list_model_unrealize(Eo *obj, Efl_Ui_List_Data *pd, Efl_Ui_L
 
    evt.child = item->children;
    evt.layout = item->layout;
-   evt.index = efl_ui_list_item_index_get((Efl_Ui_List_Item *)item);
+   evt.index = efl_ui_list_item_index_get(item);
    efl_event_callback_call(obj, EFL_UI_LIST_EVENT_ITEM_UNREALIZED, &evt);
 
    evas_object_smart_member_del(item->layout);
diff --git a/src/lib/elementary/efl_ui_list_private.h b/src/lib/elementary/efl_ui_list_private.h
index 5cd1fb3caf..f0ba576b99 100644
--- a/src/lib/elementary/efl_ui_list_private.h
+++ b/src/lib/elementary/efl_ui_list_private.h
@@ -20,12 +20,9 @@ struct _Efl_Ui_List_Item
    Efl_Ui_List_LayoutItem item;
    Efl_Future           *future;
    Efl_Ui_List          *list;
-   // Evas_Coord           x, y, minw, minh, w, h;
-   // // double               h, v, wx, wy;
-   // double               wx, wy;
 };
 
-int efl_ui_list_item_index_get(Efl_Ui_List_Item const* item);
+int efl_ui_list_item_index_get(Efl_Ui_List_LayoutItem *item);
 
 typedef struct _Efl_Ui_List_Data Efl_Ui_List_Data;
 
@@ -38,8 +35,6 @@ struct _Efl_Ui_List_Data
    Efl_Ui_List_Pan              *pan_obj;
    Efl_Model                    *model;
 
-   Efl_Orient                   orient;
-
    struct {
       double                    h, v;
       Eina_Bool                 scalable: 1;
@@ -53,20 +48,11 @@ struct _Efl_Ui_List_Data
       double                    x, y;
    } weight;
 
-   // struct {
-   //    Evas_Coord                w, h;
-   //    int                       start;
-   //    int                       slice;
-   // } realized;
-
    int segarray_first;
-   Efl_Ui_List_SegArray segarray;
+   Efl_Ui_List_SegArray         *segarray;
 
    Efl_Ui_Layout_Factory        *factory;
    Eina_List                    *selected_items;
-   // struct {
-   //   Eina_Inarray               array;
-   // } items;
    Eina_Stringshare             *style;
    Elm_Object_Select_Mode       select_mode;
    Elm_List_Mode                mode;
@@ -74,7 +60,7 @@ struct _Efl_Ui_List_Data
    Efl_Ui_Focus_Manager         *manager;
    Eina_Rect                    gmt;
    Eina_Size2D                  min;
-   int                          /*average_item_size, avsom, */item_count;
+   int                          item_count;
    Efl_Future                   *slice_future;
    Efl_Future                   *count_future;
    Efl_Ui_List_Relayout         *relayout;
@@ -108,8 +94,6 @@ struct _Efl_Ui_List_Slice
    int                    newstart, slicestart, newslice;
 };
 
-
-
 #define EFL_UI_LIST_DATA_GET(o, ptr) \
   Efl_Ui_List_Data * ptr = efl_data_scope_get(o, EFL_UI_LIST_CLASS)
 
diff --git a/src/lib/elementary/efl_ui_list_relayout.eo b/src/lib/elementary/efl_ui_list_relayout.eo
index 22ba57fae3..cf9ab6080a 100644
--- a/src/lib/elementary/efl_ui_list_relayout.eo
+++ b/src/lib/elementary/efl_ui_list_relayout.eo
@@ -1,7 +1,5 @@
 import efl_ui_list_types;
 
-struct @extern Efl_Ui_List_SegArray;
-
 interface Efl.Ui.List.Relayout (Efl.Interface)
 {
    methods {
@@ -9,7 +7,7 @@ interface Efl.Ui.List.Relayout (Efl.Interface)
          params {
             modeler: Efl.Ui.List.Model;
             first: int;
-            children: ptr(Efl_Ui_List_SegArray);
+            children: Efl.Ui.List.SegArray;
          }
       }
       @property model {
diff --git a/src/lib/elementary/efl_ui_list_segarray.c b/src/lib/elementary/efl_ui_list_segarray.c
index 4cc7dc9ba3..efa0b3d5c2 100644
--- a/src/lib/elementary/efl_ui_list_segarray.c
+++ b/src/lib/elementary/efl_ui_list_segarray.c
@@ -2,13 +2,15 @@
 # include "elementary_config.h"
 #endif
 
-#include "efl_ui_list_private.h"
-#include "efl_ui_list_segarray.h"
-
 #include <Efl.h>
-
 #include <assert.h>
 
+#define MY_CLASS EFL_UI_LIST_SEGARRAY_CLASS
+#define MY_CLASS_NAME "Efl.Ui.List.SegArray"
+
+#include "efl_ui_list_private.h"
+#include "efl_ui_list_segarray.h"
+
 static int _search_lookup_cb(Eina_Rbtree const* rbtree, const void* key, int length EINA_UNUSED, void* data EINA_UNUSED)
 {
   Efl_Ui_List_SegArray_Node const* node = (void const*)rbtree;
@@ -70,31 +72,27 @@ _free_node(Efl_Ui_List_SegArray_Node* node, void* data EINA_UNUSED)
 }
 
 static Efl_Ui_List_SegArray_Node*
-_alloc_node(Efl_Ui_List_SegArray* segarray, int first, int max)
+_alloc_node(Efl_Ui_List_SegArray_Data* pd, int first)
 {
    Efl_Ui_List_SegArray_Node* node;
-   node = calloc(1, sizeof(Efl_Ui_List_SegArray_Node) + max*sizeof(Efl_Ui_List_Item*));
+   node = calloc(1, sizeof(Efl_Ui_List_SegArray_Node) + pd->step_size*sizeof(Efl_Ui_List_Item*));
    node->first = first;
-   node->max = max;
-   segarray->root = (void*)eina_rbtree_inline_insert(EINA_RBTREE_GET(segarray->root), EINA_RBTREE_GET(node),
+   node->max = pd->step_size;
+   pd->root = (void*)eina_rbtree_inline_insert(EINA_RBTREE_GET(pd->root), EINA_RBTREE_GET(node),
                                                      EINA_RBTREE_CMP_NODE_CB(&_rbtree_compare), NULL);
-   segarray->node_count++;
+   pd->node_count++;
    return node;
 }
 
-void efl_ui_list_segarray_setup(Efl_Ui_List_SegArray* segarray, //int member_size,
-                                int initial_step_size)
+EOLIAN static void
+_efl_ui_list_segarray_flush(Eo* obj EINA_UNUSED, Efl_Ui_List_SegArray_Data *pd)
 {
-   segarray->root = NULL;
-   segarray->array_initial_size = initial_step_size;
-}
+   if (pd->root)
+     eina_rbtree_delete(EINA_RBTREE_GET(pd->root), EINA_RBTREE_FREE_CB(_free_node), NULL);
 
-void efl_ui_list_segarray_flush(Efl_Ui_List_SegArray* segarray)
-{
-   eina_rbtree_delete(EINA_RBTREE_GET(segarray->root), EINA_RBTREE_FREE_CB(_free_node), NULL);
-   segarray->root = NULL;
-   segarray->node_count = 0;
-   segarray->count = 0;
+   pd->root = NULL;
+   pd->node_count = 0;
+   pd->count = 0;
 }
 
 static Efl_Ui_List_Item* _create_item_partial(Efl_Model* model)
@@ -112,15 +110,15 @@ static Efl_Ui_List_Item* _create_item(Efl_Model* model, Efl_Ui_List_SegArray_Nod
    return item;
 }
 
-Efl_Ui_List_Item*
-efl_ui_list_segarray_remove(Efl_Ui_List_SegArray* segarray, int index)
+EOLIAN static Efl_Ui_List_Item*
+_efl_ui_list_segarray_remove(Eo* obj EINA_UNUSED, Efl_Ui_List_SegArray_Data *pd, int index)
 {
    Efl_Ui_List_SegArray_Node *node;
    Efl_Ui_List_Item *item, *rt;
    Eina_Iterator* iterator;
    int offset;
 
-   node = (void*)eina_rbtree_inline_lookup(EINA_RBTREE_GET(segarray->root),
+   node = (void*)eina_rbtree_inline_lookup(EINA_RBTREE_GET(pd->root),
                                         &index, sizeof(index), &_insert_lookup_cb, NULL);
    if (!node) return NULL;
 
@@ -128,7 +126,7 @@ efl_ui_list_segarray_remove(Efl_Ui_List_SegArray* segarray, int index)
    if (offset >= node->length) return NULL;
 
    rt = node->pointers[offset];
-   segarray->count--;
+   pd->count--;
    node->length--;
 
    while (offset < node->length)
@@ -148,7 +146,7 @@ efl_ui_list_segarray_remove(Efl_Ui_List_SegArray* segarray, int index)
 }
 
 static void
-_efl_ui_list_segarray_insert_at_node(Efl_Ui_List_SegArray* segarray, int index, Efl_Ui_List_Item* item, Efl_Ui_List_SegArray_Node* node)
+_efl_ui_list_segarray_insert_at_node(Efl_Ui_List_SegArray_Data* pd, int index, Efl_Ui_List_Item* item, Efl_Ui_List_SegArray_Node* node)
 {
    Eina_Iterator* iterator;
    int pos;
@@ -166,10 +164,10 @@ _efl_ui_list_segarray_insert_at_node(Efl_Ui_List_SegArray* segarray, int index,
             node->pointers[pos] = item;
             node->length++;
          }
-       else 
+       else
          {
             assert(pos == node->length);
-      
+
             assert(node->length != node->max);
             node->pointers[pos] = item;
             node->length++;
@@ -177,7 +175,7 @@ _efl_ui_list_segarray_insert_at_node(Efl_Ui_List_SegArray* segarray, int index,
     }
   else
     {
-       node = _alloc_node(segarray, index, segarray->array_initial_size);
+       node = _alloc_node(pd, index);
        node->pointers[0] = item;
        node->length++;
        item->item.index_offset = 0;
@@ -195,28 +193,30 @@ _efl_ui_list_segarray_insert_at_node(Efl_Ui_List_SegArray* segarray, int index,
 }
 
 
-void efl_ui_list_segarray_insert(Efl_Ui_List_SegArray* segarray, int index, Efl_Model* model)
+EOLIAN static void
+_efl_ui_list_segarray_insert(Eo *obj EINA_UNUSED, Efl_Ui_List_SegArray_Data* pd, int index, Efl_Model* model)
 {
   Efl_Ui_List_SegArray_Node* node, *next;
   Efl_Ui_List_Item* item;
 
   item = _create_item_partial(model);
-  
-  node = (void*)eina_rbtree_inline_lookup(EINA_RBTREE_GET(segarray->root),
+
+  node = (void*)eina_rbtree_inline_lookup(EINA_RBTREE_GET(pd->root),
                                           &index, sizeof(index), &_insert_lookup_cb, NULL);
   if(node)
     {
       next = (void*)EINA_RBTREE_GET(node)->son[EINA_RBTREE_LEFT];
       if(next && next->first <= index)
-        _efl_ui_list_segarray_insert_at_node(segarray, index, item, next);
+        _efl_ui_list_segarray_insert_at_node(pd, index, item, next);
       else
-        _efl_ui_list_segarray_insert_at_node(segarray, index, item, node);
+        _efl_ui_list_segarray_insert_at_node(pd, index, item, node);
     }
   else
-    _efl_ui_list_segarray_insert_at_node(segarray, index, item, NULL);
+    _efl_ui_list_segarray_insert_at_node(pd, index, item, NULL);
 }
 
-void efl_ui_list_segarray_insert_accessor(Efl_Ui_List_SegArray* segarray, int first, Eina_Accessor* accessor)
+EOLIAN static void
+_efl_ui_list_segarray_insert_accessor(Eo *obj EINA_UNUSED, Efl_Ui_List_SegArray_Data* pd, int first, Eina_Accessor* accessor)
 {
    int i;
    Efl_Model* children;
@@ -226,29 +226,30 @@ void efl_ui_list_segarray_insert_accessor(Efl_Ui_List_SegArray* segarray, int fi
         Efl_Ui_List_SegArray_Node *node;
         int idx = first + i;
 
-        node = (void*)eina_rbtree_inline_lookup(EINA_RBTREE_GET(segarray->root),
+        node = (void*)eina_rbtree_inline_lookup(EINA_RBTREE_GET(pd->root),
                                                 &idx, sizeof(idx), &_insert_lookup_cb, NULL);
         if (!node)
           {
-             node = _alloc_node(segarray, idx, segarray->array_initial_size);
+             node = _alloc_node(pd, idx);
           }
 
         assert(node->length < node->max);
         node->pointers[node->length] = _create_item(children, node, idx);
         node->length++;
-        segarray->count++;
+        pd->count++;
      }
 }
 
-int efl_ui_list_segarray_count(Efl_Ui_List_SegArray const* segarray)
+EOLIAN static int
+_efl_ui_list_segarray_count(Eo *obj EINA_UNUSED, Efl_Ui_List_SegArray_Data* pd)
 {
-   return segarray->count;
+   return pd->count;
 }
 
 typedef struct _Efl_Ui_List_Segarray_Eina_Accessor
 {
    Eina_Accessor vtable;
-   Efl_Ui_List_SegArray* segarray;
+   Efl_Ui_List_SegArray_Data* segarray;
 } Efl_Ui_List_Segarray_Eina_Accessor;
 
 static Eina_Bool
@@ -258,19 +259,40 @@ _efl_ui_list_segarray_accessor_get_at(Efl_Ui_List_Segarray_Eina_Accessor* acc,
    Efl_Ui_List_SegArray_Node* node;
    node = (void*)eina_rbtree_inline_lookup(EINA_RBTREE_GET(acc->segarray->root),
                                            &idx, sizeof(idx), &_search_lookup_cb, NULL);
-   if(node)
+   if (node && (node->first <= idx && node->first + node->length > idx))
      {
-        if(node->first <= idx && node->first + node->length > idx)
-          {
-             int i = idx - node->first;
-             Efl_Ui_List_Item* item = node->pointers[i];
-             *data = item;
-             return EINA_TRUE;
-          }
+         int i = idx - node->first;
+         Efl_Ui_List_Item* item = node->pointers[i];
+         *data = item;
+         return EINA_TRUE;
      }
    return EINA_FALSE;
 }
 
+EOLIAN static void
+_efl_ui_list_segarray_setup(Eo *obj, Efl_Ui_List_SegArray_Data *pd, int size)
+{
+   pd->step_size = size;
+}
+
+EOLIAN static Eo *
+_efl_ui_list_segarray_efl_object_constructor(Eo *obj, Efl_Ui_List_SegArray_Data *pd)
+{
+   obj = efl_constructor(efl_super(obj, MY_CLASS));
+
+   return obj;
+}
+
+EOLIAN static void
+_efl_ui_list_segarray_efl_object_destructor(Eo *obj, Efl_Ui_List_SegArray_Data *pd)
+{
+   if (pd->root)
+     eina_rbtree_delete(EINA_RBTREE_GET(pd->root), EINA_RBTREE_FREE_CB(_free_node), NULL);
+
+   pd->root = NULL;
+   efl_destructor(efl_super(obj, MY_CLASS));
+}
+
 static void*
 _efl_ui_list_segarray_accessor_get_container(Efl_Ui_List_Segarray_Eina_Accessor* acc EINA_UNUSED)
 {
@@ -300,7 +322,7 @@ _efl_ui_list_segarray_accessor_clone(Efl_Ui_List_Segarray_Eina_Accessor* acc EIN
 }
 
 static void
-_efl_ui_list_segarray_accessor_setup(Efl_Ui_List_Segarray_Eina_Accessor* acc, Efl_Ui_List_SegArray* segarray)
+_efl_ui_list_segarray_accessor_setup(Efl_Ui_List_Segarray_Eina_Accessor* acc, Efl_Ui_List_SegArray_Data* segarray)
 {
    EINA_MAGIC_SET(&acc->vtable, EINA_MAGIC_ACCESSOR);
    acc->vtable.version = EINA_ACCESSOR_VERSION;
@@ -313,17 +335,18 @@ _efl_ui_list_segarray_accessor_setup(Efl_Ui_List_Segarray_Eina_Accessor* acc, Ef
    acc->segarray = segarray;
 }
 
-Eina_Accessor* efl_ui_list_segarray_accessor_get(Efl_Ui_List_SegArray* segarray)
+EOLIAN static Eina_Accessor*
+_efl_ui_list_segarray_accessor_get(Eo *obj EINA_UNUSED, Efl_Ui_List_SegArray_Data* pd)
 {
    Efl_Ui_List_Segarray_Eina_Accessor* acc = calloc(1, sizeof(Efl_Ui_List_Segarray_Eina_Accessor));
-   _efl_ui_list_segarray_accessor_setup(acc, segarray);
+   _efl_ui_list_segarray_accessor_setup(acc, pd);
    return &acc->vtable;
 }
 
 typedef struct _Efl_Ui_List_Segarray_Node_Accessor
 {
    Eina_Accessor vtable;
-   Efl_Ui_List_SegArray* segarray;
+   Efl_Ui_List_SegArray_Data* segarray;
    Eina_Iterator* pre_iterator;
    Efl_Ui_List_SegArray_Node* current_node;
    int current_index;
@@ -395,7 +418,7 @@ _efl_ui_list_segarray_node_accessor_clone(Efl_Ui_List_Segarray_Node_Accessor* ac
 }
 
 static void
-_efl_ui_list_segarray_node_accessor_setup(Efl_Ui_List_Segarray_Node_Accessor* acc, Efl_Ui_List_SegArray* segarray)
+_efl_ui_list_segarray_node_accessor_setup(Efl_Ui_List_Segarray_Node_Accessor* acc, Efl_Ui_List_SegArray_Data* segarray)
 {
    EINA_MAGIC_SET(&acc->vtable, EINA_MAGIC_ACCESSOR);
    acc->vtable.version = EINA_ACCESSOR_VERSION;
@@ -411,16 +434,18 @@ _efl_ui_list_segarray_node_accessor_setup(Efl_Ui_List_Segarray_Node_Accessor* ac
    acc->current_node = NULL;
 }
 
-Eina_Accessor* efl_ui_list_segarray_node_accessor_get(Efl_Ui_List_SegArray* segarray)
+EOLIAN static Eina_Accessor*
+_efl_ui_list_segarray_node_accessor_get(Eo *obj EINA_UNUSED, Efl_Ui_List_SegArray_Data* pd)
 {
    Efl_Ui_List_Segarray_Node_Accessor* acc = calloc(1, sizeof(Efl_Ui_List_Segarray_Node_Accessor));
-   _efl_ui_list_segarray_node_accessor_setup(acc, segarray);
+   _efl_ui_list_segarray_node_accessor_setup(acc, pd);
    return &acc->vtable;
 }
 
-int efl_ui_list_item_index_get(Efl_Ui_List_Item const* item)
+int efl_ui_list_item_index_get(Efl_Ui_List_LayoutItem* item)
 {
-  Efl_Ui_List_SegArray_Node* node = item->item.tree_node;
-  return item->item.index_offset + node->first;
+  Efl_Ui_List_SegArray_Node* node = item->tree_node;
+  return item->index_offset + node->first;
 }
 
+#include "efl_ui_list_segarray.eo.c"
diff --git a/src/lib/elementary/efl_ui_list_segarray.eo b/src/lib/elementary/efl_ui_list_segarray.eo
new file mode 100644
index 0000000000..4021aa9d1b
--- /dev/null
+++ b/src/lib/elementary/efl_ui_list_segarray.eo
@@ -0,0 +1,62 @@
+import elm_general;
+import efl_ui_list_types;
+
+class Efl.Ui.List.SegArray (Efl.Object)
+{
+   methods {
+      @property accessor {
+         get {
+            [[ Get a SegArray List items accessor ]]
+         }
+         values {
+             acc: accessor<ptr(Efl_Ui_List_Item)>;
+         }
+      }
+      @property node_accessor {
+         get {
+            [[ Get a SegArray node accessor ]]
+         }
+         values {
+             acc: accessor<ptr(Efl.Ui.List.SegArray.Node)>;
+         }
+      }
+      insert_accessor {
+         [[ Insert a accessor in segarray tree ]]
+          params {
+              @in first: int;
+              @in acc: accessor<Efl.Model>;
+          }
+      }
+      count {
+         [[ Get the number of items in SegArray tree ]]
+         return: int;
+      }
+      setup {
+         [[ Configure a step of SegArray tree, this is the max node size ]]
+          params {
+              @in initial_step_size: int;
+          }
+      }
+      flush {
+         [[ flush the SegArray tree ]]
+      }
+      insert {
+         [[ Insert a new model in SegArray tree at index position ]]
+          params {
+              @in index: int;
+              @in model: Efl.Model;
+          }
+      }
+      remove {
+         [[ Remove the item at index position in SegArray tree ]]
+          params {
+              @in index: int;
+          }
+          return: ptr(Efl_Ui_List_Item);
+      }
+   }
+   implements {
+      Efl.Object.constructor;
+      Efl.Object.destructor;
+   }
+}
diff --git a/src/lib/elementary/efl_ui_list_segarray.h b/src/lib/elementary/efl_ui_list_segarray.h
index eb8529a0c2..801aa060ed 100644
--- a/src/lib/elementary/efl_ui_list_segarray.h
+++ b/src/lib/elementary/efl_ui_list_segarray.h
@@ -1,8 +1,6 @@
 #ifndef EFL_UI_LIST_SEGARRAY_H
 #define EFL_UI_LIST_SEGARRAY_H
 
-#include "efl_ui_list_segarray.h"
-
 typedef struct _Efl_Ui_List_Item Efl_Ui_List_Item;
 
 typedef struct _Efl_Ui_List_SegArray_Node
@@ -18,25 +16,13 @@ typedef struct _Efl_Ui_List_SegArray_Node
    Efl_Ui_List_Item* pointers[0];
 } Efl_Ui_List_SegArray_Node;
 
-typedef struct _Efl_Ui_List_SegArray
+typedef struct _Efl_Ui_List_SegArray_Data
 {
-   Efl_Ui_List_SegArray_Node *root; // of Efl_Ui_List_SegArray_Nodea
+   Efl_Ui_List_SegArray_Node *root;
 
-   int array_initial_size;
+   int step_size;
    int node_count;
    int count;
-} Efl_Ui_List_SegArray;
-
-Eina_Accessor* efl_ui_list_segarray_accessor_get(Efl_Ui_List_SegArray* segarray);
-Eina_Accessor* efl_ui_list_segarray_node_accessor_get(Efl_Ui_List_SegArray* segarray);
-Efl_Ui_List_SegArray_Node* efl_ui_list_segarray_item_node_get(Efl_Ui_List_SegArray* segarray,
-                                                              Efl_Ui_List_Item* item);
-void efl_ui_list_segarray_insert_accessor(Efl_Ui_List_SegArray* segarray, int first, Eina_Accessor* accessor);
-int efl_ui_list_segarray_count(Efl_Ui_List_SegArray const* segarray);
-void efl_ui_list_segarray_setup(Efl_Ui_List_SegArray* segarray, int initial_step_size);
-void efl_ui_list_segarray_flush(Efl_Ui_List_SegArray* segarray);
-
-void efl_ui_list_segarray_insert(Efl_Ui_List_SegArray* segarray, int index, Efl_Model* model);
-Efl_Ui_List_Item *efl_ui_list_segarray_remove(Efl_Ui_List_SegArray* segarray, int index);
+} Efl_Ui_List_SegArray_Data;
 
 #endif
diff --git a/src/lib/elementary/efl_ui_list_types.eot b/src/lib/elementary/efl_ui_list_types.eot
index a0997c8db4..cdbeeaa930 100644
--- a/src/lib/elementary/efl_ui_list_types.eot
+++ b/src/lib/elementary/efl_ui_list_types.eot
@@ -7,3 +7,7 @@ struct Efl.Ui.List.LayoutItem {
    size: Eina.Size2D;
    pos: Eina.Position2D;
 }
+
+struct @extern Efl.Ui.List.SegArray.Node; [[ ]]
+struct @extern Efl_Ui_List_Item; [[ ]]
+