forked from enlightenment/efl
1539 lines
56 KiB
Plaintext
1539 lines
56 KiB
Plaintext
abstract Evas.Object (Eo.Base, Evas.Common_Interface)
|
||
{
|
||
eo_prefix: evas_obj;
|
||
data: Evas_Object_Protected_Data;
|
||
properties {
|
||
size_hint_max {
|
||
set {
|
||
/*@
|
||
Sets the hints for an object's maximum size.
|
||
|
||
This is not a size enforcement in any way, it's just a hint that
|
||
should be used whenever appropriate.
|
||
|
||
Values @c -1 will be treated as unset hint components, when queried
|
||
by managers.
|
||
|
||
Example:
|
||
@dontinclude evas-hints.c
|
||
@skip evas_object_size_hint_max_set
|
||
@until return
|
||
|
||
In this example the maximum size hints change the behavior of an
|
||
Evas box when layouting its children. See the full @ref
|
||
Example_Evas_Size_Hints "example".
|
||
|
||
@see evas_object_size_hint_max_get() */
|
||
}
|
||
get {
|
||
/*@
|
||
Retrieves the hints for an object's maximum size.
|
||
|
||
These are hints on the maximum sizes @p obj should have. This is
|
||
not a size enforcement in any way, it's just a hint that should be
|
||
used whenever appropriate.
|
||
|
||
@note Use @c NULL pointers on the hint components you're not
|
||
interested in: they'll be ignored by the function.
|
||
|
||
@see evas_object_size_hint_max_set() */
|
||
}
|
||
values {
|
||
Evas_Coord w; /*@ Integer to use as the maximum width hint. */
|
||
Evas_Coord h; /*@ Integer to use as the maximum height hint. */
|
||
}
|
||
}
|
||
size_hint_request {
|
||
set {
|
||
/*@
|
||
Sets the hints for an object's optimum size.
|
||
|
||
This is not a size enforcement in any way, it's just a hint that
|
||
should be used whenever appropriate.
|
||
|
||
Values @c 0 will be treated as unset hint components, when queried
|
||
by managers.
|
||
|
||
@see evas_object_size_hint_request_get() */
|
||
}
|
||
get {
|
||
/*@
|
||
Retrieves the hints for an object's optimum size.
|
||
|
||
These are hints on the optimum sizes @p obj should have. This is
|
||
not a size enforcement in any way, it's just a hint that should be
|
||
used whenever appropriate.
|
||
|
||
@note Use @c NULL pointers on the hint components you're not
|
||
interested in: they'll be ignored by the function.
|
||
|
||
@see evas_object_size_hint_request_set() */
|
||
}
|
||
values {
|
||
Evas_Coord w; /*@ Integer to use as the preferred width hint. */
|
||
Evas_Coord h; /*@ Integer to use as the preferred height hint. */
|
||
}
|
||
}
|
||
visibility {
|
||
set {
|
||
/*@ Makes the given Evas object visible or invisible. */
|
||
legacy null;
|
||
}
|
||
get {
|
||
/*@ Retrieves whether or not the given Evas object is visible. */
|
||
legacy evas_object_visible_get;
|
||
}
|
||
values {
|
||
bool v; /*@ @c EINA_TRUE if to make the object visible, @c EINA_FALSE otherwise */
|
||
}
|
||
}
|
||
type {
|
||
set {
|
||
/*@ Sets the type of the given Evas object. */
|
||
legacy null;
|
||
}
|
||
get {
|
||
/*@
|
||
Retrieves the type of the given Evas object.
|
||
|
||
@return The type of the object.
|
||
|
||
For Evas' builtin types, the return strings will be one of:
|
||
- <c>"rectangle"</c>,
|
||
- <c>"line"</c>,
|
||
- <c>"polygon"</c>,
|
||
- <c>"text"</c>,
|
||
- <c>"textblock"</c> and
|
||
- <c>"image"</c>.
|
||
|
||
For Evas smart objects (see @ref Evas_Smart_Group), the name of the
|
||
smart class itself is returned on this call. For the built-in smart
|
||
objects, these names are:
|
||
- <c>"EvasObjectSmartClipped"</c>, for the clipped smart object
|
||
- <c>"Evas_Object_Box"</c>, for the box object and
|
||
- <c>"Evas_Object_Table"</c>, for the table object.
|
||
|
||
Example:
|
||
@dontinclude evas-object-manipulation.c
|
||
@skip d.img = evas_object_image_filled_add(d.canvas);
|
||
@until border on the
|
||
|
||
See the full @ref Example_Evas_Object_Manipulation "example". */
|
||
}
|
||
values {
|
||
const(char)* type; /*@ in */
|
||
}
|
||
}
|
||
size_hint_min {
|
||
set {
|
||
/*@
|
||
Sets the hints for an object's minimum size.
|
||
|
||
This is not a size enforcement in any way, it's just a hint that
|
||
should be used whenever appropriate.
|
||
|
||
Values @c 0 will be treated as unset hint components, when queried
|
||
by managers.
|
||
|
||
Example:
|
||
@dontinclude evas-hints.c
|
||
@skip evas_object_size_hint_min_set
|
||
@until return
|
||
|
||
In this example the minimum size hints change the behavior of an
|
||
Evas box when layouting its children. See the full @ref
|
||
Example_Evas_Size_Hints "example".
|
||
|
||
@see evas_object_size_hint_min_get() */
|
||
}
|
||
get {
|
||
/*@
|
||
Retrieves the hints for an object's minimum size.
|
||
|
||
These are hints on the minimum sizes @p obj should have. This is
|
||
not a size enforcement in any way, it's just a hint that should be
|
||
used whenever appropriate.
|
||
|
||
@note Use @c NULL pointers on the hint components you're not
|
||
interested in: they'll be ignored by the function.
|
||
|
||
@see evas_object_size_hint_min_set() for an example */
|
||
}
|
||
values {
|
||
Evas_Coord w; /*@ Integer to use as the minimum width hint. */
|
||
Evas_Coord h; /*@ Integer to use as the minimum height hint. */
|
||
}
|
||
}
|
||
pointer_mode {
|
||
set {
|
||
/*@
|
||
Set pointer behavior.
|
||
|
||
This function has direct effect on event callbacks related to
|
||
mouse.
|
||
|
||
If @p setting is EVAS_OBJECT_POINTER_MODE_AUTOGRAB, then when mouse
|
||
is down at this object, events will be restricted to it as source,
|
||
mouse moves, for example, will be emitted even if outside this
|
||
object area.
|
||
|
||
If @p setting is EVAS_OBJECT_POINTER_MODE_NOGRAB, then events will
|
||
be emitted just when inside this object area.
|
||
|
||
The default value is EVAS_OBJECT_POINTER_MODE_AUTOGRAB.
|
||
|
||
@ingroup Evas_Object_Group_Extras */
|
||
}
|
||
get {
|
||
/*@
|
||
Determine how pointer will behave.
|
||
@return pointer behavior.
|
||
@ingroup Evas_Object_Group_Extras */
|
||
}
|
||
values {
|
||
Evas_Object_Pointer_Mode pointer_mode; /*@ desired behavior. */
|
||
}
|
||
}
|
||
render_op {
|
||
set {
|
||
/*@
|
||
Sets the render_op to be used for rendering the Evas object.
|
||
@ingroup Evas_Object_Group_Extras */
|
||
}
|
||
get {
|
||
/*@
|
||
Retrieves the current value of the operation used for rendering the Evas object.
|
||
@return one of the enumerated values in Evas_Render_Op.
|
||
@ingroup Evas_Object_Group_Extras */
|
||
}
|
||
values {
|
||
Evas_Render_Op render_op; /*@ one of the Evas_Render_Op values. */
|
||
}
|
||
}
|
||
freeze_events {
|
||
set {
|
||
/*@
|
||
Set whether an Evas object is to freeze (discard) events.
|
||
|
||
If @p freeze is @c EINA_TRUE, it will make events on @p obj to be @b
|
||
discarded. Unlike evas_object_pass_events_set(), events will not be
|
||
passed to @b next lower object. This API can be used for blocking
|
||
events while @p obj is on transiting.
|
||
|
||
If @p freeze is @c EINA_FALSE, events will be processed on that
|
||
object as normal.
|
||
|
||
@warning If you block only key/mouse up events with this API, we won't
|
||
guarantee the state of the object, that only had key/mouse down
|
||
events, will be.
|
||
|
||
@see evas_object_freeze_events_get()
|
||
@see evas_object_pass_events_set()
|
||
@see evas_object_repeat_events_set()
|
||
@see evas_object_propagate_events_set()
|
||
@since 1.1 */
|
||
}
|
||
get {
|
||
/*@
|
||
Determine whether an object is set to freeze (discard) events.
|
||
|
||
@return freeze whether @p obj is set to freeze events (@c EINA_TRUE) or
|
||
not (@c EINA_FALSE)
|
||
|
||
@see evas_object_freeze_events_set()
|
||
@see evas_object_pass_events_get()
|
||
@see evas_object_repeat_events_get()
|
||
@see evas_object_propagate_events_get()
|
||
@since 1.1 */
|
||
}
|
||
values {
|
||
bool freeze; /*@ pass whether @p obj is to freeze events (@c EINA_TRUE) or not
|
||
(@c EINA_FALSE) */
|
||
}
|
||
}
|
||
map {
|
||
set {
|
||
/*@
|
||
Set current object transformation map.
|
||
|
||
This sets the map on a given object. It is copied from the @p map pointer,
|
||
so there is no need to keep the @p map object if you don't need it anymore.
|
||
|
||
A map is a set of 4 points which have canvas x, y coordinates per point,
|
||
with an optional z point value as a hint for perspective correction, if it
|
||
is available. As well each point has u and v coordinates. These are like
|
||
"texture coordinates" in OpenGL in that they define a point in the source
|
||
image that is mapped to that map vertex/point. The u corresponds to the x
|
||
coordinate of this mapped point and v, the y coordinate. Note that these
|
||
coordinates describe a bounding region to sample. If you have a 200x100
|
||
source image and want to display it at 200x100 with proper pixel
|
||
precision, then do:
|
||
|
||
@code
|
||
Evas_Map *m = evas_map_new(4);
|
||
evas_map_point_coord_set(m, 0, 0, 0, 0);
|
||
evas_map_point_coord_set(m, 1, 200, 0, 0);
|
||
evas_map_point_coord_set(m, 2, 200, 100, 0);
|
||
evas_map_point_coord_set(m, 3, 0, 100, 0);
|
||
evas_map_point_image_uv_set(m, 0, 0, 0);
|
||
evas_map_point_image_uv_set(m, 1, 200, 0);
|
||
evas_map_point_image_uv_set(m, 2, 200, 100);
|
||
evas_map_point_image_uv_set(m, 3, 0, 100);
|
||
evas_object_map_set(obj, m);
|
||
evas_map_free(m);
|
||
@endcode
|
||
|
||
Note that the map points a uv coordinates match the image geometry. If
|
||
the @p map parameter is NULL, the stored map will be freed and geometry
|
||
prior to enabling/setting a map will be restored.
|
||
|
||
@see evas_map_new() */
|
||
}
|
||
get {
|
||
/*@
|
||
Get current object transformation map.
|
||
|
||
This returns the current internal map set on the indicated object. It is
|
||
intended for read-only access and is only valid as long as the object is
|
||
not deleted or the map on the object is not changed. If you wish to modify
|
||
the map and set it back do the following:
|
||
|
||
@code
|
||
const Evas_Map *m = evas_object_map_get(obj);
|
||
Evas_Map *m2 = evas_map_dup(m);
|
||
evas_map_util_rotate(m2, 30.0, 0, 0);
|
||
evas_object_map_set(obj, m2);
|
||
evas_map_free(m2);
|
||
@endcode
|
||
|
||
@return map reference to map in use. This is an internal data structure, so
|
||
do not modify it.
|
||
|
||
@see evas_object_map_set() */
|
||
}
|
||
values {
|
||
const(Evas_Map)* map; /*@ new map to use */
|
||
}
|
||
}
|
||
size_hint_aspect {
|
||
set {
|
||
/*@
|
||
Sets the hints for an object's aspect ratio.
|
||
|
||
This is not a size enforcement in any way, it's just a hint that should
|
||
be used whenever appropriate.
|
||
|
||
If any of the given aspect ratio terms are @c 0,
|
||
the object's container will ignore the aspect and scale @p obj to
|
||
occupy the whole available area, for any given policy.
|
||
|
||
@see evas_object_size_hint_aspect_get() for more information. */
|
||
}
|
||
get {
|
||
/*@
|
||
Retrieves the hints for an object's aspect ratio.
|
||
|
||
The different aspect ratio policies are documented in the
|
||
#Evas_Aspect_Control type. A container respecting these size hints
|
||
would @b resize its children accordingly to those policies.
|
||
|
||
For any policy, if any of the given aspect ratio terms are @c 0,
|
||
the object's container should ignore the aspect and scale @p obj to
|
||
occupy the whole available area. If they are both positive
|
||
integers, that proportion will be respected, under each scaling
|
||
policy.
|
||
|
||
These images illustrate some of the #Evas_Aspect_Control policies:
|
||
|
||
@image html any-policy.png
|
||
@image rtf any-policy.png
|
||
@image latex any-policy.eps
|
||
|
||
@image html aspect-control-none-neither.png
|
||
@image rtf aspect-control-none-neither.png
|
||
@image latex aspect-control-none-neither.eps
|
||
|
||
@image html aspect-control-both.png
|
||
@image rtf aspect-control-both.png
|
||
@image latex aspect-control-both.eps
|
||
|
||
@image html aspect-control-horizontal.png
|
||
@image rtf aspect-control-horizontal.png
|
||
@image latex aspect-control-horizontal.eps
|
||
|
||
This is not a size enforcement in any way, it's just a hint that
|
||
should be used whenever appropriate.
|
||
|
||
@note Use @c NULL pointers on the hint components you're not
|
||
interested in: they'll be ignored by the function.
|
||
|
||
Example:
|
||
@dontinclude evas-aspect-hints.c
|
||
@skip if (strcmp(ev->key, "c") == 0)
|
||
@until }
|
||
|
||
See the full @ref Example_Evas_Aspect_Hints "example".
|
||
|
||
@see evas_object_size_hint_aspect_set() */
|
||
}
|
||
values {
|
||
Evas_Aspect_Control aspect; /*@ The policy/type of aspect ratio to apply to @p obj. */
|
||
Evas_Coord w; /*@ Integer to use as aspect width ratio term. */
|
||
Evas_Coord h; /*@ Integer to use as aspect height ratio term. */
|
||
}
|
||
}
|
||
layer {
|
||
set {
|
||
/*@
|
||
Sets the layer of its canvas that the given object will be part of.
|
||
|
||
If you don't use this function, you'll be dealing with an @b unique
|
||
layer of objects, the default one. Additional layers are handy when
|
||
you don't want a set of objects to interfere with another set with
|
||
regard to @b stacking. Two layers are completely disjoint in that
|
||
matter.
|
||
|
||
This is a low-level function, which you'd be using when something
|
||
should be always on top, for example.
|
||
|
||
@warning Be careful, it doesn't make sense to change the layer of
|
||
smart objects' children. Smart objects have a layer of their own,
|
||
which should contain all their children objects.
|
||
|
||
@see evas_object_layer_get() */
|
||
}
|
||
get {
|
||
/*@
|
||
Retrieves the layer of its canvas that the given object is part of.
|
||
|
||
@return Number of its layer
|
||
|
||
@see evas_object_layer_set() */
|
||
}
|
||
values {
|
||
short l; /*@ The number of the layer to place the object on.
|
||
Must be between #EVAS_LAYER_MIN and #EVAS_LAYER_MAX. */
|
||
}
|
||
}
|
||
clip {
|
||
set {
|
||
/*@
|
||
Clip one object to another.
|
||
|
||
This function will clip the object @p obj to the area occupied by
|
||
the object @p clip. This means the object @p obj will only be
|
||
visible within the area occupied by the clipping object (@p clip).
|
||
|
||
The color of the object being clipped will be multiplied by the
|
||
color of the clipping one, so the resulting color for the former
|
||
will be <code>RESULT = (OBJ * CLIP) / (255 * 255)</code>, per color
|
||
element (red, green, blue and alpha).
|
||
|
||
Clipping is recursive, so clipping objects may be clipped by
|
||
others, and their color will in term be multiplied. You may @b not
|
||
set up circular clipping lists (i.e. object 1 clips object 2, which
|
||
clips object 1): the behavior of Evas is undefined in this case.
|
||
|
||
Objects which do not clip others are visible in the canvas as
|
||
normal; <b>those that clip one or more objects become invisible
|
||
themselves</b>, only affecting what they clip. If an object ceases
|
||
to have other objects being clipped by it, it will become visible
|
||
again.
|
||
|
||
The visibility of an object affects the objects that are clipped by
|
||
it, so if the object clipping others is not shown (as in
|
||
evas_object_show()), the objects clipped by it will not be shown
|
||
either.
|
||
|
||
If @p obj was being clipped by another object when this function is
|
||
called, it gets implicitly removed from the old clipper's domain
|
||
and is made now to be clipped by its new clipper.
|
||
|
||
The following figure illustrates some clipping in Evas:
|
||
|
||
@image html clipping.png
|
||
@image rtf clipping.png
|
||
@image latex clipping.eps
|
||
|
||
@note At the moment the <b>only objects that can validly be used to
|
||
clip other objects are rectangle objects</b>. All other object
|
||
types are invalid and the result of using them is undefined. The
|
||
clip object @p clip must be a valid object, but can also be @c
|
||
NULL, in which case the effect of this function is the same as
|
||
calling evas_object_clip_unset() on the @p obj object.
|
||
|
||
Example:
|
||
@dontinclude evas-object-manipulation.c
|
||
@skip solid white clipper (note that it's the default color for a
|
||
@until evas_object_show(d.clipper);
|
||
|
||
See the full @ref Example_Evas_Object_Manipulation "example". */
|
||
}
|
||
get {
|
||
/*@
|
||
Get the object clipping @p obj (if any).
|
||
|
||
This function returns the object clipping @p obj. If @p obj is
|
||
not being clipped at all, @c NULL is returned. The object @p obj
|
||
must be a valid .Evas_Object.
|
||
|
||
See also evas_object_clip_set(), evas_object_clip_unset() and
|
||
evas_object_clipees_get().
|
||
|
||
Example:
|
||
@dontinclude evas-object-manipulation.c
|
||
@skip if (evas_object_clip_get(d.img) == d.clipper)
|
||
@until return
|
||
|
||
See the full @ref Example_Evas_Object_Manipulation "example". */
|
||
}
|
||
values {
|
||
Evas_Object *clip @nonull; /*@ The object to clip @p obj by */
|
||
}
|
||
}
|
||
size_hint_padding {
|
||
set {
|
||
/*@
|
||
Sets the hints for an object's padding space.
|
||
|
||
This is not a size enforcement in any way, it's just a hint that
|
||
should be used whenever appropriate.
|
||
|
||
@see evas_object_size_hint_padding_get() for more information */
|
||
}
|
||
get {
|
||
/*@
|
||
Retrieves the hints for an object's padding space.
|
||
|
||
Padding is extra space an object takes on each of its delimiting
|
||
rectangle sides, in canvas units. This space will be rendered
|
||
transparent, naturally, as in the following figure:
|
||
|
||
@image html padding-hints.png
|
||
@image rtf padding-hints.png
|
||
@image latex padding-hints.eps
|
||
|
||
This is not a size enforcement in any way, it's just a hint that
|
||
should be used whenever appropriate.
|
||
|
||
@note Use @c NULL pointers on the hint components you're not
|
||
interested in: they'll be ignored by the function.
|
||
|
||
Example:
|
||
@dontinclude evas-hints.c
|
||
@skip evas_object_size_hint_padding_set
|
||
@until return
|
||
|
||
In this example the padding hints change the behavior of an Evas box
|
||
when layouting its children. See the full @ref
|
||
Example_Evas_Size_Hints "example".
|
||
|
||
@see evas_object_size_hint_padding_set() */
|
||
}
|
||
values {
|
||
Evas_Coord l; /*@ Integer to specify left padding. */
|
||
Evas_Coord r; /*@ Integer to specify right padding. */
|
||
Evas_Coord t; /*@ Integer to specify top padding. */
|
||
Evas_Coord b; /*@ Integer to specify bottom padding. */
|
||
}
|
||
}
|
||
repeat_events {
|
||
set {
|
||
/*@
|
||
Set whether an Evas object is to repeat events.
|
||
|
||
If @p repeat is @c EINA_TRUE, it will make events on @p obj to also
|
||
be repeated for the @b next lower object in the objects' stack (see
|
||
see evas_object_below_get()).
|
||
|
||
If @p repeat is @c EINA_FALSE, events occurring on @p obj will be
|
||
processed only on it.
|
||
|
||
Example:
|
||
@dontinclude evas-stacking.c
|
||
@skip if (strcmp(ev->key, "r") == 0)
|
||
@until }
|
||
|
||
See the full @ref Example_Evas_Stacking "example".
|
||
|
||
@see evas_object_repeat_events_get()
|
||
@see evas_object_pass_events_set()
|
||
@see evas_object_propagate_events_set()
|
||
@see evas_object_freeze_events_set() */
|
||
}
|
||
get {
|
||
/*@
|
||
Determine whether an object is set to repeat events.
|
||
|
||
@return whether @p obj is set to repeat events (@c EINA_TRUE)
|
||
or not (@c EINA_FALSE)
|
||
|
||
@see evas_object_repeat_events_set() for an example
|
||
@see evas_object_pass_events_get()
|
||
@see evas_object_propagate_events_get()
|
||
@see evas_object_freeze_events_get() */
|
||
}
|
||
values {
|
||
bool repeat; /*@ whether @p obj is to repeat events (@c EINA_TRUE) or not
|
||
(@c EINA_FALSE) */
|
||
}
|
||
}
|
||
size_hint_weight {
|
||
set {
|
||
/*@
|
||
Sets the hints for an object's weight.
|
||
|
||
This is not a size enforcement in any way, it's just a hint that
|
||
should be used whenever appropriate.
|
||
|
||
This is a hint on how a container object should @b resize a given
|
||
child within its area. Containers may adhere to the simpler logic
|
||
of just expanding the child object's dimensions to fit its own (see
|
||
the #EVAS_HINT_EXPAND helper weight macro) or the complete one of
|
||
taking each child's weight hint as real @b weights to how much of
|
||
its size to allocate for them in each axis. A container is supposed
|
||
to, after @b normalizing the weights of its children (with weight
|
||
hints), distribute the space it has to layout them by those factors
|
||
-- most weighted children get larger in this process than the least
|
||
ones.
|
||
|
||
Example:
|
||
@dontinclude evas-hints.c
|
||
@skip evas_object_size_hint_weight_set
|
||
@until return
|
||
|
||
In this example the weight hints change the behavior of an Evas box
|
||
when layouting its children. See the full @ref
|
||
Example_Evas_Size_Hints "example".
|
||
|
||
@note Default weight hint values are 0.0, for both axis.
|
||
|
||
@see evas_object_size_hint_weight_get() for more information */
|
||
}
|
||
get {
|
||
/*@
|
||
Retrieves the hints for an object's weight.
|
||
|
||
Accepted values are zero or positive values. Some users might use
|
||
this hint as a boolean, but some might consider it as a @b
|
||
proportion, see documentation of possible users, which in Evas are
|
||
the @ref Evas_Object_Box "box" and @ref Evas_Object_Table "table"
|
||
smart objects.
|
||
|
||
This is not a size enforcement in any way, it's just a hint that
|
||
should be used whenever appropriate.
|
||
|
||
@note Use @c NULL pointers on the hint components you're not
|
||
interested in: they'll be ignored by the function.
|
||
@note If @c obj is invalid, then the hint components will be set with 0.0
|
||
|
||
@see evas_object_size_hint_weight_set() for an example */
|
||
}
|
||
values {
|
||
double x; /*@ Nonnegative double value to use as horizontal weight hint. */
|
||
double y; /*@ Nonnegative double value to use as vertical weight hint. */
|
||
}
|
||
}
|
||
name {
|
||
set {
|
||
/*@
|
||
Sets the name of the given Evas object to the given name.
|
||
|
||
There might be occasions where one would like to name his/her
|
||
objects.
|
||
|
||
Example:
|
||
@dontinclude evas-events.c
|
||
@skip d.bg = evas_object_rectangle_add(d.canvas);
|
||
@until evas_object_name_set(d.bg, "our dear rectangle");
|
||
|
||
See the full @ref Example_Evas_Events "example". */
|
||
}
|
||
get {
|
||
/*@
|
||
Retrieves the name of the given Evas object.
|
||
|
||
@return The name of the object or @c NULL, if no name has been given
|
||
to it.
|
||
|
||
Example:
|
||
@dontinclude evas-events.c
|
||
@skip fprintf(stdout, "An object got focused: %s\n",
|
||
@until evas_focus_get
|
||
|
||
See the full @ref Example_Evas_Events "example". */
|
||
}
|
||
values {
|
||
const(char)* name; /*@ The given name. */
|
||
}
|
||
}
|
||
scale {
|
||
set {
|
||
/*@
|
||
Sets the scaling factor for an Evas object. Does not affect all
|
||
objects.
|
||
|
||
This will multiply the object's dimension by the given factor, thus
|
||
altering its geometry (width and height). Useful when you want
|
||
scalable UI elements, possibly at run time.
|
||
|
||
@note Only text and textblock objects have scaling change
|
||
handlers. Other objects won't change visually on this call.
|
||
|
||
@see evas_object_scale_get()
|
||
|
||
@ingroup Evas_Object_Group_Extras */
|
||
}
|
||
get {
|
||
/*@
|
||
Retrieves the scaling factor for the given Evas object.
|
||
|
||
@return The scaling factor.
|
||
|
||
@ingroup Evas_Object_Group_Extras
|
||
|
||
@see evas_object_scale_set() */
|
||
}
|
||
values {
|
||
double scale; /*@ The scaling factor. <c>1.0</c> means no scaling,
|
||
default size. */
|
||
}
|
||
}
|
||
static_clip {
|
||
set {
|
||
/*@
|
||
Set a hint flag on the given Evas object that it's used as a "static
|
||
clipper".
|
||
|
||
This is a hint to Evas that this object is used as a big static
|
||
clipper and shouldn't be moved with children and otherwise
|
||
considered specially. The default value for new objects is
|
||
@c EINA_FALSE.
|
||
|
||
@see evas_object_static_clip_get()
|
||
|
||
@ingroup Evas_Object_Group_Extras */
|
||
}
|
||
get {
|
||
/*@
|
||
Get the "static clipper" hint flag for a given Evas object.
|
||
|
||
@return @c EINA_TRUE if it's set as a static clipper,
|
||
@c EINA_FALSE otherwise.
|
||
|
||
@see evas_object_static_clip_set() for more details
|
||
|
||
@ingroup Evas_Object_Group_Extras */
|
||
}
|
||
values {
|
||
bool is_static_clip; /*@ @c EINA_TRUE if it's to be used as a static
|
||
clipper, @c EINA_FALSE otherwise. */
|
||
}
|
||
}
|
||
size {
|
||
set {
|
||
/*@ Changes the size of the given Evas object. */
|
||
legacy evas_object_resize;
|
||
}
|
||
get {
|
||
/*@ Retrieves the (rectangular) size of the given Evas object. */
|
||
legacy null;
|
||
}
|
||
values {
|
||
Evas_Coord w; /*@ in */
|
||
Evas_Coord h; /*@ in */
|
||
}
|
||
}
|
||
focus {
|
||
set {
|
||
/*@
|
||
Sets or unsets a given object as the currently focused one on its
|
||
canvas.
|
||
|
||
Changing focus only affects where (key) input events go. There can
|
||
be only one object focused at any time. If @p focus is @c EINA_TRUE,
|
||
@p obj will be set as the currently focused object and it will
|
||
receive all keyboard events that are not exclusive key grabs on
|
||
other objects.
|
||
|
||
Example:
|
||
@dontinclude evas-events.c
|
||
@skip evas_object_focus_set
|
||
@until evas_object_focus_set
|
||
|
||
See the full example @ref Example_Evas_Events "here".
|
||
|
||
@see evas_object_focus_get
|
||
@see evas_focus_get
|
||
@see evas_object_key_grab
|
||
@see evas_object_key_ungrab */
|
||
}
|
||
get {
|
||
/*@
|
||
Retrieve whether an object has the focus.
|
||
|
||
@return @c EINA_TRUE if the object has the focus, @c EINA_FALSE otherwise.
|
||
|
||
If the passed object is the currently focused one, @c EINA_TRUE is
|
||
returned. @c EINA_FALSE is returned, otherwise.
|
||
|
||
Example:
|
||
@dontinclude evas-events.c
|
||
@skip And again
|
||
@until something is bad
|
||
|
||
See the full example @ref Example_Evas_Events "here".
|
||
|
||
@see evas_object_focus_set
|
||
@see evas_focus_get
|
||
@see evas_object_key_grab
|
||
@see evas_object_key_ungrab */
|
||
}
|
||
values {
|
||
bool focus; /*@ @c EINA_TRUE, to set it as focused or @c EINA_FALSE,
|
||
to take away the focus from it. */
|
||
}
|
||
}
|
||
is_frame_object {
|
||
set {
|
||
/*@ @since 1.2 */
|
||
}
|
||
get {
|
||
/*@ @since 1.2 */
|
||
}
|
||
values {
|
||
bool is_frame; /*@ in */
|
||
}
|
||
}
|
||
map_enable {
|
||
set {
|
||
/*@
|
||
Enable or disable the map that is set.
|
||
|
||
Enable or disable the use of map for the object @p obj.
|
||
On enable, the object geometry will be saved, and the new geometry will
|
||
change (position and size) to reflect the map geometry set.
|
||
|
||
If the object doesn't have a map set (with evas_object_map_set()), the
|
||
initial geometry will be undefined. It is advised to always set a map
|
||
to the object first, and then call this function to enable its use. */
|
||
}
|
||
get {
|
||
/*@
|
||
Get the map enabled state
|
||
|
||
This returns the currently enabled state of the map on the object indicated.
|
||
The default map enable state is off. You can enable and disable it with
|
||
evas_object_map_enable_set().
|
||
|
||
@return the map enabled state */
|
||
}
|
||
values {
|
||
bool enabled; /*@ enabled state */
|
||
}
|
||
}
|
||
precise_is_inside {
|
||
set {
|
||
/*@
|
||
Set whether to use precise (usually expensive) point collision
|
||
detection for a given Evas object.
|
||
|
||
Use this function to make Evas treat objects' transparent areas as
|
||
@b not belonging to it with regard to mouse pointer events. By
|
||
default, all of the object's boundary rectangle will be taken in
|
||
account for them.
|
||
|
||
@warning By using precise point collision detection you'll be
|
||
making Evas more resource intensive.
|
||
|
||
Example code follows.
|
||
@dontinclude evas-events.c
|
||
@skip if (strcmp(ev->key, "p") == 0)
|
||
@until }
|
||
|
||
See the full example @ref Example_Evas_Events "here".
|
||
|
||
@see evas_object_precise_is_inside_get()
|
||
@ingroup Evas_Object_Group_Extras */
|
||
}
|
||
get {
|
||
/*@
|
||
Determine whether an object is set to use precise point collision
|
||
detection.
|
||
|
||
@return whether @p obj is set to use precise point collision
|
||
detection or not The default value is false.
|
||
|
||
@see evas_object_precise_is_inside_set() for an example
|
||
|
||
@ingroup Evas_Object_Group_Extras */
|
||
}
|
||
values {
|
||
bool precise; /*@ Whether to use precise point collision detection or
|
||
not. The default value is false. */
|
||
}
|
||
}
|
||
size_hint_align {
|
||
set {
|
||
/*@
|
||
Sets the hints for an object's alignment.
|
||
|
||
These are hints on how to align an object <b>inside the boundaries
|
||
of a container/manager</b>. Accepted values are in the @c 0.0 to @c
|
||
1.0 range, with the special value #EVAS_HINT_FILL used to specify
|
||
"justify" or "fill" by some users. In this case, maximum size hints
|
||
should be enforced with higher priority, if they are set. Also, any
|
||
padding hint set on objects should add up to the alignment space on
|
||
the final scene composition.
|
||
|
||
See documentation of possible users: in Evas, they are the @ref
|
||
Evas_Object_Box "box" and @ref Evas_Object_Table "table" smart
|
||
objects.
|
||
|
||
For the horizontal component, @c 0.0 means to the left, @c 1.0
|
||
means to the right. Analogously, for the vertical component, @c 0.0
|
||
to the top, @c 1.0 means to the bottom.
|
||
|
||
See the following figure:
|
||
|
||
@image html alignment-hints.png
|
||
@image rtf alignment-hints.png
|
||
@image latex alignment-hints.eps
|
||
|
||
This is not a size enforcement in any way, it's just a hint that
|
||
should be used whenever appropriate.
|
||
|
||
@note Default alignment hint values are 0.5, for both axis.
|
||
|
||
Example:
|
||
@dontinclude evas-hints.c
|
||
@skip evas_object_size_hint_align_set
|
||
@until return
|
||
|
||
In this example the alignment hints change the behavior of an Evas
|
||
box when layouting its children. See the full @ref
|
||
Example_Evas_Size_Hints "example".
|
||
|
||
@see evas_object_size_hint_align_get()
|
||
@see evas_object_size_hint_max_set()
|
||
@see evas_object_size_hint_padding_set() */
|
||
}
|
||
get {
|
||
/*@
|
||
Retrieves the hints for on object's alignment.
|
||
|
||
This is not a size enforcement in any way, it's just a hint that
|
||
should be used whenever appropriate.
|
||
|
||
@note Use @c NULL pointers on the hint components you're not
|
||
interested in: they'll be ignored by the function.
|
||
@note If @c obj is invalid, then the hint components will be set with 0.5
|
||
|
||
@see evas_object_size_hint_align_set() for more information */
|
||
}
|
||
values {
|
||
double x; /*@ Double, ranging from @c 0.0 to @c 1.0 or with the
|
||
special value #EVAS_HINT_FILL, to use as horizontal alignment hint. */
|
||
double y; /*@ Double, ranging from @c 0.0 to @c 1.0 or with the
|
||
special value #EVAS_HINT_FILL, to use as vertical alignment hint. */
|
||
}
|
||
}
|
||
propagate_events {
|
||
set {
|
||
/*@
|
||
Set whether events on a smart object's member should get propagated
|
||
up to its parent.
|
||
|
||
This function has @b no effect if @p obj is not a member of a smart
|
||
object.
|
||
|
||
If @p prop is @c EINA_TRUE, events occurring on this object will be
|
||
propagated on to the smart object of which @p obj is a member. If
|
||
@p prop is @c EINA_FALSE, events occurring on this object will @b
|
||
not be propagated on to the smart object of which @p obj is a
|
||
member. The default value is @c EINA_TRUE.
|
||
|
||
@see evas_object_propagate_events_get()
|
||
@see evas_object_repeat_events_set()
|
||
@see evas_object_pass_events_set()
|
||
@see evas_object_freeze_events_set() */
|
||
}
|
||
get {
|
||
/*@
|
||
Retrieve whether an Evas object is set to propagate events.
|
||
|
||
@return whether @p obj is set to propagate events (@c EINA_TRUE)
|
||
or not (@c EINA_FALSE)
|
||
|
||
@see evas_object_propagate_events_set()
|
||
@see evas_object_repeat_events_get()
|
||
@see evas_object_pass_events_get()
|
||
@see evas_object_freeze_events_get() */
|
||
}
|
||
values {
|
||
bool propagate; /*@ whether to propagate events (@c EINA_TRUE) or not
|
||
(@c EINA_FALSE) */
|
||
}
|
||
}
|
||
pass_events {
|
||
set {
|
||
/*@
|
||
Set whether an Evas object is to pass (ignore) events.
|
||
|
||
If @p pass is @c EINA_TRUE, it will make events on @p obj to be @b
|
||
ignored. They will be triggered on the @b next lower object (that
|
||
is not set to pass events), instead (see evas_object_below_get()).
|
||
|
||
If @p pass is @c EINA_FALSE, events will be processed on that
|
||
object as normal.
|
||
|
||
@see evas_object_pass_events_get() for an example
|
||
@see evas_object_repeat_events_set()
|
||
@see evas_object_propagate_events_set()
|
||
@see evas_object_freeze_events_set() */
|
||
}
|
||
get {
|
||
/*@
|
||
Determine whether an object is set to pass (ignore) events.
|
||
|
||
@return pass whether @p obj is set to pass events (@c EINA_TRUE) or not
|
||
(@c EINA_FALSE)
|
||
|
||
Example:
|
||
@dontinclude evas-stacking.c
|
||
@skip if (strcmp(ev->key, "p") == 0)
|
||
@until }
|
||
|
||
See the full @ref Example_Evas_Stacking "example".
|
||
|
||
@see evas_object_pass_events_set()
|
||
@see evas_object_repeat_events_get()
|
||
@see evas_object_propagate_events_get()
|
||
@see evas_object_freeze_events_get() */
|
||
}
|
||
values {
|
||
bool pass; /*@ whether @p obj is to pass events (@c EINA_TRUE) or not
|
||
(@c EINA_FALSE) */
|
||
}
|
||
}
|
||
position {
|
||
set {
|
||
/*@ Move the given Evas object to the given location inside its canvas' viewport. */
|
||
legacy evas_object_move;
|
||
}
|
||
get {
|
||
/*@ Retrieves the position of the given Evas object. */
|
||
legacy null;
|
||
}
|
||
values {
|
||
Evas_Coord x; /*@ in */
|
||
Evas_Coord y; /*@ in */
|
||
}
|
||
}
|
||
anti_alias {
|
||
set {
|
||
/*@
|
||
Sets whether or not the given Evas object is to be drawn anti-aliased.
|
||
|
||
@ingroup Evas_Object_Group_Extras */
|
||
}
|
||
get {
|
||
/*@
|
||
Retrieves whether or not the given Evas object is to be drawn anti_aliased.
|
||
@return @c 1 if the object is to be anti_aliased. @c 0 otherwise.
|
||
@ingroup Evas_Object_Group_Extras */
|
||
}
|
||
values {
|
||
bool anti_alias; /*@ 1 if the object is to be anti_aliased, 0 otherwise. */
|
||
}
|
||
}
|
||
color {
|
||
set {
|
||
/*@
|
||
Sets the general/main color of the given Evas object to the given
|
||
one.
|
||
|
||
@see evas_object_color_get() (for an example)
|
||
@note These color values are expected to be premultiplied by @p a.
|
||
|
||
@ingroup Evas_Object_Group_Basic */
|
||
}
|
||
get {
|
||
/*@
|
||
Retrieves the general/main color of the given Evas object.
|
||
|
||
Retrieves the “main” color's RGB component (and alpha channel)
|
||
values, <b>which range from 0 to 255</b>. For the alpha channel,
|
||
which defines the object's transparency level, 0 means totally
|
||
transparent, while 255 means opaque. These color values are
|
||
premultiplied by the alpha value.
|
||
|
||
Usually you’ll use this attribute for text and rectangle objects,
|
||
where the “main” color is their unique one. If set for objects
|
||
which themselves have colors, like the images one, those colors get
|
||
modulated by this one.
|
||
|
||
@note All newly created Evas rectangles get the default color
|
||
values of <code>255 255 255 255</code> (opaque white).
|
||
|
||
@note Use @c NULL pointers on the components you're not interested
|
||
in: they'll be ignored by the function.
|
||
|
||
Example:
|
||
@dontinclude evas-object-manipulation.c
|
||
@skip int alpha, r, g, b;
|
||
@until return
|
||
|
||
See the full @ref Example_Evas_Object_Manipulation "example".
|
||
|
||
@ingroup Evas_Object_Group_Basic */
|
||
}
|
||
values {
|
||
int r; /*@ The red component of the given color. */
|
||
int g; /*@ The green component of the given color. */
|
||
int b; /*@ The blue component of the given color. */
|
||
int a; /*@ The alpha component of the given color. */
|
||
}
|
||
}
|
||
smart_data {
|
||
get {
|
||
/*@
|
||
Retrieve user data stored on a given smart object.
|
||
|
||
@return A pointer to data stored using
|
||
evas_object_smart_data_set(), or @c NULL, if none has been
|
||
set.
|
||
|
||
@see evas_object_smart_data_set()
|
||
|
||
@ingroup Evas_Smart_Object_Group */
|
||
return void * @warn_unused;
|
||
}
|
||
}
|
||
smart_clipped_clipper {
|
||
get {
|
||
/*@
|
||
Get the clipper object for the given clipped smart object.
|
||
|
||
@return the clipper object.
|
||
|
||
Use this function if you want to change any of this clipper's
|
||
properties, like colors.
|
||
|
||
@see evas_object_smart_clipped_smart_add() */
|
||
return Evas_Object * @warn_unused;
|
||
}
|
||
}
|
||
below {
|
||
get {
|
||
/*@
|
||
Get the Evas object stacked right below @p obj
|
||
|
||
@return the #Evas_Object directly below @p obj, if any, or @c NULL,
|
||
if none
|
||
|
||
This function will traverse layers in its search, if there are
|
||
objects on layers below the one @p obj is placed at.
|
||
|
||
@see evas_object_layer_get()
|
||
@see evas_object_layer_set()
|
||
@see evas_object_below_get() */
|
||
return Evas_Object * @warn_unused;
|
||
}
|
||
}
|
||
clipees {
|
||
get {
|
||
/*@
|
||
Return a list of objects currently clipped by @p obj.
|
||
|
||
@return a list of objects being clipped by @p obj
|
||
|
||
This returns the internal list handle that contains all objects
|
||
clipped by the object @p obj. If none are clipped by it, the call
|
||
returns @c NULL. This list is only valid until the clip list is
|
||
changed and should be fetched again with another call to
|
||
evas_object_clipees_get() if any objects being clipped by this
|
||
object are unclipped, clipped by a new object, deleted or get the
|
||
clipper deleted. These operations will invalidate the list
|
||
returned, so it should not be used anymore after that point. Any
|
||
use of the list after this may have undefined results, possibly
|
||
leading to crashes. The object @p obj must be a valid
|
||
.Evas_Object.
|
||
|
||
See also evas_object_clip_set(), evas_object_clip_unset() and
|
||
evas_object_clip_get().
|
||
|
||
Example:
|
||
@code
|
||
extern Evas_Object *obj;
|
||
Evas_Object *clipper;
|
||
|
||
clipper = evas_object_clip_get(obj);
|
||
if (clipper)
|
||
{
|
||
Eina.List *clippees, *l;
|
||
Evas_Object *obj_tmp;
|
||
|
||
clippees = evas_object_clipees_get(clipper);
|
||
printf("Clipper clips %i objects\n", eina_list_count(clippees));
|
||
EINA_LIST_FOREACH(clippees, l, obj_tmp)
|
||
evas_object_show(obj_tmp);
|
||
}
|
||
@endcode */
|
||
return const(Eina.List)* @warn_unused;
|
||
}
|
||
}
|
||
smart_parent {
|
||
get {
|
||
/*@
|
||
Gets the parent smart object of a given Evas object, if it has one.
|
||
|
||
@return Returns the parent smart object of @a obj or @c NULL, if @a
|
||
obj is not a smart member of any
|
||
|
||
@ingroup Evas_Smart_Object_Group */
|
||
return Evas_Object * @warn_unused;
|
||
}
|
||
}
|
||
above {
|
||
get {
|
||
/*@
|
||
Get the Evas object stacked right above @p obj
|
||
|
||
@return the #Evas_Object directly above @p obj, if any, or @c NULL,
|
||
if none
|
||
|
||
This function will traverse layers in its search, if there are
|
||
objects on layers above the one @p obj is placed at.
|
||
|
||
@see evas_object_layer_get()
|
||
@see evas_object_layer_set()
|
||
@see evas_object_below_get() */
|
||
return Evas_Object * @warn_unused;
|
||
}
|
||
}
|
||
size_hint_display_mode {
|
||
get {
|
||
/*@
|
||
Retrieves the hints for an object's display mode
|
||
|
||
These are hints on the display mode @p obj. This is
|
||
not a size enforcement in any way, it's just a hint that can be
|
||
used whenever appropriate.
|
||
This mode can be used object's display mode like commpress or expand */
|
||
}
|
||
set {
|
||
/*@
|
||
Sets the hints for an object's disply mode
|
||
|
||
This is not a size enforcement in any way, it's just a hint that
|
||
can be used whenever appropriate.*/
|
||
}
|
||
values {
|
||
Evas_Display_Mode dispmode; /*@ display mode hint */
|
||
}
|
||
}
|
||
}
|
||
methods {
|
||
clipees_has @const {
|
||
/*@
|
||
Test if any object is clipped by @p obj.
|
||
|
||
@return EINA_TRUE if @p obj clip any object.
|
||
@since 1.8 */
|
||
return bool @warn_unused;
|
||
}
|
||
key_grab {
|
||
/*@
|
||
Requests @p keyname key events be directed to @p obj.
|
||
|
||
@return @c EINA_TRUE, if the call succeeded, @c EINA_FALSE otherwise.
|
||
|
||
Key grabs allow one or more objects to receive key events for
|
||
specific key strokes even if other objects have focus. Whenever a
|
||
key is grabbed, only the objects grabbing it will get the events
|
||
for the given keys.
|
||
|
||
@p keyname is a platform dependent symbolic name for the key
|
||
pressed (see @ref Evas_Keys for more information).
|
||
|
||
@p modifiers and @p not_modifiers are bit masks of all the
|
||
modifiers that must and mustn't, respectively, be pressed along
|
||
with @p keyname key in order to trigger this new key
|
||
grab. Modifiers can be things such as Shift and Ctrl as well as
|
||
user defined types via evas_key_modifier_add(). Retrieve them with
|
||
evas_key_modifier_mask_get() or use @c 0 for empty masks.
|
||
|
||
@p exclusive will make the given object the only one permitted to
|
||
grab the given key. If given @c EINA_TRUE, subsequent calls on this
|
||
function with different @p obj arguments will fail, unless the key
|
||
is ungrabbed again.
|
||
|
||
Example code follows.
|
||
@dontinclude evas-events.c
|
||
@skip if (d.focus)
|
||
@until else
|
||
|
||
See the full example @ref Example_Evas_Events "here".
|
||
|
||
@warning Providing impossible modifier sets creates undefined behavior
|
||
|
||
@see evas_object_key_ungrab
|
||
@see evas_object_focus_set
|
||
@see evas_object_focus_get
|
||
@see evas_focus_get
|
||
@see evas_key_modifier_add */
|
||
|
||
return bool @warn_unused;
|
||
params {
|
||
@in const(char)* keyname @nonull; /*@ the key to request events for. */
|
||
@in Evas_Modifier_Mask modifiers; /*@ a mask of modifiers that must be present to
|
||
trigger the event. */
|
||
@in Evas_Modifier_Mask not_modifiers; /*@ a mask of modifiers that must @b not be present
|
||
to trigger the event. */
|
||
@in bool exclusive; /*@ request that the @p obj is the only object
|
||
receiving the @p keyname events. */
|
||
}
|
||
}
|
||
stack_below {
|
||
/*@
|
||
Stack @p obj immediately below @p below
|
||
|
||
Objects, in a given canvas, are stacked in the order they get added
|
||
to it. This means that, if they overlap, the highest ones will
|
||
cover the lowest ones, in that order. This function is a way to
|
||
change the stacking order for the objects.
|
||
|
||
This function is intended to be used with <b>objects belonging to
|
||
the same layer</b> in a given canvas, otherwise it will fail (and
|
||
accomplish nothing).
|
||
|
||
If you have smart objects on your canvas and @p obj is a member of
|
||
one of them, then @p below must also be a member of the same
|
||
smart object.
|
||
|
||
Similarly, if @p obj is not a member of a smart object, @p below
|
||
must not be either.
|
||
|
||
@see evas_object_layer_get()
|
||
@see evas_object_layer_set()
|
||
@see evas_object_stack_below() */
|
||
|
||
params {
|
||
@in Evas_Object *below @nonull; /*@ the object below which to stack */
|
||
}
|
||
}
|
||
raise {
|
||
/*@
|
||
Raise @p obj to the top of its layer.
|
||
|
||
@p obj will, then, be the highest one in the layer it belongs
|
||
to. Object on other layers won't get touched.
|
||
|
||
@see evas_object_stack_above()
|
||
@see evas_object_stack_below()
|
||
@see evas_object_lower() */
|
||
|
||
}
|
||
stack_above {
|
||
/*@
|
||
Stack @p obj immediately above @p above
|
||
|
||
Objects, in a given canvas, are stacked in the order they get added
|
||
to it. This means that, if they overlap, the highest ones will
|
||
cover the lowest ones, in that order. This function is a way to
|
||
change the stacking order for the objects.
|
||
|
||
This function is intended to be used with <b>objects belonging to
|
||
the same layer</b> in a given canvas, otherwise it will fail (and
|
||
accomplish nothing).
|
||
|
||
If you have smart objects on your canvas and @p obj is a member of
|
||
one of them, then @p above must also be a member of the same
|
||
smart object.
|
||
|
||
Similarly, if @p obj is not a member of a smart object, @p above
|
||
must not be either.
|
||
|
||
@see evas_object_layer_get()
|
||
@see evas_object_layer_set()
|
||
@see evas_object_stack_below() */
|
||
|
||
params {
|
||
@in Evas_Object *above @nonull; /*@ the object above which to stack */
|
||
}
|
||
}
|
||
smart_type_check @const {
|
||
/*@
|
||
Checks whether a given smart object or any of its smart object
|
||
parents is of a given smart class.
|
||
|
||
@return @c EINA_TRUE, if @a obj or any of its parents is of type @a
|
||
type, @c EINA_FALSE otherwise
|
||
|
||
If @p obj is not a smart object, this call will fail
|
||
immediately.
|
||
|
||
This function supports Eo and legacy inheritance mechanisms. However,
|
||
it is recommended to use eo_isa instead if your object is using Eo from
|
||
top to bottom.
|
||
|
||
The checks use smart classes names and <b>string
|
||
comparison</b>. There is a version of this same check using
|
||
<b>pointer comparison</b>, since a smart class' name is a single
|
||
string in Evas.
|
||
|
||
@see evas_object_smart_type_check_ptr()
|
||
@see eo_isa
|
||
|
||
@ingroup Evas_Smart_Object_Group */
|
||
return bool @warn_unused;
|
||
params {
|
||
@in const(char)* type @nonull; /*@ The @b name (type) of the smart class to check for */
|
||
}
|
||
}
|
||
name_child_find @const {
|
||
/*@
|
||
Retrieves the object from children of the given object with the given name.
|
||
@return If successful, the Evas object with the given name. Otherwise,
|
||
@c NULL.
|
||
|
||
This looks for the evas object given a name by evas_object_name_set(), but
|
||
it ONLY looks at the children of the object *p obj, and will only recurse
|
||
into those children if @p recurse is greater than 0. If the name is not
|
||
unique within immediate children (or the whole child tree) then it is not
|
||
defined which child object will be returned. If @p recurse is set to -1 then
|
||
it will recurse without limit.
|
||
|
||
@since 1.2
|
||
|
||
@ingroup Evas_Object_Group_Find */
|
||
return Evas_Object * @warn_unused;
|
||
params {
|
||
@in const(char)* name; /*@ The given name. */
|
||
@in int recurse; /*@ Set to the number of child levels to recurse (0 == don't recurse, 1 == only look at the children of @p obj or their immediate children, but no further etc.). */
|
||
}
|
||
}
|
||
key_ungrab {
|
||
/*@
|
||
Removes the grab on @p keyname key events by @p obj.
|
||
|
||
Removes a key grab on @p obj if @p keyname, @p modifiers, and @p
|
||
not_modifiers match.
|
||
|
||
Example code follows.
|
||
@dontinclude evas-events.c
|
||
@skip got here by key grabs
|
||
@until }
|
||
|
||
See the full example @ref Example_Evas_Events "here".
|
||
|
||
@see evas_object_key_grab
|
||
@see evas_object_focus_set
|
||
@see evas_object_focus_get
|
||
@see evas_focus_get */
|
||
|
||
params {
|
||
@in const(char)* keyname @nonull; /*@ the key the grab is set for. */
|
||
@in Evas_Modifier_Mask modifiers; /*@ a mask of modifiers that must be present to
|
||
trigger the event. */
|
||
@in Evas_Modifier_Mask not_modifiers; /*@ a mask of modifiers that must not not be
|
||
present to trigger the event. */
|
||
}
|
||
}
|
||
lower {
|
||
/*@
|
||
Lower @p obj to the bottom of its layer.
|
||
|
||
@p obj will, then, be the lowest one in the layer it belongs
|
||
to. Objects on other layers won't get touched.
|
||
|
||
@see evas_object_stack_above()
|
||
@see evas_object_stack_below()
|
||
@see evas_object_raise() */
|
||
|
||
}
|
||
clip_unset {
|
||
/*@
|
||
Disable/cease clipping on a clipped @p obj object.
|
||
|
||
This function disables clipping for the object @p obj, if it was
|
||
already clipped, i.e., its visibility and color get detached from
|
||
the previous clipper. If it wasn't, this has no effect. The object
|
||
@p obj must be a valid .Evas_Object.
|
||
|
||
See also evas_object_clip_set() (for an example),
|
||
evas_object_clipees_get() and evas_object_clip_get(). */
|
||
|
||
}
|
||
smart_move_children_relative {
|
||
/*@
|
||
Moves all children objects of a given smart object relative to a
|
||
given offset.
|
||
|
||
This will make each of @p obj object's children to move, from where
|
||
they before, with those delta values (offsets) on both directions.
|
||
|
||
@note This is most useful on custom smart @c move() functions.
|
||
|
||
@note Clipped smart objects already make use of this function on
|
||
their @c move() smart function definition. */
|
||
|
||
params {
|
||
@in Evas_Coord dx; /*@ horizontal offset (delta). */
|
||
@in Evas_Coord dy; /*@ vertical offset (delta). */
|
||
}
|
||
}
|
||
smart_type_check_ptr @const {
|
||
/*@
|
||
Checks whether a given smart object or any of its smart object
|
||
parents is of a given smart class, <b>using pointer comparison</b>.
|
||
|
||
@return @c EINA_TRUE, if @a obj or any of its parents is of type @a
|
||
type, @c EINA_FALSE otherwise
|
||
|
||
@see evas_object_smart_type_check() for more details
|
||
@see eo_isa
|
||
|
||
@ingroup Evas_Smart_Object_Group */
|
||
return bool @warn_unused;
|
||
params {
|
||
@in const(char)* type @nonull; /*@ The type (name string) to check for. Must be the name */
|
||
}
|
||
}
|
||
}
|
||
implements {
|
||
Eo.Base.constructor;
|
||
Eo.Base.destructor;
|
||
Eo.Base.dbg_info_get;
|
||
Evas.Common_Interface.evas.get;
|
||
}
|
||
events {
|
||
mouse,in; /*@ Mouse In Event */
|
||
mouse,out; /*@ Mouse Out Event */
|
||
mouse,down; /*@ Mouse Button Down Event */
|
||
mouse,up; /*@ Mouse Button Up Event */
|
||
mouse,move; /*@ Mouse Move Event */
|
||
mouse,wheel; /*@ Mouse Wheel Event */
|
||
multi,down; /*@ Mouse-touch Down Event */
|
||
multi,up; /*@ Mouse-touch Up Event */
|
||
multi,move; /*@ Multi-touch Move Event */
|
||
free; /*@ Object Being Freed (Called after Del) */
|
||
key,down; /*@ Key Press Event */
|
||
key,up; /*@ Key Release Event */
|
||
focus,in; /*@ Focus In Event */
|
||
focus,out; /*@ Focus Out Event */
|
||
show; /*@ Show Event */
|
||
hide; /*@ Hide Event */
|
||
move; /*@ Move Event */
|
||
resize; /*@ Resize Event */
|
||
restack; /*@ Restack Event */
|
||
del; /*@ Object Being Deleted (called before Free) */
|
||
hold; /*@ Events go on/off hold */
|
||
changed,size,hints; /*@ Size hints changed event */
|
||
image,preloaded; /*@ Image has been preloaded */
|
||
image,resize; /*@ Image resize */
|
||
image,unloaded; /*@ Image data has been unloaded (by some mechanism in Evas that throw out original image data) */
|
||
}
|
||
}
|