1003 lines
37 KiB
Plaintext
1003 lines
37 KiB
Plaintext
import efl_input_types;
|
|
|
|
class Evas.Canvas (Efl.Object, Efl.Canvas, Efl.Animator, Efl.Input.Interface,
|
|
Efl.Loop.Consumer, Efl.Canvas.Pointer)
|
|
{
|
|
[[Evas canvas class]]
|
|
legacy_prefix: evas;
|
|
data: Evas_Public_Data;
|
|
methods {
|
|
@property image_cache {
|
|
set {
|
|
[[Set the image cache.
|
|
|
|
This function sets the image cache of canvas in bytes.
|
|
]]
|
|
}
|
|
get {
|
|
[[Get the image cache.
|
|
|
|
This function returns the image cache size of canvas in bytes.
|
|
]]
|
|
}
|
|
values {
|
|
size: int; [[The cache size.]]
|
|
}
|
|
}
|
|
@property event_default_flags {
|
|
set {
|
|
[[Set the default set of flags an event begins with
|
|
|
|
Events in evas can have an event_flags member. This starts
|
|
out with an initial value (no flags). This lets you set
|
|
the default flags that an event begins with to $flags.
|
|
|
|
@since 1.2
|
|
]]
|
|
}
|
|
get {
|
|
[[Get the default set of flags an event begins with
|
|
|
|
This gets the default event flags events are produced with
|
|
when fed in.
|
|
|
|
@since 1.2
|
|
]]
|
|
}
|
|
values {
|
|
flags: Efl.Input.Flags; [[The default flags to use.]]
|
|
}
|
|
}
|
|
@property font_cache {
|
|
set {
|
|
[[Changes the size of font cache of the given evas.]]
|
|
}
|
|
get {
|
|
[[Get the size of font cache of the given evas in bytes.]]
|
|
}
|
|
values {
|
|
size: int; [[The size in bytes.]]
|
|
}
|
|
}
|
|
@property data_attach {
|
|
set {
|
|
[[Attaches a specific pointer to the evas for fetching later.]]
|
|
}
|
|
get {
|
|
[[Returns the pointer attached by @.data_attach.set.]]
|
|
}
|
|
values {
|
|
data: void_ptr; [[The attached pointer.]]
|
|
}
|
|
}
|
|
@property focus {
|
|
get {
|
|
[[Retrieve the object focused by the default seat.
|
|
|
|
Focused objects will be the ones having key events delivered
|
|
to, which the programmer can act upon by means of
|
|
\@ref evas_object_event_callback_add usage.
|
|
|
|
Note: Most users wouldn't be dealing directly with Evas'
|
|
focused objects. Instead, they would be using a higher level
|
|
library for that (like a toolkit, as Elementary) to handle
|
|
focus and who's receiving input for them.
|
|
|
|
This call returns the object that currently has focus on the
|
|
canvas $e or $null, if none.
|
|
|
|
See also \@ref evas_object_focus_set,
|
|
\@ref evas_object_focus_get, \@ref evas_object_key_grab,
|
|
\@ref evas_object_key_ungrab, @.seat_focus.get,
|
|
@Efl.Canvas.Object.seat_focus_check,
|
|
@Efl.Canvas.Object.seat_focus_add,
|
|
@Efl.Canvas.Object.seat_focus_del.
|
|
]]
|
|
/* FIXME-doc
|
|
Example:
|
|
@dontinclude evas-events.c
|
|
@skip evas_event_callback_add(d.canvas, EVAS_CALLBACK_CANVAS_OBJECT_FOCUS_IN,
|
|
@until evas_object_focus_set(d.bg, EINA_TRUE);
|
|
@dontinclude evas-events.c
|
|
@skip called when our rectangle gets focus
|
|
@until }
|
|
|
|
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
|
|
or $null if there is not one.]]
|
|
}
|
|
}
|
|
@property seat_focus {
|
|
[[Return the focused object by a given seat. @since 1.19]]
|
|
get {}
|
|
keys {
|
|
seat: Efl.Input.Device;[[The seat to fetch the focused
|
|
object or $null for the default seat.]]
|
|
}
|
|
values {
|
|
return: Efl.Canvas.Object; [[The object that has the focus or $null if
|
|
the seat has no focused object.]]
|
|
}
|
|
}
|
|
@property object_top {
|
|
get {
|
|
[[Get the highest (stacked) Evas object on the canvas $e.
|
|
|
|
This function will take all populated layers in the canvas
|
|
into account, getting the highest object for the highest
|
|
layer, naturally.
|
|
|
|
Warning: This function will skip objects parented by smart
|
|
objects, acting only on the ones at the "top level", with
|
|
regard to object parenting.
|
|
|
|
See also \@ref evas_object_layer_get,
|
|
\@ref evas_object_layer_set, \@ref evas_object_below_get,
|
|
\@ref evas_object_above_get.
|
|
]]
|
|
return: Efl.Canvas.Object @warn_unused; [[A pointer to the highest object
|
|
on it (if any) or $null otherwise.]]
|
|
}
|
|
}
|
|
@property pointer_canvas_xy_by_device {
|
|
[[This function returns the current known default pointer coordinates. @since 1.19]]
|
|
get {}
|
|
keys {
|
|
dev: Efl.Input.Device; [[The pointer device.]]
|
|
}
|
|
values {
|
|
x: int; [[The pointer to a Evas_Coord to be filled in.]]
|
|
y: int; [[The pointer to a Evas_Coord to be filled in.]]
|
|
}
|
|
}
|
|
@property pointer_canvas_xy {
|
|
get {
|
|
[[This function returns the current known default pointer coordinates
|
|
|
|
This function returns the current known canvas unit
|
|
coordinates of the mouse pointer and sets the contents of
|
|
the Evas_Coords pointed to by $x and $y to contain these
|
|
coordinates. If $e is not a valid canvas the results of
|
|
this function are undefined.
|
|
]]
|
|
/* FIXME-doc
|
|
Example:
|
|
@code
|
|
extern Evas *evas;
|
|
Evas_Coord mouse_x, mouse_y;
|
|
|
|
evas_pointer_output_xy_get(evas, &mouse_x, &mouse_y);
|
|
printf("Mouse is at canvas position %d, %d\n", mouse_x, mouse_y);
|
|
@endcode
|
|
*/
|
|
}
|
|
values {
|
|
x: int; [[The pointer to a Evas_Coord to be filled in.]]
|
|
y: int; [[The pointer to a Evas_Coord to be filled in.]]
|
|
}
|
|
}
|
|
@property event_down_count {
|
|
get {
|
|
[[Get the number of mouse or multi presses currently active.
|
|
|
|
@since 1.2
|
|
]]
|
|
return: int; [[Mouse or multi presses currently active]]
|
|
}
|
|
}
|
|
@property smart_objects_calculate_count {
|
|
get {
|
|
[[This gets the internal counter that counts the number of
|
|
smart calculations.
|
|
|
|
Whenever evas performs smart object calculations on the whole
|
|
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
|
|
generation/run if the calculations maybe cause self-feeding
|
|
effects.
|
|
|
|
@since 1.1
|
|
]]
|
|
return: int; [[Number of smart calculations]]
|
|
}
|
|
}
|
|
@property focus_state {
|
|
get {
|
|
[[Get the focus state for the default seat.]]
|
|
return: bool; [[$true if focused, $false otherwise]]
|
|
}
|
|
}
|
|
@property seat_focus_state {
|
|
[[Get the focus state by a given seat.]]
|
|
get {}
|
|
keys {
|
|
seat: Efl.Input.Device; [[The seat to check the focus state. Use $null for the default seat.]]
|
|
}
|
|
values {
|
|
return: bool; [[$true if the seat has the canvas focus, $false otherwise.]]
|
|
}
|
|
}
|
|
@property changed {
|
|
get {
|
|
[[Get the changed marker for the canvas.
|
|
|
|
@since 1.11
|
|
]]
|
|
return: bool; [[$true if changed, $false otherwise]]
|
|
}
|
|
}
|
|
@property pointer_output_xy_by_device {
|
|
[[This function returns the current known pointer coordinates. @since 1.19]]
|
|
get {}
|
|
keys {
|
|
dev: Efl.Input.Device; [[The mouse device.]]
|
|
}
|
|
values {
|
|
x: int; [[The pointer to an integer to be filled in.]]
|
|
y: int; [[The pointer to an integer to be filled in.]]
|
|
}
|
|
}
|
|
@property pointer_output_xy {
|
|
get {
|
|
[[This function returns the current known default pointer coordinates.
|
|
|
|
This function returns the current known screen/output
|
|
coordinates of the mouse pointer and sets the contents of
|
|
the integers pointed to by $x and $y to contain these
|
|
coordinates. If $e is not a valid canvas the results of
|
|
this function are undefined.
|
|
]]
|
|
/* FIXME-doc
|
|
Example:
|
|
@code
|
|
extern Evas *evas;
|
|
int mouse_x, mouse_y;
|
|
|
|
evas_pointer_output_xy_get(evas, &mouse_x, &mouse_y);
|
|
printf("Mouse is at screen position %i, %i\n", mouse_x, mouse_y);
|
|
@endcode
|
|
*/
|
|
}
|
|
values {
|
|
x: int; [[The pointer to an integer to be filled in.]]
|
|
y: int; [[The pointer to an integer to be filled in.]]
|
|
}
|
|
}
|
|
@property object_bottom {
|
|
get {
|
|
[[Get the lowest (stacked) Evas object on the canvas $e.
|
|
|
|
This function will take all populated layers in the canvas
|
|
into account, getting the lowest object for the lowest layer,
|
|
naturally.
|
|
|
|
Warning: This function will skip objects parented by smart
|
|
objects, acting only on the ones at the "top level", with
|
|
regard to object parenting.
|
|
|
|
See also \@ref evas_object_layer_get, \@ref evas_object_layer_set,
|
|
\@ref evas_object_below_get, \@ref evas_object_below_set.
|
|
]]
|
|
return: Efl.Canvas.Object @warn_unused; [[
|
|
A pointer to the lowest object on it, if any, or $null
|
|
otherwise.
|
|
]]
|
|
}
|
|
}
|
|
@property pointer_button_down_mask_by_device {
|
|
[[Returns a bitmask with the mouse buttons currently pressed,
|
|
set to 1.]]
|
|
keys {
|
|
dev: Efl.Input.Device; [[The mouse device.]]
|
|
}
|
|
get {}
|
|
values {
|
|
mask: uint; [[A bitmask of the currently depressed buttons on the canvas.]]
|
|
}
|
|
}
|
|
@property pointer_button_down_mask {
|
|
get {
|
|
[[Returns a bitmask with the default mouse buttons currently pressed,
|
|
set to 1.
|
|
|
|
Calling this function will return a 32-bit integer with the
|
|
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.
|
|
|
|
A canvas by default begins with no mouse buttons being
|
|
pressed and only pointer move events can alter that.
|
|
|
|
The least significant bit corresponds to the first mouse
|
|
button (button 1) and the most significant bit corresponds
|
|
to the last mouse button (button 32).
|
|
|
|
If $e is not a valid canvas, the return value is undefined.
|
|
]]
|
|
/* FIXME-doc
|
|
Example:
|
|
@code
|
|
extern Evas *evas;
|
|
unsigned int button_mask;
|
|
int i;
|
|
|
|
button_mask = evas_pointer_button_down_mask_get(evas);
|
|
printf("Buttons currently pressed:\n");
|
|
for (i = 0; i < 32; i++)
|
|
{
|
|
if ((button_mask & (1u << i)) != 0) printf("Button %i\n", i + 1);
|
|
}
|
|
@endcode
|
|
*/
|
|
return: uint @warn_unused; [[A bitmask of the currently depressed buttons on the canvas.]]
|
|
}
|
|
}
|
|
|
|
tree_objects_at_xy_get {
|
|
[[Retrieve a list of Evas objects lying over a given position in
|
|
a canvas.
|
|
|
|
This function will traverse all the layers of the given canvas,
|
|
from top to bottom, querying for objects with areas covering the
|
|
given position. It will enter the smart objects.
|
|
It will not append to the list pass events as hidden objects.
|
|
Call eina_list_free on the returned list after usage.
|
|
]]
|
|
return: list<Efl.Canvas.Object> @warn_unused; [[List of objects]]
|
|
params {
|
|
@in stop: Efl.Canvas.Object; [[An Evas Object where to stop searching.]]
|
|
@in x: int; [[The horizontal coordinate of the position.]]
|
|
@in y: int; [[The vertical coordinate of the position.]]
|
|
}
|
|
}
|
|
key_lock_on {
|
|
[[Enables or turns on programmatically the lock key with name
|
|
$keyname for the default seat.
|
|
|
|
The effect will be as if the key was put on its active state
|
|
after this call.
|
|
|
|
See also @.key_lock_add, @.key_lock_del, @.key_lock_del,
|
|
@.key_lock_off, @.seat_key_lock_on, @.seat_key_lock_off.
|
|
]]
|
|
params {
|
|
@in keyname: string @nonull; [[The name of the lock to enable.]]
|
|
}
|
|
}
|
|
seat_key_lock_on {
|
|
[[Enables or turns on programmatically the lock key with name
|
|
$keyname for a give seat.
|
|
|
|
The effect will be as if the key was put on its active state
|
|
after this call.
|
|
|
|
See also @.key_lock_add, @.key_lock_del, @.key_lock_del,
|
|
@.key_lock_off, @.key_lock_on, @.seat_key_lock_off.
|
|
@since 1.19
|
|
]]
|
|
params {
|
|
@in keyname: string @nonull; [[The name of the lock to enable.]]
|
|
@in seat: Efl.Input.Device; [[The seat to enable the keylock. A $null seat repesents the default seat.]]
|
|
}
|
|
}
|
|
seat_key_lock_off {
|
|
[[Disables or turns off programmatically the lock key with name
|
|
$keyname for a given seat.
|
|
|
|
The effect will be as if the key was put on its inactive state
|
|
after this call.
|
|
|
|
See also @.key_lock_on, @.seat_key_lock_on, @.key_lock_off.
|
|
@since 1.19
|
|
]]
|
|
params {
|
|
@in keyname: string @nonull; [[The name of the lock to enable.]]
|
|
@in seat: Efl.Input.Device; [[The seat to disable the keylock. A $null seat repesents the default seat.]]
|
|
}
|
|
}
|
|
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
|
|
are meant to be pressed together with others, altering the
|
|
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
|
|
at run time. It is then possible to set and unset modifier keys
|
|
programmatically for other parts of the program to check and act
|
|
on. Programmers using Evas would check for modifier keys on key
|
|
event callbacks using \@ref evas_key_modifier_is_set.
|
|
|
|
Note: If the programmer instantiates the canvas by means of the
|
|
\@ref ecore_evas_new family of helper functions, Ecore will take
|
|
care of registering on it all standard modifiers: "Shift",
|
|
"Control", "Alt", "Meta", "Hyper", "Super".
|
|
]]
|
|
params {
|
|
@in keyname: string @nonull; [[
|
|
The name of the modifier key to add to the list of
|
|
Evas modifiers.
|
|
]]
|
|
}
|
|
}
|
|
key_modifier_off {
|
|
[[Disables or turns off programmatically the modifier key with
|
|
name $keyname for the default seat.
|
|
|
|
See also @.key_modifier_add, \@ref evas_key_modifier_get,
|
|
@.key_modifier_on, @.seat_key_modifier_off,
|
|
@.seat_key_modifier_off, \@ref evas_key_modifier_is_set, \@ref evas_seat_key_modifier_is_set.
|
|
]]
|
|
params {
|
|
@in keyname: string @nonull; [[The name of the modifier to disable.]]
|
|
}
|
|
}
|
|
render_async {
|
|
[[Render the given Evas canvas asynchronously.
|
|
|
|
This function only returns $true when a frame will be rendered.
|
|
If the previous frame is still rendering, $false will be
|
|
returned so the users know not to wait for the updates
|
|
callback and just return to their main loop.
|
|
|
|
If a $func callback is given, a list of updated areas will be
|
|
generated and the function will be called from the main thread
|
|
after the rendered frame is flushed to the screen. The resulting
|
|
list should be freed with \@ref evas_render_updates_free.
|
|
|
|
The list is given in the $event_info parameter of the callback
|
|
function.
|
|
|
|
@since 1.8
|
|
]]
|
|
return: bool; [[$true if the canvas will render, $false otherwise.]]
|
|
}
|
|
render2 {
|
|
[[Render the given Evas canvas using the new rendering infra.
|
|
|
|
This is experimental and will change over time until noted here.
|
|
|
|
This function only returns $true when a frame will be rendered.
|
|
If the previous frame is still rendering, $false will be
|
|
returned so the users know not to wait for the updates
|
|
callback and just return to their main loop.
|
|
|
|
@since 1.14
|
|
]]
|
|
return: bool; [[$true if the canvas will render, $false otherwise.]]
|
|
}
|
|
render2_updates {
|
|
[[Render the given Evas canvas using the new rendering infra.
|
|
|
|
This is experimental and will change over time until noted here.
|
|
|
|
@since 1.15
|
|
]]
|
|
return: list<ptr(Eina.Rect)> @owned @warn_unused; [[
|
|
A newly allocated list of updated rectangles of the canvas
|
|
($Eina.Rect structs). Free this list with
|
|
\@ref evas_render_updates_free.
|
|
]]
|
|
}
|
|
focus_out {
|
|
[[Inform the evas that it lost the focus from the default seat.]]
|
|
}
|
|
norender {
|
|
[[Update the canvas internal objects but not triggering immediate
|
|
renderization.
|
|
|
|
This function updates the canvas internal objects not triggering
|
|
renderization. To force renderization function @.render
|
|
should be used.
|
|
]]
|
|
}
|
|
nochange_pop {
|
|
[[Pop the nochange flag down 1.
|
|
|
|
This tells evas, that while the nochange flag is greater than 0,
|
|
do not mark objects as "changed" when making changes.
|
|
|
|
Warning: Do not use this function unless you know what Evas
|
|
exactly works with "changed" state.
|
|
]]
|
|
}
|
|
key_lock_off {
|
|
[[Disables or turns off programmatically the lock key with name
|
|
$keyname for the default seat.
|
|
|
|
The effect will be as if the key was put on its inactive state
|
|
after this call.
|
|
|
|
See also @.key_lock_on, @.seat_key_lock_on, @.seat_key_lock_off.
|
|
]]
|
|
params {
|
|
@in keyname: string @nonull; [[The name of the lock to disable.]]
|
|
}
|
|
}
|
|
nochange_push {
|
|
[[Push the nochange flag up 1
|
|
|
|
This tells evas, that while the nochange flag is greater than 0,
|
|
do not mark objects as "changed" when making changes.
|
|
|
|
Warning: Do not use this function unless you know what Evas
|
|
exactly works with "changed" state.
|
|
]]
|
|
}
|
|
font_cache_flush {
|
|
[[Force the given evas and associated engine to flush its font cache.]]
|
|
|
|
}
|
|
key_modifier_on {
|
|
[[Enables or turns on programmatically the modifier key with name
|
|
$keyname for the default seat.
|
|
|
|
The effect will be as if the key was pressed for the whole time
|
|
between this call and a matching evas_key_modifier_off().
|
|
|
|
See also @.key_modifier_off, @.seat_key_modifier_on,
|
|
@.seat_key_modifier_off.
|
|
]]
|
|
params {
|
|
@in keyname: string @nonull; [[The name of the modifier to enable.]]
|
|
}
|
|
}
|
|
seat_key_modifier_on {
|
|
[[Enables or turns on programmatically the modifier key with name
|
|
$keyname for a given seat.
|
|
|
|
The effect will be as if the key was pressed for the whole time
|
|
between this call and a matching @.seat_key_modifier_off.
|
|
|
|
See also @.key_modifier_off, @.seat_key_modifier_on,
|
|
@.seat_key_modifier_off.
|
|
@since 1.19
|
|
]]
|
|
params {
|
|
@in keyname: string @nonull; [[The name of the lock to enable.]]
|
|
@in seat: Efl.Input.Device; [[The seat to enable the modifier. A $null seat repesents the default seat.]]
|
|
}
|
|
}
|
|
seat_key_modifier_off {
|
|
[[Disables or turns off programmatically the modifier key with
|
|
name $keyname for a given seat.
|
|
|
|
See also @.key_modifier_add, \@ref evas_key_modifier_get,
|
|
@.key_modifier_on, @.seat_key_modifier_off,
|
|
@.seat_key_modifier_off, \@ref evas_key_modifier_is_set, \@ref evas_seat_key_modifier_is_set.
|
|
@since 1.19
|
|
]]
|
|
params {
|
|
@in keyname: string @nonull; [[The name of the lock to enable.]]
|
|
@in seat: Efl.Input.Device; [[The seat to disable the modifier. A $null seat repesents the default seat.]]
|
|
}
|
|
}
|
|
font_available_list @const {
|
|
[[List of available font descriptions known or found by this evas.
|
|
|
|
The list depends on Evas compile time configuration, such as
|
|
fontconfig support, and the paths provided at runtime as
|
|
explained in \@ref Evas_Font_Path_Group.
|
|
]]
|
|
return: list<string> @warn_unused; [[
|
|
A newly allocated list of strings. Do not change the
|
|
strings. Be sure to call \@ref evas_font_available_list_free
|
|
after you're done.
|
|
]]
|
|
}
|
|
object_name_find @const {
|
|
[[Retrieves the object on the given evas with the given name.
|
|
|
|
This looks for the evas object given a name by
|
|
\@ref evas_object_name_set. If the name is not unique
|
|
canvas-wide, then which one of the many objects with that
|
|
name is returned is undefined, so only use this if you can
|
|
ensure the object name is unique.
|
|
]]
|
|
return: Efl.Canvas.Object @warn_unused; [[
|
|
If successful, the Evas object with the given name. Otherwise,
|
|
$null.
|
|
]]
|
|
params {
|
|
@in name: string; [[The given name.]]
|
|
}
|
|
}
|
|
font_path_append {
|
|
[[Appends a font path to the list of font paths used by the
|
|
given evas.
|
|
]]
|
|
params {
|
|
@in path: string @nonull; [[The new font path.]]
|
|
}
|
|
}
|
|
font_path_clear {
|
|
[[Removes all font paths loaded into memory for the given evas.]]
|
|
}
|
|
/* FIXME: The below function is only for efl.ui.win */
|
|
touch_point_list_nth_xy_get {
|
|
[[This function returns the nth touch point's coordinates.
|
|
|
|
Touch point's coordinates is updated whenever moving that point
|
|
on the canvas.
|
|
]]
|
|
params {
|
|
@in n: uint; [[The number of the touched point (0 being the first).]]
|
|
@out x: double; [[Last known X position in window coordinates]]
|
|
@out y: double; [[Last known Y position in window coordinates]]
|
|
}
|
|
/* Legacy uses int. */
|
|
legacy: null;
|
|
}
|
|
key_lock_del {
|
|
[[Removes the $keyname key from the current list of lock keys on
|
|
canvas $e.
|
|
]]
|
|
params {
|
|
@in keyname: string @nonull; [[The name of the key to remove from the locks list.]]
|
|
}
|
|
}
|
|
damage_rectangle_add {
|
|
[[Add a damage rectangle.
|
|
|
|
This is the function by which one tells evas that a part of the
|
|
canvas has to be repainted.
|
|
|
|
Note: All newly created Evas rectangles get the default color
|
|
values of 255 255 255 255 (opaque white).
|
|
]]
|
|
params {
|
|
@in x: int; [[The rectangle's left position.]]
|
|
@in y: int; [[The rectangle's top position.]]
|
|
@in w: int; [[The rectangle's width.]]
|
|
@in h: int; [[The rectangle's height.]]
|
|
}
|
|
}
|
|
sync {
|
|
[[Sync evas canvas]]
|
|
}
|
|
font_path_list @const {
|
|
[[Retrieves the list of font paths used by the given evas.]]
|
|
return: const(list<string>) @warn_unused; [[The list of font paths used.]]
|
|
}
|
|
image_cache_reload {
|
|
[[Reload the image cache.
|
|
|
|
This function reloads the image cache of canvas.
|
|
]]
|
|
|
|
}
|
|
coord_world_x_to_screen @const {
|
|
[[Convert/scale a canvas coordinate into output screen
|
|
coordinates.
|
|
|
|
This function takes in a horizontal coordinate as the $x
|
|
parameter and converts it into output units, accounting for
|
|
output size, viewport size and location, returning it as the
|
|
function return value. If $e is invalid, the results are
|
|
undefined.
|
|
]]
|
|
/* FIXME-doc
|
|
Example:
|
|
@code
|
|
extern Evas *evas;
|
|
int screen_x;
|
|
extern Evas_Coord canvas_x;
|
|
|
|
screen_x = evas_coord_world_x_to_screen(evas, canvas_x);
|
|
@endcode
|
|
*/
|
|
return: int @warn_unused; [[The output/screen coordinate translated to output coordinates.]]
|
|
params {
|
|
@in x: int; [[The canvas X coordinate.]]
|
|
}
|
|
}
|
|
render_updates {
|
|
[[Force immediate renderization of the given Evas canvas.
|
|
|
|
This function forces an immediate renderization update of
|
|
the given canvas $e.
|
|
|
|
Note: This is a very low level function, which most of Evas'
|
|
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
|
|
any changes and this call will be a no-op.
|
|
]]
|
|
/* FIXME-doc
|
|
Example code follows.
|
|
@dontinclude evas-events.c
|
|
@skip add an obscured
|
|
@until d.obscured = !d.obscured;
|
|
|
|
See the full @ref Example_Evas_Events "example".
|
|
*/
|
|
return: list<ptr(Eina.Rect)> @owned @warn_unused; [[
|
|
A newly allocated list of updated rectangles of the canvas
|
|
($Eina.Rect structs). Free this list with
|
|
\@ref evas_render_updates_free.
|
|
]]
|
|
}
|
|
image_cache_flush {
|
|
[[Flush the image cache of the canvas.
|
|
|
|
This function flushes image cache of canvas.
|
|
]]
|
|
}
|
|
coord_screen_y_to_world @const {
|
|
[[Convert/scale an output screen coordinate into canvas
|
|
coordinates.
|
|
|
|
This function takes in a vertical coordinate as the $y parameter
|
|
and converts it into canvas units, accounting for output size,
|
|
viewport size and location, returning it as the function return
|
|
value. If $e is invalid, the results are undefined.
|
|
]]
|
|
/* FIXME-doc
|
|
Example:
|
|
@code
|
|
extern Evas *evas;
|
|
extern int screen_y;
|
|
Evas_Coord canvas_y;
|
|
|
|
canvas_y = evas_coord_screen_y_to_world(evas, screen_y);
|
|
@endcode
|
|
*/
|
|
return: int @warn_unused; [[The screen coordinate translated to canvas unit coordinates.]]
|
|
params {
|
|
@in y: int; [[The screen/output y coordinate.]]
|
|
}
|
|
}
|
|
key_modifier_del {
|
|
[[Removes the $keyname key from the current list of modifier keys
|
|
on canvas $e.
|
|
|
|
See also @.key_modifier_add.
|
|
]]
|
|
params {
|
|
@in keyname: string @nonull; [[The name of the key to remove from the modifiers list.]]
|
|
}
|
|
}
|
|
focus_in {
|
|
[[Inform to the evas that it got the focus from the default seat.]]
|
|
}
|
|
seat_focus_in {
|
|
[[Inform to the evas that it got the focus from a given seat. @since 1.19]]
|
|
legacy: null;
|
|
params {
|
|
@in seat: Efl.Input.Device; [[The seat or $null for the default seat.]]
|
|
}
|
|
}
|
|
seat_focus_out {
|
|
[[Inform to the evas that it lost the focus from a given seat. @since 1.19]]
|
|
legacy: null;
|
|
params {
|
|
@in seat: Efl.Input.Device; [[The seat or $null for the default seat.]]
|
|
}
|
|
}
|
|
obscured_rectangle_add {
|
|
[[Add an "obscured region" to an Evas canvas.
|
|
|
|
This is the function by which one tells an Evas canvas that a
|
|
part of it must not be repainted. The region must be rectangular
|
|
and its coordinates inside the canvas viewport are passed in the
|
|
call. After this call, the region specified won't participate
|
|
in any form in Evas' calculations and actions during its
|
|
rendering updates, having its displaying content frozen as
|
|
it was just after this function took place.
|
|
|
|
We call it "obscured region" because the most common use case
|
|
for this rendering (partial) freeze is something else (most
|
|
probably other canvas) being on top of the specified rectangular
|
|
region, thus shading it completely from the user's final scene
|
|
in a display. To avoid unnecessary processing, one should
|
|
indicate to the obscured canvas not to bother about the
|
|
non-important area.
|
|
|
|
The majority of users won't have to worry about this function,
|
|
as they'll be using just one canvas in their applications, with
|
|
nothing inset or on top of it in any form.
|
|
|
|
To make this region one that has to be repainted again, call the
|
|
function \@ref evas_obscured_clear.
|
|
|
|
Note: This is a very low level function, which most of
|
|
Evas' users wouldn't care about.
|
|
|
|
Note: This function does not flag the canvas as having its state
|
|
changed. If you want to re-render it afterwards expecting new
|
|
contents, you have to add "damage" regions yourself (see
|
|
\@ref evas_damage_rectangle_add).
|
|
]]
|
|
/* FIXME-doc
|
|
Example code follows.
|
|
@dontinclude evas-events.c
|
|
@skip add an obscured
|
|
@until evas_obscured_clear(evas);
|
|
|
|
In that example, pressing the "Ctrl" and "o" keys will impose or
|
|
remove an obscured region in the middle of the canvas. You'll get
|
|
the same contents at the time the key was pressed, if toggling it
|
|
on, until you toggle it off again (make sure the animation is
|
|
running on to get the idea better). See the full @ref
|
|
Example_Evas_Events "example".
|
|
*/
|
|
params {
|
|
@in x: int; [[The rectangle's top left corner's horizontal coordinate.]]
|
|
@in y: int; [[The rectangle's top left corner's vertical coordinate.]]
|
|
@in w: int; [[The rectangle's width.]]
|
|
@in h: int; [[The rectangle's height.]]
|
|
}
|
|
}
|
|
render_dump {
|
|
[[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
|
|
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
|
|
@.render_idle_flush might discard too.
|
|
]]
|
|
}
|
|
render {
|
|
[[Force renderization of the given canvas.]]
|
|
|
|
}
|
|
font_path_prepend {
|
|
[[Prepends a font path to the list of font paths used by the
|
|
given evas.
|
|
]]
|
|
params {
|
|
@in path: string @nonull; [[The new font path.]]
|
|
}
|
|
}
|
|
obscured_clear {
|
|
[[Remove all "obscured regions" from an Evas canvas.
|
|
|
|
This function removes all the rectangles from the obscured
|
|
regions list of the canvas $e. It takes obscured areas added
|
|
with @.obscured_rectangle_add and make them again a regions
|
|
that have to be repainted on rendering updates.
|
|
|
|
Note: This is a very low level function, which most of
|
|
Evas' users wouldn't care about.
|
|
|
|
Note: This function does not flag the canvas as having its state
|
|
changed. If you want to re-render it afterwards expecting new
|
|
contents, you have to add "damage" regions yourself (see
|
|
@.damage_rectangle_add).
|
|
]]
|
|
}
|
|
coord_screen_x_to_world @const {
|
|
[[Convert/scale an output screen coordinate into canvas
|
|
coordinates.
|
|
|
|
This function takes in a horizontal coordinate as the $x
|
|
parameter and converts it into canvas units, accounting for
|
|
output size, viewport size and location, returning it as the
|
|
function return value. If $e is invalid, the results are
|
|
undefined.
|
|
]]
|
|
/* FIXME-doc
|
|
Example:
|
|
@code
|
|
extern Evas *evas;
|
|
extern int screen_x;
|
|
Evas_Coord canvas_x;
|
|
|
|
canvas_x = evas_coord_screen_x_to_world(evas, screen_x);
|
|
@endcode
|
|
*/
|
|
return: int @warn_unused; [[
|
|
The screen coordinate translated to canvas unit coordinates.
|
|
]]
|
|
params {
|
|
@in x: int; [[The screen/output x coordinate.]]
|
|
}
|
|
}
|
|
key_lock_add {
|
|
[[Adds the $keyname key to the current list of lock keys.
|
|
|
|
Locks are keys like caps lock, num lock or scroll lock, i.e.,
|
|
keys which are meant to be pressed once -- toggling a binary
|
|
state which is bound to it -- and thus altering the behavior
|
|
of all subsequently pressed keys somehow, depending on its
|
|
state. Evas is so that these keys can be defined by the user.
|
|
|
|
This allows custom locks to be added to the evas system at run
|
|
time. It is then possible to set and unset lock keys
|
|
programmatically for other parts of the program to check and act
|
|
on. Programmers using Evas would check for lock keys on key
|
|
event callbacks using \@ref evas_key_lock_is_set.
|
|
|
|
Note: If the programmer instantiates the canvas by means of the
|
|
ecore_evas_new() family of helper functions, Ecore will take
|
|
care of registering on it all standard lock keys: "Caps_Lock",
|
|
"Num_Lock", "Scroll_Lock".
|
|
]]
|
|
params {
|
|
@in keyname: string @nonull; [[The name of the key to add to the locks list.]]
|
|
}
|
|
}
|
|
render_idle_flush {
|
|
[[Make the canvas discard internally cached data used for
|
|
rendering.
|
|
|
|
This function flushes the arrays of delete, active and render
|
|
objects. Other things it may also discard are: shared memory
|
|
segments, temporary scratch buffers, cached data to avoid
|
|
re-compute of that data etc.
|
|
]]
|
|
}
|
|
@property default_device {
|
|
[[Return the default device of a given type.
|
|
|
|
Note: Currently EFL only creates a seat, mouse and keyboard.
|
|
@since 1.19
|
|
]]
|
|
get {}
|
|
keys {
|
|
type: Efl.Input.Device.Type; [[The class of the default device to fetch.]]
|
|
}
|
|
values {
|
|
seat: Efl.Input.Device; [[The default device or $null on error.]]
|
|
}
|
|
}
|
|
coord_world_y_to_screen @const {
|
|
[[Convert/scale a canvas coordinate into output screen
|
|
coordinates.
|
|
|
|
This function takes in a vertical coordinate as the $x
|
|
parameter and converts it into output units, accounting for
|
|
output size, viewport size and location, returning it as the
|
|
function return value. If $e is invalid, the results are
|
|
undefined.
|
|
]]
|
|
/* FIXME-doc
|
|
Example:
|
|
@code
|
|
extern Evas *evas;
|
|
int screen_y;
|
|
extern Evas_Coord canvas_y;
|
|
|
|
screen_y = evas_coord_world_y_to_screen(evas, canvas_y);
|
|
@endcode
|
|
*/
|
|
return: int @warn_unused; [[The output/screen coordinate translated to output coordinates.]]
|
|
params {
|
|
@in y: int; [[The canvas y coordinate.]]
|
|
}
|
|
}
|
|
}
|
|
implements {
|
|
Efl.Object.constructor;
|
|
Efl.Object.destructor;
|
|
Efl.Object.event_thaw;
|
|
Efl.Object.event_freeze;
|
|
Efl.Object.provider_find;
|
|
Efl.Loop.Consumer.loop { get; }
|
|
//Efl.Canvas.seats;
|
|
Efl.Canvas.Pointer.pointer_inside { get; }
|
|
Efl.Canvas.device { get; }
|
|
Efl.Canvas.seat { get; }
|
|
Efl.Canvas.image_max_size { get; }
|
|
Efl.Canvas.objects_at_xy_get;
|
|
Efl.Canvas.object_top_at_xy_get;
|
|
Efl.Canvas.objects_in_rectangle_get;
|
|
Efl.Canvas.object_top_in_rectangle_get;
|
|
Efl.Canvas.smart_objects_calculate;
|
|
Efl.Canvas.smart_objects_calculating { get; }
|
|
}
|
|
}
|