166 lines
4.9 KiB
C
166 lines
4.9 KiB
C
#ifdef HAVE_CONFIG_H
|
|
# include <config.h>
|
|
#endif
|
|
|
|
#include "Efl.h"
|
|
#include "Efl_MVVM_Common.h"
|
|
|
|
EAPI Eina_Error EFL_MODEL_ERROR_UNKNOWN = 0;
|
|
EAPI Eina_Error EFL_MODEL_ERROR_NOT_SUPPORTED = 0;
|
|
EAPI Eina_Error EFL_MODEL_ERROR_NOT_FOUND = 0;
|
|
EAPI Eina_Error EFL_MODEL_ERROR_READ_ONLY = 0;
|
|
EAPI Eina_Error EFL_MODEL_ERROR_INIT_FAILED = 0;
|
|
EAPI Eina_Error EFL_MODEL_ERROR_PERMISSION_DENIED = 0;
|
|
EAPI Eina_Error EFL_MODEL_ERROR_INCORRECT_VALUE = 0;
|
|
EAPI Eina_Error EFL_MODEL_ERROR_INVALID_OBJECT = 0;
|
|
|
|
EAPI Eina_Error EFL_FACTORY_ERROR_NOT_SUPPORTED = 0;
|
|
EAPI Eina_Error EFL_PROPERTY_ERROR_INVALID_KEY = 0;
|
|
|
|
static const char EFL_MODEL_ERROR_UNKNOWN_STR[] = "Unknown Error";
|
|
static const char EFL_MODEL_ERROR_NOT_SUPPORTED_STR[] = "Operation not supported";
|
|
static const char EFL_MODEL_ERROR_NOT_FOUND_STR[] = "Value not found";
|
|
static const char EFL_MODEL_ERROR_READ_ONLY_STR[] = "Value read only";
|
|
static const char EFL_MODEL_ERROR_INIT_FAILED_STR[] = "Init failed";
|
|
static const char EFL_MODEL_ERROR_PERMISSION_DENIED_STR[] = "Permission denied";
|
|
static const char EFL_MODEL_ERROR_INCORRECT_VALUE_STR[] = "Incorrect value";
|
|
static const char EFL_MODEL_ERROR_INVALID_OBJECT_STR[] = "Object is invalid";
|
|
|
|
static const char EFL_FACTORY_ERROR_NOT_SUPPORTED_STR[] = "Operation not supported";
|
|
|
|
static const char EFL_PROPERTY_ERROR_INVALID_KEY_STR[] = "Incorrect key provided";
|
|
|
|
|
|
EAPI int
|
|
efl_model_init(void)
|
|
{
|
|
#define _ERROR(Name) EFL_MODEL_ERROR_##Name = eina_error_msg_static_register(EFL_MODEL_ERROR_##Name##_STR);
|
|
_ERROR(INCORRECT_VALUE);
|
|
_ERROR(UNKNOWN);
|
|
_ERROR(NOT_SUPPORTED);
|
|
_ERROR(NOT_FOUND);
|
|
_ERROR(READ_ONLY);
|
|
_ERROR(INIT_FAILED);
|
|
_ERROR(PERMISSION_DENIED);
|
|
_ERROR(INVALID_OBJECT);
|
|
|
|
#undef _ERROR
|
|
#define _ERROR(Name) EFL_FACTORY_ERROR_##Name = eina_error_msg_static_register(EFL_FACTORY_ERROR_##Name##_STR);
|
|
_ERROR(NOT_SUPPORTED);
|
|
|
|
#undef _ERROR
|
|
#define _ERROR(Name) EFL_PROPERTY_ERROR_##Name = eina_error_msg_static_register(EFL_PROPERTY_ERROR_##Name##_STR);
|
|
_ERROR(INVALID_KEY);
|
|
|
|
return EINA_TRUE;
|
|
}
|
|
|
|
#undef _ERROR
|
|
|
|
EAPI void
|
|
_efl_model_properties_changed_internal(const Efl_Model *model, ...)
|
|
{
|
|
Efl_Model_Property_Event ev = { 0 };
|
|
Eina_Array *properties = eina_array_new(1);
|
|
Eina_Stringshare *sp;
|
|
const char *property;
|
|
va_list args;
|
|
|
|
va_start(args, model);
|
|
|
|
while ((property = (const char*) va_arg(args, const char*)))
|
|
{
|
|
eina_array_push(properties, eina_stringshare_add(property));
|
|
}
|
|
|
|
va_end(args);
|
|
|
|
ev.changed_properties = properties;
|
|
|
|
efl_event_callback_call((Efl_Model *) model, EFL_MODEL_EVENT_PROPERTIES_CHANGED, &ev);
|
|
|
|
while ((sp = eina_array_pop(properties)))
|
|
eina_stringshare_del(sp);
|
|
eina_array_free(properties);
|
|
}
|
|
|
|
EAPI void
|
|
efl_model_property_invalidated_notify(Efl_Model *model, const char *property)
|
|
{
|
|
Eina_Array *invalidated_properties = eina_array_new(1);
|
|
EINA_SAFETY_ON_NULL_RETURN(invalidated_properties);
|
|
|
|
Eina_Stringshare *sp = eina_stringshare_add(property);
|
|
|
|
Eina_Bool ret = eina_array_push(invalidated_properties, sp);
|
|
EINA_SAFETY_ON_FALSE_GOTO(ret, on_error);
|
|
|
|
Efl_Model_Property_Event evt = {.invalidated_properties = invalidated_properties};
|
|
efl_event_callback_call(model, EFL_MODEL_EVENT_PROPERTIES_CHANGED, &evt);
|
|
|
|
on_error:
|
|
eina_stringshare_del(sp);
|
|
eina_array_free(invalidated_properties);
|
|
}
|
|
|
|
typedef struct _Efl_Model_Value_Struct_Desc Efl_Model_Value_Struct_Desc;
|
|
|
|
struct _Efl_Model_Value_Struct_Desc
|
|
{
|
|
Eina_Value_Struct_Desc base;
|
|
void *data;
|
|
Eina_Value_Struct_Member members[];
|
|
};
|
|
|
|
EAPI Eina_Value_Struct_Desc *
|
|
efl_model_value_struct_description_new(unsigned int member_count, Efl_Model_Value_Struct_Member_Setup_Cb setup_cb, void *data)
|
|
{
|
|
Efl_Model_Value_Struct_Desc *desc;
|
|
unsigned int offset = 0;
|
|
size_t i;
|
|
|
|
EINA_SAFETY_ON_FALSE_RETURN_VAL(member_count > 0, NULL);
|
|
EINA_SAFETY_ON_NULL_RETURN_VAL(setup_cb, NULL);
|
|
EINA_SAFETY_ON_NULL_RETURN_VAL(data, NULL);
|
|
|
|
desc = malloc(sizeof(Efl_Model_Value_Struct_Desc) + member_count * sizeof(Eina_Value_Struct_Member));
|
|
EINA_SAFETY_ON_NULL_RETURN_VAL(desc, NULL);
|
|
|
|
desc->base.version = EINA_VALUE_STRUCT_DESC_VERSION;
|
|
desc->base.ops = EINA_VALUE_STRUCT_OPERATIONS_STRINGSHARE;
|
|
desc->base.members = desc->members;
|
|
desc->base.member_count = member_count;
|
|
desc->base.size = 0;
|
|
desc->data = data;
|
|
|
|
for (i = 0; i < member_count; ++i)
|
|
{
|
|
Eina_Value_Struct_Member *m = (Eina_Value_Struct_Member *)desc->members + i;
|
|
unsigned int size;
|
|
|
|
m->offset = offset;
|
|
setup_cb(data, i, m);
|
|
|
|
size = m->type->value_size;
|
|
if (size % sizeof(void *) != 0)
|
|
size += size - (size % sizeof(void *));
|
|
|
|
offset += size;
|
|
}
|
|
|
|
desc->base.size = offset;
|
|
return &desc->base;
|
|
}
|
|
|
|
EAPI void
|
|
efl_model_value_struct_description_free(Eina_Value_Struct_Desc *desc)
|
|
{
|
|
size_t i;
|
|
|
|
if (!desc) return;
|
|
|
|
for (i = 0; i < desc->member_count; i++)
|
|
eina_stringshare_del(desc->members[i].name);
|
|
free(desc);
|
|
}
|