forked from enlightenment/efl
447 lines
13 KiB
C
447 lines
13 KiB
C
#include "edje_private.h"
|
|
|
|
#include <assert.h>
|
|
|
|
static Eina_Hash *signal_match = NULL;
|
|
|
|
static unsigned int
|
|
_edje_signal_match_key_length(const void *key EINA_UNUSED)
|
|
{
|
|
return sizeof (Edje_Signal_Callback_Matches);
|
|
}
|
|
|
|
static int
|
|
_edje_signal_match_key_cmp(const void *key1, int key1_length EINA_UNUSED, const void *key2, int key2_length EINA_UNUSED)
|
|
{
|
|
const Edje_Signal_Callback_Matches *a = key1;
|
|
const Edje_Signal_Callback_Matches *b = key2;
|
|
unsigned int i;
|
|
|
|
if (a->matches_count != b->matches_count) return a->matches_count - b->matches_count;
|
|
for (i = 0; i < a->matches_count; ++i)
|
|
{
|
|
if (a->matches[i].signal != b->matches[i].signal) return a->matches[i].signal - b->matches[i].signal;
|
|
if (a->matches[i].source != b->matches[i].source) return a->matches[i].source - b->matches[i].source;
|
|
if (a->matches[i].func != b->matches[i].func) return (unsigned char*) a->matches[i].func - (unsigned char*) b->matches[i].func;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static int
|
|
_edje_signal_match_key_hash(const void *key, int key_length EINA_UNUSED)
|
|
{
|
|
const Edje_Signal_Callback_Matches *a = key;
|
|
unsigned int hash, i;
|
|
|
|
hash = eina_hash_int32(&a->matches_count, sizeof (int));
|
|
for (i = 0; i < a->matches_count; ++i)
|
|
{
|
|
#ifdef EFL64
|
|
hash ^= eina_hash_int64((const unsigned long long int*) &a->matches[i].signal, sizeof (char *));
|
|
hash ^= eina_hash_int64((const unsigned long long int*) &a->matches[i].source, sizeof (char *));
|
|
hash ^= eina_hash_int64((const unsigned long long int*) &a->matches[i].func, sizeof (Edje_Signal_Cb));
|
|
#else
|
|
hash ^= eina_hash_int32((const unsigned int*) a->matches[i].signal, sizeof (char *));
|
|
hash ^= eina_hash_int32((const unsigned int*) a->matches[i].source, sizeof (char *));
|
|
hash ^= eina_hash_int32((const unsigned int*) a->matches[i].func, sizeof (Edje_Signal_Cb));
|
|
#endif
|
|
}
|
|
return hash;
|
|
}
|
|
|
|
static const Edje_Signal_Callback_Matches *
|
|
_edje_signal_callback_matches_dup(const Edje_Signal_Callback_Matches *src)
|
|
{
|
|
Edje_Signal_Callback_Matches *result;
|
|
unsigned int i;
|
|
|
|
result = calloc(1, sizeof (Edje_Signal_Callback_Matches));
|
|
if (!result) return NULL;
|
|
|
|
result->hashed = EINA_FALSE;
|
|
result->matches = malloc(sizeof (Edje_Signal_Callback_Match) * src->matches_count);
|
|
result->matches_count = src->matches_count;
|
|
result->patterns = NULL;
|
|
EINA_REFCOUNT_REF(result);
|
|
|
|
for (i = 0; i < src->matches_count; i++)
|
|
{
|
|
result->matches[i].signal = eina_stringshare_ref(src->matches[i].signal);
|
|
result->matches[i].source = eina_stringshare_ref(src->matches[i].source);
|
|
result->matches[i].func = src->matches[i].func;
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
void
|
|
_edje_callbacks_patterns_clean(Edje_Signal_Callback_Group *gp)
|
|
{
|
|
Edje_Signal_Callback_Matches *tmp;
|
|
|
|
assert(EINA_REFCOUNT_GET(gp->matches) == 1);
|
|
tmp = (Edje_Signal_Callback_Matches*) gp->matches;
|
|
|
|
_edje_signal_callback_patterns_unref(tmp->patterns);
|
|
tmp->patterns = NULL;
|
|
}
|
|
|
|
static void
|
|
_edje_callbacks_patterns_init(Edje_Signal_Callback_Group *gp)
|
|
{
|
|
Edje_Signals_Sources_Patterns *ssp;
|
|
Edje_Signal_Callback_Matches *tmp;
|
|
|
|
if (gp->matches->patterns) return;
|
|
|
|
tmp = (Edje_Signal_Callback_Matches*) gp->matches;
|
|
tmp->patterns = calloc(1, sizeof (Edje_Signals_Sources_Patterns));
|
|
if (!gp->matches->patterns) return;
|
|
|
|
ssp = gp->matches->patterns;
|
|
edje_match_callback_hash_build(gp->matches->matches,
|
|
gp->matches->matches_count,
|
|
&ssp->exact_match,
|
|
&ssp->u.callbacks.globing);
|
|
|
|
ssp->signals_patterns = edje_match_callback_signal_init(&ssp->u.callbacks.globing, tmp->matches);
|
|
ssp->sources_patterns = edje_match_callback_source_init(&ssp->u.callbacks.globing, tmp->matches);
|
|
EINA_REFCOUNT_REF(ssp);
|
|
}
|
|
|
|
void
|
|
edje_signal_init(void)
|
|
{
|
|
signal_match = eina_hash_new(_edje_signal_match_key_length,
|
|
_edje_signal_match_key_cmp,
|
|
_edje_signal_match_key_hash,
|
|
NULL,
|
|
3);
|
|
}
|
|
|
|
void
|
|
edje_signal_shutdown(void)
|
|
{
|
|
// FIXME: iterate and destroy leftover signal matcher
|
|
eina_hash_free(signal_match);
|
|
}
|
|
|
|
static void
|
|
_edje_signal_callback_unset(Edje_Signal_Callback_Group *gp, int idx)
|
|
{
|
|
Edje_Signal_Callback_Match *m;
|
|
|
|
m = gp->matches->matches + idx;
|
|
eina_stringshare_del(m->signal);
|
|
m->signal = NULL;
|
|
eina_stringshare_del(m->source);
|
|
m->source = NULL;
|
|
}
|
|
|
|
static void
|
|
_edje_signal_callback_set(Edje_Signal_Callback_Group *gp, int idx,
|
|
const char *sig, const char *src,
|
|
Edje_Signal_Cb func, void *data, Edje_Signal_Callback_Flags flags)
|
|
{
|
|
Edje_Signal_Callback_Match *m;
|
|
|
|
m = gp->matches->matches + idx;
|
|
m->signal = eina_stringshare_ref(sig);
|
|
m->source = eina_stringshare_ref(src);
|
|
m->func = func;
|
|
|
|
gp->custom_data[idx] = data;
|
|
|
|
gp->flags[idx] = flags;
|
|
}
|
|
|
|
static Edje_Signal_Callback_Group *
|
|
_edje_signal_callback_grow(Edje_Signal_Callback_Group *gp)
|
|
{
|
|
Edje_Signal_Callback_Matches *tmp;
|
|
|
|
tmp = (Edje_Signal_Callback_Matches*) gp->matches;
|
|
tmp->matches_count++;
|
|
tmp->matches = realloc(tmp->matches, sizeof (Edje_Signal_Callback_Match) * tmp->matches_count);
|
|
gp->custom_data = realloc(gp->custom_data, sizeof (void*) * tmp->matches_count);
|
|
gp->flags = realloc(gp->flags, sizeof (Edje_Signal_Callback_Flags) * tmp->matches_count);
|
|
|
|
return gp;
|
|
}
|
|
|
|
void
|
|
_edje_signal_callback_push(const Edje_Signal_Callback_Group *cgp,
|
|
const char *sig, const char *src,
|
|
Edje_Signal_Cb func, void *data, Eina_Bool propagate)
|
|
{
|
|
Edje_Signal_Callback_Group *gp = (Edje_Signal_Callback_Group*) cgp;
|
|
unsigned int i;
|
|
Edje_Signal_Callback_Flags flags;
|
|
|
|
flags.delete_me = EINA_FALSE;
|
|
flags.just_added = EINA_TRUE;
|
|
flags.propagate = !!propagate;
|
|
|
|
// let's first try to see if we do find an empty matching stop
|
|
for (i = 0; i < gp->matches->matches_count; i++)
|
|
if (sig == gp->matches->matches[i].signal &&
|
|
src == gp->matches->matches[i].source &&
|
|
func == gp->matches->matches[i].func)
|
|
{
|
|
if (gp->flags[i].delete_me)
|
|
{
|
|
_edje_signal_callback_unset(gp, i);
|
|
_edje_signal_callback_set(gp, i, sig, src, func, data, flags);
|
|
return;
|
|
}
|
|
}
|
|
|
|
if (gp->matches->hashed)
|
|
{
|
|
Edje_Signal_Callback_Matches *tmp;
|
|
|
|
tmp = (Edje_Signal_Callback_Matches*) gp->matches;
|
|
|
|
if (EINA_REFCOUNT_GET(tmp) == 1)
|
|
{
|
|
eina_hash_del(signal_match, tmp, tmp);
|
|
tmp->hashed = 0;
|
|
}
|
|
else
|
|
{
|
|
Edje_Signal_Callback_Matches *tmp_dup;
|
|
tmp_dup = (Edje_Signal_Callback_Matches*) _edje_signal_callback_matches_dup(tmp);
|
|
if (!tmp_dup) return;
|
|
EINA_REFCOUNT_UNREF(tmp)
|
|
(void) 0; // Nothing to do because the case where refcount == 1 was already handle above.
|
|
gp->matches = tmp_dup;
|
|
}
|
|
|
|
assert(gp->matches->hashed == 0);
|
|
}
|
|
|
|
// search an empty spot now
|
|
for (i = 0; i < gp->matches->matches_count; i++)
|
|
if (gp->flags[i].delete_me)
|
|
{
|
|
_edje_signal_callback_unset(gp, i);
|
|
_edje_signal_callback_set(gp, i, sig, src, func, data, flags);
|
|
return;
|
|
}
|
|
|
|
_edje_signal_callback_grow(gp);
|
|
|
|
// Set propagate and just_added flags
|
|
_edje_signal_callback_set(gp, gp->matches->matches_count - 1,
|
|
sig, src, func, data, flags);
|
|
|
|
return;
|
|
}
|
|
|
|
const Edje_Signal_Callback_Group *
|
|
_edje_signal_callback_alloc(void)
|
|
{
|
|
Edje_Signal_Callback_Group *escg;
|
|
Edje_Signal_Callback_Matches *m;
|
|
|
|
escg = calloc(1, sizeof (Edje_Signal_Callback_Group));
|
|
if (!escg) return NULL;
|
|
|
|
m = calloc(1, sizeof (Edje_Signal_Callback_Matches));
|
|
if (!m)
|
|
{
|
|
free(escg);
|
|
return NULL;
|
|
}
|
|
|
|
EINA_REFCOUNT_REF(m);
|
|
escg->matches = m;
|
|
|
|
return escg;
|
|
}
|
|
|
|
void
|
|
_edje_signal_callback_matches_unref(Edje_Signal_Callback_Matches *m)
|
|
{
|
|
EINA_REFCOUNT_UNREF(m)
|
|
{
|
|
unsigned int i;
|
|
|
|
_edje_signal_callback_patterns_unref(m->patterns);
|
|
|
|
if (m->hashed)
|
|
eina_hash_del(signal_match, m, m);
|
|
|
|
for (i = 0; i < m->matches_count; ++i)
|
|
{
|
|
eina_stringshare_del(m->matches[i].signal);
|
|
eina_stringshare_del(m->matches[i].source);
|
|
}
|
|
free(m->matches);
|
|
free(m);
|
|
}
|
|
}
|
|
|
|
void
|
|
_edje_signal_callback_free(const Edje_Signal_Callback_Group *cgp)
|
|
{
|
|
Edje_Signal_Callback_Group *gp = (Edje_Signal_Callback_Group*) cgp;
|
|
|
|
if (!gp) return;
|
|
|
|
_edje_signal_callback_matches_unref((Edje_Signal_Callback_Matches*) gp->matches);
|
|
gp->matches = NULL;
|
|
free(gp->flags);
|
|
free(gp->custom_data);
|
|
free(gp);
|
|
}
|
|
|
|
void *
|
|
_edje_signal_callback_disable(const Edje_Signal_Callback_Group *cgp,
|
|
const char *sig, const char *src,
|
|
Edje_Signal_Cb func, void *data)
|
|
{
|
|
Edje_Signal_Callback_Group *gp = (Edje_Signal_Callback_Group*) cgp;
|
|
unsigned int i;
|
|
|
|
if (!gp || !gp->matches) return NULL;
|
|
|
|
// FIXME: Shall we check DELETE_ME flags ?
|
|
for (i = 0; i < gp->matches->matches_count; ++i)
|
|
{
|
|
if (sig == gp->matches->matches[i].signal &&
|
|
src == gp->matches->matches[i].source &&
|
|
func == gp->matches->matches[i].func &&
|
|
gp->custom_data[i] == data)
|
|
{
|
|
gp->flags[i].delete_me = EINA_TRUE;
|
|
return gp->custom_data[i];
|
|
}
|
|
}
|
|
|
|
if (data == NULL)
|
|
{
|
|
for (i = 0; i < gp->matches->matches_count; ++i)
|
|
{
|
|
if (sig == gp->matches->matches[i].signal &&
|
|
src == gp->matches->matches[i].source &&
|
|
func == gp->matches->matches[i].func)
|
|
{
|
|
gp->flags[i].delete_me = EINA_TRUE;
|
|
return gp->custom_data[i];
|
|
}
|
|
}
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
static void
|
|
_edje_signal_callback_move_last(Edje_Signal_Callback_Group *gp,
|
|
unsigned int i)
|
|
{
|
|
Edje_Signal_Callback_Matches *m;
|
|
unsigned int j;
|
|
|
|
m = (Edje_Signal_Callback_Matches*) gp->matches;
|
|
|
|
for (j = --m->matches_count; j > i; --j)
|
|
{
|
|
if (!gp->flags[j].delete_me)
|
|
{
|
|
_edje_signal_callback_unset(gp, i);
|
|
m->matches[i].signal = m->matches[j].signal;
|
|
m->matches[i].source = m->matches[j].source;
|
|
m->matches[i].func = m->matches[j].func;
|
|
gp->flags[i] = gp->flags[j];
|
|
gp->custom_data[i] = gp->custom_data[j];
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
const Edje_Signals_Sources_Patterns *
|
|
_edje_signal_callback_patterns_ref(const Edje_Signal_Callback_Group *gp)
|
|
{
|
|
const Edje_Signal_Callback_Matches *m;
|
|
Edje_Signal_Callback_Matches *tmp;
|
|
|
|
if (gp->matches->hashed)
|
|
goto got_it;
|
|
|
|
m = eina_hash_find(signal_match, gp->matches);
|
|
if (!m)
|
|
{
|
|
tmp = (Edje_Signal_Callback_Matches*) gp->matches;
|
|
if (!(tmp->patterns && (EINA_REFCOUNT_GET(tmp->patterns) > 1)))
|
|
{
|
|
// Let compact it and remove uneeded pattern before building it
|
|
// We can do that because the custom data are kept local into the matching code.
|
|
unsigned int i;
|
|
|
|
for (i = 0; i < tmp->matches_count; i++)
|
|
{
|
|
if (gp->flags[i].delete_me)
|
|
_edje_signal_callback_move_last((Edje_Signal_Callback_Group*) gp, i);
|
|
}
|
|
|
|
}
|
|
|
|
_edje_signal_callback_patterns_unref(tmp->patterns);
|
|
tmp->patterns = NULL;
|
|
|
|
_edje_callbacks_patterns_init((Edje_Signal_Callback_Group*) gp);
|
|
eina_hash_add(signal_match, tmp, tmp);
|
|
// We should be able to use direct_add, but if I do so valgrind stack explode and
|
|
// it bagain to be a pain to debug efl apps. I can't understand what is going on.
|
|
// eina_hash_direct_add(signal_match, tmp, tmp);
|
|
tmp->hashed = EINA_TRUE;
|
|
}
|
|
else
|
|
{
|
|
_edje_signal_callback_matches_unref((Edje_Signal_Callback_Matches*) gp->matches);
|
|
((Edje_Signal_Callback_Group*)gp)->matches = m;
|
|
tmp = (Edje_Signal_Callback_Matches*) gp->matches;
|
|
EINA_REFCOUNT_REF(tmp);
|
|
}
|
|
|
|
got_it:
|
|
tmp = (Edje_Signal_Callback_Matches*) gp->matches;
|
|
|
|
EINA_REFCOUNT_REF(tmp->patterns);
|
|
return gp->matches->patterns;
|
|
}
|
|
|
|
void
|
|
_edje_signal_callback_patterns_unref(const Edje_Signals_Sources_Patterns *essp)
|
|
{
|
|
Edje_Signals_Sources_Patterns *ssp;
|
|
|
|
if (!essp) return;
|
|
|
|
ssp = (Edje_Signals_Sources_Patterns*) essp;
|
|
|
|
EINA_REFCOUNT_UNREF(ssp)
|
|
{
|
|
_edje_signals_sources_patterns_clean(ssp);
|
|
|
|
eina_rbtree_delete(ssp->exact_match,
|
|
EINA_RBTREE_FREE_CB(edje_match_signal_source_free),
|
|
NULL);
|
|
ssp->exact_match = NULL;
|
|
|
|
eina_inarray_flush(&ssp->u.callbacks.globing);
|
|
|
|
free(ssp);
|
|
}
|
|
}
|
|
|
|
void
|
|
_edje_signal_callback_reset(Edje_Signal_Callback_Flags *flags, unsigned int length)
|
|
{
|
|
unsigned int i;
|
|
for (i = 0; i < length; ++i)
|
|
flags[i].just_added = EINA_FALSE;
|
|
}
|
|
|