enlightenment/efl
enlightenment
/
efl
8
7
Fork 14
Code Issues 13 Pull Requests 3 Projects Releases Wiki Activity

elementary: efl_ui_list change SegArray tree to Efl.Object

This commit is contained in:
Larry Jr 2018-01-26 16:53:42 -02:00 committed by Felipe Magno de Almeida
parent 10d10dfa5d
commit ee0cbdad17
10 changed files with 167 additions and 108 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
src/Makefile_Elementary.am
View File

@ -73,6 +73,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 \

1
src/examples/elementary/efl_ui_list_example_1.c
View File

@ -105,6 +105,7 @@ elm_main(int argc, char **argv)
evas_object_show(win);
elm_run();
efl_unref(model);
return 0;
}

1
src/lib/elementary/Elementary.h
View File

@ -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>

15
src/lib/elementary/efl_ui_list.c
View File

@ -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);

22
src/lib/elementary/efl_ui_list_private.h
View File

@ -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)

4
src/lib/elementary/efl_ui_list_relayout.eo
View File

@ -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 {

143
src/lib/elementary/efl_ui_list_segarray.c
View File

@ -2,13 +2,15 @@
# include "elementary_config.h"
#endif
#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"
#include <Efl.h>
#include <assert.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"

62
src/lib/elementary/efl_ui_list_segarray.eo Normal file
View File

@ -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;
}
}

22
src/lib/elementary/efl_ui_list_segarray.h
View File

@ -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

4
src/lib/elementary/efl_ui_list_types.eot
View File

@ -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; [[ ]]