2002-11-08 00:02:15 -08:00
|
|
|
#include "evas_common.h"
|
|
|
|
#include "evas_private.h"
|
|
|
|
|
2006-10-07 17:32:50 -07:00
|
|
|
/* FIXME: this broken e17's mouse cursor - need to figure out why */
|
|
|
|
|
2006-10-07 10:35:14 -07:00
|
|
|
/* uncomment the next line if smart objects should be informed
|
|
|
|
* if they are moved to the position they are already in
|
|
|
|
* (e.g. if they are in 0,0 and you call evas_object_move(o, 0, 0)
|
|
|
|
*/
|
2007-10-04 21:52:10 -07:00
|
|
|
//#define FORWARD_NOOP_MOVES_TO_SMART_OBJS
|
2006-10-07 10:35:14 -07:00
|
|
|
|
|
|
|
/* likewise, for resizes
|
|
|
|
*/
|
2007-10-04 21:52:10 -07:00
|
|
|
//#define FORWARD_NOOP_RESIZES_TO_SMART_OBJS
|
2006-10-07 10:35:14 -07:00
|
|
|
|
Do not inform callbacks that did not changed the state of object.
For some unknown reason evas was informing EVAS_CALLBACK_* even if the
original call did not changed the internal object state, that is, new
value is already equal to current value.
This is specially costly since Edje, Box, Table and possible other
layout engines will call evas_object_resize(), move(), show(), hide()
even if the state has not changed, assuming evas will ignore the call
(as it does). The real overhead might come if there are listeners
attached to these events, that in turn might do lots of other stuff,
leading to a torrent of useless calls.
I marked it for removal, please test it and uncomment '#define
CALLBACK_NOOPS' to get the old behavior back. It does seems to work
with e17 and edje_editor. If problems appear, let's try to fix the
real problem instead of getting this code back, it's a performance
penalty.
SVN revision: 38955
2009-02-05 06:37:58 -08:00
|
|
|
/* Similar to FORWARD_NOOP_*, this will allow no-operations (those calls that
|
|
|
|
* have values exactly like current state) to call EVAS_CALLBACK_*.
|
|
|
|
*
|
|
|
|
* For some unknown reason this was the default behavior so it is left as
|
|
|
|
* a compile-time option, but will be deprecated and removed soon as it can
|
|
|
|
* potentially lead to execution of unnecessary code.
|
|
|
|
* by Gustavo, February 5th, 2009.
|
|
|
|
* XXX: remove-me before e17 release!
|
|
|
|
*/
|
|
|
|
//#define CALLBACK_NOOP
|
|
|
|
|
|
|
|
|
2008-10-17 04:23:18 -07:00
|
|
|
static Eina_Inlist *
|
2007-02-12 09:02:15 -08:00
|
|
|
get_layer_objects_last(Evas_Layer *l)
|
2006-01-22 22:54:04 -08:00
|
|
|
{
|
2007-02-12 09:02:15 -08:00
|
|
|
if( !l || !l->objects ) return NULL;
|
2006-01-22 22:54:04 -08:00
|
|
|
|
2008-10-17 04:23:18 -07:00
|
|
|
return (EINA_INLIST_GET(l->objects))->last;
|
2006-01-22 22:54:04 -08:00
|
|
|
}
|
|
|
|
|
2002-11-08 00:02:15 -08:00
|
|
|
/* evas internal stuff */
|
|
|
|
Evas_Object *
|
|
|
|
evas_object_new(void)
|
|
|
|
{
|
|
|
|
Evas_Object *obj;
|
|
|
|
|
|
|
|
obj = calloc(1, sizeof(Evas_Object));
|
|
|
|
if (!obj) return NULL;
|
2005-05-21 19:49:50 -07:00
|
|
|
|
2002-11-08 00:02:15 -08:00
|
|
|
obj->magic = MAGIC_OBJ;
|
2008-09-09 07:14:26 -07:00
|
|
|
obj->cur.scale = 1.0;
|
|
|
|
obj->prev.scale = 1.0;
|
2005-05-21 19:49:50 -07:00
|
|
|
|
2002-11-08 00:02:15 -08:00
|
|
|
return obj;
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
evas_object_free(Evas_Object *obj, int clean_layer)
|
|
|
|
{
|
2005-10-26 19:44:36 -07:00
|
|
|
int was_smart_child = 0;
|
2006-07-30 07:30:24 -07:00
|
|
|
|
2003-01-05 04:55:37 -08:00
|
|
|
evas_object_grabs_cleanup(obj);
|
2002-12-14 16:33:57 -08:00
|
|
|
evas_object_intercept_cleanup(obj);
|
2005-10-26 19:44:36 -07:00
|
|
|
if (obj->smart.parent) was_smart_child = 1;
|
2002-11-08 00:02:15 -08:00
|
|
|
evas_object_smart_cleanup(obj);
|
|
|
|
obj->func->free(obj);
|
2005-10-26 19:44:36 -07:00
|
|
|
if (!was_smart_child) evas_object_release(obj, clean_layer);
|
2002-11-08 00:02:15 -08:00
|
|
|
if (obj->clip.clipees)
|
2008-10-21 09:31:05 -07:00
|
|
|
eina_list_free(obj->clip.clipees);
|
2009-04-14 20:14:41 -07:00
|
|
|
evas_object_clip_changes_clean(obj);
|
2007-02-21 13:43:45 -08:00
|
|
|
evas_object_event_callback_all_del(obj);
|
2002-12-14 16:33:57 -08:00
|
|
|
evas_object_event_callback_cleanup(obj);
|
2002-11-08 00:02:15 -08:00
|
|
|
while (obj->data.elements)
|
|
|
|
{
|
|
|
|
Evas_Data_Node *node;
|
2005-05-21 19:49:50 -07:00
|
|
|
|
2002-11-08 00:02:15 -08:00
|
|
|
node = obj->data.elements->data;
|
2008-10-21 09:31:05 -07:00
|
|
|
obj->data.elements = eina_list_remove(obj->data.elements, node);
|
2002-11-08 00:02:15 -08:00
|
|
|
free(node);
|
|
|
|
}
|
|
|
|
obj->magic = 0;
|
2008-04-30 15:51:08 -07:00
|
|
|
if (obj->size_hints) free(obj->size_hints);
|
2002-11-08 00:02:15 -08:00
|
|
|
free(obj);
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
evas_object_change(Evas_Object *obj)
|
|
|
|
{
|
2008-10-21 09:31:05 -07:00
|
|
|
Eina_List *l;
|
2009-11-06 21:01:43 -08:00
|
|
|
Evas_Object *obj2;
|
2005-05-21 19:49:50 -07:00
|
|
|
|
2005-10-26 19:44:36 -07:00
|
|
|
obj->layer->evas->changed = 1;
|
2002-11-08 00:02:15 -08:00
|
|
|
if (obj->changed) return;
|
2009-11-06 21:01:43 -08:00
|
|
|
// obj->changed = 1;
|
2008-05-26 06:24:24 -07:00
|
|
|
evas_render_object_recalc(obj);
|
2002-11-08 00:02:15 -08:00
|
|
|
/* set changed flag on all objects this one clips too */
|
2009-11-06 21:01:43 -08:00
|
|
|
EINA_LIST_FOREACH(obj->clip.clipees, l, obj2) evas_object_change(obj2);
|
2005-10-26 19:44:36 -07:00
|
|
|
if (obj->smart.parent) evas_object_change(obj->smart.parent);
|
2002-11-08 00:02:15 -08:00
|
|
|
}
|
|
|
|
|
2008-07-07 14:29:29 -07:00
|
|
|
void
|
2009-04-15 06:40:37 -07:00
|
|
|
evas_object_render_pre_visible_change(Eina_Array *rects, Evas_Object *obj, int is_v, int was_v)
|
2002-11-08 00:02:15 -08:00
|
|
|
{
|
2008-07-07 14:29:29 -07:00
|
|
|
if (obj->smart.smart) return ;
|
|
|
|
if (is_v == was_v) return ;
|
2002-11-08 00:02:15 -08:00
|
|
|
if (is_v)
|
|
|
|
{
|
2008-07-07 14:29:29 -07:00
|
|
|
evas_add_rect(rects,
|
|
|
|
obj->cur.cache.clip.x,
|
|
|
|
obj->cur.cache.clip.y,
|
|
|
|
obj->cur.cache.clip.w,
|
|
|
|
obj->cur.cache.clip.h);
|
2002-11-08 00:02:15 -08:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2008-07-07 14:29:29 -07:00
|
|
|
evas_add_rect(rects,
|
|
|
|
obj->prev.cache.clip.x,
|
|
|
|
obj->prev.cache.clip.y,
|
|
|
|
obj->prev.cache.clip.w,
|
|
|
|
obj->prev.cache.clip.h);
|
2002-11-08 00:02:15 -08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-07-07 14:29:29 -07:00
|
|
|
void
|
2009-04-15 06:40:37 -07:00
|
|
|
evas_object_render_pre_clipper_change(Eina_Array *rects, Evas_Object *obj)
|
2002-11-08 00:02:15 -08:00
|
|
|
{
|
2008-07-07 14:29:29 -07:00
|
|
|
if (obj->smart.smart) return ;
|
|
|
|
if (obj->cur.clipper == obj->prev.clipper) return ;
|
2002-11-08 00:02:15 -08:00
|
|
|
if ((obj->cur.clipper) && (obj->prev.clipper))
|
|
|
|
{
|
|
|
|
/* get difference rects between clippers */
|
2008-07-07 14:29:29 -07:00
|
|
|
evas_rects_return_difference_rects(rects,
|
|
|
|
obj->cur.clipper->cur.cache.clip.x,
|
|
|
|
obj->cur.clipper->cur.cache.clip.y,
|
|
|
|
obj->cur.clipper->cur.cache.clip.w,
|
|
|
|
obj->cur.clipper->cur.cache.clip.h,
|
|
|
|
obj->prev.clipper->prev.cache.clip.x,
|
|
|
|
obj->prev.clipper->prev.cache.clip.y,
|
|
|
|
obj->prev.clipper->prev.cache.clip.w,
|
|
|
|
obj->prev.clipper->prev.cache.clip.h);
|
2002-11-08 00:02:15 -08:00
|
|
|
}
|
|
|
|
else if (obj->cur.clipper)
|
|
|
|
{
|
2008-07-07 14:29:29 -07:00
|
|
|
evas_rects_return_difference_rects(rects,
|
|
|
|
obj->cur.geometry.x,
|
|
|
|
obj->cur.geometry.y,
|
|
|
|
obj->cur.geometry.w,
|
|
|
|
obj->cur.geometry.h,
|
2006-11-15 19:20:24 -08:00
|
|
|
//// rl = evas_rects_return_difference_rects(obj->cur.cache.geometry.x,
|
|
|
|
//// obj->cur.cache.geometry.y,
|
|
|
|
//// obj->cur.cache.geometry.w,
|
|
|
|
//// obj->cur.cache.geometry.h,
|
2008-07-07 14:29:29 -07:00
|
|
|
obj->cur.clipper->cur.cache.clip.x,
|
|
|
|
obj->cur.clipper->cur.cache.clip.y,
|
|
|
|
obj->cur.clipper->cur.cache.clip.w,
|
|
|
|
obj->cur.clipper->cur.cache.clip.h);
|
2002-11-08 00:02:15 -08:00
|
|
|
}
|
|
|
|
else if (obj->prev.clipper)
|
|
|
|
{
|
2008-07-07 14:29:29 -07:00
|
|
|
evas_rects_return_difference_rects(rects,
|
|
|
|
obj->prev.geometry.x,
|
|
|
|
obj->prev.geometry.y,
|
|
|
|
obj->prev.geometry.w,
|
|
|
|
obj->prev.geometry.h,
|
2006-11-15 19:20:24 -08:00
|
|
|
//// rl = evas_rects_return_difference_rects(obj->prev.cache.geometry.x,
|
|
|
|
//// obj->prev.cache.geometry.y,
|
|
|
|
//// obj->prev.cache.geometry.w,
|
|
|
|
//// obj->prev.cache.geometry.h,
|
2008-07-07 14:29:29 -07:00
|
|
|
obj->prev.clipper->prev.cache.clip.x,
|
|
|
|
obj->prev.clipper->prev.cache.clip.y,
|
|
|
|
obj->prev.clipper->prev.cache.clip.w,
|
|
|
|
obj->prev.clipper->prev.cache.clip.h);
|
2002-11-08 00:02:15 -08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-07-07 14:29:29 -07:00
|
|
|
void
|
2009-04-15 06:40:37 -07:00
|
|
|
evas_object_render_pre_prev_cur_add(Eina_Array *rects, Evas_Object *obj)
|
2002-11-08 00:02:15 -08:00
|
|
|
{
|
2008-07-07 14:29:29 -07:00
|
|
|
evas_add_rect(rects,
|
2009-11-03 07:41:36 -08:00
|
|
|
obj->cur.cache.clip.x,
|
|
|
|
obj->cur.cache.clip.y,
|
|
|
|
obj->cur.cache.clip.w,
|
|
|
|
obj->cur.cache.clip.h);
|
|
|
|
evas_add_rect(rects,
|
|
|
|
obj->prev.cache.clip.x,
|
|
|
|
obj->prev.cache.clip.y,
|
|
|
|
obj->prev.cache.clip.w,
|
|
|
|
obj->prev.cache.clip.h);
|
|
|
|
/*
|
|
|
|
evas_add_rect(rects,
|
|
|
|
obj->cur.geometry.x,
|
|
|
|
obj->cur.geometry.y,
|
|
|
|
obj->cur.geometry.w,
|
|
|
|
obj->cur.geometry.h);
|
2006-11-15 19:20:24 -08:00
|
|
|
//// obj->cur.cache.geometry.x,
|
|
|
|
//// obj->cur.cache.geometry.y,
|
|
|
|
//// obj->cur.cache.geometry.w,
|
|
|
|
//// obj->cur.cache.geometry.h);
|
2009-11-03 07:41:36 -08:00
|
|
|
evas_add_rect(rects,
|
|
|
|
obj->prev.geometry.x,
|
|
|
|
obj->prev.geometry.y,
|
|
|
|
obj->prev.geometry.w,
|
|
|
|
obj->prev.geometry.h);
|
2006-11-15 19:20:24 -08:00
|
|
|
//// obj->prev.cache.geometry.x,
|
|
|
|
//// obj->prev.cache.geometry.y,
|
|
|
|
//// obj->prev.cache.geometry.w,
|
|
|
|
//// obj->prev.cache.geometry.h);
|
2009-11-03 07:41:36 -08:00
|
|
|
*/
|
2005-05-21 19:49:50 -07:00
|
|
|
}
|
2002-11-08 00:02:15 -08:00
|
|
|
|
2009-04-14 05:15:07 -07:00
|
|
|
void
|
|
|
|
evas_object_clip_changes_clean(Evas_Object *obj)
|
|
|
|
{
|
2009-06-23 06:57:27 -07:00
|
|
|
Eina_Rectangle *r;
|
2009-04-14 05:15:07 -07:00
|
|
|
|
2009-11-06 21:01:43 -08:00
|
|
|
EINA_LIST_FREE(obj->clip.changes, r) eina_rectangle_free(r);
|
2009-04-14 05:15:07 -07:00
|
|
|
}
|
|
|
|
|
2002-11-08 00:02:15 -08:00
|
|
|
void
|
2009-04-15 06:40:37 -07:00
|
|
|
evas_object_render_pre_effect_updates(Eina_Array *rects, Evas_Object *obj, int is_v, int was_v)
|
2002-11-08 00:02:15 -08:00
|
|
|
{
|
2009-06-23 06:57:27 -07:00
|
|
|
Eina_Rectangle *r;
|
2002-11-08 00:02:15 -08:00
|
|
|
Evas_Object *clipper;
|
2008-10-21 09:31:05 -07:00
|
|
|
Eina_List *l;
|
2008-07-07 14:29:29 -07:00
|
|
|
unsigned int i;
|
2009-04-15 06:40:37 -07:00
|
|
|
Eina_Array_Iterator it;
|
2008-07-07 14:29:29 -07:00
|
|
|
int x, y, w, h;
|
2002-11-08 00:02:15 -08:00
|
|
|
|
2008-07-07 14:29:29 -07:00
|
|
|
if (obj->smart.smart) goto end;
|
2002-11-08 00:02:15 -08:00
|
|
|
/* FIXME: was_v isn't used... why? */
|
|
|
|
was_v = 0;
|
|
|
|
if (!obj->clip.clipees)
|
|
|
|
{
|
2009-04-15 06:40:37 -07:00
|
|
|
EINA_ARRAY_ITER_NEXT(rects, i, r, it)
|
2002-11-08 00:02:15 -08:00
|
|
|
{
|
|
|
|
/* get updates and clip to current clip */
|
2009-04-15 06:40:37 -07:00
|
|
|
x = r->x;
|
|
|
|
y = r->y;
|
|
|
|
w = r->w;
|
|
|
|
h = r->h;
|
2002-11-08 00:02:15 -08:00
|
|
|
RECTS_CLIP_TO_RECT(x, y, w, h,
|
2005-05-21 19:49:50 -07:00
|
|
|
obj->cur.cache.clip.x,
|
2002-11-08 00:02:15 -08:00
|
|
|
obj->cur.cache.clip.y,
|
2005-05-21 19:49:50 -07:00
|
|
|
obj->cur.cache.clip.w,
|
2002-11-08 00:02:15 -08:00
|
|
|
obj->cur.cache.clip.h);
|
|
|
|
if ((w > 0) && (h > 0))
|
|
|
|
obj->layer->evas->engine.func->output_redraws_rect_add(obj->layer->evas->engine.data.output,
|
|
|
|
x, y, w, h);
|
|
|
|
/* get updates and clip to previous clip */
|
2009-04-15 06:40:37 -07:00
|
|
|
x = r->x;
|
|
|
|
y = r->y;
|
|
|
|
w = r->w;
|
|
|
|
h = r->h;
|
2002-11-08 00:02:15 -08:00
|
|
|
RECTS_CLIP_TO_RECT(x, y, w, h,
|
2005-05-21 19:49:50 -07:00
|
|
|
obj->prev.cache.clip.x,
|
2002-11-08 00:02:15 -08:00
|
|
|
obj->prev.cache.clip.y,
|
2005-05-21 19:49:50 -07:00
|
|
|
obj->prev.cache.clip.w,
|
2002-11-08 00:02:15 -08:00
|
|
|
obj->prev.cache.clip.h);
|
|
|
|
if ((w > 0) && (h > 0))
|
|
|
|
obj->layer->evas->engine.func->output_redraws_rect_add(obj->layer->evas->engine.data.output,
|
|
|
|
x, y, w, h);
|
|
|
|
}
|
|
|
|
/* if the object is actually visible, take any parent clip changes */
|
|
|
|
if (is_v)
|
|
|
|
{
|
|
|
|
clipper = obj->cur.clipper;
|
|
|
|
while (clipper)
|
|
|
|
{
|
2008-10-21 09:31:05 -07:00
|
|
|
EINA_LIST_FOREACH(clipper->clip.changes, l, r)
|
2002-11-08 00:02:15 -08:00
|
|
|
{
|
|
|
|
/* get updates and clip to current clip */
|
|
|
|
x = r->x; y = r->y; w = r->w; h = r->h;
|
|
|
|
RECTS_CLIP_TO_RECT(x, y, w, h,
|
2005-05-21 19:49:50 -07:00
|
|
|
obj->cur.cache.clip.x,
|
2002-11-08 00:02:15 -08:00
|
|
|
obj->cur.cache.clip.y,
|
2005-05-21 19:49:50 -07:00
|
|
|
obj->cur.cache.clip.w,
|
2002-11-08 00:02:15 -08:00
|
|
|
obj->cur.cache.clip.h);
|
|
|
|
if ((w > 0) && (h > 0))
|
|
|
|
obj->layer->evas->engine.func->output_redraws_rect_add(obj->layer->evas->engine.data.output,
|
|
|
|
x, y, w, h);
|
|
|
|
/* get updates and clip to previous clip */
|
|
|
|
x = r->x; y = r->y; w = r->w; h = r->h;
|
|
|
|
RECTS_CLIP_TO_RECT(x, y, w, h,
|
2005-05-21 19:49:50 -07:00
|
|
|
obj->prev.cache.clip.x,
|
2002-11-08 00:02:15 -08:00
|
|
|
obj->prev.cache.clip.y,
|
2005-05-21 19:49:50 -07:00
|
|
|
obj->prev.cache.clip.w,
|
2002-11-08 00:02:15 -08:00
|
|
|
obj->prev.cache.clip.h);
|
|
|
|
if ((w > 0) && (h > 0))
|
|
|
|
obj->layer->evas->engine.func->output_redraws_rect_add(obj->layer->evas->engine.data.output,
|
|
|
|
x, y, w, h);
|
|
|
|
}
|
|
|
|
clipper = clipper->cur.clipper;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2009-04-14 05:15:07 -07:00
|
|
|
evas_object_clip_changes_clean(obj);
|
2009-04-15 06:40:37 -07:00
|
|
|
EINA_ARRAY_ITER_NEXT(rects, i, r, it)
|
|
|
|
obj->clip.changes = eina_list_append(obj->clip.changes, r);
|
|
|
|
eina_array_clean(rects);
|
2002-11-08 00:02:15 -08:00
|
|
|
}
|
2008-07-07 14:29:29 -07:00
|
|
|
|
|
|
|
end:
|
2009-04-15 06:40:37 -07:00
|
|
|
EINA_ARRAY_ITER_NEXT(rects, i, r, it)
|
2009-06-23 06:57:27 -07:00
|
|
|
eina_rectangle_free(r);
|
2009-04-15 06:40:37 -07:00
|
|
|
eina_array_clean(rects);
|
2002-11-08 00:02:15 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
evas_object_was_in_output_rect(Evas_Object *obj, int x, int y, int w, int h)
|
|
|
|
{
|
|
|
|
if (obj->smart.smart) return 0;
|
|
|
|
/* assumes coords have been recalced */
|
|
|
|
if ((RECTS_INTERSECT(x, y, w, h,
|
|
|
|
obj->prev.cache.clip.x,
|
|
|
|
obj->prev.cache.clip.y,
|
|
|
|
obj->prev.cache.clip.w,
|
|
|
|
obj->prev.cache.clip.h)))
|
|
|
|
return 1;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
evas_object_was_opaque(Evas_Object *obj)
|
|
|
|
{
|
|
|
|
if (obj->smart.smart) return 0;
|
2005-05-21 19:49:50 -07:00
|
|
|
if (obj->prev.cache.clip.a == 255)
|
2002-11-08 00:02:15 -08:00
|
|
|
{
|
|
|
|
if (obj->func->was_opaque)
|
|
|
|
return obj->func->was_opaque(obj);
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2007-07-23 07:22:57 -07:00
|
|
|
int
|
|
|
|
evas_object_is_inside(Evas_Object *obj, Evas_Coord x, Evas_Coord y)
|
|
|
|
{
|
|
|
|
if (obj->smart.smart) return 0;
|
|
|
|
if (obj->func->is_inside)
|
|
|
|
return obj->func->is_inside(obj, x, y);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
evas_object_was_inside(Evas_Object *obj, Evas_Coord x, Evas_Coord y)
|
|
|
|
{
|
|
|
|
if (obj->smart.smart) return 0;
|
|
|
|
if (obj->func->was_inside)
|
|
|
|
return obj->func->was_inside(obj, x, y);
|
|
|
|
return 0;
|
|
|
|
}
|
2002-11-08 00:02:15 -08:00
|
|
|
/* routines apps will call */
|
|
|
|
|
2003-03-04 18:30:20 -08:00
|
|
|
/**
|
2004-08-15 22:13:25 -07:00
|
|
|
* @defgroup Evas_Object_Group Generic Object Functions
|
2003-03-04 18:30:20 -08:00
|
|
|
*
|
2004-08-01 05:34:19 -07:00
|
|
|
* Functions that manipulate generic evas objects.
|
|
|
|
*/
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Deletes the given evas object and frees its memory.
|
|
|
|
*
|
|
|
|
* The object's 'free' callback is called when this function is called.
|
|
|
|
* If the object currently has the focus, its 'focus out' callback is
|
|
|
|
* also called.
|
|
|
|
*
|
2004-08-15 22:13:25 -07:00
|
|
|
* @param obj The given evas object.
|
|
|
|
* @ingroup Evas_Object_Group
|
2003-03-04 18:30:20 -08:00
|
|
|
*/
|
2006-01-06 15:05:17 -08:00
|
|
|
EAPI void
|
2002-11-08 00:02:15 -08:00
|
|
|
evas_object_del(Evas_Object *obj)
|
|
|
|
{
|
|
|
|
MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ);
|
|
|
|
return;
|
|
|
|
MAGIC_CHECK_END();
|
2006-10-15 07:39:16 -07:00
|
|
|
|
2004-03-07 18:42:08 -08:00
|
|
|
if (obj->delete_me) return;
|
2006-07-12 17:26:25 -07:00
|
|
|
|
2007-10-02 21:09:36 -07:00
|
|
|
evas_object_event_callback_call(obj, EVAS_CALLBACK_DEL, NULL);
|
2006-07-12 17:26:25 -07:00
|
|
|
if (obj->name) evas_object_name_set(obj, NULL);
|
2002-11-08 00:02:15 -08:00
|
|
|
if (!obj->layer)
|
|
|
|
{
|
|
|
|
evas_object_free(obj, 1);
|
|
|
|
return;
|
|
|
|
}
|
2002-12-16 16:00:38 -08:00
|
|
|
if (obj->focused)
|
|
|
|
{
|
|
|
|
obj->focused = 0;
|
|
|
|
obj->layer->evas->focused = NULL;
|
|
|
|
evas_object_event_callback_call(obj, EVAS_CALLBACK_FOCUS_OUT, NULL);
|
|
|
|
}
|
2006-05-19 00:56:53 -07:00
|
|
|
obj->layer->evas->pointer.mouse_grabbed -= obj->mouse_grabbed;
|
|
|
|
obj->mouse_grabbed = 0;
|
2005-05-21 19:49:50 -07:00
|
|
|
evas_object_hide(obj);
|
2003-01-05 04:55:37 -08:00
|
|
|
evas_object_grabs_cleanup(obj);
|
2002-11-08 00:02:15 -08:00
|
|
|
while (obj->clip.clipees) evas_object_clip_unset(obj->clip.clipees->data);
|
|
|
|
if (obj->cur.clipper) evas_object_clip_unset(obj);
|
|
|
|
if (obj->smart.smart) evas_object_smart_del(obj);
|
2009-10-28 01:59:01 -07:00
|
|
|
evas_object_map_set(obj, NULL);
|
2007-09-25 06:33:12 -07:00
|
|
|
evas_object_event_callback_call(obj, EVAS_CALLBACK_FREE, NULL);
|
2003-01-09 21:38:47 -08:00
|
|
|
evas_object_smart_cleanup(obj);
|
2004-03-07 18:42:08 -08:00
|
|
|
obj->delete_me = 1;
|
|
|
|
evas_object_change(obj);
|
2002-11-08 00:02:15 -08:00
|
|
|
}
|
|
|
|
|
2003-03-04 18:30:20 -08:00
|
|
|
/**
|
2004-08-01 05:34:19 -07:00
|
|
|
* Moves the given evas object to the given location.
|
|
|
|
* @param obj The given evas object.
|
|
|
|
* @param x X position to move the object to, in canvas units.
|
|
|
|
* @param y Y position to move the object to, in canvas units.
|
2004-08-15 22:13:25 -07:00
|
|
|
* @ingroup Evas_Object_Group
|
2003-03-04 18:30:20 -08:00
|
|
|
*/
|
2006-01-06 15:05:17 -08:00
|
|
|
EAPI void
|
2003-10-17 20:34:00 -07:00
|
|
|
evas_object_move(Evas_Object *obj, Evas_Coord x, Evas_Coord y)
|
2002-11-08 00:02:15 -08:00
|
|
|
{
|
2005-07-22 03:28:11 -07:00
|
|
|
int is, was = 0, pass = 0;
|
2005-05-21 19:49:50 -07:00
|
|
|
|
2002-11-08 00:02:15 -08:00
|
|
|
MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ);
|
|
|
|
return;
|
|
|
|
MAGIC_CHECK_END();
|
2004-03-07 18:42:08 -08:00
|
|
|
if (obj->delete_me) return;
|
2002-12-14 16:33:57 -08:00
|
|
|
if (evas_object_intercept_call_move(obj, x, y)) return;
|
2006-10-07 10:35:14 -07:00
|
|
|
#ifdef FORWARD_NOOP_MOVES_TO_SMART_OBJS
|
2002-11-08 00:02:15 -08:00
|
|
|
if (obj->smart.smart)
|
|
|
|
{
|
2003-10-08 20:05:17 -07:00
|
|
|
if (obj->smart.smart->smart_class->move)
|
|
|
|
obj->smart.smart->smart_class->move(obj, x, y);
|
2002-11-08 00:02:15 -08:00
|
|
|
}
|
2006-10-07 10:35:14 -07:00
|
|
|
#endif
|
2002-11-08 00:02:15 -08:00
|
|
|
if ((obj->cur.geometry.x == x) &&
|
2005-05-21 19:49:50 -07:00
|
|
|
(obj->cur.geometry.y == y))
|
2002-12-09 22:45:18 -08:00
|
|
|
{
|
Do not inform callbacks that did not changed the state of object.
For some unknown reason evas was informing EVAS_CALLBACK_* even if the
original call did not changed the internal object state, that is, new
value is already equal to current value.
This is specially costly since Edje, Box, Table and possible other
layout engines will call evas_object_resize(), move(), show(), hide()
even if the state has not changed, assuming evas will ignore the call
(as it does). The real overhead might come if there are listeners
attached to these events, that in turn might do lots of other stuff,
leading to a torrent of useless calls.
I marked it for removal, please test it and uncomment '#define
CALLBACK_NOOPS' to get the old behavior back. It does seems to work
with e17 and edje_editor. If problems appear, let's try to fix the
real problem instead of getting this code back, it's a performance
penalty.
SVN revision: 38955
2009-02-05 06:37:58 -08:00
|
|
|
#ifdef CALLBACK_NOOP
|
2002-12-09 22:45:18 -08:00
|
|
|
evas_object_inform_call_move(obj);
|
Do not inform callbacks that did not changed the state of object.
For some unknown reason evas was informing EVAS_CALLBACK_* even if the
original call did not changed the internal object state, that is, new
value is already equal to current value.
This is specially costly since Edje, Box, Table and possible other
layout engines will call evas_object_resize(), move(), show(), hide()
even if the state has not changed, assuming evas will ignore the call
(as it does). The real overhead might come if there are listeners
attached to these events, that in turn might do lots of other stuff,
leading to a torrent of useless calls.
I marked it for removal, please test it and uncomment '#define
CALLBACK_NOOPS' to get the old behavior back. It does seems to work
with e17 and edje_editor. If problems appear, let's try to fix the
real problem instead of getting this code back, it's a performance
penalty.
SVN revision: 38955
2009-02-05 06:37:58 -08:00
|
|
|
#endif
|
2002-12-09 22:45:18 -08:00
|
|
|
return;
|
|
|
|
}
|
2006-10-07 10:35:14 -07:00
|
|
|
#ifndef FORWARD_NOOP_MOVES_TO_SMART_OBJS
|
|
|
|
if (obj->smart.smart)
|
|
|
|
{
|
|
|
|
if (obj->smart.smart->smart_class->move)
|
|
|
|
obj->smart.smart->smart_class->move(obj, x, y);
|
|
|
|
}
|
|
|
|
#endif
|
2005-09-21 19:52:53 -07:00
|
|
|
if (obj->layer->evas->events_frozen <= 0)
|
2005-07-22 03:28:11 -07:00
|
|
|
{
|
|
|
|
pass = evas_event_passes_through(obj);
|
2005-09-23 07:41:10 -07:00
|
|
|
if (!pass)
|
2005-07-22 03:28:11 -07:00
|
|
|
was = evas_object_is_in_output_rect(obj,
|
|
|
|
obj->layer->evas->pointer.x,
|
|
|
|
obj->layer->evas->pointer.y, 1, 1);
|
|
|
|
}
|
2002-11-08 00:02:15 -08:00
|
|
|
obj->cur.geometry.x = x;
|
|
|
|
obj->cur.geometry.y = y;
|
2006-11-15 19:20:24 -08:00
|
|
|
//// obj->cur.cache.geometry.validity = 0;
|
2002-11-08 00:02:15 -08:00
|
|
|
evas_object_change(obj);
|
2005-04-03 07:22:17 -07:00
|
|
|
evas_object_clip_dirty(obj);
|
2005-09-21 19:52:53 -07:00
|
|
|
if (obj->layer->evas->events_frozen <= 0)
|
2002-11-08 00:02:15 -08:00
|
|
|
{
|
2005-07-30 02:52:53 -07:00
|
|
|
evas_object_recalc_clippees(obj);
|
2005-07-22 03:28:11 -07:00
|
|
|
if (!pass)
|
2003-07-21 22:16:47 -07:00
|
|
|
{
|
2005-07-22 03:28:11 -07:00
|
|
|
if (!obj->smart.smart)
|
|
|
|
{
|
|
|
|
is = evas_object_is_in_output_rect(obj,
|
|
|
|
obj->layer->evas->pointer.x,
|
|
|
|
obj->layer->evas->pointer.y, 1, 1);
|
|
|
|
if ((is ^ was) && obj->cur.visible)
|
|
|
|
evas_event_feed_mouse_move(obj->layer->evas,
|
|
|
|
obj->layer->evas->pointer.x,
|
|
|
|
obj->layer->evas->pointer.y,
|
2005-07-25 02:55:47 -07:00
|
|
|
obj->layer->evas->last_timestamp,
|
2005-07-22 03:28:11 -07:00
|
|
|
NULL);
|
|
|
|
}
|
2003-07-21 22:16:47 -07:00
|
|
|
}
|
2002-11-08 00:02:15 -08:00
|
|
|
}
|
2002-12-09 22:45:18 -08:00
|
|
|
evas_object_inform_call_move(obj);
|
2002-11-08 00:02:15 -08:00
|
|
|
}
|
|
|
|
|
2003-03-04 18:30:20 -08:00
|
|
|
/**
|
2004-08-01 05:34:19 -07:00
|
|
|
* Changes the size of the given evas object.
|
|
|
|
* @param obj The given evas object.
|
|
|
|
* @param w The new width of the evas object.
|
|
|
|
* @param h The new height of the evas object.
|
2004-08-15 22:13:25 -07:00
|
|
|
* @ingroup Evas_Object_Group
|
2003-03-04 18:30:20 -08:00
|
|
|
*/
|
2006-01-06 15:05:17 -08:00
|
|
|
EAPI void
|
2003-10-17 20:34:00 -07:00
|
|
|
evas_object_resize(Evas_Object *obj, Evas_Coord w, Evas_Coord h)
|
2002-11-08 00:02:15 -08:00
|
|
|
{
|
2005-07-22 03:28:11 -07:00
|
|
|
int is, was = 0, pass = 0;
|
2005-05-21 19:49:50 -07:00
|
|
|
|
2002-11-08 00:02:15 -08:00
|
|
|
MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ);
|
|
|
|
return;
|
|
|
|
MAGIC_CHECK_END();
|
2004-03-07 18:42:08 -08:00
|
|
|
if (obj->delete_me) return;
|
2009-09-23 21:55:01 -07:00
|
|
|
if (w < 0) w = 0; if (h < 0) h = 0;
|
2002-12-14 16:33:57 -08:00
|
|
|
if (evas_object_intercept_call_resize(obj, w, h)) return;
|
2006-10-07 10:35:14 -07:00
|
|
|
#ifdef FORWARD_NOOP_RESIZES_TO_SMART_OBJS
|
2002-11-08 00:02:15 -08:00
|
|
|
if (obj->smart.smart)
|
|
|
|
{
|
2003-10-08 20:05:17 -07:00
|
|
|
if (obj->smart.smart->smart_class->resize)
|
|
|
|
obj->smart.smart->smart_class->resize(obj, w, h);
|
2002-11-08 00:02:15 -08:00
|
|
|
}
|
2006-10-07 10:35:14 -07:00
|
|
|
#endif
|
2002-11-08 00:02:15 -08:00
|
|
|
if ((obj->cur.geometry.w == w) &&
|
2002-12-09 22:45:18 -08:00
|
|
|
(obj->cur.geometry.h == h))
|
|
|
|
{
|
Do not inform callbacks that did not changed the state of object.
For some unknown reason evas was informing EVAS_CALLBACK_* even if the
original call did not changed the internal object state, that is, new
value is already equal to current value.
This is specially costly since Edje, Box, Table and possible other
layout engines will call evas_object_resize(), move(), show(), hide()
even if the state has not changed, assuming evas will ignore the call
(as it does). The real overhead might come if there are listeners
attached to these events, that in turn might do lots of other stuff,
leading to a torrent of useless calls.
I marked it for removal, please test it and uncomment '#define
CALLBACK_NOOPS' to get the old behavior back. It does seems to work
with e17 and edje_editor. If problems appear, let's try to fix the
real problem instead of getting this code back, it's a performance
penalty.
SVN revision: 38955
2009-02-05 06:37:58 -08:00
|
|
|
#ifdef CALLBACK_NOOP
|
2002-12-09 22:45:18 -08:00
|
|
|
evas_object_inform_call_resize(obj);
|
Do not inform callbacks that did not changed the state of object.
For some unknown reason evas was informing EVAS_CALLBACK_* even if the
original call did not changed the internal object state, that is, new
value is already equal to current value.
This is specially costly since Edje, Box, Table and possible other
layout engines will call evas_object_resize(), move(), show(), hide()
even if the state has not changed, assuming evas will ignore the call
(as it does). The real overhead might come if there are listeners
attached to these events, that in turn might do lots of other stuff,
leading to a torrent of useless calls.
I marked it for removal, please test it and uncomment '#define
CALLBACK_NOOPS' to get the old behavior back. It does seems to work
with e17 and edje_editor. If problems appear, let's try to fix the
real problem instead of getting this code back, it's a performance
penalty.
SVN revision: 38955
2009-02-05 06:37:58 -08:00
|
|
|
#endif
|
2002-12-09 22:45:18 -08:00
|
|
|
return;
|
|
|
|
}
|
2006-10-07 10:35:14 -07:00
|
|
|
#ifndef FORWARD_NOOP_RESIZES_TO_SMART_OBJS
|
|
|
|
if (obj->smart.smart)
|
|
|
|
{
|
|
|
|
if (obj->smart.smart->smart_class->resize)
|
|
|
|
obj->smart.smart->smart_class->resize(obj, w, h);
|
|
|
|
}
|
|
|
|
#endif
|
2005-09-21 19:52:53 -07:00
|
|
|
if (obj->layer->evas->events_frozen <= 0)
|
2005-07-22 03:28:11 -07:00
|
|
|
{
|
|
|
|
pass = evas_event_passes_through(obj);
|
|
|
|
if (!pass)
|
|
|
|
was = evas_object_is_in_output_rect(obj,
|
|
|
|
obj->layer->evas->pointer.x,
|
|
|
|
obj->layer->evas->pointer.y, 1, 1);
|
|
|
|
}
|
2009-08-07 13:35:30 -07:00
|
|
|
|
2002-11-08 00:02:15 -08:00
|
|
|
obj->cur.geometry.w = w;
|
|
|
|
obj->cur.geometry.h = h;
|
2006-11-15 19:20:24 -08:00
|
|
|
//// obj->cur.cache.geometry.validity = 0;
|
2002-11-08 00:02:15 -08:00
|
|
|
evas_object_change(obj);
|
2005-04-03 07:22:17 -07:00
|
|
|
evas_object_clip_dirty(obj);
|
2009-08-07 13:35:30 -07:00
|
|
|
/* NB: evas_object_recalc_clippees was here previously ( < 08/07/2009) */
|
2005-09-21 19:52:53 -07:00
|
|
|
if (obj->layer->evas->events_frozen <= 0)
|
2002-11-08 00:02:15 -08:00
|
|
|
{
|
2009-08-07 13:35:30 -07:00
|
|
|
/* NB: If this creates glitches on screen then move to above position */
|
|
|
|
evas_object_recalc_clippees(obj);
|
|
|
|
|
2005-07-22 03:28:11 -07:00
|
|
|
// if (obj->func->coords_recalc) obj->func->coords_recalc(obj);
|
|
|
|
if (!pass)
|
2003-07-21 22:16:47 -07:00
|
|
|
{
|
2005-07-22 03:28:11 -07:00
|
|
|
if (!obj->smart.smart)
|
|
|
|
{
|
|
|
|
is = evas_object_is_in_output_rect(obj,
|
|
|
|
obj->layer->evas->pointer.x,
|
|
|
|
obj->layer->evas->pointer.y, 1, 1);
|
|
|
|
if ((is ^ was) && (obj->cur.visible))
|
|
|
|
evas_event_feed_mouse_move(obj->layer->evas,
|
|
|
|
obj->layer->evas->pointer.x,
|
|
|
|
obj->layer->evas->pointer.y,
|
2005-07-25 02:55:47 -07:00
|
|
|
obj->layer->evas->last_timestamp,
|
2005-07-22 03:28:11 -07:00
|
|
|
NULL);
|
|
|
|
}
|
2003-07-21 22:16:47 -07:00
|
|
|
}
|
2002-11-08 00:02:15 -08:00
|
|
|
}
|
2004-09-20 20:15:42 -07:00
|
|
|
evas_object_inform_call_resize(obj);
|
2002-11-08 00:02:15 -08:00
|
|
|
}
|
|
|
|
|
2003-03-04 18:30:20 -08:00
|
|
|
/**
|
2004-08-15 22:13:25 -07:00
|
|
|
* Retrieves the position and rectangular size of the given evas object.
|
2003-03-04 18:30:20 -08:00
|
|
|
*
|
2004-08-15 22:13:25 -07:00
|
|
|
* Note that if any of @p x, @p y, @p w or @p h are @c NULL, the @c NULL
|
|
|
|
* parameters are ignored.
|
2005-05-21 19:49:50 -07:00
|
|
|
*
|
2004-08-15 22:13:25 -07:00
|
|
|
* @param obj The given evas object.
|
|
|
|
* @param x Pointer to an integer in which to store the X coordinate of
|
|
|
|
* the object.
|
|
|
|
* @param y Pointer to an integer in which to store the Y coordinate of
|
|
|
|
* the object.
|
|
|
|
* @param w Pointer to an integer in which to store the width of the
|
|
|
|
* object.
|
|
|
|
* @param h Pointer to an integer in which to store the height of the
|
|
|
|
* object.
|
|
|
|
* @ingroup Evas_Object_Group
|
2003-03-04 18:30:20 -08:00
|
|
|
*/
|
2006-01-06 15:05:17 -08:00
|
|
|
EAPI void
|
2008-02-08 14:35:19 -08:00
|
|
|
evas_object_geometry_get(const Evas_Object *obj, Evas_Coord *x, Evas_Coord *y, Evas_Coord *w, Evas_Coord *h)
|
2002-11-08 00:02:15 -08:00
|
|
|
{
|
|
|
|
MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ);
|
|
|
|
if (x) *x = 0; if (y) *y = 0; if (w) *w = 0; if (h) *h = 0;
|
|
|
|
return;
|
|
|
|
MAGIC_CHECK_END();
|
2004-03-07 18:42:08 -08:00
|
|
|
if (obj->delete_me)
|
|
|
|
{
|
|
|
|
if (x) *x = 0; if (y) *y = 0; if (w) *w = 0; if (h) *h = 0;
|
|
|
|
return;
|
|
|
|
}
|
2002-11-08 00:02:15 -08:00
|
|
|
if (x) *x = obj->cur.geometry.x;
|
|
|
|
if (y) *y = obj->cur.geometry.y;
|
|
|
|
if (w) *w = obj->cur.geometry.w;
|
|
|
|
if (h) *h = obj->cur.geometry.h;
|
|
|
|
}
|
|
|
|
|
2008-04-11 16:12:20 -07:00
|
|
|
/**
|
2008-11-01 15:21:10 -07:00
|
|
|
* @addtogroup Evas_Object_Group
|
2008-11-01 14:50:36 -07:00
|
|
|
* @{
|
|
|
|
*/
|
|
|
|
|
2008-10-04 09:57:02 -07:00
|
|
|
static void
|
|
|
|
_evas_object_size_hint_alloc(Evas_Object *obj)
|
|
|
|
{
|
|
|
|
if (obj->size_hints) return;
|
2009-09-03 22:13:19 -07:00
|
|
|
|
2008-10-04 09:57:02 -07:00
|
|
|
obj->size_hints = calloc(1, sizeof(Evas_Size_Hints));
|
|
|
|
obj->size_hints->max.w = -1;
|
|
|
|
obj->size_hints->max.h = -1;
|
|
|
|
obj->size_hints->align.x = 0.5;
|
|
|
|
obj->size_hints->align.y = 0.5;
|
|
|
|
}
|
2008-04-11 16:12:20 -07:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Retrieves the size hint for the minimum size.
|
|
|
|
*
|
|
|
|
* This is not a size enforcement in any way, it's just a hint that should
|
|
|
|
* be used whenever appropriate.
|
|
|
|
*
|
|
|
|
* Note that if any of @p w or @p h are @c NULL, the @c NULL
|
|
|
|
* parameters are ignored.
|
|
|
|
*
|
|
|
|
* @param obj The given evas object.
|
|
|
|
* @param w Pointer to an integer in which to store the minimum width.
|
|
|
|
* @param h Pointer to an integer in which to store the minimum height.
|
|
|
|
*/
|
|
|
|
EAPI void
|
|
|
|
evas_object_size_hint_min_get(const Evas_Object *obj, Evas_Coord *w, Evas_Coord *h)
|
|
|
|
{
|
|
|
|
MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ);
|
|
|
|
if (w) *w = 0; if (h) *h = 0;
|
|
|
|
return;
|
|
|
|
MAGIC_CHECK_END();
|
2008-04-30 15:51:08 -07:00
|
|
|
if ((!obj->size_hints) || obj->delete_me)
|
2008-04-11 16:12:20 -07:00
|
|
|
{
|
|
|
|
if (w) *w = 0; if (h) *h = 0;
|
|
|
|
return;
|
|
|
|
}
|
2008-04-30 15:51:08 -07:00
|
|
|
if (w) *w = obj->size_hints->min.w;
|
|
|
|
if (h) *h = obj->size_hints->min.h;
|
2008-04-11 16:12:20 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Sets the size hint for the minimum size.
|
|
|
|
*
|
|
|
|
* This is not a size enforcement in any way, it's just a hint that should
|
|
|
|
* be used whenever appropriate.
|
|
|
|
*
|
2008-11-19 19:02:27 -08:00
|
|
|
* Value 0 is considered unset.
|
|
|
|
*
|
2008-04-11 16:12:20 -07:00
|
|
|
* @param obj The given evas object.
|
|
|
|
* @param w Integer to use as the minimum width hint.
|
|
|
|
* @param h Integer to use as the minimum height hint.
|
|
|
|
*/
|
|
|
|
EAPI void
|
|
|
|
evas_object_size_hint_min_set(Evas_Object *obj, Evas_Coord w, Evas_Coord h)
|
|
|
|
{
|
|
|
|
MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ);
|
|
|
|
return;
|
|
|
|
MAGIC_CHECK_END();
|
|
|
|
if (obj->delete_me)
|
|
|
|
return;
|
2008-10-04 09:57:02 -07:00
|
|
|
_evas_object_size_hint_alloc(obj);
|
2008-10-04 10:10:44 -07:00
|
|
|
if ((obj->size_hints->min.w == w) && (obj->size_hints->min.h == h)) return;
|
2008-04-30 15:51:08 -07:00
|
|
|
obj->size_hints->min.w = w;
|
|
|
|
obj->size_hints->min.h = h;
|
2008-04-11 16:12:20 -07:00
|
|
|
|
|
|
|
evas_object_inform_call_changed_size_hints(obj);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Retrieves the size hint for the maximum size.
|
|
|
|
*
|
|
|
|
* This is not a size enforcement in any way, it's just a hint that should
|
|
|
|
* be used whenever appropriate.
|
|
|
|
*
|
|
|
|
* Note that if any of @p w or @p h are @c NULL, the @c NULL
|
|
|
|
* parameters are ignored.
|
|
|
|
*
|
|
|
|
* @param obj The given evas object.
|
|
|
|
* @param w Pointer to an integer in which to store the maximum width.
|
|
|
|
* @param h Pointer to an integer in which to store the maximum height.
|
|
|
|
*/
|
|
|
|
EAPI void
|
|
|
|
evas_object_size_hint_max_get(const Evas_Object *obj, Evas_Coord *w, Evas_Coord *h)
|
|
|
|
{
|
|
|
|
MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ);
|
2008-10-04 09:53:47 -07:00
|
|
|
if (w) *w = -1; if (h) *h = -1;
|
2008-04-11 16:12:20 -07:00
|
|
|
return;
|
|
|
|
MAGIC_CHECK_END();
|
2008-04-30 15:51:08 -07:00
|
|
|
if ((!obj->size_hints) || obj->delete_me)
|
2008-04-11 16:12:20 -07:00
|
|
|
{
|
2008-10-04 09:53:47 -07:00
|
|
|
if (w) *w = -1; if (h) *h = -1;
|
2008-04-11 16:12:20 -07:00
|
|
|
return;
|
|
|
|
}
|
2008-04-30 15:51:08 -07:00
|
|
|
if (w) *w = obj->size_hints->max.w;
|
|
|
|
if (h) *h = obj->size_hints->max.h;
|
2008-04-11 16:12:20 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Sets the size hint for the maximum size.
|
|
|
|
*
|
|
|
|
* This is not a size enforcement in any way, it's just a hint that should
|
|
|
|
* be used whenever appropriate.
|
|
|
|
*
|
2008-11-19 19:02:27 -08:00
|
|
|
* Value -1 is considered unset.
|
|
|
|
*
|
2008-04-11 16:12:20 -07:00
|
|
|
* @param obj The given evas object.
|
|
|
|
* @param w Integer to use as the maximum width hint.
|
|
|
|
* @param h Integer to use as the maximum height hint.
|
|
|
|
*/
|
|
|
|
EAPI void
|
|
|
|
evas_object_size_hint_max_set(Evas_Object *obj, Evas_Coord w, Evas_Coord h)
|
|
|
|
{
|
|
|
|
MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ);
|
|
|
|
return;
|
|
|
|
MAGIC_CHECK_END();
|
|
|
|
if (obj->delete_me)
|
|
|
|
return;
|
2008-10-04 09:57:02 -07:00
|
|
|
_evas_object_size_hint_alloc(obj);
|
2008-10-04 10:10:44 -07:00
|
|
|
if ((obj->size_hints->max.w == w) && (obj->size_hints->max.h == h)) return;
|
2008-04-30 15:51:08 -07:00
|
|
|
obj->size_hints->max.w = w;
|
|
|
|
obj->size_hints->max.h = h;
|
2008-04-11 16:12:20 -07:00
|
|
|
|
|
|
|
evas_object_inform_call_changed_size_hints(obj);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Retrieves the size request hint.
|
|
|
|
*
|
|
|
|
* This is not a size enforcement in any way, it's just a hint that should
|
|
|
|
* be used whenever appropriate.
|
|
|
|
*
|
|
|
|
* Note that if any of @p w or @p h are @c NULL, the @c NULL
|
|
|
|
* parameters are ignored.
|
|
|
|
*
|
|
|
|
* @param obj The given evas object.
|
|
|
|
* @param w Pointer to an integer in which to store the requested width.
|
|
|
|
* @param h Pointer to an integer in which to store the requested height.
|
|
|
|
*/
|
|
|
|
EAPI void
|
|
|
|
evas_object_size_hint_request_get(const Evas_Object *obj, Evas_Coord *w, Evas_Coord *h)
|
|
|
|
{
|
|
|
|
MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ);
|
|
|
|
if (w) *w = 0; if (h) *h = 0;
|
|
|
|
return;
|
|
|
|
MAGIC_CHECK_END();
|
2008-04-30 15:51:08 -07:00
|
|
|
if ((!obj->size_hints) || obj->delete_me)
|
2008-04-11 16:12:20 -07:00
|
|
|
{
|
|
|
|
if (w) *w = 0; if (h) *h = 0;
|
|
|
|
return;
|
|
|
|
}
|
2008-04-30 15:51:08 -07:00
|
|
|
if (w) *w = obj->size_hints->request.w;
|
|
|
|
if (h) *h = obj->size_hints->request.h;
|
2008-04-11 16:12:20 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Sets the requested size hint.
|
|
|
|
*
|
|
|
|
* This is not a size enforcement in any way, it's just a hint that should
|
|
|
|
* be used whenever appropriate.
|
|
|
|
*
|
2008-11-19 19:02:27 -08:00
|
|
|
* Value 0 is considered unset.
|
|
|
|
*
|
2008-04-11 16:12:20 -07:00
|
|
|
* @param obj The given evas object.
|
|
|
|
* @param w Integer to use as the preferred width hint.
|
|
|
|
* @param h Integer to use as the preferred height hint.
|
|
|
|
*/
|
|
|
|
EAPI void
|
|
|
|
evas_object_size_hint_request_set(Evas_Object *obj, Evas_Coord w, Evas_Coord h)
|
|
|
|
{
|
|
|
|
MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ);
|
|
|
|
return;
|
|
|
|
MAGIC_CHECK_END();
|
|
|
|
if (obj->delete_me)
|
|
|
|
return;
|
2008-10-04 09:57:02 -07:00
|
|
|
_evas_object_size_hint_alloc(obj);
|
2008-10-04 10:10:44 -07:00
|
|
|
if ((obj->size_hints->request.w == w) && (obj->size_hints->request.h == h)) return;
|
2008-04-30 15:51:08 -07:00
|
|
|
obj->size_hints->request.w = w;
|
|
|
|
obj->size_hints->request.h = h;
|
2008-04-11 16:12:20 -07:00
|
|
|
|
|
|
|
evas_object_inform_call_changed_size_hints(obj);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Retrieves the size aspect control hint.
|
|
|
|
*
|
|
|
|
* This is not a size enforcement in any way, it's just a hint that should
|
|
|
|
* be used whenever appropriate.
|
|
|
|
*
|
|
|
|
* Note that if any of @p aspect, @p w or @p h are @c NULL, the @c NULL
|
|
|
|
* parameters are ignored.
|
|
|
|
*
|
|
|
|
* @param obj The given evas object.
|
|
|
|
* @param aspect Returns the hint on how size should be calculated.
|
|
|
|
* @param w Pointer to an integer in which to store the aspect width.
|
|
|
|
* @param h Pointer to an integer in which to store the aspect height.
|
|
|
|
*/
|
|
|
|
EAPI void
|
|
|
|
evas_object_size_hint_aspect_get(const Evas_Object *obj, Evas_Aspect_Control *aspect, Evas_Coord *w, Evas_Coord *h)
|
|
|
|
{
|
|
|
|
MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ);
|
|
|
|
if (aspect) *aspect = EVAS_ASPECT_CONTROL_NONE;
|
|
|
|
if (w) *w = 0; if (h) *h = 0;
|
|
|
|
return;
|
|
|
|
MAGIC_CHECK_END();
|
2008-04-30 15:51:08 -07:00
|
|
|
if ((!obj->size_hints) || obj->delete_me)
|
2008-04-11 16:12:20 -07:00
|
|
|
{
|
|
|
|
if (aspect) *aspect = EVAS_ASPECT_CONTROL_NONE;
|
|
|
|
if (w) *w = 0; if (h) *h = 0;
|
|
|
|
return;
|
|
|
|
}
|
2008-04-30 15:51:08 -07:00
|
|
|
if (aspect) *aspect = obj->size_hints->aspect.mode;
|
|
|
|
if (w) *w = obj->size_hints->aspect.size.w;
|
|
|
|
if (h) *h = obj->size_hints->aspect.size.h;
|
2008-04-11 16:12:20 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Sets the size aspect control hint.
|
|
|
|
*
|
|
|
|
* This is not a size enforcement in any way, it's just a hint that should
|
|
|
|
* be used whenever appropriate.
|
|
|
|
*
|
|
|
|
* @param obj The given evas object.
|
|
|
|
* @param aspect Hint on how to calculate size.
|
|
|
|
* @param w Integer to use as aspect width hint.
|
|
|
|
* @param h Integer to use as aspect height hint.
|
|
|
|
*/
|
|
|
|
EAPI void
|
|
|
|
evas_object_size_hint_aspect_set(Evas_Object *obj, Evas_Aspect_Control aspect, Evas_Coord w, Evas_Coord h)
|
|
|
|
{
|
|
|
|
MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ);
|
|
|
|
return;
|
|
|
|
MAGIC_CHECK_END();
|
|
|
|
if (obj->delete_me)
|
|
|
|
return;
|
2008-10-04 09:57:02 -07:00
|
|
|
_evas_object_size_hint_alloc(obj);
|
2008-10-04 20:47:52 -07:00
|
|
|
if ((obj->size_hints->aspect.mode == aspect) && (obj->size_hints->aspect.size.w == w) && (obj->size_hints->aspect.size.h == h)) return;
|
2008-04-30 15:51:08 -07:00
|
|
|
obj->size_hints->aspect.mode = aspect;
|
|
|
|
obj->size_hints->aspect.size.w = w;
|
|
|
|
obj->size_hints->aspect.size.h = h;
|
2008-04-11 16:12:20 -07:00
|
|
|
|
|
|
|
evas_object_inform_call_changed_size_hints(obj);
|
|
|
|
}
|
|
|
|
|
2008-10-04 09:11:23 -07:00
|
|
|
/**
|
|
|
|
* Retrieves the size align control hint.
|
|
|
|
*
|
|
|
|
* This is not a size enforcement in any way, it's just a hint that should
|
|
|
|
* be used whenever appropriate.
|
|
|
|
*
|
2008-11-19 19:02:27 -08:00
|
|
|
* Note that if any of @p x or @p y are @c NULL, the @c NULL
|
|
|
|
* parameters are ignored.
|
|
|
|
*
|
2008-10-04 09:11:23 -07:00
|
|
|
* @param obj The given evas object.
|
2008-11-19 19:02:27 -08:00
|
|
|
* @param x Pointer to a double in which to store the align x.
|
|
|
|
* @param y Pointer to a double in which to store the align y.
|
2008-10-04 09:11:23 -07:00
|
|
|
*/
|
|
|
|
EAPI void
|
|
|
|
evas_object_size_hint_align_get(const Evas_Object *obj, double *x, double *y)
|
|
|
|
{
|
|
|
|
MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ);
|
2008-10-04 09:12:48 -07:00
|
|
|
if (x) *x = 0.5; if (y) *y = 0.5;
|
2008-10-04 09:11:23 -07:00
|
|
|
return;
|
|
|
|
MAGIC_CHECK_END();
|
|
|
|
if ((!obj->size_hints) || obj->delete_me)
|
|
|
|
{
|
2008-10-04 09:12:48 -07:00
|
|
|
if (x) *x = 0.5; if (y) *y = 0.5;
|
2008-10-04 09:11:23 -07:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
if (x) *x = obj->size_hints->align.x;
|
|
|
|
if (y) *y = obj->size_hints->align.y;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Sets the size align control hint.
|
|
|
|
*
|
|
|
|
* This is not a size enforcement in any way, it's just a hint that should
|
|
|
|
* be used whenever appropriate.
|
|
|
|
*
|
2008-11-19 19:02:27 -08:00
|
|
|
* Accepted values are in the 0.0 to 1.0 range, with the special value
|
|
|
|
* -1.0 used to specify "justify" or "fill" by some users. See
|
|
|
|
* documentation of possible users.
|
|
|
|
*
|
2008-10-04 09:11:23 -07:00
|
|
|
* @param obj The given evas object.
|
2008-11-19 19:02:27 -08:00
|
|
|
* @param x Double (0.0..1.0 or -1.0) to use as align x hint.
|
|
|
|
* @param y Double (0.0..1.0 or -1.0) to use as align y hint.
|
2008-10-04 09:11:23 -07:00
|
|
|
*/
|
|
|
|
EAPI void
|
|
|
|
evas_object_size_hint_align_set(Evas_Object *obj, double x, double y)
|
|
|
|
{
|
|
|
|
MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ);
|
|
|
|
return;
|
|
|
|
MAGIC_CHECK_END();
|
|
|
|
if (obj->delete_me)
|
|
|
|
return;
|
2008-10-04 09:57:02 -07:00
|
|
|
_evas_object_size_hint_alloc(obj);
|
2008-10-04 10:10:44 -07:00
|
|
|
if ((obj->size_hints->align.x == x) && (obj->size_hints->align.y == y)) return;
|
2008-10-04 09:11:23 -07:00
|
|
|
obj->size_hints->align.x = x;
|
2008-10-04 10:10:44 -07:00
|
|
|
obj->size_hints->align.y = y;
|
2008-10-04 09:11:23 -07:00
|
|
|
|
|
|
|
evas_object_inform_call_changed_size_hints(obj);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Retrieves the size weight control hint.
|
|
|
|
*
|
|
|
|
* This is not a size enforcement in any way, it's just a hint that should
|
|
|
|
* be used whenever appropriate.
|
|
|
|
*
|
2008-11-19 19:02:27 -08:00
|
|
|
* Note that if any of @p x or @p y are @c NULL, the @c NULL
|
|
|
|
* parameters are ignored.
|
|
|
|
*
|
|
|
|
* Accepted values are zero or positive values. Some users might use
|
|
|
|
* this hint as a boolean, but some might consider it as a proportion,
|
|
|
|
* see documentation of possible users.
|
|
|
|
*
|
2008-10-04 09:11:23 -07:00
|
|
|
* @param obj The given evas object.
|
2008-11-19 19:02:27 -08:00
|
|
|
* @param x Pointer to a double in which to store the weight x.
|
|
|
|
* @param y Pointer to a double in which to store the weight y.
|
2008-10-04 09:11:23 -07:00
|
|
|
*/
|
|
|
|
EAPI void
|
|
|
|
evas_object_size_hint_weight_get(const Evas_Object *obj, double *x, double *y)
|
|
|
|
{
|
|
|
|
MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ);
|
2008-10-04 09:42:04 -07:00
|
|
|
if (x) *x = 0.0; if (y) *y = 0.0;
|
2008-10-04 09:11:23 -07:00
|
|
|
return;
|
|
|
|
MAGIC_CHECK_END();
|
|
|
|
if ((!obj->size_hints) || obj->delete_me)
|
|
|
|
{
|
2008-10-04 09:42:04 -07:00
|
|
|
if (x) *x = 0.0; if (y) *y = 0.0;
|
2008-10-04 09:11:23 -07:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
if (x) *x = obj->size_hints->weight.x;
|
|
|
|
if (y) *y = obj->size_hints->weight.y;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Sets the size weight control hint.
|
|
|
|
*
|
|
|
|
* This is not a size enforcement in any way, it's just a hint that should
|
|
|
|
* be used whenever appropriate.
|
|
|
|
*
|
|
|
|
* @param obj The given evas object.
|
|
|
|
* @param x Double (0.0-1.0) to use as weight x hint.
|
|
|
|
* @param y Double (0.0-1.0) to use as weight y hint.
|
|
|
|
*/
|
|
|
|
EAPI void
|
|
|
|
evas_object_size_hint_weight_set(Evas_Object *obj, double x, double y)
|
|
|
|
{
|
|
|
|
MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ);
|
|
|
|
return;
|
|
|
|
MAGIC_CHECK_END();
|
|
|
|
if (obj->delete_me)
|
|
|
|
return;
|
2008-10-04 09:57:02 -07:00
|
|
|
_evas_object_size_hint_alloc(obj);
|
2008-10-04 10:10:44 -07:00
|
|
|
if ((obj->size_hints->weight.x == x) && (obj->size_hints->weight.y == y)) return;
|
2008-10-04 09:11:23 -07:00
|
|
|
obj->size_hints->weight.x = x;
|
2008-10-04 10:10:44 -07:00
|
|
|
obj->size_hints->weight.y = y;
|
2008-10-04 09:11:23 -07:00
|
|
|
|
|
|
|
evas_object_inform_call_changed_size_hints(obj);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Retrieves the size padding control hint.
|
|
|
|
*
|
|
|
|
* This is not a size enforcement in any way, it's just a hint that should
|
|
|
|
* be used whenever appropriate.
|
|
|
|
*
|
2008-11-19 19:02:27 -08:00
|
|
|
* Note that if any of @p l, @p r, @p t or @p b are @c NULL, the @c
|
|
|
|
* NULL parameters are ignored.
|
|
|
|
*
|
2008-10-04 09:11:23 -07:00
|
|
|
* @param obj The given evas object.
|
2008-11-19 19:02:27 -08:00
|
|
|
* @param l Pointer to an integer in which to store left padding.
|
|
|
|
* @param r Pointer to an integer in which to store right padding.
|
|
|
|
* @param t Pointer to an integer in which to store top padding.
|
|
|
|
* @param b Pointer to an integer in which to store bottom padding.
|
2008-10-04 09:11:23 -07:00
|
|
|
*/
|
|
|
|
EAPI void
|
|
|
|
evas_object_size_hint_padding_get(const Evas_Object *obj, Evas_Coord *l, Evas_Coord *r, Evas_Coord *t, Evas_Coord *b)
|
|
|
|
{
|
|
|
|
MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ);
|
|
|
|
if (l) *l = 0; if (r) *r = 0;
|
|
|
|
if (t) *t = 0; if (b) *b = 0;
|
|
|
|
return;
|
|
|
|
MAGIC_CHECK_END();
|
|
|
|
if ((!obj->size_hints) || obj->delete_me)
|
|
|
|
{
|
|
|
|
if (l) *l = 0; if (r) *r = 0;
|
|
|
|
if (t) *t = 0; if (b) *b = 0;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
if (l) *l = obj->size_hints->padding.l;
|
|
|
|
if (r) *r = obj->size_hints->padding.r;
|
|
|
|
if (t) *t = obj->size_hints->padding.t;
|
|
|
|
if (b) *b = obj->size_hints->padding.b;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Sets the size padding control hint.
|
|
|
|
*
|
|
|
|
* This is not a size enforcement in any way, it's just a hint that should
|
|
|
|
* be used whenever appropriate.
|
|
|
|
*
|
|
|
|
* @param obj The given evas object.
|
2008-11-19 19:02:27 -08:00
|
|
|
* @param l Integer to specify left padding.
|
|
|
|
* @param r Integer to specify right padding.
|
|
|
|
* @param t Integer to specify top padding.
|
|
|
|
* @param b Integer to specify bottom padding.
|
2008-10-04 09:11:23 -07:00
|
|
|
*/
|
|
|
|
EAPI void
|
|
|
|
evas_object_size_hint_padding_set(Evas_Object *obj, Evas_Coord l, Evas_Coord r, Evas_Coord t, Evas_Coord b)
|
|
|
|
{
|
|
|
|
MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ);
|
|
|
|
return;
|
|
|
|
MAGIC_CHECK_END();
|
|
|
|
if (obj->delete_me)
|
|
|
|
return;
|
2008-10-04 09:57:02 -07:00
|
|
|
_evas_object_size_hint_alloc(obj);
|
2008-10-04 10:10:44 -07:00
|
|
|
if ((obj->size_hints->padding.l == l) && (obj->size_hints->padding.r == r) && (obj->size_hints->padding.t == t) && (obj->size_hints->padding.b == b)) return;
|
2008-10-04 10:28:43 -07:00
|
|
|
obj->size_hints->padding.l = l;
|
2008-10-04 09:11:23 -07:00
|
|
|
obj->size_hints->padding.r = r;
|
|
|
|
obj->size_hints->padding.t = t;
|
|
|
|
obj->size_hints->padding.b = b;
|
|
|
|
|
|
|
|
evas_object_inform_call_changed_size_hints(obj);
|
|
|
|
}
|
2008-04-11 16:12:20 -07:00
|
|
|
|
2008-11-01 14:50:36 -07:00
|
|
|
|
|
|
|
/**
|
|
|
|
* @}
|
|
|
|
*/
|
|
|
|
|
2004-08-15 22:13:25 -07:00
|
|
|
/**
|
|
|
|
* Makes the given evas object visible.
|
|
|
|
* @param obj The given evas object.
|
2008-11-01 13:19:28 -07:00
|
|
|
* @ingroup Evas_Object_Group
|
2003-03-04 18:30:20 -08:00
|
|
|
*/
|
2006-01-06 15:05:17 -08:00
|
|
|
EAPI void
|
2002-11-08 00:02:15 -08:00
|
|
|
evas_object_show(Evas_Object *obj)
|
|
|
|
{
|
|
|
|
MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ);
|
|
|
|
return;
|
|
|
|
MAGIC_CHECK_END();
|
2004-03-07 18:42:08 -08:00
|
|
|
if (obj->delete_me) return;
|
2002-12-14 16:33:57 -08:00
|
|
|
if (evas_object_intercept_call_show(obj)) return;
|
2002-11-08 00:02:15 -08:00
|
|
|
if (obj->smart.smart)
|
|
|
|
{
|
2003-10-08 20:05:17 -07:00
|
|
|
if (obj->smart.smart->smart_class->show)
|
|
|
|
obj->smart.smart->smart_class->show(obj);
|
2002-11-08 00:02:15 -08:00
|
|
|
}
|
2002-12-09 22:45:18 -08:00
|
|
|
if (obj->cur.visible)
|
|
|
|
{
|
Do not inform callbacks that did not changed the state of object.
For some unknown reason evas was informing EVAS_CALLBACK_* even if the
original call did not changed the internal object state, that is, new
value is already equal to current value.
This is specially costly since Edje, Box, Table and possible other
layout engines will call evas_object_resize(), move(), show(), hide()
even if the state has not changed, assuming evas will ignore the call
(as it does). The real overhead might come if there are listeners
attached to these events, that in turn might do lots of other stuff,
leading to a torrent of useless calls.
I marked it for removal, please test it and uncomment '#define
CALLBACK_NOOPS' to get the old behavior back. It does seems to work
with e17 and edje_editor. If problems appear, let's try to fix the
real problem instead of getting this code back, it's a performance
penalty.
SVN revision: 38955
2009-02-05 06:37:58 -08:00
|
|
|
#ifdef CALLBACK_NOOP
|
2002-12-09 22:45:18 -08:00
|
|
|
evas_object_inform_call_show(obj);
|
Do not inform callbacks that did not changed the state of object.
For some unknown reason evas was informing EVAS_CALLBACK_* even if the
original call did not changed the internal object state, that is, new
value is already equal to current value.
This is specially costly since Edje, Box, Table and possible other
layout engines will call evas_object_resize(), move(), show(), hide()
even if the state has not changed, assuming evas will ignore the call
(as it does). The real overhead might come if there are listeners
attached to these events, that in turn might do lots of other stuff,
leading to a torrent of useless calls.
I marked it for removal, please test it and uncomment '#define
CALLBACK_NOOPS' to get the old behavior back. It does seems to work
with e17 and edje_editor. If problems appear, let's try to fix the
real problem instead of getting this code back, it's a performance
penalty.
SVN revision: 38955
2009-02-05 06:37:58 -08:00
|
|
|
#endif
|
2002-12-09 22:45:18 -08:00
|
|
|
return;
|
|
|
|
}
|
2002-11-08 00:02:15 -08:00
|
|
|
obj->cur.visible = 1;
|
|
|
|
evas_object_change(obj);
|
2005-04-03 07:22:17 -07:00
|
|
|
evas_object_clip_dirty(obj);
|
2005-09-21 19:52:53 -07:00
|
|
|
if (obj->layer->evas->events_frozen <= 0)
|
2002-11-08 00:02:15 -08:00
|
|
|
{
|
2005-07-30 02:52:53 -07:00
|
|
|
evas_object_recalc_clippees(obj);
|
2005-07-22 03:28:11 -07:00
|
|
|
if (!evas_event_passes_through(obj))
|
2003-07-21 22:16:47 -07:00
|
|
|
{
|
2005-07-22 03:28:11 -07:00
|
|
|
if (!obj->smart.smart)
|
|
|
|
{
|
|
|
|
if (evas_object_is_in_output_rect(obj,
|
|
|
|
obj->layer->evas->pointer.x,
|
|
|
|
obj->layer->evas->pointer.y, 1, 1))
|
|
|
|
evas_event_feed_mouse_move(obj->layer->evas,
|
2005-05-21 19:49:50 -07:00
|
|
|
obj->layer->evas->pointer.x,
|
2005-07-22 03:28:11 -07:00
|
|
|
obj->layer->evas->pointer.y,
|
2005-07-25 02:55:47 -07:00
|
|
|
obj->layer->evas->last_timestamp,
|
2005-07-22 03:28:11 -07:00
|
|
|
NULL);
|
|
|
|
}
|
2003-07-21 22:16:47 -07:00
|
|
|
}
|
2002-11-08 00:02:15 -08:00
|
|
|
}
|
2002-12-09 22:45:18 -08:00
|
|
|
evas_object_inform_call_show(obj);
|
2002-11-08 00:02:15 -08:00
|
|
|
}
|
|
|
|
|
2003-03-04 18:30:20 -08:00
|
|
|
/**
|
2004-08-15 22:13:25 -07:00
|
|
|
* Makes the given evas object invisible.
|
|
|
|
* @param obj The given evas object.
|
2008-11-01 13:19:28 -07:00
|
|
|
* @ingroup Evas_Object_Group
|
2003-03-04 18:30:20 -08:00
|
|
|
*/
|
2006-01-06 15:05:17 -08:00
|
|
|
EAPI void
|
2002-11-08 00:02:15 -08:00
|
|
|
evas_object_hide(Evas_Object *obj)
|
|
|
|
{
|
|
|
|
MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ);
|
|
|
|
return;
|
|
|
|
MAGIC_CHECK_END();
|
2004-03-07 18:42:08 -08:00
|
|
|
if (obj->delete_me) return;
|
2002-12-14 16:33:57 -08:00
|
|
|
if (evas_object_intercept_call_hide(obj)) return;
|
2002-11-08 00:02:15 -08:00
|
|
|
if (obj->smart.smart)
|
|
|
|
{
|
2003-10-08 20:05:17 -07:00
|
|
|
if (obj->smart.smart->smart_class->hide)
|
|
|
|
obj->smart.smart->smart_class->hide(obj);
|
2002-11-08 00:02:15 -08:00
|
|
|
}
|
2002-12-09 22:45:18 -08:00
|
|
|
if (!obj->cur.visible)
|
|
|
|
{
|
Do not inform callbacks that did not changed the state of object.
For some unknown reason evas was informing EVAS_CALLBACK_* even if the
original call did not changed the internal object state, that is, new
value is already equal to current value.
This is specially costly since Edje, Box, Table and possible other
layout engines will call evas_object_resize(), move(), show(), hide()
even if the state has not changed, assuming evas will ignore the call
(as it does). The real overhead might come if there are listeners
attached to these events, that in turn might do lots of other stuff,
leading to a torrent of useless calls.
I marked it for removal, please test it and uncomment '#define
CALLBACK_NOOPS' to get the old behavior back. It does seems to work
with e17 and edje_editor. If problems appear, let's try to fix the
real problem instead of getting this code back, it's a performance
penalty.
SVN revision: 38955
2009-02-05 06:37:58 -08:00
|
|
|
#ifdef CALLBACK_NOOP
|
2002-12-09 22:45:18 -08:00
|
|
|
evas_object_inform_call_hide(obj);
|
Do not inform callbacks that did not changed the state of object.
For some unknown reason evas was informing EVAS_CALLBACK_* even if the
original call did not changed the internal object state, that is, new
value is already equal to current value.
This is specially costly since Edje, Box, Table and possible other
layout engines will call evas_object_resize(), move(), show(), hide()
even if the state has not changed, assuming evas will ignore the call
(as it does). The real overhead might come if there are listeners
attached to these events, that in turn might do lots of other stuff,
leading to a torrent of useless calls.
I marked it for removal, please test it and uncomment '#define
CALLBACK_NOOPS' to get the old behavior back. It does seems to work
with e17 and edje_editor. If problems appear, let's try to fix the
real problem instead of getting this code back, it's a performance
penalty.
SVN revision: 38955
2009-02-05 06:37:58 -08:00
|
|
|
#endif
|
2002-12-09 22:45:18 -08:00
|
|
|
return;
|
|
|
|
}
|
2002-11-08 00:02:15 -08:00
|
|
|
obj->cur.visible = 0;
|
|
|
|
evas_object_change(obj);
|
2005-04-03 07:22:17 -07:00
|
|
|
evas_object_clip_dirty(obj);
|
2005-09-21 19:52:53 -07:00
|
|
|
if (obj->layer->evas->events_frozen <= 0)
|
2005-05-21 19:49:50 -07:00
|
|
|
{
|
2005-07-30 02:52:53 -07:00
|
|
|
evas_object_recalc_clippees(obj);
|
2005-07-22 03:28:11 -07:00
|
|
|
if (!evas_event_passes_through(obj))
|
2003-07-21 22:16:47 -07:00
|
|
|
{
|
2005-07-22 03:28:11 -07:00
|
|
|
if (!obj->smart.smart)
|
2004-11-19 23:41:14 -08:00
|
|
|
{
|
2005-07-22 03:28:11 -07:00
|
|
|
if (evas_object_is_in_output_rect(obj,
|
|
|
|
obj->layer->evas->pointer.x,
|
|
|
|
obj->layer->evas->pointer.y, 1, 1))
|
|
|
|
evas_event_feed_mouse_move(obj->layer->evas,
|
|
|
|
obj->layer->evas->pointer.x,
|
|
|
|
obj->layer->evas->pointer.y,
|
2005-07-25 02:55:47 -07:00
|
|
|
obj->layer->evas->last_timestamp,
|
2005-07-22 03:28:11 -07:00
|
|
|
NULL);
|
2005-08-01 06:52:55 -07:00
|
|
|
if (obj->delete_me) return;
|
2005-07-22 03:28:11 -07:00
|
|
|
if (obj->mouse_grabbed > 0)
|
2004-11-19 23:41:14 -08:00
|
|
|
{
|
2006-04-19 07:37:49 -07:00
|
|
|
// if (obj->layer->evas->pointer.mouse_grabbed >= obj->mouse_grabbed)
|
2005-07-22 03:28:11 -07:00
|
|
|
obj->layer->evas->pointer.mouse_grabbed -= obj->mouse_grabbed;
|
2004-11-19 23:41:14 -08:00
|
|
|
}
|
2008-11-14 21:13:09 -08:00
|
|
|
if ((obj->mouse_in) || (obj->mouse_grabbed > 0))
|
|
|
|
{
|
|
|
|
obj->layer->evas->pointer.object.in = eina_list_remove(obj->layer->evas->pointer.object.in, obj);
|
|
|
|
}
|
|
|
|
obj->mouse_grabbed = 0;
|
|
|
|
if (obj->layer->evas->events_frozen > 0)
|
|
|
|
{
|
|
|
|
obj->mouse_in = 0;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
if (obj->mouse_in)
|
|
|
|
{
|
|
|
|
Evas_Event_Mouse_Out ev;
|
2009-09-03 22:13:19 -07:00
|
|
|
|
2008-11-14 21:13:09 -08:00
|
|
|
obj->mouse_in = 0;
|
|
|
|
ev.buttons = obj->layer->evas->pointer.button;
|
|
|
|
ev.output.x = obj->layer->evas->pointer.x;
|
|
|
|
ev.output.y = obj->layer->evas->pointer.y;
|
|
|
|
ev.canvas.x = obj->layer->evas->pointer.x;
|
|
|
|
ev.canvas.y = obj->layer->evas->pointer.y;
|
|
|
|
ev.data = NULL;
|
|
|
|
ev.modifiers = &(obj->layer->evas->modifiers);
|
|
|
|
ev.locks = &(obj->layer->evas->locks);
|
2009-07-12 09:11:58 -07:00
|
|
|
ev.timestamp = obj->layer->evas->last_timestamp;
|
|
|
|
ev.event_flags = EVAS_EVENT_FLAG_NONE;
|
2008-11-14 21:13:09 -08:00
|
|
|
evas_object_event_callback_call(obj, EVAS_CALLBACK_MOUSE_OUT, &ev);
|
2003-07-21 22:16:47 -07:00
|
|
|
}
|
2002-11-08 00:02:15 -08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2005-08-01 06:52:55 -07:00
|
|
|
else
|
|
|
|
{
|
|
|
|
if ((obj->mouse_in) || (obj->mouse_grabbed > 0))
|
2008-10-21 09:31:05 -07:00
|
|
|
obj->layer->evas->pointer.object.in = eina_list_remove(obj->layer->evas->pointer.object.in, obj);
|
2005-08-01 06:52:55 -07:00
|
|
|
obj->mouse_grabbed = 0;
|
|
|
|
obj->mouse_in = 0;
|
|
|
|
}
|
2002-12-09 22:45:18 -08:00
|
|
|
evas_object_inform_call_hide(obj);
|
2002-11-08 00:02:15 -08:00
|
|
|
}
|
|
|
|
|
2003-03-04 18:30:20 -08:00
|
|
|
/**
|
2004-08-15 22:13:25 -07:00
|
|
|
* Retrieves whether or not the given evas object is visible.
|
|
|
|
* @param obj The given evas object.
|
|
|
|
* @return @c 1 if the object is visible. @c 0 otherwise.
|
2008-11-01 13:19:28 -07:00
|
|
|
* @ingroup Evas_Object_Group
|
2003-03-04 18:30:20 -08:00
|
|
|
*/
|
2009-06-17 03:01:52 -07:00
|
|
|
EAPI Eina_Bool
|
2008-02-08 14:35:19 -08:00
|
|
|
evas_object_visible_get(const Evas_Object *obj)
|
2002-11-08 00:02:15 -08:00
|
|
|
{
|
|
|
|
MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ);
|
|
|
|
return 0;
|
|
|
|
MAGIC_CHECK_END();
|
2004-03-07 18:42:08 -08:00
|
|
|
if (obj->delete_me) return 0;
|
2002-11-08 00:02:15 -08:00
|
|
|
return obj->cur.visible;
|
|
|
|
}
|
|
|
|
|
2003-03-04 18:30:20 -08:00
|
|
|
/**
|
2004-08-15 22:13:25 -07:00
|
|
|
* Sets the general colour of the given evas object to the given colour.
|
|
|
|
* @param obj The given evas object.
|
|
|
|
* @param r The red component of the given colour.
|
|
|
|
* @param g The green component of the given colour.
|
|
|
|
* @param b The blue component of the given colour.
|
|
|
|
* @param a The alpha component of the given colour.
|
|
|
|
* @ingroup Evas_Object_Group
|
2003-03-04 18:30:20 -08:00
|
|
|
*/
|
2006-01-06 15:05:17 -08:00
|
|
|
EAPI void
|
2002-11-08 00:02:15 -08:00
|
|
|
evas_object_color_set(Evas_Object *obj, int r, int g, int b, int a)
|
|
|
|
{
|
|
|
|
MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ);
|
|
|
|
return;
|
|
|
|
MAGIC_CHECK_END();
|
2004-03-07 18:42:08 -08:00
|
|
|
if (obj->delete_me) return;
|
2002-11-08 00:02:15 -08:00
|
|
|
if (r > 255) r = 255; if (r < 0) r = 0;
|
|
|
|
if (g > 255) g = 255; if (g < 0) g = 0;
|
|
|
|
if (b > 255) b = 255; if (b < 0) b = 0;
|
|
|
|
if (a > 255) a = 255; if (a < 0) a = 0;
|
2007-08-22 09:45:37 -07:00
|
|
|
if (evas_object_intercept_call_color_set(obj, r, g, b, a)) return;
|
2002-11-08 00:02:15 -08:00
|
|
|
if (obj->smart.smart)
|
|
|
|
{
|
2003-10-08 20:05:17 -07:00
|
|
|
if (obj->smart.smart->smart_class->color_set)
|
|
|
|
obj->smart.smart->smart_class->color_set(obj, r, g, b, a);
|
2002-11-08 00:02:15 -08:00
|
|
|
}
|
|
|
|
if ((obj->cur.color.r == r) &&
|
|
|
|
(obj->cur.color.g == g) &&
|
|
|
|
(obj->cur.color.b == b) &&
|
|
|
|
(obj->cur.color.a == a)) return;
|
|
|
|
obj->cur.color.r = r;
|
|
|
|
obj->cur.color.g = g;
|
|
|
|
obj->cur.color.b = b;
|
2009-04-14 03:47:15 -07:00
|
|
|
evas_object_clip_dirty(obj);
|
2002-11-08 00:02:15 -08:00
|
|
|
if ((obj->cur.color.a == 0) && (a == 0)) return;
|
2005-05-21 19:49:50 -07:00
|
|
|
obj->cur.color.a = a;
|
2002-11-08 00:02:15 -08:00
|
|
|
evas_object_change(obj);
|
|
|
|
}
|
|
|
|
|
2003-03-04 18:30:20 -08:00
|
|
|
/**
|
2004-08-15 22:13:25 -07:00
|
|
|
* Retrieves the general colour of the given evas object.
|
2003-03-04 18:30:20 -08:00
|
|
|
*
|
2004-08-15 22:13:25 -07:00
|
|
|
* Note that if any of @p r, @p g, @p b or @p a are @c NULL, then the
|
|
|
|
* @c NULL parameters are ignored.
|
|
|
|
*
|
|
|
|
* @param obj The given evas object.
|
|
|
|
* @param r Pointer to an integer in which to store the red component of
|
|
|
|
* the colour.
|
|
|
|
* @param g Pointer to an integer in which to store the green component of
|
|
|
|
* the colour.
|
|
|
|
* @param b Pointer to an integer in which to store the blue component of
|
|
|
|
* the colour.
|
|
|
|
* @param a Pointer to an integer in which to store the alpha component of
|
|
|
|
* the colour.
|
|
|
|
* @ingroup Evas_Object_Group
|
2003-03-04 18:30:20 -08:00
|
|
|
*/
|
2006-01-06 15:05:17 -08:00
|
|
|
EAPI void
|
2008-02-08 14:35:19 -08:00
|
|
|
evas_object_color_get(const Evas_Object *obj, int *r, int *g, int *b, int *a)
|
2002-11-08 00:02:15 -08:00
|
|
|
{
|
|
|
|
MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ);
|
|
|
|
if (r) *r = 0; if (g) *g = 0; if (b) *b = 0; if (a) *a = 0;
|
|
|
|
return;
|
|
|
|
MAGIC_CHECK_END();
|
2004-03-07 18:42:08 -08:00
|
|
|
if (obj->delete_me)
|
|
|
|
{
|
|
|
|
if (r) *r = 0; if (g) *g = 0; if (b) *b = 0; if (a) *a = 0;
|
|
|
|
return;
|
|
|
|
}
|
2002-11-08 00:02:15 -08:00
|
|
|
if (r) *r = obj->cur.color.r;
|
|
|
|
if (g) *g = obj->cur.color.g;
|
|
|
|
if (b) *b = obj->cur.color.b;
|
|
|
|
if (a) *a = obj->cur.color.a;
|
|
|
|
}
|
|
|
|
|
2005-12-03 01:27:53 -08:00
|
|
|
/**
|
2009-09-17 15:38:10 -07:00
|
|
|
* Sets whether or not the given evas object is to be drawn anti-aliased.
|
|
|
|
*
|
2005-12-03 01:27:53 -08:00
|
|
|
* @param obj The given evas object.
|
2009-09-17 15:38:10 -07:00
|
|
|
* @param anti_alias 1 if the object is to be anti_aliased, 0 otherwise.
|
2005-12-03 01:27:53 -08:00
|
|
|
* @ingroup Evas_Object_Group
|
|
|
|
*/
|
2006-01-06 15:05:17 -08:00
|
|
|
EAPI void
|
2009-06-17 03:01:52 -07:00
|
|
|
evas_object_anti_alias_set(Evas_Object *obj, Eina_Bool anti_alias)
|
2005-12-03 01:27:53 -08:00
|
|
|
{
|
|
|
|
MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ);
|
|
|
|
return;
|
|
|
|
MAGIC_CHECK_END();
|
|
|
|
if (obj->delete_me) return;
|
|
|
|
if (obj->cur.anti_alias == !!anti_alias)
|
2008-09-09 07:14:26 -07:00
|
|
|
return;
|
2005-12-03 01:27:53 -08:00
|
|
|
obj->cur.anti_alias = !!anti_alias;
|
2006-05-02 00:28:49 -07:00
|
|
|
evas_object_change(obj);
|
2005-12-03 01:27:53 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Retrieves whether or not the given evas object is to be drawn anti_aliased.
|
|
|
|
* @param obj The given evas object.
|
|
|
|
* @return @c 1 if the object is to be anti_aliased. @c 0 otherwise.
|
|
|
|
* @ingroup Evas_Object_Group
|
|
|
|
*/
|
2009-06-17 03:01:52 -07:00
|
|
|
EAPI Eina_Bool
|
2008-02-08 14:35:19 -08:00
|
|
|
evas_object_anti_alias_get(const Evas_Object *obj)
|
2005-12-03 01:27:53 -08:00
|
|
|
{
|
|
|
|
MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ);
|
|
|
|
return 0;
|
|
|
|
MAGIC_CHECK_END();
|
|
|
|
if (obj->delete_me) return 0;
|
|
|
|
return obj->cur.anti_alias;
|
|
|
|
}
|
|
|
|
|
2008-09-09 07:14:26 -07:00
|
|
|
/**
|
|
|
|
* Sets the scaling factor for an evas object. Does not affect all objects.
|
2009-09-17 15:38:10 -07:00
|
|
|
*
|
2008-09-09 07:14:26 -07:00
|
|
|
* @param obj The given evas object.
|
2009-09-17 15:38:10 -07:00
|
|
|
* @param scale The scaling factor. 1.0 == none.
|
2008-09-09 07:14:26 -07:00
|
|
|
* @ingroup Evas_Object_Group
|
|
|
|
*/
|
|
|
|
EAPI void
|
|
|
|
evas_object_scale_set(Evas_Object *obj, double scale)
|
|
|
|
{
|
|
|
|
MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ);
|
|
|
|
return;
|
|
|
|
MAGIC_CHECK_END();
|
|
|
|
if (obj->delete_me) return;
|
|
|
|
if (obj->cur.scale == scale)
|
|
|
|
return;
|
|
|
|
obj->cur.scale = scale;
|
|
|
|
evas_object_change(obj);
|
2008-11-15 02:39:46 -08:00
|
|
|
if (obj->func->scale_update) obj->func->scale_update(obj);
|
2008-09-09 07:14:26 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Retrieves the scaling factor for the given evas object.
|
|
|
|
* @param obj The given evas object.
|
|
|
|
* @return The scaling factor.
|
2009-09-17 15:38:10 -07:00
|
|
|
*
|
2008-09-09 07:14:26 -07:00
|
|
|
* @ingroup Evas_Object_Group
|
|
|
|
*/
|
|
|
|
EAPI double
|
|
|
|
evas_object_scale_get(const Evas_Object *obj)
|
|
|
|
{
|
|
|
|
MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ);
|
|
|
|
return 0;
|
|
|
|
MAGIC_CHECK_END();
|
|
|
|
if (obj->delete_me) return 1.0;
|
|
|
|
return obj->cur.scale;
|
|
|
|
}
|
|
|
|
|
2005-12-03 01:27:53 -08:00
|
|
|
/**
|
|
|
|
* Sets the color_space to be used for linear interpolation of colors.
|
2009-09-17 15:38:10 -07:00
|
|
|
*
|
2005-12-03 01:27:53 -08:00
|
|
|
* @param obj The given evas object.
|
2009-09-17 15:38:10 -07:00
|
|
|
* @param color_space one of EVAS_COLOR_SPACE_ARGB or EVAS_COLOR_SPACE_AHSV.
|
|
|
|
*
|
2005-12-03 01:27:53 -08:00
|
|
|
* @ingroup Evas_Object_Group
|
|
|
|
*/
|
2006-01-06 15:05:17 -08:00
|
|
|
EAPI void
|
2005-12-03 01:27:53 -08:00
|
|
|
evas_object_color_interpolation_set(Evas_Object *obj, int color_space)
|
|
|
|
{
|
|
|
|
MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ);
|
|
|
|
return;
|
|
|
|
MAGIC_CHECK_END();
|
|
|
|
if (obj->delete_me) return;
|
2008-04-30 21:14:08 -07:00
|
|
|
if (obj->cur.interpolation_color_space == color_space)
|
2009-09-03 22:13:19 -07:00
|
|
|
return;
|
2008-04-30 21:14:08 -07:00
|
|
|
obj->cur.interpolation_color_space = color_space;
|
2006-05-02 00:28:49 -07:00
|
|
|
evas_object_change(obj);
|
2005-12-03 01:27:53 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Retrieves the current value of the color space used for linear interpolation.
|
|
|
|
* @param obj The given evas object.
|
|
|
|
* @return @c EVAS_COLOR_SPACE_ARGB or EVAS_COLOR_SPACE_AHSV.
|
|
|
|
* @ingroup Evas_Object_Group
|
|
|
|
*/
|
2006-01-06 15:05:17 -08:00
|
|
|
EAPI int
|
2008-02-08 14:35:19 -08:00
|
|
|
evas_object_color_interpolation_get(const Evas_Object *obj)
|
2005-12-03 01:27:53 -08:00
|
|
|
{
|
|
|
|
MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ);
|
|
|
|
return 0;
|
|
|
|
MAGIC_CHECK_END();
|
|
|
|
if (obj->delete_me) return 0;
|
2008-04-30 21:14:08 -07:00
|
|
|
return obj->cur.interpolation_color_space;
|
2005-12-03 01:27:53 -08:00
|
|
|
}
|
|
|
|
|
2006-05-02 00:28:49 -07:00
|
|
|
/**
|
|
|
|
* Sets the render_op to be used for rendering the evas object.
|
|
|
|
* @param obj The given evas object.
|
|
|
|
* @param render_op one of the Evas_Render_Op values.
|
|
|
|
* @ingroup Evas_Object_Group
|
|
|
|
*/
|
|
|
|
EAPI void
|
|
|
|
evas_object_render_op_set(Evas_Object *obj, Evas_Render_Op render_op)
|
|
|
|
{
|
|
|
|
MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ);
|
|
|
|
return;
|
|
|
|
MAGIC_CHECK_END();
|
|
|
|
if (obj->delete_me) return;
|
2006-08-12 07:46:15 -07:00
|
|
|
if ((Evas_Render_Op)obj->cur.render_op == render_op)
|
2009-09-03 22:13:19 -07:00
|
|
|
return;
|
2006-05-02 00:28:49 -07:00
|
|
|
obj->cur.render_op = render_op;
|
|
|
|
evas_object_change(obj);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Retrieves the current value of the operation used for rendering the evas object.
|
|
|
|
* @param obj The given evas object.
|
|
|
|
* @return one of the enumerated values in Evas_Render_Op.
|
|
|
|
* @ingroup Evas_Object_Group
|
|
|
|
*/
|
|
|
|
EAPI Evas_Render_Op
|
2008-02-08 14:35:19 -08:00
|
|
|
evas_object_render_op_get(const Evas_Object *obj)
|
2006-05-02 00:28:49 -07:00
|
|
|
{
|
|
|
|
MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ);
|
|
|
|
return 0;
|
|
|
|
MAGIC_CHECK_END();
|
|
|
|
if (obj->delete_me) return EVAS_RENDER_BLEND;
|
|
|
|
return obj->cur.render_op;
|
|
|
|
}
|
|
|
|
|
2003-03-04 18:30:20 -08:00
|
|
|
/**
|
2004-08-15 22:13:25 -07:00
|
|
|
* Retrieves the evas that the given evas object is on.
|
|
|
|
* @param obj The given evas object.
|
|
|
|
* @return The evas that the object is on.
|
|
|
|
* @ingroup Evas_Object_Group
|
2003-03-04 18:30:20 -08:00
|
|
|
*/
|
2006-01-06 15:05:17 -08:00
|
|
|
EAPI Evas *
|
2008-02-08 14:35:19 -08:00
|
|
|
evas_object_evas_get(const Evas_Object *obj)
|
2002-11-08 00:02:15 -08:00
|
|
|
{
|
|
|
|
MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ);
|
|
|
|
return NULL;
|
|
|
|
MAGIC_CHECK_END();
|
2009-08-24 03:52:40 -07:00
|
|
|
if (obj->delete_me) return NULL;
|
2002-11-08 00:02:15 -08:00
|
|
|
return obj->layer->evas;
|
|
|
|
}
|
|
|
|
|
2004-08-15 22:13:25 -07:00
|
|
|
/**
|
2008-11-01 15:21:10 -07:00
|
|
|
* @addtogroup Evas_Object_Group
|
2008-11-01 14:50:36 -07:00
|
|
|
* @{
|
|
|
|
*/
|
|
|
|
|
2003-03-04 18:30:20 -08:00
|
|
|
/**
|
2009-09-17 15:38:10 -07:00
|
|
|
* Retrieves the top object at the given position (x,y)
|
|
|
|
* @param e The given evas object.
|
|
|
|
* @param x The horizontal coordinate
|
|
|
|
* @param y The vertical coordinate
|
|
|
|
* @param include_pass_events_objects Boolean Flag to include or not
|
|
|
|
* pass events objects
|
|
|
|
* @param include_hidden_objects Boolean Flag to include or not hidden objects
|
|
|
|
* @return The evas object that is over all others objects at the given position.
|
2003-03-04 18:30:20 -08:00
|
|
|
*/
|
2006-01-06 15:05:17 -08:00
|
|
|
EAPI Evas_Object *
|
2009-06-17 03:01:52 -07:00
|
|
|
evas_object_top_at_xy_get(const Evas *e, Evas_Coord x, Evas_Coord y, Eina_Bool include_pass_events_objects, Eina_Bool include_hidden_objects)
|
2002-11-08 00:02:15 -08:00
|
|
|
{
|
2008-10-17 04:23:18 -07:00
|
|
|
Evas_Layer *lay;
|
2002-11-08 00:02:15 -08:00
|
|
|
int xx, yy;
|
2005-05-21 19:49:50 -07:00
|
|
|
|
2002-11-08 00:02:15 -08:00
|
|
|
MAGIC_CHECK(e, Evas, MAGIC_EVAS);
|
|
|
|
return NULL;
|
|
|
|
MAGIC_CHECK_END();
|
2006-11-15 19:20:24 -08:00
|
|
|
xx = x;
|
|
|
|
yy = y;
|
|
|
|
//// xx = evas_coord_world_x_to_screen(e, x);
|
|
|
|
//// yy = evas_coord_world_y_to_screen(e, y);
|
2008-10-21 05:19:57 -07:00
|
|
|
EINA_INLIST_REVERSE_FOREACH((EINA_INLIST_GET(e->layers)), lay)
|
2002-11-08 00:02:15 -08:00
|
|
|
{
|
2008-10-17 04:23:18 -07:00
|
|
|
Evas_Object *obj;
|
2005-05-21 19:49:50 -07:00
|
|
|
|
2008-10-21 05:19:57 -07:00
|
|
|
EINA_INLIST_REVERSE_FOREACH(get_layer_objects_last(lay), obj)
|
2002-11-08 00:02:15 -08:00
|
|
|
{
|
2004-03-07 18:42:08 -08:00
|
|
|
if (obj->delete_me) continue;
|
2004-06-13 23:04:22 -07:00
|
|
|
if ((!include_pass_events_objects) && (evas_event_passes_through(obj))) continue;
|
2002-11-08 00:02:15 -08:00
|
|
|
if ((!include_hidden_objects) && (!obj->cur.visible)) continue;
|
|
|
|
evas_object_clip_recalc(obj);
|
|
|
|
if ((evas_object_is_in_output_rect(obj, xx, yy, 1, 1)) &&
|
|
|
|
(!obj->clip.clipees))
|
|
|
|
return obj;
|
|
|
|
}
|
2005-05-21 19:49:50 -07:00
|
|
|
}
|
2002-11-08 00:02:15 -08:00
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2003-03-04 18:30:20 -08:00
|
|
|
/**
|
2009-09-17 15:38:10 -07:00
|
|
|
* Retrieves the top object at mouse pointer position
|
|
|
|
* @param e The given evas object.
|
|
|
|
* @return The evas object that is over all others objects at the
|
|
|
|
* pointer position.
|
2003-03-04 18:30:20 -08:00
|
|
|
*/
|
2006-01-06 15:05:17 -08:00
|
|
|
EAPI Evas_Object *
|
2008-02-08 13:42:01 -08:00
|
|
|
evas_object_top_at_pointer_get(const Evas *e)
|
2002-11-08 00:02:15 -08:00
|
|
|
{
|
2006-11-15 19:20:24 -08:00
|
|
|
//// return evas_object_top_at_xy_get(e, e->pointer.canvas_x, e->pointer.canvas_y, 0, 0);
|
|
|
|
return evas_object_top_at_xy_get(e, e->pointer.x, e->pointer.y, 1, 1);
|
2002-11-08 00:02:15 -08:00
|
|
|
}
|
|
|
|
|
2003-03-04 18:30:20 -08:00
|
|
|
/**
|
2009-09-17 15:38:10 -07:00
|
|
|
* Retrieves the top object in the given rectangle region
|
|
|
|
* @param e The given evas object.
|
|
|
|
* @param x The horizontal coordinate.
|
|
|
|
* @param y The vertical coordinate.
|
|
|
|
* @param w The width size.
|
|
|
|
* @param h The height size.
|
|
|
|
* @param include_pass_events_objects Boolean Flag to include or not pass events objects
|
|
|
|
* @param include_hidden_objects Boolean Flag to include or not hidden objects
|
|
|
|
* @return The evas object that is over all others objects at the pointer position.
|
2003-03-04 18:30:20 -08:00
|
|
|
*
|
|
|
|
*/
|
2006-01-06 15:05:17 -08:00
|
|
|
EAPI Evas_Object *
|
2009-06-17 03:01:52 -07:00
|
|
|
evas_object_top_in_rectangle_get(const Evas *e, Evas_Coord x, Evas_Coord y, Evas_Coord w, Evas_Coord h, Eina_Bool include_pass_events_objects, Eina_Bool include_hidden_objects)
|
2002-11-08 00:02:15 -08:00
|
|
|
{
|
2008-10-17 04:23:18 -07:00
|
|
|
Evas_Layer *lay;
|
2002-11-08 00:02:15 -08:00
|
|
|
int xx, yy, ww, hh;
|
2005-05-21 19:49:50 -07:00
|
|
|
|
2002-11-08 00:02:15 -08:00
|
|
|
MAGIC_CHECK(e, Evas, MAGIC_EVAS);
|
|
|
|
return NULL;
|
|
|
|
MAGIC_CHECK_END();
|
2006-11-15 19:20:24 -08:00
|
|
|
xx = x;
|
|
|
|
yy = y;
|
|
|
|
ww = w;
|
|
|
|
hh = h;
|
|
|
|
//// xx = evas_coord_world_x_to_screen(e, x);
|
|
|
|
//// yy = evas_coord_world_y_to_screen(e, y);
|
|
|
|
//// ww = evas_coord_world_x_to_screen(e, w);
|
|
|
|
//// hh = evas_coord_world_y_to_screen(e, h);
|
2002-11-08 00:02:15 -08:00
|
|
|
if (ww < 1) ww = 1;
|
|
|
|
if (hh < 1) hh = 1;
|
2008-10-21 05:19:57 -07:00
|
|
|
EINA_INLIST_REVERSE_FOREACH((EINA_INLIST_GET(e->layers)), lay)
|
2002-11-08 00:02:15 -08:00
|
|
|
{
|
2008-10-17 04:23:18 -07:00
|
|
|
Evas_Object *obj;
|
2005-05-21 19:49:50 -07:00
|
|
|
|
2008-10-21 05:19:57 -07:00
|
|
|
EINA_INLIST_REVERSE_FOREACH(get_layer_objects_last(lay), obj)
|
2002-11-08 00:02:15 -08:00
|
|
|
{
|
2004-03-07 18:42:08 -08:00
|
|
|
if (obj->delete_me) continue;
|
2004-06-13 23:04:22 -07:00
|
|
|
if ((!include_pass_events_objects) && (evas_event_passes_through(obj))) continue;
|
2002-11-08 00:02:15 -08:00
|
|
|
if ((!include_hidden_objects) && (!obj->cur.visible)) continue;
|
|
|
|
evas_object_clip_recalc(obj);
|
|
|
|
if ((evas_object_is_in_output_rect(obj, xx, yy, ww, hh)) &&
|
|
|
|
(!obj->clip.clipees))
|
|
|
|
return obj;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2003-03-04 18:30:20 -08:00
|
|
|
/**
|
2009-09-17 15:38:10 -07:00
|
|
|
* Retrieves the objects at the given position
|
|
|
|
* @param e The given evas object.
|
|
|
|
* @param x The horizontal coordinate.
|
|
|
|
* @param y The vertical coordinate.
|
|
|
|
* @param include_pass_events_objects Boolean Flag to include or not
|
|
|
|
* pass events objects
|
|
|
|
* @param include_hidden_objects Boolean Flag to include or not hidden objects
|
|
|
|
* @return The list of evas objects at the pointer position.
|
2003-03-04 18:30:20 -08:00
|
|
|
*
|
|
|
|
*/
|
2008-10-21 09:31:05 -07:00
|
|
|
EAPI Eina_List *
|
2009-06-17 03:01:52 -07:00
|
|
|
evas_objects_at_xy_get(const Evas *e, Evas_Coord x, Evas_Coord y, Eina_Bool include_pass_events_objects, Eina_Bool include_hidden_objects)
|
2002-11-08 00:02:15 -08:00
|
|
|
{
|
2008-10-21 09:31:05 -07:00
|
|
|
Eina_List *in = NULL;
|
2008-10-17 04:23:18 -07:00
|
|
|
Evas_Layer *lay;
|
2002-11-08 00:02:15 -08:00
|
|
|
int xx, yy;
|
2005-05-21 19:49:50 -07:00
|
|
|
|
2002-11-08 00:02:15 -08:00
|
|
|
MAGIC_CHECK(e, Evas, MAGIC_EVAS);
|
|
|
|
return NULL;
|
|
|
|
MAGIC_CHECK_END();
|
2006-11-15 19:20:24 -08:00
|
|
|
xx = x;
|
|
|
|
yy = y;
|
|
|
|
//// xx = evas_coord_world_x_to_screen(e, x);
|
|
|
|
//// yy = evas_coord_world_y_to_screen(e, y);
|
2008-10-21 05:19:57 -07:00
|
|
|
EINA_INLIST_REVERSE_FOREACH((EINA_INLIST_GET(e->layers)), lay)
|
2002-11-08 00:02:15 -08:00
|
|
|
{
|
2008-10-17 04:23:18 -07:00
|
|
|
Evas_Object *obj;
|
2005-05-21 19:49:50 -07:00
|
|
|
|
2008-10-21 05:19:57 -07:00
|
|
|
EINA_INLIST_REVERSE_FOREACH(get_layer_objects_last(lay), obj)
|
2002-11-08 00:02:15 -08:00
|
|
|
{
|
2004-03-07 18:42:08 -08:00
|
|
|
if (obj->delete_me) continue;
|
2004-06-13 23:04:22 -07:00
|
|
|
if ((!include_pass_events_objects) && (evas_event_passes_through(obj))) continue;
|
2002-11-08 00:02:15 -08:00
|
|
|
if ((!include_hidden_objects) && (!obj->cur.visible)) continue;
|
|
|
|
evas_object_clip_recalc(obj);
|
|
|
|
if ((evas_object_is_in_output_rect(obj, xx, yy, 1, 1)) &&
|
|
|
|
(!obj->clip.clipees))
|
2008-10-21 09:31:05 -07:00
|
|
|
in = eina_list_prepend(in, obj);
|
2002-11-08 00:02:15 -08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
return in;
|
|
|
|
}
|
|
|
|
|
2003-03-04 18:30:20 -08:00
|
|
|
/**
|
|
|
|
* To be documented.
|
|
|
|
*
|
|
|
|
* FIXME: To be fixed.
|
|
|
|
*/
|
2009-09-17 15:38:10 -07:00
|
|
|
/**
|
|
|
|
* Retrieves the objects in the given rectangle region
|
|
|
|
* @param e The given evas object.
|
|
|
|
* @param x The horizontal coordinate.
|
|
|
|
* @param y The vertical coordinate.
|
|
|
|
* @param w The width size.
|
|
|
|
* @param h The height size.
|
|
|
|
* @param include_pass_events_objects Boolean Flag to include or not pass events objects
|
|
|
|
* @param include_hidden_objects Boolean Flag to include or not hidden objects
|
|
|
|
* @return The list of evas object in the rectangle region.
|
|
|
|
*
|
|
|
|
*/
|
2008-10-21 09:31:05 -07:00
|
|
|
EAPI Eina_List *
|
2009-06-17 03:01:52 -07:00
|
|
|
evas_objects_in_rectangle_get(const Evas *e, Evas_Coord x, Evas_Coord y, Evas_Coord w, Evas_Coord h, Eina_Bool include_pass_events_objects, Eina_Bool include_hidden_objects)
|
2002-11-08 00:02:15 -08:00
|
|
|
{
|
2008-10-21 09:31:05 -07:00
|
|
|
Eina_List *in = NULL;
|
2008-10-17 04:23:18 -07:00
|
|
|
Evas_Layer *lay;
|
2002-11-08 00:02:15 -08:00
|
|
|
int xx, yy, ww, hh;
|
2005-05-21 19:49:50 -07:00
|
|
|
|
2002-11-08 00:02:15 -08:00
|
|
|
MAGIC_CHECK(e, Evas, MAGIC_EVAS);
|
|
|
|
return NULL;
|
|
|
|
MAGIC_CHECK_END();
|
2006-11-15 19:20:24 -08:00
|
|
|
xx = x;
|
|
|
|
yy = y;
|
2008-10-17 04:23:18 -07:00
|
|
|
ww = w;
|
2006-11-15 19:20:24 -08:00
|
|
|
hh = h;
|
|
|
|
//// xx = evas_coord_world_x_to_screen(e, x);
|
|
|
|
//// yy = evas_coord_world_y_to_screen(e, y);
|
|
|
|
//// ww = evas_coord_world_x_to_screen(e, w);
|
|
|
|
//// hh = evas_coord_world_y_to_screen(e, h);
|
2002-11-08 00:02:15 -08:00
|
|
|
if (ww < 1) ww = 1;
|
|
|
|
if (hh < 1) hh = 1;
|
2008-10-21 05:19:57 -07:00
|
|
|
EINA_INLIST_REVERSE_FOREACH((EINA_INLIST_GET(e->layers)), lay)
|
2002-11-08 00:02:15 -08:00
|
|
|
{
|
2008-10-17 04:23:18 -07:00
|
|
|
Evas_Object *obj;
|
2005-05-21 19:49:50 -07:00
|
|
|
|
2009-11-26 06:56:46 -08:00
|
|
|
EINA_INLIST_FOREACH(get_layer_objects_last(lay), obj)
|
2002-11-08 00:02:15 -08:00
|
|
|
{
|
2004-03-07 18:42:08 -08:00
|
|
|
if (obj->delete_me) continue;
|
2004-06-13 23:04:22 -07:00
|
|
|
if ((!include_pass_events_objects) && (evas_event_passes_through(obj))) continue;
|
2002-11-08 00:02:15 -08:00
|
|
|
if ((!include_hidden_objects) && (!obj->cur.visible)) continue;
|
|
|
|
evas_object_clip_recalc(obj);
|
|
|
|
if ((evas_object_is_in_output_rect(obj, xx, yy, ww, hh)) &&
|
|
|
|
(!obj->clip.clipees))
|
2008-10-21 09:31:05 -07:00
|
|
|
in = eina_list_prepend(in, obj);
|
2002-11-08 00:02:15 -08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
return in;
|
|
|
|
}
|
|
|
|
|
2003-03-04 18:30:20 -08:00
|
|
|
/**
|
2004-08-15 22:13:25 -07:00
|
|
|
* Retrieves the name of the type of the given evas object.
|
|
|
|
* @param obj The given object.
|
|
|
|
* @return The name.
|
2003-03-04 18:30:20 -08:00
|
|
|
*/
|
2006-01-06 15:05:17 -08:00
|
|
|
EAPI const char *
|
2008-02-08 14:35:19 -08:00
|
|
|
evas_object_type_get(const Evas_Object *obj)
|
2002-11-08 00:02:15 -08:00
|
|
|
{
|
|
|
|
MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ);
|
|
|
|
return NULL;
|
|
|
|
MAGIC_CHECK_END();
|
2004-03-07 18:42:08 -08:00
|
|
|
if (obj->delete_me) return "";
|
2002-11-08 00:02:15 -08:00
|
|
|
return obj->type;
|
|
|
|
}
|
2007-07-23 07:22:57 -07:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Set whether to use a precise (usually expensive) point collision detection.
|
|
|
|
* @param obj The given object.
|
|
|
|
* @param precise wheter to use a precise point collision detection or not
|
|
|
|
* The default value is false.
|
|
|
|
*/
|
|
|
|
EAPI void
|
2009-06-17 03:01:52 -07:00
|
|
|
evas_object_precise_is_inside_set(Evas_Object *obj, Eina_Bool precise)
|
2007-07-23 07:22:57 -07:00
|
|
|
{
|
|
|
|
MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ);
|
|
|
|
return;
|
|
|
|
MAGIC_CHECK_END();
|
|
|
|
obj->precise_is_inside = precise;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Determine whether an object is set to use a precise point collision detection.
|
|
|
|
* @param obj The given object.
|
|
|
|
*/
|
2009-06-17 03:01:52 -07:00
|
|
|
EAPI Eina_Bool
|
2008-02-08 14:35:19 -08:00
|
|
|
evas_object_precise_is_inside_get(const Evas_Object *obj)
|
2007-07-23 07:22:57 -07:00
|
|
|
{
|
|
|
|
MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ);
|
|
|
|
return 0;
|
|
|
|
MAGIC_CHECK_END();
|
|
|
|
return obj->precise_is_inside;
|
|
|
|
}
|
2008-11-01 14:50:36 -07:00
|
|
|
|
|
|
|
/**
|
|
|
|
* @}
|
|
|
|
*/
|