Eina_Bool
evas_module_register(const Evas_Module_Api *module, Evas_Module_Type type)
{
Evas_Module *em;
if ((unsigned int)type > 3) return EINA_FALSE;
if (!module) return EINA_FALSE;
if (module->version != EVAS_MODULE_API_VERSION) return EINA_FALSE;
em = eina_hash_find(evas_modules[type], module->name);
if (em) return EINA_FALSE;
em = calloc(1, sizeof (Evas_Module));
if (!em) return EINA_FALSE;
em->definition = module;
if (type == EVAS_MODULE_TYPE_ENGINE)
{
eina_array_push(evas_engines, em);
em->id_engine = eina_array_count(evas_engines);
}
eina_hash_direct_add(evas_modules[type], module->name, em);
return EINA_TRUE;
}
static void
_introspect_append_interface(Eina_Strbuf *buf, Eldbus_Service_Interface *iface)
{
const Eldbus_Method *method;
Property *prop;
Eina_Iterator *iterator;
unsigned short i;
eina_strbuf_append_printf(buf, "<interface name=\"%s\">", iface->name);
iterator = eina_hash_iterator_data_new(iface->methods);
EINA_ITERATOR_FOREACH(iterator, method)
_introspect_append_method(buf, method);
eina_iterator_free(iterator);
for (i = 0; i < eina_array_count(iface->sign_of_signals); i++)
_introspect_append_signal(buf, &iface->signals[i]);
iterator = eina_hash_iterator_data_new(iface->properties);
EINA_ITERATOR_FOREACH(iterator, prop)
_instrospect_append_property(buf, prop->property, iface);
eina_iterator_free(iterator);
eina_strbuf_append(buf, "</interface>");
}
static void
_free_eina_array(Eina_Array *array, _free_func free_cb)
{
if (!array)
return;
while (eina_array_count(array))
free_cb(eina_array_pop(array));
eina_array_free(array);
}
static Eina_Bool
eina_array_iterator_next(Eina_Iterator_Array *it, void **data)
{
EINA_MAGIC_CHECK_ARRAY_ITERATOR(it, EINA_FALSE);
if (!(it->index < eina_array_count(it->array)))
return EINA_FALSE;
if (data)
*data = eina_array_data_get(it->array, it->index);
it->index++;
return EINA_TRUE;
}
static Eina_Bool
eina_array_accessor_get_at(Eina_Accessor_Array *it,
unsigned int idx,
void **data)
{
EINA_MAGIC_CHECK_ARRAY_ACCESSOR(it, EINA_FALSE);
if (!(idx < eina_array_count(it->array)))
return EINA_FALSE;
if (data)
*data = eina_array_data_get(it->array, idx);
return EINA_TRUE;
}
static void
compiz_damage(void)
{
CompDisplay *d;
CompScreen *s;
CompWindow *w;
Eina_Bool thaw = EINA_FALSE;
for (d = core.displays; d; d = d->next)
for (s = d->screens; s; s = s->next)
{
if (!s->damageMask)
for (w = s->windows; w; w = w->next)
{
E_Client *ec;
ec = compiz_win_to_client(w);
if (w->grabbed && ((!ec->moving) && (!e_client_util_resizing_get(ec))))
w->screen->windowUngrabNotify(w);
if ((w->attrib.x == ec->client.x) && (w->attrib.y == ec->client.y))
continue;
moveWindow(w, ec->client.x - w->attrib.x, ec->client.y - w->attrib.y, TRUE, TRUE);
syncWindowPosition(w);
compiz_texture_clear(w->texture);
}
if (s->damageMask)
{
evas_damage_rectangle_add(e_comp->evas, 0, 0, 1, 1);
thaw = EINA_TRUE;
}
}
if (eina_array_count(events) || thaw)
ecore_animator_thaw(compiz_anim);
else
ecore_animator_freeze(compiz_anim);
}
static Eina_Value *
azy_value_deserialize_struct_json(cJSON *object)
{
Eina_Array *st_members, *st_values;
unsigned int offset = 0, z = 0;
Eina_Value *value_st = NULL;
Eina_Value_Struct_Member *members;
Eina_Value_Struct_Desc *st_desc;
const char *name;
cJSON *child;
st_desc = azy_value_util_struct_desc_new();
st_members = eina_array_new(1);
st_values = eina_array_new(1);
for (child = object->child; child; child = child->next)
{
Eina_Value_Struct_Member *m;
const Eina_Value_Type *type;
Eina_Value *v;
type = _azy_value_type_get(child);
if (!type) goto end;
name = child->string;
m = (Eina_Value_Struct_Member*)calloc(1, sizeof(Eina_Value_Struct_Member));
m->name = eina_stringshare_add(name);
offset = azy_value_util_type_offset(type, offset);
m->offset = offset;
offset += azy_value_util_type_size(type);
m->type = type;
eina_array_push(st_members, m);
v = azy_value_deserialize_json(child);
if (!v) goto end;
eina_array_push(st_values, v);
z++;
}
if (!z)
{
free(st_desc);
goto end;
}
members = (Eina_Value_Struct_Member*)malloc(eina_array_count(st_members) * sizeof(Eina_Value_Struct_Member));
for (z = 0; z < eina_array_count(st_members); z++)
{
Eina_Value_Struct_Member *m = (Eina_Value_Struct_Member*)eina_array_data_get(st_members, z);
members[z].name = m->name;
members[z].offset = m->offset;
members[z].type = m->type;
free(m);
}
//setup
st_desc->members = members;
st_desc->member_count = eina_array_count(st_members);
st_desc->size = offset;
value_st = eina_value_struct_new(st_desc);
//filling with data
for (z = 0; z < eina_array_count(st_values); z++)
{
Eina_Value *v = (Eina_Value*)eina_array_data_get(st_values, z);
eina_value_struct_value_set(value_st, members[z].name, v);
eina_value_free(v);
}
end:
eina_array_free(st_members);
eina_array_free(st_values);
return value_st;
}
#include <Ecore.h>
#include "ecore_suite.h"
#include "ecore_private.h"
static const char *args[] = {
"a", "b", "c", "d", "e", "f", "g", "h"
};
static void
_cb_args1(void *data EINA_UNUSED, const Efl_Event *event)
{
Efl_Loop_Arguments *arge = event->info;
unsigned int i;
fail_if(eina_array_count(arge->argv) != (sizeof (args) / sizeof (args[0])));
for (i = 0; i < eina_array_count(arge->argv); i++)
{
fail_if(!!strcmp(eina_array_data_get(arge->argv, i), args[i]));
}
ecore_main_loop_quit();
}
START_TEST(ecore_test_args1)
{
ecore_init();
efl_event_callback_add(ecore_main_loop_get(), EFL_LOOP_EVENT_ARGUMENTS,
_cb_args1, NULL);
ecore_loop_arguments_send(8, args);
ecore_main_loop_begin();
ecore_shutdown();
char *
_nedje_text_escape(const char *text)
{
Eina_Strbuf *txt;
char *ret;
const char *text_end;
size_t text_len;
Eina_Array *arr;
const char *cur_tag = NULL;
if (!text) return NULL;
txt = eina_strbuf_new();
text_len = strlen(text);
arr = eina_array_new(3);
text_end = text + text_len;
while (text < text_end)
{
int advance;
if ((text[0] == '<') && text[1])
{
const char *tag, *popped;
Eina_Bool closing = EINA_FALSE;
if (text[1] == '/') //closing tag
{
closing = EINA_TRUE;
tag = _get_tag(text + 2);
}
else
tag = _get_tag(text + 1);
if (closing)
{
if (cur_tag && (tag != cur_tag))
{
/* tag mismatch: autoclose all failure tags
* not technically required by the spec,
* but it makes me feel better about myself
*/
do
{
popped = eina_array_pop(arr);
if (eina_array_count(arr))
cur_tag = eina_array_data_get(arr, eina_array_count(arr) - 1);
else
cur_tag = NULL;
eina_strbuf_append_printf(txt, "</%c>", popped[1]);
} while (cur_tag && (popped != tag));
advance = 4;
}
else if (cur_tag)
{
/* tag match: just pop */
popped = eina_array_pop(arr);
if (eina_array_count(arr))
cur_tag = eina_array_data_get(arr, eina_array_count(arr) - 1);
else
cur_tag = NULL;
eina_strbuf_append_printf(txt, "</%c>", popped[1]);
advance = 4;
}
else
{
/* no current tag: escape */
advance = _text_escape(txt, text);
}
}
else
{
if (tag)
{
cur_tag = tag;
eina_array_push(arr, tag);
eina_strbuf_append_printf(txt, "<%c>", tag[1]);
advance = 3;
}
else
advance = _text_escape(txt, text);
}
}
else if (text[0] == '&')
{
const char *s;
s = strchr(text, ';');
if (s)
s = evas_textblock_escape_string_range_get(text, s + 1);
if (s)
{
eina_strbuf_append_char(txt, text[0]);
advance = 1;
}
else
advance = _text_escape(txt, text);
}
else
advance = _text_escape(txt, text);
text += advance;
}
eina_array_free(arr);
ret = eina_strbuf_string_steal(txt);
eina_strbuf_free(txt);
return ret;
}
