Low level Evas canvas functions. Sub groups will present more high level ones, though.

Most of these functions deal with low level Evas actions, like:

create/destroy raw canvases, not bound to any displaying engine
tell a canvas i got focused (in a windowing context, for example)
tell a canvas a region should not be calculated anymore in rendering
tell a canvas to render its contents, immediately

Most users will be using Evas by means of the Ecore_Evas wrapper, which deals with all the above mentioned issues automatically for them. Thus, you'll be looking at this section only if you're building low level stuff.

The groups within present you functions that deal with the canvas directly, too, and not yet with its objects. They are the functions you need to use at a minimum to get a working canvas.

Some of the functions in this group are exemplified here.

Functions
void	evas_render_updates_free (Eina_List *updates)
const Evas_Modifier *	evas_key_modifier_get (const Evas *obj)
	Returns a handle to the list of modifier keys registered in the canvas `e`.
Evas_Modifier_Mask	evas_key_modifier_mask_get (const Evas evas, const char keyname)
	Creates a bit mask from the `keyname` modifier key. Values returned from different calls to it may be ORed together, naturally.
const Evas_Lock *	evas_key_lock_get (const Evas *obj)
	Returns a handle to the list of lock keys registered in the canvas `e`.
Eina_Bool	evas_pointer_inside_by_device_get (const Evas obj, Efl_Input_Device dev)
	Returns whether the mouse pointer is logically inside the canvas.
Eina_Bool	evas_pointer_inside_get (const Evas *obj)
	Returns whether the default mouse pointer is logically inside the canvas.
void	evas_output_view_get (const Evas_Out obj, Evas_Coord x, Evas_Coord y, Evas_Coord w, Evas_Coord *h) EINA_DEPRECATED
	Gets the viewport region of the canvas that the output display.
void	evas_output_framespace_set (Evas *e, Evas_Coord x, Evas_Coord y, Evas_Coord w, Evas_Coord h)
	Sets the output framespace size of the render engine of the given evas.
void	evas_output_framespace_get (const Evas e, Evas_Coord x, Evas_Coord y, Evas_Coord w, Evas_Coord *h)
	Get the render engine's output framespace coordinates in canvas units.
void	evas_output_viewport_set (Evas *e, Evas_Coord x, Evas_Coord y, Evas_Coord w, Evas_Coord h)
	Sets the output viewport of the given evas in evas units.
void	evas_output_viewport_get (const Evas e, Evas_Coord x, Evas_Coord y, Evas_Coord w, Evas_Coord *h)
	Get the render engine's output viewport coordinates in canvas units.
void	evas_output_method_set (Evas *e, int render_method)
	Sets the output engine for the given evas.
int	evas_output_method_get (const Evas *e)
	Retrieves the number of the output engine used for the given evas.
void	evas_output_size_set (Evas *e, int w, int h)
	Sets the output size of the render engine of the given evas.
void	evas_output_size_get (const Evas e, int w, int *h)
	Retrieve the output size of the render engine of the given evas.
Typedefs
typedef Eo	Evas
typedef struct _Evas_Public_Data	Evas_Public_Data

Typedef Documentation

Evas

An opaque handle to an Evas canvas.

See also:: evas_new(); evas_free()

Evas_Public_Data

Public data for an Evas.

Function Documentation

Evas_Engine_Info* evas_engine_info_get ( const Evas * obj )

Retrieves the current render engine info struct from the given evas.

The returned structure is publicly modifiable. The contents are valid until either evas_engine_info_set or evas_render are called.

This structure does not need to be freed by the caller.

Returns:: The pointer to the engine info to use.

Since :: 2.3

Examples:: evas-buffer-simple.c.

Eina_Bool evas_engine_info_set	(	Evas *	obj,
		Evas_Engine_Info *	info
	)

Applies the engine settings for the given evas from the given Evas_Engine_Info structure.

To get the Evas_Engine_Info structure to use, call evas_engine_info_get. Do not try to obtain a pointer to an Evas_Engine_Info structure in any other way.

You will need to call this function at least once before you can create objects on an evas or render that evas. Some engines allow their settings to be changed more than once.

Once called, the info pointer should be considered invalid.

Parameters:

[in] info The pointer to the engine info to use.

Returns:: true if no error occurred, false otherwise.

Since :: 2.3

Examples:: evas-buffer-simple.c.

Eina_Bool evas_font_hinting_can_hint	(	const Evas *	e,
		Evas_Font_Hinting_Flags	hinting
	)

Checks if the font hinting is supported by the given evas.

One of #EVAS_FONT_HINTING_NONE, #EVAS_FONT_HINTING_AUTO, #EVAS_FONT_HINTING_BYTECODE.

Parameters:

[in] hinting The hinting to use.

Returns:: true if it is supported, false otherwise.

Since :: 3.0f(2.3.1)

void evas_free ( Evas * e )

Frees the given evas and any objects created on it.

Any objects with 'free' callbacks will have those callbacks called in this function.

Parameters:

e	The given evas.

Since :: 2.3

Examples:: evas-buffer-simple.c.

const Evas_Lock* evas_key_lock_get ( const Evas * obj )

Returns a handle to the list of lock keys registered in the canvas e.

This is required to check for which locks are set at a given time with the evas_key_lock_is_set function.

Returns:: An Evas_Lock handle to query Evas' keys subsystem with evas_key_lock_is_set or evas_seat_key_lock_is_set, or null on error.

Since :: 2.3

const Evas_Modifier* evas_key_modifier_get ( const Evas * obj )

Returns a handle to the list of modifier keys registered in the canvas e.

This is required to check for which modifiers are set at a given time with the evas_key_modifier_is_set function.

See also evas_key_modifier_add, evas_key_modifier_del, evas_key_modifier_on, evas_key_modifier_off, evas_seat_key_modifier_on, evas_seat_key_modifier_off.

Returns:: An Evas_Modifier handle to query Evas' keys subsystem with evas_key_modifier_is_set or evas_seat_key_modifier_is_set, or null on error.

Since :: 2.3

Examples:: edje-box2.c, evas-aspect-hints.c, evas-box.c, evas-events.c, evas-hints.c, and web_example_02.c.

Evas_Modifier_Mask evas_key_modifier_mask_get	(	const Evas *	evas,
		const char *	keyname
	)

Creates a bit mask from the keyname modifier key. Values returned from different calls to it may be ORed together, naturally.

This function is meant to be using in conjunction with evas_object_key_grab/@ref evas_object_key_ungrab. Go check their documentation for more information.

See also evas_key_modifier_add, evas_key_modifier_get, evas_key_modifier_on, evas_key_modifier_off, evas_seat_key_modifier_on, evas_seat_key_modifier_off, evas_key_modifier_is_set, evas_seat_key_modifier_is_set..

Parameters:

[in] keyname The name of the modifier key to create the mask for.

Returns:: The bit mask or 0 if the keyname key wasn't registered as a modifier for canvas e.

Since :: 2.3

Examples:: evas-events.c, and web_example_02.c.

Evas* evas_new ( void )

Creates a new empty evas.

Note that before you can use the evas, you will to at a minimum:

Set its render method with evas_output_method_set .
Set its viewport size with evas_output_viewport_set .
Set its size of the canvas with evas_output_size_set .
Ensure that the render engine is given the correct settings with evas_engine_info_set .

This function should only fail if the memory allocation fails

Note:: this function is very low level. Instead of using it directly, consider using the high level functions in Ecore_Evas wrapper/helper set of functions such as ecore_evas_new(). See Ecore.

Attention:: it is recommended that one calls evas_init() before creating new canvas.

Returns:: A new uninitialised Evas canvas on success. Otherwise, NULL.

Since :: 2.3

Examples:: evas-buffer-simple.c.

Evas_Object* evas_object_smart_add	(	Evas *	e,
		Evas_Smart *	s
	)

Instantiates a new smart object described by s.

Parameters:

e	the canvas on which to add the object
s	the #Evas_Smart describing the smart object

Returns:: a new Evas_Object handle

This is the function one should use when defining the public function adding an instance of the new smart object to a given canvas. It will take care of setting all of its internals to work as they should, if the user set things properly, as seem on the EVAS_SMART_SUBCLASS_NEW, for example.

Since :: 2.3

Examples:: evas-smart-interface.c, and evas-smart-object.c.

void evas_object_smart_calculate ( Evas_Object * obj )

Call the calculate() smart function immediately on a given smart object.

This will force immediate calculations (see Evas_Smart_Class) needed for renderization of this object and, besides, unset the flag on it telling it needs recalculation for the next rendering phase.

Since :: 3.0f(2.3.1)

void evas_object_smart_callback_add	(	Evas_Object *	obj,
		const char *	event,
		Evas_Smart_Cb	func,
		const void *	data
	)

Add (register) a callback function to the smart event specified by event on the smart object obj.

Parameters:

obj	a smart object
event	the event's name string
func	the callback function
data	user data to be passed to the callback function

Smart callbacks look very similar to Evas callbacks, but are implemented as smart object's custom ones.

This function adds a function callback to an smart object when the event named event occurs in it. The function is func.

In the event of a memory allocation error during addition of the callback to the object, evas_alloc_error() should be used to determine the nature of the error, if any, and the program should sensibly try and recover.

A smart callback function must have the ::Evas_Smart_Cb prototype definition. The first parameter (data) in this definition will have the same value passed to evas_object_smart_callback_add() as the data parameter, at runtime. The second parameter obj is a handle to the object on which the event occurred. The third parameter, event_info, is a pointer to data which is totally dependent on the smart object's implementation and semantic for the given event.

There is an infrastructure for introspection on smart objects' events (see evas_smart_callbacks_descriptions_get()), but no internal smart objects on Evas implement them yet.

See also:: Smart events and callbacks for more details.; evas_object_smart_callback_del()

Since :: 2.3

Examples:: actionslider_example_01.c, bg_example_03.c, box_example_02.c, bubble_example_01.c, button_example_00.c, button_example_01.c, calendar_example_05.c, calendar_example_06.c, check_example_01.c, codegen_example.c, colorselector_example_01.c, combobox_example_01.c, ctxpopup_example_01.c, dayselector_example.c, diskselector_example_02.c, efl_thread_1.c, efl_thread_2.c, efl_thread_3.c, efl_thread_4.c, efl_thread_5.c, entry_example.c, evas-smart-interface.c, evas-smart-object.c, fileselector_button_example.c, fileselector_entry_example.c, fileselector_example.c, flip_example_01.c, flipselector_example.c, general_funcs_example.c, gengrid_example.c, genlist_example_02.c, genlist_example_04.c, genlist_example_05.c, glview_example_01.c, hover_example_01.c, hoversel_example_01.c, index_example_01.c, index_example_02.c, inwin_example.c, layout_example_01.c, layout_example_03.c, list_example_03.c, map_example_01.c, map_example_02.c, map_example_03.c, mapbuf_example.c, menu_example_01.c, naviframe_example.c, notify_example_01.c, panes_example.c, photocam_example_01.c, popup_example_01.c, popup_example_02.c, popup_example_03.c, prefs_example_01.c, prefs_example_02.c, prefs_example_03.c, progressbar_example.c, radio_example_01.c, slider_example.c, slideshow_example.c, spinner_example.c, theme_example_01.c, theme_example_02.c, thumb_example_01.c, transit_example_03.c, transit_example_04.c, web_example_02.c, and win_example.c.

void evas_object_smart_callback_call	(	Evas_Object *	obj,
		const char *	event,
		void *	event_info
	)

Call a given smart callback on the smart object obj.

Parameters:

obj	the smart object
event	the event's name string
event_info	pointer to an event specific struct or information to pass to the callback functions registered on this smart event

This should be called internally, from the smart object's own code, when some specific event has occurred and the implementor wants is to pertain to the object's events API (see Smart events and callbacks). The documentation for the smart object should include a list of possible events and what type of event_info to expect for each of them. Also, when defining an Evas_Smart_Class, smart object implementors are strongly encouraged to properly set the Evas_Smart_Class::callbacks callbacks description array, so that the users of the smart object can have introspection on its events API at run time.

Since :: 2.3

Examples:: evas-smart-interface.c, and evas-smart-object.c.

void* evas_object_smart_callback_del	(	Evas_Object *	obj,
		const char *	event,
		Evas_Smart_Cb	func
	)

Delete (unregister) a callback function from the smart event specified by event on the smart object obj.

Parameters:

obj	a smart object
event	the event's name string
func	the callback function

Returns:: the data pointer

This function removes the first added smart callback on the object obj matching the event name event and the registered function pointer func. If the removal is successful it will also return the data pointer that was passed to evas_object_smart_callback_add() (that will be the same as the parameter) when the callback(s) was(were) added to the canvas. If not successful NULL will be returned.

See also:: evas_object_smart_callback_add() for more details.

Since :: 2.3

void* evas_object_smart_callback_del_full	(	Evas_Object *	obj,
		const char *	event,
		Evas_Smart_Cb	func,
		const void *	data
	)

Delete (unregister) a callback function from the smart event specified by event on the smart object obj.

Parameters:

obj	a smart object
event	the event's name string
func	the callback function
data	the data pointer that was passed to the callback

Returns:: the data pointer

This function removes the first added smart callback on the object obj matching the event name event, the registered function pointer func and the callback data pointer data. If the removal is successful it will also return the data pointer that was passed to evas_object_smart_callback_add() (that will be the same as the parameter) when the callback(s) was(were) added to the canvas. If not successful NULL will be returned. A common use would be to remove an exact match of a callback

See also:: evas_object_smart_callback_add() for more details.

Since (EFL) :: 1.2

Note:: To delete all smart event callbacks which match type and func, use evas_object_smart_callback_del().

Since :: 2.3

void evas_object_smart_callback_description_find	(	const Evas_Object *	obj,
		const char *	name,
		const Evas_Smart_Cb_Description **	class_description,
		const Evas_Smart_Cb_Description **	instance_description
	)

Find callback description for callback called name or null if not found.

If parameter is null, no search will be done on instance descriptions.

Parameters:

[in]	name	name of desired callback, must not be `null`. The search have a special case for name being the same pointer as registered with Evas_Smart_Cb_Description, one can use it to avoid excessive use of strcmp().
[out]	class_description	pointer to return class description or `null` if not found. If parameter is `null`, no search will be done on class descriptions.
[out]	instance_description	pointer to return instance description.

Since :: 3.0f(2.3.1)

void evas_object_smart_callback_priority_add	(	Evas_Object *	obj,
		const char *	event,
		Evas_Callback_Priority	priority,
		Evas_Smart_Cb	func,
		const void *	data
	)

Add (register) a callback function to the smart event specified by event on the smart object obj. Except for the priority field, it's exactly the same as evas_object_smart_callback_add

Parameters:

obj	a smart object
event	the event's name string
priority	The priority of the callback, lower values called first.
func	the callback function
data	user data to be passed to the callback function

See also:: evas_object_smart_callback_add

Since (EFL) :: 1.1

Since :: 3.0f(2.3.1)

void evas_object_smart_callbacks_descriptions_get	(	const Evas_Object *	obj,
		const Evas_Smart_Cb_Description ***	class_descriptions,
		unsigned int *	class_count,
		const Evas_Smart_Cb_Description ***	instance_descriptions,
		unsigned int *	instance_count
	)

Retrieve an smart object's know smart callback descriptions (both instance and class ones).

This call searches for registered callback descriptions for both instance and class of the given smart object. These arrays will be sorted by Evas_Smart_Cb_Description.name and also null terminated, so both class_count and instance_count can be ignored, if the caller wishes so. The terminator null is not counted in these values.

Note:: If just class descriptions are of interest, try evas_smart_callbacks_descriptions_get() instead.; Use null pointers on the descriptions/counters you're not interested in: they'll be ignored by the function.

evas_smart_callbacks_descriptions_get().

Parameters:

[out]	class_descriptions	Where to store class callbacks descriptions array, if any is known. If no descriptions are known, `null` is returned.
[out]	class_count	Returns how many class callbacks descriptions are known.
[out]	instance_descriptions	Where to store instance callbacks descriptions array, if any is known. If no descriptions are known, `null` is returned.
[out]	instance_count	Returns how many instance callbacks descriptions are known.

Since :: 2.3

Examples:: evas-smart-interface.c, and evas-smart-object.c.

Eina_Bool evas_object_smart_callbacks_descriptions_set	(	Evas_Object *	obj,
		const Evas_Smart_Cb_Description *	descriptions
	)

Set an smart object instance's smart callbacks descriptions.

These descriptions are hints to be used by introspection and are not enforced in any way.

It will not be checked if instance callbacks descriptions have the same name as respective possibly registered in the smart object class. Both are kept in different arrays and users of evas_object_smart_callbacks_descriptions_get() should handle this case as they wish.

Note:: Because descriptions must be null terminated, and because a null name makes little sense, too, Evas_Smart_Cb_Description.name must not be null.; While instance callbacks descriptions are possible, they are not recommended. Use class callbacks descriptions instead as they make you smart object user's life simpler and will use less memory, as descriptions and arrays will be shared among all instances.

Parameters:

[in] descriptions null terminated array with Evas_Smart_Cb_Description descriptions. Array elements won't be modified at run time, but references to them and their contents will be made, so this array should be kept alive during the whole object's lifetime.

Returns:: true on success, false on failure.

Since :: 2.3

void evas_object_smart_changed ( Evas_Object * obj )

Mark smart object as changed, dirty.

This will flag the given object as needing recalculation, forcefully. As an effect, on the next rendering cycle its calculate() (see Evas_Smart_Class) smart function will be called.

Since :: 2.3

Examples:: evas-aspect-hints.c, evas-smart-interface.c, and evas-smart-object.c.

Evas_Object* evas_object_smart_clipped_clipper_get ( const Evas_Object * obj )

Get the clipper object for the given clipped smart object.

Use this function if you want to change any of this clipper's properties, like colors.

Since :: 3.0f(2.3.1)

Examples:: evas-smart-interface.c, and evas-smart-object.c.

void* evas_object_smart_data_get ( const Evas_Object * obj )

Since :: 2.3

void evas_object_smart_data_set	(	Evas_Object *	obj,
		void *	data
	)

Store a pointer to user data for a given smart object.

This data is stored independently of the one set by evas_object_data_set(), naturally.

See also evas_object_smart_data_get.

Parameters:

[in] data A pointer to user data.

Since :: 2.3

void* evas_object_smart_interface_data_get	(	const Evas_Object *	obj,
		const Evas_Smart_Interface *	iface
	)

Retrieve an Evas smart object interface's private data.

Parameters:

obj	An Evas smart object.
iface	The given object's interface handle.

Since (EFL) :: 1.7

Returns:: The object interface's private data blob pointer, if found, NULL otherwise.

Since :: 3.0f(2.3.1)

Examples:: evas-smart-interface.c.

const void* evas_object_smart_interface_get	(	const Evas_Object *	obj,
		const char *	name
	)

Retrieve an Evas smart object's interface, by name string pointer.

Parameters:

obj	An Evas smart object.
name	Name string of the desired interface, which must be the same pointer used at the interface's declarion, when creating the smart object obj.

Since (EFL) :: 1.7

Returns:: The interface's handle pointer, if found, NULL otherwise.

Since :: 3.0f(2.3.1)

Examples:: evas-smart-interface.c.

Eina_Iterator* evas_object_smart_iterator_new ( const Evas_Object * obj )

Retrieves an iterator of the member objects of a given Evas smart object.

See also Efl::Canvas::Group::group_member_add and Efl::Canvas::Group::group_member_remove

Returns:: Returns the iterator of the member objects of obj.

Since (EFL) :: 1.8

Since :: 3.0f(2.3.1)

void evas_object_smart_member_add	(	Evas_Object *	obj,
		Evas_Object *	smart_obj
	)

Set an Evas object as a member of a given smart object.

Parameters:

obj	The member object
smart_obj	The smart object

Members will automatically be stacked and layered together with the smart object. The various stacking functions will operate on members relative to the other members instead of the entire canvas, since they now live on an exclusive layer (see evas_object_stack_above(), for more details).

Any smart_obj object's specific implementation of the member_add() smart function will take place too, naturally.

See also:: evas_object_smart_member_del(); evas_object_smart_members_get()

Since :: 2.3

Examples:: evas-smart-interface.c, and evas-smart-object.c.

void evas_object_smart_member_del ( Evas_Object * obj )

Removes a member object from a given smart object.

Parameters:

obj	the member object

This removes a member object from a smart object, if it was added to any. The object will still be on the canvas, but no longer associated with whichever smart object it was associated with.

See also:: evas_object_smart_member_add() for more details; evas_object_smart_members_get()

Since :: 2.3

Examples:: evas-smart-interface.c, and evas-smart-object.c.

Eina_List* evas_object_smart_members_get ( const Evas_Object * obj )

Retrieves the list of the member objects of a given Evas smart object.

The returned list should be freed with eina_list_free() when you no longer need it.

This function will return null when a non-smart object is passed.

See also Efl::Canvas::Group::group_member_add, Efl::Canvas::Group::group_member_remove and evas_object_smart_iterator_new.

Returns:: Returns the list of the member objects of obj.

Since (EFL) :: 1.7

Since :: 2.3

void evas_object_smart_move_children_relative	(	Evas_Object *	obj,
		Evas_Coord	dx,
		Evas_Coord	dy
	)

Moves all children objects of a given smart object relative to a given offset.

This will make each of 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 move functions.; Clipped smart objects already make use of this function on their move smart function definition.

Parameters:

[in]	dx	Horizontal offset (delta).
[in]	dy	Vertical offset (delta).

Since :: 3.0f(2.3.1)

Eina_Bool evas_object_smart_need_recalculate_get ( const Evas_Object * obj )

Get the value of the flag signalling that a given smart object needs to get recalculated.

Note:: this flag will be unset during the rendering phase, when the calculate() smart function is called, if one is provided. If it's not provided, then the flag will be left unchanged after the rendering phase.

See also evas_object_smart_need_recalculate_set, for more details.

Returns:: whether one wants to set ($true) or to unset ($false) the flag.

Since :: 3.0f(2.3.1)

void evas_object_smart_need_recalculate_set	(	Evas_Object *	obj,
		Eina_Bool	value
	)

Set or unset the flag signalling that a given smart object needs to get recalculated.

If this flag is set, then the calculate() smart function of obj will be called, if one is provided, during rendering phase of Evas (see evas_render()), after which this flag will be automatically unset.

If that smart function is not provided for the given object, this flag will be left unchanged.

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 evas_object_smart_changed(), that will also call this function automatically, with true as parameter.

Parameters:

[in] value whether one wants to set ($true) or to unset ($false) the flag.

Since :: 3.0f(2.3.1)

Evas_Smart* evas_object_smart_smart_get ( const Evas_Object * obj )

Get the Evas_Smart from which obj smart object was created.

Returns:: the Evas_Smart handle or null, on errors.

Since :: 3.0f(2.3.1)

Eina_Bool evas_object_smart_type_check	(	const Evas_Object *	obj,
		const char *	type
	)

Checks whether a given smart object or any of its smart object parents is of a given smart class.

If 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 efl_isa instead if your object is using Eo from top to bottom.

The checks use smart classes names and string comparison. There is a version of this same check using pointer comparison, since a smart class' name is a single string in Evas.

Parameters:

[in] type The name (type) of the smart class to check for.

Since :: 2.3

Examples:: evas-smart-interface.c, and evas-smart-object.c.

Eina_Bool evas_object_smart_type_check_ptr	(	const Evas_Object *	obj,
		const char *	type
	)

Checks whether a given smart object or any of its smart object parents is of a given smart class, using pointer comparison.

Parameters:

[in] type The type (name string) to check for. Must be the name.

Returns:: true if obj or any of its parents is of type type, false otherwise.

Since :: 3.0f(2.3.1)

Evas_Object* evas_object_top_in_rectangle_get	(	const Eo *	obj,
		int	x,
		int	y,
		int	w,
		int	h,
		Eina_Bool	include_pass_events_objects,
		Eina_Bool	include_hidden_objects
	)

Retrieve the Evas object stacked at the top of a given rectangular region in a canvas.

This function will traverse all the layers of the given canvas, from top to bottom, querying for objects with areas overlapping with the given rectangular region inside e. The user can remove from the query objects which are hidden and/or which are set to pass events.

Warning:: This function will skip objects parented by smart objects, acting only on the ones at the "top level", with regard to object parenting.

Parameters:

[in]	obj	The object.
[in]	x	The top left corner's horizontal coordinate for the rectangular region.
[in]	y	The top left corner's vertical coordinate for the rectangular region.
[in]	w	The width of the rectangular region.
[in]	h	The height of the rectangular region.
[in]	include_pass_events_objects	Boolean flag to include or not objects which pass events in this calculation.
[in]	include_hidden_objects	Boolean flag to include or not hidden objects in this calculation.

Returns:: The Evas object that is over all other objects at the given rectangular region. 3.0f(2.3.1)

void evas_output_framespace_get	(	const Evas *	e,
		Evas_Coord *	x,
		Evas_Coord *	y,
		Evas_Coord *	w,
		Evas_Coord *	h
	)

Get the render engine's output framespace coordinates in canvas units.

Parameters:

[out]	x	The left coordinate in output units, usually pixels.
[out]	y	The top coordinate in output units, usually pixels.
[out]	w	The width in output units, usually pixels.
[out]	h	The height in output units, usually pixels.

Since (EFL) :: 1.1

Since :: 2.3

void evas_output_framespace_set	(	Evas *	e,
		Evas_Coord	x,
		Evas_Coord	y,
		Evas_Coord	w,
		Evas_Coord	h
	)

Sets the output framespace size of the render engine of the given evas.

The framespace size is used in the Wayland engines to denote space in the viewport which is occupied by the window frame. This is mainly used in ecore_evas to draw borders.

The units used for w and h depend on the engine used by the evas.

Parameters:

[in]	x	The left coordinate in output units, usually pixels.
[in]	y	The top coordinate in output units, usually pixels.
[in]	w	The width in output units, usually pixels.
[in]	h	The height in output units, usually pixels.

Since (EFL) :: 1.1

Since :: 2.3

int evas_output_method_get ( const Evas * e )

Retrieves the number of the output engine used for the given evas.

Returns:: The numeric engine value to use.

Since :: 2.3

void evas_output_method_set	(	Evas *	e,
		int	render_method
	)

Sets the output engine for the given evas.

Once the output engine for an evas is set, any attempt to change it will be ignored. The value for render_method can be found using evas_render_method_lookup.

Note:: it is mandatory that one calls evas_init before setting the output method.

Parameters:

[in] render_method The numeric engine value to use.

Since :: 2.3

Examples:: evas-buffer-simple.c.

void evas_output_size_get	(	const Evas *	e,
		int *	w,
		int *	h
	)

Retrieve the output size of the render engine of the given evas.

The output size is given in whatever the output units are for the engine.

If either w or h is null, then it is ignored. If e is invalid, the returned results are undefined.

Parameters:

[out]	w	The width in output units, usually pixels.
[out]	h	The height in output units, usually pixels.

Since :: 2.3

Examples:: ecore_evas_buffer_example_01.c, evas-buffer-simple.c, and evas-map-utils.c.

void evas_output_size_set	(	Evas *	e,
		int	w,
		int	h
	)

Sets the output size of the render engine of the given evas.

The evas will render to a rectangle of the given size once this function is called. The output size is independent of the viewport size. The viewport will be stretched to fill the given rectangle.

The units used for w and h depend on the engine used by the evas.

Parameters:

[in]	w	The width in output units, usually pixels.
[in]	h	The height in output units, usually pixels.

Since :: 2.3

Examples:: evas-buffer-simple.c.

void evas_output_view_get	(	const Evas_Out *	obj,
		Evas_Coord *	x,
		Evas_Coord *	y,
		Evas_Coord *	w,
		Evas_Coord *	h
	)

Gets the viewport region of the canvas that the output display.

Parameters:

[in]	obj	The object
[out]	x
[out]	y
[out]	w
[out]	h

Since :: 3.0

Deprecated:: evas_output_view_get

void evas_output_viewport_get	(	const Evas *	e,
		Evas_Coord *	x,
		Evas_Coord *	y,
		Evas_Coord *	w,
		Evas_Coord *	h
	)

Get the render engine's output viewport coordinates in canvas units.

Calling this function writes the current canvas output viewport size and location values into the variables pointed to by x, y, w and h. On success the variables have the output location and size values written to them in canvas units. Any of x, y, w or h that are null will not be written to. If e is invalid, the results are undefined.

Parameters:

[out]	x	The top-left corner x value of the viewport.
[out]	y	The top-left corner y value of the viewport.
[out]	w	The width of the viewport. Must be greater than 0.
[out]	h	The height of the viewport. Must be greater than 0.

Since :: 2.3

Examples:: evas-events.c.

void evas_output_viewport_set	(	Evas *	e,
		Evas_Coord	x,
		Evas_Coord	y,
		Evas_Coord	w,
		Evas_Coord	h
	)

Sets the output viewport of the given evas in evas units.

The output viewport is the area of the evas that will be visible to the viewer. The viewport will be stretched to fit the output target of the evas when rendering is performed.

Note:: The coordinate values do not have to map 1-to-1 with the output target. However, it is generally advised that it is done for ease of use.

Parameters:

[in]	x	The top-left corner x value of the viewport.
[in]	y	The top-left corner y value of the viewport.
[in]	w	The width of the viewport. Must be greater than 0.
[in]	h	The height of the viewport. Must be greater than 0.

Since :: 2.3

Examples:: evas-buffer-simple.c.

Eina_Bool evas_pointer_inside_by_device_get	(	const Evas *	obj,
		Efl_Input_Device *	dev
	)

Returns whether the mouse pointer is logically inside the canvas.

Parameters:

[in]	obj	The object.
[in]	dev	The pointer device.

Returns:: true if the pointer is inside, false otherwise.

Since (EFL) :: 1.19

Eina_Bool evas_pointer_inside_get ( const Evas * obj )

Returns whether the default mouse pointer is logically inside the canvas.

When this function is called it will return a value of either false or true, depending on if event_feed_mouse_in or event_feed_mouse_out have been called to feed in a mouse enter event into the canvas.

A return value of true indicates the mouse is logically inside the canvas, and false implies it is logically outside the canvas.

A canvas begins with the mouse being assumed outside ($false).

If e is not a valid canvas, the return value is undefined.

Parameters:

[in] obj The object.

Returns:: true if the mouse pointer is inside the canvas, false otherwise

Since :: 2.3

void evas_render_updates_free ( Eina_List * updates )

Free the rectangles returned by evas_render_updates().

Parameters:

updates The list of updated rectangles of the canvas.

This function removes the region from the render updates list. It makes the region doesn't be render updated anymore.

See also:: evas_render_updates() for an example

Since :: 2.3

Examples:: evas-buffer-simple.c, and evas-events.c.

void evas_smart_objects_calculate ( Eo * obj )

Call user-provided calculate smart functions and unset the flag signalling that the object needs to get recalculated to all smart objects in the canvas.

Since :: 2.3

Examples:: map_example_01.c, map_example_02.c, and map_example_03.c.

Eina_Bool evas_smart_objects_calculating_get ( const Eo * obj )

Get if the canvas is currently calculating smart objects.

Parameters:

[in] obj The object.

Returns:: true if currently calculating smart objects.

Functions

Typedefs

Typedef Documentation

Function Documentation