unsigned int j;
if (ep->type != EDJE_PART_TYPE_IMAGE)
- return ;
+ return;
ed = (Edje_Part_Description_Image*) ep->default_desc;
_edje_part_description_image_remove(ed);
eina_hash_set(part_dest_lookup, &pl->dest, list);
eina_hash_del(part_pc_dest_lookup, &key, pl);
}
- return ;
+ return;
}
if (!name[0]) return;
Eina_List *l, *l2;
Program_Lookup *pl;
- if (!ep) return ; /* FIXME: should we stop compiling ? */
+ if (!ep) return; /* FIXME: should we stop compiling ? */
EINA_LIST_FOREACH(program_lookups, l, pl)
{
{
Program_Lookup *pl;
- if (!name) return ; /* FIXME: should we stop compiling ? */
+ if (!name) return; /* FIXME: should we stop compiling ? */
pl = mem_alloc(SZ(Program_Lookup));
program_lookups = eina_list_append(program_lookups, pl);
image_lookups = eina_list_remove_list(image_lookups, l);
free(il->name);
free(il);
- return ;
+ return;
}
}
}
if (!watchfile) return;
f = fopen(watchfile, "ab");
- if (!f) return ;
+ if (!f) return;
if (anotate)
{
fprintf(f, "%c: %s\n", type, filename);
Edje_Program **tmp;
tmp = realloc(*array, sizeof (Edje_Program*) * (*count + 1));
- if (!tmp) return ;
+ if (!tmp) return;
tmp[(*count)++] = add;
*array = tmp;
Eina_List *r = NULL;
f = eina_file_open(file, EINA_FALSE);
- if (!f) return ;
+ if (!f) return;
it = eina_file_map_lines(f);
if (!it) goto err;
FILE *f;
f = fopen(options.watchfile, "a");
- if (!f) return ;
+ if (!f) return;
if (anotate)
{
fprintf(f, "%c: %s\n", type, filename);
else
{
ERR("Impossible to allocate mempool '%s' !", choice);
- return ;
+ return;
}
}
}
if (n->buffer_current + size > n->buffer_length)
{
_ecore_con_eet_reply_cleanup(n);
- return ;
+ return;
}
_ecore_con_eet_raw_data_push(n, data, size);
- return ;
+ return;
}
else if (eet_connection_empty(n->econn) && size > (int) (4 * sizeof (unsigned int) + 2))
{
if (n->buffer)
{
_ecore_con_eet_raw_data_push(n, buffer, size);
- return ;
+ return;
}
_ecore_con_eet_reply_cleanup(n);
EAPI void
ecore_con_eet_server_free(Ecore_Con_Eet *r)
{
- if (!r) return ;
+ if (!r) return;
eet_data_descriptor_free(r->edd);
eet_data_descriptor_free(r->matching);
EAPI void
ecore_con_eet_register(Ecore_Con_Eet *ece, const char *name, Eet_Data_Descriptor *edd)
{
- if (!ece) return ;
+ if (!ece) return;
EET_DATA_DESCRIPTOR_ADD_MAPPING(ece->matching, name, edd);
}
{
Ecore_Con_Eet_Data *eced;
- if (!ece) return ;
+ if (!ece) return;
eced = calloc(1, sizeof (Ecore_Con_Eet_Data));
- if (!eced) return ;
+ if (!eced) return;
eced->func = func;
eced->data = data;
EAPI void
ecore_con_eet_data_callback_del(Ecore_Con_Eet *ece, const char *name)
{
- if (!ece) return ;
+ if (!ece) return;
eina_hash_del(ece->data_callbacks, name, NULL);
}
{
Ecore_Con_Eet_Raw_Data *eced;
- if (!ece) return ;
+ if (!ece) return;
eced = calloc(1, sizeof (Ecore_Con_Eet_Raw_Data));
- if (!eced) return ;
+ if (!eced) return;
eced->func = func;
eced->data = data;
EAPI void
ecore_con_eet_raw_data_callback_del(Ecore_Con_Eet *ece, const char *name)
{
- if (!ece) return ;
+ if (!ece) return;
if (ece->client && ece->u.client.r->buffer_handler && !strcmp(ece->u.client.r->buffer_handler->name, name))
{
{
Ecore_Con_Eet_Client *c;
- if (!ece || !func) return ;
+ if (!ece || !func) return;
c = calloc(1, sizeof (Ecore_Con_Eet_Client));
- if (!c) return ;
+ if (!c) return;
c->func = func;
c->data = data;
Ecore_Con_Eet_Client *c;
Eina_List *l;
- if (!ece || !func) return ;
+ if (!ece || !func) return;
EINA_LIST_FOREACH(ece->u.server.client_connect_callbacks, l, c)
if (c->func == func && c->data == data)
{
ece->u.server.client_connect_callbacks = eina_list_remove_list(ece->u.server.client_connect_callbacks, l);
free(c);
- return ;
+ return;
}
}
{
Ecore_Con_Eet_Client *c;
- if (!ece || !func) return ;
+ if (!ece || !func) return;
c = calloc(1, sizeof (Ecore_Con_Eet_Client));
- if (!c) return ;
+ if (!c) return;
c->func = func;
c->data = data;
Ecore_Con_Eet_Client *c;
Eina_List *l;
- if (!ece || !func) return ;
+ if (!ece || !func) return;
EINA_LIST_FOREACH(ece->u.server.client_disconnect_callbacks, l, c)
if (c->func == func && c->data == data)
ece->u.server.client_disconnect_callbacks = eina_list_remove_list(ece->u.server.client_disconnect_callbacks,
l);
free(c);
- return ;
+ return;
}
}
{
Ecore_Con_Eet_Server *s;
- if (!ece || !func) return ;
+ if (!ece || !func) return;
s = calloc(1, sizeof (Ecore_Con_Eet_Server));
- if (!s) return ;
+ if (!s) return;
s->func = func;
s->data = data;
Ecore_Con_Eet_Server *s;
Eina_List *l;
- if (!ece || !func) return ;
+ if (!ece || !func) return;
EINA_LIST_FOREACH(ece->u.client.server_connect_callbacks, l, s)
if (s->func == func && s->data == data)
{
ece->u.client.server_connect_callbacks = eina_list_remove_list(ece->u.client.server_connect_callbacks, l);
free(s);
- return ;
+ return;
}
}
{
Ecore_Con_Eet_Server *s;
- if (!ece || !func) return ;
+ if (!ece || !func) return;
s = calloc(1, sizeof (Ecore_Con_Eet_Server));
- if (!s) return ;
+ if (!s) return;
s->func = func;
s->data = data;
Ecore_Con_Eet_Server *s;
Eina_List *l;
- if (!ece || !func) return ;
+ if (!ece || !func) return;
EINA_LIST_FOREACH(ece->u.client.server_disconnect_callbacks, l, s)
if (s->func == func && s->data == data)
{
ece->u.client.server_disconnect_callbacks = eina_list_remove_list(ece->u.client.server_disconnect_callbacks, l);
free(s);
- return ;
+ return;
}
}
{
Ecore_Con_Eet_Protocol protocol;
- if (!reply) return ;
+ if (!reply) return;
protocol.type = name;
protocol.data = value;
unsigned int size;
char *tmp;
- if (!reply) return ;
- if (!protocol_name) return ;
- if (!section) return ;
+ if (!reply) return;
+ if (!protocol_name) return;
+ if (!section) return;
protocol_length = strlen(protocol_name) + 1;
- if (protocol_length == 1) return ;
+ if (protocol_length == 1) return;
section_length = strlen(section) + 1;
protocol[0] = htonl(ECORE_CON_EET_RAW_MAGIC);
{
Ecore_Event_Last *eel;
- if (!_last_events_enable) return ;
+ if (!_last_events_enable) return;
eel = _ecore_event_evas_lookup(e->multi.device, e->buttons, EINA_TRUE);
- if (!eel) return ;
+ if (!eel) return;
switch (eel->state)
{
{
/* Save the Ecore_Event somehow */
if (!eel->ev) eel->ev = malloc(sizeof (Ecore_Event_Mouse_Button));
- if (!eel->ev) return ;
+ if (!eel->ev) return;
memcpy(eel->ev, e, sizeof (Ecore_Event_Mouse_Button));
eel->timer = ecore_timer_add(_last_events_timeout, _ecore_event_evas_push_fake, eel);
}
Ecore_Event_Last *eel;
Eina_List *l;
- if (!_last_events_enable) return ;
+ if (!_last_events_enable) return;
EINA_LIST_FOREACH(_last_events, l, eel)
switch (eel->state)
Ecore_Event_Mouse_Move *ev;
ev = malloc(sizeof(Ecore_Event_Mouse_Move));
- if (!ev) return ;
+ if (!ev) return;
ev->timestamp = timestamp;
ev->window = 0;
Ecore_Event_Mouse_Wheel *ev;
ev = malloc(sizeof(Ecore_Event_Mouse_Wheel));
- if (!ev) return ;
+ if (!ev) return;
ev->timestamp = timestamp;
ev->window = 0;
Ecore_Event_Mouse_Button *ev;
ev = malloc(sizeof(Ecore_Event_Mouse_Button));
- if (!ev) return ;
+ if (!ev) return;
ev->timestamp = timestamp;
ev->window = 0;
Ecore_Event_Mouse_Button *ev;
ev = malloc(sizeof(Ecore_Event_Mouse_Button));
- if (!ev) return ;
+ if (!ev) return;
ev->timestamp = timestamp;
ev->window = 0;
ev->event_window = 0;
+ edc->programs.strrncmp_count
+ edc->programs.fnmatch_count
+ edc->programs.nocmp_count;
- if (j == 0) return ;
+ if (j == 0) return;
all = malloc(sizeof (Edje_Program *) * j);
- if (!all) return ;
+ if (!all) return;
j = 0;
/* FIXME: Build specialized data type for each case */
eo_do(ed->obj, evas_obj_size_hint_min_set(w, h));
}
- if (!ed->collection) return ;
+ if (!ed->collection) return;
for (i = 0; i < ed->collection->limits.parts_count; i++)
{
_edje_dragable_pos_set(Edje *ed, Edje_Real_Part *ep, FLOAT_T x, FLOAT_T y)
{
/* check whether this part is dragable at all */
- if (!ep->drag) return ;
+ if (!ep->drag) return;
/* instead of checking for equality, we really should check that
* the difference is greater than foo, but I have no idea what
params->lighted = params->mapped ? !!light : 0;
params->persp_on = params->mapped ? !!persp : 0;
- if (!params->mapped) return ;
+ if (!params->mapped) return;
EINA_COW_CALC_MAP_BEGIN(params, params_write)
{
#ifdef EDJE_CALC_CACHE
if (ep->state == ed->state && !state)
- return ;
+ return;
#endif
if (ep->param1.description->rel1.id_x >= 0)
Edje_Program **tmp;
tmp = realloc(*array, sizeof (Edje_Program*) * (*count + 1));
- if (!tmp) return ;
+ if (!tmp) return;
tmp[(*count)++] = add;
*array = tmp;
{
free(rp->drag);
rp->drag = NULL;
- return ;
+ return;
}
if (rp->drag) return;
{
free(rp->drag);
rp->drag = NULL;
- return ;
+ return;
}
if (rp->drag) return;
if (!e) \
{ \
rp->part->dragable.Id##_id = -1; \
- return ; \
+ return; \
} \
\
e_part = _edje_real_part_get(ed, e); \
if (!rp->typedata.text->entry_data) return;
ed = _edje_fetch(o);
- if (ed) return ;
+ if (ed) return;
en = rp->typedata.text->entry_data;
if (!en || !en->imf_context) return;
void
edje_match_patterns_free(Edje_Patterns *ppat)
{
- if (!ppat) return ;
+ if (!ppat) return;
ppat->delete_me = EINA_TRUE;
ppat->ref--;
Edje_Signals_Sources_Patterns *ssp;
Edje_Signal_Callback_Matches *tmp;
- if (gp->matches->patterns) return ;
+ 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 ;
+ if (!gp->matches->patterns) return;
ssp = gp->matches->patterns;
edje_match_callback_hash_build(gp->matches->matches,
_edje_signal_callback_set(gp, i,
sig, src, func, data,
(((!!propagate) & 1) | _JUST_ADDED));
- return ;
+ return;
}
}
{
Edje_Signal_Callback_Matches *tmp_dup;
tmp_dup = (Edje_Signal_Callback_Matches*) _edje_signal_callback_matches_dup(tmp);
- if (!tmp_dup) return ;
+ 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;
_edje_signal_callback_set(gp, i,
sig, src, func, data,
(((!!propagate) & 1) | _JUST_ADDED));
- return ;
+ return;
}
if (gp->flags[i >> 1] & (_DELETE_ME << 4))
{
_edje_signal_callback_set(gp, i + 1,
sig, src, func, data,
(((!!propagate) & 1) | _JUST_ADDED));
- return ;
+ return;
}
}
_edje_signal_callback_set(gp, gp->matches->matches_count - 1,
sig, src, func, data, (((!!propagate) & 1) | _JUST_ADDED));
- return ;
+ return;
}
const Edje_Signal_Callback_Group *
{
Edje_Signal_Callback_Group *gp = (Edje_Signal_Callback_Group*) cgp;
- if (!gp) return ;
+ if (!gp) return;
_edje_signal_callback_matches_unref((Edje_Signal_Callback_Matches*) gp->matches);
gp->matches = NULL;
m->matches[i].func = m->matches[j].func;
gp->flags[i] = (gp->flags[i >> 1] & (0xF << (((i & 1) ^ 1) * 4))) |
(gp->flags[j >> 1] & (0xF << (((j & 1) * 4))));
- return ;
+ return;
}
--m->matches_count;
}
{
Edje_Signals_Sources_Patterns *ssp;
- if (!essp) return ;
+ if (!essp) return;
ssp = (Edje_Signals_Sources_Patterns*) essp;
char *buffer;
unsigned int length;
- if (!limit_name) return ;
+ if (!limit_name) return;
length = strlen(limit_name) + 13;
buffer = alloca(length);
{
unsigned int i;
- if (size_next == size_current) return ;
+ if (size_next == size_current) return;
for (i = 0; i < length; ++i)
{
if (!pt) return;
if (pt->type != EDJE_PART_TYPE_TEXT
&& pt->type != EDJE_PART_TYPE_TEXTBLOCK)
- return ;
+ return;
desc = (Edje_Part_Description_Text *) pt->default_desc;
if ((pt->default_desc) && (desc->text.text_class))
}
lookup = malloc(sizeof (Edje_List_Refcount));
- if (!lookup) return ;
+ if (!lookup) return;
EINA_REFCOUNT_INIT(lookup);
/* Get members list */
if (!members) return;
lookup = eina_hash_find(*ehash, class);
- if (!lookup) return ;
+ if (!lookup) return;
EINA_REFCOUNT_UNREF(lookup)
{
if (!raw_text)
{
_edje_user_definition_free(eud);
- return ;
+ return;
}
eud->u.string.text = raw_text;
- return ;
+ return;
}
eud = _edje_user_definition_new(EDJE_USER_STRING, part, ed);
- if (!eud) return ;
+ if (!eud) return;
eud->u.string.text = raw_text;
}
if (eud->type == EDJE_USER_SWALLOW && eud->u.swallow.child == obj_swallow)
{
_edje_user_definition_free(eud);
- return ;
+ return;
}
}
}
Eina_Bool update = va_arg(*list, int);
Edje *ed = _pd;
- if (!ed) return ;
- if (ed->update_hints == !!update) return ;
+ if (!ed) return;
+ if (ed->update_hints == !!update) return;
ed->update_hints = !!update;
if (update)
type >= EET_T_LAST)
{
CRIT("Preventing later bug due to unknow type: %i", type);
- return ;
+ return;
}
if (offset < 0)
{
CRIT("Preventing later buffer underrun : offset = %i", offset);
- return ;
+ return;
}
if (offset > edd->size)
{
CRIT("Preventing later buffer overrun : offset = %i in a structure of %i bytes", offset, edd->size);
- return ;
+ return;
}
if (group_type == EET_G_UNKNOWN && type != EET_T_UNKNOW)
{
if (offset + eet_basic_codec[type - 1].size > edd->size)
{
CRIT("Preventing later buffer overrun : offset = %i, size = %i in a structure of %i bytes", offset, eet_basic_codec[type - 1].size, edd->size);
- return ;
+ return;
}
}
else if ((offset + sizeof (void*)) > (unsigned int) edd->size)
{
CRIT("Preventing later buffer overrun : offset = %i, estimated size = %zu in a structure of %i bytes", offset, sizeof (void*), edd->size);
- return ;
+ return;
}
/* UNION, VARIANT type would not work with simple type, we need a way to map the type. */
EINA_SAFETY_ON_NULL_RETURN(file);
f = eina_file_open(file, 0);
- if (!f) return ;
+ if (!f) return;
it = eina_file_map_lines(f);
if (it)
void *data;
unsigned int i;
- if (!accessor) return ;
+ if (!accessor) return;
EINA_MAGIC_CHECK_ACCESSOR(accessor);
EINA_SAFETY_ON_NULL_RETURN(accessor->get_container);
EINA_SAFETY_ON_FALSE_RETURN(start < end);
if (!eina_accessor_lock(accessor))
- return ;
+ return;
container = accessor->get_container(accessor);
for (i = start; i < end && accessor->get_at(accessor, i, &data) == EINA_TRUE;
(int) sizeof (Eina_Array));
/* Force memory to zero to provide a small layer of security */
memset(array, 0, sizeof_eina_array);
- return ;
+ return;
}
array->version = EINA_ARRAY_VERSION;
Eina_Cow_Ptr *ref)
{
/* eina_cow_gc is not supposed to be thread safe */
- if (!ref->hashed) return ;
+ if (!ref->hashed) return;
current_cow_size = cow->struct_size;
eina_hash_del(cow->match, data, data);
_eina_cow_togc_del(Eina_Cow *cow, Eina_Cow_Ptr *ref)
{
/* eina_cow_gc is not supposed to be thread safe */
- if (!ref->togc) return ;
+ if (!ref->togc) return;
eina_hash_del(cow->togc, &ref, NULL);
ref->togc = EINA_FALSE;
}
Eina_Cow_GC *gc;
/* needed if we want to make cow gc safe */
- if (ref->togc) return ;
+ if (ref->togc) return;
#ifndef NVALGRIND
VALGRIND_MAKE_MEM_NOACCESS(ref, sizeof (*ref));
#endif
gc = eina_mempool_malloc(gc_pool, sizeof (Eina_Cow_GC));
- if (!gc) return ; /* That one will not get gced this time */
+ if (!gc) return; /* That one will not get gced this time */
gc->ref = ref;
gc->dst = dst;
EAPI void
eina_cow_del(Eina_Cow *cow)
{
- if (!cow) return ;
+ if (!cow) return;
#ifdef EINA_COW_MAGIC_ON
EINA_COW_MAGIC_CHECK(cow);
EINA_COW_MAGIC_CHECK(cow);
#endif
- if (!data) return ;
- if (cow->default_value == data) return ;
+ if (!data) return;
+ if (cow->default_value == data) return;
ref = EINA_COW_PTR_GET(data);
#ifndef NVALGRIND
#ifndef NVALGRIND
VALGRIND_MAKE_MEM_NOACCESS(ref, sizeof (*ref));
#endif
- return ;
+ return;
}
#ifdef EINA_COW_MAGIC_ON
VALGRIND_MAKE_MEM_NOACCESS(ref, sizeof (*ref));
#endif
- if (!cow->togc || !needed_gc) return ;
+ if (!cow->togc || !needed_gc) return;
#ifndef NVALGRIND
VALGRIND_MAKE_MEM_DEFINED(ref, sizeof (*ref));
EINA_COW_MAGIC_CHECK(cow);
- if (*dst == src) return ;
+ if (*dst == src) return;
if (src != cow->default_value)
{
eina_lock_take(&file->lock);
file->refcount--;
eina_lock_release(&file->lock);
- if (file->refcount != 0) return ;
+ if (file->refcount != 0) return;
eina_lock_take(&_eina_file_lock_cache);
(int) sizeof (Eina_Inarray));
/* Force memory to zero to provide a small layer of security */
memset(array, 0, sizeof_eina_inarray);
- return ;
+ return;
}
_eina_inarray_setup(array, member_size, step);
EINA_SAFETY_ON_NULL_RETURN(iterator->next);
EINA_SAFETY_ON_NULL_RETURN(cb);
- if (!eina_iterator_lock(iterator)) return ;
+ if (!eina_iterator_lock(iterator)) return;
container = iterator->get_container(iterator);
while (iterator->next(iterator, &data) == EINA_TRUE)
Eina_Log_Domain *d;
Eina_Log_Timing *t;
- if (_disable_timing) return ;
+ if (_disable_timing) return;
d = _log_domains + domain;
t = _log_timing + domain;
#endif
if (!t->phase && state == EINA_LOG_STATE_STOP)
- return ;
+ return;
if (t->phase == EINA_LOG_STATE_INIT &&
phase == EINA_LOG_STATE_SHUTDOWN)
- return ;
+ return;
if (state == EINA_LOG_STATE_START &&
t->phase &&
{
Eina_Object_Item *item;
- if (!object) return ;
+ if (!object) return;
EINA_MAGIC_CHECK_CLASS(class);
if (!eina_lock_take(&class->mutex))
/* list all the content that should be copied */
if (!_eio_dir_recursiv_ls(thread, copy, copy->progress.source))
- return ;
+ return;
/* init all structure needed to copy the file */
if (!_eio_dir_init(thread, &step, &count, &length_source, &length_dest, copy, &file_copy))
if (!ecore_thread_check(thread))
eio_progress_send(thread, ©->progress, count, count);
- return ;
+ return;
}
static void
{
/* we are really lucky */
eio_progress_send(thread, &move->progress, 1, 1);
- return ;
+ return;
}
/* list all the content that should be moved */
if (!_eio_dir_recursiv_ls(thread, move, move->progress.source))
- return ;
+ return;
/* init all structure needed to move the file */
if (!_eio_dir_init(thread, &step, &count, &length_source, &length_dest, move, &file_move))
/* list all the content that should be moved */
if (!_eio_dir_recursiv_ls(thread, rmrf, rmrf->progress.source))
- return ;
+ return;
/* init counter */
step = 0;
if (!ls)
{
eio_file_thread_error(&async->ls.common, thread);
- return ;
+ return;
}
eio_file_container_set(&async->ls.common, eina_iterator_container_get(ls));
if (!ls)
{
eio_file_thread_error(&async->ls.common, thread);
- return ;
+ return;
}
eio_file_container_set(&async->ls.common, eina_iterator_container_get(ls));
if (move->copy)
{
eio_file_cancel(move->copy);
- return ;
+ return;
}
if (move->progress.common.error == EXDEV)
move->copy = eio_cp;
move->progress.common.thread = ((Eio_File_Progress*)move->copy)->common.thread;
- return ;
+ return;
}
}
Eio_Progress *progress;
if (op->progress_cb == NULL)
- return ;
+ return;
progress = eio_progress_malloc();
- if (!progress) return ;
+ if (!progress) return;
progress->op = op->op;
progress->current = current;
{
Eio_File_Associate *tmp;
- if (!data) return ;
+ if (!data) return;
tmp = data;
if (tmp->free_cb)
Eio_Monitor_Error *ev;
ev = calloc(1, sizeof (Eio_Monitor_Error));
- if (!ev) return ;
+ if (!ev) return;
ev->monitor = monitor;
EINA_REFCOUNT_REF(ev->monitor);
EINA_REFCOUNT_UNREF(monitor)
_eio_monitor_free(monitor);
- return ;
+ return;
}
/**
Eio_Monitor_Event *ev;
ev = calloc(1, sizeof (Eio_Monitor_Event));
- if (!ev) return ;
+ if (!ev) return;
ev->monitor = monitor;
EINA_REFCOUNT_REF(ev->monitor);
if (tmp == monitor->path)
{
_eio_monitor_error(monitor, -1);
- return ;
+ return;
}
EINA_REFCOUNT_REF(monitor); /* as we spawn a thread for this monitor, we need to refcount specifically for it */
fd = inotify_init();
if (fd < 0)
- return ;
+ return;
#ifdef HAVE_FCNTL
flags = fcntl(fd, F_GETFD);
if (!_inotify_fdh)
{
close(fd);
- return ;
+ return;
}
_inotify_monitors = eina_hash_int32_new(_eio_inotify_del);
{
int fd;
- if (!_inotify_fdh) return ;
+ if (!_inotify_fdh) return;
eina_hash_free(_inotify_monitors);
if (!_inotify_fdh)
eio_monitor_fallback_del(monitor);
- if (!monitor->backend) return ;
+ if (!monitor->backend) return;
eina_hash_del(_inotify_monitors, &monitor->backend->hwnd, monitor->backend);
monitor->backend = NULL;
est = alloca(sizeof (Eina_Stat));
if (!backend->parent)
- return ;
+ return;
if (_eio_stat(backend->parent->path, &st))
{
ecore_thread_main_loop_end();
backend->destroyed = EINA_TRUE;
}
- return ;
+ return;
}
backend->destroyed = EINA_FALSE;
if (backend->delete_me)
{
free(backend);
- return ;
+ return;
}
backend->timer = ecore_timer_add(60.0, _eio_monitor_fallback_timer_cb, backend);
}
monitor->backend = NULL;
backend = calloc(1, sizeof (Eio_Monitor_Backend));
- if (!backend) return ;
+ if (!backend) return;
backend->children = eina_hash_string_superfast_new(free);
backend->parent = monitor;
backend = monitor->backend;
monitor->backend = NULL;
- if (!backend) return ;
+ if (!backend) return;
backend->parent = NULL;
if (backend->timer) ecore_timer_del(backend->timer);
{
backend->delete_me = EINA_TRUE;
ecore_thread_cancel(backend->work);
- return ;
+ return;
}
eina_hash_free(backend->children);
free(backend);
if (!_eio_monitor_win32_native)
{
eio_monitor_fallback_del(monitor);
- return ;
+ return;
}
_eio_monitor_win32_watcher_free(monitor->backend->watcher_parent);
if (chown(own->path, owner, group) != 0)
eio_file_thread_error(&own->common, thread);
- return ;
+ return;
on_error:
ecore_thread_cancel(thread);
- return ;
+ return;
#endif
}
const char *tmp;
it = eina_xattr_ls(async->ls.directory);
- if (!it) return ;
+ if (!it) return;
EINA_ITERATOR_FOREACH(it, tmp)
{
if (!sd->open)
{
sd->remember_jump = sec;
- return ;
+ return;
}
sd->remember_jump = 0;
sd->seek_pos = sec;
#endif
E_SMART_OBJ_GET(sd, obj, E_OBJ_NAME);
- if (!sd->file) return ;
+ if (!sd->file) return;
if (!strncmp(sd->file, "file://", 7))
tmp = sd->file + 7;
else if (!strstr(sd->file, "://"))
tmp = sd->file;
else
- return ;
+ return;
#ifdef HAVE_EIO
- if (sd->load_xattr) return ;
+ if (sd->load_xattr) return;
EINA_REFCOUNT_REF(sd);
const char *tmp;
E_SMART_OBJ_GET(sd, obj, E_OBJ_NAME);
- if (!sd->file) return ;
+ if (!sd->file) return;
if (!strncmp(sd->file, "file://", 7))
tmp = sd->file + 7;
else if (!strstr(sd->file, "://"))
tmp = sd->file;
else
- return ;
+ return;
#ifdef HAVE_EIO
- if (sd->save_xattr) return ;
+ if (sd->save_xattr) return;
EINA_REFCOUNT_REF(sd);
int fd;
#endif
- if (!ew) return ;
+ if (!ew) return;
#ifdef HAVE_V4L2
if (!ew->device) goto on_error;
EINA_REFCOUNT_INIT(ew);
- return ;
+ return;
on_error:
#endif
EINA_SAFETY_ON_NULL_RETURN(dst);
EINA_SAFETY_ON_NULL_RETURN(src);
- if (src == dst) return ;
+ if (src == dst) return;
eina_stringshare_del(dst->src_hash);
dst->src_hash = eina_stringshare_ref(src->src_hash);
if (eim->flags.dirty)
{
_evas_cache_engine_image_dealloc(cache, eim);
- return ;
+ return;
}
if (eim->references == 0)
_evas_cache_engine_image_remove_activ(cache, eim);
_evas_cache_engine_image_make_inactive(cache, eim, eim->cache_key);
evas_cache_engine_image_flush(cache);
- return ;
+ return;
}
}
if (e->output.render_method != RENDER_METHOD_INVALID) return;
/* Request the right engine. */
em = evas_module_engine_get(render_method);
- if (!em) return ;
+ if (!em) return;
if (em->id_engine != render_method) return;
if (!evas_module_load(em)) return;
obj->changed_map = EINA_TRUE;
}
- if (!obj->changed_map) return ;
+ if (!obj->changed_map) return;
if (obj->map->cur.map && obj->map->spans && obj->map->cur.map->count != obj->map->spans->count)
{
EINA_COW_WRITE_END(evas_object_map_cow, obj->map, map_write);
}
- if (!obj->map->spans) return ;
+ if (!obj->map->spans) return;
EINA_COW_WRITE_BEGIN(evas_object_map_cow, obj->map, Evas_Object_Map_Data, map_write)
{
evas_object_inject(eo_obj, obj, eo_e);
if (!_init_cow(eo_obj))
- return ;
+ return;
o->load_opts = eina_cow_alloc(evas_object_image_load_opts_cow);
o->pixels = eina_cow_alloc(evas_object_image_pixels_cow);
evas_object_image_preload(Evas_Object *eo_obj, Eina_Bool cancel)
{
MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ);
- return ;
+ return;
MAGIC_CHECK_END();
if (cancel)
eo_do(eo_obj, evas_obj_image_preload_cancel());
Eina_Bool enable = va_arg(*list, int);
Evas_Object_Image *o = _pd;
- if (o->load_opts->orientation == !!enable) return ;
+ if (o->load_opts->orientation == !!enable) return;
EINA_COW_LOAD_OPTS_WRITE_BEGIN(o, low)
low->orientation = !!enable;
if (surf)
{
- if (surf->version != EVAS_VIDEO_SURFACE_VERSION) return ;
+ if (surf->version != EVAS_VIDEO_SURFACE_VERSION) return;
if (!surf->update_pixels ||
!surf->move ||
!surf->resize ||
!surf->hide ||
!surf->show)
- return ;
+ return;
o->created = EINA_TRUE;
o->video_surface = EINA_TRUE;
!o->pixels->video.hide &&
!o->pixels->video.show &&
!o->pixels->video.data)
- return ;
+ return;
o->video_surface = EINA_FALSE;
EINA_COW_PIXEL_WRITE_BEGIN(o, pixi_write)
{
Evas_Object_Image *o;
- if (!eo_isa(obj, MY_CLASS)) return ;
+ if (!eo_isa(obj, MY_CLASS)) return;
o = eo_data_scope_get(obj, MY_CLASS);
Evas_Coord px, py, pw, ph;
Eina_Bool noclip;
- if (!obj->smart.parent) return ;
+ if (!obj->smart.parent) return;
- if (obj->child_has_map) return ; /* Disable bounding box computation for this object and its parent */
+ if (obj->child_has_map) return; /* Disable bounding box computation for this object and its parent */
/* We could also remove object that are not visible from the bounding box, use the clipping information
to reduce the bounding of the object they are clipping, but for the moment this will do it's jobs */
noclip = !(obj->clip.clipees || obj->is_static_clip);
Evas_Object_Protected_Data *obj = eo_data_scope_get(eo_obj, EVAS_OBJ_CLASS);
Evas_Object_Smart *o = eo_data_scope_get(eo_obj, MY_CLASS);
- if (o->update_boundingbox_needed) return ;
+ if (o->update_boundingbox_needed) return;
o->update_boundingbox_needed = EINA_TRUE;
if (obj->smart.parent) evas_object_smart_need_bounding_box_update(obj->smart.parent);
os = eo_data_scope_get(eo_obj, MY_CLASS);
- if (!os->update_boundingbox_needed) return ;
+ if (!os->update_boundingbox_needed) return;
os->update_boundingbox_needed = EINA_FALSE;
minx = obj->layer->evas->output.w;
obj->cur->scale == obj->prev->scale &&
o->last_computed.w == obj->cur->geometry.w &&
o->last_computed.h == obj->cur->geometry.h)
- return ;
+ return;
evas_object_content_change(eo_obj, obj);
Evas_Object_Text *o = _pd;
double ellipsis = va_arg(*list, double);
- if (o->cur.ellipsis == ellipsis) return ;
+ if (o->cur.ellipsis == ellipsis) return;
o->cur.ellipsis = ellipsis;
o->changed = 1;
if (!fad)
{
ERR("Failed to allocate Evas_Font_Array_Data.");
- return ;
+ return;
}
for (xx = 0; xx < row->texts_num; xx++)
color->r == r &&
color->g == g &&
color->b == b)
- return ;
+ return;
}
else
{
OBJS_ARRAY_CLEAN(&e->restack_objects);
OBJS_ARRAY_CLEAN(&e->delete_objects);
e->invalidate = EINA_TRUE;
- return ;
+ return;
}
}
}
EAPI void
evas_common_draw_context_cutouts_free(Cutout_Rects* rects)
{
- if (!rects) return ;
+ if (!rects) return;
rects->active = 0;
}
dc->clip.x, dc->clip.y,
dc->clip.w, dc->clip.h,
im_w, im_h);
- return ;
+ return;
}
for (i = 0; i < reuse->active; ++i)
{
RGBA_Font_Int *fi = NULL;
- if (!fonts_lru) return ;
+ if (!fonts_lru) return;
fi = eina_list_data_get(fonts_lru);
fonts_lru = eina_list_remove_list(fonts_lru, fonts_lru);
eina_hash_del(fonts, fi, fi);
{
DATA32 nas = 0;
- if (!ie) return ;
- if (!evas_cache_image_pixels(ie)) return ;
+ if (!ie) return;
+ if (!evas_cache_image_pixels(ie)) return;
if (!ie->flags.alpha) return;
nas = evas_common_convert_argb_premul(evas_cache_image_pixels(ie), ie->w * ie->h);
DATA32 nas = 0;
if (!ie) return;
- if (!evas_cache_image_pixels(ie)) return ;
+ if (!evas_cache_image_pixels(ie)) return;
if (!ie->flags.alpha) return;
s = evas_cache_image_pixels(ie);
if (old && old->count == count)
{
- return ;
+ return;
}
size = sizeof (RGBA_Map_Cutout) + sizeof (RGBA_Map_Spans) * (count - 1);
memset(r, 0, size);
m->engine_data = r;
r->count = count;
- return ;
+ return;
empty:
evas_common_map_rgba_clean(m);
- return ;
+ return;
}
static void
evas_common_pipe_image_load(RGBA_Image *im)
{
if (im->flags & RGBA_IMAGE_TODO_LOAD)
- return ;
+ return;
if (im->cache_entry.space == EVAS_COLORSPACE_ARGB8888
&& !evas_cache_image_is_loaded(&(im->cache_entry)))
if (!((!im->cs.data) || ((!im->cs.dirty) && (!(im->flags & RGBA_IMAGE_IS_DIRTY)))))
goto add_task;
- return ;
+ return;
add_task:
LKL(im_task_mutex);
RGBA_Font_Int *fi;
fi = text_props->font_instance;
- if (!fi) return ;
+ if (!fi) return;
if (!text_props->changed && text_props->generation == fi->generation && text_props->glyphs)
- return ;
+ return;
LKL(fi->ft_mutex);
clip->x, clip->y,
clip->w, clip->h);
rectangle_draw_internal(dst, dc, x, y, w, h);
- return ;
+ return;
}
for (i = 0; i < reuse->active; ++i)
if (!em->loaded)
return;
if (!em->definition)
- return ;
+ return;
// for now lets not unload modules - they may still be in use.
// em->definition->func.close(em);
| SDL_DOUBLEBUF);
if (!einfo->info.switch_data)
{
- return ;
+ return;
}
SDL_SetAlpha(einfo->info.switch_data, SDL_SRCALPHA, 0);
einfo->info.func.switch_buffer = _ecore_evas_sdl_switch_buffer;
if (!evas_engine_info_set(ee->evas, (Evas_Engine_Info *) einfo))
{
- return ;
+ return;
}
}
}
Evas_Event_Render_Post *ev = event_info;
Ecore_Evas *ee = data;
- if (!ev) return ;
+ if (!ev) return;
EDBG("ee=%p finished asynchronous render.", ee);
if (!ev->fd_write)
{
ERR("you should wait for emotion to be ready to take action.");
- return ;
+ return;
}
ecore_pipe_write(ev->fd_write, &cmd, sizeof(cmd));
}
if (!ev->fd_write)
{
ERR("you should wait for emotion to be ready to take action.");
- return ;
+ return;
}
ecore_pipe_write(ev->fd_write, &number, sizeof(number));
}
if (!ev->fd_write)
{
ERR("you should wait for emotion to be ready to take action.");
- return ;
+ return;
}
ecore_pipe_write(ev->fd_write, &number, sizeof(number));
}
switch (GST_MESSAGE_TYPE(message)) {
case GST_MESSAGE_EOS:
/* what to do here ? just returning at the moment */
- return ;
+ return;
default:
break;
}
Emotion_Gstreamer_Video *ev;
ev = (Emotion_Gstreamer_Video *)video;
- if (!ev->pipeline) return ;
+ if (!ev->pipeline) return;
if (ev->pipeline_parsed)
gst_element_set_state(ev->pipeline, GST_STATE_PLAYING);
ev = (Emotion_Gstreamer_Video *)video;
- if (!ev->pipeline) return ;
+ if (!ev->pipeline) return;
if (ev->pipeline_parsed)
gst_element_set_state(ev->pipeline, GST_STATE_PAUSED);
if (width) *width = vstream->width;
if (height) *height = vstream->height;
- return ;
+ return;
}
on_error:
ev = (Emotion_Gstreamer_Video *)video;
- if (!ev->pipeline) return ;
+ if (!ev->pipeline) return;
if (ev->play)
gst_element_set_state(ev->pipeline, GST_STATE_PAUSED);
*w = vstream->width;
*h = vstream->height;
- return ;
+ return;
}
on_error:
ev = (Emotion_Gstreamer_Video *)video;
- if (!ev->pipeline) return ;
+ if (!ev->pipeline) return;
ev->audio_mute = mute;
ev = (Emotion_Gstreamer_Video *)video;
- if (!ev->pipeline) return ;
+ if (!ev->pipeline) return;
if (vol < 0.0)
vol = 0.0;
Emotion_Gstreamer_Video *ev;
ev = video;
- if (priority_overide > 3) return ; /* If we failed to much to create that pipeline, let's don't wast our time anymore */
+ if (priority_overide > 3) return; /* If we failed to much to create that pipeline, let's don't wast our time anymore */
if (ev->priority != pri && ev->pipeline)
{
{
double tim;
- if (!debug_fps) return ;
+ if (!debug_fps) return;
tim = ecore_time_get();
ev->frames++;
Emotion_Gstreamer_Video *ev = data;
gboolean res;
- if (ecore_thread_check(thread) || !ev->pipeline) return ;
+ if (ecore_thread_check(thread) || !ev->pipeline) return;
gst_element_set_state(ev->pipeline, GST_STATE_PAUSED);
res = gst_element_get_state(ev->pipeline, NULL, NULL, GST_CLOCK_TIME_NONE);
Emotion_Gstreamer_Buffer *send;
EvasVideoSinkPrivate *priv = NULL;
- if (!ev->send) return ;
+ if (!ev->send) return;
send = ev->send;
priv = send->sink;
}
secsym_eglUnmapImageSEC(tex->gc->egldisp, tex->ptuv->dyn.img, EGL_MAP_GL_TEXTURE_DEVICE_CPU_SEC);
- return ;
+ return;
}
#endif
if ((w <= 0) || (h <= 0)) return;
cr = eina_mempool_malloc(_mp_command_rect, sizeof (Evas_Thread_Command_Rect));
- if (!cr) return ;
+ if (!cr) return;
cr->surface = dst;
cr->color = dc->col.col;
int x, y, w, h;
cl = eina_mempool_malloc(_mp_command_line, sizeof (Evas_Thread_Command_Line));
- if (!cl) return ;
+ if (!cl) return;
cl->surface = dst;
}
cp = eina_mempool_malloc(_mp_command_polygon, sizeof (Evas_Thread_Command_Polygon));
- if (!cp) return ;
+ if (!cp) return;
EINA_RECTANGLE_SET(&cp->ext, ext_x, ext_y, ext_w, ext_h);
cp->col = dc->col.col;
eng_image_data_preload_request(void *data EINA_UNUSED, void *image, const Eo *target)
{
RGBA_Image *im = image;
- if (!im) return ;
+ if (!im) return;
#ifdef EVAS_CSERVE2
if (evas_cserve2_use_get())
return;
#endif
- if (!im) return ;
+ if (!im) return;
evas_cache_image_preload_cancel(&im->cache_entry, target);
}
if ((cpunum > 1))
{
evas_common_pipe_map_draw(im, surface, context, m, smooth, level);
- return ;
+ return;
}
else
#endif
{
Evas_PNG_Info *epi = png_get_io_ptr(png_ptr);
- if (!epi) return ;
- if (epi->position == epi->length) return ;
+ if (!epi) return;
+ if (epi->position == epi->length) return;
if (epi->position + count > epi->length) count = epi->length - epi->position;
memcpy(out, epi->map + epi->position, count);
projects / platform / upstream / efl.git / commitdiff