kimcinoo
/
efl
forked from enlightenment/efl
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
efl/src/lib/evas/canvas/evas_object.eo

1334 lines
49 KiB
Plaintext
Raw Blame History

abstract Evas.Object (Eo.Base, Evas.Common_Interface, Efl.Gfx.Base, Efl.Gfx.Stack)
{
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.
@note Smart objects(such as elementary) can have their own size hint
policy. So calling this API may or may not affect the size of smart objects.
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.
@note Smart objects(such as elementary) can have their own size hint
policy. So calling this API may or may not affect the size of smart objects.
@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. */
}
}
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.
@note Smart objects(such as elementary) can have their own size hint
policy. So calling this API may or may not affect the size of smart objects.
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.
@note Smart objects(such as elementary) can have their own size hint
policy. So calling this API may or may not affect the size of smart objects.
@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. */
}
}
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.
@note Smart objects(such as elementary) can have their own size hint
policy. So calling this API may or may not affect the size of smart objects.
@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. */
}
}
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) */
}
}
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 EINA_TRUE) if the object is to be anti_aliased. (@c EINA_FALSE) otherwise.
@ingroup Evas_Object_Group_Extras */
}
values {
bool anti_alias; /*@ (@c EINA_TRUE) if the object is to be anti_aliased, (@c EINA_FALSE) otherwise. */
}
}
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;
}
}
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(list<Evas.Object*>)* @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;
}
}
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. */
}
}
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. */
}
}
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;
Efl.Gfx.Base.visible.set;
Efl.Gfx.Base.visible.get;
Efl.Gfx.Base.position.set;
Efl.Gfx.Base.position.get;
Efl.Gfx.Base.color.set;
Efl.Gfx.Base.color.get;
Efl.Gfx.Base.size.set;
Efl.Gfx.Base.size.get;
Efl.Gfx.Stack.layer.set;
Efl.Gfx.Stack.layer.get;
Efl.Gfx.Stack.below.get;
Efl.Gfx.Stack.above.get;
Efl.Gfx.Stack.stack_below;
Efl.Gfx.Stack.stack_above;
Efl.Gfx.Stack.raise;
Efl.Gfx.Stack.lower;
}
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) */
}
}
Reference in New Issue View Git Blame Copy Permalink