b: int; [[Bottom]]
x: int; [[X offset]]
y: int; [[Y offset]]
- do_async: bool; [[$true when the operation should be done asynchronous, $false otherwise]]
+ do_async: bool; [[$true when the operation should be done asynchronously, $false otherwise]]
}
}
filter_dirty @protected @pure_virtual {
- [[Called when the filter changes must trigger a redraw of the object.
+ [[Called when filter changes must trigger a redraw of the object.
Virtual, to be implemented in the parent class.
]]
class Efl.Canvas.Group (Efl.Canvas.Object)
{
- [[A group object is a container of other canvas objects. Its children
- move along their parent, are often clipped with a common clipper.
+ [[A group object is a container for other canvas objects. Its children
+ move along their parent and are often clipped with a common clipper.
This is part of the legacy smart object concept.
- A group is not necessarily a container (see @Efl.Container), in the
- sense that a standard widget may not have any empty slots for content,
- but is still a group of low-level canvas objects (clipper, raw objects,
- etc...).
+ A group is not necessarily a container (see @Efl.Container) in the
+ sense that a standard widget may not have any empty slots for content.
+ However it's still a group of low-level canvas objects (clipper, raw objects,
+ etc.).
]]
legacy_prefix: evas_object_smart;
data: Evas_Smart_Data;
methods {
@property group_need_recalculate {
- [[Indicates that the group's layout need to be recalculated.
+ [[Indicates that the group's layout needs to be recalculated.
If this flag is set, then the @.group_calculate function will
be called, during rendering phase of the canvas. After that,
this flag will be automatically unset.
- Note: just setting this flag will not make the canvas' whole scene
- dirty, by itself, and evas_render() will have no effect. To
- force that, use @.group_change, that will also call this function
- automatically, with $true as parameter.
+ Note: setting this flag alone will not make the canvas' whole scene
+ dirty. Using evas_render() will have no effect. To
+ force this, use @.group_change, which will also call this function
+ automatically, with the parameter set to $true.
See also @.group_calculate.
]]
legacy: evas_object_smart_calculate;
}
group_members_iterate @const {
- [[Returns an iterator over the children of this object, that are
+ [[Returns an iterator over the children of this object, which are
canvas objects.
This returns the list of "smart" children. This might be different
Please do not assume that @Efl.Gfx.Render_Op.copy mode can be
used to "poke" holes in a window (to see through it), as only the
compositor can ensure that. Copy mode should only be used with
- otherwise opaque widgets, or inside non-window surfaces (eg. a
+ otherwise opaque widgets or inside non-window surfaces (eg. a
transparent background inside a buffer canvas).
]]
set {
set {
[[Set whether an Evas object is to freeze (discard) events.
- If $freeze is $true, it will make events on $obj to be
+ If $freeze is $true, it will force events on $obj to be
discarded. Unlike @.pass_events.set, events will not be
passed to next lower object. This API can be used for
- blocking events while $obj is on transiting.
+ blocking events while $obj is in transition.
If $freeze is $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.
+ you can't be sure of the state of any objects that have only
+ key/mouse down events.
@since 1.1
]]
seat_focus_add {
[[ Add a seat to the focus list.
- Evas supports that an Efl.Canvas.Object may be focused by multiple seats
- at the same time. This function adds a new seat to the focus list, in other words,
+ Evas allows the Efl.Canvas.Object to be focused by multiple seats
+ at the same time. This function adds a new seat to the focus list. In other words,
after the seat is added to the list this object will now be also focused by this new seat.
This function generates an \@ref EFL_CANVAS_OBJECT_EVENT_FOCUS_DEVICE_IN event.
}
@property propagate_events {
set {
- [[Set whether events on a smart object's member should get
+ [[Set whether events on a smart object's member should be
propagated up to its parent.
This function has no effect if $obj is not a member of a
They will be triggered on the next lower object (that is not
set to pass events), instead (see \@ref evas_object_below_get).
- If $pass is $false, events will be processed on that object
+ If $pass is $false events will be processed on that object
as normal.
See also @.repeat_events.set, @.propagate_events.set,
get {
[[Return a list of objects currently clipped by $obj.
- This returns the internal list handle that contains all
+ This returns the internal list handle containing all
objects clipped by the object $obj. If none are clipped by
it, the call returns $null. This list is only valid until
the clip list is changed and should be fetched again with
This flag will be used to indicate to Evas that this object
should never be rendered on the canvas under any
- circurmstances. In particular, this is useful to avoid
+ circumstances. In particular, this is useful to avoid
drawing clipper objects (or masks) even when they don't
clip any object. This can also be used to replace the old
source_visible flag with proxy objects.
Child objects are not modified in any way, unlike other types of smart objects.
- It is a user error for any child objects to be stacked above the event
- grabber parent while the event grabber is visible.
- A critical error will be raised if this is detected at any point.
+ No child objects should be stacked above the event
+ grabber parent while the grabber is visible.
+ A critical error will be raised if this is detected.
@since 1.20
]]
visible_range_get {
[[Returns the currently visible range.
- The given $start and $end cursor act like an out-variables here,
- as these are set to the positions of the start and the end of the
+ The given $start and $end cursor act like out-variables here,
+ as they are set to the positions of the start and the end of the
visible range in the text, respectively.
@since 1.18
}
@property bidi_delimiters {
[[BiDi delimiters are used for in-paragraph separation of bidi
- segments. This is useful for example in recipients fields of
+ segments. This is useful, for example, in the recipient fields of
e-mail clients where bidi oddities can occur when mixing RTL
and LTR.
This sets alpha flag for map rendering. If the object is a type that
has its own alpha settings, then this will take precedence. Only
image objects support this currently (@Efl.Canvas.Image and its
- friends). Setting this off stops alpha blending of the map area,
+ friends). Setting this to off stops alpha blending of the map area,
and is useful if you know the object and/or all sub-objects is 100%
solid.
This sets/gets the fixed point's coordinate in the map. Note that points
describe the outline of a quadrangle and are ordered either clockwise
- or counter-clockwise. It is suggested to keep your quadrangles concave and
- non-complex, though these polygon modes may work, they may not render
+ or counter-clockwise. Try to keep your quadrangles concave and
+ non-complex. Though these polygon modes may work, they may not render
a desired set of output. The quadrangle will use points 0 and 1 , 1 and 2,
2 and 3, and 3 and 0 to describe the edges of the quadrangle.
X and Y rendered coordinates. It may be used for calculating fills with
perspective correct rendering.
- Remember all coordinates are canvas global ones like with move and resize
+ Remember all coordinates are canvas global ones as with move and resize
in the canvas.
This property can be read to get the 4 points positions on the
rotate_3d {
[[Rotate the object around 3 axes in 3D.
- This will rotate in 3D and not just around the "Z" axis as the case
- with @.rotate. This will rotate around the X, Y and Z axes. The
+ This will rotate in 3D, not just around the "Z" axis as is the case
+ with @.rotate. You can rotate around the X, Y and Z axes. The
Z axis points "into" the screen with low values at the screen and
higher values further away. The X axis runs from left to right on
the screen and the Y axis from top to bottom.
}
}
lightning_3d {
- [[Apply a lightning effect on the object.
+ [[Apply a lighting effect on the object.
This is used to apply lighting calculations (from a single light
source) to a given mapped object. The R, G and B values of each
mapping between spatial coordinates and screen coordinates. Any points
on this z value will not have their X and Y values modified in the transform.
Those further away (Z value higher) will shrink into the distance, and
- those less than this value will expand and become bigger. The $foc value
+ those under this value will expand and become bigger. The $foc value
determines the "focal length" of the camera. This is in reality the distance
between the camera lens plane itself (at or closer than this rendering
results are undefined) and the "z0" z value. This allows for some "depth"
}
}
lightning_3d_absolute {
- [[Apply a lightning effect on the object.
+ [[Apply a lighting effect to the object.
This is used to apply lighting calculations (from a single light
- source) to a given mapped object. The R, G and B values of each
+ source) to a given mapped object. The RGB values of each
vertex will be modified to reflect the lighting based on the light
- point coordinates, the light color and the ambient color, and at
+ point coordinates, the light color, the ambient color and at
what angle the map is facing the light source. A surface should have
its points be declared in a clockwise fashion if the face is
"facing" towards you (as opposed to away from you) as faces have a
methods {
@property name {
set {
- [[Set an unique name from the parent point of view. $null means
+ [[Set an unique name from the parent's point of view. $null means
no name.
@since 1.16
]]
}
get {
- [[Get an unique name from the parent point of view.
+ [[Get an unique name from the parent's point of view.
- $null means no name. When set a parent after the name what
- defined, it might be forced back to $null if the parent
+ $null means no name. When setting a parent after a name has
+ already been defined, it might be forced back to $null if the parent
already has a node of that name.
@since 1.16
}
@property origin {
set {
- [[Sets the origin position of this node object.
+ [[Sets the origin position of the node object.
- This origin position affects to node transformation.
+ This origin position affects node transformation.
@since 1.14]]
}
get {
- [[Gets the origin position of this node object.
+ [[Gets the origin position of the node object.
@since 1.14]]
}
}
} */
bounds_get @pure_virtual {
- [[Give the bounding box in screen coordinate as being drawn.
+ [[Give the bounding box in screen coordinates as being drawn.
- It will start as the control box until it is refined once the shape
+ It will start as the control box until it is refined, once the shape
is computed.
@since 1.14]]
box.
In a flow horizontal box, the box's child elements are placed in
- rows (think of text as an analogy). A row has as much elements as
+ rows (think of text as an analogy). A row has as many elements as
can fit into the box's width. The box's overall behavior is
controlled by its properties, which are set by the
evas_object_box_{h,v}_{align,padding}_set family of
justified horizontally. $align_v controls the vertical alignment
of the entire set of rows ($0.0 to top, $1.0 to bottom). A
value of $-1.0 to $align_v makes the box to justify the rows
- vertically. The padding between them, in this case, is corrected so
+ vertically. The padding between them in this case is corrected so
that the first row touches the top border and the last one touches
the bottom border (even if they must overlap). $padding_v has no
influence on the layout.
[[Set the default set of flags an event begins with
Events in evas can have an event_flags member. This starts
- out with and initial value (no flags). This lets you set
- the default flags that an event begins with to be $flags.
+ out with an initial value (no flags). This lets you set
+ the default flags that an event begins with to $flags.
@since 1.2
]]
@skip called when our rectangle gets focus
@until }
- In this example the $event_info is exactly a pointer to that
+ In this example the $event_info is a pointer to that
focused rectangle. See the full @ref Example_Evas_Events "example".
*/
return: Efl.Canvas.Object @warn_unused; [[The object that has focus
smart calculations.
Whenever evas performs smart object calculations on the whole
- canvas it increments a counter by 1. This is the smart object
- calculate counter that this function returns the value of.
- It starts at the value of 0 and will increase (and eventually
+ canvas it increments a counter by 1. This function returns
+ the value of the smart object calculate counter.
+ It starts with a value of 0 and will increase (and eventually
wrap around to negative values and so on) by 1 every time
objects are calculated. You can use this counter to ensure
you don't re-do calculations withint the same calculation
set to 1.
Calling this function will return a 32-bit integer with the
- appropriate bits set to 1 that correspond to a mouse button
+ appropriate bits set to 1, which correspond to a mouse button
being depressed. This limits Evas to a mouse devices with a
maximum of 32 buttons, but that is generally in excess of
any host system's pointing device abilities.
key_modifier_add {
[[Adds the $keyname key to the current list of modifier keys.
- Modifiers are keys like shift, alt and ctrl, i.e., keys which
+ Modifiers are keys like shift, alt and ctrl, i.e. keys which
are meant to be pressed together with others, altering the
- behavior of the secondly pressed keys somehow. Evas is so that
+ behavior of the second keys pressed. Evas is so that
these keys can be user defined.
This call allows custom modifiers to be added to the Evas system
]]
}
focus_out {
- [[Inform to the evas that it lost the focus from the default seat.]]
+ [[Inform the evas that it lost the focus from the default seat.]]
}
norender {
[[Update the canvas internal objects but not triggering immediate
the given canvas $e.
Note: This is a very low level function, which most of Evas'
- users wouldn't care about. One would use it, for example, to
+ users wouldn't care about. You might use it, for instance, to
grab an Evas' canvas update regions and paint them back, using
the canvas' pixmap, on a displaying system working below Evas.
Note: Evas is a stateful canvas. If no operations changing its
state took place since the last rendering action, you won't see
- no changes and this call will be a no-op.
+ any changes and this call will be a no-op.
]]
/* FIXME-doc
Example code follows.
[[Make the canvas discard as much data as possible used by the
engine at runtime.
- This function will unload images, delete textures and much more,
+ This function will unload images, delete textures and much more
where possible. You may also want to call @.render_idle_flush
immediately prior to this to perhaps discard a little more,
though this function should implicitly delete most of what
[[Add a member node to the given node.
Nodes can be constructed into N-ary tree structure like other ordinary scene
- graph. Basically a node inherit transforms from its parent.
+ graphs. A node inherit transforms from its parent.
See also @Evas.Canvas3D.Node.parent_get.]]
[[Set the position inheritance flag of the given node.
When inheritance is enabled, a node's world space position is determined by
- adding the parent node's world position and the node's position, otherwise,
+ adding the parent node's world position and the node's position. Otherwise
the node's position will be the world space position.]]
}
get {
When inheritance is enabled, a node's world space orientation is determined
by multiplying the parent node's world orientation and the node's
- orientation, otherwise, the node's orientation will be the world space
+ orientation. Otherwise the node's orientation will be the world space
orientation.]]
}
get {
[[Set the scale inheritance flag of the given node.
When inheritance is enabled, a node's world space scale is determined by
- multiplying the parent node's world scale and the node's scale, otherwise,
+ multiplying the parent node's world scale and the node's scale. Otherwise
the node's scale will be the world space scale.]]
}
get {
Mode defines which function will be chosen to set data to mesh
on call of evas_canvas3d_mesh_primitive_set. It helps to choose
- alternative algorithm for primitive with given form
- (like cone without base or sphere textured in alternative way).
+ an alternative algorithm for primitives with a given form,
+ such as a cone without a base or sphere textured in alternative way.
- Now available next mods of primitives are
- witout base (bases) (supported for cylinder and cone) and
+ Mods of primitives are now available
+ without base (bases) (supported for cylinder and cone) and
with alternative UV (supported by sphere).
Default form is EVAS_CANVAS3D_PRIMITIVE_MODE_DEFAULT.]]
set {
[[Set the ratio of the given primitive.
- Now ratio uses only in torus as the ratio of the
+ Ratio is used only in torus as the ratio of the
major radius and minor radius. For this usage
Available values is from 1.0 to infinity.
If ratio for torus has a bad value,
- will be used 3.0 as ratio. Like ratio of usual doughnut.
+ 3.0 will be used as the ratio.
Default ratio is 3.0.]]
}
set {
[[Set the precision of the given primitive.
- Precision uses in all non tabulated primitives and defines
- precision of created primitives.
- Available values is from 3 to infinity.
- But if value will be more than 100, should be a warning
- about possibility of incorrect or slow work.
+ Precision is used in all non tabulated primitives and defines
+ the precision of created primitives.
+ Available values range from 3 to infinity.
+ If the value is more than 100, you may see a warning
+ about possibility of incorrect values or slow processing.
Default ratio is 10.]]
}
set {
[[Set the surface of the given primitive.
- Surface uses only in surface primitive and defines
- equation of filling mesh data on call of
+ Surface is used only in surface primitives and defines
+ the equation of filling mesh data on call of
evas_canvas3d_mesh_primitive_set.
- It gives possibility to create customers primitives like
+ This allows you to create customers primitives like
shell, heart, hyperbolic paraboloid etc. See _shell_func in
examples/evas/evas-3d-visual-test.c or _perlin_terrain in
- modules/evas/primitives/surfaces/terrain.c as an example of usage.
+ modules/evas/primitives/surfaces/terrain.c for usage examples.
Default surface is $null]]
}
size_set {
[[Set the resolution of a scene.
- A scene should be rendered to be displayed through an image
- objects. The resolution defines size of the internal surface
+ A scene should be rendered to be displayed through image
+ objects. The resolution defines the size of the internal surface
holding the rendered result.
]]
params {
background_color_set {
[[Set the background color of a scene.
- Background color defines initial color of pixels before a scene
+ Background color defines the initial color of pixels before a scene
is rendered. If you want to display a scene with background evas
- objects are still remaining as if it was the background, set
+ objects as if they're part of the background, set
the alpha term to 0.0.
Default background color is (0.0, 0.0, 0.0, 0.0).
[[Set the visibility flag of the source evas object of the given
texture.
- Recommend to call \@ref evas_object_show on the source object
+ Call \@ref evas_object_show on the source object
and control the visibility using this function.
- By default, source object is visible.
+ By default the source object is visible.
See also @.source_set.
]]
set {
[[Set enable flag to generation texture unit with support atlas.
- Use this flag only in case not normalize texture coordinates.
+ Use this flag only when you cannot normalize texture coordinates.
- By default, is enabled.
+ By default it is enabled.
]]
}
get {
[[Set the data of the given texture from an evas object.
Evas 3D support using existing evas object as a texture source.
- This feature make it possible using any exisiting evas object
+ This feature make it possible using any existing evas object
inside 3D scene.
See also @.source_visible.set.
size_get @const {
[[Get the size of the given texture.
- If the texture has source object, the size of the source object
- will be returned. Otherwise, the size of the data (or image file)
+ If the texture has a source object, the size of the source object
+ will be returned. Otherwise the size of the data (or image file)
will be returned.
See also @.data_set, @Efl.File.file.set, @.source_set.
@in child: Efl.Canvas.Object; [[The child object to add.]]
@out col: ushort; [[Pointer to store relative-horizontal position to place child.]]
@out row: ushort; [[Pointer to store relative-vertical position to place child.]]
- @out colspan: ushort; [[Pointer to store how many relative-horizontal position to use for this child.]]
- @out rowspan: ushort; [[Pointer to store how many relative-vertical position to use for this child.]]
+ @out colspan: ushort; [[Pointer to store how many relative-horizontal positions to use for this child.]]
+ @out rowspan: ushort; [[Pointer to store how many relative-vertical positions to use for this child.]]
}
}
pack {
@in child: Efl.Canvas.Object @nonull; [[The child object to add.]]
@in col: ushort; [[Relative-horizontal position to place child.]]
@in row: ushort; [[Relative-vertical position to place child.]]
- @in colspan: ushort; [[How many relative-horizontal position to use for this child.]]
- @in rowspan: ushort; [[How many relative-vertical position to use for this child.]]
+ @in colspan: ushort; [[How many relative-horizontal positions to use for this child.]]
+ @in rowspan: ushort; [[How many relative-vertical positions to use for this child.]]
}
}
unpack {
projects / platform / upstream / efl.git / commitdiff