void
e_syscon_hide(void)
{
if (!popup) return;
if (deftimer)
{
ecore_timer_del(deftimer);
deftimer = NULL;
}
if (do_defact) eina_stringshare_del(do_defact);
do_defact = NULL;
while (handlers)
{
ecore_event_handler_del(handlers->data);
handlers = eina_list_remove_list(handlers, handlers);
}
e_popup_hide(popup);
e_object_del(E_OBJECT(popup));
popup = NULL;
e_grabinput_release(input_window, input_window);
ecore_x_window_free(input_window);
input_window = 0;
}
Eina_Bool
email_pop3_list_read(Email *e, Ecore_Con_Event_Server_Data *ev)
{
Email_List_Cb cb;
Eina_List *next, *list = NULL;
Email_List_Item *it;
const char *n;
unsigned char *data;
int len;
size_t size;
if ((!e->buf) && (!email_op_ok(ev->data, ev->size)))
{
ERR("Error with LIST");
cb = e->cbs->data;
e->cbs = eina_list_remove_list(e->cbs, e->cbs);
if (cb) cb(e, NULL);
return EINA_TRUE;
}
next = e->ev ? e->ev : list;
if (e->buf)
{
eina_binbuf_append_length(e->buf, ev->data, ev->size);
data = (unsigned char*)eina_binbuf_string_get(e->buf);
len = eina_binbuf_length_get(e->buf);
}
else
{
data = ev->data;
len = ev->size;
}
for (n = (char*)memchr(data + 3, '\n', len - 3), size = len - (n - (char*)data);
n && (size > 1);
n = (char*)memchr(n, '\n', size - 1), size = len - (n - (char*)data))
{
it = calloc(1, sizeof(Email_List_Item));
if (sscanf(++n, "%u %zu", &it->id, &it->size) != 2)
{
free(it);
break;
}
INF("Message %u: %zu octets", it->id, it->size);
list = eina_list_append(list, it);
}
if (!memcmp(n - 2, "\r\n.\r\n", 5))
{
cb = e->cbs->data;
e->cbs = eina_list_remove_list(e->cbs, e->cbs);
INF("LIST returned %u messages", eina_list_count(list));
if (cb) cb(e, list);
EINA_LIST_FREE(list, it)
free(it);
if (e->buf)
{
eina_binbuf_free(e->buf);
e->buf = NULL;
}
return EINA_TRUE;
}
else if (!e->buf)
{
e->buf = eina_binbuf_new();
eina_binbuf_append_length(e->buf, (unsigned char*)n, ev->size - (n - (char*)ev->data));
}
return EINA_FALSE;
}
int
main(int argc, char ** argv)
{
int i, passed = 0, num_tests = 0;
Eina_List *run = NULL;
double total;
char *env;
eina_init();
ecore_init();
total = ecore_time_get();
if (argc > 1)
{
for (i = 1; i < argc; i++)
{
if ((!strcmp(argv[i], "-h")) ||
(!strcmp(argv[i], "--help")))
{
for (i = 0; tests[i].name; i++)
{
printf("%s\n", tests[i].name);
}
return 1;
}
run = eina_list_append(run, argv[i]);
}
}
environment_store();
for (i = 0; tests[i].name; i++)
{
int ret;
double start;
/* we've been given specific tests and it isn't in the list */
if (run && !eina_list_search_unsorted(run, EINA_COMPARE_CB(strcasecmp),
tests[i].name))
continue;
if (!efreet_init())
{
printf("Error initializing Efreet\n");
continue;
}
num_tests ++;
printf("%s:\t\t", tests[i].name);
fflush(stdout);
start = ecore_time_get();
ret = tests[i].cb();
printf("%s in %.3f seconds\n", (ret ? "PASSED" : "FAILED"),
ecore_time_get() - start);
passed += ret;
efreet_shutdown();
environment_restore();
}
printf("\n-----------------\n");
clearenv();
EINA_LIST_FREE(environment, env)
free(env);
printf("Passed %d of %d tests.\n", passed, num_tests);
while (run)
run = eina_list_remove_list(run, run);
printf("Total run: %.3f seconds\n", ecore_time_get() - total);
ecore_shutdown();
eina_shutdown();
return 0;
}
EAPI const char *
efreet_mime_type_icon_get(const char *mime, const char *theme, unsigned int size)
{
const char *icon = NULL;
char *data;
Eina_List *icons = NULL;
const char *env = NULL;
char *p = NULL, *pp = NULL, *ppp = NULL;
char buf[PATH_MAX];
const char *cache;
EINA_SAFETY_ON_NULL_RETURN_VAL(mime, NULL);
EINA_SAFETY_ON_NULL_RETURN_VAL(theme, NULL);
mime = eina_stringshare_add(mime);
theme = eina_stringshare_add(theme);
cache = efreet_mime_icon_entry_find(mime, theme, size);
if (cache)
{
eina_stringshare_del(mime);
eina_stringshare_del(theme);
return cache;
}
/* Standard icon name */
p = strdup(mime);
pp = p;
while (*pp)
{
if (*pp == '/') *pp = '-';
pp++;
}
icons = eina_list_append(icons, p);
/* Environment Based icon names */
if ((env = efreet_desktop_environment_get()))
{
snprintf(buf, sizeof(buf), "%s-mime-%s", env, p);
icons = eina_list_append(icons, strdup(buf));
snprintf(buf, sizeof(buf), "%s-%s", env, p);
icons = eina_list_append(icons, strdup(buf));
}
/* Mime prefixed icon names */
snprintf(buf, sizeof(buf), "mime-%s", p);
icons = eina_list_append(icons, strdup(buf));
/* Generic icons */
pp = strdup(p);
while ((ppp = strrchr(pp, '-')))
{
*ppp = '\0';
snprintf(buf, sizeof(buf), "%s-x-generic", pp);
icons = eina_list_append(icons, strdup(buf));
snprintf(buf, sizeof(buf), "%s-generic", pp);
icons = eina_list_append(icons, strdup(buf));
snprintf(buf, sizeof(buf), "%s", pp);
icons = eina_list_append(icons, strdup(buf));
}
FREE(pp);
/* Search for icons using list */
icon = efreet_icon_list_find(theme, icons, size);
while (icons)
{
data = eina_list_data_get(icons);
free(data);
icons = eina_list_remove_list(icons, icons);
}
efreet_mime_icon_entry_add(mime, eina_stringshare_add(icon), theme, size);
return icon;
}
EAPI void
edje_object_message_signal_process(Evas_Object *obj)
{
Eina_List *l, *ln, *tmpq = NULL;
Edje *ed;
Edje_Message *em;
int gotos = 0;
ed = _edje_fetch(obj);
if (!ed) return;
for (l = msgq; l; )
{
ln = l->next;
em = l->data;
if (em->edje == ed)
{
tmpq = eina_list_append(tmpq, em);
msgq = eina_list_remove_list(msgq, l);
}
l = ln;
}
/* a temporary message queue */
if (tmp_msgq)
{
while (tmpq)
{
tmp_msgq = eina_list_append(tmp_msgq, tmpq->data);
tmpq = eina_list_remove_list(tmpq, tmpq);
}
}
else
{
tmp_msgq = tmpq;
tmpq = NULL;
}
#if 0
while (tmp_msgq)
{
Edje_Message *em;
em = tmp_msgq->data;
tmp_msgq = eina_list_remove_list(tmp_msgq, tmp_msgq);
if (!ed->delete_me)
{
ed->processing_messages++;
_edje_message_process(em);
_edje_message_free(em);
ed->processing_messages--;
}
else
_edje_message_free(em);
}
#else
tmp_msgq_processing++;
again:
EINA_LIST_FOREACH_SAFE(tmp_msgq, l, ln, em)
{
if (em->edje != ed) continue;
tmp_msgq = eina_list_remove_list(tmp_msgq, l);
if (!ed->delete_me)
{
ed->processing_messages++;
_edje_message_process(em);
_edje_message_free(em);
ed->processing_messages--;
}
else
_edje_message_free(em);
if (ed->processing_messages == 0)
{
if (ed->delete_me) _edje_del(ed);
}
// if some child callback in _edje_message_process called
// edje_object_message_signal_process() or
// edje_message_signal_process() then those will mark the restart
// flag when they finish - it mabsicammyt means tmp_msgq and
// any item in it has potentially become invalid - so that means l
// and ln could be rogue pointers, so start again from the beginning
// and skip anything that is not this object and process only what is.
// to avoid self-feeding loops allow a max of 1024 loops.
if (tmp_msgq_restart)
{
tmp_msgq_restart = 0;
gotos++;
if (gotos < 1024) goto again;
else
{
WRN("Edje is in a self-feeding message loop (> 1024 gotos needed in a row)");
goto end;
}
}
}
end:
tmp_msgq_processing--;
if (tmp_msgq_processing == 0)
tmp_msgq_restart = 0;
else
tmp_msgq_restart = 1;
#endif
}
EAPI int
e_modapi_shutdown (E_Module * m)
{
mail_config->module = NULL;
e_gadcon_provider_unregister (&_gc_class);
if (exit_handler)
ecore_event_handler_del (exit_handler);
if (mail_config->config_dialog)
e_object_del (E_OBJECT (mail_config->config_dialog));
if (mail_config->menu)
{
e_menu_post_deactivate_callback_set (mail_config->menu, NULL, NULL);
e_object_del (E_OBJECT (mail_config->menu));
mail_config->menu = NULL;
}
while (mail_config->items)
{
Config_Item *ci;
ci = mail_config->items->data;
while (ci->boxes)
{
Config_Box *cb;
cb = ci->boxes->data;
switch (cb->type)
{
case MAIL_TYPE_IMAP:
_mail_imap_del_mailbox (cb);
break;
case MAIL_TYPE_POP:
_mail_pop_del_mailbox (cb);
break;
case MAIL_TYPE_MDIR:
_mail_mdir_del_mailbox (cb);
break;
case MAIL_TYPE_MBOX:
_mail_mbox_del_mailbox (cb);
break;
}
if (cb->name)
eina_stringshare_del (cb->name);
if (cb->host)
eina_stringshare_del (cb->host);
if (cb->user)
eina_stringshare_del (cb->user);
if (cb->pass)
eina_stringshare_del (cb->pass);
if (cb->new_path)
eina_stringshare_del (cb->new_path);
if (cb->cur_path)
eina_stringshare_del (cb->cur_path);
if (cb->exec)
eina_stringshare_del (cb->exec);
ci->boxes = eina_list_remove_list (ci->boxes, ci->boxes);
free (cb);
cb = NULL;
}
if (ci->id)
eina_stringshare_del (ci->id);
mail_config->items =
eina_list_remove_list (mail_config->items, mail_config->items);
free (ci);
ci = NULL;
}
_mail_imap_shutdown ();
_mail_pop_shutdown ();
_mail_mdir_shutdown ();
_mail_mbox_shutdown ();
free (mail_config);
mail_config = NULL;
E_CONFIG_DD_FREE (conf_box_edd);
E_CONFIG_DD_FREE (conf_item_edd);
E_CONFIG_DD_FREE (conf_edd);
return 1;
}
//Scan the files stored in the list of files to scan
static void *_eclair_meta_tag_thread(void *param)
{
Eclair *eclair = param;
Eclair_Meta_Tag_Manager *meta_tag_manager;
Eina_List *l, *next;
Eclair_Media_File *current_file;
if (!eclair)
return NULL;
next = NULL;
meta_tag_manager = &eclair->meta_tag_manager;
pthread_mutex_lock(&meta_tag_manager->meta_tag_mutex);
for (;;)
{
if (meta_tag_manager->meta_tag_should_scan_files || meta_tag_manager->meta_tag_delete_thread)
meta_tag_manager->meta_tag_should_scan_files = 0;
else
pthread_cond_wait(&meta_tag_manager->meta_tag_cond, &meta_tag_manager->meta_tag_mutex);
while (meta_tag_manager->meta_tag_files_to_scan || meta_tag_manager->meta_tag_files_to_add || meta_tag_manager->meta_tag_delete_thread)
{
if (meta_tag_manager->meta_tag_delete_thread)
{
meta_tag_manager->meta_tag_files_to_scan = eina_list_free(meta_tag_manager->meta_tag_files_to_scan);
meta_tag_manager->meta_tag_files_to_add = eina_list_free(meta_tag_manager->meta_tag_files_to_add);
meta_tag_manager->meta_tag_delete_thread = 0;
return NULL;
}
//Add the new files to the list of files to treat
if (meta_tag_manager->meta_tag_files_to_add)
{
while (meta_tag_manager->meta_tag_add_state != ECLAIR_IDLE)
usleep(10000);
meta_tag_manager->meta_tag_add_state = ECLAIR_ADDING_FILE_TO_TREAT;
for (l = meta_tag_manager->meta_tag_files_to_add; l; l = l->next)
meta_tag_manager->meta_tag_files_to_scan = eina_list_append(meta_tag_manager->meta_tag_files_to_scan, l->data);
meta_tag_manager->meta_tag_files_to_add = eina_list_free(meta_tag_manager->meta_tag_files_to_add);
meta_tag_manager->meta_tag_add_state = ECLAIR_IDLE;
}
//Treat the files in the list
for (l = meta_tag_manager->meta_tag_files_to_scan; l || meta_tag_manager->meta_tag_delete_thread; l = next)
{
if (meta_tag_manager->meta_tag_delete_thread || meta_tag_manager->meta_tag_files_to_add)
break;
next = l->next;
current_file = l->data;
meta_tag_manager->meta_tag_files_to_scan = eina_list_remove_list(meta_tag_manager->meta_tag_files_to_scan, l);
if (current_file)
{
if (current_file->delete_me)
{
current_file->in_meta_tag_process = 0;
continue;
}
eclair_meta_tag_read(eclair, current_file);
eclair_media_file_update(eclair, current_file);
current_file->in_meta_tag_process = 0;
}
}
}
}
return NULL;
}
Eina_Bool
data_pop(Email *e, int type __UNUSED__, Ecore_Con_Event_Server_Data *ev)
{
char *recv;
if (e != ecore_con_server_data_get(ev->server))
{
DBG("Event mismatch");
return ECORE_CALLBACK_PASS_ON;
}
recv = alloca(ev->size + 1);
memcpy(recv, ev->data, ev->size);
recv[ev->size] = 0;
DBG("Receiving %i bytes:\n%s", ev->size, recv);
if (e->state < EMAIL_STATE_CONNECTED)
{
email_login_pop(e, ev);
return ECORE_CALLBACK_RENEW;
}
if (!e->current) return ECORE_CALLBACK_RENEW;
switch (e->current)
{
case EMAIL_OP_STAT:
if (!email_pop3_stat_read(e, recv, ev->size)) return ECORE_CALLBACK_RENEW;
break;
case EMAIL_OP_LIST:
if (!email_pop3_list_read(e, ev)) return ECORE_CALLBACK_RENEW;
break;
case EMAIL_OP_RETR:
if (!email_pop3_retr_read(e, ev)) return ECORE_CALLBACK_RENEW;
break;
case EMAIL_OP_DELE:
case EMAIL_OP_QUIT:
{
Ecore_Cb cb;
cb = e->cbs->data;
e->cbs = eina_list_remove_list(e->cbs, e->cbs);
if (!email_op_ok(ev->data, ev->size))
{
if (e->current == EMAIL_OP_DELE) ERR("Error with DELE");
else ERR("Error with QUIT");
}
else
{
if (e->current == EMAIL_OP_DELE) INF("DELE successful");
else INF("QUIT");
}
if (cb) cb(e);
if (e->current == EMAIL_OP_QUIT) ecore_con_server_del(e->svr);
break;
}
default:
break;
}
next_pop(e);
return ECORE_CALLBACK_RENEW;
}
EINA_LIST_FREE(sources, rp)
{
/* XXX: curr_item and pack_it don't require to be NULL since
* XXX: they are just used when source != NULL and type == BOX,
* XXX: and they're always set in this case, but GCC fails to
* XXX: notice that, so let's shut it up
*/
Edje_Pack_Element **curr_item = NULL;
unsigned int item_count = 0;
Edje_Pack_Element *pack_it = NULL;
const char *source = NULL;
switch (rp->part->type)
{
case EDJE_PART_TYPE_GROUP:
source = rp->part->source;
break;
case EDJE_PART_TYPE_BOX:
case EDJE_PART_TYPE_TABLE:
if (rp->part->items)
{
curr_item = rp->part->items;
item_count = rp->part->items_count;
if (item_count > 0)
{
pack_it = *curr_item;
source = pack_it->source;
item_count--;
curr_item++;
}
}
break;
default:
/* This list should only be filled by group, box or table, nothing else. */
abort();
continue;
}
while (source)
{
Eina_List *l;
Evas_Object *child_obj;
const char *group_path_entry = eina_stringshare_add(source);
const char *data;
if (!group_path)
{
group_path = eina_list_append(NULL, eina_stringshare_add(group));
group_path_started = 1;
}
/* make sure that this group isn't already in the tree of parents */
EINA_LIST_FOREACH(group_path, l, data)
{
if (data == group_path_entry)
{
ERR("recursive loop group '%s' already included inside part '%s' of group '%s' from file '%s'",
group_path_entry, rp->part->name, group, file);
textblocks = eina_list_free(textblocks);
externals = eina_list_free(externals);
sources = eina_list_free(sources);
_edje_thaw(ed);
_edje_unblock(ed);
_edje_unref(ed);
_edje_file_del(ed);
eina_stringshare_del(group_path_entry);
if (group_path_started)
{
eina_stringshare_del(eina_list_data_get(group_path));
eina_list_free(group_path);
}
ed->load_error = EDJE_LOAD_ERROR_RECURSIVE_REFERENCE;
evas_event_thaw(tev);
evas_event_thaw_eval(tev);
return 0;
}
}
child_obj = edje_object_add(ed->base.evas);
group_path = eina_list_append(group_path, group_path_entry);
if (rp->part->type == EDJE_PART_TYPE_GROUP)
{
_edje_real_part_swallow(rp, child_obj, EINA_FALSE);
}
if (!_edje_object_file_set_internal(child_obj, file, source, rp->part->name, group_path))
{
ERR("impossible to set part '%s' of group '%s' from file '%s' to '%s'",
rp->part->name, group_path_entry, file, source);
textblocks = eina_list_free(textblocks);
externals = eina_list_free(externals);
sources = eina_list_free(sources);
_edje_thaw(ed);
_edje_unblock(ed);
_edje_unref(ed);
_edje_file_del(ed);
if (group_path_started)
{
while (group_path)
{
eina_stringshare_del(eina_list_data_get(group_path));
group_path = eina_list_remove_list(group_path, group_path);
}
}
ed->load_error = edje_object_load_error_get(child_obj);
evas_object_del(child_obj);
evas_event_thaw(tev);
evas_event_thaw_eval(tev);
return 0;
}
group_path = eina_list_remove(group_path, group_path_entry);
eina_stringshare_del(group_path_entry);
edje_object_propagate_callback_add(child_obj,
_cb_signal_repeat,
obj);
if (rp->part->type == EDJE_PART_TYPE_GROUP)
{
_edje_real_part_swallow(rp, child_obj, EINA_TRUE);
_edje_subobj_register(ed, child_obj);
source = NULL;
}
else
{
pack_it->parent = rp;
_edje_object_pack_item_hints_set(child_obj, pack_it);
if (pack_it->name)
evas_object_name_set(child_obj, pack_it->name);
if (rp->part->type == EDJE_PART_TYPE_BOX)
{
_edje_real_part_box_append(rp, child_obj);
evas_object_data_set(child_obj, "\377 edje.box_item", pack_it);
}
else if (rp->part->type == EDJE_PART_TYPE_TABLE)
{
_edje_real_part_table_pack(rp, child_obj, pack_it->col, pack_it->row, pack_it->colspan, pack_it->rowspan);
evas_object_data_set(child_obj, "\377 edje.table_item", pack_it);
}
_edje_subobj_register(ed, child_obj);
evas_object_show(child_obj);
rp->items = eina_list_append(rp->items, child_obj);
if (item_count > 0)
{
pack_it = *curr_item;
source = pack_it->source;
curr_item++;
item_count--;
}
else
{
source = NULL;
curr_item = NULL;
pack_it = NULL;
}
}
}
}
/* parse a message from the pipe an execute the corresponding
* functions. the protocol might be something like this:
* header char[4]
* **************
* RIPE => rip end
* RIPP => rip progress
* RIPS => rip start
* ENCE => encoder end
* ENCP => we cant know the real
* progress here without knowing the encoding quality.
* ENCS => encoder start
*
* S: start
* E: end
* body char *
* ***********
*/
void
ex_protocol_parse(Extrackt *ex, char *msg, int length)
{
char *oldmsg;
oldmsg = msg;
//printf("%d bytes of data received %s\n", length, msg);
while(length > 0)
{
char *line;
char header[5];
char *body;
int llength;
line = E_STRDUP(msg);
llength = strlen(msg);
snprintf(header, sizeof(header),"%s", line);
body = index(line,' ') + 1;
/* FIXME the string received from the CDDB protocol
* might be incomplete (truncated) search the end of
* message (. the dot) if it isnt found accumulate the
* data
*/
/* the cddb process status */
if(!strcmp("CDPS",header))
{
/* FIXME depending on the body set the status DONE or CANT_BE_DONE */
ex->cddb.status = EX_STATUS_DONE;
}
/* the first query to the cddb, the match find query */
else if(!strcmp("DBMF", header))
{
ex->cddb.pid = 0;
ex_cddb_response_find_parse(ex,body);
}
/* the list info query */
else if(!strcmp("DBMG", header))
{
ex->cddb.pid = 0;
ex_cddb_response_get_parse(ex,body);
}
else if(!strcmp("RIPS", header))
{
time(&(ex->rip.start));
ex->rip.status = EX_STATUS_DOING;
}
else if(!strcmp("RIPE", header))
{
ex->rip.status = EX_STATUS_DONE;
if(ex->rip.num_done + 1 != ex->rip.num_total)
ex->rip.num_done++;
else
{
ex->rip.num_done = 0;
ex->rip.num_total= 0;
//ex->rip.status = EX_STATUS_NOT_DONE;
}
ex->rip.pid = 0;
if(ex->encode.on)
ex_command_encode_append(ex, ex->rip.curr_track.number);
ex->rip.curr_track.number = -1;
ex->rip.curr_track.size = -1;
ex->rip.curr_track.filename = NULL;
ex->rip.tracks = eina_list_remove_list(ex->rip.tracks,ex->rip.tracks);
if(ex->rip.tracks)
ex_command_rip(ex);
}
else if(!strcmp("RIPP", header))
{
double percent;
percent = atof(body);
ex->fe->rip_percent_update(percent);
}
else if(!strcmp("ENCS", header))
{
ex->encode.status = EX_STATUS_DOING;
}
else if(!strcmp("ENCE", header))
{
ex->encode.status = EX_STATUS_DONE;
if(ex->encode.num_done + 1 != ex->encode.num_total)
ex->encode.num_done++;
else
{
ex->encode.num_done = 0;
ex->encode.num_total= 0;
//ex->encode.status = EX_STATUS_NOT_DONE;
}
if(ex->config.encode->wav_delete)
ex_string_file_delete(ex->encode.curr_track.filename);
ex->encode.pid = 0;
ex->encode.curr_track.number = -1;
ex->encode.curr_track.size = -1;
ex->encode.curr_track.filename = NULL;
ex->encode.tracks = eina_list_remove_list(ex->encode.tracks,ex->encode.tracks);
if(ex->encode.tracks)
ex_command_encode(ex);
}
else
{
/* printf("HEADER %s\n", header); */
}
E_FREE(line);
length = length - llength - 1; /* 1 = \n */
msg = msg + llength + 1;
}
}
static Eina_List *
_eina_rectangle_empty_space_find(Eina_List *empty, int w, int h, int *x, int *y)
{
Eina_Rectangle *r;
Eina_List *l;
EINA_LIST_FOREACH(empty, l, r)
{
if (r->w >= w && r->h >= h)
{
/* Remove l from empty */
empty = eina_list_remove_list(empty, l);
/* Remember x and y */
*x = r->x;
*y = r->y;
/* Split r in 2 rectangle if needed (only the empty one) and insert them */
if (r->w == w)
{
r->y += h;
r->h -= h;
}
else if (r->h == h)
{
r->x += w;
r->w -= w;
}
else
{
int rx1, ry1, rw1, rh1;
int x2, y2, w2, h2;
rx1 = r->x + w;
ry1 = r->y;
rw1 = r->w - w;
/* h1 could be h or r->h */
x2 = r->x;
y2 = r->y + h;
/* w2 could be w or r->w */
h2 = r->h - h;
if (rw1 * r->h > h2 * r->w)
{
rh1 = r->h;
w2 = w;
}
else
{
rh1 = h;
w2 = r->w;
}
EINA_RECTANGLE_SET(r, rx1, ry1, rw1, rh1);
empty = _eina_rectangle_merge_list(empty, r);
r = eina_rectangle_new(x2, y2, w2, h2);
}
if (r)
{
empty = _eina_rectangle_merge_list(empty, r); /* Return empty */
}
return empty;
}
}
*x = -1;
*y = -1;
return empty;
}
