lib/ecore/efl_bounce_interpolator.eo \
lib/ecore/efl_spring_interpolator.eo \
lib/ecore/efl_cubic_bezier_interpolator.eo \
- lib/ecore/efl_model_loop.eo \
- lib/ecore/efl_model_item.eo \
- lib/ecore/efl_model_container.eo \
- lib/ecore/efl_model_container_item.eo \
- lib/ecore/efl_model_composite_boolean.eo \
- lib/ecore/efl_model_composite_selection.eo \
- lib/ecore/efl_model_composite.eo \
- lib/ecore/efl_model_view.eo
+ lib/ecore/efl_loop_model.eo \
+ lib/ecore/efl_generic_model.eo \
+ lib/ecore/efl_container_model.eo \
+ lib/ecore/efl_container_model_item.eo \
+ lib/ecore/efl_boolean_model.eo \
+ lib/ecore/efl_select_model.eo \
+ lib/ecore/efl_composite_model.eo \
+ lib/ecore/efl_view_model.eo
ecore_eolian_files = \
$(ecore_eolian_files_legacy) \
lib/ecore/efl_io_file.c \
lib/ecore/efl_io_copier.c \
lib/ecore/efl_io_buffered_stream.c \
-lib/ecore/efl_model_loop.c \
-lib/ecore/efl_model_item.c \
-lib/ecore/efl_model_container.c \
-lib/ecore/efl_model_container_item.c \
-lib/ecore/efl_model_container_private.h \
-lib/ecore/efl_model_composite.c \
-lib/ecore/efl_model_composite_boolean.c \
-lib/ecore/efl_model_composite_selection.c \
-lib/ecore/efl_model_composite_private.h \
+lib/ecore/efl_loop_model.c \
+lib/ecore/efl_generic_model.c \
+lib/ecore/efl_container_model.c \
+lib/ecore/efl_container_model_item.c \
+lib/ecore/efl_container_model_private.h \
+lib/ecore/efl_composite_model.c \
+lib/ecore/efl_boolean_model.c \
+lib/ecore/efl_select_model.c \
+lib/ecore/efl_composite_model_private.h \
lib/ecore/efl_model_accessor_view.c \
lib/ecore/efl_model_accessor_view_private.h \
-lib/ecore/efl_model_view.c \
+lib/ecore/efl_view_model.c \
lib/ecore/efl_linear_interpolator.c \
lib/ecore/efl_accelerate_interpolator.c \
lib/ecore/efl_decelerate_interpolator.c \
tests_efl_efl_suite_SOURCES = \
tests/efl/efl_suite.c \
-tests/efl/efl_test_model_container.c \
-tests/efl/efl_test_model_composite.c \
-tests/efl/efl_test_model_view.c \
+tests/efl/efl_test_container_model.c \
+tests/efl/efl_test_composite_model.c \
+tests/efl/efl_test_view_model.c \
tests/efl/efl_suite.h
tests_efl_efl_suite_CPPFLAGS = -I$(top_builddir)/src/lib/efl \
### Library
eio_eolian_files = \
- lib/eio/eio_model.eo \
+ lib/eio/efl_io_model.eo \
lib/eio/efl_io_manager.eo \
lib/eio/eio_sentry.eo
lib/eio/eio_monitor_poll.c \
lib/eio/eio_single.c \
lib/eio/eio_xattr.c \
-lib/eio/eio_model.c \
-lib/eio/eio_model_private.h \
+lib/eio/efl_io_model.c \
+lib/eio/efl_io_model_private.h \
lib/eio/eio_private.h \
lib/eio/eio_sentry_private.h
tests_eio_eio_suite_SOURCES = \
tests/eio/eio_suite.c \
-tests/eio/eio_model_test_file.c \
-tests/eio/eio_model_test_monitor_add.c \
+tests/eio/efl_io_model_test_file.c \
+tests/eio/efl_io_model_test_monitor_add.c \
tests/eio/eio_test_monitor.c \
tests/eio/eio_test_sentry.c \
tests/eio/eio_test_file.c \
lib/elementary/efl_ui_focus_parent_provider.eo \
lib/elementary/efl_ui_focus_parent_provider_standard.eo \
lib/elementary/efl_ui_focus_parent_provider_gen.eo \
- lib/elementary/efl_ui_model_state.eo \
+ lib/elementary/efl_ui_state_model.eo \
tests/elementary/focus_test.eo \
tests/elementary/focus_test_sub_main.eo \
lib/elementary/efl_ui_selection_manager.eo \
lib/elementary/efl_datetime_manager.eo \
lib/elementary/efl_ui_list_view_relayout.eo \
lib/elementary/efl_ui_list_view_precise_layouter.eo \
- lib/elementary/efl_ui_model_size.eo \
- lib/elementary/efl_ui_model_homogeneous.eo \
- lib/elementary/efl_ui_model_exact.eo \
- lib/elementary/efl_ui_model_average.eo \
+ lib/elementary/efl_ui_size_model.eo \
+ lib/elementary/efl_ui_homogeneous_model.eo \
+ lib/elementary/efl_ui_exact_model.eo \
+ lib/elementary/efl_ui_average_model.eo \
$(NULL)
## TIZEN_ONLY(20180509): support elementary optional build
lib/elementary/efl_ui_widget_focus_manager.c \
lib/elementary/efl_ui_caching_factory.c \
lib/elementary/efl_ui_widget_factory.c \
- lib/elementary/efl_ui_model_size.c \
- lib/elementary/efl_ui_model_homogeneous.c \
- lib/elementary/efl_ui_model_exact.c \
- lib/elementary/efl_ui_model_average.c \
+ lib/elementary/efl_ui_size_model.c \
+ lib/elementary/efl_ui_homogeneous_model.c \
+ lib/elementary/efl_ui_exact_model.c \
+ lib/elementary/efl_ui_average_model.c \
$(NULL)
_make_model(Evas_Object *win)
{
Eina_Value vtext;
- Efl_Model_Item *model, *child;
+ Efl_Generic_Model *model, *child;
unsigned int i, s;
char buf[256];
- model = efl_add(EFL_MODEL_ITEM_CLASS, win);
+ model = efl_add(EFL_GENERIC_MODEL_CLASS, win);
eina_value_setup(&vtext, EINA_VALUE_TYPE_STRING);
for (i = 0; i < (NUM_ITEMS); i++)
Efl_Ui_Factory *factory;
Evas_Object *win, *li;
Eo *model;
- Efl_Model_Composite_Selection *selmodel;
+ Efl_Select_Model *selmodel;
win = elm_win_util_standard_add("list_view", "List_View");
elm_policy_set(ELM_POLICY_QUIT, ELM_POLICY_QUIT_LAST_WINDOW_CLOSED);
elm_win_autodel_set(win, EINA_TRUE);
model = _make_model(win);
- selmodel = efl_add(EFL_MODEL_COMPOSITE_SELECTION_CLASS, efl_main_loop_get()
+ selmodel = efl_add(EFL_SELECT_MODEL_CLASS, efl_main_loop_get()
, efl_ui_view_model_set(efl_added, model)
);
if (argv[1] != NULL) dirname = argv[1];
else dirname = EFL_MODEL_TEST_FILENAME_PATH;
- model = efl_add(EIO_MODEL_CLASS, win, eio_model_path_set(efl_added, dirname));
+ model = efl_add(EFL_IO_MODEL_CLASS, win, efl_io_model_path_set(efl_added, dirname));
factory = efl_add(EFL_UI_LAYOUT_FACTORY_CLASS, win);
efl_ui_model_connect(factory, "efl.text", "filename");
efl_ui_layout_factory_theme_config(factory, "list_item", NULL, "default");
{
Priv_Data *priv = (Priv_Data*)data;
Eina_Value vtext, value;
- Efl_Model_Item *child;
+ Efl_Generic_Model *child;
eina_value_setup(&vtext, EINA_VALUE_TYPE_STRING);
eina_value_setup(&value, EINA_VALUE_TYPE_UCHAR);
_make_model()
{
Eina_Value vtext, value;
- Efl_Model_Item *model, *child;
+ Efl_Generic_Model *model, *child;
unsigned int i, len;
- model = efl_add(EFL_MODEL_ITEM_CLASS, efl_main_loop_get());
+ model = efl_add(EFL_GENERIC_MODEL_CLASS, efl_main_loop_get());
eina_value_setup(&vtext, EINA_VALUE_TYPE_STRING);
eina_value_setup(&value, EINA_VALUE_TYPE_UCHAR);
#include <Elementary.h>
#include <Efl.h>
#include <Eio.h>
-#include <eio_model.eo.h>
+#include <efl_io_model.eo.h>
#include <stdio.h>
#include <Eio.h>
#include <elm_view_form.h>
}
static int
-_filter_cb(void *data EINA_UNUSED, Eio_Model *model, Eina_File_Direct_Info *info)
+_filter_cb(void *data EINA_UNUSED, Efl_Io_Model *model, Eina_File_Direct_Info *info)
{
if (info->type == EINA_FILE_DIR && info->path[info->name_start] != '.') return 1;
else dirname = EFL_MODEL_TEST_FILENAME_PATH;
//treemodel
- priv.treemodel = efl_add(EIO_MODEL_CLASS, win, eio_model_path_set(efl_added, dirname));
- eio_model_children_filter_set(priv.treemodel, NULL, _filter_cb, NULL);
+ priv.treemodel = efl_add(EFL_IO_MODEL_CLASS, win, efl_io_model_path_set(efl_added, dirname));
+ efl_io_model_children_filter_set(priv.treemodel, NULL, _filter_cb, NULL);
//treeview
genlist = elm_genlist_add(win);
#include <Elementary.h>
#include <Efl.h>
#include <Eio.h>
-#include <eio_model.eo.h>
+#include <efl_io_model.eo.h>
#include <stdio.h>
#define EFL_MODEL_TEST_FILENAME_PATH "/tmp"
evas_object_size_hint_weight_set(genlist, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
evas_object_show(genlist);
- priv.filemodel = efl_add(EIO_MODEL_CLASS, win, eio_model_path_set(efl_added, dirname));
+ priv.filemodel = efl_add(EFL_IO_MODEL_CLASS, win, efl_io_model_path_set(efl_added, dirname));
priv.fileview = efl_add(ELM_VIEW_LIST_CLASS, win, elm_view_list_genlist_set(efl_added, genlist, ELM_GENLIST_ITEM_TREE, "double_label"));
elm_view_list_model_set(priv.fileview, priv.filemodel);
evas_object_event_callback_add(win, EVAS_CALLBACK_DEL, _cleanup_cb, &priv);
if (argv[1] != NULL) dirname = argv[1];
else dirname = EFL_MODEL_TEST_FILENAME_PATH;
- priv->model = efl_add(EIO_MODEL_CLASS, win, eio_model_path_set(efl_added, dirname));
+ priv->model = efl_add(EFL_IO_MODEL_CLASS, win, efl_io_model_path_set(efl_added, dirname));
genlist = elm_genlist_add(win);
priv->fileview = efl_add(ELM_VIEW_LIST_CLASS, win, elm_view_list_genlist_set(efl_added, genlist, ELM_GENLIST_ITEM_NONE, NULL));
* @{
*/
-#include "efl_model_loop.eo.h"
-#include "efl_model_item.eo.h"
-#include "efl_model_container.eo.h"
-#include "efl_model_container_item.eo.h"
-#include "efl_model_composite.eo.h"
-#include "efl_model_composite_boolean.eo.h"
-#include "efl_model_composite_selection.eo.h"
-#include "efl_model_view.eo.h"
+#include "efl_loop_model.eo.h"
+#include "efl_generic_model.eo.h"
+#include "efl_container_model.eo.h"
+#include "efl_container_model_item.eo.h"
+#include "efl_composite_model.eo.h"
+#include "efl_boolean_model.eo.h"
+#include "efl_select_model.eo.h"
+#include "efl_view_model.eo.h"
/**
* @}
#include <Efl_Core.h>
-#include "efl_model_composite_private.h"
+#include "efl_composite_model_private.h"
-typedef struct _Efl_Model_Composite_Boolean_Data Efl_Model_Composite_Boolean_Data;
-typedef struct _Efl_Model_Composite_Boolean_Value Efl_Model_Composite_Boolean_Value;
+typedef struct _Efl_Boolean_Model_Data Efl_Boolean_Model_Data;
+typedef struct _Efl_Boolean_Model_Value Efl_Boolean_Model_Value;
-struct _Efl_Model_Composite_Boolean_Data
+struct _Efl_Boolean_Model_Data
{
- Efl_Model_Composite_Boolean_Data *parent;
+ Efl_Boolean_Model_Data *parent;
Eina_Hash *values;
};
-struct _Efl_Model_Composite_Boolean_Value
+struct _Efl_Boolean_Model_Value
{
Eina_Stringshare *property;
};
static Eina_Iterator *
-_efl_model_composite_boolean_efl_model_properties_get(const Eo *obj,
- Efl_Model_Composite_Boolean_Data *pd)
+_efl_boolean_model_efl_model_properties_get(const Eo *obj,
+ Efl_Boolean_Model_Data *pd)
{
- EFL_MODEL_COMPOSITE_PROPERTIES_SUPER(props,
- obj, EFL_MODEL_COMPOSITE_BOOLEAN_CLASS,
+ EFL_COMPOSITE_MODEL_PROPERTIES_SUPER(props,
+ obj, EFL_BOOLEAN_MODEL_CLASS,
eina_hash_iterator_key_new(pd->parent->values));
return props;
}
static Eina_Value *
-_efl_model_composite_boolean_efl_model_property_get(const Eo *obj,
- Efl_Model_Composite_Boolean_Data *pd,
- const char *property)
+_efl_boolean_model_efl_model_property_get(const Eo *obj,
+ Efl_Boolean_Model_Data *pd,
+ const char *property)
{
- Efl_Model_Composite_Boolean_Value *v;
+ Efl_Boolean_Model_Value *v;
Eina_Stringshare *s;
Eina_Bool flag;
unsigned int index;
if (property == NULL) return NULL;
- // If we do not have a parent set that his a COMPOSITE_BOOLEAN, then we should just forward up the call
+ // If we do not have a parent set that his a BOOLEAN, then we should just forward up the call
if (!pd->parent)
- return efl_model_property_get(efl_super(obj, EFL_MODEL_COMPOSITE_BOOLEAN_CLASS), property);
+ return efl_model_property_get(efl_super(obj, EFL_BOOLEAN_MODEL_CLASS), property);
// Check if this is requesting a defined boolean property
- // Property are defined and their value are stored on the parent COMPOSITE_BOOLEAN
+ // Property are defined and their value are stored on the parent BOOLEAN
s = eina_stringshare_add(property);
v = eina_hash_find(pd->parent->values, s);
eina_stringshare_del(s);
if (!v) // Not a property handle by this object, forward
- return efl_model_property_get(efl_super(obj, EFL_MODEL_COMPOSITE_BOOLEAN_CLASS), property);
+ return efl_model_property_get(efl_super(obj, EFL_BOOLEAN_MODEL_CLASS), property);
- index = efl_model_composite_index_get(obj);
+ index = efl_composite_model_index_get(obj);
// As an optimization we do optimistically allocate the boolean array
// Better would be to have a sparse boolean array
}
static Eina_Future *
-_efl_model_composite_boolean_efl_model_property_set(Eo *obj,
- Efl_Model_Composite_Boolean_Data *pd,
- const char *property, Eina_Value *value)
+_efl_boolean_model_efl_model_property_set(Eo *obj,
+ Efl_Boolean_Model_Data *pd,
+ const char *property, Eina_Value *value)
{
- Efl_Model_Composite_Boolean_Value *v;
+ Efl_Boolean_Model_Value *v;
Eina_Stringshare *s;
Eina_Bool flag;
unsigned int index;
return efl_loop_future_rejected(obj,
EFL_MODEL_ERROR_UNKNOWN);
- // If we do not have a parent set that his a COMPOSITE_BOOLEAN, then we should just forward up the call
+ // If we do not have a parent set that his a BOOLEAN, then we should just forward up the call
if (!pd->parent)
- return efl_model_property_set(efl_super(obj, EFL_MODEL_COMPOSITE_BOOLEAN_CLASS),
+ return efl_model_property_set(efl_super(obj, EFL_BOOLEAN_MODEL_CLASS),
property, value);
// Check if this is requesting a defined boolean property
- // Property are defined and their value are stored on the parent COMPOSITE_BOOLEAN
+ // Property are defined and their value are stored on the parent BOOLEAN
s = eina_stringshare_add(property);
v = eina_hash_find(pd->parent->values, s);
eina_stringshare_del(s);
if (!v)
- return efl_model_property_set(efl_super(obj, EFL_MODEL_COMPOSITE_BOOLEAN_CLASS),
+ return efl_model_property_set(efl_super(obj, EFL_BOOLEAN_MODEL_CLASS),
property, value);
if (!eina_value_bool_convert(value, &flag))
return efl_loop_future_rejected(obj, EFL_MODEL_ERROR_UNKNOWN);
- index = efl_model_composite_index_get(obj);
+ index = efl_composite_model_index_get(obj);
// We are optimistically allocating the boolean buffer now.
// Aligning it on 64bits
static void
_boolean_value_free(void *data)
{
- Efl_Model_Composite_Boolean_Value *value = data;
+ Efl_Boolean_Model_Value *value = data;
eina_stringshare_del(value->property);
value->property = NULL;
}
static Eo *
-_efl_model_composite_boolean_efl_object_constructor(Eo *obj, Efl_Model_Composite_Boolean_Data *pd)
+_efl_boolean_model_efl_object_constructor(Eo *obj, Efl_Boolean_Model_Data *pd)
{
Eo *parent;
- obj = efl_constructor(efl_super(obj, EFL_MODEL_COMPOSITE_BOOLEAN_CLASS));
+ obj = efl_constructor(efl_super(obj, EFL_BOOLEAN_MODEL_CLASS));
if (!obj) return NULL;
pd->values = eina_hash_stringshared_new(_boolean_value_free);
- // Only add a reference to the parent if it is actually a COMPOSITE_BOOLEAN_CLASS
+ // Only add a reference to the parent if it is actually a BOOLEAN_MODEL_CLASS
// The root typically doesn't have any boolean property, only its child do
parent = efl_parent_get(obj);
- if (efl_isa(parent, EFL_MODEL_COMPOSITE_BOOLEAN_CLASS))
- pd->parent = efl_data_scope_get(parent, EFL_MODEL_COMPOSITE_BOOLEAN_CLASS);
+ if (efl_isa(parent, EFL_BOOLEAN_MODEL_CLASS))
+ pd->parent = efl_data_scope_get(parent, EFL_BOOLEAN_MODEL_CLASS);
return obj;
}
static void
-_efl_model_composite_boolean_efl_object_destructor(Eo *obj, Efl_Model_Composite_Boolean_Data *pd)
+_efl_boolean_model_efl_object_destructor(Eo *obj, Efl_Boolean_Model_Data *pd)
{
eina_hash_free(pd->values);
- efl_destructor(efl_super(obj, EFL_MODEL_COMPOSITE_BOOLEAN_CLASS));
+ efl_destructor(efl_super(obj, EFL_BOOLEAN_MODEL_CLASS));
}
static void
-_efl_model_composite_boolean_boolean_add(Eo *obj EINA_UNUSED,
- Efl_Model_Composite_Boolean_Data *pd,
- const char *name, Eina_Bool default_value)
+_efl_boolean_model_boolean_add(Eo *obj EINA_UNUSED,
+ Efl_Boolean_Model_Data *pd,
+ const char *name, Eina_Bool default_value)
{
- Efl_Model_Composite_Boolean_Value *value;
+ Efl_Boolean_Model_Value *value;
if (!name) return ;
- value = calloc(1, sizeof (Efl_Model_Composite_Boolean_Value));
+ value = calloc(1, sizeof (Efl_Boolean_Model_Value));
if (!value) return ;
value->property = eina_stringshare_add(name);
}
static void
-_efl_model_composite_boolean_boolean_del(Eo *obj EINA_UNUSED,
- Efl_Model_Composite_Boolean_Data *pd,
- const char *name)
+_efl_boolean_model_boolean_del(Eo *obj EINA_UNUSED,
+ Efl_Boolean_Model_Data *pd,
+ const char *name)
{
Eina_Stringshare *s;
eina_stringshare_del(s);
}
-#include "efl_model_composite_boolean.eo.c"
+#include "efl_boolean_model.eo.c"
-class Efl.Model_Composite_Boolean extends Efl.Model_Composite
+class Efl.Boolean_Model extends Efl.Composite_Model
{
- [[Efl model composite boolean class]]
+ [[Efl boolean model class]]
methods {
boolean_add {
[[Add a new named boolean property with a defined default value.]]
#include "ecore_private.h"
-#include "efl_model_composite.eo.h"
+#include "efl_composite_model.eo.h"
#define _CHILD_INDEX "child.index"
-typedef struct _Efl_Model_Composite_Data Efl_Model_Composite_Data;
+typedef struct _Efl_Composite_Model_Data Efl_Composite_Model_Data;
-struct _Efl_Model_Composite_Data
+struct _Efl_Composite_Model_Data
{
Efl_Model *source;
};
static void
-_efl_model_composite_efl_object_destructor(Eo *obj, Efl_Model_Composite_Data *pd)
+_efl_composite_model_efl_object_destructor(Eo *obj, Efl_Composite_Model_Data *pd)
{
if (pd->source)
{
pd->source = NULL;
}
- efl_destructor(efl_super(obj, EFL_MODEL_COMPOSITE_CLASS));
+ efl_destructor(efl_super(obj, EFL_COMPOSITE_MODEL_CLASS));
}
static Efl_Object *
-_efl_model_composite_efl_object_finalize(Eo *obj, Efl_Model_Composite_Data *pd)
+_efl_composite_model_efl_object_finalize(Eo *obj, Efl_Composite_Model_Data *pd)
{
if (pd->source == NULL)
{
}
static void
-_efl_model_composite_index_set(Eo *obj EINA_UNUSED, Efl_Model_Composite_Data *pd, unsigned int index)
+_efl_composite_model_index_set(Eo *obj EINA_UNUSED, Efl_Composite_Model_Data *pd, unsigned int index)
{
if (pd->set_index || !pd->source)
return ;
}
static unsigned int
-_efl_model_composite_index_get(const Eo *obj, Efl_Model_Composite_Data *pd)
+_efl_composite_model_index_get(const Eo *obj, Efl_Composite_Model_Data *pd)
{
Eina_Value *fetch = NULL;
unsigned int r = 0xFFFFFFFF;
}
static void
-_efl_model_composite_efl_ui_view_model_set(Eo *obj EINA_UNUSED, Efl_Model_Composite_Data *pd, Efl_Model *model)
+_efl_composite_model_efl_ui_view_model_set(Eo *obj EINA_UNUSED, Efl_Composite_Model_Data *pd, Efl_Model *model)
{
Eina_Iterator *properties;
const char *property;
}
static Efl_Model *
-_efl_model_composite_efl_ui_view_model_get(const Eo *obj EINA_UNUSED, Efl_Model_Composite_Data *pd)
+_efl_composite_model_efl_ui_view_model_get(const Eo *obj EINA_UNUSED, Efl_Composite_Model_Data *pd)
{
return pd->source;
}
static Eina_Future *
-_efl_model_composite_efl_model_property_set(Eo *obj, Efl_Model_Composite_Data *pd,
+_efl_composite_model_efl_model_property_set(Eo *obj, Efl_Composite_Model_Data *pd,
const char *property, Eina_Value *value)
{
if (pd->need_index && !strcmp(property, _CHILD_INDEX))
}
static Eina_Value *
-_efl_model_composite_efl_model_property_get(const Eo *obj EINA_UNUSED, Efl_Model_Composite_Data *pd,
+_efl_composite_model_efl_model_property_get(const Eo *obj EINA_UNUSED, Efl_Composite_Model_Data *pd,
const char *property)
{
if (pd->need_index && !strcmp(property, _CHILD_INDEX))
}
static Eina_Iterator *
-_efl_model_composite_efl_model_properties_get(const Eo *obj EINA_UNUSED, Efl_Model_Composite_Data *pd)
+_efl_composite_model_efl_model_properties_get(const Eo *obj EINA_UNUSED, Efl_Composite_Model_Data *pd)
{
if (pd->need_index)
{
}
static unsigned int
-_efl_model_composite_efl_model_children_count_get(const Eo *obj EINA_UNUSED, Efl_Model_Composite_Data *pd)
+_efl_composite_model_efl_model_children_count_get(const Eo *obj EINA_UNUSED, Efl_Composite_Model_Data *pd)
{
return efl_model_children_count_get(pd->source);
}
-typedef struct _Efl_Model_Composite_Slice_Request Efl_Model_Composite_Slice_Request;
-struct _Efl_Model_Composite_Slice_Request
+typedef struct _Efl_Composite_Model_Slice_Request Efl_Composite_Model_Slice_Request;
+struct _Efl_Composite_Model_Slice_Request
{
const Efl_Class *self;
Eo *parent;
};
static Eina_Value
-_efl_model_composite_then(Eo *o EINA_UNUSED, void *data, const Eina_Value v)
+_efl_composite_model_then(Eo *o EINA_UNUSED, void *data, const Eina_Value v)
{
- Efl_Model_Composite_Slice_Request *req = data;
+ Efl_Composite_Model_Slice_Request *req = data;
unsigned int i, len;
Eina_Value r = EINA_VALUE_EMPTY;
Eo *target = NULL;
// can know if it needs to retain the information regarding its index.
composite = efl_add(req->self, req->parent,
efl_ui_view_model_set(efl_added, target),
- efl_model_composite_index_set(efl_added, req->start + i));
+ efl_composite_model_index_set(efl_added, req->start + i));
eina_value_array_append(&r, composite);
}
}
static void
-_efl_model_composite_clean(Eo *o EINA_UNUSED, void *data, const Eina_Future *dead_future EINA_UNUSED)
+_efl_composite_model_clean(Eo *o EINA_UNUSED, void *data, const Eina_Future *dead_future EINA_UNUSED)
{
- Efl_Model_Composite_Slice_Request *req = data;
+ Efl_Composite_Model_Slice_Request *req = data;
efl_unref(req->parent);
free(data);
}
static Eina_Future *
-_efl_model_composite_efl_model_children_slice_get(Eo *obj,
- Efl_Model_Composite_Data *pd,
+_efl_composite_model_efl_model_children_slice_get(Eo *obj,
+ Efl_Composite_Model_Data *pd,
unsigned int start,
unsigned int count)
{
- Efl_Model_Composite_Slice_Request *req;
+ Efl_Composite_Model_Slice_Request *req;
Eina_Future *f;
f = efl_model_children_slice_get(pd->source, start, count);
if (!f) return NULL;
- req = malloc(sizeof (Efl_Model_Composite_Slice_Request));
+ req = malloc(sizeof (Efl_Composite_Model_Slice_Request));
if (!req) return efl_loop_future_rejected(obj, ENOMEM);
req->self = efl_class_get(obj);
req->start = start;
return efl_future_then(obj, f, .success_type = EINA_VALUE_TYPE_ARRAY,
- .success = _efl_model_composite_then,
- .free = _efl_model_composite_clean,
+ .success = _efl_composite_model_then,
+ .free = _efl_composite_model_clean,
.data = req);
}
static Efl_Object *
-_efl_model_composite_efl_model_child_add(Eo *obj EINA_UNUSED,
- Efl_Model_Composite_Data *pd)
+_efl_composite_model_efl_model_child_add(Eo *obj EINA_UNUSED,
+ Efl_Composite_Model_Data *pd)
{
return efl_model_child_add(pd->source);
}
static void
-_efl_model_composite_efl_model_child_del(Eo *obj EINA_UNUSED,
- Efl_Model_Composite_Data *pd,
+_efl_composite_model_efl_model_child_del(Eo *obj EINA_UNUSED,
+ Efl_Composite_Model_Data *pd,
Efl_Object *child)
{
efl_model_child_del(pd->source, child);
}
-#include "efl_model_composite.eo.c"
+#include "efl_composite_model.eo.c"
-class Efl.Model_Composite extends Efl.Model_Loop implements Efl.Ui.View
+class Efl.Composite_Model extends Efl.Loop_Model implements Efl.Ui.View
{
[[Efl model for all composite class which provide a unified API to set source of data.
-#define EFL_MODEL_COMPOSITE_PROPERTIES(name, dyn, sta, ...) \
- EFL_MODEL_COMPOSITE_PROPERTIES_SUPER(name, NULL, NULL, (dyn), sta, ##__VA_ARGS__)
+#define EFL_COMPOSITE_MODEL_PROPERTIES(name, dyn, sta, ...) \
+ EFL_COMPOSITE_MODEL_PROPERTIES_SUPER(name, NULL, NULL, (dyn), sta, ##__VA_ARGS__)
-#define EFL_MODEL_COMPOSITE_PROPERTIES_SUPER(name, obj, klass, dyn, ...) \
+#define EFL_COMPOSITE_MODEL_PROPERTIES_SUPER(name, obj, klass, dyn, ...) \
Eina_Iterator *name; \
do \
{ \
static const char *static_props__[] = { \
__VA_ARGS__ \
}; \
- name = _efl_model_composite_properties_mix( \
+ name = _efl_composite_model_properties_mix( \
((obj) ? efl_model_properties_get(efl_super((obj), (klass))) : NULL), \
(dyn), \
EINA_C_ARRAY_ITERATOR_NEW(static_props__)); \
static inline Eina_Iterator *
-_efl_model_composite_properties_mix(Eina_Iterator *super, Eina_Iterator *dyn, Eina_Iterator *sta)
+_efl_composite_model_properties_mix(Eina_Iterator *super, Eina_Iterator *dyn, Eina_Iterator *sta)
{
Eina_Iterator *its[3];
int i = 0;
#include "ecore_internal.h"
-#include "efl_model_container_private.h"
+#include "efl_container_model_private.h"
-#define MY_CLASS EFL_MODEL_CONTAINER_CLASS
+#define MY_CLASS EFL_CONTAINER_MODEL_CLASS
void *
_value_copy_alloc(void *v, const Eina_Value_Type *type)
}
static Efl_Object *
-_efl_model_container_efl_object_constructor(Eo *obj,
- Efl_Model_Container_Data *sd)
+_efl_container_model_efl_object_constructor(Eo *obj,
+ Efl_Container_Model_Data *sd)
{
obj = efl_constructor(efl_super(obj, MY_CLASS));
if (!obj)
}
static void
-_efl_model_container_efl_object_destructor(Eo *obj,
- Efl_Model_Container_Data *sd)
+_efl_container_model_efl_object_destructor(Eo *obj,
+ Efl_Container_Model_Data *sd)
{
Eina_Stringshare *key;
Eina_Iterator *it;
}
static const Eina_Value_Type *
-_efl_model_container_child_property_value_type_get(Eo *obj EINA_UNUSED,
- Efl_Model_Container_Data *sd,
+_efl_container_model_child_property_value_type_get(Eo *obj EINA_UNUSED,
+ Efl_Container_Model_Data *sd,
const char *property)
{
Child_Property_Data *cpd;
}
static Eina_Iterator *
-_efl_model_container_child_property_values_get(Eo *obj EINA_UNUSED,
- Efl_Model_Container_Data *sd,
+_efl_container_model_child_property_values_get(Eo *obj EINA_UNUSED,
+ Efl_Container_Model_Data *sd,
const char *property)
{
Child_Property_Data *cpd;
}
static Eina_Bool
-_efl_model_container_child_property_add(Eo *obj,
- Efl_Model_Container_Data *sd,
+_efl_container_model_child_property_add(Eo *obj,
+ Efl_Container_Model_Data *sd,
const char *name,
const Eina_Value_Type *type,
Eina_Iterator *values)
Efl_Model_Children_Event cevt = { 0 };
Efl_Model *child;
- child = efl_add(EFL_MODEL_CONTAINER_ITEM_CLASS, obj,
- efl_model_container_item_define(efl_added, sd, i));
+ child = efl_add(EFL_CONTAINER_MODEL_ITEM_CLASS, obj,
+ efl_container_model_item_define(efl_added, sd, i));
sd->childrens = eina_list_append(sd->childrens, child);
cevt.index = i;
}
static Eina_Iterator *
-_efl_model_container_efl_model_properties_get(const Eo *obj EINA_UNUSED, Efl_Model_Container_Data *sd)
+_efl_container_model_efl_model_properties_get(const Eo *obj EINA_UNUSED, Efl_Container_Model_Data *sd)
{
return eina_hash_iterator_key_new(sd->properties);
}
static Eina_Future *
-_efl_model_container_efl_model_property_set(Eo *obj,
- Efl_Model_Container_Data *pd EINA_UNUSED,
+_efl_container_model_efl_model_property_set(Eo *obj,
+ Efl_Container_Model_Data *pd EINA_UNUSED,
const char *property EINA_UNUSED,
Eina_Value *value EINA_UNUSED)
{
}
static Eina_Value *
-_efl_model_container_efl_model_property_get(const Eo *obj EINA_UNUSED,
- Efl_Model_Container_Data *pd EINA_UNUSED,
+_efl_container_model_efl_model_property_get(const Eo *obj EINA_UNUSED,
+ Efl_Container_Model_Data *pd EINA_UNUSED,
const char *property EINA_UNUSED)
{
return eina_value_error_new(EFL_MODEL_ERROR_NOT_FOUND);
}
static Eina_Future *
-_efl_model_container_efl_model_children_slice_get(Eo *obj,
- Efl_Model_Container_Data *sd,
+_efl_container_model_efl_model_children_slice_get(Eo *obj,
+ Efl_Container_Model_Data *sd,
unsigned int start,
unsigned int count)
{
}
static unsigned int
-_efl_model_container_efl_model_children_count_get(const Eo *obj EINA_UNUSED, Efl_Model_Container_Data *sd)
+_efl_container_model_efl_model_children_count_get(const Eo *obj EINA_UNUSED, Efl_Container_Model_Data *sd)
{
return eina_list_count(sd->childrens);
}
static Eo *
-_efl_model_container_efl_model_child_add(Eo *obj EINA_UNUSED, Efl_Model_Container_Data *sd EINA_UNUSED)
+_efl_container_model_efl_model_child_add(Eo *obj EINA_UNUSED, Efl_Container_Model_Data *sd EINA_UNUSED)
{
EINA_LOG_WARN("child_add not supported by Efl.Model.Container");
eina_error_set(EFL_MODEL_ERROR_NOT_SUPPORTED);
}
static void
-_efl_model_container_efl_model_child_del(Eo *obj EINA_UNUSED, Efl_Model_Container_Data *sd EINA_UNUSED, Eo *child EINA_UNUSED)
+_efl_container_model_efl_model_child_del(Eo *obj EINA_UNUSED, Efl_Container_Model_Data *sd EINA_UNUSED, Eo *child EINA_UNUSED)
{
EINA_LOG_WARN("child_del not supported by Efl.Model.Container");
eina_error_set(EFL_MODEL_ERROR_NOT_SUPPORTED);
}
-#include "efl_model_container.eo.c"
+#include "efl_container_model.eo.c"
import eina_types;
-class Efl.Model_Container extends Efl.Model_Loop
+class Efl.Container_Model extends Efl.Loop_Model
{
[[
Class used to create data models from Eina containers.
Each container supplied represents a series of property values, each item
- being the property value for a child object (@Efl.Model_Container_Item).
+ being the property value for a child object (@Efl.Container_Model_Item).
The data in the given containers are copied and stored internally.
#include <Efl.h>
#include <Ecore.h>
-#include "efl_model_container_private.h"
+#include "efl_container_model_private.h"
-#define MY_CLASS EFL_MODEL_CONTAINER_ITEM_CLASS
+#define MY_CLASS EFL_CONTAINER_MODEL_ITEM_CLASS
static void
-_efl_model_container_item_define(Eo *obj EINA_UNUSED, Efl_Model_Container_Item_Data *sd, void *parent_data, unsigned int index)
+_efl_container_model_item_define(Eo *obj EINA_UNUSED, Efl_Container_Model_Item_Data *sd, void *parent_data, unsigned int index)
{
sd->parent_data = parent_data;
sd->index = index;
}
EOLIAN static void
-_efl_model_container_item_efl_object_invalidate(Eo *obj, Efl_Model_Container_Item_Data *sd)
+_efl_container_model_item_efl_object_invalidate(Eo *obj, Efl_Container_Model_Item_Data *sd)
{
efl_invalidate(efl_super(obj, MY_CLASS));
}
static Eina_Iterator *
-_efl_model_container_item_efl_model_properties_get(const Eo *obj EINA_UNUSED, Efl_Model_Container_Item_Data *sd)
+_efl_container_model_item_efl_model_properties_get(const Eo *obj EINA_UNUSED, Efl_Container_Model_Item_Data *sd)
{
// FIXME: Not to sure here, shouldn't we extend a child of the parent actually ?
return efl_model_properties_get(sd->parent_data->obj);
}
static Efl_Object *
-_efl_model_container_item_efl_object_finalize(Eo *obj, Efl_Model_Container_Item_Data *pd)
+_efl_container_model_item_efl_object_finalize(Eo *obj, Efl_Container_Model_Item_Data *pd)
{
if (!pd->parent_data)
return NULL;
}
static Eina_Future *
-_efl_model_container_item_efl_model_property_set(Eo *obj,
- Efl_Model_Container_Item_Data *sd,
+_efl_container_model_item_efl_model_property_set(Eo *obj,
+ Efl_Container_Model_Item_Data *sd,
const char *property, Eina_Value *value)
{
Eina_Stringshare *name;
}
static Eina_Value *
-_efl_model_container_item_efl_model_property_get(const Eo *obj EINA_UNUSED,
- Efl_Model_Container_Item_Data *sd,
+_efl_container_model_item_efl_model_property_get(const Eo *obj EINA_UNUSED,
+ Efl_Container_Model_Item_Data *sd,
const char *property)
{
Eina_Stringshare *name;
}
EOLIAN static Eina_Future *
-_efl_model_container_item_efl_model_children_slice_get(Eo *obj,
- Efl_Model_Container_Item_Data *sd EINA_UNUSED,
+_efl_container_model_item_efl_model_children_slice_get(Eo *obj,
+ Efl_Container_Model_Item_Data *sd EINA_UNUSED,
unsigned int start EINA_UNUSED,
unsigned int count EINA_UNUSED)
{
}
EOLIAN static unsigned int
-_efl_model_container_item_efl_model_children_count_get(const Eo *obj EINA_UNUSED,
- Efl_Model_Container_Item_Data *sd EINA_UNUSED)
+_efl_container_model_item_efl_model_children_count_get(const Eo *obj EINA_UNUSED,
+ Efl_Container_Model_Item_Data *sd EINA_UNUSED)
{
return 0;
}
EOLIAN static Eo *
-_efl_model_container_item_efl_model_child_add(Eo *obj EINA_UNUSED,
- Efl_Model_Container_Item_Data *sd EINA_UNUSED)
+_efl_container_model_item_efl_model_child_add(Eo *obj EINA_UNUSED,
+ Efl_Container_Model_Item_Data *sd EINA_UNUSED)
{
EINA_LOG_WARN("child_add not supported by Efl.Model.Container.Item");
eina_error_set(EFL_MODEL_ERROR_NOT_SUPPORTED);
}
EOLIAN static void
-_efl_model_container_item_efl_model_child_del(Eo *obj EINA_UNUSED,
- Efl_Model_Container_Item_Data *sd EINA_UNUSED,
+_efl_container_model_item_efl_model_child_del(Eo *obj EINA_UNUSED,
+ Efl_Container_Model_Item_Data *sd EINA_UNUSED,
Eo *child EINA_UNUSED)
{
EINA_LOG_WARN("child_del not supported by Efl.Model.Container.Item");
eina_error_set(EFL_MODEL_ERROR_NOT_SUPPORTED);
}
-#include "efl_model_container_item.eo.c"
+#include "efl_container_model_item.eo.c"
-class Efl.Model_Container_Item extends Efl.Object implements Efl.Model
+class Efl.Container_Model_Item extends Efl.Object implements Efl.Model
{
[[
- Used as a child of @Efl.Model_Container.
+ Used as a child of @Efl.Container_Model.
- Provides the @Efl.Model API for elements of @Efl.Model_Container.
+ Provides the @Efl.Model API for elements of @Efl.Container_Model.
Should not be used in another context, so do not manually create objects
of this class.
]]
methods {
define {
- [[Defines @Efl.Model_Container_Item internal data.]]
+ [[Defines @Efl.Container_Model_Item internal data.]]
params {
parent_data: void_ptr; [[Pointer to the private data of the
- @Efl.Model_Container parent object.]]
- index: uint; [[Index of this item within the @Efl.Model_Container
+ @Efl.Container_Model parent object.]]
+ index: uint; [[Index of this item within the @Efl.Container_Model
children.]]
}
}
-#ifndef EFL_MODEL_CONTAINER_PRIVATE_H__
-#define EFL_MODEL_CONTAINER_PRIVATE_H__
+#ifndef EFL_CONTAINER_MODEL_PRIVATE_H__
+#define EFL_CONTAINER_MODEL_PRIVATE_H__
typedef struct _Child_Property_Data Child_Property_Data;
struct _Child_Property_Data
Eina_Array *values;
};
-typedef struct _Efl_Model_Container_Data Efl_Model_Container_Data;
-struct _Efl_Model_Container_Data
+typedef struct _Efl_Container_Model_Data Efl_Container_Model_Data;
+struct _Efl_Container_Model_Data
{
Eo *obj;
};
-typedef struct _Efl_Model_Container_Item_Data Efl_Model_Container_Item_Data;
-struct _Efl_Model_Container_Item_Data
+typedef struct _Efl_Container_Model_Item_Data Efl_Container_Model_Item_Data;
+struct _Efl_Container_Model_Item_Data
{
- Efl_Model_Container_Data *parent_data;
+ Efl_Container_Model_Data *parent_data;
unsigned int index;
};
#include "ecore_internal.h"
-#define MY_CLASS EFL_MODEL_ITEM_CLASS
+#define MY_CLASS EFL_GENERIC_MODEL_CLASS
-typedef struct _Efl_Model_Item_Data Efl_Model_Item_Data;
-struct _Efl_Model_Item_Data
+typedef struct _Efl_Generic_Model_Data Efl_Generic_Model_Data;
+struct _Efl_Generic_Model_Data
{
Eina_Hash *properties;
Eina_List *childrens;
}
static Efl_Object *
-_efl_model_item_efl_object_constructor(Eo *obj, Efl_Model_Item_Data *sd)
+_efl_generic_model_efl_object_constructor(Eo *obj, Efl_Generic_Model_Data *sd)
{
obj = efl_constructor(efl_super(obj, MY_CLASS));
if (!obj)
}
static void
-_efl_model_item_efl_object_destructor(Eo *obj, Efl_Model_Item_Data *sd)
+_efl_generic_model_efl_object_destructor(Eo *obj, Efl_Generic_Model_Data *sd)
{
eina_list_free(sd->childrens);
eina_hash_foreach(sd->properties, _stringshared_keys_free, NULL);
}
static Eina_Iterator *
-_efl_model_item_efl_model_properties_get(const Eo *obj EINA_UNUSED, Efl_Model_Item_Data *pd)
+_efl_generic_model_efl_model_properties_get(const Eo *obj EINA_UNUSED, Efl_Generic_Model_Data *pd)
{
return eina_hash_iterator_key_new(pd->properties);
}
static Eina_Future *
-_efl_model_item_efl_model_property_set(Eo *obj, Efl_Model_Item_Data *pd, const char *property, Eina_Value *value)
+_efl_generic_model_efl_model_property_set(Eo *obj, Efl_Generic_Model_Data *pd, const char *property, Eina_Value *value)
{
Eina_Stringshare *prop;
Eina_Value *exist;
}
static Eina_Value *
-_efl_model_item_efl_model_property_get(const Eo *obj EINA_UNUSED,
- Efl_Model_Item_Data *pd,
- const char *property)
+_efl_generic_model_efl_model_property_get(const Eo *obj EINA_UNUSED,
+ Efl_Generic_Model_Data *pd,
+ const char *property)
{
Eina_Stringshare *prop;
Eina_Value *value;
}
static Eina_Future *
-_efl_model_item_efl_model_children_slice_get(Eo *obj, Efl_Model_Item_Data *pd, unsigned int start, unsigned int count)
+_efl_generic_model_efl_model_children_slice_get(Eo *obj, Efl_Generic_Model_Data *pd, unsigned int start, unsigned int count)
{
Eina_Value v;
}
static unsigned int
-_efl_model_item_efl_model_children_count_get(const Eo *obj EINA_UNUSED, Efl_Model_Item_Data *pd)
+_efl_generic_model_efl_model_children_count_get(const Eo *obj EINA_UNUSED, Efl_Generic_Model_Data *pd)
{
return eina_list_count(pd->childrens);
}
static Eo *
-_efl_model_item_efl_model_child_add(Eo *obj, Efl_Model_Item_Data *sd)
+_efl_generic_model_efl_model_child_add(Eo *obj, Efl_Generic_Model_Data *sd)
{
Efl_Model_Children_Event cevt;
Efl_Model *child;
- child = efl_add(EFL_MODEL_ITEM_CLASS, obj);
+ child = efl_add(EFL_GENERIC_MODEL_CLASS, obj);
if (!child)
{
- EINA_LOG_ERR("Could not allocate Efl.Model.Item");
+ EINA_LOG_ERR("Could not allocate Efl.Generic_Model");
eina_error_set(EFL_MODEL_ERROR_UNKNOWN);
return NULL;
}
}
static void
-_efl_model_item_efl_model_child_del(Eo *obj, Efl_Model_Item_Data *sd, Eo *child)
+_efl_generic_model_efl_model_child_del(Eo *obj, Efl_Generic_Model_Data *sd, Eo *child)
{
Efl_Model *data;
Eina_List *l;
}
}
-#include "efl_model_item.eo.c"
+#include "efl_generic_model.eo.c"
-class Efl.Model_Item extends Efl.Model_Loop
+class Efl.Generic_Model extends Efl.Loop_Model
{
[[
Generic model that allows any property to be manually set.
#include <Ecore.h>
#include "Eo.h"
-#include "efl_model_loop.eo.h"
+#include "efl_loop_model.eo.h"
-typedef struct _Efl_Model_Loop_Watcher_Data Efl_Model_Loop_Watcher_Data;
+typedef struct _Efl_Loop_Model_Watcher_Data Efl_Loop_Model_Watcher_Data;
-struct _Efl_Model_Loop_Watcher_Data
+struct _Efl_Loop_Model_Watcher_Data
{
const char *property;
Eina_Promise *p;
static void _propagate_future(void *data, const Efl_Event *event);
static void
-_efl_model_loop_wathcer_free(Efl_Model_Loop_Watcher_Data *wd)
+_efl_loop_model_wathcer_free(Efl_Loop_Model_Watcher_Data *wd)
{
efl_event_callback_del(wd->obj, EFL_MODEL_EVENT_PROPERTIES_CHANGED,
_propagate_future, wd);
const char *property;
unsigned int i;
Eina_Array_Iterator it;
- Efl_Model_Loop_Watcher_Data *wd = data;
+ Efl_Loop_Model_Watcher_Data *wd = data;
EINA_ARRAY_ITER_NEXT(ev->changed_properties, i, property, it)
if (property == wd->property || !strcmp(property, wd->property))
}
eina_value_free(v);
- _efl_model_loop_wathcer_free(wd);
+ _efl_loop_model_wathcer_free(wd);
break ;
}
}
static void
_event_cancel(void *data, const Eina_Promise *dead_ptr EINA_UNUSED)
{
- _efl_model_loop_wathcer_free(data);
+ _efl_loop_model_wathcer_free(data);
}
static Eina_Future *
-_efl_model_loop_efl_model_property_ready_get(Eo *obj, void *pd EINA_UNUSED, const char *property)
+_efl_loop_model_efl_model_property_ready_get(Eo *obj, void *pd EINA_UNUSED, const char *property)
{
Eina_Value *value = efl_model_property_get(obj, property);
Eina_Future *f;
if (err == EAGAIN)
{
- Efl_Model_Loop_Watcher_Data *wd = calloc(1, sizeof (Efl_Model_Loop_Watcher_Data));
+ Efl_Loop_Model_Watcher_Data *wd = calloc(1, sizeof (Efl_Loop_Model_Watcher_Data));
wd->obj = obj;
wd->property = eina_stringshare_add(property);
return efl_future_then(obj, f);
}
-#include "efl_model_loop.eo.c"
+#include "efl_loop_model.eo.c"
-abstract Efl.Model_Loop extends Efl.Loop_Consumer implements Efl.Model
+abstract Efl.Loop_Model extends Efl.Loop_Consumer implements Efl.Model
{
data: null;
implements {
#include <Ecore.h>
#include "Eo.h"
-#include "efl_model_composite_selection.eo.h"
+#include "efl_select_model.eo.h"
#include "efl_model_accessor_view_private.h"
-#include "efl_model_composite_private.h"
+#include "efl_composite_model_private.h"
-typedef struct _Efl_Model_Composite_Selection_Data Efl_Model_Composite_Selection_Data;
+typedef struct _Efl_Select_Model_Data Efl_Select_Model_Data;
-struct _Efl_Model_Composite_Selection_Data
+struct _Efl_Select_Model_Data
{
- Efl_Model_Composite_Selection_Data *parent;
+ Efl_Select_Model_Data *parent;
unsigned long last;
Eina_Bool exclusive : 1;
};
static Eo*
-_efl_model_composite_selection_efl_object_constructor(Eo *obj,
- Efl_Model_Composite_Selection_Data *pd)
+_efl_select_model_efl_object_constructor(Eo *obj,
+ Efl_Select_Model_Data *pd EINA_UNUSED)
{
Eo *parent;
- obj = efl_constructor(efl_super(obj, EFL_MODEL_COMPOSITE_SELECTION_CLASS));
+ obj = efl_constructor(efl_super(obj, EFL_SELECT_MODEL_CLASS));
- efl_model_composite_boolean_add(obj, "selected", EINA_FALSE);
+ efl_boolean_model_boolean_add(obj, "selected", EINA_FALSE);
pd->last = -1;
parent = efl_parent_get(obj);
- if (efl_isa(parent, EFL_MODEL_COMPOSITE_SELECTION_CLASS))
- pd->parent = efl_data_scope_get(parent, EFL_MODEL_COMPOSITE_SELECTION_CLASS);
+ if (efl_isa(parent, EFL_SELECT_MODEL_CLASS))
+ pd->parent = efl_data_scope_get(parent, EFL_SELECT_MODEL_CLASS);
return obj;
}
static Eina_Value
_commit_change(Eo *child, void *data EINA_UNUSED, const Eina_Value v)
{
- Efl_Model_Composite_Selection_Data *pd;
+ Efl_Select_Model_Data *pd;
Eina_Value *selected = NULL;
Eina_Bool selflag = EINA_FALSE;
selected = efl_model_property_get(child, "selected");
- pd = efl_data_scope_get(efl_parent_get(child), EFL_MODEL_COMPOSITE_SELECTION_CLASS);
+ pd = efl_data_scope_get(efl_parent_get(child), EFL_SELECT_MODEL_CLASS);
if (!pd) goto on_error;
eina_value_bool_get(selected, &selflag);
{
// select case
pd->none = EINA_FALSE;
- pd->last = efl_model_composite_index_get(child);
- efl_event_callback_call(child, EFL_MODEL_COMPOSITE_SELECTION_EVENT_SELECTED, child);
+ pd->last = efl_composite_model_index_get(child);
+ efl_event_callback_call(child, EFL_SELECT_MODEL_EVENT_SELECTED, child);
}
else
{
// unselect case
unsigned long last;
- last = efl_model_composite_index_get(child);
+ last = efl_composite_model_index_get(child);
if (pd->last == last)
{
pd->last = 0;
pd->none = EINA_TRUE;
}
- efl_event_callback_call(child, EFL_MODEL_COMPOSITE_SELECTION_EVENT_UNSELECTED, child);
+ efl_event_callback_call(child, EFL_SELECT_MODEL_EVENT_UNSELECTED, child);
}
on_error:
// where we could end up here.
Eina_Error *error = calloc(1, sizeof (Eina_Error));
- f = efl_model_property_set(efl_super(child, EFL_MODEL_COMPOSITE_SELECTION_CLASS),
+ f = efl_model_property_set(efl_super(child, EFL_SELECT_MODEL_CLASS),
"selected", eina_value_bool_new(EINA_FALSE));
// Once this is done, we need to repropagate the error
*error = err;
}
static Eina_Iterator *
-_efl_model_composite_selection_efl_model_properties_get(const Eo *obj,
- Efl_Model_Composite_Selection_Data *pd EINA_UNUSED)
+_efl_select_model_efl_model_properties_get(const Eo *obj,
+ Efl_Select_Model_Data *pd EINA_UNUSED)
{
- EFL_MODEL_COMPOSITE_PROPERTIES_SUPER(props,
- obj, EFL_MODEL_COMPOSITE_SELECTION_CLASS,
+ EFL_COMPOSITE_MODEL_PROPERTIES_SUPER(props,
+ obj, EFL_SELECT_MODEL_CLASS,
NULL,
"self.selected", "child.selected", "exclusive");
return props;
}
static Eina_Future *
-_efl_model_composite_selection_efl_model_property_set(Eo *obj,
- Efl_Model_Composite_Selection_Data *pd,
+_efl_select_model_efl_model_property_set(Eo *obj,
+ Efl_Select_Model_Data *pd,
const char *property, Eina_Value *value)
{
Eina_Value vf = EINA_VALUE_EMPTY;
Eina_Value *prev;
Eina_Future *chain;
- prev = efl_model_property_get(efl_super(obj, EFL_MODEL_COMPOSITE_SELECTION_CLASS), "selected");
+ prev = efl_model_property_get(efl_super(obj, EFL_SELECT_MODEL_CLASS), "selected");
success = eina_value_bool_get(prev, &prevflag);
success &= eina_value_bool_convert(value, &newflag);
exclusive = pd->parent->exclusive;
// First store the new value in the boolean model we inherit from
- chain = efl_model_property_set(efl_super(obj, EFL_MODEL_COMPOSITE_SELECTION_CLASS),
+ chain = efl_model_property_set(efl_super(obj, EFL_SELECT_MODEL_CLASS),
"selected", value);
// Now act !
{
unsigned int i;
- i = efl_model_composite_index_get(obj);
+ i = efl_composite_model_index_get(obj);
if (pd->parent->last == i && !newflag)
pd->parent->none = EINA_TRUE;
}
return efl_future_then(obj, chain, .success = _commit_change);
}
- return efl_model_property_set(efl_super(obj, EFL_MODEL_COMPOSITE_SELECTION_CLASS),
+ return efl_model_property_set(efl_super(obj, EFL_SELECT_MODEL_CLASS),
property, value);
}
static Eina_Value *
-_efl_model_composite_selection_efl_model_property_get(const Eo *obj, Efl_Model_Composite_Selection_Data *pd, const char *property)
+_efl_select_model_efl_model_property_get(const Eo *obj, Efl_Select_Model_Data *pd, const char *property)
{
if (!strcmp("exclusive", property))
return eina_value_bool_new(pd->exclusive);
// Redirect to are we ourself selected
if (pd->parent && !strcmp("self.selected", property))
{
- return efl_model_property_get(efl_super(obj, EFL_MODEL_COMPOSITE_SELECTION_CLASS), "selected");
+ return efl_model_property_get(efl_super(obj, EFL_SELECT_MODEL_CLASS), "selected");
}
- return efl_model_property_get(efl_super(obj, EFL_MODEL_COMPOSITE_SELECTION_CLASS), property);
+ return efl_model_property_get(efl_super(obj, EFL_SELECT_MODEL_CLASS), property);
}
-#include "efl_model_composite_selection.eo.c"
+#include "efl_select_model.eo.c"
-class Efl.Model_Composite_Selection extends Efl.Model_Composite_Boolean
+class Efl.Select_Model extends Efl.Boolean_Model
{
- [[Efl model composite selection class]]
+ [[Efl select model class]]
implements {
Efl.Object.constructor;
Efl.Model.property { get; set; }
#include "ecore_internal.h"
-#include "efl_model_composite_private.h"
+#include "efl_composite_model_private.h"
-typedef struct _Efl_Model_View_Data Efl_Model_View_Data;
-typedef struct _Efl_Model_View_Bind Efl_Model_View_Bind;
-typedef struct _Efl_Model_View_Logic Efl_Model_View_Logic;
-typedef struct _Efl_Model_View_Property_Ref Efl_Model_View_Property_Ref;
+typedef struct _Efl_View_Model_Data Efl_View_Model_Data;
+typedef struct _Efl_View_Model_Bind Efl_View_Model_Bind;
+typedef struct _Efl_View_Model_Logic Efl_View_Model_Logic;
+typedef struct _Efl_View_Model_Property_Ref Efl_View_Model_Property_Ref;
-struct _Efl_Model_View_Data
+struct _Efl_View_Model_Data
{
// FIXME: If parent is set, always access parent... recursively?
- Efl_Model_View_Data *parent;
+ Efl_View_Model_Data *parent;
- Eina_Hash *bound; // Stringhash of Efl_Model_View_Bind
- Eina_Hash *logics; // Stringhash of Efl_Model_View_Logic
+ Eina_Hash *bound; // Stringhash of Efl_View_Model_Bind
+ Eina_Hash *logics; // Stringhash of Efl_View_Model_Logic
- Eina_Hash *deduplication; // Stringhash of Efl_Model_View_Property_Ref
+ Eina_Hash *deduplication; // Stringhash of Efl_View_Model_Property_Ref
struct {
Eina_Bool property_changed : 1;
Eina_Bool children_bind : 1; // Define if child object should be automatically binded
};
-struct _Efl_Model_View_Bind
+struct _Efl_View_Model_Bind
{
Eina_Stringshare *source;
Eina_List *destinations;
};
-struct _Efl_Model_View_Logic
+struct _Efl_View_Model_Logic
{
struct {
- EflModelViewPropertyGet fct;
+ EflViewModelPropertyGet fct;
Eina_Free_Cb free_cb;
void *data;
} get;
struct {
- EflModelViewPropertySet fct;
+ EflViewModelPropertySet fct;
Eina_Free_Cb free_cb;
void *data;
} set;
Eina_Stringshare *property;
};
-struct _Efl_Model_View_Property_Ref
+struct _Efl_View_Model_Property_Ref
{
EINA_REFCOUNT;
Eina_Stringshare *property;
static void
_ref_free(void *data)
{
- Efl_Model_View_Property_Ref *r = data;
+ Efl_View_Model_Property_Ref *r = data;
eina_stringshare_del(r->property);
free(r);
}
static void
-_ref_add(Efl_Model_View_Data *pd, Eina_Stringshare *property)
+_ref_add(Efl_View_Model_Data *pd, Eina_Stringshare *property)
{
- Efl_Model_View_Property_Ref *r;
+ Efl_View_Model_Property_Ref *r;
r = eina_hash_find(pd->deduplication, property);
if (!r)
{
- r = calloc(1, sizeof (Efl_Model_View_Property_Ref));
+ r = calloc(1, sizeof (Efl_View_Model_Property_Ref));
if (!r) return ;
r->property = eina_stringshare_ref(property);
}
static void
-_ref_del(Efl_Model_View_Data *pd, Eina_Stringshare *property)
+_ref_del(Efl_View_Model_Data *pd, Eina_Stringshare *property)
{
- Efl_Model_View_Property_Ref *r;
+ Efl_View_Model_Property_Ref *r;
r = eina_hash_find(pd->deduplication, property);
if (!r) return ;
static void
_logic_free(void *data)
{
- Efl_Model_View_Logic *logic = data;
+ Efl_View_Model_Logic *logic = data;
Eina_Stringshare *source;
if (logic->get.free_cb) logic->get.free_cb(logic->get.data);
if (logic->set.free_cb) logic->set.free_cb(logic->set.data);
EINA_LIST_FREE(logic->sources, source)
{
- efl_model_view_property_unbind(logic->object, source, logic->property);
+ efl_view_model_property_unbind(logic->object, source, logic->property);
eina_stringshare_del(source);
}
eina_stringshare_del(logic->property);
}
static Eina_Value *
-_efl_model_view_property_dummy_get(void *data EINA_UNUSED,
- const Efl_Model_View *model_view EINA_UNUSED,
+_efl_view_model_property_dummy_get(void *data EINA_UNUSED,
+ const Efl_View_Model *view_model EINA_UNUSED,
Eina_Stringshare *property EINA_UNUSED)
{
return eina_value_error_new(EFL_MODEL_ERROR_NOT_SUPPORTED);
}
static Eina_Future *
-_efl_model_view_property_dummy_set(void *data EINA_UNUSED,
- Efl_Model_View *model_view,
+_efl_view_model_property_dummy_set(void *data EINA_UNUSED,
+ Efl_View_Model *view_model,
Eina_Stringshare *property EINA_UNUSED,
Eina_Value *value EINA_UNUSED)
{
- return efl_loop_future_rejected(model_view, EFL_MODEL_ERROR_READ_ONLY);
+ return efl_loop_future_rejected(view_model, EFL_MODEL_ERROR_READ_ONLY);
}
static Eina_Error
-_efl_model_view_property_logic_add(Eo *obj, Efl_Model_View_Data *pd,
+_efl_view_model_property_logic_add(Eo *obj, Efl_View_Model_Data *pd,
const char *property,
- void *get_data, EflModelViewPropertyGet get, Eina_Free_Cb get_free_cb,
- void *set_data, EflModelViewPropertySet set, Eina_Free_Cb set_free_cb,
+ void *get_data, EflViewModelPropertyGet get, Eina_Free_Cb get_free_cb,
+ void *set_data, EflViewModelPropertySet set, Eina_Free_Cb set_free_cb,
Eina_Iterator *bound)
{
- Efl_Model_View_Logic *logic;
+ Efl_View_Model_Logic *logic;
Eina_Stringshare *prop;
const char *source;
return EFL_MODEL_ERROR_INCORRECT_VALUE;
}
- logic = calloc(1, sizeof (Efl_Model_View_Logic));
+ logic = calloc(1, sizeof (Efl_View_Model_Logic));
if (!logic) return ENOMEM;
logic->object = obj;
logic->property = prop;
- logic->get.fct = get ? get : _efl_model_view_property_dummy_get;
+ logic->get.fct = get ? get : _efl_view_model_property_dummy_get;
logic->get.free_cb = get_free_cb;
logic->get.data = get_data;
- logic->set.fct = set ? set : _efl_model_view_property_dummy_set;
+ logic->set.fct = set ? set : _efl_view_model_property_dummy_set;
logic->set.free_cb = set_free_cb;
logic->set.data = set_data;
EINA_ITERATOR_FOREACH(bound, source)
{
logic->sources = eina_list_append(logic->sources, eina_stringshare_add(source));
- efl_model_view_property_bind(obj, source, property);
+ efl_view_model_property_bind(obj, source, property);
}
return 0;
}
static Eina_Error
-_efl_model_view_property_logic_del(Eo *obj EINA_UNUSED, Efl_Model_View_Data *pd,
+_efl_view_model_property_logic_del(Eo *obj EINA_UNUSED, Efl_View_Model_Data *pd,
const char *property)
{
- Efl_Model_View_Logic *logic;
+ Efl_View_Model_Logic *logic;
logic = eina_hash_find(pd->logics, property);
if (!logic) return EFL_MODEL_ERROR_INCORRECT_VALUE;
}
static void
-_efl_model_view_property_bind(Eo *obj EINA_UNUSED, Efl_Model_View_Data *pd,
+_efl_view_model_property_bind(Eo *obj EINA_UNUSED, Efl_View_Model_Data *pd,
const char *source, const char *destination)
{
- Efl_Model_View_Bind *bind;
+ Efl_View_Model_Bind *bind;
Eina_Stringshare *src;
Eina_Stringshare *dst;
bind = eina_hash_find(pd->bound, src);
if (!bind)
{
- bind = calloc(1, sizeof (Efl_Model_View_Bind));
+ bind = calloc(1, sizeof (Efl_View_Model_Bind));
if (!bind) goto on_error;
bind->source = eina_stringshare_ref(src);
}
static void
-_efl_model_view_property_unbind(Eo *obj EINA_UNUSED, Efl_Model_View_Data *pd,
+_efl_view_model_property_unbind(Eo *obj EINA_UNUSED, Efl_View_Model_Data *pd,
const char *source, const char *destination)
{
- Efl_Model_View_Bind *bind;
+ Efl_View_Model_Bind *bind;
Eina_Stringshare *src;
Eina_Stringshare *dst;
Eina_Stringshare *cmp;
static void
_bind_free(void *data)
{
- Efl_Model_View_Bind *bind = data;
+ Efl_View_Model_Bind *bind = data;
Eina_Stringshare *dst;
eina_stringshare_del(bind->source);
free(bind);
}
-static Efl_Model_View_Bind *
-_efl_model_view_property_bind_lookup(Efl_Model_View_Data *pd, Eina_Stringshare *src)
+static Efl_View_Model_Bind *
+_efl_view_model_property_bind_lookup(Efl_View_Model_Data *pd, Eina_Stringshare *src)
{
- Efl_Model_View_Bind *bind;
+ Efl_View_Model_Bind *bind;
bind = eina_hash_find(pd->bound, src);
- if (!bind && pd->parent) return _efl_model_view_property_bind_lookup(pd->parent, src);
+ if (!bind && pd->parent) return _efl_view_model_property_bind_lookup(pd->parent, src);
return bind;
}
static void
-_efl_model_view_property_changed(void *data, const Efl_Event *event)
+_efl_view_model_property_changed(void *data, const Efl_Event *event)
{
- Efl_Model_View_Data *pd = data;
+ Efl_View_Model_Data *pd = data;
Efl_Model_Property_Event *ev = event->info;
Efl_Model_Property_Event nev = { 0 };
const char *property;
EINA_ARRAY_ITER_NEXT(ev->changed_properties, i, property, iterator)
{
- Efl_Model_View_Bind *bind;
+ Efl_View_Model_Bind *bind;
eina_array_push(nev.changed_properties, property);
src = eina_stringshare_add(property);
- bind = _efl_model_view_property_bind_lookup(pd, src);
+ bind = _efl_view_model_property_bind_lookup(pd, src);
if (bind)
{
Eina_Stringshare *dest;
}
static void
-_efl_model_view_children_bind_set(Eo *obj EINA_UNUSED, Efl_Model_View_Data *pd, Eina_Bool enable)
+_efl_view_model_children_bind_set(Eo *obj EINA_UNUSED, Efl_View_Model_Data *pd, Eina_Bool enable)
{
if (pd->finalized) return;
}
static Eina_Bool
-_efl_model_view_children_bind_get(const Eo *obj EINA_UNUSED, Efl_Model_View_Data *pd)
+_efl_view_model_children_bind_get(const Eo *obj EINA_UNUSED, Efl_View_Model_Data *pd)
{
return pd->children_bind;
}
static void
-_efl_model_view_parent_data(Efl_Model_View *child, Efl_Model_View_Data *ppd)
+_efl_view_model_parent_data(Efl_View_Model *child, Efl_View_Model_Data *ppd)
{
- Efl_Model_View_Data *cpd;
+ Efl_View_Model_Data *cpd;
- cpd = efl_data_scope_get(child, EFL_MODEL_VIEW_CLASS);
+ cpd = efl_data_scope_get(child, EFL_VIEW_MODEL_CLASS);
cpd->parent = ppd;
cpd->propagating = ppd->propagating;
}
-static Efl_Model_View *
-_efl_model_view_child_lookup(Efl_Model_View_Data *pd, Efl_Object *parent, Efl_Model *view)
+static Efl_View_Model *
+_efl_view_model_child_lookup(Efl_View_Model_Data *pd, Efl_Object *parent, Efl_Model *view)
{
- Efl_Model_View *co;
+ Efl_View_Model *co;
- co = efl_key_wref_get(view, "_efl.model_view");
+ co = efl_key_wref_get(view, "_efl.view_model");
if (co) return co;
- co = efl_add(EFL_MODEL_VIEW_CLASS, parent,
+ co = efl_add(EFL_VIEW_MODEL_CLASS, parent,
efl_ui_view_model_set(efl_added, view),
- _efl_model_view_parent_data(efl_added, pd));
+ _efl_view_model_parent_data(efl_added, pd));
if (!co) return NULL;
- efl_key_wref_set(view, "_efl.model_view", co);
+ efl_key_wref_set(view, "_efl.view_model", co);
return co;
}
static void
-_efl_model_view_child_added(void *data, const Efl_Event *event)
+_efl_view_model_child_added(void *data, const Efl_Event *event)
{
Efl_Model_Children_Event *ev = event->info;
Efl_Model_Children_Event nevt = { 0 };
- Efl_Model_View_Data *pd = data;
- Efl_Model_View *co;
+ Efl_View_Model_Data *pd = data;
+ Efl_View_Model *co;
if (pd->propagating.child_added) return ;
if (!pd->children_bind) return;
// Our strategy is to rebuild a new Child_Add and cancel the current one.
efl_event_callback_stop(event->object);
- co = _efl_model_view_child_lookup(pd, event->object, ev->child);
+ co = _efl_view_model_child_lookup(pd, event->object, ev->child);
if (!co) return;
nevt.index = ev->index;
}
static void
-_efl_model_view_child_removed(void *data, const Efl_Event *event)
+_efl_view_model_child_removed(void *data, const Efl_Event *event)
{
Efl_Model_Children_Event *ev = event->info;
Efl_Model_Children_Event nevt = { 0 };
- Efl_Model_View_Data *pd = data;
- Efl_Model_View *co;
+ Efl_View_Model_Data *pd = data;
+ Efl_View_Model *co;
if (pd->propagating.child_removed) return ;
if (!pd->children_bind) return;
// Our strategy is to rebuild a new Child_Add and cancel the current one.
efl_event_callback_stop(event->object);
- co = _efl_model_view_child_lookup(pd, event->object, ev->child);
+ co = _efl_view_model_child_lookup(pd, event->object, ev->child);
if (!co) return;
nevt.index = ev->index;
efl_event_callback_call(event->object, EFL_MODEL_EVENT_CHILD_REMOVED, &nevt);
- // The object is being destroyed, there is no point in us keeping the ModelView proxy alive.
+ // The object is being destroyed, there is no point in us keeping the ViewModel proxy alive.
efl_del(co);
pd->propagating.child_removed = EINA_FALSE;
}
-EFL_CALLBACKS_ARRAY_DEFINE(efl_model_view_intercept,
- { EFL_MODEL_EVENT_PROPERTIES_CHANGED, _efl_model_view_property_changed },
- { EFL_MODEL_EVENT_CHILD_ADDED, _efl_model_view_child_added },
- { EFL_MODEL_EVENT_CHILD_REMOVED, _efl_model_view_child_removed })
+EFL_CALLBACKS_ARRAY_DEFINE(efl_view_model_intercept,
+ { EFL_MODEL_EVENT_PROPERTIES_CHANGED, _efl_view_model_property_changed },
+ { EFL_MODEL_EVENT_CHILD_ADDED, _efl_view_model_child_added },
+ { EFL_MODEL_EVENT_CHILD_REMOVED, _efl_view_model_child_removed })
static Efl_Object *
-_efl_model_view_efl_object_constructor(Eo *obj, Efl_Model_View_Data *pd)
+_efl_view_model_efl_object_constructor(Eo *obj, Efl_View_Model_Data *pd)
{
- obj = efl_constructor(efl_super(obj, EFL_MODEL_VIEW_CLASS));
+ obj = efl_constructor(efl_super(obj, EFL_VIEW_MODEL_CLASS));
pd->children_bind = EINA_TRUE;
pd->bound = eina_hash_stringshared_new(_bind_free);
pd->logics = eina_hash_stringshared_new(_logic_free);
pd->deduplication = eina_hash_stringshared_new(_ref_free);
- efl_event_callback_array_priority_add(obj, efl_model_view_intercept(), EFL_CALLBACK_PRIORITY_BEFORE, pd);
+ efl_event_callback_array_priority_add(obj, efl_view_model_intercept(), EFL_CALLBACK_PRIORITY_BEFORE, pd);
return obj;
}
static Efl_Object *
-_efl_model_view_efl_object_finalize(Eo *obj, Efl_Model_View_Data *pd)
+_efl_view_model_efl_object_finalize(Eo *obj, Efl_View_Model_Data *pd)
{
pd->finalized = EINA_TRUE;
- return efl_finalize(efl_super(obj, EFL_MODEL_VIEW_CLASS));
+ return efl_finalize(efl_super(obj, EFL_VIEW_MODEL_CLASS));
}
static void
-_efl_model_view_efl_object_destructor(Eo *obj, Efl_Model_View_Data *pd)
+_efl_view_model_efl_object_destructor(Eo *obj, Efl_View_Model_Data *pd)
{
- efl_event_callback_array_del(obj, efl_model_view_intercept(), pd);
+ efl_event_callback_array_del(obj, efl_view_model_intercept(), pd);
eina_hash_free(pd->bound);
pd->bound = NULL;
eina_hash_free(pd->logics);
pd->logics = NULL;
- efl_destructor(efl_super(obj, EFL_MODEL_VIEW_CLASS));
+ efl_destructor(efl_super(obj, EFL_VIEW_MODEL_CLASS));
}
-static Efl_Model_View_Logic *
-_efl_model_view_property_logic_lookup(Efl_Model_View_Data *pd, Eina_Stringshare *property)
+static Efl_View_Model_Logic *
+_efl_view_model_property_logic_lookup(Efl_View_Model_Data *pd, Eina_Stringshare *property)
{
- Efl_Model_View_Logic *logic;
+ Efl_View_Model_Logic *logic;
if (!pd) return NULL;
logic = eina_hash_find(pd->logics, property);
- if (!logic) return _efl_model_view_property_logic_lookup(pd->parent, property);
+ if (!logic) return _efl_view_model_property_logic_lookup(pd->parent, property);
return logic;
}
static Eina_Future *
-_efl_model_view_efl_model_property_set(Eo *obj, Efl_Model_View_Data *pd,
+_efl_view_model_efl_model_property_set(Eo *obj, Efl_View_Model_Data *pd,
const char *property, Eina_Value *value)
{
- Efl_Model_View_Logic *logic;
+ Efl_View_Model_Logic *logic;
Eina_Stringshare *prop;
Eina_Future *f;
prop = eina_stringshare_add(property);
- logic = _efl_model_view_property_logic_lookup(pd, prop);
+ logic = _efl_view_model_property_logic_lookup(pd, prop);
if (logic)
f = logic->set.fct(logic->get.data, obj, prop, value);
else
- f = efl_model_property_set(efl_super(obj, EFL_MODEL_VIEW_CLASS), property, value);
+ f = efl_model_property_set(efl_super(obj, EFL_VIEW_MODEL_CLASS), property, value);
eina_stringshare_del(prop);
return f;
}
static Eina_Value *
-_efl_model_view_efl_model_property_get(const Eo *obj, Efl_Model_View_Data *pd,
+_efl_view_model_efl_model_property_get(const Eo *obj, Efl_View_Model_Data *pd,
const char *property)
{
- Efl_Model_View_Logic *logic;
+ Efl_View_Model_Logic *logic;
Eina_Stringshare *prop;
Eina_Value *r;
prop = eina_stringshare_add(property);
- logic = _efl_model_view_property_logic_lookup(pd, prop);
+ logic = _efl_view_model_property_logic_lookup(pd, prop);
if (logic)
r = logic->get.fct(logic->get.data, obj, prop);
else
- r = efl_model_property_get(efl_super(obj, EFL_MODEL_VIEW_CLASS), property);
+ r = efl_model_property_get(efl_super(obj, EFL_VIEW_MODEL_CLASS), property);
eina_stringshare_del(prop);
return r;
}
static Eina_Iterator *
-_efl_model_view_efl_model_properties_get(const Eo *obj, Efl_Model_View_Data *pd)
+_efl_view_model_efl_model_properties_get(const Eo *obj, Efl_View_Model_Data *pd)
{
- EFL_MODEL_COMPOSITE_PROPERTIES_SUPER(props, obj, EFL_MODEL_VIEW_CLASS,
+ EFL_COMPOSITE_MODEL_PROPERTIES_SUPER(props, obj, EFL_VIEW_MODEL_CLASS,
eina_hash_iterator_key_new(pd->deduplication));
return props;
}
-typedef struct _Efl_Model_View_Slice_Request Efl_Model_View_Slice_Request;
-struct _Efl_Model_View_Slice_Request
+typedef struct _Efl_View_Model_Slice_Request Efl_View_Model_Slice_Request;
+struct _Efl_View_Model_Slice_Request
{
- Efl_Model_View_Data *pd;
+ Efl_View_Model_Data *pd;
unsigned int start;
};
static Eina_Value
-_efl_model_view_slice_then(Eo *o, void *data, const Eina_Value v)
+_efl_view_model_slice_then(Eo *o, void *data, const Eina_Value v)
{
- Efl_Model_View_Slice_Request *req = data;
+ Efl_View_Model_Slice_Request *req = data;
Eo *target;
Eina_Value r = EINA_VALUE_EMPTY;
unsigned int i, len;
{
Eo *composite;
- composite = _efl_model_view_child_lookup(req->pd, o, target);
+ composite = _efl_view_model_child_lookup(req->pd, o, target);
eina_value_array_append(&r, composite);
}
}
static void
-_efl_model_view_slice_clean(Eo *o EINA_UNUSED, void *data, const Eina_Future *dead_future EINA_UNUSED)
+_efl_view_model_slice_clean(Eo *o EINA_UNUSED, void *data, const Eina_Future *dead_future EINA_UNUSED)
{
free(data);
}
static Eina_Future *
-_efl_model_view_efl_model_children_slice_get(Eo *obj, Efl_Model_View_Data *pd,
+_efl_view_model_efl_model_children_slice_get(Eo *obj, Efl_View_Model_Data *pd,
unsigned int start, unsigned int count)
{
- Efl_Model_View_Slice_Request *req;
+ Efl_View_Model_Slice_Request *req;
Eina_Future *f;
- f = efl_model_children_slice_get(efl_super(obj, EFL_MODEL_VIEW_CLASS), start, count);
+ f = efl_model_children_slice_get(efl_super(obj, EFL_VIEW_MODEL_CLASS), start, count);
- req = malloc(sizeof (Efl_Model_View_Slice_Request));
+ req = malloc(sizeof (Efl_View_Model_Slice_Request));
if (!req)
{
eina_future_cancel(f);
req->start = start;
return efl_future_then(obj, f, .success_type = EINA_VALUE_TYPE_ARRAY,
- .success = _efl_model_view_slice_then,
- .free = _efl_model_view_slice_clean,
+ .success = _efl_view_model_slice_then,
+ .free = _efl_view_model_slice_clean,
.data = req);
}
-#include "efl_model_view.eo.c"
+#include "efl_view_model.eo.c"
-function EflModelViewPropertyGet {
+function EflViewModelPropertyGet {
[[Function called when a property is get.]]
params {
- @in model_view: const(Efl.Model_View); [[The ModelView object the @.property.get is issued on.]]
+ @in view_model: const(Efl.View_Model); [[The ViewModel object the @.property.get is issued on.]]
@in property: stringshare; [[The property name the @.property.get is issued on.]]
}
return: any_value_ptr; [[The property value.]]
};
-function EflModelViewPropertySet {
+function EflViewModelPropertySet {
[[Function called when a property is set.]]
params {
- @in model_view: Efl.Model_View; [[The ModelView object the @.property.set is issued on.]]
+ @in view_model: Efl.View_Model; [[The ViewModel object the @.property.set is issued on.]]
@in property: stringshare; [[The property name the @.property.set is issued on.]]
@in value: any_value_ptr @owned; [[The new value to set.]]
}
return: future<any_value_ptr>; [[The value that was finally set.]]
};
-class Efl.Model_View extends Efl.Model_Composite
+class Efl.View_Model extends Efl.Composite_Model
{
[[Efl model providing helpers for custom properties used when linking a model to a view and you need to generate/adapt values for display.
]]
params {
property: string; [[The property to bind on to.]]
- get: EflModelViewPropertyGet; [[Define the get callback called when the @Efl.Model.property.get is called with the above property name.]]
- set: EflModelViewPropertySet; [[Define the set callback called when the @Efl.Model.property.set is called with the above property name.]]
+ get: EflViewModelPropertyGet; [[Define the get callback called when the @Efl.Model.property.get is called with the above property name.]]
+ set: EflViewModelPropertySet; [[Define the set callback called when the @Efl.Model.property.set is called with the above property name.]]
binded: iterator<string>; [[Iterator of property name to bind with this defined property see @.property_bind.]]
}
return: Eina.Error;
]]
params {
@in source: string; [[Property name in the composited model.]]
- @in destination: string; [[Property name in the @Efl.Model_View]]
+ @in destination: string; [[Property name in the @Efl.View_Model]]
}
}
property_unbind {
]]
params {
@in source: string; [[Property name in the composited model.]]
- @in destination: string; [[Property name in the @Efl.Model_View]]
+ @in destination: string; [[Property name in the @Efl.View_Model]]
}
}
@property children_bind {
[[Define if we will intercept all childrens object reference and
- bind them through the ModelView with the same property logic as this
+ bind them through the ViewModel with the same property logic as this
one. Be careful of recursivity.
This can only be applied at construction time.]]
Efl.Model.property { set; get; }
}
constructors {
- Efl.Model_View.children_bind;
+ Efl.View_Model.children_bind;
}
}
'efl_cubic_bezier_interpolator.eo',
'efl_loop_message_future_handler.eo',
'efl_loop_message_future.eo',
- 'efl_model_loop.eo',
- 'efl_model_item.eo',
- 'efl_model_container.eo',
- 'efl_model_container_item.eo',
- 'efl_model_composite_boolean.eo',
- 'efl_model_composite_selection.eo',
- 'efl_model_composite.eo',
- 'efl_model_view.eo'
+ 'efl_loop_model.eo',
+ 'efl_generic_model.eo',
+ 'efl_container_model.eo',
+ 'efl_container_model_item.eo',
+ 'efl_boolean_model.eo',
+ 'efl_select_model.eo',
+ 'efl_composite_model.eo',
+ 'efl_view_model.eo'
]
foreach eo_file : pub_eo_files
'efl_io_file.c',
'efl_io_copier.c',
'efl_io_buffered_stream.c',
- 'efl_model_loop.c',
- 'efl_model_item.c',
- 'efl_model_container.c',
- 'efl_model_container_item.c',
- 'efl_model_container_private.h',
- 'efl_model_composite.c',
- 'efl_model_composite_boolean.c',
- 'efl_model_composite_selection.c',
- 'efl_model_composite_private.h',
+ 'efl_loop_model.c',
+ 'efl_generic_model.c',
+ 'efl_container_model.c',
+ 'efl_container_model_item.c',
+ 'efl_container_model_private.h',
+ 'efl_composite_model.c',
+ 'efl_boolean_model.c',
+ 'efl_select_model.c',
+ 'efl_composite_model_private.h',
'efl_model_accessor_view.c',
'efl_model_accessor_view_private.h',
- 'efl_model_view.c',
+ 'efl_view_model.c',
'efl_linear_interpolator.c',
'efl_accelerate_interpolator.c',
'efl_decelerate_interpolator.c',
#include "efl_io_manager.eo.h"
#include "eio_sentry.eo.h"
-#include "eio_model.eo.h"
+#include "efl_io_model.eo.h"
#ifdef __cplusplus
}
#include "Eio.h"
#include "eio_private.h"
-#include "eio_model_private.h"
+#include "efl_io_model_private.h"
-#define MY_CLASS EIO_MODEL_CLASS
-#define MY_CLASS_NAME "Eio_Model"
+#define MY_CLASS EFL_IO_MODEL_CLASS
+#define MY_CLASS_NAME "Efl_Io_Model"
-static void _eio_model_info_free(Eio_Model_Info *info, Eina_Bool model);
-static void _eio_model_efl_model_monitor_add(Eio_Model_Data *priv);
+static void _efl_io_model_info_free(Efl_Io_Model_Info *info, Eina_Bool model);
+static void _efl_io_model_efl_model_monitor_add(Efl_Io_Model_Data *priv);
EINA_VALUE_STRUCT_DESC_DEFINE(_eina_file_direct_info_desc,
NULL,
- sizeof (Eio_Model_Info),
- EINA_VALUE_STRUCT_MEMBER(EINA_VALUE_TYPE_ULONG, Eio_Model_Info, path_length),
- EINA_VALUE_STRUCT_MEMBER(EINA_VALUE_TYPE_ULONG, Eio_Model_Info, name_length),
- EINA_VALUE_STRUCT_MEMBER(EINA_VALUE_TYPE_ULONG, Eio_Model_Info, name_start),
- EINA_VALUE_STRUCT_MEMBER(EINA_VALUE_TYPE_UINT, Eio_Model_Info, type),
- EINA_VALUE_STRUCT_MEMBER(EINA_VALUE_TYPE_STRINGSHARE, Eio_Model_Info, path));
+ sizeof (Efl_Io_Model_Info),
+ EINA_VALUE_STRUCT_MEMBER(EINA_VALUE_TYPE_ULONG, Efl_Io_Model_Info, path_length),
+ EINA_VALUE_STRUCT_MEMBER(EINA_VALUE_TYPE_ULONG, Efl_Io_Model_Info, name_length),
+ EINA_VALUE_STRUCT_MEMBER(EINA_VALUE_TYPE_ULONG, Efl_Io_Model_Info, name_start),
+ EINA_VALUE_STRUCT_MEMBER(EINA_VALUE_TYPE_UINT, Efl_Io_Model_Info, type),
+ EINA_VALUE_STRUCT_MEMBER(EINA_VALUE_TYPE_STRINGSHARE, Efl_Io_Model_Info, path));
/**
* Callbacks
* Property
static void
_eio_move_done_cb(void *data, Eio_File *handler)
{
- Eio_Model_Data *pd = ecore_thread_local_data_find(handler->thread, ".pd");
+ Efl_Io_Model_Data *pd = ecore_thread_local_data_find(handler->thread, ".pd");
Eina_Promise *p = data;
// FIXME: generate events
static void
_eio_file_error_cb(void *data, Eio_File *handler, int error)
{
- Eio_Model_Data *pd = ecore_thread_local_data_find(handler->thread, ".pd");
+ Efl_Io_Model_Data *pd = ecore_thread_local_data_find(handler->thread, ".pd");
Eina_Promise *p = data;
eina_promise_reject(p, error);
_efl_model_evt_added_ecore_cb(void *data, int type, void *event)
{
Eio_Monitor_Event *ev = event;
- Eio_Model *obj;
- Eio_Model_Data *pd = data;
+ Efl_Io_Model *obj;
+ Efl_Io_Model_Data *pd = data;
Efl_Model_Children_Event cevt;
- Eio_Model_Info *mi;
+ Efl_Io_Model_Info *mi;
Eina_List *l;
Eina_Stringshare *spath = NULL;
char *path = NULL;
goto end;
}
- mi = calloc(1, sizeof (Eio_Model_Info));
+ mi = calloc(1, sizeof (Efl_Io_Model_Info));
if (!mi) goto end;
mi->path_length = eina_stringshare_strlen(spath);
static Eina_Bool
_efl_model_evt_deleted_ecore_cb(void *data, int type, void *event)
{
- Eio_Model_Info *mi;
+ Efl_Io_Model_Info *mi;
Eina_List *l;
Eio_Monitor_Event *ev = event;
- Eio_Model *obj;
- Eio_Model_Data *pd = data;
+ Efl_Io_Model *obj;
+ Efl_Io_Model_Data *pd = data;
Eina_Stringshare *spath = NULL;
Efl_Model_Children_Event cevt = { 0 };
unsigned int i = 0;
// This should trigger the object child destruction if it exist
// resulting in the potential destruction of the child, after
// this point mi and info might be freed.
- _eio_model_info_free(mi, EINA_FALSE);
+ _efl_io_model_info_free(mi, EINA_FALSE);
end:
eina_stringshare_del(spath);
* Child Del
*/
static void
-_eio_del_cleanup(Eio_Model *obj)
+_eio_del_cleanup(Efl_Io_Model *obj)
{
- Eio_Model_Data *pd = efl_data_scope_get(obj, EIO_MODEL_CLASS);
+ Efl_Io_Model_Data *pd = efl_data_scope_get(obj, EFL_IO_MODEL_CLASS);
pd->request.del = NULL;
efl_unref(obj);
static void
_eio_done_unlink_cb(void *data, Eio_File *handler EINA_UNUSED)
{
- Eio_Model *child = data;
+ Efl_Io_Model *child = data;
_eio_del_cleanup(child);
}
static void
_eio_error_unlink_cb(void *data, Eio_File *handler EINA_UNUSED, int error)
{
- Eio_Model *child = data;
+ Efl_Io_Model *child = data;
ERR("%d: %s.", error, strerror(error));
}
static void
-_eio_model_info_free(Eio_Model_Info *info, Eina_Bool model)
+_efl_io_model_info_free(Efl_Io_Model_Info *info, Eina_Bool model)
{
if (!info) return ;
}
static Eina_File_Type
-_eio_model_info_type_get(const Eina_File_Direct_Info *info, const Eina_Stat *st)
+_efl_io_model_info_type_get(const Eina_File_Direct_Info *info, const Eina_Stat *st)
{
if (info && info->type != EINA_FILE_UNKNOWN)
return info->type;
}
static void
-_eio_model_info_build(const Eio_Model *model, Eio_Model_Data *pd)
+_efl_io_model_info_build(const Efl_Io_Model *model, Efl_Io_Model_Data *pd)
{
char *path;
if (pd->info) goto end;
- pd->info = calloc(1, sizeof (Eio_Model_Info));
+ pd->info = calloc(1, sizeof (Efl_Io_Model_Info));
if (!pd->info) return ;
pd->info->path_length = eina_stringshare_strlen(pd->path);
pd->info->name_length = pd->info->path_length - pd->info->name_start;
free(path);
- pd->info->type = _eio_model_info_type_get(NULL, pd->st);
+ pd->info->type = _efl_io_model_info_type_get(NULL, pd->st);
efl_model_properties_changed(model, "direct_info");
static void
_eio_build_st_done(void *data, Eio_File *handler EINA_UNUSED, const Eina_Stat *stat)
{
- Eio_Model *model = data;
- Eio_Model_Data *pd = efl_data_scope_get(model, EIO_MODEL_CLASS);
+ Efl_Io_Model *model = data;
+ Efl_Io_Model_Data *pd = efl_data_scope_get(model, EFL_IO_MODEL_CLASS);
if (!pd) return ;
pd->request.stat = NULL;
memcpy(pd->st, stat, sizeof (Eina_Stat));
- if (!pd->info) _eio_model_info_build(model, pd);
+ if (!pd->info) _efl_io_model_info_build(model, pd);
if (pd->info->type == EINA_FILE_UNKNOWN)
- pd->info->type = _eio_model_info_type_get(NULL, stat);
+ pd->info->type = _efl_io_model_info_type_get(NULL, stat);
efl_model_properties_changed(model, "mtime", "atime", "ctime", "is_dir", "is_lnk", "size", "stat");
if (eio_file_is_dir(pd->st))
{
// Now that we know we are a directory, we should whatch it
- _eio_model_efl_model_monitor_add(pd);
+ _efl_io_model_efl_model_monitor_add(pd);
// And start listing its child
efl_model_children_count_get(model);
static void
_eio_build_st_done_clobber(void *data, Eio_File *handler, const Eina_Stat *stat)
{
- Eio_Model *model = data;
- Eio_Model *parent;
+ Efl_Io_Model *model = data;
+ Efl_Io_Model *parent;
efl_ref(model);
_eio_build_st_done(data, handler, stat);
static void
_eio_build_st_error(void *data, Eio_File *handler EINA_UNUSED, int error)
{
- Eio_Model *model = data;
- Eio_Model_Data *pd = efl_data_scope_get(model, EIO_MODEL_CLASS);
+ Efl_Io_Model *model = data;
+ Efl_Io_Model_Data *pd = efl_data_scope_get(model, EFL_IO_MODEL_CLASS);
pd->request.stat = NULL;
pd->error = error;
static void
_eio_build_st_error_clobber(void *data, Eio_File *handler, int error)
{
- Eio_Model *model = data;
- Eio_Model *parent;
+ Efl_Io_Model *model = data;
+ Efl_Io_Model *parent;
efl_ref(model);
_eio_build_st_error(data, handler, error);
}
static void
-_eio_build_st(const Eio_Model *model, Eio_Model_Data *pd)
+_eio_build_st(const Efl_Io_Model *model, Efl_Io_Model_Data *pd)
{
if (pd->st) return ;
if (pd->request.stat) return ;
}
static void
-_eio_build_st_then_clobber(const Eio_Model *model, Eio_Model_Data *pd)
+_eio_build_st_then_clobber(const Efl_Io_Model *model, Efl_Io_Model_Data *pd)
{
if (pd->st) return ;
if (pd->request.stat) return ;
}
static Eina_Future *
-_build_delay(Eio_Model *model)
+_build_delay(Efl_Io_Model *model)
{
Eina_Promise *p;
}
static void
-_eio_build_mime_clean(Eio_Model_Data *pd)
+_eio_build_mime_clean(Efl_Io_Model_Data *pd)
{
efl_wref_del(pd->loop, &pd->loop);
pd->loop = NULL;
static Eina_Value
_eio_build_mime_now(void *data, const Eina_Value v, const Eina_Future *dead_future EINA_UNUSED)
{
- Eio_Model *model = data;
- Eio_Model_Data *pd = efl_data_scope_get(model, EIO_MODEL_CLASS);
+ Efl_Io_Model *model = data;
+ Efl_Io_Model_Data *pd = efl_data_scope_get(model, EFL_IO_MODEL_CLASS);
if (v.type == EINA_VALUE_TYPE_ERROR) goto on_error;
if (!pd->loop) goto on_error;
}
static void
-_eio_build_mime(const Efl_Object *model, Eio_Model_Data *pd)
+_eio_build_mime(const Efl_Object *model, Efl_Io_Model_Data *pd)
{
Eina_Future *f;
}
static Eina_Value *
-_property_filename_cb(const Eo *obj, Eio_Model_Data *pd)
+_property_filename_cb(const Eo *obj, Efl_Io_Model_Data *pd)
{
- _eio_model_info_build(obj, pd);
+ _efl_io_model_info_build(obj, pd);
if (pd->info)
return eina_value_string_new(pd->info->path + pd->info->name_start);
return eina_value_error_new(EAGAIN);
}
static Eina_Value *
-_property_path_cb(const Eo *obj EINA_UNUSED, Eio_Model_Data *pd)
+_property_path_cb(const Eo *obj EINA_UNUSED, Efl_Io_Model_Data *pd)
{
return eina_value_string_new(pd->path);
}
static Eina_Value *
-_property_direct_info_cb(const Eo *obj, Eio_Model_Data *pd)
+_property_direct_info_cb(const Eo *obj, Efl_Io_Model_Data *pd)
{
- _eio_model_info_build(obj, pd);
+ _efl_io_model_info_build(obj, pd);
if (pd->info)
{
#define TIMECB(Prop) \
static Eina_Value * \
- _property_##Prop##_cb(const Eo *obj, Eio_Model_Data *pd) \
+ _property_##Prop##_cb(const Eo *obj, Efl_Io_Model_Data *pd) \
{ \
if (pd->st) \
return eina_value_time_new(pd->st->Prop); \
TIMECB(ctime);
static Eina_Value *
-_property_is_dir_cb(const Eo *obj, Eio_Model_Data *pd)
+_property_is_dir_cb(const Eo *obj, Efl_Io_Model_Data *pd)
{
if (pd->st)
return eina_value_bool_new(eio_file_is_dir(pd->st));
}
static Eina_Value *
-_property_is_lnk_cb(const Eo *obj, Eio_Model_Data *pd)
+_property_is_lnk_cb(const Eo *obj, Efl_Io_Model_Data *pd)
{
if (pd->st)
return eina_value_bool_new(eio_file_is_lnk(pd->st));
}
static Eina_Value *
-_property_size_cb(const Eo *obj, Eio_Model_Data *pd)
+_property_size_cb(const Eo *obj, Efl_Io_Model_Data *pd)
{
if (pd->st)
return eina_value_ulong_new(pd->st->size);
}
static Eina_Value *
-_property_stat_cb(const Eo *obj, Eio_Model_Data *pd)
+_property_stat_cb(const Eo *obj, Efl_Io_Model_Data *pd)
{
if (pd->st)
{
}
static Eina_Value *
-_property_mime_type_cb(const Eo *obj, Eio_Model_Data *pd)
+_property_mime_type_cb(const Eo *obj, Efl_Io_Model_Data *pd)
{
if (pd->mime_type)
return eina_value_string_new(pd->mime_type);
static struct {
const char *name;
- Eina_Value *(*cb)(const Eo *obj, Eio_Model_Data *pd);
+ Eina_Value *(*cb)(const Eo *obj, Efl_Io_Model_Data *pd);
} properties[] = {
PP(filename), PP(path),
PP(direct_info),
* Interfaces impl.
*/
static Eina_Iterator *
-_eio_model_efl_model_properties_get(const Eo *obj EINA_UNUSED,
- Eio_Model_Data *pd EINA_UNUSED)
+_efl_io_model_efl_model_properties_get(const Eo *obj EINA_UNUSED,
+ Efl_Io_Model_Data *pd EINA_UNUSED)
{
return EINA_C_ARRAY_ITERATOR_NEW(properties);
}
static Eina_Value *
-_eio_model_efl_model_property_get(const Eo *obj, Eio_Model_Data *pd, const char *property)
+_efl_io_model_efl_model_property_get(const Eo *obj, Efl_Io_Model_Data *pd, const char *property)
{
unsigned int i;
ERR("Could not find property '%s'.", property);
// Unknow value request
- return efl_model_property_get(efl_super(obj, EIO_MODEL_CLASS), property);
+ return efl_model_property_get(efl_super(obj, EFL_IO_MODEL_CLASS), property);
}
static Eina_Future *
-_eio_model_efl_model_property_set(Eo *obj,
- Eio_Model_Data *pd,
- const char *property, Eina_Value *value)
+_efl_io_model_efl_model_property_set(Eo *obj,
+ Efl_Io_Model_Data *pd,
+ const char *property, Eina_Value *value)
{
const char *path;
Eina_Future *f;
}
static void
-_eio_model_children_list(void *data, Eina_Array *entries)
+_efl_io_model_children_list(void *data, Eina_Array *entries)
{
Eina_File_Direct_Info *info;
Efl_Model *obj = data;
- Eio_Model_Data *pd;
+ Efl_Io_Model_Data *pd;
Efl_Model_Children_Event cevt = { 0 };
Eina_Array_Iterator iterator;
unsigned int i;
- pd = efl_data_scope_get(obj, EIO_MODEL_CLASS);
+ pd = efl_data_scope_get(obj, EFL_IO_MODEL_CLASS);
if (!pd) return ;
EINA_ARRAY_ITER_NEXT(entries, i, info, iterator)
{
- Eio_Model_Info *mi;
+ Efl_Io_Model_Info *mi;
if (pd->filter.cb)
{
continue ;
}
- mi = calloc(1, sizeof (Eio_Model_Info));
+ mi = calloc(1, sizeof (Efl_Io_Model_Info));
if (!mi) continue ;
mi->path_length = info->path_length;
mi->name_start = info->name_start;
mi->name_length = info->name_length;
- mi->type = _eio_model_info_type_get(info, NULL);
+ mi->type = _efl_io_model_info_type_get(info, NULL);
mi->parent_ref = EINA_TRUE;
cevt.index = eina_list_count(pd->files);
}
static Eina_Value
-_eio_model_children_list_on(void *data, const Eina_Value v,
- const Eina_Future *dead EINA_UNUSED)
+_efl_io_model_children_list_on(void *data, const Eina_Value v,
+ const Eina_Future *dead EINA_UNUSED)
{
- Eio_Model_Data *pd = data;
+ Efl_Io_Model_Data *pd = data;
pd->request.listing = NULL;
pd->listed = EINA_TRUE;
// Now that we have listed the content of the directory,
// we can whatch over it
- _eio_model_efl_model_monitor_add(pd);
+ _efl_io_model_efl_model_monitor_add(pd);
return v;
}
* Children Count Get
*/
static unsigned int
-_eio_model_efl_model_children_count_get(const Eo *obj, Eio_Model_Data *pd)
+_efl_io_model_efl_model_children_count_get(const Eo *obj, Efl_Io_Model_Data *pd)
{
// If we have no information on the object, let's build it.
if (efl_invalidated_get(obj))
}
f = efl_io_manager_direct_ls(iom, pd->path, EINA_FALSE,
- (void*) obj, _eio_model_children_list, NULL);
- f = eina_future_then(f, _eio_model_children_list_on, pd, NULL);
+ (void*) obj, _efl_io_model_children_list, NULL);
+ f = eina_future_then(f, _efl_io_model_children_list_on, pd, NULL);
pd->request.listing = efl_future_then(obj, f);
}
}
static void
-_eio_model_efl_model_monitor_add(Eio_Model_Data *priv)
+_efl_io_model_efl_model_monitor_add(Efl_Io_Model_Data *priv)
{
if (!priv->monitor)
{
}
static void
-_eio_model_efl_model_monitor_del(Eio_Model_Data *priv)
+_efl_io_model_efl_model_monitor_del(Efl_Io_Model_Data *priv)
{
if (priv->monitor)
{
* Children Load
*/
static void
-_eio_model_children_filter_set(Eo *obj EINA_UNUSED, Eio_Model_Data *pd,
- void *filter_data, EflIoFilter filter, Eina_Free_Cb filter_free_cb)
+_efl_io_model_children_filter_set(Eo *obj EINA_UNUSED, Efl_Io_Model_Data *pd,
+ void *filter_data, EflIoFilter filter, Eina_Free_Cb filter_free_cb)
{
pd->filter.data = filter_data;
pd->filter.cb = filter;
* Child Add
*/
static Eo *
-_eio_model_efl_model_child_add(Eo *obj EINA_UNUSED, Eio_Model_Data *priv EINA_UNUSED)
+_efl_io_model_efl_model_child_add(Eo *obj EINA_UNUSED, Efl_Io_Model_Data *priv EINA_UNUSED)
{
return NULL;
}
* Child Remove
*/
static void
-_eio_model_efl_model_child_del(Eo *obj EINA_UNUSED,
- Eio_Model_Data *priv EINA_UNUSED,
- Eo *child)
+_efl_io_model_efl_model_child_del(Eo *obj EINA_UNUSED,
+ Efl_Io_Model_Data *priv EINA_UNUSED,
+ Eo *child)
{
- Eio_Model_Data *child_pd;
+ Efl_Io_Model_Data *child_pd;
Eina_File_Type type;
child_pd = efl_data_scope_get(child, MY_CLASS);
* Children Slice Get
*/
static Eina_Future *
-_eio_model_efl_model_children_slice_get(Eo *obj, Eio_Model_Data *pd,
- unsigned int start, unsigned int count)
+_efl_io_model_efl_model_children_slice_get(Eo *obj, Efl_Io_Model_Data *pd,
+ unsigned int start, unsigned int count)
{
Eina_Future_Scheduler *scheduler = NULL;
Eina_Value array = EINA_VALUE_EMPTY;
while (count > 0)
{
- Eio_Model_Info *info = eina_list_data_get(ls);
- Eio_Model_Data *child_data = NULL;
+ Efl_Io_Model_Info *info = eina_list_data_get(ls);
+ Efl_Io_Model_Data *child_data = NULL;
info->child_ref = EINA_TRUE;
if (info->object == NULL)
// Little trick here, setting internal data before finalize
- info->object = efl_add(EIO_MODEL_CLASS, obj,
- child_data = efl_data_scope_get(efl_added, EIO_MODEL_CLASS),
+ info->object = efl_add(EFL_IO_MODEL_CLASS, obj,
+ child_data = efl_data_scope_get(efl_added, EFL_IO_MODEL_CLASS),
child_data->info = info,
child_data->path = eina_stringshare_ref(info->path),
child_data->parent = ls,
* Class definitions
*/
static Efl_Object *
-_eio_model_efl_object_finalize(Eo *obj, Eio_Model_Data *pd)
+_efl_io_model_efl_object_finalize(Eo *obj, Efl_Io_Model_Data *pd)
{
if (!pd->path) return NULL;
if (!efl_provider_find(obj, EFL_LOOP_CLASS))
}
static void
-_eio_model_path_set(Eo *obj EINA_UNUSED, Eio_Model_Data *priv, const char *path)
+_efl_io_model_path_set(Eo *obj EINA_UNUSED, Efl_Io_Model_Data *priv, const char *path)
{
char *sanitized = eina_file_path_sanitize(path);
priv->path = eina_stringshare_add(sanitized);
}
static const char *
-_eio_model_path_get(const Eo *obj EINA_UNUSED, Eio_Model_Data *priv)
+_efl_io_model_path_get(const Eo *obj EINA_UNUSED, Efl_Io_Model_Data *priv)
{
return priv->path;
}
static void
-_eio_model_efl_object_destructor(Eo *obj , Eio_Model_Data *priv)
+_efl_io_model_efl_object_destructor(Eo *obj , Efl_Io_Model_Data *priv)
{
- Eio_Model_Info *info;
+ Efl_Io_Model_Info *info;
- _eio_model_info_free(priv->info, EINA_TRUE);
+ _efl_io_model_info_free(priv->info, EINA_TRUE);
priv->info = NULL;
EINA_LIST_FREE(priv->files, info)
- _eio_model_info_free(info, EINA_FALSE);
+ _efl_io_model_info_free(info, EINA_FALSE);
eina_stringshare_del(priv->path);
}
static void
-_eio_model_efl_object_invalidate(Eo *obj , Eio_Model_Data *priv)
+_efl_io_model_efl_object_invalidate(Eo *obj , Efl_Io_Model_Data *priv)
{
- _eio_model_efl_model_monitor_del(priv);
+ _efl_io_model_efl_model_monitor_del(priv);
// Unlink the object from the parent
if (priv->info) priv->info->object = NULL;
}
}
- efl_invalidate(efl_super(obj, EIO_MODEL_CLASS));
+ efl_invalidate(efl_super(obj, EFL_IO_MODEL_CLASS));
}
-#include "eio_model.eo.c"
+#include "efl_io_model.eo.c"
function EflIoFilter {
[[EflIoFilter function]]
params {
- @in model: Eio.Model;
+ @in model: Efl.Io.Model;
@in entry: ptr(Eina.File_Direct_Info);
}
return: int;
};
-class Eio.Model extends Efl.Model_Loop
+class Efl.Io.Model extends Efl.Loop_Model
{
- [[Eio model class]]
+ [[Efl Io model class]]
methods {
children_filter_set {
-#ifndef _EIO_MODEL_PRIVATE_H
-#define _EIO_MODEL_PRIVATE_H
+#ifndef _EFL_IO_MODEL_PRIVATE_H
+#define _EFL_IO_MODEL_PRIVATE_H
#define PROP_LIST_SIZE 8
-typedef struct _Eio_Model_Data Eio_Model_Data;
-typedef struct _Eio_Model_Info Eio_Model_Info;
+typedef struct _Efl_Io_Model_Data Efl_Io_Model_Data;
+typedef struct _Efl_Io_Model_Info Efl_Io_Model_Info;
-typedef struct _Eio_Model_Monitor_Data Eio_Model_Monitor_Data;
-struct _Eio_Model_Monitor_Data
+typedef struct _Efl_Io_Model_Monitor_Data Efl_Io_Model_Monitor_Data;
+struct _Efl_Io_Model_Monitor_Data
{
Ecore_Event_Handler *ecore_child_add_handler[3];
Ecore_Event_Handler *ecore_child_del_handler[3];
// FIXME: Would be more efficient to introduce an Eina_Path that assemble
// an array of stringshare instead of using one mega stringshare directly.
-struct _Eio_Model_Info
+struct _Efl_Io_Model_Info
{
Eina_Stringshare *path;
Eo *object;
Eina_Bool child_ref : 1;
};
-struct _Eio_Model_Data
+struct _Efl_Io_Model_Data
{
Efl_Loop *loop;
- Eio_Model *self;
+ Efl_Io_Model *self;
Eina_Stringshare *path;
- Eio_Model_Info *info;
+ Efl_Io_Model_Info *info;
Eina_Stat *st;
const char *mime_type;
void *data;
} filter;
- Eio_Model_Monitor_Data mon;
+ Efl_Io_Model_Monitor_Data mon;
Eio_Monitor *monitor; // Notification stuff
// FIXME: would be interesting to figure a more efficient structure for holding files
Eina_List *parent;
- Eina_List *files; // Eio_Model_Info
+ Eina_List *files; // Efl_Io_Model_Info
Eina_Error error;
pub_eo_file_target = []
pub_eo_files = [
- 'eio_model.eo',
+ 'efl_io_model.eo',
'efl_io_manager.eo',
'eio_sentry.eo'
]
'eio_monitor_poll.c',
'eio_single.c',
'eio_xattr.c',
- 'eio_model.c',
- 'eio_model_private.h',
+ 'efl_io_model.c',
+ 'efl_io_model_private.h',
'eio_private.h',
'eio_sentry_private.h'
]
import eldbus_types;
-class Eldbus.Model extends Efl.Model_Loop {
+class Eldbus.Model extends Efl.Loop_Model {
methods {
connect {
[[Define connection parameters.
// it only compute the average size of an item and answer for that property alone.
// FIXME: handle child being removed
-typedef struct _Efl_Ui_Model_Average_Data Efl_Ui_Model_Average_Data;
-struct _Efl_Ui_Model_Average_Data
+typedef struct _Efl_Ui_Average_Model_Data Efl_Ui_Average_Model_Data;
+struct _Efl_Ui_Average_Model_Data
{
- Efl_Ui_Model_Average_Data *parent;
+ Efl_Ui_Average_Model_Data *parent;
struct {
unsigned long long width;
Eina_Bool hseen : 1;
};
-typedef struct _Efl_Ui_Model_Average_Update Efl_Ui_Model_Average_Update;
-struct _Efl_Ui_Model_Average_Update
+typedef struct _Efl_Ui_Average_Model_Update Efl_Ui_Average_Model_Update;
+struct _Efl_Ui_Average_Model_Update
{
unsigned long long *total;
unsigned long long *seen;
};
static Eina_Value
-_efl_ui_model_average_update(Eo *obj EINA_UNUSED, void *data, const Eina_Value v)
+_efl_ui_average_model_update(Eo *obj EINA_UNUSED, void *data, const Eina_Value v)
{
- Efl_Ui_Model_Average_Update *request = data;
+ Efl_Ui_Average_Model_Update *request = data;
unsigned int now;
if (!eina_value_uint_convert(&v, &now))
}
static void
-_efl_ui_model_average_clean(Eo *obj EINA_UNUSED, void *data, const Eina_Future *dead_future EINA_UNUSED)
+_efl_ui_average_model_clean(Eo *obj EINA_UNUSED, void *data, const Eina_Future *dead_future EINA_UNUSED)
{
free(data);
}
static Eina_Future *
-_efl_ui_model_average_prepare(Eo *obj,
+_efl_ui_average_model_prepare(Eo *obj,
unsigned long long *total, unsigned long long *seen,
const char *property, Eina_Value *value)
{
- Efl_Ui_Model_Average_Update *update;
+ Efl_Ui_Average_Model_Update *update;
Eina_Value *previous;
Eina_Future *f;
- update = calloc(1, sizeof (Efl_Ui_Model_Average_Update));
+ update = calloc(1, sizeof (Efl_Ui_Average_Model_Update));
if (!update) return efl_loop_future_rejected(obj, ENOMEM);
previous = efl_model_property_get(obj, property);
update->seen = seen;
// We have to make the change after we fetch the old value, otherwise, well, no old value left
- f = efl_model_property_set(efl_super(obj, EFL_UI_MODEL_AVERAGE_CLASS), property, value);
+ f = efl_model_property_set(efl_super(obj, EFL_UI_AVERAGE_MODEL_CLASS), property, value);
return efl_future_then(obj, f,
- .success = _efl_ui_model_average_update,
- .free = _efl_ui_model_average_clean,
+ .success = _efl_ui_average_model_update,
+ .free = _efl_ui_average_model_clean,
.data = update);
on_error:
eina_value_free(previous);
}
static Eina_Future *
-_efl_ui_model_average_efl_model_property_set(Eo *obj, Efl_Ui_Model_Average_Data *pd, const char *property, Eina_Value *value)
+_efl_ui_average_model_efl_model_property_set(Eo *obj, Efl_Ui_Average_Model_Data *pd, const char *property, Eina_Value *value)
{
Eina_Future *f = NULL;
// In vertical list mode we do not need to compute the average width size
/* if (!strcmp(property, _efl_model_property_selfw)) */
/* { */
- /* f = _efl_ui_model_average_prepare(obj, &pd->parent->total.width, */
+ /* f = _efl_ui_average_model_prepare(obj, &pd->parent->total.width, */
/* pd->wseen ? NULL : &pd->parent->total.wseen, */
/* property, value, EINA_TRUE); */
/* pd->wseen = EINA_TRUE; */
/* } */
if (!strcmp(property, _efl_model_property_selfh))
{
- f = _efl_ui_model_average_prepare(obj, &pd->parent->total.height,
+ f = _efl_ui_average_model_prepare(obj, &pd->parent->total.height,
pd->hseen ? NULL : &pd->parent->total.hseen,
property, value);
pd->hseen = EINA_TRUE;
end:
if (!f)
- f = efl_model_property_set(efl_super(obj, EFL_UI_MODEL_AVERAGE_CLASS), property, value);
+ f = efl_model_property_set(efl_super(obj, EFL_UI_AVERAGE_MODEL_CLASS), property, value);
return f;
}
static inline Eina_Value *
-_efl_ui_model_average_compute(const Eo *obj, Eina_Value *r, unsigned long long total, unsigned long long seen)
+_efl_ui_average_model_compute(const Eo *obj, Eina_Value *r, unsigned long long total, unsigned long long seen)
{
unsigned int count;
}
static Eina_Value *
-_efl_ui_model_average_efl_model_property_get(const Eo *obj, Efl_Ui_Model_Average_Data *pd, const char *property)
+_efl_ui_average_model_efl_model_property_get(const Eo *obj, Efl_Ui_Average_Model_Data *pd, const char *property)
{
const Eina_Value_Type *t;
Eina_Value *r;
- r = efl_model_property_get(efl_super(obj, EFL_UI_MODEL_AVERAGE_CLASS), property);
+ r = efl_model_property_get(efl_super(obj, EFL_UI_AVERAGE_MODEL_CLASS), property);
if (!r) return r;
// We are checking that the parent class was able to provide an answer to the request for property "Total.Width"
if (t == EINA_VALUE_TYPE_UINT)
{
if (!strcmp(property, _efl_model_property_totalh))
- r = _efl_ui_model_average_compute(obj, r, pd->total.height, pd->total.hseen);
+ r = _efl_ui_average_model_compute(obj, r, pd->total.height, pd->total.hseen);
// We do not need to average the width in vertical list mode as this is done by the parent class
/* if (!strcmp(property, _efl_model_property_totalw)) */
- /* r = _efl_ui_model_average_compute(obj, r, pd->total.width, pd->total.wseen); */
+ /* r = _efl_ui_average_model_compute(obj, r, pd->total.width, pd->total.wseen); */
}
return r;
}
static Efl_Object *
-_efl_ui_model_average_efl_object_constructor(Eo *obj, Efl_Ui_Model_Average_Data *pd)
+_efl_ui_average_model_efl_object_constructor(Eo *obj, Efl_Ui_Average_Model_Data *pd)
{
Eo *parent = efl_parent_get(obj);
- if (parent && efl_isa(parent, EFL_UI_MODEL_AVERAGE_CLASS))
- pd->parent = efl_data_scope_get(efl_parent_get(obj), EFL_UI_MODEL_AVERAGE_CLASS);
+ if (parent && efl_isa(parent, EFL_UI_AVERAGE_MODEL_CLASS))
+ pd->parent = efl_data_scope_get(efl_parent_get(obj), EFL_UI_AVERAGE_MODEL_CLASS);
- return efl_constructor(efl_super(obj, EFL_UI_MODEL_AVERAGE_CLASS));
+ return efl_constructor(efl_super(obj, EFL_UI_AVERAGE_MODEL_CLASS));
}
-#include "efl_ui_model_average.eo.c"
+#include "efl_ui_average_model.eo.c"
-class Efl.Ui.Model_Average extends Efl.Ui.Model_Exact
+class Efl.Ui.Average_Model extends Efl.Ui.Exact_Model
{
[[Class to be used to store object item size for List/Grid View.
- This model provide the same feature as @Efl.Ui.Model_Exact except for the
+ This model provide the same feature as @Efl.Ui.Exact_Model except for the
@Efl.Model.property "$total.width" and "$total.height" which reflect an
estimated value of the total size by using the currently know size from its
children as an average size for all its children. As more children fill
"$self.width" and "$self.height", this model will figure out a more precise
answer. Once all children size is known, the result will be exact and the same
- as @Efl.Ui.Model_Exact.
+ as @Efl.Ui.Exact_Model.
This model only supporting vertical list at this point.]]
Efl.Object.constructor;
Efl.Model.property { set; get; }
}
-}
\ No newline at end of file
+}
// That cache could get dropped when the application is entering the 'pause'
// state.
-#define EFL_UI_MODEL_EXACT_CONTENT 1024
-#define EFL_UI_MODEL_EXACT_CONTENT_LENGTH (EFL_UI_MODEL_EXACT_CONTENT * sizeof (unsigned int))
+#define EFL_UI_EXACT_MODEL_CONTENT 1024
+#define EFL_UI_EXACT_MODEL_CONTENT_LENGTH (EFL_UI_EXACT_MODEL_CONTENT * sizeof (unsigned int))
// For now only vertical logic is implemented. Horizontal list and grid are not supported.
-typedef struct _Efl_Ui_Model_Exact_Data Efl_Ui_Model_Exact_Data;
-struct _Efl_Ui_Model_Exact_Data
+typedef struct _Efl_Ui_Exact_Model_Data Efl_Ui_Exact_Model_Data;
+struct _Efl_Ui_Exact_Model_Data
{
- Efl_Ui_Model_Exact_Data *parent;
+ Efl_Ui_Exact_Model_Data *parent;
struct {
Eina_List *width;
};
static Efl_Object *
-_efl_ui_model_exact_efl_object_constructor(Eo *obj, Efl_Ui_Model_Exact_Data *pd)
+_efl_ui_exact_model_efl_object_constructor(Eo *obj, Efl_Ui_Exact_Model_Data *pd)
{
Eo *parent = efl_parent_get(obj);
- if (parent && efl_isa(parent, EFL_UI_MODEL_EXACT_CLASS))
- pd->parent = efl_data_scope_get(efl_parent_get(obj), EFL_UI_MODEL_EXACT_CLASS);
+ if (parent && efl_isa(parent, EFL_UI_EXACT_MODEL_CLASS))
+ pd->parent = efl_data_scope_get(efl_parent_get(obj), EFL_UI_EXACT_MODEL_CLASS);
- return efl_constructor(efl_super(obj, EFL_UI_MODEL_EXACT_CLASS));
+ return efl_constructor(efl_super(obj, EFL_UI_EXACT_MODEL_CLASS));
}
static unsigned int
-_efl_ui_model_exact_list_find(unsigned int list_index, Eina_List *start, Eina_List **l)
+_efl_ui_exact_model_list_find(unsigned int list_index, Eina_List *start, Eina_List **l)
{
Eina_Binbuf *tbuf;
}
static Eina_List *
-_efl_ui_model_exact_slot_compress(unsigned int index, Eina_List *compressed, unsigned int *buffer)
+_efl_ui_exact_model_slot_compress(unsigned int index, Eina_List *compressed, unsigned int *buffer)
{
- unsigned int list_index = index / EFL_UI_MODEL_EXACT_CONTENT;
+ unsigned int list_index = index / EFL_UI_EXACT_MODEL_CONTENT;
static Eina_Binbuf *z = NULL;
Eina_Binbuf *cbuf;
Eina_Binbuf *tbuf;
Eina_List *l = NULL;
- _efl_ui_model_exact_list_find(list_index, compressed, &l);
+ _efl_ui_exact_model_list_find(list_index, compressed, &l);
- tbuf = eina_binbuf_manage_new((unsigned char *) buffer, EFL_UI_MODEL_EXACT_CONTENT_LENGTH, EINA_TRUE);
+ tbuf = eina_binbuf_manage_new((unsigned char *) buffer, EFL_UI_EXACT_MODEL_CONTENT_LENGTH, EINA_TRUE);
cbuf = emile_compress(tbuf, EMILE_LZ4, EMILE_COMPRESSOR_FAST);
eina_binbuf_free(tbuf);
{
unsigned char *zmem;
- zmem = calloc(EFL_UI_MODEL_EXACT_CONTENT, sizeof (unsigned int));
+ zmem = calloc(EFL_UI_EXACT_MODEL_CONTENT, sizeof (unsigned int));
if (!zmem) return compressed;
- tbuf = eina_binbuf_manage_new(zmem, EFL_UI_MODEL_EXACT_CONTENT_LENGTH, EINA_TRUE);
+ tbuf = eina_binbuf_manage_new(zmem, EFL_UI_EXACT_MODEL_CONTENT_LENGTH, EINA_TRUE);
if (!tbuf) return compressed;
z = emile_compress(tbuf, EMILE_LZ4, EMILE_COMPRESSOR_FAST);
}
static unsigned int *
-_efl_ui_model_exact_buffer_expand(unsigned int list_index, unsigned int *buffer, Eina_List *list)
+_efl_ui_exact_model_buffer_expand(unsigned int list_index, unsigned int *buffer, Eina_List *list)
{
unsigned int found;
Eina_Binbuf *tmp;
Eina_List *l = NULL;
- if (!buffer) buffer = malloc(EFL_UI_MODEL_EXACT_CONTENT_LENGTH);
+ if (!buffer) buffer = malloc(EFL_UI_EXACT_MODEL_CONTENT_LENGTH);
- found = _efl_ui_model_exact_list_find(list_index, list, &l);
+ found = _efl_ui_exact_model_list_find(list_index, list, &l);
// Check if the data is in the list
if (!found)
{
// Not found -> everything is assumed to be zero
- memset(buffer, 0, EFL_UI_MODEL_EXACT_CONTENT_LENGTH);
+ memset(buffer, 0, EFL_UI_EXACT_MODEL_CONTENT_LENGTH);
return buffer;
}
// Found -> expand in buffer
- tmp = eina_binbuf_manage_new((unsigned char*) buffer, EFL_UI_MODEL_EXACT_CONTENT_LENGTH, EINA_TRUE);
+ tmp = eina_binbuf_manage_new((unsigned char*) buffer, EFL_UI_EXACT_MODEL_CONTENT_LENGTH, EINA_TRUE);
emile_expand(eina_list_data_get(l), tmp, EMILE_LZ4);
eina_binbuf_free(tmp);
}
static unsigned char
-_efl_ui_model_exact_slot_find(Efl_Ui_Model_Exact_Data *pd, unsigned int index,
+_efl_ui_exact_model_slot_find(Efl_Ui_Exact_Model_Data *pd, unsigned int index,
Eina_Bool width_get, Eina_Bool height_get)
{
unsigned char lookup;
if (!pd->parent->slot[lookup].defined)
continue;
if (pd->parent->slot[lookup].start_offset <= index &&
- index < pd->parent->slot[lookup].start_offset + EFL_UI_MODEL_EXACT_CONTENT)
+ index < pd->parent->slot[lookup].start_offset + EFL_UI_EXACT_MODEL_CONTENT)
found = lookup;
// Reduce usage to find unused slot.
if (pd->parent->slot[lookup].usage > 0)
{
if (pd->parent->slot[found].width &&
pd->parent->slot[found].decompressed.width)
- pd->parent->compressed.width = _efl_ui_model_exact_slot_compress(index,
+ pd->parent->compressed.width = _efl_ui_exact_model_slot_compress(index,
pd->parent->compressed.width,
pd->parent->slot[found].width);
if (pd->parent->slot[found].height &&
pd->parent->slot[found].decompressed.height)
- pd->parent->compressed.height = _efl_ui_model_exact_slot_compress(index,
+ pd->parent->compressed.height = _efl_ui_exact_model_slot_compress(index,
pd->parent->compressed.height,
pd->parent->slot[found].height);
}
pd->parent->slot[found].defined = EINA_TRUE;
pd->parent->slot[found].decompressed.width = EINA_FALSE;
pd->parent->slot[found].decompressed.height = EINA_FALSE;
- pd->parent->slot[found].start_offset = index / EFL_UI_MODEL_EXACT_CONTENT;
+ pd->parent->slot[found].start_offset = index / EFL_UI_EXACT_MODEL_CONTENT;
}
// Increase usage of the returnd slot for now
// Unpack the data if requested
if (width_get && !pd->parent->slot[found].decompressed.width)
{
- pd->parent->slot[found].width = _efl_ui_model_exact_buffer_expand(pd->parent->slot[found].start_offset,
+ pd->parent->slot[found].width = _efl_ui_exact_model_buffer_expand(pd->parent->slot[found].start_offset,
pd->parent->slot[found].width,
pd->parent->compressed.width);
pd->parent->slot[found].decompressed.width = EINA_TRUE;
}
if (height_get && !pd->parent->slot[found].decompressed.height)
{
- pd->parent->slot[found].height = _efl_ui_model_exact_buffer_expand(pd->parent->slot[found].start_offset,
+ pd->parent->slot[found].height = _efl_ui_exact_model_buffer_expand(pd->parent->slot[found].start_offset,
pd->parent->slot[found].height,
pd->parent->compressed.height);
pd->parent->slot[found].decompressed.height = EINA_TRUE;
}
static Eina_Future *
-_efl_ui_model_exact_efl_model_property_set(Eo *obj, Efl_Ui_Model_Exact_Data *pd,
+_efl_ui_exact_model_efl_model_property_set(Eo *obj, Efl_Ui_Exact_Model_Data *pd,
const char *property, Eina_Value *value)
{
if (pd->parent)
unsigned int index;
unsigned char found;
- index = efl_model_composite_index_get(obj);
- found = _efl_ui_model_exact_slot_find(pd, index, EINA_TRUE, EINA_FALSE);
- if (!eina_value_uint_convert(value, &pd->parent->slot[found].width[index % EFL_UI_MODEL_EXACT_CONTENT]))
+ index = efl_composite_model_index_get(obj);
+ found = _efl_ui_exact_model_slot_find(pd, index, EINA_TRUE, EINA_FALSE);
+ if (!eina_value_uint_convert(value, &pd->parent->slot[found].width[index % EFL_UI_EXACT_MODEL_CONTENT]))
return efl_loop_future_rejected(obj, EFL_MODEL_ERROR_INCORRECT_VALUE);
// We succeeded so let's update the max total size width (As we only handle vertical list case at the moment)
- if (pd->parent->total_size.width < pd->parent->slot[found].width[index % EFL_UI_MODEL_EXACT_CONTENT])
- pd->parent->total_size.width = pd->parent->slot[found].width[index % EFL_UI_MODEL_EXACT_CONTENT];
- return efl_loop_future_resolved(obj, eina_value_uint_init(pd->parent->slot[found].width[index % EFL_UI_MODEL_EXACT_CONTENT]));
+ if (pd->parent->total_size.width < pd->parent->slot[found].width[index % EFL_UI_EXACT_MODEL_CONTENT])
+ pd->parent->total_size.width = pd->parent->slot[found].width[index % EFL_UI_EXACT_MODEL_CONTENT];
+ return efl_loop_future_resolved(obj, eina_value_uint_init(pd->parent->slot[found].width[index % EFL_UI_EXACT_MODEL_CONTENT]));
}
if (!strcmp(property, _efl_model_property_selfh))
{
unsigned int index;
unsigned char found;
- index = efl_model_composite_index_get(obj);
- found = _efl_ui_model_exact_slot_find(pd, index, EINA_FALSE, EINA_TRUE);
- old_value = pd->parent->slot[found].height[index % EFL_UI_MODEL_EXACT_CONTENT];
- if (!eina_value_uint_convert(value, &pd->parent->slot[found].height[index % EFL_UI_MODEL_EXACT_CONTENT]))
+ index = efl_composite_model_index_get(obj);
+ found = _efl_ui_exact_model_slot_find(pd, index, EINA_FALSE, EINA_TRUE);
+ old_value = pd->parent->slot[found].height[index % EFL_UI_EXACT_MODEL_CONTENT];
+ if (!eina_value_uint_convert(value, &pd->parent->slot[found].height[index % EFL_UI_EXACT_MODEL_CONTENT]))
return efl_loop_future_rejected(obj, EFL_MODEL_ERROR_INCORRECT_VALUE);
// We succeeded so let's update the total size
- pd->parent->total_size.height += pd->parent->slot[found].height[index % EFL_UI_MODEL_EXACT_CONTENT] - old_value;
- return efl_loop_future_resolved(obj, eina_value_uint_init(pd->parent->slot[found].height[index % EFL_UI_MODEL_EXACT_CONTENT]));
+ pd->parent->total_size.height += pd->parent->slot[found].height[index % EFL_UI_EXACT_MODEL_CONTENT] - old_value;
+ return efl_loop_future_resolved(obj, eina_value_uint_init(pd->parent->slot[found].height[index % EFL_UI_EXACT_MODEL_CONTENT]));
}
// The following property are calculated by the model and so READ_ONLY
if (!strcmp(property, _efl_model_property_totalh))
return efl_loop_future_rejected(obj, EFL_MODEL_ERROR_READ_ONLY);
}
- return efl_model_property_set(efl_super(obj, EFL_UI_MODEL_EXACT_CLASS), property, value);
+ return efl_model_property_set(efl_super(obj, EFL_UI_EXACT_MODEL_CLASS), property, value);
}
static Eina_Value *
-_efl_ui_model_exact_efl_model_property_get(const Eo *obj, Efl_Ui_Model_Exact_Data *pd,
+_efl_ui_exact_model_efl_model_property_get(const Eo *obj, Efl_Ui_Exact_Model_Data *pd,
const char *property)
{
if (pd->parent)
unsigned int index;
unsigned char found;
- index = efl_model_composite_index_get(obj);
- found = _efl_ui_model_exact_slot_find(pd, index, EINA_TRUE, EINA_FALSE);
- return eina_value_uint_new(pd->parent->slot[found].width[index % EFL_UI_MODEL_EXACT_CONTENT]);
+ index = efl_composite_model_index_get(obj);
+ found = _efl_ui_exact_model_slot_find(pd, index, EINA_TRUE, EINA_FALSE);
+ return eina_value_uint_new(pd->parent->slot[found].width[index % EFL_UI_EXACT_MODEL_CONTENT]);
}
if (!strcmp(property, _efl_model_property_selfh))
{
unsigned int index;
unsigned char found;
- index = efl_model_composite_index_get(obj);
- found = _efl_ui_model_exact_slot_find(pd, index, EINA_FALSE, EINA_TRUE);
- return eina_value_uint_new(pd->parent->slot[found].height[index % EFL_UI_MODEL_EXACT_CONTENT]);
+ index = efl_composite_model_index_get(obj);
+ found = _efl_ui_exact_model_slot_find(pd, index, EINA_FALSE, EINA_TRUE);
+ return eina_value_uint_new(pd->parent->slot[found].height[index % EFL_UI_EXACT_MODEL_CONTENT]);
}
}
if (!strcmp(property, _efl_model_property_totalh))
// The exact model can not guess a general item size if asked.
return eina_value_error_new(EAGAIN);
}
- return efl_model_property_get(efl_super(obj, EFL_UI_MODEL_EXACT_CLASS), property);
+ return efl_model_property_get(efl_super(obj, EFL_UI_EXACT_MODEL_CLASS), property);
}
-#include "efl_ui_model_exact.eo.c"
+#include "efl_ui_exact_model.eo.c"
-class Efl.Ui.Model_Exact extends Efl.Ui.Model_Size
+class Efl.Ui.Exact_Model extends Efl.Ui.Size_Model
{
[[Class to be used to store object item size for List/Grid View.
Efl.Object.constructor;
Efl.Model.property { set; get; }
}
-}
\ No newline at end of file
+}
// For now only vertical logic is implemented. Horizontal list and grid are not supported.
-typedef struct _Efl_Ui_Model_Homogeneous_Data Efl_Ui_Model_Homogeneous_Data;
-struct _Efl_Ui_Model_Homogeneous_Data
+typedef struct _Efl_Ui_Homogeneous_Model_Data Efl_Ui_Homogeneous_Model_Data;
+struct _Efl_Ui_Homogeneous_Model_Data
{
- Efl_Ui_Model_Homogeneous_Data *parent;
+ Efl_Ui_Homogeneous_Model_Data *parent;
struct {
unsigned int width;
};
static Eina_Future *
-_efl_ui_model_homogeneous_property_set(Eo *obj, Eina_Value *value,
+_efl_ui_homogeneous_model_property_set(Eo *obj, Eina_Value *value,
Eina_Bool *defined, unsigned int *r)
{
Eina_Future *f;
}
static Eina_Future *
-_efl_ui_model_homogeneous_efl_model_property_set(Eo *obj,
- Efl_Ui_Model_Homogeneous_Data *pd,
+_efl_ui_homogeneous_model_efl_model_property_set(Eo *obj,
+ Efl_Ui_Homogeneous_Model_Data *pd,
const char *property, Eina_Value *value)
{
if (pd->parent)
{
if (!strcmp(property, _efl_model_property_selfw))
- return _efl_ui_model_homogeneous_property_set(obj, value,
+ return _efl_ui_homogeneous_model_property_set(obj, value,
&pd->parent->item.defined.width,
&pd->parent->item.width);
if (!strcmp(property, _efl_model_property_selfh))
- return _efl_ui_model_homogeneous_property_set(obj, value,
+ return _efl_ui_homogeneous_model_property_set(obj, value,
&pd->parent->item.defined.height,
&pd->parent->item.height);
if (!strcmp(property, _efl_model_property_totalw) ||
}
if (!strcmp(property, _efl_model_property_itemw))
{
- return _efl_ui_model_homogeneous_property_set(obj, value,
+ return _efl_ui_homogeneous_model_property_set(obj, value,
&pd->item.defined.width,
&pd->item.width);
}
if (!strcmp(property, _efl_model_property_itemh))
{
- return _efl_ui_model_homogeneous_property_set(obj, value,
+ return _efl_ui_homogeneous_model_property_set(obj, value,
&pd->item.defined.height,
&pd->item.height);
}
- return efl_model_property_set(efl_super(obj, EFL_UI_MODEL_HOMOGENEOUS_CLASS),
+ return efl_model_property_set(efl_super(obj, EFL_UI_HOMOGENEOUS_MODEL_CLASS),
property, value);
}
static Eina_Value *
-_efl_ui_model_homogeneous_efl_model_property_get(const Eo *obj,
- Efl_Ui_Model_Homogeneous_Data *pd,
+_efl_ui_homogeneous_model_efl_model_property_get(const Eo *obj,
+ Efl_Ui_Homogeneous_Model_Data *pd,
const char *property)
{
if (pd->parent)
goto not_ready;
}
- return efl_model_property_get(efl_super(obj, EFL_UI_MODEL_HOMOGENEOUS_CLASS), property);
+ return efl_model_property_get(efl_super(obj, EFL_UI_HOMOGENEOUS_MODEL_CLASS), property);
not_ready:
return eina_value_error_new(EAGAIN);
}
static Efl_Object *
-_efl_ui_model_homogeneous_efl_object_constructor(Eo *obj, Efl_Ui_Model_Homogeneous_Data *pd)
+_efl_ui_homogeneous_model_efl_object_constructor(Eo *obj, Efl_Ui_Homogeneous_Model_Data *pd)
{
Eo *parent = efl_parent_get(obj);
- if (parent && efl_isa(parent, EFL_UI_MODEL_HOMOGENEOUS_CLASS))
- pd->parent = efl_data_scope_get(efl_parent_get(obj), EFL_UI_MODEL_HOMOGENEOUS_CLASS);
+ if (parent && efl_isa(parent, EFL_UI_HOMOGENEOUS_MODEL_CLASS))
+ pd->parent = efl_data_scope_get(efl_parent_get(obj), EFL_UI_HOMOGENEOUS_MODEL_CLASS);
- return efl_constructor(efl_super(obj, EFL_UI_MODEL_HOMOGENEOUS_CLASS));
+ return efl_constructor(efl_super(obj, EFL_UI_HOMOGENEOUS_MODEL_CLASS));
}
-#include "efl_ui_model_homogeneous.eo.c"
+#include "efl_ui_homogeneous_model.eo.c"
-class Efl.Ui.Model_Homogeneous extends Efl.Ui.Model_Size
+class Efl.Ui.Homogeneous_Model extends Efl.Ui.Size_Model
{
[[Class to be used to store object item size for List/Grid View.
This model provides the properties "$item.width" and "$item.height" which have the
same value for all siblings of this object. The first sibling that defines "$self.width"
and "$self.height" set them for all other siblings and also set "$item.width" and
- "$item.height" for the parent (See @Efl.Ui.Model_Size).
+ "$item.height" for the parent (See @Efl.Ui.Size_Model).
Subsequent attempts to set "$self.width" or "$self.height" will fail with a
Read Only error code.
const char *_efl_model_property_totalh = "total.height";
static Eina_Iterator *
-_efl_ui_model_size_properties_child(void)
+_efl_ui_size_model_properties_child(void)
{
const char *properties[] = {
_efl_model_property_itemw, _efl_model_property_itemh, _efl_model_property_selfh, _efl_model_property_selfw
}
static Eina_Iterator *
-_efl_ui_model_size_properties_root(void)
+_efl_ui_size_model_properties_root(void)
{
const char *properties[] = {
_efl_model_property_itemw, _efl_model_property_itemh
}
static Eina_Iterator *
-_efl_ui_model_size_efl_model_properties_get(const Eo *obj, void *pd EINA_UNUSED)
+_efl_ui_size_model_efl_model_properties_get(const Eo *obj, void *pd EINA_UNUSED)
{
Eina_Iterator *super;
Eina_Iterator *prop;
- super = efl_model_properties_get(efl_super(obj, EFL_UI_MODEL_SIZE_CLASS));
- if (efl_isa(efl_parent_get(obj), EFL_UI_MODEL_SIZE_CLASS))
- prop = _efl_ui_model_size_properties_child();
+ super = efl_model_properties_get(efl_super(obj, EFL_UI_SIZE_MODEL_CLASS));
+ if (efl_isa(efl_parent_get(obj), EFL_UI_SIZE_MODEL_CLASS))
+ prop = _efl_ui_size_model_properties_child();
else
- prop = _efl_ui_model_size_properties_root();
+ prop = _efl_ui_size_model_properties_root();
return eina_multi_iterator_new(super, prop);
}
-#include "efl_ui_model_size.eo.c"
+#include "efl_ui_size_model.eo.c"
-class Efl.Ui.Model_Size extends Efl.Model_Composite
+class Efl.Ui.Size_Model extends Efl.Composite_Model
{
[[Class to be used to store object item size for List/Grid View.
view of the @Efl.Ui.View that use it. It only apply on children and not on the
top root object.
- "$item.width" and "$item.height" define all the children size and is available
- only on @Efl.Ui.Model_Size that do have children.
+ only on @Efl.Ui.Size_Model that do have children.
- "$total.width" and "$total.height" define the accumulated size used by all the children.
Only vertical list accumulation logic is implemented at this point.]]
implements {
Efl.Model.properties { get; }
}
-}
\ No newline at end of file
+}
-class Efl.Ui.Model_State extends Efl.Model_Composite_Boolean
+class Efl.Ui.State_Model extends Efl.Boolean_Model
{
[[Efl model handling visibility, enable and selected state]]
implements {
// Is this item selected
if (sd->target)
{
- const char *target_path = eio_model_path_get(sd->target);
+ const char *target_path = efl_io_model_path_get(sd->target);
if (!strcmp(it_data->path, target_path))
{
parent = efl_parent_get(sd->model);
if (!parent) return;
- if (!efl_isa(parent, EIO_MODEL_CLASS))
+ if (!efl_isa(parent, EFL_IO_MODEL_CLASS))
{
- const char *path = eio_model_path_get(sd->model);
+ const char *path = efl_io_model_path_get(sd->model);
char dir[PATH_MAX] = "";
char *r;
{
const Efl_Class *model_cls = NULL;
if (!sd->model)
- model_cls = EIO_MODEL_CLASS;
+ model_cls = EFL_IO_MODEL_CLASS;
else
model_cls = efl_class_get(sd->model);
void
_elm_fileselector_path_set_internal(Evas_Object *obj, const char *_path)
{
- Eio_Model *model = efl_add_ref(EIO_MODEL_CLASS, obj, eio_model_path_set(efl_added, _path),
- efl_event_callback_array_add(efl_added, noref_death(), NULL));
+ Efl_Io_Model *model = efl_add_ref(EFL_IO_MODEL_CLASS, obj, efl_io_model_path_set(efl_added, _path),
+ efl_event_callback_array_add(efl_added, noref_death(), NULL));
if (!model)
{
ERR("Efl.Model allocation error");
if (!sd->path) return NULL;
if (sd->target)
{
- return eio_model_path_get(sd->target);
+ return efl_io_model_path_get(sd->target);
}
Elm_Fileselector_Item_Data *it_data = _selected_item_data_get(sd);
if (!is_dir)
{
Efl_Model *parent;
- const char *path = eio_model_path_get(ev->object);
+ const char *path = efl_io_model_path_get(ev->object);
char *dir = ecore_file_dir_get(path);
- parent = efl_add_ref(EIO_MODEL_CLASS, obj, eio_model_path_set(efl_added, dir),
+ parent = efl_add_ref(EFL_IO_MODEL_CLASS, obj, efl_io_model_path_set(efl_added, dir),
efl_event_callback_array_add(efl_added, noref_death(), NULL));
if (!parent)
{
if (stat(path, &st)) return EINA_FALSE;
- pd->target = efl_add_ref(EIO_MODEL_CLASS, obj, eio_model_path_set(efl_added, path),
+ pd->target = efl_add_ref(EFL_IO_MODEL_CLASS, obj, efl_io_model_path_set(efl_added, path),
efl_event_callback_array_add(efl_added, noref_death(), NULL));
if (!pd->target)
{
Eina_Value *value = NULL;
Eina_Bool dir = EINA_FALSE;
- if (!efl_isa(model, EIO_MODEL_CLASS)) return EINA_FALSE;
+ if (!efl_isa(model, EFL_IO_MODEL_CLASS)) return EINA_FALSE;
efl_event_callback_del(pd->target, EFL_MODEL_EVENT_PROPERTIES_CHANGED, _properties_ready, obj);
efl_replace(&pd->target, model);
eina_value_error_get(value, &err);
if (err != EAGAIN)
{
- ERR("Unexpected error '%s' when setting path '%s'.", eina_value_to_string(value), eio_model_path_get(pd->target));
+ ERR("Unexpected error '%s' when setting path '%s'.", eina_value_to_string(value), efl_io_model_path_get(pd->target));
goto clean_up;
}
if (!dir)
{
Efl_Model *parent;
- const char *path = eio_model_path_get(pd->target);
+ const char *path = efl_io_model_path_get(pd->target);
char *d = ecore_file_dir_get(path);
- parent = efl_add_ref(EIO_MODEL_CLASS, obj, eio_model_path_set(efl_added, d),
+ parent = efl_add_ref(EFL_IO_MODEL_CLASS, obj, efl_io_model_path_set(efl_added, d),
efl_event_callback_array_add(efl_added, noref_death(), NULL));
if (!parent)
{
if (path) priv->fsd.path = eina_stringshare_add(path);
else priv->fsd.path = eina_stringshare_add("/");
- priv->fsd.model = efl_add_ref(EIO_MODEL_CLASS, obj,
- eio_model_path_set(efl_added, priv->fsd.path),
+ priv->fsd.model = efl_add_ref(EFL_IO_MODEL_CLASS, obj,
+ efl_io_model_path_set(efl_added, priv->fsd.path),
efl_event_callback_array_add(efl_added, noref_death(), NULL));
priv->fsd.expandable = _elm_config->fileselector_expand_enable;
{
ELM_FILESELECTOR_BUTTON_DATA_GET_OR_RETURN(obj, sd);
- Efl_Model *model = efl_add(EIO_MODEL_CLASS, obj, eio_model_path_set(efl_added, path));
+ Efl_Model *model = efl_add(EFL_IO_MODEL_CLASS, obj, efl_io_model_path_set(efl_added, path));
if (!model)
{
ERR("Efl.Model allocation error");
[[Get the currently selected item's model, in the given file the given file selector widget]]
}
values {
- model: Eio.Model; [[Model to be set, NULL reset it.]]
+ model: Efl.Io.Model; [[Model to be set, NULL reset it.]]
}
}
custom_filter_append {
# include "elm_widget_item_static_focus.eo.h"
# include "efl_ui_selection_manager.eo.h"
# include "efl_datetime_manager.eo.h"
-# include "efl_ui_model_size.eo.h"
-# include "efl_ui_model_homogeneous.eo.h"
-# include "efl_ui_model_exact.eo.h"
-# include "efl_ui_model_average.eo.h"
+# include "efl_ui_size_model.eo.h"
+# include "efl_ui_homogeneous_model.eo.h"
+# include "efl_ui_exact_model.eo.h"
+# include "efl_ui_average_model.eo.h"
extern const char *_efl_model_property_itemw;
extern const char *_efl_model_property_itemh;
'efl_ui_focus_parent_provider.eo',
'efl_ui_focus_parent_provider_standard.eo',
'efl_ui_focus_parent_provider_gen.eo',
- 'efl_ui_model_state.eo',
+ 'efl_ui_state_model.eo',
'efl_ui_selection_manager.eo',
'efl_datetime_manager.eo',
'efl_ui_list_view_precise_layouter.eo',
'efl_ui_list_view_relayout.eo',
- 'efl_ui_model_size.eo',
- 'efl_ui_model_homogeneous.eo',
- 'efl_ui_model_exact.eo',
- 'efl_ui_model_average.eo',
+ 'efl_ui_size_model.eo',
+ 'efl_ui_homogeneous_model.eo',
+ 'efl_ui_exact_model.eo',
+ 'efl_ui_average_model.eo',
]
priv_eo_file_target = []
'efl_ui_widget_focus_manager.c',
'efl_ui_caching_factory.c',
'efl_ui_widget_factory.c',
- 'efl_ui_model_size.c',
- 'efl_ui_model_homogeneous.c',
- 'efl_ui_model_exact.c',
- 'efl_ui_model_average.c',
+ 'efl_ui_size_model.c',
+ 'efl_ui_homogeneous_model.c',
+ 'efl_ui_exact_model.c',
+ 'efl_ui_average_model.c'
]
elementary_deps = [emile, eo, efl, edje, ethumb, ethumb_client, emotion, ecore_imf, ecore_con, eldbus, efreet, efreet_mime, efreet_trash, eio, atspi, dl, intl]
#include "../efl_check.h"
static const Efl_Test_Case etc[] = {
- { "Efl_Model_Container", efl_test_case_model_container },
- { "Efl_Model_View", efl_test_case_model_view },
- { "Efl_Model_Composite_Boolean", efl_test_case_model_composite_boolean },
+ { "Efl_Container_Model", efl_test_case_container_model },
+ { "Efl_View_Model", efl_test_case_view_model },
+ { "Efl_Boolean_Model", efl_test_case_boolean_model },
{ NULL, NULL }
};
#include <check.h>
#include "../efl_check.h"
-void efl_test_case_model_container(TCase *tc);
-void efl_test_case_model_view(TCase *tc);
-void efl_test_case_model_composite_boolean(TCase *tc);
+void efl_test_case_container_model(TCase *tc);
+void efl_test_case_view_model(TCase *tc);
+void efl_test_case_boolean_model(TCase *tc);
#endif /* EFL_SUITE_H_ */
return v;
}
-EFL_START_TEST(efl_test_model_composite_boolean)
+EFL_START_TEST(efl_test_boolean_model)
{
- Efl_Model_Item *base_model, *child;
+ Efl_Generic_Model *base_model, *child;
int i;
Eina_Value v;
- Efl_Model_Composite_Boolean *model;
+ Efl_Boolean_Model *model;
Eina_Future *future;
eina_value_setup(&v, EINA_VALUE_TYPE_INT);
- base_model = efl_add_ref(EFL_MODEL_ITEM_CLASS, efl_main_loop_get());
+ base_model = efl_add_ref(EFL_GENERIC_MODEL_CLASS, efl_main_loop_get());
ck_assert(!!base_model);
for (i = 0; i < child_number; ++i)
efl_model_property_set(child, "test_p_int", &v);
}
- model = efl_add_ref(EFL_MODEL_COMPOSITE_BOOLEAN_CLASS, efl_main_loop_get(),
+ model = efl_add_ref(EFL_BOOLEAN_MODEL_CLASS, efl_main_loop_get(),
efl_ui_view_model_set(efl_added, base_model),
- efl_model_composite_boolean_add(efl_added, "test_p_true", EINA_TRUE),
- efl_model_composite_boolean_add(efl_added, "test_p_false", EINA_FALSE));
+ efl_boolean_model_boolean_add(efl_added, "test_p_true", EINA_TRUE),
+ efl_boolean_model_boolean_add(efl_added, "test_p_false", EINA_FALSE));
ck_assert(!!model);
future = efl_model_children_slice_get(model, 0, efl_model_children_count_get(model));
return v;
}
-EFL_START_TEST(efl_test_model_composite_selection)
+EFL_START_TEST(efl_test_select_model)
{
- Efl_Model_Item *base_model, *child;
+ Efl_Generic_Model *base_model, *child;
int i;
Eina_Value v;
- Efl_Model_Composite_Selection *model;
+ Efl_Select_Model *model;
Eina_Future *future;
eina_value_setup(&v, EINA_VALUE_TYPE_INT);
- base_model = efl_add_ref(EFL_MODEL_ITEM_CLASS, efl_main_loop_get());
+ base_model = efl_add_ref(EFL_GENERIC_MODEL_CLASS, efl_main_loop_get());
ck_assert(!!base_model);
for (i = 0; i < child_number; ++i)
efl_model_property_set(child, "test_p_int", &v);
}
- model = efl_add_ref(EFL_MODEL_COMPOSITE_SELECTION_CLASS, efl_main_loop_get(),
+ model = efl_add_ref(EFL_SELECT_MODEL_CLASS, efl_main_loop_get(),
efl_ui_view_model_set(efl_added, base_model));
ck_assert(!!model);
future = efl_model_property_set(model, "child.selected", eina_value_int_new(2));
EFL_END_TEST
void
-efl_test_case_model_composite_boolean(TCase *tc)
+efl_test_case_boolean_model(TCase *tc)
{
- tcase_add_test(tc, efl_test_model_composite_boolean);
- tcase_add_test(tc, efl_test_model_composite_selection);
+ tcase_add_test(tc, efl_test_boolean_model);
+ tcase_add_test(tc, efl_test_select_model);
}
return v;
}
-EFL_START_TEST(efl_test_model_container_values)
+EFL_START_TEST(efl_test_container_model_values)
{
- Efl_Model_Container* model;
+ Efl_Container_Model* model;
Eina_Future *future;
int **cmp_int;
const char **cmp_str;
cmp_str[i] = strdup(base_str[i]);
}
- model = efl_add_ref(EFL_MODEL_CONTAINER_CLASS, NULL);
+ model = efl_add_ref(EFL_CONTAINER_MODEL_CLASS, NULL);
- efl_model_container_child_property_add(model, "test_p_int", EINA_VALUE_TYPE_INT,
+ efl_container_model_child_property_add(model, "test_p_int", EINA_VALUE_TYPE_INT,
eina_carray_iterator_new((void**)cmp_int));
- efl_model_container_child_property_add(model, "test_p_str", EINA_VALUE_TYPE_STRING,
+ efl_container_model_child_property_add(model, "test_p_str", EINA_VALUE_TYPE_STRING,
eina_carray_iterator_new((void**)cmp_str));
for (i = 0; i < 7; ++i)
void
-efl_test_case_model_container(TCase *tc)
+efl_test_case_container_model(TCase *tc)
{
- tcase_add_test(tc, efl_test_model_container_values);
+ tcase_add_test(tc, efl_test_container_model_values);
}
static const int child_number = 3;
static const int base_ints[] = { 41, 42, 43 };
-static const char *_efl_test_model_view_label_format = "Index %i.";
+static const char *_efl_test_view_model_label_format = "Index %i.";
static const char *dependences[] = { "test_p_int" };
static Eina_Value *
-_efl_test_model_view_label_get(void *data, const Efl_Model_View *mv, Eina_Stringshare *property)
+_efl_test_view_model_label_get(void *data, const Efl_View_Model *mv, Eina_Stringshare *property)
{
Eina_Strbuf *buf;
Eina_Value *r;
}
static Eina_Future *
-_efl_test_model_view_label_set(void *data EINA_UNUSED, Efl_Model_View *mv, Eina_Stringshare *property EINA_UNUSED, Eina_Value *value EINA_UNUSED)
+_efl_test_view_model_label_set(void *data EINA_UNUSED, Efl_View_Model *mv, Eina_Stringshare *property EINA_UNUSED, Eina_Value *value EINA_UNUSED)
{
return efl_loop_future_rejected(mv, EFL_MODEL_ERROR_READ_ONLY);
}
static void
-_efl_test_model_view_label_clean(void *data)
+_efl_test_view_model_label_clean(void *data)
{
- ck_assert_ptr_eq(data, _efl_test_model_view_label_format);
+ ck_assert_ptr_eq(data, _efl_test_view_model_label_format);
}
static Eina_Value *
-_efl_test_model_view_color_get(void *data EINA_UNUSED, const Efl_Model_View *mv, Eina_Stringshare *property)
+_efl_test_view_model_color_get(void *data EINA_UNUSED, const Efl_View_Model *mv, Eina_Stringshare *property)
{
Eina_Strbuf *buf;
Eina_Value *r;
}
static Eina_Future *
-_efl_test_model_view_color_set(void *data EINA_UNUSED, Efl_Model_View *mv, Eina_Stringshare *property EINA_UNUSED, Eina_Value *value EINA_UNUSED)
+_efl_test_view_model_color_set(void *data EINA_UNUSED, Efl_View_Model *mv, Eina_Stringshare *property EINA_UNUSED, Eina_Value *value EINA_UNUSED)
{
return efl_loop_future_rejected(mv, EFL_MODEL_ERROR_READ_ONLY);
}
static void
-_efl_test_model_view_color_clean(void *data EINA_UNUSED)
+_efl_test_view_model_color_clean(void *data EINA_UNUSED)
{
}
}
static Eina_Value
-_efl_test_model_view_child_get(Eo *obj EINA_UNUSED,
+_efl_test_view_model_child_get(Eo *obj EINA_UNUSED,
void *data EINA_UNUSED,
const Eina_Value v)
{
}
static Eina_Value
-_efl_test_model_view_child_fetch(Eo *mv,
+_efl_test_view_model_child_fetch(Eo *mv,
void *data EINA_UNUSED,
const Eina_Value v EINA_UNUSED)
{
}
static Eina_Value
-_efl_test_model_view_child_updated_get(Eo *obj EINA_UNUSED,
+_efl_test_view_model_child_updated_get(Eo *obj EINA_UNUSED,
void *data EINA_UNUSED,
const Eina_Value v)
{
}
static Eina_Value
-_efl_test_model_view_tests_end(Eo *obj,
+_efl_test_view_model_tests_end(Eo *obj,
void *data EINA_UNUSED,
const Eina_Value v)
{
return v;
}
-EFL_START_TEST(efl_test_model_view)
+EFL_START_TEST(efl_test_view_model)
{
- Efl_Model_Item *base_model, *child, *mv;
+ Efl_Generic_Model *base_model, *child, *mv;
Eina_Future *f;
int i;
Eina_Value v;
- base_model = efl_add_ref(EFL_MODEL_ITEM_CLASS, efl_main_loop_get());
+ base_model = efl_add_ref(EFL_GENERIC_MODEL_CLASS, efl_main_loop_get());
ck_assert(!!base_model);
for (i = 0; i < child_number; ++i)
efl_model_property_set(child, "test_p_int", &v);
}
- mv = efl_add_ref(EFL_MODEL_VIEW_CLASS, efl_main_loop_get(),
+ mv = efl_add_ref(EFL_VIEW_MODEL_CLASS, efl_main_loop_get(),
efl_ui_view_model_set(efl_added, base_model));
ck_assert(!!mv);
- efl_model_view_property_logic_add(mv, "label",
- (void*) _efl_test_model_view_label_format, _efl_test_model_view_label_get, _efl_test_model_view_label_clean,
- (void*) _efl_test_model_view_label_format, _efl_test_model_view_label_set, _efl_test_model_view_label_clean,
+ efl_view_model_property_logic_add(mv, "label",
+ (void*) _efl_test_view_model_label_format, _efl_test_view_model_label_get, _efl_test_view_model_label_clean,
+ (void*) _efl_test_view_model_label_format, _efl_test_view_model_label_set, _efl_test_view_model_label_clean,
EINA_C_ARRAY_ITERATOR_NEW(dependences));
- efl_model_view_property_logic_add(mv, "color",
- NULL, _efl_test_model_view_color_get, _efl_test_model_view_color_clean,
- NULL, _efl_test_model_view_color_set, _efl_test_model_view_color_clean,
+ efl_view_model_property_logic_add(mv, "color",
+ NULL, _efl_test_view_model_color_get, _efl_test_view_model_color_clean,
+ NULL, _efl_test_view_model_color_set, _efl_test_view_model_color_clean,
EINA_C_ARRAY_ITERATOR_NEW(dependences));
- efl_model_view_property_logic_add(mv, "deadend",
+ efl_view_model_property_logic_add(mv, "deadend",
NULL, NULL, NULL,
NULL, NULL, NULL,
NULL);
f = efl_model_children_slice_get(mv, 0, efl_model_children_count_get(mv));
f = efl_future_then(mv, f, .success_type = EINA_VALUE_TYPE_ARRAY,
- .success = _efl_test_model_view_child_get);
- f = efl_future_then(mv, f, .success = _efl_test_model_view_child_fetch);
+ .success = _efl_test_view_model_child_get);
+ f = efl_future_then(mv, f, .success = _efl_test_view_model_child_fetch);
f = efl_future_then(mv, f, .success_type = EINA_VALUE_TYPE_ARRAY,
- .success = _efl_test_model_view_child_updated_get);
+ .success = _efl_test_view_model_child_updated_get);
f = efl_future_then(mv, f, .success_type = EINA_VALUE_TYPE_INT,
- .success = _efl_test_model_view_tests_end);
+ .success = _efl_test_view_model_tests_end);
// And run !
ecore_main_loop_begin();
EFL_END_TEST
void
-efl_test_case_model_view(TCase *tc)
+efl_test_case_view_model(TCase *tc)
{
- tcase_add_test(tc, efl_test_model_view);
+ tcase_add_test(tc, efl_test_view_model);
}
efl_suite_src = [
'efl_suite.c',
'efl_suite.h',
- 'efl_test_model_composite.c',
- 'efl_test_model_container.c',
- 'efl_test_model_view.c'
+ 'efl_test_composite_model.c',
+ 'efl_test_container_model.c',
+ 'efl_test_view_model.c'
]
efl_suite_bin = executable('efl_suite',
{ EFL_MODEL_EVENT_PROPERTIES_CHANGED, _property_changed },
{ EFL_MODEL_EVENT_CHILD_ADDED, _child_added })
-EFL_START_TEST(eio_model_test_test_file)
+EFL_START_TEST(efl_io_model_test_test_file)
{
Eo *filemodel = NULL;
Eina_Value *result;
memset(&reqs, 0, sizeof(struct reqs_t));
- filemodel = efl_add(EIO_MODEL_CLASS, efl_main_loop_get(),
- eio_model_path_set(efl_added, EFL_MODEL_TEST_FILENAME_PATH));
+ filemodel = efl_add(EFL_IO_MODEL_CLASS, efl_main_loop_get(),
+ efl_io_model_path_set(efl_added, EFL_MODEL_TEST_FILENAME_PATH));
fail_if(!filemodel, "ERROR: Cannot init model!\n");
handler = ecore_event_handler_add(ECORE_EVENT_SIGNAL_EXIT, exit_func, NULL);
EFL_END_TEST
void
-eio_model_test_file(TCase *tc)
+efl_io_model_test_file(TCase *tc)
{
- tcase_add_test(tc, eio_model_test_test_file);
+ tcase_add_test(tc, efl_io_model_test_test_file);
}
eina_future_then(future, _children_get, event->object, NULL);
}
-EFL_START_TEST(eio_model_test_test_monitor_add)
+EFL_START_TEST(efl_io_model_test_test_monitor_add)
{
Eo *filemodel = NULL;
tmpdir = eina_environment_tmp_get();
- filemodel = efl_add(EIO_MODEL_CLASS,
+ filemodel = efl_add(EFL_IO_MODEL_CLASS,
efl_main_loop_get(),
- eio_model_path_set(efl_added, tmpdir));
+ efl_io_model_path_set(efl_added, tmpdir));
fail_if(!filemodel, "ERROR: Cannot init model!\n");
efl_event_callback_add(filemodel, EFL_MODEL_EVENT_CHILD_ADDED, &_children_added_cb, filemodel);
EFL_END_TEST
void
-eio_model_test_monitor_add(TCase *tc)
+efl_io_model_test_monitor_add(TCase *tc)
{
- tcase_add_test(tc, eio_model_test_test_monitor_add);
+ tcase_add_test(tc, efl_io_model_test_test_monitor_add);
}
{"Eio", eio_test_init},
{"Eio_Monitor", eio_test_monitor},
{"Eio_Sentry", eio_test_sentry},
- {"Eio Model", eio_model_test_file},
- {"Eio Model Monitor", eio_model_test_monitor_add},
+ {"Efl Io Model", efl_io_model_test_file},
+ {"Efl Io Model Monitor", efl_io_model_test_monitor_add},
{"Eio File", eio_test_file},
{"Eio Job", eio_test_job},
#ifdef XATTR_TEST_DIR
#include "../efl_check.h"
void eio_test_monitor(TCase *tc);
void eio_test_sentry(TCase *tc);
-void eio_model_test_file(TCase *tc);
-void eio_model_test_monitor_add(TCase *tc);
+void efl_io_model_test_file(TCase *tc);
+void efl_io_model_test_monitor_add(TCase *tc);
void eio_test_file(TCase *tc);
void eio_test_job(TCase *tc);
void eio_test_job_xattr(TCase *tc);
eio_suite_src = [
'eio_suite.c',
- 'eio_model_test_file.c',
- 'eio_model_test_monitor_add.c',
+ 'efl_io_model_test_file.c',
+ 'efl_io_model_test_monitor_add.c',
'eio_test_monitor.c',
'eio_test_sentry.c',
'eio_test_file.c',
#endif
#include "efl_ui_suite.h"
-#include "efl_ui_model_homogeneous.eo.h"
-#include "efl_ui_model_exact.eo.h"
-#include "efl_ui_model_average.eo.h"
+#include "efl_ui_homogeneous_model.eo.h"
+#include "efl_ui_exact_model.eo.h"
+#include "efl_ui_average_model.eo.h"
static const int child_number = 3;
static const int base_ints[] = { 41, 42, 43 };
static Efl_Model *
_generate_base_model(void)
{
- Efl_Model_Item *base_model, *child;
+ Efl_Generic_Model *base_model, *child;
Eina_Value v;
int i;
eina_value_setup(&v, EINA_VALUE_TYPE_INT);
- base_model = efl_add_ref(EFL_MODEL_ITEM_CLASS, efl_main_loop_get());
+ base_model = efl_add_ref(EFL_GENERIC_MODEL_CLASS, efl_main_loop_get());
ck_assert(!!base_model);
for (i = 0; i < child_number; ++i)
{
return eina_future_as_value(f);
}
-EFL_START_TEST(efl_ui_model_homogeneous_test)
+EFL_START_TEST(efl_ui_homogeneous_model_test)
{
- Efl_Model_Item *base_model, *model;
+ Efl_Generic_Model *base_model, *model;
Eina_Value *ret__;
Eina_Future *future;
int real__;
base_model = _generate_base_model();
- model = efl_add_ref(EFL_UI_MODEL_HOMOGENEOUS_CLASS, efl_main_loop_get(),
+ model = efl_add_ref(EFL_UI_HOMOGENEOUS_MODEL_CLASS, efl_main_loop_get(),
efl_ui_view_model_set(efl_added, base_model));
ck_assert(!!model);
return eina_future_as_value(f);
}
-EFL_START_TEST(efl_ui_model_exact_test)
+EFL_START_TEST(efl_ui_exact_model_test)
{
- Efl_Model_Item *base_model, *model;
+ Efl_Generic_Model *base_model, *model;
Eina_Future *future;
Eina_Value *ret__;
int real__;
base_model = _generate_base_model();
- model = efl_add_ref(EFL_UI_MODEL_EXACT_CLASS, efl_main_loop_get(),
+ model = efl_add_ref(EFL_UI_EXACT_MODEL_CLASS, efl_main_loop_get(),
efl_ui_view_model_set(efl_added, base_model));
ck_assert(!!model);
return eina_future_as_value(f);
}
-EFL_START_TEST(efl_ui_model_average_test)
+EFL_START_TEST(efl_ui_average_model_test)
{
- Efl_Model_Item *base_model, *model;
+ Efl_Generic_Model *base_model, *model;
Eina_Future *future;
Eina_Value *ret__;
int real__;
base_model = _generate_base_model();
- model = efl_add_ref(EFL_UI_MODEL_AVERAGE_CLASS, efl_main_loop_get(),
+ model = efl_add_ref(EFL_UI_AVERAGE_MODEL_CLASS, efl_main_loop_get(),
efl_ui_view_model_set(efl_added, base_model));
ck_assert(!!model);
expected_average[1] = ((base_ints[0] * 3 + base_ints[1] * 3) * 3) / 2;
expected_average[2] = base_ints[0] * 3 + base_ints[1] * 3 + base_ints[2] * 3;
- tcase_add_test(tc, efl_ui_model_homogeneous_test);
- tcase_add_test(tc, efl_ui_model_average_test);
- tcase_add_test(tc, efl_ui_model_exact_test);
+ tcase_add_test(tc, efl_ui_homogeneous_model_test);
+ tcase_add_test(tc, efl_ui_average_model_test);
+ tcase_add_test(tc, efl_ui_exact_model_test);
}
{
char buf[PATH_MAX];
Evas_Object *win, *ly;
- Efl_Model_Item *model;
+ Efl_Generic_Model *model;
Eina_Value v;
Eina_Future *f;
const char *part_text;
efl_file_set(ly, buf, "layout");
efl_gfx_entity_visible_set(ly, EINA_TRUE);
- model = efl_add(EFL_MODEL_ITEM_CLASS, win);
+ model = efl_add(EFL_GENERIC_MODEL_CLASS, win);
ck_assert(!!eina_value_setup(&v, EINA_VALUE_TYPE_STRING));
ck_assert(!!eina_value_set(&v, text_value));
f = efl_model_property_set(model, "text_property", &v);
projects / platform / upstream / efl.git / commitdiff