EAPI const Eolian_Type *
eolian_function_return_type_get(const Eolian_Function *fid, Eolian_Function_Type ftype)
{
EINA_SAFETY_ON_NULL_RETURN_VAL(fid, NULL);
EINA_SAFETY_ON_FALSE_RETURN_VAL(ftype != EOLIAN_UNRESOLVED, NULL);
EINA_SAFETY_ON_FALSE_RETURN_VAL(ftype != EOLIAN_PROPERTY, NULL);
switch (ftype)
{
case EOLIAN_METHOD:
if (fid->type != EOLIAN_METHOD)
return NULL;
return fid->get_ret_type;
case EOLIAN_PROP_GET:
if ((fid->type != EOLIAN_PROP_GET) && (fid->type != EOLIAN_PROPERTY))
return NULL;
return fid->get_ret_type;
case EOLIAN_PROP_SET:
if ((fid->type != EOLIAN_PROP_SET) && (fid->type != EOLIAN_PROPERTY))
return NULL;
return fid->set_ret_type;
case EOLIAN_FUNCTION_POINTER:
return (fid->type != EOLIAN_FUNCTION_POINTER) ? NULL : fid->get_ret_type;
default:
return NULL;
}
}
static Eina_Bool
_eldbus_message_arguments_vappend(Eldbus_Message *msg, const char *signature, va_list *aq)
{
DBusSignatureIter signature_iter;
Eldbus_Message_Iter *iter;
int type;
Eina_Bool r = EINA_TRUE;
if (!signature[0]) return EINA_TRUE;
EINA_SAFETY_ON_FALSE_RETURN_VAL(dbus_signature_validate(signature, NULL),
EINA_FALSE);
iter = eldbus_message_iter_get(msg);
EINA_SAFETY_ON_FALSE_RETURN_VAL(iter->writable, EINA_FALSE);
dbus_signature_iter_init(&signature_iter, signature);
while ((type = dbus_signature_iter_get_current_type(&signature_iter)))
{
if (dbus_type_is_basic(type))
r = append_basic(type, aq, &iter->dbus_iterator);
else
{
ERR("sig = %s | eldbus_message_arguments_append() and \
eldbus_message_arguments_vappend() only support basic types, \
to complex types use eldbus_message_iter_* functions",
signature);
r = EINA_FALSE;
}
if (!r || !dbus_signature_iter_next(&signature_iter))
break;
}
return r;
}
/**
* @brief Create a new Sparse Matrix.
*
* @param rows number of rows in matrix. Operations with rows greater than this
* value will fail.
* @param cols number of columns in matrix. Operations with columns greater
* than this value will fail.
* @param free_func used to delete cell data contents, used by
* eina_matrixsparse_free(), eina_matrixsparse_size_set(),
* eina_matrixsparse_row_idx_clear(),
* eina_matrixsparse_column_idx_clear(),
* eina_matrixsparse_cell_idx_clear() and possible others.
* @param user_data given to @a free_func as first parameter.
*
* @return newly allocated matrix or NULL if allocation failed and eina_error
* is set.
*/
EAPI Eina_Matrixsparse *
eina_matrixsparse_new(unsigned long rows, unsigned long cols, void (*free_func)(void *user_data, void *cell_data), const void *user_data)
{
Eina_Matrixsparse *m;
EINA_SAFETY_ON_FALSE_RETURN_VAL(rows > 0, NULL);
EINA_SAFETY_ON_FALSE_RETURN_VAL(cols > 0, NULL);
m = malloc(sizeof(Eina_Matrixsparse));
if (!m)
{
eina_error_set(EINA_ERROR_OUT_OF_MEMORY);
return NULL;
}
m->rows = NULL;
m->last_row = NULL;
m->last_used = NULL;
m->size.rows = rows;
m->size.cols = cols;
m->free.func = free_func;
m->free.user_data = (void *)user_data;
EINA_MAGIC_SET(m, EINA_MAGIC_MATRIXSPARSE);
eina_error_set(0);
return m;
}
EAPI Eina_Bool
eolian_function_return_is_warn_unused(const Eolian_Function *fid,
Eolian_Function_Type ftype)
{
EINA_SAFETY_ON_NULL_RETURN_VAL(fid, EINA_FALSE);
EINA_SAFETY_ON_FALSE_RETURN_VAL(ftype != EOLIAN_UNRESOLVED, EINA_FALSE);
EINA_SAFETY_ON_FALSE_RETURN_VAL(ftype != EOLIAN_PROPERTY, EINA_FALSE);
switch (ftype)
{
case EOLIAN_METHOD:
if (fid->type != EOLIAN_METHOD)
return EINA_FALSE;
return fid->get_return_warn_unused;
case EOLIAN_PROP_GET:
if ((fid->type != EOLIAN_PROP_GET) && (fid->type != EOLIAN_PROPERTY))
return EINA_FALSE;
return fid->get_return_warn_unused;
case EOLIAN_PROP_SET:
if ((fid->type != EOLIAN_PROP_SET) && (fid->type != EOLIAN_PROPERTY))
return EINA_FALSE;
return fid->set_return_warn_unused;
default:
return EINA_FALSE;
}
}
EAPI Eina_Bool
eldbus_message_iter_fixed_array_append(Eldbus_Message_Iter *iter, int type, const void *array, unsigned int size)
{
ELDBUS_MESSAGE_ITERATOR_CHECK_RETVAL(iter, EINA_FALSE);
EINA_SAFETY_ON_NULL_RETURN_VAL(array, EINA_FALSE);
EINA_SAFETY_ON_FALSE_RETURN_VAL(iter->writable, EINA_FALSE);
EINA_SAFETY_ON_FALSE_RETURN_VAL(dbus_type_is_basic(type), EINA_FALSE);
return dbus_message_iter_append_fixed_array(&iter->dbus_iterator, type, &array, (int)size);
}
/**
* Get the cell reference inside Sparse Matrix.
*
* @param m the sparse matrix to operate on.
* @param row the new number of row to clear.
* @param col the new number of column to clear.
* @param cell pointer to return cell reference, if any exists.
*
* @return 1 on success, 0 on failure. It is considered success if did not
* exist but index is inside matrix size, in this case @c *cell == NULL
*
* @see eina_matrixsparse_cell_data_get()
* @see eina_matrixsparse_data_idx_get()
*/
EAPI Eina_Bool
eina_matrixsparse_cell_idx_get(const Eina_Matrixsparse *m, unsigned long row, unsigned long col, Eina_Matrixsparse_Cell **cell)
{
EINA_MAGIC_CHECK_MATRIXSPARSE(m, 0);
EINA_SAFETY_ON_NULL_RETURN_VAL(cell, 0);
*cell = NULL;
EINA_SAFETY_ON_FALSE_RETURN_VAL(row < m->size.rows, 0);
EINA_SAFETY_ON_FALSE_RETURN_VAL(col < m->size.cols, 0);
*cell = _eina_matrixsparse_cell_idx_get(m, row, col);
return 1;
}
/**
* @return EINA_TRUE if info could be refreshed, else EINA_FALSE
*/
static Eina_Bool
_screen_info_refresh(void)
{
Ecore_X_Window *roots;
Ecore_X_Window root;
int n;
EINA_SAFETY_ON_FALSE_RETURN_VAL(ecore_x_randr_query(), EINA_FALSE);
if (!(roots = ecore_x_window_root_list(&n))) return EINA_FALSE;
/* first (and only) root window */
root = roots[0];
free(roots);
e_randr_screen_info.randr_version = ecore_x_randr_version_get();
e_randr_screen_info.root = root;
e_randr_screen_info.rrvd_info.randr_info_11 = NULL;
// Value set/retrieval helper functions
if (e_randr_screen_info.randr_version == ECORE_X_RANDR_1_1)
{
return _11_screen_info_refresh();
}
else if (e_randr_screen_info.randr_version >= ECORE_X_RANDR_1_2)
{
return _12_screen_info_refresh();
}
return EINA_FALSE;
}
EAPI const Eolian_Expression *
eolian_expression_unary_expression_get(const Eolian_Expression *expr)
{
EINA_SAFETY_ON_NULL_RETURN_VAL(expr, NULL);
EINA_SAFETY_ON_FALSE_RETURN_VAL(expr->type == EOLIAN_EXPR_UNARY, NULL);
return expr->expr;
}
EAPI Eina_Module *eina_module_new(const char *file)
{
Eina_Module *m;
size_t len;
EINA_SAFETY_ON_NULL_RETURN_VAL(file, NULL);
/* TODO check that the file exists. Update doc too */
len = strlen(file);
EINA_SAFETY_ON_FALSE_RETURN_VAL(len > 0, NULL);
m = malloc(sizeof(Eina_Module) + len + 1);
if (!m)
{
ERR("could not malloc(%lu)",
(unsigned long)(sizeof(Eina_Module) + len + 1));
return NULL;
}
memcpy((char *)m->file, file, len + 1);
m->ref = 0;
m->handle = NULL;
DBG("m=%p, file=%s", m, file);
return m;
}
EAPI Evas_Object *
evas_object_polygon_add(Evas *e)
{
e = evas_find(e);
EINA_SAFETY_ON_FALSE_RETURN_VAL(efl_isa(e, EVAS_CANVAS_CLASS), NULL);
return efl_add(MY_CLASS, e, efl_canvas_object_legacy_ctor(efl_added));
}
EAPI Eolian_Unary_Operator
eolian_expression_unary_operator_get(const Eolian_Expression *expr)
{
EINA_SAFETY_ON_NULL_RETURN_VAL(expr, EOLIAN_UNOP_INVALID);
EINA_SAFETY_ON_FALSE_RETURN_VAL(expr->type == EOLIAN_EXPR_UNARY,
EOLIAN_UNOP_INVALID);
return expr->unop;
}
/**
* Clear (erase) cell given its indexes.
*
* Existing cell will be cleared with @c free_func() given to
* eina_matrixsparse_new().
*
* @param m the sparse matrix to operate on.
* @param row the new number of row to clear.
* @param col the new number of column to clear.
*
* @return 1 on success, 0 on failure. It is considered success if did not
* exist but index is inside matrix size.
*
* @warning cells, rows or columns are not reference counted and thus
* after this call any reference might be invalid if instance were
* freed. Note that this call might delete container column and
* row if this cell was the last remainder.
*/
EAPI Eina_Bool
eina_matrixsparse_cell_idx_clear(Eina_Matrixsparse *m, unsigned long row, unsigned long col)
{
Eina_Matrixsparse_Cell *c;
EINA_MAGIC_CHECK_MATRIXSPARSE(m, 0);
EINA_SAFETY_ON_FALSE_RETURN_VAL(row < m->size.rows, 0);
EINA_SAFETY_ON_FALSE_RETURN_VAL(col < m->size.cols, 0);
c = _eina_matrixsparse_cell_idx_get(m, row, col);
if (!c) return 1;
_eina_matrixsparse_cell_unlink(c);
_eina_matrixsparse_cell_free(c, m->free.func, m->free.user_data);
return 1;
}
Evas_Filter_Apply_Func
evas_filter_bump_map_cpu_func_get(Evas_Filter_Command *cmd)
{
int w, h;
EINA_SAFETY_ON_NULL_RETURN_VAL(cmd, NULL);
EINA_SAFETY_ON_NULL_RETURN_VAL(cmd->input, NULL);
EINA_SAFETY_ON_NULL_RETURN_VAL(cmd->mask, NULL);
EINA_SAFETY_ON_NULL_RETURN_VAL(cmd->output, NULL);
EINA_SAFETY_ON_FALSE_RETURN_VAL(cmd->input != cmd->output, NULL);
EINA_SAFETY_ON_FALSE_RETURN_VAL(cmd->mask->alpha_only, NULL);
EINA_SAFETY_ON_FALSE_RETURN_VAL((!cmd->output->alpha_only)
|| cmd->input->alpha_only, NULL);
w = cmd->input->w;
h = cmd->input->h;
EINA_SAFETY_ON_FALSE_RETURN_VAL(cmd->output->w == w, NULL);
EINA_SAFETY_ON_FALSE_RETURN_VAL(cmd->output->h == h, NULL);
EINA_SAFETY_ON_FALSE_RETURN_VAL(cmd->mask->w == w, NULL);
EINA_SAFETY_ON_FALSE_RETURN_VAL(cmd->mask->h == h, NULL);
if (cmd->input->alpha_only)
{
if (cmd->output->alpha_only)
return _bump_map_cpu_alpha_alpha;
else
return _bump_map_cpu_alpha_rgba;
}
else
return _bump_map_cpu_rgba_rgba;
}
EAPI Eina_Bool
eldbus_message_iter_container_close(Eldbus_Message_Iter *iter, Eldbus_Message_Iter *sub)
{
ELDBUS_MESSAGE_ITERATOR_CHECK_RETVAL(iter, EINA_FALSE);
ELDBUS_MESSAGE_ITERATOR_CHECK_RETVAL(sub, EINA_FALSE);
EINA_SAFETY_ON_FALSE_RETURN_VAL(iter->writable, EINA_FALSE);
return dbus_message_iter_close_container(&iter->dbus_iterator,
&sub->dbus_iterator);
}
/**
* Change cell value without freeing the possibly existing old value, using
* indexes.
*
* @param m the sparse matrix, must @b not be @c NULL.
* @param row the row number to set the value.
* @param col the column number to set the value.
* @param data new data to set.
* @param p_old returns the old value intact (not freed).
*
* @return 1 on success, 0 otherwise (@a m is @c NULL, indexes are not valid).
*
* @see eina_matrixsparse_cell_data_replace()
* @see eina_matrixsparse_data_idx_set()
*/
EAPI Eina_Bool
eina_matrixsparse_data_idx_replace(Eina_Matrixsparse *m, unsigned long row, unsigned long col, const void *data, void **p_old)
{
Eina_Matrixsparse_Cell *cell;
if (p_old) *p_old = NULL;
EINA_MAGIC_CHECK_MATRIXSPARSE(m, 0);
EINA_SAFETY_ON_FALSE_RETURN_VAL(row < m->size.rows, 0);
EINA_SAFETY_ON_FALSE_RETURN_VAL(col < m->size.cols, 0);
cell = _eina_matrixsparse_cell_idx_get(m, row, col);
if (cell)
{
if (p_old) *p_old = cell->data;
cell->data = (void *)data;
return 1;
}
return _eina_matrixsparse_cell_idx_add(m, row, col, data);
}
/**
* Change cell value freeing the possibly existing old value, using
* indexes.
*
* In contrast to eina_matrixsparse_data_idx_replace(), this function will
* call @c free_func() on existing value.
*
* @param m the sparse matrix, must @b not be @c NULL.
* @param row the row number to set the value.
* @param col the column number to set the value.
* @param data new data to set.
*
* @return 1 on success, 0 otherwise (@a m is @c NULL, indexes are not valid).
*
* @see eina_matrixsparse_cell_data_replace()
*/
EAPI Eina_Bool
eina_matrixsparse_data_idx_set(Eina_Matrixsparse *m, unsigned long row, unsigned long col, const void *data)
{
Eina_Matrixsparse_Cell *cell;
EINA_MAGIC_CHECK_MATRIXSPARSE(m, 0);
EINA_SAFETY_ON_FALSE_RETURN_VAL(row < m->size.rows, 0);
EINA_SAFETY_ON_FALSE_RETURN_VAL(col < m->size.cols, 0);
cell = _eina_matrixsparse_cell_idx_get(m, row, col);
if (cell)
{
if (m->free.func)
m->free.func(m->free.user_data, cell->data);
cell->data = (void *)data;
return 1;
}
return _eina_matrixsparse_cell_idx_add(m, row, col, data);
}
EAPI Eolian_Value
eolian_expression_value_get(const Eolian_Expression *expr)
{
Eolian_Value v;
v.type = EOLIAN_EXPR_UNKNOWN;
EINA_SAFETY_ON_NULL_RETURN_VAL(expr, v);
EINA_SAFETY_ON_FALSE_RETURN_VAL(expr->type != EOLIAN_EXPR_UNKNOWN
&& expr->type != EOLIAN_EXPR_BINARY
&& expr->type != EOLIAN_EXPR_UNARY, v);
v.type = expr->type;
v.value = expr->value;
return v;
}
static Eina_Bool
_eldbus_message_iter_arguments_vget(Eldbus_Message_Iter *iter, const char *signature, va_list *aq)
{
int iter_type;
DBusSignatureIter sig_iter;
ELDBUS_MESSAGE_ITERATOR_CHECK_RETVAL(iter, EINA_FALSE);
EINA_SAFETY_ON_TRUE_RETURN_VAL(iter->writable, EINA_FALSE);
EINA_SAFETY_ON_NULL_RETURN_VAL(signature, EINA_FALSE);
EINA_SAFETY_ON_FALSE_RETURN_VAL(dbus_signature_validate(signature, NULL), EINA_FALSE);
dbus_signature_iter_init(&sig_iter, signature);
iter_type = dbus_message_iter_get_arg_type(&iter->dbus_iterator);
while (iter_type != DBUS_TYPE_INVALID)
{
int sig_type = dbus_signature_iter_get_current_type(&sig_iter);
if (sig_type == DBUS_TYPE_INVALID)
break;
if (sig_type != iter_type)
{
ERR("Type in iterator different of signature expected:%c got %c", iter_type, sig_type);
return EINA_FALSE;
}
if (dbus_type_is_basic(iter_type))
get_basic(iter_type, &iter->dbus_iterator, aq);
else
{
Eldbus_Message_Iter **user_itr = va_arg(*aq, Eldbus_Message_Iter **);
Eldbus_Message_Iter *sub_itr;
sub_itr = _message_iterator_new(EINA_FALSE);
EINA_SAFETY_ON_NULL_RETURN_VAL(sub_itr, EINA_FALSE);
dbus_message_iter_recurse(&iter->dbus_iterator,
&sub_itr->dbus_iterator);
iter->iterators = eina_inlist_append(iter->iterators,
EINA_INLIST_GET(sub_itr));
*user_itr = sub_itr;
}
dbus_message_iter_next(&iter->dbus_iterator);
dbus_signature_iter_next(&sig_iter);
iter_type = dbus_message_iter_get_arg_type(&iter->dbus_iterator);
}
return dbus_signature_iter_get_current_type(&sig_iter) == DBUS_TYPE_INVALID;
}
EAPI Eina_Bool
eldbus_message_iter_basic_append(Eldbus_Message_Iter *iter, int type, ...)
{
Eina_Bool r;
va_list vl;
ELDBUS_MESSAGE_ITERATOR_CHECK_RETVAL(iter, EINA_FALSE);
EINA_SAFETY_ON_FALSE_RETURN_VAL(iter->writable, EINA_FALSE);
va_start(vl, type);
r = append_basic(type, &vl, &iter->dbus_iterator);
va_end(vl);
return r;
}
EAPI Eina_Bool
eldbus_message_from_eina_value(const char *signature, Eldbus_Message *msg, const Eina_Value *value)
{
Eldbus_Message_Iter *iter;
EINA_SAFETY_ON_NULL_RETURN_VAL(signature, EINA_FALSE);
EINA_SAFETY_ON_NULL_RETURN_VAL(msg, EINA_FALSE);
EINA_SAFETY_ON_NULL_RETURN_VAL(value, EINA_FALSE);
iter = eldbus_message_iter_get(msg);
EINA_SAFETY_ON_NULL_RETURN_VAL(iter, EINA_FALSE);
EINA_SAFETY_ON_FALSE_RETURN_VAL(iter->writable, EINA_FALSE);
return _message_iter_from_eina_value_struct(signature, iter, value);
}
EAPI const Eolian_Expression *
eolian_function_return_default_value_get(const Eolian_Function *fid, Eolian_Function_Type ftype)
{
EINA_SAFETY_ON_NULL_RETURN_VAL(fid, NULL);
EINA_SAFETY_ON_FALSE_RETURN_VAL(ftype != EOLIAN_UNRESOLVED, NULL);
EINA_SAFETY_ON_FALSE_RETURN_VAL(ftype != EOLIAN_PROPERTY, NULL);
switch (ftype)
{
case EOLIAN_METHOD:
if (fid->type != EOLIAN_METHOD)
return NULL;
return fid->get_ret_val;
case EOLIAN_PROP_GET:
if ((fid->type != EOLIAN_PROP_GET) && (fid->type != EOLIAN_PROPERTY))
return NULL;
return fid->get_ret_val;
case EOLIAN_PROP_SET:
if ((fid->type != EOLIAN_PROP_SET) && (fid->type != EOLIAN_PROPERTY))
return NULL;
return fid->set_ret_val;
default:
return NULL;
}
}
EAPI Eolian_Object_Scope
eolian_function_scope_get(const Eolian_Function *fid, Eolian_Function_Type ftype)
{
EINA_SAFETY_ON_NULL_RETURN_VAL(fid, EOLIAN_SCOPE_UNKNOWN);
EINA_SAFETY_ON_FALSE_RETURN_VAL(ftype != EOLIAN_UNRESOLVED, EOLIAN_SCOPE_UNKNOWN);
EINA_SAFETY_ON_FALSE_RETURN_VAL(ftype != EOLIAN_PROPERTY, EOLIAN_SCOPE_UNKNOWN);
switch (ftype)
{
case EOLIAN_METHOD:
if (fid->type != EOLIAN_METHOD)
return EOLIAN_SCOPE_UNKNOWN;
return fid->get_scope;
case EOLIAN_PROP_GET:
if ((fid->type != EOLIAN_PROP_GET) && (fid->type != EOLIAN_PROPERTY))
return EOLIAN_SCOPE_UNKNOWN;
return fid->get_scope;
case EOLIAN_PROP_SET:
if ((fid->type != EOLIAN_PROP_SET) && (fid->type != EOLIAN_PROPERTY))
return EOLIAN_SCOPE_UNKNOWN;
return fid->set_scope;
default:
return EOLIAN_SCOPE_UNKNOWN;
}
}
/**
* Clear (erase all cells) of row given its index.
*
* Existing cells will be cleared with @c free_func() given to
* eina_matrixsparse_new().
*
* @param m the sparse matrix to operate on.
* @param row the new number of row to clear.
*
* @return 1 on success, 0 on failure. It is considered success if row
* had no cells filled. Failure is asking for clear row outside
* matrix size.
*
* @warning cells, rows or columns are not reference counted and thus
* after this call any reference might be invalid if instance were
* freed.
*/
EAPI Eina_Bool
eina_matrixsparse_row_idx_clear(Eina_Matrixsparse *m, unsigned long row)
{
Eina_Matrixsparse_Row *r;
EINA_MAGIC_CHECK_MATRIXSPARSE(m, 0);
EINA_SAFETY_ON_FALSE_RETURN_VAL(row < m->size.rows, 0);
r = _eina_matrixsparse_row_idx_get(m, row);
if (!r) return 1;
_eina_matrixsparse_row_unlink(r);
_eina_matrixsparse_row_free(r, m->free.func, m->free.user_data);
return 1;
}
EAPI Eldbus_Message *
eldbus_message_signal_new(const char *path, const char *interface, const char *name)
{
Eldbus_Message *msg;
EINA_SAFETY_ON_NULL_RETURN_VAL(path, NULL);
EINA_SAFETY_ON_NULL_RETURN_VAL(interface, NULL);
EINA_SAFETY_ON_FALSE_RETURN_VAL(name, NULL);
msg = eldbus_message_new(EINA_TRUE);
EINA_SAFETY_ON_NULL_RETURN_VAL(msg, NULL);
msg->dbus_msg = dbus_message_new_signal(path, interface, name);
dbus_message_iter_init_append(msg->dbus_msg,
&msg->iterator->dbus_iterator);
return msg;
}
/**
* Clear (erase all cells) of column given its index.
*
* Existing cells will be cleared with @c free_func() given to
* eina_matrixsparse_new().
*
* @param m the sparse matrix to operate on.
* @param col the new number of column to clear.
*
* @return 1 on success, 0 on failure. It is considered success if column
* had no cells filled. Failure is asking for clear column outside
* matrix size.
*
* @warning cells, rows or columns are not reference counted and thus
* after this call any reference might be invalid if instance were
* freed.
*/
EAPI Eina_Bool
eina_matrixsparse_column_idx_clear(Eina_Matrixsparse *m, unsigned long col)
{
Eina_Matrixsparse_Row *r;
void (*free_func)(void *, void *);
void *user_data;
EINA_MAGIC_CHECK_MATRIXSPARSE(m, 0);
EINA_SAFETY_ON_FALSE_RETURN_VAL(col < m->size.cols, 0);
free_func = m->free.func;
user_data = m->free.user_data;
for (r = m->rows; r != NULL;)
{
Eina_Matrixsparse_Row *r_aux = r;
Eina_Matrixsparse_Cell *c;
c = _eina_matrixsparse_row_cell_idx_get(r, col);
r = r->next;
if (!c)
continue;
if ((r_aux->cols != c) || (r_aux->last_col != c))
{
_eina_matrixsparse_cell_unlink(c);
_eina_matrixsparse_cell_free(c, free_func, user_data);
}
else
{
_eina_matrixsparse_row_unlink(r_aux);
_eina_matrixsparse_row_free(r_aux, free_func, user_data);
}
}
return 1;
}
EAPI Eina_Bool
eldbus_message_iter_fixed_array_get(Eldbus_Message_Iter *iter, int signature, void *value, int *n_elements)
{
int iter_type;
ELDBUS_MESSAGE_ITERATOR_CHECK_RETVAL(iter, EINA_FALSE);
EINA_SAFETY_ON_TRUE_RETURN_VAL(iter->writable, EINA_FALSE);
EINA_SAFETY_ON_NULL_RETURN_VAL(n_elements, EINA_FALSE);
iter_type = dbus_message_iter_get_arg_type(&iter->dbus_iterator);
if (iter_type == DBUS_TYPE_INVALID)
{
*n_elements = 0;
return EINA_TRUE;
}
EINA_SAFETY_ON_FALSE_RETURN_VAL(
(dbus_message_iter_get_arg_type(&iter->dbus_iterator) == signature),
EINA_FALSE);
dbus_message_iter_get_fixed_array(&iter->dbus_iterator, value, n_elements);
return EINA_TRUE;
}
/**
* Get the nearest tile for given position and zoom.
*
* The nearest tile is the one at the given position but with the
* closest zoom, this being the division of the tile zoom by the
* desired zoom, the closest to 1.0 gets it.
*
* If the tile was unused then it's removed from the cache.
*
* After usage, please give it back using ewk_tile_matrix_tile_put().
*
* @param tm the tile matrix to get tile from.
* @param col the column number.
* @param row the row number.
* @param zoom the exact zoom to use.
*
* @return The tile instance or @c NULL if none is found. If the tile
* was in the unused cache it will be @b removed (thus
* considered used) and one should give it back with
* ewk_tile_matrix_tile_put() afterwards.
*/
Ewk_Tile *ewk_tile_matrix_tile_nearest_get(Ewk_Tile_Matrix *tm, unsigned long col, unsigned int row, float zoom)
{
Ewk_Tile *t, *item, *item_found = NULL;
Eina_Inlist *inl;
float zoom_found = 0;
EINA_SAFETY_ON_NULL_RETURN_VAL(tm, NULL);
EINA_SAFETY_ON_FALSE_RETURN_VAL(zoom > 0.0, NULL);
t = eina_matrixsparse_data_idx_get(tm->matrix, row, col);
if (!t)
return NULL;
if (t->zoom == zoom) {
item_found = t;
goto end;
}
EINA_INLIST_FOREACH(EINA_INLIST_GET(t), item) {
float cur_zoom = item->zoom;
if (cur_zoom == zoom) {
item_found = item;
break;
}
if (cur_zoom > zoom)
cur_zoom = zoom / cur_zoom;
else
cur_zoom = cur_zoom / zoom;
if (cur_zoom > zoom_found) {
item_found = item;
zoom_found = cur_zoom;
}
}
static Eina_Bool
_array_append(const char *type, const Eina_Value *value_array, Eldbus_Message_Iter *iter)
{
Eldbus_Message_Iter *array;
Eina_Bool ok = eldbus_message_iter_arguments_append(iter, type, &array);
EINA_SAFETY_ON_FALSE_RETURN_VAL(ok, EINA_FALSE);
DBG("array of type %c", type[1]);
switch (type[1])
{
case '{':
case '(':
{
unsigned i = strlen(type+2);//remove 'a()' of len a(sv)
char *entry_sig = malloc(sizeof(char) * i);
memcpy(entry_sig, type+2, i);
entry_sig[i-1] = 0;
for (i = 0; i < eina_value_array_count(value_array); i++)
{
Eina_Value st;
Eldbus_Message_Iter *entry;
eina_value_array_value_get(value_array, i, &st);
eldbus_message_iter_arguments_append(array, type+1, &entry);
_message_iter_from_eina_value_struct(entry_sig, entry, &st);
eldbus_message_iter_container_close(array, entry);
eina_value_flush(&st);
}
free(entry_sig);
break;
}
case 'a':
{
unsigned i;
for (i = 0; i < eina_value_array_count(value_array); i++)
{
Eina_Value inner_array;
Eldbus_Message_Iter *sub_array;
eina_value_array_value_get(value_array, i, &inner_array);
eldbus_message_iter_arguments_append(array, type+1, &sub_array);
_array_append(type+1, &inner_array, sub_array);
eldbus_message_iter_container_close(array, sub_array);
eina_value_flush(&inner_array);
}
break;
}
case 'v':
{
ERR("Variant not supported.");
return EINA_FALSE;
}
case 'i':
case 'h'://fd
{
int32_t z;
unsigned i;
for (i = 0; i < eina_value_array_count(value_array); i++)
{
eina_value_array_get(value_array, i, &z);
eldbus_message_iter_basic_append(array, type[1], z);
}
break;
}
case 's':
case 'o'://object path
case 'g'://signature
{
const char *txt;
unsigned i;
for (i = 0; i < eina_value_array_count(value_array); i++)
{
eina_value_array_get(value_array, i, &txt);
eldbus_message_iter_basic_append(array, type[1], txt);
}
break;
}
case 'b'://boolean
case 'y'://byte
{
unsigned char z;
unsigned i;
for (i = 0; i < eina_value_array_count(value_array); i++)
{
eina_value_array_get(value_array, i, &z);
eldbus_message_iter_basic_append(array, type[1], z);
}
break;
}
case 'n'://int16
{
int16_t z;
unsigned i;
for (i = 0; i < eina_value_array_count(value_array); i++)
{
eina_value_array_get(value_array, i, &z);
eldbus_message_iter_basic_append(array, type[1], z);
}
break;
}
case 'q'://uint16
{
uint16_t z;
unsigned i;
for (i = 0; i < eina_value_array_count(value_array); i++)
{
eina_value_array_get(value_array, i, &z);
eldbus_message_iter_basic_append(array, type[1], z);
}
break;
}
case 'u'://uint32
{
uint32_t z;
unsigned i;
for (i = 0; i < eina_value_array_count(value_array); i++)
{
eina_value_array_get(value_array, i, &z);
eldbus_message_iter_basic_append(array, type[1], z);
}
break;
}
case 'x'://int64
{
int64_t z;
unsigned i;
for (i = 0; i < eina_value_array_count(value_array); i++)
{
eina_value_array_get(value_array, i, &z);
eldbus_message_iter_basic_append(array, type[1], z);
}
break;
}
case 't'://uint64
{
uint64_t z;
unsigned i;
for (i = 0; i < eina_value_array_count(value_array); i++)
{
eina_value_array_get(value_array, i, &z);
eldbus_message_iter_basic_append(array, type[1], z);
}
break;
}
case 'd'://double
{
double z;
unsigned i;
for (i = 0; i < eina_value_array_count(value_array); i++)
{
eina_value_array_get(value_array, i, &z);
eldbus_message_iter_basic_append(array, type[1], z);
}
break;
}
default:
{
ERR("Unknown type %c", type[1]);
return EINA_FALSE;
}
}
eldbus_message_iter_container_close(iter, array);
return EINA_TRUE;
}
EAPI int
efreet_trash_delete_uri(Efreet_Uri *uri, int force_delete)
{
char dest[PATH_MAX];
char times[64];
const char *fname;
const char *escaped;
const char *trash_dir;
int i = 1;
time_t now;
FILE *f;
EINA_SAFETY_ON_NULL_RETURN_VAL(uri, 0);
EINA_SAFETY_ON_NULL_RETURN_VAL(uri->path, 0);
EINA_SAFETY_ON_FALSE_RETURN_VAL(ecore_file_can_write(uri->path), 0);
fname = ecore_file_file_get(uri->path);
trash_dir = efreet_trash_dir_get(uri->path);
if (!trash_dir)
{
ERR("No trash directory for file '%s'", uri->path);
return 0;
}
snprintf(dest, sizeof(dest), "%s/files/%s", trash_dir, fname);
/* search for a free filename */
while (ecore_file_exists(dest) && (i < 100))
snprintf(dest, sizeof(dest), "%s/files/%s$%d",
trash_dir, fname, i++);
fname = ecore_file_file_get(dest);
/* move file to trash dir */
if (rename(uri->path, dest))
{
if (errno == EXDEV)
{
if (!force_delete)
{
eina_stringshare_del(trash_dir);
return -1;
}
if (!ecore_file_recursive_rm(uri->path))
{
ERR("Can't delete file '%s'", uri->path);
eina_stringshare_del(trash_dir);
return 0;
}
}
else
{
ERR("Can't move file to trash '%s'", uri->path);
eina_stringshare_del(trash_dir);
return 0;
}
}
/* create info file */
snprintf(dest, sizeof(dest), "%s/info/%s.trashinfo", trash_dir, fname);
if ((f = fopen(dest, "w")))
{
fputs("[Trash Info]\n", f);
fputs("Path=", f);
escaped = efreet_uri_encode(uri);
fputs(escaped + 7, f); // +7 == don't write 'file://'
IF_RELEASE(escaped);
time(&now);
strftime(times, sizeof(times), "%Y-%m-%dT%H:%M:%S", localtime(&now));
fputs("\nDeletionDate=", f);
fputs(times, f);
fputs("\n", f);
fclose(f);
}
else
{
ERR("Can't create trash info file '%s'", dest);
return 0;
}
return 1;
}
static Eina_Bool
_eldbus_message_iter_arguments_vappend(Eldbus_Message_Iter *iter, const char *signature, va_list *aq)
{
DBusSignatureIter signature_iter;
Eina_Bool r = EINA_TRUE;
char *type;
ELDBUS_MESSAGE_ITERATOR_CHECK_RETVAL(iter, EINA_FALSE);
EINA_SAFETY_ON_FALSE_RETURN_VAL(iter->writable, EINA_FALSE);
EINA_SAFETY_ON_NULL_RETURN_VAL(signature, EINA_FALSE);
dbus_signature_iter_init(&signature_iter, signature);
while ((type = dbus_signature_iter_get_signature(&signature_iter)))
{
if (type[0] != DBUS_TYPE_VARIANT && !type[1])
r = append_basic(type[0], aq, &iter->dbus_iterator);
else
{
Eldbus_Message_Iter **user_itr;
Eldbus_Message_Iter *sub;
user_itr = va_arg(*aq, Eldbus_Message_Iter **);
sub = _message_iterator_new(EINA_TRUE);
if (!sub)
{
ERR("Could not create sub iterator");
r = EINA_FALSE;
goto next;
}
iter->iterators = eina_inlist_append(iter->iterators,
EINA_INLIST_GET(sub));
if (type[0] == DBUS_TYPE_ARRAY)
r = dbus_message_iter_open_container(&iter->dbus_iterator,
type[0], type+1,
&sub->dbus_iterator);
else if (type[1] == DBUS_TYPE_VARIANT)
{
ERR("variant not supported by \
eldbus_message_iter_arguments_append(), \
try eldbus_message_iter_container_new()");
r = EINA_FALSE;
goto next;
}
else
{
char real_type;
if (type[0] == DBUS_STRUCT_BEGIN_CHAR)
real_type = DBUS_TYPE_STRUCT;
else real_type = DBUS_TYPE_DICT_ENTRY;
r = dbus_message_iter_open_container(&iter->dbus_iterator,
real_type, NULL,
&sub->dbus_iterator);
}
*user_itr = sub;
}
next:
dbus_free(type);
if (!r || !dbus_signature_iter_next(&signature_iter))
break;
}
return r;
}
