aboutsummaryrefslogtreecommitdiffstats
path: root/src/lib/ecore/efl_model_composite_boolean.c
diff options
context:
space:
mode:
authorFelipe Magno de Almeida <felipe@expertisesolutions.com.br>2016-06-20 18:50:38 -0300
committerCedric BAIL <cedric@osg.samsung.com>2017-02-06 15:26:27 -0800
commit80540379925fefbbfcb7a305a69d123152bfe627 (patch)
tree6cf9c78e4bcfd663d08de17d12e77946e91da76e /src/lib/ecore/efl_model_composite_boolean.c
parentefl: add efl_model and efl_ui_view classes (diff)
downloadefl-80540379925fefbbfcb7a305a69d123152bfe627.tar.gz
efl: add composite model for boolean properties
Add Efl.Model.Composite.Boolean, a model for wrapping another Efl.Model and adding boolean properties to its children. Children of the given composite model will have the boolean properties specified in Efl.Model.Composite.Boolean with the specified default value. A call to Efl.Model.Property_set can change the property value for a child. Signed-off-by: Cedric BAIL <cedric@osg.samsung.com>
Diffstat (limited to '')
-rw-r--r--src/lib/ecore/efl_model_composite_boolean.c642
1 files changed, 642 insertions, 0 deletions
diff --git a/src/lib/ecore/efl_model_composite_boolean.c b/src/lib/ecore/efl_model_composite_boolean.c
new file mode 100644
index 0000000000..7ec344d05c
--- /dev/null
+++ b/src/lib/ecore/efl_model_composite_boolean.c
@@ -0,0 +1,642 @@
+#ifdef HAVE_CONFIG_H
+# include <config.h>
+#endif
+
+#include "Eina.h"
+#include "Efl.h"
+#include <Ecore.h>
+
+#include "efl_model_composite_boolean_children.eo.h"
+
+typedef struct _Efl_Model_Hash_Value
+{
+ unsigned char *buffer;
+ unsigned int bits_count;
+ Eina_Bool default_value : 1;
+} Efl_Model_Hash_Value;
+
+typedef struct _Efl_Model_Composite_Boolean_Data
+{
+ Efl_Model *composite_model;
+ Eina_Array *bool_children_cache;
+ Eina_Array *empty_properties;
+ Eina_Hash *values; // [property_name, Efl_Model_Hash_Value*]
+} Efl_Model_Composite_Boolean_Data;
+
+typedef struct _Efl_Model_Composite_Boolean_Children_Data
+{
+ Efl_Model_Composite_Boolean_Data *parent_pd;
+ Efl_Model *composite_child;
+ Eina_Array *properties_names;
+ unsigned int index;
+} Efl_Model_Composite_Boolean_Children_Data;
+
+typedef struct _Efl_Model_Accessor_Slice
+{
+ Eina_Accessor vtable;
+ Eina_Accessor *real_accessor;
+ Efl_Model *parent;
+ Efl_Model_Composite_Boolean_Data *parent_pd;
+ Efl_Promise *promise;
+ unsigned int index;
+} Efl_Model_Accessor_Slice;
+
+static Eina_Value *
+_value_clone(const Eina_Value *value)
+{
+ Eina_Value *copy = eina_value_new(eina_value_type_get(value));
+ eina_value_copy(value, copy);
+ return copy;
+}
+
+static void
+_future_forward_cb(void *data, Efl_Event const *event)
+{
+ efl_promise_value_set(
+ data, _value_clone(((Efl_Future_Event_Success*)event->info)->value), (Eina_Free_Cb)eina_value_free);
+}
+
+static void
+_future_error_forward_cb(void *data, Efl_Event const *event)
+{
+ Eina_Error err = ((Efl_Future_Event_Failure*)event->info)->error;
+ efl_promise_failed_set(data, err);
+}
+
+static Eina_Bool
+_bit_get(const unsigned char *bitstream, unsigned int idx)
+{
+ return (bitstream[idx / 8] >> (idx % 8)) & 1u;
+}
+
+static void
+_bit_set(unsigned char *bitstream, unsigned int idx, Eina_Bool v)
+{
+ if (v)
+ bitstream[idx / 8] |= 1u << (idx % 8);
+ else
+ bitstream[idx / 8] &= ~(1u << (idx % 8));
+}
+
+/**************** efl_mmodel_composite_boolean_children **************/
+
+static void
+_properties_names_array_free(Eina_Array *properties_names)
+{
+ Eina_Array_Iterator it;
+ void *name;
+ unsigned int i;
+
+ EINA_ARRAY_ITER_NEXT(properties_names, i, name, it)
+ free(name);
+
+ eina_array_free(properties_names);
+}
+
+
+static void
+_efl_model_composite_boolean_children_efl_object_destructor(Eo *obj,
+ Efl_Model_Composite_Boolean_Children_Data *pd)
+{
+ if (pd->properties_names)
+ _properties_names_array_free(pd->properties_names);
+
+ if (pd->composite_child)
+ efl_unref(pd->composite_child);
+
+ efl_destructor(efl_super(obj, EFL_MODEL_COMPOSITE_BOOLEAN_CHILDREN_CLASS));
+}
+
+static Eina_Bool
+_properties_names_push(const Eina_Hash *hash EINA_UNUSED,
+ const void *key, void *data EINA_UNUSED, void *fdata)
+{
+ eina_array_push(fdata, key);
+ return EINA_TRUE;
+}
+
+static const Eina_Array*
+_efl_model_composite_boolean_children_efl_model_properties_get(Eo *obj EINA_UNUSED,
+ Efl_Model_Composite_Boolean_Children_Data *pd)
+{
+ Eina_Array const *composite_properties;
+ unsigned int composite_count, self_count, i;
+
+ if (pd->properties_names)
+ {
+ _properties_names_array_free(pd->properties_names);
+ pd->properties_names = NULL;
+ }
+
+ composite_properties = efl_model_properties_get(pd->composite_child);
+ if (!composite_properties)
+ return pd->properties_names = eina_array_new(1);
+
+ composite_count = eina_array_count_get(composite_properties);
+ self_count = eina_hash_population(pd->parent_pd->values);
+
+ pd->properties_names = eina_array_new(composite_count + self_count);
+ for (i = 0; i != composite_count; ++i)
+ {
+ const char *name = strdup(eina_array_data_get(composite_properties, i));
+ eina_array_push(pd->properties_names, name);
+ }
+
+ eina_hash_foreach(pd->parent_pd->values, _properties_names_push, pd->properties_names);
+
+ return pd->properties_names;
+}
+
+static Efl_Future *
+_efl_model_composite_boolean_children_efl_model_property_get(Eo *obj EINA_UNUSED,
+ Efl_Model_Composite_Boolean_Children_Data *pd, const char *property)
+{
+ Efl_Model_Hash_Value *hv = eina_hash_find(pd->parent_pd->values, property);
+ if (hv)
+ {
+ Efl_Promise *promise = efl_add(EFL_PROMISE_CLASS, ecore_main_loop_get());
+ Efl_Future *rfuture = efl_promise_future_get(promise);
+
+ Eina_Value *eina_value = eina_value_new(EINA_VALUE_TYPE_UCHAR);
+ if (hv->bits_count <= pd->index)
+ {
+ unsigned char f = hv->default_value;
+ eina_value_set(eina_value, f);
+ }
+ else
+ {
+ eina_value_set(eina_value, _bit_get(hv->buffer, pd->index));
+ }
+ efl_promise_value_set(promise, eina_value, (Eina_Free_Cb)eina_value_free);
+ return rfuture;
+ }
+ else if (pd->composite_child)
+ return efl_model_property_get(pd->composite_child, property);
+ else
+ {
+ Efl_Promise *promise = efl_add(EFL_PROMISE_CLASS, ecore_main_loop_get());
+ Efl_Future *rfuture = efl_promise_future_get(promise);
+
+ efl_promise_failed_set(promise, EFL_MODEL_ERROR_NOT_FOUND);
+ return rfuture;
+ }
+}
+
+static Efl_Future *
+_efl_model_composite_boolean_children_efl_model_property_set(Eo *obj EINA_UNUSED,
+ Efl_Model_Composite_Boolean_Children_Data *pd, const char *property, const Eina_Value *value)
+{
+ Efl_Promise *promise = efl_add(EFL_PROMISE_CLASS, ecore_main_loop_get());
+ Efl_Future *rfuture = efl_promise_future_get(promise);
+
+ Efl_Model_Hash_Value *hv = eina_hash_find(pd->parent_pd->values, property);
+ if (hv)
+ {
+ Eina_Bool flag = EINA_FALSE;
+
+ if (eina_value_type_get(value) == EINA_VALUE_TYPE_UCHAR)
+ {
+ efl_promise_failed_set(promise, EFL_MODEL_ERROR_INCORRECT_VALUE);
+ return rfuture;
+ }
+ if (!eina_value_get(value, &flag))
+ {
+ efl_promise_failed_set(promise, EFL_MODEL_ERROR_UNKNOWN);
+ return rfuture;
+ }
+
+ if (pd->index >= hv->bits_count)
+ {
+ unsigned int bytes = (pd->index / 8) + 1;
+ unsigned int buff_size = (hv->bits_count / 8) + (hv->bits_count % 8 ? 1 : 0);
+ unsigned char *buff = realloc(hv->buffer, bytes);
+ if (!buff)
+ {
+ efl_promise_failed_set(promise, EFL_MODEL_ERROR_UNKNOWN);
+ return rfuture;
+ }
+ memset(
+ buff + buff_size,
+ hv->default_value ? -1 : 0,
+ bytes - buff_size);
+
+ hv->buffer = buff;
+ hv->bits_count = bytes * 8;
+ }
+
+ _bit_set(hv->buffer, pd->index, flag);
+
+ efl_promise_value_set(
+ promise, _value_clone(value), (Eina_Free_Cb)eina_value_free);
+ }
+ else if (pd->composite_child)
+ {
+ Efl_Future *f_forward = efl_model_property_set(pd->composite_child, property, value);
+ efl_future_then(f_forward, _future_forward_cb, _future_error_forward_cb, NULL, promise);
+ }
+ else
+ {
+ efl_promise_failed_set(promise, EFL_MODEL_ERROR_NOT_FOUND);
+ }
+
+ return rfuture;
+}
+
+static Efl_Future*
+_efl_model_composite_boolean_children_efl_model_children_slice_get(Eo *obj EINA_UNUSED,
+ Efl_Model_Composite_Boolean_Children_Data *pd, unsigned int start, unsigned int count)
+{
+ return efl_model_children_slice_get(pd->composite_child, start, count);
+}
+
+static Efl_Future*
+_efl_model_composite_boolean_children_efl_model_children_count_get(Eo *obj EINA_UNUSED,
+ Efl_Model_Composite_Boolean_Children_Data *pd)
+{
+ return efl_model_children_count_get(pd->composite_child);
+}
+
+static Efl_Object*
+_efl_model_composite_boolean_children_efl_model_child_add(Eo *obj EINA_UNUSED,
+ Efl_Model_Composite_Boolean_Children_Data *pd)
+{
+ return efl_model_child_add(pd->composite_child);
+}
+
+static void
+_efl_model_composite_boolean_children_efl_model_child_del(Eo *obj EINA_UNUSED,
+ Efl_Model_Composite_Boolean_Children_Data *pd, Efl_Object *child)
+{
+ efl_model_child_del(pd->composite_child, child);
+}
+
+/**************** efl_model_accessor_slice **************/
+
+static void
+_bool_children_cache_array_free(Eina_Array *children_cache)
+{
+ int i, count = eina_array_count_get(children_cache);
+ for (i = 0; i < count; ++i)
+ efl_unref(eina_array_data_get(children_cache, i));
+ eina_array_free(children_cache);
+}
+
+static Eina_Bool
+efl_model_acessor_slice_get_at(Efl_Model_Accessor_Slice *acc, unsigned int idx, void **data)
+{
+ Efl_Model *child_bool;
+ Eina_Array *children_cache = acc->parent_pd->bool_children_cache;
+
+ /* NOTE: Efl.Model.Composite.Boolean must alloc the cache with the correct size
+ and NULL initialized. */
+ if (idx >= eina_array_count(children_cache))
+ {
+ EINA_LOG_WARN("Index bigger than size");
+ return EINA_FALSE;
+ }
+
+ child_bool = eina_array_data_get(children_cache, idx);
+
+ if (!child_bool)
+ {
+ Efl_Model *child = NULL;
+
+ if (!eina_accessor_data_get(acc->real_accessor, idx, (void *)&child))
+ return EINA_FALSE;
+
+ if (child)
+ {
+ Efl_Model_Composite_Boolean_Children_Data *pd;
+ child_bool = efl_add(EFL_MODEL_COMPOSITE_BOOLEAN_CHILDREN_CLASS, NULL);
+ pd = efl_data_scope_get(child_bool, EFL_MODEL_COMPOSITE_BOOLEAN_CHILDREN_CLASS);
+
+ pd->parent_pd = acc->parent_pd;
+ pd->composite_child = efl_ref(child);
+ pd->index = acc->index++;
+
+ eina_array_data_set(children_cache, idx, child_bool);
+ }
+ }
+
+ if (data) *data = child_bool;
+ return EINA_TRUE;
+}
+
+static void *
+efl_model_acessor_slice_get_container(Efl_Model_Accessor_Slice *acc)
+{
+ return eina_accessor_container_get(acc->real_accessor);
+}
+
+static void
+efl_model_acessor_slice_free(Efl_Model_Accessor_Slice *acc)
+{
+ if (acc->real_accessor)
+ {
+ eina_accessor_free(acc->real_accessor);
+ acc->real_accessor = NULL;
+ }
+
+ if (acc->parent)
+ {
+ efl_unref(acc->parent);
+ acc->parent = NULL;
+ }
+
+ acc->parent_pd = NULL;
+ acc->promise = NULL;
+
+ free(acc);
+}
+
+static Eina_Bool
+efl_model_acessor_slice_lock(Efl_Model_Accessor_Slice *acc)
+{
+ return eina_accessor_lock(acc->real_accessor);
+}
+
+static Eina_Bool
+efl_model_acessor_slice_unlock(Efl_Model_Accessor_Slice *acc)
+{
+ return eina_accessor_unlock(acc->real_accessor);
+}
+
+static Efl_Model_Accessor_Slice *
+efl_model_acessor_slice_clone(Efl_Model_Accessor_Slice *acc EINA_UNUSED)
+{
+ return NULL;
+}
+
+static void
+efl_model_accessor_slice_setup(Efl_Model_Accessor_Slice *acc,
+ Efl_Model *parent, Efl_Model_Composite_Boolean_Data *parent_pd, Efl_Promise *promise)
+{
+ acc->vtable.version = EINA_ACCESSOR_VERSION;
+ acc->vtable.get_at = FUNC_ACCESSOR_GET_AT(efl_model_acessor_slice_get_at);
+ acc->vtable.get_container = FUNC_ACCESSOR_GET_CONTAINER(efl_model_acessor_slice_get_container);
+ acc->vtable.free = FUNC_ACCESSOR_FREE(efl_model_acessor_slice_free);
+
+ acc->vtable.lock = FUNC_ACCESSOR_LOCK(efl_model_acessor_slice_lock);
+ acc->vtable.unlock = FUNC_ACCESSOR_LOCK(efl_model_acessor_slice_unlock);
+
+ acc->vtable.clone = FUNC_ACCESSOR_CLONE(efl_model_acessor_slice_clone);
+
+ EINA_MAGIC_SET(&acc->vtable, EINA_MAGIC_ACCESSOR);
+
+ acc->parent = efl_ref(parent);
+ acc->parent_pd = parent_pd;
+ acc->promise = promise;
+}
+
+static void
+_efl_model_composite_boolean_slice_then_cb(void *data, Efl_Event const *event)
+{
+ Efl_Model_Accessor_Slice *slice_acc = data;
+ Eina_Accessor *value_itt = (Eina_Accessor *)((Efl_Future_Event_Success*)event->info)->value;
+ unsigned int *children_count = NULL;
+ Eina_Accessor *children_accessor = NULL;
+
+ if (!eina_accessor_data_get(value_itt, 0, (void**)&children_count) ||
+ !children_count ||
+ !eina_accessor_data_get(value_itt, 1, (void**)&children_accessor) ||
+ !children_accessor)
+ {
+ EINA_LOG_WARN("missing Efl.Model information");
+ efl_promise_failed_set(slice_acc->promise, EFL_MODEL_ERROR_UNKNOWN);
+ efl_model_acessor_slice_free(slice_acc);
+ return;
+ }
+
+ slice_acc->real_accessor = eina_accessor_clone(children_accessor);
+ if (slice_acc->real_accessor)
+ {
+ Eina_Array *children_cache;
+ unsigned int i;
+
+ if (slice_acc->parent_pd->bool_children_cache)
+ _bool_children_cache_array_free(slice_acc->parent_pd->bool_children_cache);
+
+ children_cache = eina_array_new(*children_count);
+ for (i = 0 ; i < *children_count; ++i)
+ {
+ // NOTE: eina_array_push do not accept NULL
+ eina_array_push(children_cache, (void*)0x01);
+ eina_array_data_set(children_cache, i, NULL);
+ }
+
+ slice_acc->parent_pd->bool_children_cache = children_cache;
+
+ efl_promise_value_set(slice_acc->promise, slice_acc, (Eina_Free_Cb)&eina_accessor_free);
+ }
+ else
+ {
+ efl_promise_failed_set(slice_acc->promise, EFL_MODEL_ERROR_NOT_SUPPORTED);
+ efl_model_acessor_slice_free(slice_acc);
+ }
+}
+
+static void
+_efl_model_composite_boolean_slice_error_cb(void *data, Efl_Event const*event)
+{
+ Efl_Model_Accessor_Slice *slice_acc = data;
+ Eina_Error error = ((Efl_Future_Event_Failure*)event->info)->error;
+ efl_promise_failed_set(slice_acc->promise, error);
+ efl_model_acessor_slice_free(slice_acc);
+}
+
+/**************** efl_mmodel_composite_boolean **************/
+
+static void
+efl_model_hash_value_free(void *p)
+{
+ Efl_Model_Hash_Value *value = p;
+ if (value)
+ {
+ free(value->buffer);
+ free(value);
+ }
+}
+
+static void
+_composite_model_data_reset(Efl_Model_Composite_Boolean_Data *pd)
+{
+ if (pd->bool_children_cache)
+ {
+ _bool_children_cache_array_free(pd->bool_children_cache);
+ pd->bool_children_cache = NULL;
+ }
+
+ if (pd->composite_model)
+ {
+ efl_unref(pd->composite_model);
+ pd->composite_model = NULL;
+ }
+}
+
+static void
+_efl_model_composite_boolean_efl_object_destructor(Eo *obj, Efl_Model_Composite_Boolean_Data *pd)
+{
+ if (pd->empty_properties)
+ {
+ eina_array_free(pd->empty_properties);
+ pd->empty_properties = NULL;
+ }
+
+ if (pd->values)
+ {
+ eina_hash_free(pd->values);
+ pd->values = NULL;
+ }
+
+ _composite_model_data_reset(pd);
+
+ efl_destructor(efl_super(obj, EFL_MODEL_COMPOSITE_BOOLEAN_CLASS));
+}
+
+static void
+_efl_model_composite_boolean_composite_model_set(Eo *obj EINA_UNUSED,
+ Efl_Model_Composite_Boolean_Data *pd, Efl_Model *model)
+{
+ if (pd->composite_model)
+ {
+ _composite_model_data_reset(pd);
+ }
+
+ pd->composite_model = efl_ref(model);
+}
+
+static Efl_Model *
+_efl_model_composite_boolean_composite_model_get(Eo *obj EINA_UNUSED, Efl_Model_Composite_Boolean_Data *pd)
+{
+ return pd->composite_model;
+}
+
+static void
+_efl_model_composite_boolean_property_add(Eo *obj EINA_UNUSED, Efl_Model_Composite_Boolean_Data *pd,
+ const char *name, Eina_Bool initial_value)
+{
+ if (!pd->values)
+ pd->values = eina_hash_string_small_new(&efl_model_hash_value_free);
+ Efl_Model_Hash_Value *value = calloc(1, sizeof(Efl_Model_Hash_Value));
+ value->default_value = initial_value;
+ eina_hash_add(pd->values, name, value);
+}
+
+static const Eina_Array *
+_efl_model_composite_boolean_efl_model_properties_get(Eo *obj EINA_UNUSED, Efl_Model_Composite_Boolean_Data *pd)
+{
+ if (pd->composite_model)
+ return efl_model_properties_get(pd->composite_model);
+ else if (pd->empty_properties)
+ return pd->empty_properties;
+ else
+ return pd->empty_properties = eina_array_new(1);
+}
+
+Efl_Future *
+_efl_model_composite_boolean_efl_model_property_get(Eo *obj EINA_UNUSED,
+ Efl_Model_Composite_Boolean_Data *pd, const char *property)
+{
+ if (pd->composite_model)
+ return efl_model_property_get(pd->composite_model, property);
+
+ Efl_Promise *promise = efl_add(EFL_PROMISE_CLASS, ecore_main_loop_get());
+ Efl_Future *rfuture = efl_promise_future_get(promise);
+
+ efl_promise_failed_set(promise, EFL_MODEL_ERROR_NOT_FOUND);
+ return rfuture;
+}
+
+Efl_Future *
+_efl_model_composite_boolean_efl_model_property_set(Eo *obj EINA_UNUSED, Efl_Model_Composite_Boolean_Data *pd,
+ const char *property, const Eina_Value *value)
+{
+
+ Efl_Promise *promise = efl_add(EFL_PROMISE_CLASS, ecore_main_loop_get());
+ Efl_Future *rfuture = efl_promise_future_get(promise);
+
+ if (pd->composite_model)
+ {
+ Efl_Future *f_forward = efl_model_property_set(pd->composite_model, property, value);
+ efl_future_then(f_forward, _future_forward_cb, _future_error_forward_cb, NULL, promise);
+ }
+ else
+ {
+ efl_promise_failed_set(promise, EFL_MODEL_ERROR_NOT_FOUND);
+ }
+
+ return rfuture;
+}
+
+static Efl_Future *
+_efl_model_composite_boolean_efl_model_children_slice_get(Eo *obj, Efl_Model_Composite_Boolean_Data *pd, unsigned int start, unsigned int count)
+{
+ Efl_Promise *promise = efl_add(EFL_PROMISE_CLASS, ecore_main_loop_get());
+ Efl_Future *rfuture = efl_promise_future_get(promise);
+
+ if (pd->composite_model)
+ {
+ Efl_Model_Accessor_Slice *accessor;
+ Efl_Future *composite_future;
+ Efl_Future *futures[2] = {NULL,};
+
+ futures[0] = efl_model_children_count_get(pd->composite_model);
+ futures[1] = efl_model_children_slice_get(pd->composite_model, start, count);
+
+ composite_future = efl_future_all(futures[0], futures[1]);
+
+ accessor = calloc(1, sizeof(Efl_Model_Accessor_Slice));
+ efl_model_accessor_slice_setup(accessor, obj, pd, promise);
+
+ efl_future_then(composite_future, &_efl_model_composite_boolean_slice_then_cb,
+ &_efl_model_composite_boolean_slice_error_cb, NULL, accessor);
+ }
+ else
+ {
+ efl_promise_failed_set(promise, EFL_MODEL_ERROR_NOT_SUPPORTED);
+ }
+ return rfuture;
+}
+
+static Efl_Future *
+_efl_model_composite_boolean_efl_model_children_count_get(Eo *obj EINA_UNUSED, Efl_Model_Composite_Boolean_Data *pd)
+{
+ if (pd->composite_model)
+ return efl_model_children_count_get(pd->composite_model);
+ else
+ {
+ Efl_Promise *promise = efl_add(EFL_PROMISE_CLASS, ecore_main_loop_get());
+ Efl_Future *rfuture = efl_promise_future_get(promise);
+
+ unsigned int *count = malloc(sizeof(unsigned int));
+ *count = 0;
+ efl_promise_value_set(promise, count, free);
+ return rfuture;
+ }
+}
+
+static Efl_Object*
+_efl_model_composite_boolean_efl_model_child_add(Eo *obj EINA_UNUSED, Efl_Model_Composite_Boolean_Data *pd)
+{
+ if (pd->composite_model)
+ return efl_model_child_add(pd->composite_model);
+ else
+ {
+ eina_error_set(EFL_MODEL_ERROR_NOT_SUPPORTED);
+ return NULL;
+ }
+}
+
+static void
+_efl_model_composite_boolean_efl_model_child_del(Eo *obj EINA_UNUSED, Efl_Model_Composite_Boolean_Data *pd, Efl_Object *child)
+{
+ if (pd->composite_model)
+ return efl_model_child_del(pd->composite_model, child);
+ else
+ {
+ eina_error_set(EFL_MODEL_ERROR_NOT_SUPPORTED);
+ }
+}
+
+#include "efl_model_composite_boolean.eo.c"
+#include "efl_model_composite_boolean_children.eo.c"