2015-04-05 06:19:45 -07:00
|
|
|
#ifdef HAVE_CONFIG_H
|
|
|
|
# include <config.h>
|
|
|
|
#endif
|
|
|
|
|
2015-04-05 06:19:47 -07:00
|
|
|
#include <stdint.h>
|
|
|
|
|
2015-04-05 06:19:59 -07:00
|
|
|
#include <Efl.h>
|
2015-04-05 06:19:45 -07:00
|
|
|
#include <Eina.h>
|
|
|
|
#include <Ecore.h>
|
2016-06-05 16:52:52 -07:00
|
|
|
#include <Ecore_File.h>
|
2015-04-05 06:19:45 -07:00
|
|
|
#include <Eo.h>
|
2016-06-05 17:21:43 -07:00
|
|
|
#include <Efreet_Mime.h>
|
2015-04-05 06:19:45 -07:00
|
|
|
|
2016-06-06 11:00:54 -07:00
|
|
|
#include "Eio.h"
|
|
|
|
|
2015-04-05 06:19:52 -07:00
|
|
|
#include "eio_private.h"
|
2015-04-05 06:19:45 -07:00
|
|
|
#include "eio_model_private.h"
|
|
|
|
|
|
|
|
#define MY_CLASS EIO_MODEL_CLASS
|
|
|
|
#define MY_CLASS_NAME "Eio_Model"
|
|
|
|
|
|
|
|
static void _eio_prop_set_error_cb(void *, Eio_File *, int);
|
2016-04-20 13:07:53 -07:00
|
|
|
static void _eio_stat_done_cb(void *data, Eio_File *handler EINA_UNUSED, const Eina_Stat *stat);
|
|
|
|
static void _eio_error_cb(void *data EINA_UNUSED, Eio_File *handler EINA_UNUSED, int error);
|
2015-04-05 06:19:45 -07:00
|
|
|
|
|
|
|
static void
|
2016-04-20 13:07:53 -07:00
|
|
|
_eio_stat_do(Eio_Model_Data *priv)
|
2015-04-05 06:19:45 -07:00
|
|
|
{
|
2016-04-20 13:07:53 -07:00
|
|
|
priv->stat_file = eio_file_direct_stat(priv->path, _eio_stat_done_cb, _eio_error_cb, priv);
|
|
|
|
}
|
2015-04-05 06:19:45 -07:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Callbacks
|
|
|
|
* Property
|
|
|
|
*/
|
|
|
|
static void
|
|
|
|
_eio_stat_done_cb(void *data, Eio_File *handler EINA_UNUSED, const Eina_Stat *stat)
|
|
|
|
{
|
2016-04-20 13:07:53 -07:00
|
|
|
_Eio_Model_Data *priv = data;
|
|
|
|
_Eio_Property_Promise* p;
|
|
|
|
Eina_List *l;
|
|
|
|
EINA_LIST_FOREACH(priv->property_promises, l, p)
|
|
|
|
{
|
2016-06-08 15:33:29 -07:00
|
|
|
Eina_Value* v = eina_value_new(EINA_VALUE_TYPE_CHAR);
|
2016-04-20 13:07:53 -07:00
|
|
|
switch(p->property)
|
|
|
|
{
|
|
|
|
case EIO_MODEL_PROP_IS_DIR:
|
|
|
|
eina_value_setup(v, EINA_VALUE_TYPE_CHAR);
|
|
|
|
eina_value_set(v, eio_file_is_dir(stat) ? EINA_TRUE : EINA_FALSE);
|
|
|
|
break;
|
|
|
|
case EIO_MODEL_PROP_IS_LNK:
|
|
|
|
eina_value_setup(v, EINA_VALUE_TYPE_CHAR);
|
|
|
|
eina_value_set(v, eio_file_is_lnk(stat) ? EINA_TRUE : EINA_FALSE);
|
|
|
|
break;
|
|
|
|
case EIO_MODEL_PROP_MTIME:
|
2016-06-10 15:24:50 -07:00
|
|
|
eina_value_setup(v, EINA_VALUE_TYPE_DOUBLE);
|
2016-04-20 13:07:53 -07:00
|
|
|
eina_value_set(v, eio_file_mtime(stat));
|
|
|
|
break;
|
|
|
|
case EIO_MODEL_PROP_SIZE:
|
|
|
|
eina_value_setup(v, EINA_VALUE_TYPE_INT64);
|
|
|
|
eina_value_set(v, eio_file_size(stat));
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
};
|
|
|
|
|
2016-06-08 15:33:29 -07:00
|
|
|
eina_promise_owner_value_set(p->promise, v, (Eina_Promise_Free_Cb)&eina_value_free);
|
2016-04-20 13:07:53 -07:00
|
|
|
free(p);
|
|
|
|
}
|
|
|
|
eina_list_free(priv->property_promises);
|
|
|
|
priv->property_promises = NULL;
|
2015-04-05 06:19:45 -07:00
|
|
|
|
2016-04-20 13:07:53 -07:00
|
|
|
eio_file_cancel(priv->stat_file);
|
|
|
|
priv->stat_file = NULL;
|
2015-04-05 06:19:45 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_eio_progress_cb(void *data EINA_UNUSED, Eio_File *handler EINA_UNUSED, const Eio_Progress *info EINA_UNUSED)
|
|
|
|
{
|
|
|
|
//TODO: implement
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_eio_move_done_cb(void *data, Eio_File *handler EINA_UNUSED)
|
|
|
|
{
|
2015-04-05 06:19:59 -07:00
|
|
|
Efl_Model_Property_Event evt;
|
2015-04-05 06:19:45 -07:00
|
|
|
Eio_Model_Data *priv = data;
|
2016-07-08 02:15:05 -07:00
|
|
|
Eina_Array *properties;
|
2015-04-05 06:19:45 -07:00
|
|
|
|
2016-08-15 06:44:41 -07:00
|
|
|
EINA_SAFETY_ON_FALSE_RETURN(efl_ref_get(priv->obj));
|
2016-07-08 02:15:05 -07:00
|
|
|
properties = eina_array_new(20);
|
2015-04-05 06:19:45 -07:00
|
|
|
|
2015-04-05 06:19:59 -07:00
|
|
|
memset(&evt, 0, sizeof(Efl_Model_Property_Event));
|
2015-04-05 06:19:55 -07:00
|
|
|
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;
|
2015-04-05 06:19:45 -07:00
|
|
|
|
2016-08-29 16:13:22 -07:00
|
|
|
efl_event_callback_call(priv->obj, EFL_MODEL_EVENT_PROPERTIES_CHANGED, &evt);
|
2015-04-05 06:19:55 -07:00
|
|
|
eina_array_free(properties);
|
2015-04-05 06:19:45 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_eio_error_cb(void *data EINA_UNUSED, Eio_File *handler EINA_UNUSED, int error)
|
|
|
|
{
|
2015-04-05 06:19:52 -07:00
|
|
|
if (error != 0)
|
2015-04-05 06:19:45 -07:00
|
|
|
{
|
2016-04-20 13:07:53 -07:00
|
|
|
_Eio_Model_Data *priv = data;
|
|
|
|
_Eio_Property_Promise* p;
|
|
|
|
Eina_List *l;
|
2015-04-09 18:46:24 -07:00
|
|
|
WRN("%d: %s.", error, strerror(error));
|
2016-04-20 13:07:53 -07:00
|
|
|
|
|
|
|
EINA_LIST_FOREACH(priv->property_promises, l, p)
|
|
|
|
{
|
|
|
|
eina_promise_owner_error_set(p->promise, EFL_MODEL_ERROR_UNKNOWN);
|
|
|
|
}
|
2016-06-05 23:10:24 -07:00
|
|
|
eina_list_free(priv->property_promises);
|
|
|
|
priv->property_promises = NULL;
|
|
|
|
|
|
|
|
eio_file_cancel(priv->stat_file);
|
|
|
|
priv->stat_file = NULL;
|
2015-04-05 06:19:45 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2015-04-05 06:19:52 -07:00
|
|
|
_eio_prop_set_error_cb(void *data EINA_UNUSED, Eio_File *handler EINA_UNUSED, int error)
|
2015-04-05 06:19:45 -07:00
|
|
|
{
|
2015-04-05 06:19:52 -07:00
|
|
|
if (error != 0)
|
|
|
|
{
|
2015-04-09 18:46:24 -07:00
|
|
|
WRN("%d: %s.", error, strerror(error));
|
2015-04-05 06:19:52 -07:00
|
|
|
}
|
2015-04-05 06:19:45 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Callbacks
|
|
|
|
* Ecore Events
|
|
|
|
*/
|
|
|
|
static Eina_Bool
|
2016-06-14 15:33:41 -07:00
|
|
|
_efl_model_evt_added_ecore_cb(void *data, int type, void *event)
|
2015-04-05 06:19:45 -07:00
|
|
|
{
|
2016-06-14 15:33:41 -07:00
|
|
|
Eio_Monitor_Event *evt = event;
|
2015-04-05 06:19:45 -07:00
|
|
|
Eio_Model_Data *priv = data;
|
2015-04-05 06:19:59 -07:00
|
|
|
Efl_Model_Children_Event cevt;
|
2015-04-05 06:19:45 -07:00
|
|
|
Eina_Value path;
|
|
|
|
|
2016-06-14 15:33:41 -07:00
|
|
|
if (type != EIO_MONITOR_DIRECTORY_CREATED && type != EIO_MONITOR_FILE_CREATED)
|
|
|
|
return EINA_TRUE;
|
|
|
|
|
|
|
|
char *dir = ecore_file_dir_get(evt->filename);
|
|
|
|
if (strcmp(priv->path, dir) != 0)
|
|
|
|
{
|
|
|
|
free(dir);
|
|
|
|
return EINA_TRUE;
|
|
|
|
}
|
|
|
|
free(dir);
|
|
|
|
|
|
|
|
if (priv->children_list)
|
|
|
|
{
|
|
|
|
Eina_List* cur = priv->children_list;
|
|
|
|
Eina_Stringshare *spath = eina_stringshare_add(evt->filename);
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 0; cur; ++i, cur = cur->next)
|
|
|
|
{
|
2016-08-15 06:44:41 -07:00
|
|
|
Eio_Model_Data *cur_priv = efl_data_scope_get(cur->data, MY_CLASS);
|
2016-06-14 15:33:41 -07:00
|
|
|
if(cur_priv->path == spath)
|
|
|
|
{
|
|
|
|
eina_stringshare_del(spath);
|
|
|
|
return EINA_TRUE;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
eina_stringshare_del(spath);
|
|
|
|
}
|
|
|
|
|
2016-08-15 06:44:41 -07:00
|
|
|
cevt.child = efl_add_ref(EIO_MODEL_CLASS, priv->obj, eio_model_path_set(efl_self, evt->filename));
|
2015-04-10 13:22:37 -07:00
|
|
|
priv->children_list = eina_list_append(priv->children_list, cevt.child);
|
|
|
|
cevt.index = eina_list_count(priv->children_list);
|
2015-04-05 06:19:45 -07:00
|
|
|
|
2015-04-10 13:22:37 -07:00
|
|
|
eina_value_setup(&path, EINA_VALUE_TYPE_STRING);
|
|
|
|
eina_value_set(&path, evt->filename);
|
2016-03-01 10:06:28 -08:00
|
|
|
eio_model_children_filter_set(cevt.child, priv->filter_cb, priv->filter_userdata);
|
2015-04-10 13:22:37 -07:00
|
|
|
eina_value_flush(&path);
|
2015-04-05 06:19:45 -07:00
|
|
|
|
2016-08-29 16:13:22 -07:00
|
|
|
efl_event_callback_call(priv->obj, EFL_MODEL_EVENT_CHILD_ADDED, &cevt);
|
2015-04-05 06:19:45 -07:00
|
|
|
|
|
|
|
return EINA_TRUE;
|
|
|
|
}
|
|
|
|
|
|
|
|
static Eina_Bool
|
2016-06-14 15:33:41 -07:00
|
|
|
_efl_model_evt_deleted_ecore_cb(void *data, int type, void *event)
|
2015-04-05 06:19:45 -07:00
|
|
|
{
|
2016-06-14 15:33:41 -07:00
|
|
|
Eio_Monitor_Event *evt = event;
|
2015-04-05 06:19:45 -07:00
|
|
|
Eio_Model_Data *priv = data;
|
|
|
|
|
2016-06-14 15:33:41 -07:00
|
|
|
if (type != EIO_MONITOR_DIRECTORY_DELETED && type != EIO_MONITOR_FILE_DELETED)
|
|
|
|
return EINA_TRUE;
|
|
|
|
|
2015-04-05 06:19:53 -07:00
|
|
|
if (priv->children_list)
|
2015-04-05 06:19:45 -07:00
|
|
|
{
|
2015-04-05 06:19:53 -07:00
|
|
|
Eina_List* cur = priv->children_list;
|
2016-06-14 15:33:41 -07:00
|
|
|
Eina_Stringshare *spath = eina_stringshare_add(evt->filename);
|
2015-04-05 06:19:53 -07:00
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 0; cur; ++i, cur = cur->next)
|
|
|
|
{
|
2016-08-15 06:44:41 -07:00
|
|
|
Eio_Model_Data *cur_priv = efl_data_scope_get(cur->data, MY_CLASS);
|
2016-06-14 15:33:41 -07:00
|
|
|
if(cur_priv->path == spath)
|
2015-04-05 06:19:53 -07:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (cur)
|
|
|
|
{
|
2015-04-05 06:19:59 -07:00
|
|
|
Efl_Model_Children_Event cevt;
|
2015-04-05 06:19:53 -07:00
|
|
|
cevt.index = i;
|
|
|
|
cevt.child = cur->data;
|
|
|
|
|
2016-08-29 16:13:22 -07:00
|
|
|
efl_event_callback_call(priv->obj, EFL_MODEL_EVENT_CHILD_REMOVED, &cevt);
|
2015-04-05 06:19:53 -07:00
|
|
|
|
|
|
|
priv->children_list = eina_list_remove_list(priv->children_list, cur);
|
2016-08-15 06:44:41 -07:00
|
|
|
efl_unref(cevt.child);
|
2015-04-05 06:19:53 -07:00
|
|
|
}
|
2016-06-14 15:33:41 -07:00
|
|
|
|
|
|
|
eina_stringshare_del(spath);
|
2015-04-05 06:19:45 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
return EINA_TRUE;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_eio_monitors_list_load(Eio_Model_Data *priv)
|
|
|
|
{
|
|
|
|
priv->mon.mon_event_child_add[0] = EIO_MONITOR_DIRECTORY_CREATED;
|
|
|
|
priv->mon.mon_event_child_add[1] = EIO_MONITOR_FILE_CREATED;
|
|
|
|
priv->mon.mon_event_child_add[2] = EIO_MONITOR_ERROR;
|
|
|
|
priv->mon.mon_event_child_del[0] = EIO_MONITOR_DIRECTORY_DELETED;
|
|
|
|
priv->mon.mon_event_child_del[1] = EIO_MONITOR_FILE_DELETED;
|
|
|
|
priv->mon.mon_event_child_del[2] = EIO_MONITOR_ERROR;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Callbacks
|
|
|
|
* Child Del
|
|
|
|
*/
|
|
|
|
static Eina_Bool
|
|
|
|
_eio_filter_child_del_cb(void *data EINA_UNUSED, Eio_File *handler EINA_UNUSED, const Eina_File_Direct_Info *info EINA_UNUSED)
|
|
|
|
{
|
|
|
|
return EINA_TRUE;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_eio_progress_child_del_cb(void *data EINA_UNUSED, Eio_File *handler EINA_UNUSED, const Eio_Progress *info EINA_UNUSED)
|
|
|
|
{}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_eio_done_unlink_cb(void *data, Eio_File *handler EINA_UNUSED)
|
|
|
|
{
|
|
|
|
Eio_Model_Data *priv = data;
|
|
|
|
|
|
|
|
EINA_SAFETY_ON_NULL_RETURN(priv);
|
|
|
|
EINA_SAFETY_ON_NULL_RETURN(priv->obj);
|
|
|
|
|
2016-08-15 06:44:41 -07:00
|
|
|
efl_unref(priv->obj);
|
2015-04-05 06:19:45 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_eio_error_unlink_cb(void *data EINA_UNUSED, Eio_File *handler EINA_UNUSED, int error)
|
|
|
|
{
|
|
|
|
Eio_Model_Data *priv = data;
|
|
|
|
|
2015-04-05 06:19:52 -07:00
|
|
|
ERR("%d: %s.", error, strerror(error));
|
2015-04-05 06:19:45 -07:00
|
|
|
|
2016-08-15 06:44:41 -07:00
|
|
|
efl_unref(priv->obj);
|
2015-04-05 06:19:45 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Interfaces impl.
|
|
|
|
*/
|
2016-04-20 13:07:53 -07:00
|
|
|
static Eina_Array const *
|
2016-05-10 03:36:13 -07:00
|
|
|
_eio_model_efl_model_properties_get(Eo *obj EINA_UNUSED, Eio_Model_Data *_pd)
|
2015-04-05 06:19:45 -07:00
|
|
|
{
|
|
|
|
Eio_Model_Data *priv = _pd;
|
|
|
|
|
2016-04-20 13:07:53 -07:00
|
|
|
EINA_SAFETY_ON_NULL_RETURN_VAL(priv, NULL);
|
|
|
|
EINA_SAFETY_ON_NULL_RETURN_VAL(priv->obj, NULL);
|
2015-04-05 06:19:45 -07:00
|
|
|
|
2016-04-20 13:07:53 -07:00
|
|
|
return priv->properties_name;
|
2015-04-05 06:19:45 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2015-04-05 06:19:55 -07:00
|
|
|
* Property Get
|
2015-04-05 06:19:45 -07:00
|
|
|
*/
|
2016-06-16 17:50:37 -07:00
|
|
|
static Eina_Promise*
|
|
|
|
_eio_model_efl_model_property_get(Eo *obj EINA_UNUSED, Eio_Model_Data *priv, const char *property)
|
2015-04-05 06:19:45 -07:00
|
|
|
{
|
2016-04-20 13:07:53 -07:00
|
|
|
_Eio_Property_Name property_name;
|
|
|
|
const char* value = NULL;
|
2016-06-16 17:50:37 -07:00
|
|
|
Eina_Promise_Owner *promise = eina_promise_add();
|
|
|
|
Eina_Promise *rpromise = eina_promise_owner_promise_get(promise);
|
|
|
|
|
|
|
|
EINA_SAFETY_ON_NULL_RETURN_VAL(priv, rpromise);
|
2015-04-05 06:19:45 -07:00
|
|
|
|
2016-04-20 13:07:53 -07:00
|
|
|
if (property == NULL)
|
2015-04-05 06:19:55 -07:00
|
|
|
{
|
2016-04-20 13:07:53 -07:00
|
|
|
eina_promise_owner_error_set(promise, EFL_MODEL_ERROR_NOT_FOUND);
|
2016-06-16 17:50:37 -07:00
|
|
|
return rpromise;
|
2016-04-20 13:07:53 -07:00
|
|
|
}
|
2015-04-05 06:19:55 -07:00
|
|
|
|
2016-06-05 17:21:43 -07:00
|
|
|
if(strcmp(_eio_model_prop_names[EIO_MODEL_PROP_FILENAME], property) == 0)
|
2016-04-20 13:07:53 -07:00
|
|
|
{
|
2016-06-14 15:33:41 -07:00
|
|
|
char* tmp = strdup(priv->path);
|
|
|
|
char* basename_ = basename(tmp);
|
|
|
|
value = strdup(basename_);
|
2016-04-20 13:07:53 -07:00
|
|
|
property_name = EIO_MODEL_PROP_FILENAME;
|
2016-06-14 15:33:41 -07:00
|
|
|
free(tmp);
|
2016-04-20 13:07:53 -07:00
|
|
|
}
|
2016-06-05 17:21:43 -07:00
|
|
|
else if(strcmp(_eio_model_prop_names[EIO_MODEL_PROP_PATH], property) == 0)
|
2016-04-20 13:07:53 -07:00
|
|
|
{
|
|
|
|
value = priv->path;
|
|
|
|
property_name = EIO_MODEL_PROP_PATH;
|
|
|
|
}
|
2016-06-05 17:21:43 -07:00
|
|
|
else if(strcmp(_eio_model_prop_names[EIO_MODEL_PROP_MIME_TYPE], property) == 0)
|
|
|
|
{
|
|
|
|
value = efreet_mime_type_get(priv->path);
|
|
|
|
if (value == NULL)
|
|
|
|
{
|
|
|
|
eina_promise_owner_error_set(promise, EFL_MODEL_ERROR_NOT_FOUND);
|
2016-06-16 17:50:37 -07:00
|
|
|
return rpromise;
|
2016-06-05 17:21:43 -07:00
|
|
|
}
|
|
|
|
property_name = EIO_MODEL_PROP_MIME_TYPE;
|
|
|
|
}
|
|
|
|
else if(strcmp(_eio_model_prop_names[EIO_MODEL_PROP_MTIME], property) == 0)
|
2016-04-20 13:07:53 -07:00
|
|
|
property_name = EIO_MODEL_PROP_MTIME;
|
2016-06-05 17:21:43 -07:00
|
|
|
else if(strcmp(_eio_model_prop_names[EIO_MODEL_PROP_IS_DIR], property) == 0)
|
2016-04-20 13:07:53 -07:00
|
|
|
property_name = EIO_MODEL_PROP_IS_DIR;
|
2016-06-05 17:21:43 -07:00
|
|
|
else if(strcmp(_eio_model_prop_names[EIO_MODEL_PROP_IS_LNK], property) == 0)
|
2016-04-20 13:07:53 -07:00
|
|
|
property_name = EIO_MODEL_PROP_IS_LNK;
|
2016-06-05 17:21:43 -07:00
|
|
|
else if(strcmp(_eio_model_prop_names[EIO_MODEL_PROP_SIZE], property) == 0)
|
2016-04-20 13:07:53 -07:00
|
|
|
property_name = EIO_MODEL_PROP_SIZE;
|
|
|
|
else
|
|
|
|
{
|
|
|
|
eina_promise_owner_error_set(promise, EFL_MODEL_ERROR_NOT_FOUND);
|
2016-06-16 17:50:37 -07:00
|
|
|
return rpromise;
|
2015-04-05 06:19:55 -07:00
|
|
|
}
|
2015-04-05 06:19:45 -07:00
|
|
|
|
2016-04-20 13:07:53 -07:00
|
|
|
switch(property_name)
|
|
|
|
{
|
|
|
|
case EIO_MODEL_PROP_FILENAME:
|
|
|
|
case EIO_MODEL_PROP_PATH:
|
2016-06-05 17:21:43 -07:00
|
|
|
case EIO_MODEL_PROP_MIME_TYPE:
|
2016-04-20 13:07:53 -07:00
|
|
|
{
|
2016-06-08 15:33:29 -07:00
|
|
|
Eina_Value* v = eina_value_new(EINA_VALUE_TYPE_STRING);
|
2016-04-20 13:07:53 -07:00
|
|
|
eina_value_set(v, value);
|
2016-06-08 15:33:29 -07:00
|
|
|
eina_promise_owner_value_set(promise, v, (Eina_Promise_Free_Cb)&eina_value_free);
|
2016-04-20 13:07:53 -07:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
{
|
|
|
|
_Eio_Property_Promise* p = calloc(1, sizeof(_Eio_Property_Promise));
|
|
|
|
p->promise = promise;
|
|
|
|
p->property = property_name;;
|
|
|
|
priv->property_promises = eina_list_prepend(priv->property_promises, p);
|
|
|
|
|
|
|
|
if(!priv->stat_file)
|
|
|
|
_eio_stat_do(priv);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
2016-06-16 17:50:37 -07:00
|
|
|
return rpromise;
|
2015-04-05 06:19:45 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Property Set
|
|
|
|
*/
|
2016-04-20 13:07:53 -07:00
|
|
|
static void
|
2016-05-10 03:36:13 -07:00
|
|
|
_eio_model_efl_model_property_set(Eo *obj EINA_UNUSED,
|
2016-04-20 13:07:53 -07:00
|
|
|
Eio_Model_Data *priv,
|
|
|
|
const char * property,
|
|
|
|
const Eina_Value *value,
|
|
|
|
Eina_Promise_Owner *promise)
|
2015-04-05 06:19:45 -07:00
|
|
|
{
|
|
|
|
char *dest;
|
|
|
|
|
2016-04-20 13:07:53 -07:00
|
|
|
EINA_SAFETY_ON_NULL_RETURN(property);
|
2015-04-05 06:19:45 -07:00
|
|
|
|
|
|
|
if (strcmp(property, "path") != 0)
|
2016-04-20 13:07:53 -07:00
|
|
|
{
|
|
|
|
eina_promise_owner_error_set(promise, EFL_MODEL_ERROR_NOT_SUPPORTED);
|
|
|
|
return;
|
|
|
|
}
|
2015-04-05 06:19:45 -07:00
|
|
|
|
2016-06-14 15:33:41 -07:00
|
|
|
eina_value_get(value, &dest);
|
2016-06-05 16:52:52 -07:00
|
|
|
if (priv->path == NULL || !ecore_file_exists(priv->path))
|
2015-04-05 06:19:45 -07:00
|
|
|
{
|
2016-06-14 15:33:41 -07:00
|
|
|
eina_stringshare_replace(&priv->path, dest);
|
2015-04-05 06:19:45 -07:00
|
|
|
|
2016-06-14 15:33:41 -07:00
|
|
|
if (!ecore_file_exists(priv->path))
|
2016-06-05 16:52:52 -07:00
|
|
|
{
|
|
|
|
eina_promise_owner_error_set(promise, EFL_MODEL_ERROR_NOT_FOUND);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2016-06-14 15:33:41 -07:00
|
|
|
char* tmp = strdup(priv->path);
|
|
|
|
char* basename_ = basename(tmp);
|
|
|
|
INF("path '%s' with filename '%s'.", priv->path, basename_);
|
|
|
|
free(tmp);
|
|
|
|
(void)basename_;
|
2015-04-05 06:19:45 -07:00
|
|
|
|
2015-04-05 06:19:53 -07:00
|
|
|
_eio_monitors_list_load(priv);
|
2015-04-05 06:19:45 -07:00
|
|
|
|
2015-04-05 06:19:53 -07:00
|
|
|
_eio_move_done_cb(priv, NULL);
|
2016-04-20 13:07:53 -07:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2016-06-14 15:33:41 -07:00
|
|
|
priv->move_file = eio_file_move(priv->path, dest, _eio_progress_cb, _eio_move_done_cb, _eio_prop_set_error_cb, priv);
|
|
|
|
eina_stringshare_replace(&priv->path, dest);
|
2015-04-05 06:19:45 -07:00
|
|
|
}
|
|
|
|
|
2016-04-20 13:07:53 -07:00
|
|
|
eina_promise_owner_value_set(promise, &value, NULL);
|
2015-04-05 06:19:45 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2016-04-20 13:07:53 -07:00
|
|
|
* Children Count Get
|
2015-04-05 06:19:45 -07:00
|
|
|
*/
|
2016-06-16 17:50:37 -07:00
|
|
|
static Eina_Promise*
|
|
|
|
_eio_model_efl_model_children_count_get(Eo *obj EINA_UNUSED, Eio_Model_Data *priv)
|
2015-04-05 06:19:45 -07:00
|
|
|
{
|
2016-06-16 17:50:37 -07:00
|
|
|
Eina_Promise_Owner *promise = eina_promise_add();
|
|
|
|
Eina_Promise* rpromise = eina_promise_owner_promise_get(promise);
|
2016-06-08 15:33:29 -07:00
|
|
|
unsigned int *c = calloc(sizeof(unsigned int), 1);
|
|
|
|
*c = eina_list_count(priv->children_list);
|
|
|
|
eina_promise_owner_value_set(promise, c, free);
|
2016-06-16 17:50:37 -07:00
|
|
|
return rpromise;
|
2015-04-05 06:19:45 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2016-05-10 03:36:13 -07:00
|
|
|
_eio_model_efl_model_monitor_add(Eio_Model_Data *priv)
|
2015-04-05 06:19:45 -07:00
|
|
|
{
|
2015-04-05 06:19:53 -07:00
|
|
|
if (!priv->monitor)
|
2015-04-05 06:19:45 -07:00
|
|
|
{
|
2015-04-05 06:19:53 -07:00
|
|
|
priv->monitor = eio_monitor_add(priv->path);
|
|
|
|
int i = 0;
|
|
|
|
|
|
|
|
for (i = 0; priv->mon.mon_event_child_add[i] != EIO_MONITOR_ERROR ; ++i)
|
|
|
|
priv->mon.ecore_child_add_handler[i] =
|
2015-04-05 06:19:59 -07:00
|
|
|
ecore_event_handler_add(priv->mon.mon_event_child_add[i], _efl_model_evt_added_ecore_cb, priv);
|
2015-04-05 06:19:53 -07:00
|
|
|
|
|
|
|
for (i = 0; priv->mon.mon_event_child_del[i] != EIO_MONITOR_ERROR ; ++i)
|
2016-06-14 15:33:41 -07:00
|
|
|
priv->mon.ecore_child_del_handler[i] =
|
2015-04-05 06:19:59 -07:00
|
|
|
ecore_event_handler_add(priv->mon.mon_event_child_del[i], _efl_model_evt_deleted_ecore_cb, priv);
|
2015-04-05 06:19:45 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-06-14 15:33:41 -07:00
|
|
|
static void
|
|
|
|
_eio_model_efl_model_monitor_del(Eio_Model_Data *priv)
|
|
|
|
{
|
|
|
|
if (priv->monitor)
|
|
|
|
{
|
|
|
|
int i = 0;
|
|
|
|
for (i = 0; priv->mon.mon_event_child_add[i] != EIO_MONITOR_ERROR ; ++i)
|
|
|
|
ecore_event_handler_del(priv->mon.ecore_child_add_handler[i]);
|
|
|
|
|
|
|
|
for (i = 0; priv->mon.mon_event_child_del[i] != EIO_MONITOR_ERROR ; ++i)
|
|
|
|
ecore_event_handler_del(priv->mon.ecore_child_del_handler[i]);
|
|
|
|
|
|
|
|
eio_monitor_del(priv->monitor);
|
|
|
|
priv->monitor = NULL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-04-05 06:19:45 -07:00
|
|
|
/*
|
|
|
|
* Callbacks
|
|
|
|
* Children Load
|
|
|
|
*/
|
|
|
|
static Eina_Bool
|
|
|
|
_eio_filter_children_load_cb(void *data, Eio_File *handler, const Eina_File_Direct_Info *info)
|
|
|
|
{
|
|
|
|
Eio_Model_Data *priv = data;
|
|
|
|
EINA_SAFETY_ON_NULL_RETURN_VAL(priv, EINA_FALSE);
|
|
|
|
|
2015-04-10 13:22:37 -07:00
|
|
|
eina_spinlock_take(&priv->filter_lock);
|
2015-04-05 06:19:45 -07:00
|
|
|
if (priv->filter_cb)
|
|
|
|
{
|
2015-04-10 13:22:37 -07:00
|
|
|
Eina_Bool r = priv->filter_cb(priv->filter_userdata, handler, info);
|
|
|
|
eina_spinlock_release(&priv->filter_lock);
|
|
|
|
return r;
|
2015-04-05 06:19:45 -07:00
|
|
|
}
|
2015-04-10 13:22:37 -07:00
|
|
|
else
|
|
|
|
eina_spinlock_release(&priv->filter_lock);
|
2015-04-05 06:19:45 -07:00
|
|
|
|
|
|
|
return EINA_TRUE;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_eio_main_children_load_cb(void *data, Eio_File *handler EINA_UNUSED, const Eina_File_Direct_Info *info)
|
|
|
|
{
|
|
|
|
Eo *child;
|
|
|
|
Eio_Model_Data *priv = data;
|
|
|
|
EINA_SAFETY_ON_NULL_RETURN(priv);
|
|
|
|
|
2016-08-15 06:44:41 -07:00
|
|
|
child = efl_add_ref(MY_CLASS, priv->obj, eio_model_path_set(efl_self, info->path));
|
2015-04-10 13:22:37 -07:00
|
|
|
eina_spinlock_take(&priv->filter_lock);
|
2015-04-05 06:19:45 -07:00
|
|
|
if (priv->filter_cb)
|
2016-03-01 10:06:28 -08:00
|
|
|
eio_model_children_filter_set(child, priv->filter_cb, priv->filter_userdata);
|
2015-04-10 13:22:37 -07:00
|
|
|
eina_spinlock_release(&priv->filter_lock);
|
2015-04-05 06:19:49 -07:00
|
|
|
|
2015-04-05 06:19:45 -07:00
|
|
|
priv->children_list = eina_list_append(priv->children_list, child);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_eio_done_children_load_cb(void *data, Eio_File *handler EINA_UNUSED)
|
|
|
|
{
|
|
|
|
Eio_Model_Data *priv = data;
|
|
|
|
EINA_SAFETY_ON_NULL_RETURN(priv);
|
|
|
|
|
2016-04-20 13:07:53 -07:00
|
|
|
eio_file_cancel(priv->listing_file);
|
|
|
|
priv->listing_file = NULL;
|
|
|
|
priv->is_listed = EINA_TRUE;
|
|
|
|
priv->is_listing = EINA_FALSE;
|
2015-04-05 06:19:45 -07:00
|
|
|
|
2016-06-14 15:33:41 -07:00
|
|
|
_eio_model_efl_model_monitor_add(priv);
|
|
|
|
|
2016-04-20 13:07:53 -07:00
|
|
|
Eina_List* i;
|
|
|
|
_Eio_Children_Slice_Promise* p;
|
|
|
|
EINA_LIST_FOREACH(priv->children_promises, i, p)
|
|
|
|
{
|
|
|
|
Eina_Accessor* accessor = efl_model_list_slice(priv->children_list, p->start, p->count);
|
2016-06-05 18:24:52 -07:00
|
|
|
eina_promise_owner_value_set(p->promise, accessor, (Eina_Promise_Free_Cb)&eina_accessor_free);
|
2016-04-20 13:07:53 -07:00
|
|
|
free(p);
|
|
|
|
}
|
|
|
|
|
|
|
|
eina_list_free(priv->children_promises);
|
|
|
|
priv->children_promises = NULL;
|
2015-04-05 06:19:45 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_eio_error_children_load_cb(void *data, Eio_File *handler EINA_UNUSED, int error)
|
|
|
|
{
|
|
|
|
Eio_Model_Data *priv = data;
|
|
|
|
Eo *child;
|
2015-04-05 06:19:52 -07:00
|
|
|
|
2015-04-09 18:46:24 -07:00
|
|
|
WRN("%d: %s.", error, strerror(error));
|
2015-04-05 06:19:52 -07:00
|
|
|
|
2015-04-05 06:19:45 -07:00
|
|
|
EINA_LIST_FREE(priv->children_list, child)
|
2016-08-15 06:44:41 -07:00
|
|
|
efl_unref(child);
|
2015-04-05 06:19:45 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_eio_model_children_filter_set(Eo *obj EINA_UNUSED, Eio_Model_Data *priv, Eio_Filter_Direct_Cb filter_cb, void *data)
|
|
|
|
{
|
2015-04-10 13:22:37 -07:00
|
|
|
eina_spinlock_take(&priv->filter_lock);
|
2016-06-05 16:31:21 -07:00
|
|
|
|
2015-04-05 06:19:45 -07:00
|
|
|
priv->filter_cb = filter_cb;
|
|
|
|
priv->filter_userdata = data;
|
2015-04-10 13:22:37 -07:00
|
|
|
|
|
|
|
eina_spinlock_release(&priv->filter_lock);
|
2015-04-05 06:19:45 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Child Add
|
|
|
|
*/
|
|
|
|
static Eo *
|
2016-05-10 03:36:13 -07:00
|
|
|
_eio_model_efl_model_child_add(Eo *obj EINA_UNUSED, Eio_Model_Data *priv EINA_UNUSED)
|
2015-04-05 06:19:45 -07:00
|
|
|
{
|
2016-08-15 06:44:41 -07:00
|
|
|
return efl_add(EIO_MODEL_CLASS, obj);
|
2015-04-05 06:19:45 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2016-05-10 03:36:13 -07:00
|
|
|
_eio_model_efl_model_child_del_stat(void* data, Eio_File* handler EINA_UNUSED, const Eina_Stat* stat)
|
2015-04-05 06:19:45 -07:00
|
|
|
{
|
|
|
|
Eo* child = data;
|
2016-08-15 06:44:41 -07:00
|
|
|
Eio_Model_Data *child_priv = efl_data_scope_get(child, MY_CLASS);
|
2015-04-05 06:19:45 -07:00
|
|
|
|
|
|
|
if(eio_file_is_dir(stat))
|
|
|
|
eio_dir_unlink(child_priv->path,
|
|
|
|
_eio_filter_child_del_cb,
|
|
|
|
_eio_progress_child_del_cb,
|
|
|
|
_eio_done_unlink_cb,
|
|
|
|
_eio_error_unlink_cb,
|
|
|
|
child_priv);
|
|
|
|
else
|
|
|
|
eio_file_unlink(child_priv->path, _eio_done_unlink_cb, _eio_error_unlink_cb, child_priv);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Child Remove
|
|
|
|
*/
|
2016-04-20 13:07:53 -07:00
|
|
|
static void
|
2016-05-10 03:36:13 -07:00
|
|
|
_eio_model_efl_model_child_del(Eo *obj EINA_UNUSED, Eio_Model_Data *priv, Eo *child)
|
2015-04-05 06:19:45 -07:00
|
|
|
{
|
|
|
|
Eio_Model_Data *child_priv;
|
2016-04-20 13:07:53 -07:00
|
|
|
EINA_SAFETY_ON_NULL_RETURN(child);
|
2015-04-05 06:19:45 -07:00
|
|
|
|
2016-08-15 06:44:41 -07:00
|
|
|
child_priv = efl_data_scope_get(child, MY_CLASS);
|
2016-04-20 13:07:53 -07:00
|
|
|
EINA_SAFETY_ON_NULL_RETURN(child_priv);
|
2015-04-05 06:19:45 -07:00
|
|
|
|
2016-04-20 13:07:53 -07:00
|
|
|
priv->del_file = eio_file_direct_stat(child_priv->path,
|
2016-05-10 03:36:13 -07:00
|
|
|
&_eio_model_efl_model_child_del_stat,
|
2016-04-20 13:07:53 -07:00
|
|
|
&_eio_error_unlink_cb,
|
|
|
|
child);
|
2016-08-15 06:44:41 -07:00
|
|
|
efl_ref(child);
|
2015-04-05 06:19:45 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Children Slice Get
|
|
|
|
*/
|
2016-06-16 17:50:37 -07:00
|
|
|
static Eina_Promise*
|
2016-05-10 03:36:13 -07:00
|
|
|
_eio_model_efl_model_children_slice_get(Eo *obj EINA_UNUSED, Eio_Model_Data *priv,
|
2016-06-16 17:50:37 -07:00
|
|
|
unsigned int start, unsigned int count)
|
2015-04-05 06:19:45 -07:00
|
|
|
{
|
2016-06-16 17:50:37 -07:00
|
|
|
Eina_Promise_Owner *promise = eina_promise_add();
|
|
|
|
Eina_Promise* rpromise = eina_promise_owner_promise_get(promise);
|
2015-04-05 06:19:45 -07:00
|
|
|
/**
|
|
|
|
* children must be already loaded otherwise we do nothing
|
|
|
|
* and parameter is set to NULL.
|
|
|
|
*/
|
2016-06-05 16:31:21 -07:00
|
|
|
if (!priv->path)
|
|
|
|
{
|
|
|
|
eina_promise_owner_error_set(promise, EFL_MODEL_ERROR_INIT_FAILED);
|
2016-06-16 17:50:37 -07:00
|
|
|
return rpromise;
|
2016-06-05 16:31:21 -07:00
|
|
|
}
|
2015-04-05 06:19:45 -07:00
|
|
|
|
2016-04-20 13:07:53 -07:00
|
|
|
if (!(priv->is_listed))
|
2015-04-05 06:19:45 -07:00
|
|
|
{
|
2016-04-20 13:07:53 -07:00
|
|
|
_Eio_Children_Slice_Promise* p = calloc(1, sizeof(struct _Eio_Children_Slice_Promise));
|
|
|
|
p->promise = promise;
|
|
|
|
p->start = start;
|
|
|
|
p->count = count;
|
2015-04-05 06:19:45 -07:00
|
|
|
|
2016-04-20 13:07:53 -07:00
|
|
|
priv->children_promises = eina_list_prepend(priv->children_promises, p);
|
2015-04-05 06:19:53 -07:00
|
|
|
|
2016-04-20 13:07:53 -07:00
|
|
|
|
|
|
|
if (priv->is_listing == EINA_FALSE)
|
|
|
|
{
|
|
|
|
priv->is_listing = EINA_TRUE;
|
|
|
|
eio_file_direct_ls(priv->path, _eio_filter_children_load_cb,
|
|
|
|
_eio_main_children_load_cb, _eio_done_children_load_cb,
|
|
|
|
_eio_error_children_load_cb, priv);
|
|
|
|
}
|
2016-06-16 17:50:37 -07:00
|
|
|
return rpromise;
|
2015-04-05 06:19:45 -07:00
|
|
|
}
|
|
|
|
|
2016-04-20 13:07:53 -07:00
|
|
|
Eina_Accessor* accessor = efl_model_list_slice(priv->children_list, start, count);
|
2016-06-05 18:24:52 -07:00
|
|
|
eina_promise_owner_value_set(promise, accessor, (Eina_Promise_Free_Cb)&eina_accessor_free);
|
2016-06-16 17:50:37 -07:00
|
|
|
return rpromise;
|
2015-04-05 06:19:45 -07:00
|
|
|
}
|
|
|
|
|
2016-04-20 13:07:53 -07:00
|
|
|
|
2015-04-05 06:19:45 -07:00
|
|
|
/**
|
|
|
|
* Class definitions
|
|
|
|
*/
|
2015-05-19 03:41:27 -07:00
|
|
|
static Eo *
|
2016-08-10 07:23:04 -07:00
|
|
|
_eio_model_efl_object_constructor(Eo *obj, Eio_Model_Data *priv)
|
2015-04-05 06:19:45 -07:00
|
|
|
{
|
2016-08-15 06:44:41 -07:00
|
|
|
obj = efl_constructor(efl_super(obj, MY_CLASS));
|
2015-04-05 06:19:55 -07:00
|
|
|
unsigned int i;
|
2015-04-05 06:19:45 -07:00
|
|
|
priv->obj = obj;
|
2016-04-20 13:07:53 -07:00
|
|
|
priv->is_listed = priv->is_listing = EINA_FALSE;
|
2015-04-05 06:19:55 -07:00
|
|
|
|
|
|
|
priv->properties_name = eina_array_new(EIO_MODEL_PROP_LAST);
|
2015-05-19 03:41:27 -07:00
|
|
|
EINA_SAFETY_ON_NULL_RETURN_VAL(priv->properties_name, NULL);
|
2015-04-05 06:19:55 -07:00
|
|
|
for (i = 0; i < EIO_MODEL_PROP_LAST; ++i)
|
|
|
|
eina_array_push(priv->properties_name, _eio_model_prop_names[i]);
|
|
|
|
|
2015-04-05 06:19:45 -07:00
|
|
|
priv->monitor = NULL;
|
2015-04-10 13:22:37 -07:00
|
|
|
eina_spinlock_new(&priv->filter_lock);
|
2015-05-19 03:41:27 -07:00
|
|
|
|
|
|
|
return obj;
|
2015-04-05 06:19:45 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_eio_model_path_set(Eo *obj EINA_UNUSED, Eio_Model_Data *priv, const char *path)
|
|
|
|
{
|
2016-06-14 15:33:41 -07:00
|
|
|
priv->path = eina_stringshare_add(path);
|
2015-04-05 06:19:45 -07:00
|
|
|
_eio_monitors_list_load(priv);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2016-08-10 07:23:04 -07:00
|
|
|
_eio_model_efl_object_destructor(Eo *obj , Eio_Model_Data *priv)
|
2015-04-05 06:19:45 -07:00
|
|
|
{
|
|
|
|
Eo *child;
|
2015-04-05 06:19:49 -07:00
|
|
|
|
2016-06-14 15:33:41 -07:00
|
|
|
_eio_model_efl_model_monitor_del(priv);
|
2015-04-05 06:19:45 -07:00
|
|
|
|
2015-04-10 13:22:37 -07:00
|
|
|
eina_spinlock_free(&priv->filter_lock);
|
|
|
|
|
2015-04-05 06:19:55 -07:00
|
|
|
if (priv->properties_name)
|
|
|
|
eina_array_free(priv->properties_name);
|
2015-04-05 06:19:49 -07:00
|
|
|
|
2015-04-05 06:19:45 -07:00
|
|
|
EINA_LIST_FREE(priv->children_list, child)
|
2016-08-15 06:44:41 -07:00
|
|
|
efl_unref(child);
|
2015-04-05 06:19:45 -07:00
|
|
|
|
2016-06-14 15:33:41 -07:00
|
|
|
eina_stringshare_del(priv->path);
|
2016-08-15 06:44:41 -07:00
|
|
|
efl_destructor(efl_super(obj, MY_CLASS));
|
2015-04-05 06:19:45 -07:00
|
|
|
}
|
|
|
|
|
2016-06-05 16:52:52 -07:00
|
|
|
|
|
|
|
static Eo *
|
2016-08-10 07:23:04 -07:00
|
|
|
_eio_model_efl_object_parent_get(Eo *obj , Eio_Model_Data *priv)
|
2016-06-05 16:52:52 -07:00
|
|
|
{
|
2016-08-15 06:44:41 -07:00
|
|
|
Eo *model = efl_parent_get(efl_super(obj, MY_CLASS));
|
2016-06-05 16:52:52 -07:00
|
|
|
|
2016-08-15 06:44:41 -07:00
|
|
|
if (model == NULL || !efl_isa(model, EFL_MODEL_INTERFACE))
|
2016-06-05 16:52:52 -07:00
|
|
|
{
|
|
|
|
char *path = ecore_file_dir_get(priv->path);
|
|
|
|
if (path != NULL && strcmp(priv->path, "/") != 0)
|
|
|
|
{
|
2016-08-15 06:44:41 -07:00
|
|
|
model = efl_add(MY_CLASS, NULL, eio_model_path_set(efl_self, path));
|
2016-06-05 16:52:52 -07:00
|
|
|
}
|
|
|
|
else
|
|
|
|
model = NULL;
|
|
|
|
|
|
|
|
free(path);
|
|
|
|
}
|
|
|
|
return model;
|
|
|
|
}
|
2015-04-05 06:19:45 -07:00
|
|
|
#include "eio_model.eo.c"
|