kimcinoo
/
efl
forked from enlightenment/efl
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

emodel: api change property_get/set and event modelchange

This commit is contained in:
Larry Jr 2015-04-05 15:19:55 +02:00 committed by Cedric BAIL
parent 23cfd2b4f4
commit 2f53833331
7 changed files with 150 additions and 193 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

162
src/lib/eio/eio_model.c
View File

@ -17,7 +17,6 @@
#define MY_CLASS EIO_MODEL_CLASS #define MY_CLASS EIO_MODEL_CLASS
#define MY_CLASS_NAME "Eio_Model" #define MY_CLASS_NAME "Eio_Model"
static Eina_Value_Struct_Desc *EIO_MODEL_PROPERTIES_DESC = NULL;
static void _eio_prop_set_error_cb(void *, Eio_File *, int); static void _eio_prop_set_error_cb(void *, Eio_File *, int);
static void _eio_model_emodel_properties_load(Eo *, Eio_Model_Data *); static void _eio_model_emodel_properties_load(Eo *, Eio_Model_Data *);
static void _eio_model_emodel_children_load(Eo *, Eio_Model_Data *); static void _eio_model_emodel_children_load(Eo *, Eio_Model_Data *);
@ -66,31 +65,18 @@ _eio_stat_done_cb(void *data, Eio_File *handler EINA_UNUSED, const Eina_Stat *st
{ {
Emodel_Property_Event evt; Emodel_Property_Event evt;
Eio_Model_Data *priv = data; Eio_Model_Data *priv = data;
Eina_Bool changed = EINA_FALSE;
Eina_Value_Struct_Desc *desc = EIO_MODEL_PROPERTIES_DESC;
EINA_SAFETY_ON_FALSE_RETURN(eo_ref_get(priv->obj)); EINA_SAFETY_ON_FALSE_RETURN(eo_ref_get(priv->obj));
priv->stat = stat; priv->is_dir = eio_file_is_dir(stat);
memset(&evt, 0, sizeof(Emodel_Property_Event)); memset(&evt, 0, sizeof(Emodel_Property_Event));
changed |= eina_value_struct_set(priv->properties, eina_value_set(priv->properties_value[EIO_MODEL_PROP_IS_DIR], eio_file_is_dir(stat));
desc->members[EIO_MODEL_PROP_IS_DIR].name, eio_file_is_dir(stat)); eina_value_set(priv->properties_value[EIO_MODEL_PROP_IS_LNK], eio_file_is_lnk(stat));
eina_value_set(priv->properties_value[EIO_MODEL_PROP_MTIME], eio_file_mtime(stat));
eina_value_set(priv->properties_value[EIO_MODEL_PROP_SIZE], eio_file_size(stat));
changed |= eina_value_struct_set(priv->properties, evt.changed_properties = priv->properties_name;
desc->members[EIO_MODEL_PROP_IS_LNK].name, eio_file_is_lnk(stat));
changed |= eina_value_struct_set(priv->properties,
desc->members[EIO_MODEL_PROP_MTIME].name, eio_file_mtime(stat));
changed |= eina_value_struct_set(priv->properties,
desc->members[EIO_MODEL_PROP_SIZE].name, eio_file_size(stat));
if (changed == EINA_TRUE)
{
evt.changed_properties = priv->properties;
eo_do(priv->obj, eo_event_callback_call(EMODEL_EVENT_PROPERTIES_CHANGED, &evt)); eo_do(priv->obj, eo_event_callback_call(EMODEL_EVENT_PROPERTIES_CHANGED, &evt));
}
_load_set(priv, EMODEL_LOAD_STATUS_LOADED_PROPERTIES); _load_set(priv, EMODEL_LOAD_STATUS_LOADED_PROPERTIES);
@ -109,7 +95,7 @@ _eio_move_done_cb(void *data, Eio_File *handler EINA_UNUSED)
{ {
Emodel_Property_Event evt; Emodel_Property_Event evt;
Eio_Model_Data *priv = data; Eio_Model_Data *priv = data;
Eina_Value_Struct_Desc *desc = EIO_MODEL_PROPERTIES_DESC; Eina_Array *properties;
EINA_SAFETY_ON_FALSE_RETURN(eo_ref_get(priv->obj)); EINA_SAFETY_ON_FALSE_RETURN(eo_ref_get(priv->obj));
@ -119,11 +105,16 @@ _eio_move_done_cb(void *data, Eio_File *handler EINA_UNUSED)
* When mv is executed we update our values and * When mv is executed we update our values and
* notify both path and filename properties listeners. * notify both path and filename properties listeners.
*/ */
eina_value_struct_set(priv->properties, desc->members[EIO_MODEL_PROP_PATH].name, priv->path); eina_value_set(priv->properties_value[EIO_MODEL_PROP_PATH], priv->path);
eina_value_struct_set(priv->properties, desc->members[EIO_MODEL_PROP_FILENAME].name, basename(priv->path)); eina_value_set(priv->properties_value[EIO_MODEL_PROP_FILENAME], basename(priv->path));
evt.changed_properties = priv->properties;
properties = eina_array_new(2);
eina_array_push(properties, _eio_model_prop_names[EIO_MODEL_PROP_PATH]);
eina_array_push(properties, _eio_model_prop_names[EIO_MODEL_PROP_FILENAME]);
evt.changed_properties = properties;
eo_do(priv->obj, eo_event_callback_call(EMODEL_EVENT_PROPERTIES_CHANGED, &evt)); eo_do(priv->obj, eo_event_callback_call(EMODEL_EVENT_PROPERTIES_CHANGED, &evt));
eina_array_free(properties);
} }
static void static void
@ -259,41 +250,43 @@ _eio_error_unlink_cb(void *data EINA_UNUSED, Eio_File *handler EINA_UNUSED, int
* Interfaces impl. * Interfaces impl.
*/ */
static Emodel_Load_Status static Emodel_Load_Status
_eio_model_emodel_properties_list_get(Eo *obj EINA_UNUSED, _eio_model_emodel_properties_get(Eo *obj EINA_UNUSED,
Eio_Model_Data *_pd, Eina_Array * const* properties_list) Eio_Model_Data *_pd, Eina_Array * const* properties)
{ {
Eio_Model_Data *priv = _pd; Eio_Model_Data *priv = _pd;
unsigned int i;
EINA_SAFETY_ON_NULL_RETURN_VAL(priv, EINA_FALSE); EINA_SAFETY_ON_NULL_RETURN_VAL(priv, EINA_FALSE);
EINA_SAFETY_ON_NULL_RETURN_VAL(priv->obj, EINA_FALSE); EINA_SAFETY_ON_NULL_RETURN_VAL(priv->obj, EINA_FALSE);
if (priv->properties_array == NULL) *(Eina_Array **)properties = priv->properties_name;
{
Eina_Value_Struct_Desc *desc = EIO_MODEL_PROPERTIES_DESC;
priv->properties_array = eina_array_new(desc->member_count);
for (i = 0; i < desc->member_count; ++i)
eina_array_push(priv->properties_array, desc->members[i].name);
}
*(Eina_Array **)properties_list = priv->properties_array;
return priv->load.status; return priv->load.status;
} }
/** /**
* Property Fetch //carlos * Property Get
*/ */
static Emodel_Load_Status static Emodel_Load_Status
_eio_model_emodel_property_get(Eo *obj EINA_UNUSED, Eio_Model_Data *priv, const char *property, Eina_Value *value) _eio_model_emodel_property_get(Eo *obj EINA_UNUSED, Eio_Model_Data *priv, const char *property, const Eina_Value **value)
{ {
unsigned int i;
EINA_SAFETY_ON_NULL_RETURN_VAL(property, EMODEL_LOAD_STATUS_ERROR); EINA_SAFETY_ON_NULL_RETURN_VAL(property, EMODEL_LOAD_STATUS_ERROR);
EINA_SAFETY_ON_NULL_RETURN_VAL(priv, EMODEL_LOAD_STATUS_ERROR); EINA_SAFETY_ON_NULL_RETURN_VAL(priv, EMODEL_LOAD_STATUS_ERROR);
//XXX Return error code? *value = NULL;
eina_value_struct_value_get(priv->properties, property, value); if (priv->load.status & EMODEL_LOAD_STATUS_LOADED_PROPERTIES)
{
for (i = 0; i < EIO_MODEL_PROP_LAST; ++i)
{
if (!strcmp(property, _eio_model_prop_names[i]))
break;
}
if ( i < EIO_MODEL_PROP_LAST)
{
*value = priv->properties_value[i];
}
}
return priv->load.status; return priv->load.status;
} }
@ -302,25 +295,24 @@ _eio_model_emodel_property_get(Eo *obj EINA_UNUSED, Eio_Model_Data *priv, const
* Property Set * Property Set
*/ */
static Emodel_Load_Status static Emodel_Load_Status
_eio_model_emodel_property_set(Eo *obj EINA_UNUSED, Eio_Model_Data *priv, const char * property, Eina_Value value) _eio_model_emodel_property_set(Eo *obj EINA_UNUSED, Eio_Model_Data *priv, const char * property, const Eina_Value *value)
{ {
char *dest; char *dest;
Eina_Value v = value;
EINA_SAFETY_ON_NULL_RETURN_VAL(property, EINA_FALSE); EINA_SAFETY_ON_NULL_RETURN_VAL(property, EINA_FALSE);
if (strcmp(property, "path") != 0) if (strcmp(property, "path") != 0)
return EINA_FALSE; return EINA_FALSE;
dest = eina_value_to_string(&v); dest = eina_value_to_string(value);
if (priv->path == NULL) if (priv->path == NULL)
{ {
priv->path = dest; priv->path = dest;
INF("path '%s' with filename '%s'.", priv->path, basename(priv->path)); INF("path '%s' with filename '%s'.", priv->path, basename(priv->path));
eina_value_struct_set(priv->properties, "path", priv->path); eina_value_set(priv->properties_value[EIO_MODEL_PROP_PATH], priv->path);
eina_value_struct_set(priv->properties, "filename", basename(priv->path)); eina_value_set(priv->properties_value[EIO_MODEL_PROP_FILENAME], basename(priv->path));
_eio_monitors_list_load(priv); _eio_monitors_list_load(priv);
@ -328,8 +320,7 @@ _eio_model_emodel_property_set(Eo *obj EINA_UNUSED, Eio_Model_Data *priv, const
if (priv->load_pending & EMODEL_LOAD_STATUS_LOADED_PROPERTIES) if (priv->load_pending & EMODEL_LOAD_STATUS_LOADED_PROPERTIES)
_eio_model_emodel_properties_load(obj, priv); _eio_model_emodel_properties_load(obj, priv);
else if (priv->load_pending & EMODEL_LOAD_STATUS_LOADED_CHILDREN)
if (priv->load_pending & EMODEL_LOAD_STATUS_LOADED_CHILDREN)
_eio_model_emodel_children_load(obj, priv); _eio_model_emodel_children_load(obj, priv);
return priv->load.status; return priv->load.status;
@ -460,9 +451,10 @@ _eio_model_emodel_children_load(Eo *obj EINA_UNUSED, Eio_Model_Data *priv)
priv->load_pending |= EMODEL_LOAD_STATUS_LOADED_CHILDREN; priv->load_pending |= EMODEL_LOAD_STATUS_LOADED_CHILDREN;
return; return;
} }
priv->load_pending &= ~EMODEL_LOAD_STATUS_LOADED_CHILDREN; priv->load_pending &= ~EMODEL_LOAD_STATUS_LOADED_CHILDREN;
if (priv->children_list == NULL && if (priv->children_list == NULL && priv->is_dir &&
!(priv->load.status & (EMODEL_LOAD_STATUS_LOADED_CHILDREN | EMODEL_LOAD_STATUS_LOADING_CHILDREN))) !(priv->load.status & (EMODEL_LOAD_STATUS_LOADED_CHILDREN | EMODEL_LOAD_STATUS_LOADING_CHILDREN)))
{ {
_eio_model_emodel_monitor_add(priv); _eio_model_emodel_monitor_add(priv);
@ -571,7 +563,6 @@ _eio_model_emodel_child_del(Eo *obj EINA_UNUSED, Eio_Model_Data *priv, Eo *child
/** /**
* Children Slice Get * Children Slice Get
* TODO/XXX/FIXME: Untested code - validate this implementation
*/ */
static Emodel_Load_Status static Emodel_Load_Status
_eio_model_emodel_children_slice_get(Eo *obj EINA_UNUSED, Eio_Model_Data *priv, _eio_model_emodel_children_slice_get(Eo *obj EINA_UNUSED, Eio_Model_Data *priv,
@ -627,44 +618,6 @@ _eio_model_emodel_children_slice_get(Eo *obj EINA_UNUSED, Eio_Model_Data *priv,
return priv->load.status; return priv->load.status;
} }
static void
_struct_properties_init(void)
{
typedef struct _This_Eio_Properties
{
const char *filename;
const char *path;
struct timeval mtime;
int is_dir;
int is_lnk;
int64_t size;
} This_Eio_Properties;
static Eina_Value_Struct_Member prop_members[] = {
EINA_VALUE_STRUCT_MEMBER(NULL, This_Eio_Properties, filename),
EINA_VALUE_STRUCT_MEMBER(NULL, This_Eio_Properties, path),
EINA_VALUE_STRUCT_MEMBER(NULL, This_Eio_Properties, mtime),
EINA_VALUE_STRUCT_MEMBER(NULL, This_Eio_Properties, is_dir),
EINA_VALUE_STRUCT_MEMBER(NULL, This_Eio_Properties, is_lnk),
EINA_VALUE_STRUCT_MEMBER(NULL, This_Eio_Properties, size)
};
prop_members[EIO_MODEL_PROP_FILENAME].type = EINA_VALUE_TYPE_STRING;
prop_members[EIO_MODEL_PROP_PATH].type = EINA_VALUE_TYPE_STRING;
prop_members[EIO_MODEL_PROP_MTIME].type = EINA_VALUE_TYPE_TIMEVAL;
prop_members[EIO_MODEL_PROP_IS_DIR].type = EINA_VALUE_TYPE_INT;
prop_members[EIO_MODEL_PROP_IS_LNK].type = EINA_VALUE_TYPE_INT;
prop_members[EIO_MODEL_PROP_SIZE].type = EINA_VALUE_TYPE_INT64;
static Eina_Value_Struct_Desc prop_desc = {
EINA_VALUE_STRUCT_DESC_VERSION,
NULL, // no special operations
prop_members,
EINA_C_ARRAY_LENGTH(prop_members),
sizeof(This_Eio_Properties)
};
EIO_MODEL_PROPERTIES_DESC = &prop_desc;
}
/** /**
* Class definitions * Class definitions
*/ */
@ -672,10 +625,20 @@ static void
_eio_model_eo_base_constructor(Eo *obj, Eio_Model_Data *priv) _eio_model_eo_base_constructor(Eo *obj, Eio_Model_Data *priv)
{ {
eo_do_super(obj, MY_CLASS, eo_constructor()); eo_do_super(obj, MY_CLASS, eo_constructor());
unsigned int i;
priv->obj = obj; priv->obj = obj;
_struct_properties_init();
priv->properties = eina_value_struct_new(EIO_MODEL_PROPERTIES_DESC); priv->properties_name = eina_array_new(EIO_MODEL_PROP_LAST);
EINA_SAFETY_ON_NULL_RETURN(priv->properties); EINA_SAFETY_ON_NULL_RETURN(priv->properties_name);
for (i = 0; i < EIO_MODEL_PROP_LAST; ++i)
eina_array_push(priv->properties_name, _eio_model_prop_names[i]);
priv->properties_value[EIO_MODEL_PROP_FILENAME] = eina_value_new(EINA_VALUE_TYPE_STRING);
priv->properties_value[EIO_MODEL_PROP_PATH] = eina_value_new(EINA_VALUE_TYPE_STRING);
priv->properties_value[EIO_MODEL_PROP_MTIME] = eina_value_new(EINA_VALUE_TYPE_TIMEVAL);
priv->properties_value[EIO_MODEL_PROP_IS_DIR] = eina_value_new(EINA_VALUE_TYPE_INT);
priv->properties_value[EIO_MODEL_PROP_IS_LNK] = eina_value_new(EINA_VALUE_TYPE_INT);
priv->properties_value[EIO_MODEL_PROP_SIZE] = eina_value_new(EINA_VALUE_TYPE_INT64);
priv->load.status = EMODEL_LOAD_STATUS_UNLOADED; priv->load.status = EMODEL_LOAD_STATUS_UNLOADED;
priv->monitor = NULL; priv->monitor = NULL;
@ -686,8 +649,8 @@ _eio_model_path_set(Eo *obj EINA_UNUSED, Eio_Model_Data *priv, const char *path)
{ {
priv->path = strdup(path); priv->path = strdup(path);
eina_value_struct_set(priv->properties, "path", priv->path); eina_value_set(priv->properties_value[EIO_MODEL_PROP_PATH], priv->path);
eina_value_struct_set(priv->properties, "filename", basename(priv->path)); eina_value_set(priv->properties_value[EIO_MODEL_PROP_FILENAME], basename(priv->path));
priv->monitor = NULL; priv->monitor = NULL;
_eio_monitors_list_load(priv); _eio_monitors_list_load(priv);
@ -697,15 +660,18 @@ static void
_eio_model_eo_base_destructor(Eo *obj , Eio_Model_Data *priv) _eio_model_eo_base_destructor(Eo *obj , Eio_Model_Data *priv)
{ {
Eo *child; Eo *child;
unsigned int i;
if (priv->monitor) if (priv->monitor)
eio_monitor_del(priv->monitor); eio_monitor_del(priv->monitor);
if (priv->properties_array) if (priv->properties_name)
eina_array_free(priv->properties_array); eina_array_free(priv->properties_name);
if (priv->properties) for (i = 0; i < EIO_MODEL_PROP_LAST; ++i)
eina_value_free(priv->properties); {
eina_value_free(priv->properties_value[i]);
}
EINA_LIST_FREE(priv->children_list, child) EINA_LIST_FREE(priv->children_list, child)
eo_unref(child); eo_unref(child);

2
src/lib/eio/eio_model.eo
View File

@ -33,7 +33,7 @@ class Eio.Model (Eo.Base, Emodel)
implements { implements {
Eo.Base.constructor; Eo.Base.constructor;
Eo.Base.destructor; Eo.Base.destructor;
Emodel.properties_list.get; Emodel.properties.get;
Emodel.properties_load; Emodel.properties_load;
Emodel.property.set; Emodel.property.set;
Emodel.property.get; Emodel.property.get;

24
src/lib/eio/eio_model_private.h
View File

@ -14,32 +14,38 @@ struct _Eio_Model_Monitor_Data
int mon_event_child_del[3]; /**< plus EIO_MONITOR_ERROR */ int mon_event_child_del[3]; /**< plus EIO_MONITOR_ERROR */
}; };
/**
* !! Warning: Do not change enum's order
* before checking _eio_model_constructor.
* @see Eina_Value_Struct_Member.
*/
enum { enum {
EIO_MODEL_PROP_FILENAME = 0, EIO_MODEL_PROP_FILENAME = 0,
EIO_MODEL_PROP_PATH, EIO_MODEL_PROP_PATH,
EIO_MODEL_PROP_MTIME, EIO_MODEL_PROP_MTIME,
EIO_MODEL_PROP_IS_DIR, EIO_MODEL_PROP_IS_DIR,
EIO_MODEL_PROP_IS_LNK, EIO_MODEL_PROP_IS_LNK,
EIO_MODEL_PROP_SIZE EIO_MODEL_PROP_SIZE,
EIO_MODEL_PROP_LAST
};
static const char* _eio_model_prop_names[] =
{
[EIO_MODEL_PROP_FILENAME] = "filename",
[EIO_MODEL_PROP_PATH] = "path",
[EIO_MODEL_PROP_MTIME] = "mtime",
[EIO_MODEL_PROP_IS_DIR] = "is_dir",
[EIO_MODEL_PROP_IS_LNK] = "is_lnk",
[EIO_MODEL_PROP_SIZE] = "size"
}; };
struct _Eio_Model_Data struct _Eio_Model_Data
{ {
Eo *obj; Eo *obj;
char *path; char *path;
Eina_Array *properties_array; Eina_Array *properties_name;
Eina_Value *properties; Eina_Value *properties_value[EIO_MODEL_PROP_LAST];
Emodel_Load load; Emodel_Load load;
int load_pending; int load_pending;
Eina_List *children_list; Eina_List *children_list;
/**< EIO data */ /**< EIO data */
Eio_File *file; Eio_File *file;
const Eina_Stat *stat; Eina_Bool is_dir;
Eio_Monitor *monitor; Eio_Monitor *monitor;
Eio_Model_Monitor_Data mon; Eio_Model_Monitor_Data mon;
int cb_count_child_add; /**< monitor reference counter for child add event */ int cb_count_child_add; /**< monitor reference counter for child add event */

4
src/lib/emodel/Emodel_Common.h
View File

@ -50,8 +50,8 @@ typedef struct _Emodel_Load Emodel_Load;
*/ */
struct _Emodel_Property_Event struct _Emodel_Property_Event
{ {
const Eina_Value *changed_properties; /**< Eina_Value_Struct or Eina_Value_Hash with changed properties values */ const Eina_Array *changed_properties; /**< array of property name */
Eina_Array *invalidated_properties; /**< array of name */ const Eina_Array *invalidated_properties; /**< array of property name */
}; };
/** /**

23
src/lib/emodel/emodel.eo
View File

@ -14,16 +14,11 @@
* EMODEL_LOAD_STATUS_UNLOADED = (1 << 5) /*@ Model Unloaded * * EMODEL_LOAD_STATUS_UNLOADED = (1 << 5) /*@ Model Unloaded *
* } * }
* *
* type Emodel_Property_Pair: struct _Emodel_Property_Pair
* {
* value: Eina_Value; /*@ the new property value *
* property: const(char)*; /*@ the property name that has been changed *
* }
* *
* type Emodel_Property_Event: struct _Emodel_Property_Event * type Emodel_Property_Event: struct _Emodel_Property_Event
* { * {
* changed_properties: Eina_List* <Emodel_Property_Pair*>; /*@ List of changed properties * * changed_properties: Eina_Array* <const(char)*>; /*@ List of changed properties *
* invalidated_properties: Eina_List* <const(char)*>; /*@ Removed properties identified by name * * invalidated_properties: Eina_Array* <const(char)*>; /*@ Removed properties identified by name *
* } * }
*/ */
@ -48,17 +43,17 @@ interface Emodel ()
return: Emodel_Load_Status; return: Emodel_Load_Status;
} }
} }
properties_list { properties {
get { get {
/*@ /*@
Get properties list from model. Get properties from model.
@return: @c Emodel_Load_Status @return: @c Emodel_Load_Status
properties_list_get is due to provide callers a way the fetch the current properties_get is due to provide callers a way the fetch the current
properties implemented/used by the model. properties implemented/used by the model.
The event EMODEL_EVENT_PROPERTIES_CHANGE will be raised to notify listeners The event EMODEL_EVENT_PROPERTIES_CHANGE will be raised to notify listeners
of any modifications in the properties list. of any modifications in the properties.
@see EMODEL_EVENT_PROPERTIES_CHANGE @see EMODEL_EVENT_PROPERTIES_CHANGE
@since 1.11 */ @since 1.11 */
@ -66,7 +61,7 @@ interface Emodel ()
return: Emodel_Load_Status; return: Emodel_Load_Status;
} }
values { values {
const(array<const(char*)>*) properties_list; /*@ list of current properties */ const(array<const(char*)>*) properties; /*@ array of current properties */
} }
} }
property { property {
@ -105,7 +100,7 @@ interface Emodel ()
The event EMODEL_EVENT_PROPERTIES_CHANGE may be raised to notify The event EMODEL_EVENT_PROPERTIES_CHANGE may be raised to notify
listeners of the property/value. listeners of the property/value.
@see emodel_properties_list_get @see emodel_properties_get
@see EMODEL_EVENT_PROPERTIES_CHANGE @see EMODEL_EVENT_PROPERTIES_CHANGE
@since 1.11 */ @since 1.11 */
@ -115,7 +110,7 @@ interface Emodel ()
const(char)* property; /*@ Property name */ const(char)* property; /*@ Property name */
} }
values { values {
Eina_Value value; /*@ New value */ const(Eina_Value)* value; /*@ New value */
} }
} }
children_slice { children_slice {

68
src/tests/emodel/emodel_test_file.c
View File

@ -77,29 +77,25 @@ _load_status_cb(void *data EINA_UNUSED, Eo *obj, const Eo_Event_Description *des
if ((st->status & EMODEL_LOAD_STATUS_LOADED) == EMODEL_LOAD_STATUS_LOADED) if ((st->status & EMODEL_LOAD_STATUS_LOADED) == EMODEL_LOAD_STATUS_LOADED)
{ {
Eina_Accessor *accessor; Eina_Accessor *accessor;
Eina_Value value_prop; const Eina_Value *value_prop;
Eo *child;
Emodel_Load_Status status; Emodel_Load_Status status;
unsigned int total, i; unsigned int total;
char *str; char *str;
printf("Model is Loaded\n"); printf("Model is Loaded\n");
eo_do(obj, status = emodel_property_get("filename", &value_prop)); eo_do(obj, status = emodel_property_get("filename", &value_prop));
str = eina_value_to_string(&value_prop); str = eina_value_to_string(value_prop);
printf("emodel_loaded filename %s, status=%d\n", str, status); printf("emodel_loaded filename %s, status=%d\n", str, status);
eina_value_flush(&value_prop);
free(str); free(str);
eo_do(obj, status = emodel_property_get("size", &value_prop)); eo_do(obj, status = emodel_property_get("size", &value_prop));
str = eina_value_to_string(&value_prop); str = eina_value_to_string(value_prop);
printf("emodel_loaded size %s, status=%d\n", str, status); printf("emodel_loaded size %s, status=%d\n", str, status);
eina_value_flush(&value_prop);
free(str); free(str);
eo_do(obj, status = emodel_property_get("mtime", &value_prop)); eo_do(obj, status = emodel_property_get("mtime", &value_prop));
str = eina_value_to_string(&value_prop); str = eina_value_to_string(value_prop);
printf("emodel_loaded mtime %s, status=%d\n", str, status); printf("emodel_loaded mtime %s, status=%d\n", str, status);
eina_value_flush(&value_prop);
free(str); free(str);
eo_do(obj, emodel_children_count_get(&total)); eo_do(obj, emodel_children_count_get(&total));
@ -107,30 +103,8 @@ _load_status_cb(void *data EINA_UNUSED, Eo *obj, const Eo_Event_Description *des
/**< get full list */ /**< get full list */
eo_do(obj, status = emodel_children_slice_get(0 ,0 ,(Eina_Accessor **)&accessor)); eo_do(obj, status = emodel_children_slice_get(0 ,0 ,(Eina_Accessor **)&accessor));
EINA_ACCESSOR_FOREACH(accessor, i, child)
{
//XXX: check if there is memleak
eo_do(child, status = emodel_property_get("filename", &value_prop));
str = eina_value_to_string(&value_prop);
printf("(full) %d emodel_children_get filename %s\n", i, str);
eina_value_flush(&value_prop);
free(str);
}
i = 0;
eina_accessor_free(accessor); eina_accessor_free(accessor);
eo_do(obj, status = emodel_children_slice_get(5 ,5 ,(Eina_Accessor **)&accessor)); eo_do(obj, status = emodel_children_slice_get(5 ,5 ,(Eina_Accessor **)&accessor));
EINA_ACCESSOR_FOREACH(accessor, i, child)
{
//XXX: check if there is memleak
eo_do(child, status = emodel_property_get("filename", &value_prop));
str = eina_value_to_string(&value_prop);
printf("(slice) %d emodel_chidlren_property_set filename %s\n", i, str);
eina_value_flush(&value_prop);
free(str);
eo_unref(child);
}
eina_accessor_free(accessor); eina_accessor_free(accessor);
ecore_main_loop_quit(); ecore_main_loop_quit();
} }
@ -141,21 +115,22 @@ static Eina_Bool
_properties_change_cb(void *data EINA_UNUSED, Eo *obj EINA_UNUSED, const Eo_Event_Description *desc EINA_UNUSED, void *event_info) _properties_change_cb(void *data EINA_UNUSED, Eo *obj EINA_UNUSED, const Eo_Event_Description *desc EINA_UNUSED, void *event_info)
{ {
const Emodel_Property_Event *evt = (Emodel_Property_Event *)event_info; const Emodel_Property_Event *evt = (Emodel_Property_Event *)event_info;
Eina_Value v; const char *prop;
Eina_Array_Iterator it;
unsigned int i;
if (eina_value_type_get(evt->changed_properties) != EINA_VALUE_TYPE_STRUCT) EINA_ARRAY_ITER_NEXT(evt->changed_properties, i, prop, it)
return EINA_FALSE; {
if (!strcmp(prop, "is_dir"))
if(eina_value_struct_value_get(evt->changed_properties, "is_dir", &v) == EINA_TRUE)
reqs.changed_is_dir = 1; reqs.changed_is_dir = 1;
if(eina_value_struct_value_get(evt->changed_properties, "is_lnk", &v) == EINA_TRUE) else if (!strcmp(prop, "is_lnk"))
reqs.changed_is_lnk = 1; reqs.changed_is_lnk = 1;
if(eina_value_struct_value_get(evt->changed_properties, "size", &v) == EINA_TRUE) else if (!strcmp(prop, "size"))
reqs.changed_size = 1; reqs.changed_size = 1;
if(eina_value_struct_value_get(evt->changed_properties, "mtime", &v) == EINA_TRUE) else if (!strcmp(prop, "mtime"))
reqs.changed_mtime = 1; reqs.changed_mtime = 1;
}
eina_value_flush(&v);
reqs.properties = 1; reqs.properties = 1;
return EINA_TRUE; return EINA_TRUE;
} }
@ -178,7 +153,7 @@ _children_count_cb(void *data EINA_UNUSED, Eo *obj EINA_UNUSED, const Eo_Event_D
START_TEST(emodel_test_test_file) START_TEST(emodel_test_test_file)
{ {
Eo *filemodel = NULL; Eo *filemodel = NULL;
Eina_Value value_prop; const Eina_Value *value_prop;
Emodel_Load_Status status; Emodel_Load_Status status;
#ifdef _RUN_LOCAL_TEST #ifdef _RUN_LOCAL_TEST
Eina_Value nameset_value; Eina_Value nameset_value;
@ -205,17 +180,14 @@ START_TEST(emodel_test_test_file)
handler = ecore_event_handler_add(ECORE_EVENT_SIGNAL_EXIT, exit_func, NULL); handler = ecore_event_handler_add(ECORE_EVENT_SIGNAL_EXIT, exit_func, NULL);
eina_value_setup(&value_prop, EINA_VALUE_TYPE_STRING);
eo_do(filemodel, status = emodel_property_get("filename", &value_prop)); eo_do(filemodel, status = emodel_property_get("filename", &value_prop));
str = eina_value_to_string(&value_prop); str = eina_value_to_string(value_prop);
printf("emodel_test filename %s, load status %d\n", str, status); printf("emodel_test filename %s, load status %d\n", str, status);
eina_value_flush(&value_prop);
free(str); free(str);
i = 0; i = 0;
eo_do(filemodel, emodel_properties_list_get(&properties_list)); eo_do(filemodel, emodel_properties_get(&properties_list));
EINA_ARRAY_ITER_NEXT(properties_list, i, str, iterator) EINA_ARRAY_ITER_NEXT(properties_list, i, str, iterator)
{ {
fprintf(stdout, "Returned property list %d: %s\n", i, str); fprintf(stdout, "Returned property list %d: %s\n", i, str);
@ -239,11 +211,9 @@ START_TEST(emodel_test_test_file)
eina_value_setup(&nameset_value, EINA_VALUE_TYPE_STRING); eina_value_setup(&nameset_value, EINA_VALUE_TYPE_STRING);
eina_value_setup(&value_prop, EINA_VALUE_TYPE_STRING); eina_value_setup(&value_prop, EINA_VALUE_TYPE_STRING);
eina_value_set(&nameset_value, "/tmp/emodel_test"); eina_value_set(&nameset_value, "/tmp/emodel_test");
eo_do(filemodel, emodel_property_set("path", nameset_value)); eo_do(filemodel, emodel_property_set("path", &nameset_value));
eina_value_flush(&nameset_value); eina_value_flush(&nameset_value);
//emodel_property_get("path", &value_prop);
eo_do(filemodel, status = emodel_property_get("path", &value_prop)); eo_do(filemodel, status = emodel_property_get("path", &value_prop));
eina_value_flush(&value_prop);
#endif #endif
sleep(1); /**< EIO is asynchrounous so I must give some time for deletions to execute */ sleep(1); /**< EIO is asynchrounous so I must give some time for deletions to execute */

40
src/tests/emodel/emodel_test_monitor_add.c
View File

@ -18,24 +18,44 @@
Eina_Bool children_added = EINA_FALSE; Eina_Bool children_added = EINA_FALSE;
static Eina_Bool static Eina_Bool
_children_added_cb(void *data EINA_UNUSED, Eo *obj EINA_UNUSED, const Eo_Event_Description *desc EINA_UNUSED, void *event_info) _load_monitor_status_cb(void *data, Eo *obj, const Eo_Event_Description *desc EINA_UNUSED, void *event_info)
{ {
Emodel_Children_Event* evt = event_info; Emodel_Load* st = event_info;
Eo* child = evt->child; Eo* parent = data;
Eina_Value value_prop; const Eina_Value* value_prop = NULL;
const char* str; const char* str = NULL;
eo_do(child, emodel_property_get("filename", &value_prop)); if (!(st->status & EMODEL_LOAD_STATUS_LOADED_PROPERTIES))
str = eina_value_to_string(&value_prop); return EINA_TRUE;
eo_do(obj, emodel_property_get("filename", &value_prop));
fail_if(!value_prop, "ERROR: Cannot get property!\n");
str = eina_value_to_string(value_prop);
fail_if(!str, "ERROR: Cannot convert value to string!\n");
fprintf(stderr, "new children filename %s\n", str); fprintf(stderr, "new children filename %s\n", str);
if(strcmp(str, "test_file_monitor_add") == 0) if(strcmp(str, "test_file_monitor_add") == 0)
{ {
fprintf(stderr, "is child that we want\n"); fprintf(stderr, "is child that we want\n");
eo_do(obj, eo_event_callback_del(EMODEL_EVENT_LOAD_STATUS, _load_monitor_status_cb, data));
children_added = EINA_TRUE; children_added = EINA_TRUE;
eo_do(obj, emodel_child_del(child)); eo_do(parent, emodel_child_del(obj));
ecore_main_loop_quit(); ecore_main_loop_quit();
} }
eina_value_flush(&value_prop);
return EINA_FALSE;
}
static Eina_Bool
_children_added_cb(void *data EINA_UNUSED, Eo *obj EINA_UNUSED, const Eo_Event_Description *desc EINA_UNUSED, void *event_info)
{
Emodel_Children_Event* evt = event_info;
if (evt == NULL)
return EINA_TRUE;
eo_do(evt->child, eo_event_callback_add(EMODEL_EVENT_LOAD_STATUS, _load_monitor_status_cb, obj));
eo_do(evt->child, emodel_load());
return EINA_TRUE; return EINA_TRUE;
} }
@ -76,8 +96,8 @@ START_TEST(emodel_test_test_monitor_add)
filemodel = eo_add(EIO_MODEL_CLASS, NULL, eio_model_path_set(EMODEL_TEST_FILENAME_PATH)); filemodel = eo_add(EIO_MODEL_CLASS, NULL, eio_model_path_set(EMODEL_TEST_FILENAME_PATH));
fail_if(!filemodel, "ERROR: Cannot init model!\n"); fail_if(!filemodel, "ERROR: Cannot init model!\n");
eo_do(filemodel, eo_event_callback_add(EMODEL_EVENT_CHILDREN_COUNT_CHANGED, _children_count_cb, NULL));
eo_do(filemodel, eo_event_callback_add(EMODEL_EVENT_CHILD_ADDED, _children_added_cb, NULL)); eo_do(filemodel, eo_event_callback_add(EMODEL_EVENT_CHILD_ADDED, _children_added_cb, NULL));
eo_do(filemodel, eo_event_callback_add(EMODEL_EVENT_CHILDREN_COUNT_CHANGED, _children_count_cb, NULL));
eo_do(filemodel, emodel_load()); eo_do(filemodel, emodel_load());