Data Structures
struct	address_const_of

struct	address_of

Public Member Functions
bool	clipees_has () const
	Test if any object is clipped by `obj`. More...

bool	key_grab (std::string keyname_, Evas_Modifier_Mask modifiers_, Evas_Modifier_Mask not_modifiers_, bool exclusive_) const
	Requests `keyname` key events be directed to `obj`. More...

void	stack_below (::evas::object below_) const
	Stack `obj` immediately below `below`. More...

void	raise () const
	Raise `obj` to the top of its layer. More...

void	stack_above (::evas::object above_) const
	Stack `obj` immediately above `above`. More...

bool	smart_type_check (std::string type_) const
	Checks whether a given smart object or any of its smart object parents is of a given smart class. More...

::efl::eina::optional< ::evas::object >	name_child_find (::efl::eina::optional< std::string > name_, int recurse_) const
	Retrieves the object from children of the given object with the given name. More...

void	key_ungrab (std::string keyname_, Evas_Modifier_Mask modifiers_, Evas_Modifier_Mask not_modifiers_) const
	Removes the grab on `keyname` key events by `obj`. More...

void	lower () const
	Lower `obj` to the bottom of its layer. More...

void	clip_unset () const
	Disable/cease clipping on a clipped `obj` object. More...

void	smart_move_children_relative (Evas_Coord dx_, Evas_Coord dy_) const
	Moves all children objects of a given smart object relative to a given offset. More...

bool	smart_type_check_ptr (std::string type_) const
	Checks whether a given smart object or any of its smart object parents is of a given smart class, using pointer comparison. More...

void	size_hint_max_get (Evas_Coord w_, Evas_Coord h_) const
	Retrieves the hints for an object's maximum size. More...

void	size_hint_max_set (Evas_Coord w_, Evas_Coord h_) const
	Sets the hints for an object's maximum size. More...

void	size_hint_request_get (Evas_Coord w_, Evas_Coord h_) const
	Retrieves the hints for an object's optimum size. More...

void	size_hint_request_set (Evas_Coord w_, Evas_Coord h_) const
	Sets the hints for an object's optimum size. More...

bool	visibility_get () const
	Retrieves whether or not the given Evas object is visible. More...

void	visibility_set (bool v_) const
	Makes the given Evas object visible or invisible. More...

::efl::eina::optional< std::string >	type_get () const
	Retrieves the type of the given Evas object. More...

void	type_set (::efl::eina::optional< std::string > type_) const
	Sets the type of the given Evas object. More...

void	size_hint_min_get (Evas_Coord w_, Evas_Coord h_) const
	Retrieves the hints for an object's minimum size. More...

void	size_hint_min_set (Evas_Coord w_, Evas_Coord h_) const
	Sets the hints for an object's minimum size. More...

Evas_Object_Pointer_Mode	pointer_mode_get () const
	Determine how pointer will behave. More...

void	pointer_mode_set (Evas_Object_Pointer_Mode pointer_mode_) const
	Set pointer behavior. More...

Evas_Render_Op	render_op_get () const
	Retrieves the current value of the operation used for rendering the Evas object. More...

void	render_op_set (Evas_Render_Op render_op_) const
	Sets the render_op to be used for rendering the Evas object. More...

bool	freeze_events_get () const
	Determine whether an object is set to freeze (discard) events. More...

void	freeze_events_set (bool freeze_) const
	Set whether an Evas object is to freeze (discard) events. More...

const Evas_Map *	map_get () const
	Get current object transformation map. More...

void	map_set (const Evas_Map *map_) const
	Set current object transformation map. More...

void	size_hint_aspect_get (Evas_Aspect_Control aspect_, Evas_Coord w_, Evas_Coord *h_) const
	Retrieves the hints for an object's aspect ratio. More...

void	size_hint_aspect_set (Evas_Aspect_Control aspect_, Evas_Coord w_, Evas_Coord h_) const
	Sets the hints for an object's aspect ratio. More...

short	layer_get () const
	Retrieves the layer of its canvas that the given object is part of. More...

void	layer_set (short l_) const
	Sets the layer of its canvas that the given object will be part of. More...

::evas::object	clip_get () const
	Get the object clipping `obj` (if any). More...

void	clip_set (::evas::object clip_) const
	Clip one object to another. More...

void	size_hint_padding_get (Evas_Coord l_, Evas_Coord r_, Evas_Coord t_, Evas_Coord b_) const
	Retrieves the hints for an object's padding space. More...

void	size_hint_padding_set (Evas_Coord l_, Evas_Coord r_, Evas_Coord t_, Evas_Coord b_) const
	Sets the hints for an object's padding space. More...

bool	repeat_events_get () const
	Determine whether an object is set to repeat events. More...

void	repeat_events_set (bool repeat_) const
	Set whether an Evas object is to repeat events. More...

void	size_hint_weight_get (double x_, double y_) const
	Retrieves the hints for an object's weight. More...

void	size_hint_weight_set (double x_, double y_) const
	Sets the hints for an object's weight. More...

::efl::eina::optional< std::string >	name_get () const
	Retrieves the name of the given Evas object. More...

void	name_set (::efl::eina::optional< std::string > name_) const
	Sets the name of the given Evas object to the given name. More...

double	scale_get () const
	Retrieves the scaling factor for the given Evas object. More...

void	scale_set (double scale_) const
	Sets the scaling factor for an Evas object. More...

bool	static_clip_get () const
	Get the "static clipper" hint flag for a given Evas object. More...

void	static_clip_set (bool is_static_clip_) const
	Set a hint flag on the given Evas object that it's used as a "static clipper". More...

void	size_get (Evas_Coord w_, Evas_Coord h_) const
	Retrieves the (rectangular) size of the given Evas object. More...

void	size_set (Evas_Coord w_, Evas_Coord h_) const
	Changes the size of the given Evas object. More...

bool	focus_get () const
	Retrieve whether an object has the focus. More...

void	focus_set (bool focus_) const
	Sets or unsets a given object as the currently focused one on its canvas. More...

bool	is_frame_object_get () const

void	is_frame_object_set (bool is_frame_) const

bool	map_enable_get () const
	Get the map enabled state. More...

void	map_enable_set (bool enabled_) const
	Enable or disable the map that is set. More...

bool	precise_is_inside_get () const
	Determine whether an object is set to use precise point collision detection. More...

void	precise_is_inside_set (bool precise_) const
	Set whether to use precise (usually expensive) point collision detection for a given Evas object. More...

void	size_hint_align_get (double x_, double y_) const
	Retrieves the hints for on object's alignment. More...

void	size_hint_align_set (double x_, double y_) const
	Sets the hints for an object's alignment. More...

bool	propagate_events_get () const
	Retrieve whether an Evas object is set to propagate events. More...

void	propagate_events_set (bool propagate_) const
	Set whether events on a smart object's member should get propagated up to its parent. More...

bool	pass_events_get () const
	Determine whether an object is set to pass (ignore) events. More...

void	pass_events_set (bool pass_) const
	Set whether an Evas object is to pass (ignore) events. More...

void	position_get (Evas_Coord x_, Evas_Coord y_) const
	Retrieves the position of the given Evas object. More...

void	position_set (Evas_Coord x_, Evas_Coord y_) const
	Move the given Evas object to the given location inside its canvas' viewport. More...

bool	anti_alias_get () const
	Retrieves whether or not the given Evas object is to be drawn anti_aliased. More...

void	anti_alias_set (bool anti_alias_) const
	Sets whether or not the given Evas object is to be drawn anti-aliased. More...

void	color_get (int r_, int g_, int b_, int a_) const
	Retrieves the general/main color of the given Evas object. More...

void	color_set (int r_, int g_, int b_, int a_) const
	Sets the general/main color of the given Evas object to the given one. More...

void *	smart_data_get () const
	Retrieve user data stored on a given smart object. More...

::efl::eina::optional< ::evas::object >	smart_clipped_clipper_get () const
	Get the clipper object for the given clipped smart object. More...

::efl::eina::optional< ::evas::object >	below_get () const
	Get the Evas object stacked right below `obj`. More...

::efl::eina::optional< ::efl::eina::crange_list< ::evas::object > >	clipees_get () const
	Return a list of objects currently clipped by `obj`. More...

::efl::eina::optional< ::evas::object >	smart_parent_get () const
	Gets the parent smart object of a given Evas object, if it has one. More...

::efl::eina::optional< ::evas::object >	above_get () const
	Get the Evas object stacked right above `obj`. More...

Evas_Display_Mode	size_hint_display_mode_get () const
	Retrieves the hints for an object's display mode. More...

void	size_hint_display_mode_set (Evas_Display_Mode dispmode_) const
	Sets the hints for an object's disply mode. More...

template<typename F >
::efl::eo::signal_connection	callback_mouse_in_add (F &&callback_,::efl::eo::callback_priority priority_=::efl::eo::callback_priorities::default_)

template<typename T >
void	callback_mouse_in_call (T *info)

template<typename F >
::efl::eo::signal_connection	callback_mouse_out_add (F &&callback_,::efl::eo::callback_priority priority_=::efl::eo::callback_priorities::default_)

template<typename T >
void	callback_mouse_out_call (T *info)

template<typename F >
::efl::eo::signal_connection	callback_mouse_down_add (F &&callback_,::efl::eo::callback_priority priority_=::efl::eo::callback_priorities::default_)

template<typename T >
void	callback_mouse_down_call (T *info)

template<typename F >
::efl::eo::signal_connection	callback_mouse_up_add (F &&callback_,::efl::eo::callback_priority priority_=::efl::eo::callback_priorities::default_)

template<typename T >
void	callback_mouse_up_call (T *info)

template<typename F >
::efl::eo::signal_connection	callback_mouse_move_add (F &&callback_,::efl::eo::callback_priority priority_=::efl::eo::callback_priorities::default_)

template<typename T >
void	callback_mouse_move_call (T *info)

template<typename F >
::efl::eo::signal_connection	callback_mouse_wheel_add (F &&callback_,::efl::eo::callback_priority priority_=::efl::eo::callback_priorities::default_)

template<typename T >
void	callback_mouse_wheel_call (T *info)

template<typename F >
::efl::eo::signal_connection	callback_multi_down_add (F &&callback_,::efl::eo::callback_priority priority_=::efl::eo::callback_priorities::default_)

template<typename T >
void	callback_multi_down_call (T *info)

template<typename F >
::efl::eo::signal_connection	callback_multi_up_add (F &&callback_,::efl::eo::callback_priority priority_=::efl::eo::callback_priorities::default_)

template<typename T >
void	callback_multi_up_call (T *info)

template<typename F >
::efl::eo::signal_connection	callback_multi_move_add (F &&callback_,::efl::eo::callback_priority priority_=::efl::eo::callback_priorities::default_)

template<typename T >
void	callback_multi_move_call (T *info)

template<typename F >
::efl::eo::signal_connection	callback_free_add (F &&callback_,::efl::eo::callback_priority priority_=::efl::eo::callback_priorities::default_)

template<typename T >
void	callback_free_call (T *info)

template<typename F >
::efl::eo::signal_connection	callback_key_down_add (F &&callback_,::efl::eo::callback_priority priority_=::efl::eo::callback_priorities::default_)

template<typename T >
void	callback_key_down_call (T *info)

template<typename F >
::efl::eo::signal_connection	callback_key_up_add (F &&callback_,::efl::eo::callback_priority priority_=::efl::eo::callback_priorities::default_)

template<typename T >
void	callback_key_up_call (T *info)

template<typename F >
::efl::eo::signal_connection	callback_focus_in_add (F &&callback_,::efl::eo::callback_priority priority_=::efl::eo::callback_priorities::default_)

template<typename T >
void	callback_focus_in_call (T *info)

template<typename F >
::efl::eo::signal_connection	callback_focus_out_add (F &&callback_,::efl::eo::callback_priority priority_=::efl::eo::callback_priorities::default_)

template<typename T >
void	callback_focus_out_call (T *info)

template<typename F >
::efl::eo::signal_connection	callback_show_add (F &&callback_,::efl::eo::callback_priority priority_=::efl::eo::callback_priorities::default_)

template<typename T >
void	callback_show_call (T *info)

template<typename F >
::efl::eo::signal_connection	callback_hide_add (F &&callback_,::efl::eo::callback_priority priority_=::efl::eo::callback_priorities::default_)

template<typename T >
void	callback_hide_call (T *info)

template<typename F >
::efl::eo::signal_connection	callback_move_add (F &&callback_,::efl::eo::callback_priority priority_=::efl::eo::callback_priorities::default_)

template<typename T >
void	callback_move_call (T *info)

template<typename F >
::efl::eo::signal_connection	callback_resize_add (F &&callback_,::efl::eo::callback_priority priority_=::efl::eo::callback_priorities::default_)

template<typename T >
void	callback_resize_call (T *info)

template<typename F >
::efl::eo::signal_connection	callback_restack_add (F &&callback_,::efl::eo::callback_priority priority_=::efl::eo::callback_priorities::default_)

template<typename T >
void	callback_restack_call (T *info)

template<typename F >
::efl::eo::signal_connection	callback_del_add (F &&callback_,::efl::eo::callback_priority priority_=::efl::eo::callback_priorities::default_)

template<typename T >
void	callback_del_call (T *info)

template<typename F >
::efl::eo::signal_connection	callback_hold_add (F &&callback_,::efl::eo::callback_priority priority_=::efl::eo::callback_priorities::default_)

template<typename T >
void	callback_hold_call (T *info)

template<typename F >
::efl::eo::signal_connection	callback_changed_size_hints_add (F &&callback_,::efl::eo::callback_priority priority_=::efl::eo::callback_priorities::default_)

template<typename T >
void	callback_changed_size_hints_call (T *info)

template<typename F >
::efl::eo::signal_connection	callback_image_preloaded_add (F &&callback_,::efl::eo::callback_priority priority_=::efl::eo::callback_priorities::default_)

template<typename T >
void	callback_image_preloaded_call (T *info)

template<typename F >
::efl::eo::signal_connection	callback_image_resize_add (F &&callback_,::efl::eo::callback_priority priority_=::efl::eo::callback_priorities::default_)

template<typename T >
void	callback_image_resize_call (T *info)

template<typename F >
::efl::eo::signal_connection	callback_image_unloaded_add (F &&callback_,::efl::eo::callback_priority priority_=::efl::eo::callback_priorities::default_)

template<typename T >
void	callback_image_unloaded_call (T *info)

	operator::evas::object () const

	operator::evas::object & ()

	operator::evas::object const & () const

Static Public Member Functions
static Eo_Class const *	_eo_class ()

Member Function Documentation

bool eo_cxx::evas::object::clipees_has ( ) const

inline

Test if any object is clipped by obj.

Returns: EINA_TRUE if obj clip any object.

Since: 1.8

bool eo_cxx::evas::object::key_grab	(	std::string	keyname_,
		Evas_Modifier_Mask	modifiers_,
		Evas_Modifier_Mask	not_modifiers_,
		bool	exclusive_
	)		const

inline

Requests keyname key events be directed to obj.

Returns: EINA_TRUE, if the call succeeded, 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.

keyname is a platform dependent symbolic name for the key pressed (see Key Input Functions for more information).

modifiers and not_modifiers are bit masks of all the modifiers that must and mustn't, respectively, be pressed along with 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 0 for empty masks.

exclusive will make the given object the only one permitted to grab the given key. If given EINA_TRUE, subsequent calls on this function with different obj arguments will fail, unless the key is ungrabbed again.

Example code follows.

{

}

if (d.focus)

evas_object_focus_set(d.bg, EINA_FALSE);

fprintf(stdout, "Focused object is now %s\n",

evas_focus_get(d.canvas) ?

"still valid! Something went wrong." : "none.");

ret = evas_object_key_grab(d.bg, "a", 0, 0, EINA_TRUE);

if (!ret)

{

fprintf(stdout, "Something went wrong with key grabs.\n");

goto c_end;

}

ret = evas_object_key_grab(d.bg, "c", 0, 0, EINA_TRUE);

if (!ret)

{

fprintf(stdout, "Something went wrong with key grabs.\n");

goto c_end;

}

ret = evas_object_key_grab(d.bg, "d", 0, 0, EINA_TRUE);

if (!ret)

{

fprintf(stdout, "Something went wrong with key grabs.\n");

goto c_end;

}

ret = evas_object_key_grab(d.bg, "f", 0, 0, EINA_TRUE);

if (!ret)

{

fprintf(stdout, "Something went wrong with key grabs.\n");

goto c_end;

}

ret = evas_object_key_grab(d.bg, "p", 0, 0, EINA_TRUE);

if (!ret)

{

fprintf(stdout, "Something went wrong with key grabs.\n");

goto c_end;

}

ret = evas_object_key_grab(d.bg, "o", mask, 0, EINA_TRUE);

if (!ret)

{

fprintf(stdout, "Something went wrong with key grabs.\n");

goto c_end;

}

ret = evas_object_key_grab(d.bg, "h", 0, 0, EINA_TRUE);

if (!ret)

{

fprintf(stdout, "Something went wrong with key grabs.\n");

goto c_end;

}

else /* got here by key grabs */

See the full example here.

Warning: Providing impossible modifier sets creates undefined behavior

See also: evas_object_key_ungrab; evas_object_focus_set; evas_object_focus_get; evas_focus_get; evas_key_modifier_add

Parameters

keyname	the key to request events for.
modifiers	a mask of modifiers that must be present to trigger the event.
not_modifiers	a mask of modifiers that must not be present to trigger the event.
exclusive	request that the `obj` is the only object receiving the `keyname` events.

void eo_cxx::evas::object::stack_below ( ::evas::object below_ ) const

inline

Stack obj immediately below below.

Objects, in a given canvas, are stacked in the order they get added to it. This means that, if they overlap, the highest ones will cover the lowest ones, in that order. This function is a way to change the stacking order for the objects.

This function is intended to be used with objects belonging to the same layer in a given canvas, otherwise it will fail (and accomplish nothing).

If you have smart objects on your canvas and obj is a member of one of them, then below must also be a member of the same smart object.

Similarly, if obj is not a member of a smart object, below must not be either.

See also: evas_object_layer_get(); evas_object_layer_set(); evas_object_stack_below()

Parameters

below the object below which to stack

void eo_cxx::evas::object::raise ( ) const

inline

Raise obj to the top of its layer.

obj will, then, be the highest one in the layer it belongs to. Object on other layers won't get touched.

See also: evas_object_stack_above(); evas_object_stack_below(); evas_object_lower()

void eo_cxx::evas::object::stack_above ( ::evas::object above_ ) const

inline

Stack obj immediately above above.

Objects, in a given canvas, are stacked in the order they get added to it. This means that, if they overlap, the highest ones will cover the lowest ones, in that order. This function is a way to change the stacking order for the objects.

This function is intended to be used with objects belonging to the same layer in a given canvas, otherwise it will fail (and accomplish nothing).

If you have smart objects on your canvas and obj is a member of one of them, then above must also be a member of the same smart object.

Similarly, if obj is not a member of a smart object, above must not be either.

See also: evas_object_layer_get(); evas_object_layer_set(); evas_object_stack_below()

Parameters

above the object above which to stack

void eo_cxx::evas::object::key_ungrab	(	std::string	keyname_,
		Evas_Modifier_Mask	modifiers_,
		Evas_Modifier_Mask	not_modifiers_
	)		const

inline

Removes the grab on keyname key events by obj.

Removes a key grab on obj if keyname, modifiers, and not_modifiers match.

Example code follows.

        else /* got here by key grabs */
          {
             evas_object_key_ungrab(d.bg, "a", 0, 0);
             evas_object_key_ungrab(d.bg, "c", 0, 0);
             evas_object_key_ungrab(d.bg, "d", 0, 0);
             evas_object_key_ungrab(d.bg, "f", 0, 0);
             evas_object_key_ungrab(d.bg, "p", 0, 0);
             evas_object_key_ungrab(d.bg, "o", mask, 0);
             evas_object_key_ungrab(d.bg, "h", 0, 0);
             evas_object_focus_set(d.bg, EINA_TRUE);
          }

See the full example here.

See also: evas_object_key_grab; evas_object_focus_set; evas_object_focus_get; evas_focus_get

Parameters

keyname	the key the grab is set for.
modifiers	a mask of modifiers that must be present to trigger the event.
not_modifiers	a mask of modifiers that must not not be present to trigger the event.

void eo_cxx::evas::object::lower ( ) const

inline

Lower obj to the bottom of its layer.

obj will, then, be the lowest one in the layer it belongs to. Objects on other layers won't get touched.

See also: evas_object_stack_above(); evas_object_stack_below(); evas_object_raise()

void eo_cxx::evas::object::clip_unset ( ) const

inline

Disable/cease clipping on a clipped obj object.

This function disables clipping for the object 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 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().

void eo_cxx::evas::object::smart_move_children_relative	(	Evas_Coord	dx_,
		Evas_Coord	dy_
	)		const

inline

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

dx	horizontal offset (delta).
dy	vertical offset (delta).

void eo_cxx::evas::object::size_hint_max_get	(	Evas_Coord *	w_,
		Evas_Coord *	h_
	)		const

inline

Retrieves the hints for an object's maximum size.

These are hints on the maximum sizes 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 NULL pointers on the hint components you're not interested in: they'll be ignored by the function.

See also: evas_object_size_hint_max_set()

Parameters

w	Integer to use as the maximum width hint.
h	Integer to use as the maximum height hint.

void eo_cxx::evas::object::size_hint_max_set	(	Evas_Coord	w_,
		Evas_Coord	h_
	)		const

inline

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 -1 will be treated as unset hint components, when queried by managers.

Example:

        evas_object_size_hint_max_set(
          rect, r_data->max_ptr->w, r_data->max_ptr->h);
        fprintf(stdout, "Changing max. size hints for %s rect. to (%d, %d)\n",
                name, r_data->max_ptr->w, r_data->max_ptr->h);
        return;

In this example the maximum size hints change the behavior of an Evas box when layouting its children. See the full example.

See also: evas_object_size_hint_max_get()

Parameters

w	Integer to use as the maximum width hint.
h	Integer to use as the maximum height hint.

void eo_cxx::evas::object::size_hint_request_get	(	Evas_Coord *	w_,
		Evas_Coord *	h_
	)		const

inline

Retrieves the hints for an object's optimum size.

These are hints on the optimum sizes 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 NULL pointers on the hint components you're not interested in: they'll be ignored by the function.

See also: evas_object_size_hint_request_set()

Parameters

w	Integer to use as the preferred width hint.
h	Integer to use as the preferred height hint.

void eo_cxx::evas::object::size_hint_request_set	(	Evas_Coord	w_,
		Evas_Coord	h_
	)		const

inline

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 0 will be treated as unset hint components, when queried by managers.

See also: evas_object_size_hint_request_get()

Parameters

w	Integer to use as the preferred width hint.
h	Integer to use as the preferred height hint.

bool eo_cxx::evas::object::visibility_get ( ) const

inline

Retrieves whether or not the given Evas object is visible.

Parameters

v	`EINA_TRUE` if to make the object visible, `EINA_FALSE` otherwise

void eo_cxx::evas::object::visibility_set ( bool v_ ) const

inline

Makes the given Evas object visible or invisible.

Parameters

v	`EINA_TRUE` if to make the object visible, `EINA_FALSE` otherwise

efl::eina::optional< std::string > eo_cxx::evas::object::type_get ( ) const

inline

Retrieves the type of the given Evas object.

Returns: The type of the object.

For Evas' builtin types, the return strings will be one of:

"rectangle",
"line",
"polygon",
"text",
"textblock" and
"image".

For Evas smart objects (see Smart Functions), the name of the smart class itself is returned on this call. For the built-in smart objects, these names are:

"EvasObjectSmartClipped", for the clipped smart object
"Evas_Object_Box", for the box object and
"Evas_Object_Table", for the table object.

Example:

   d.img = evas_object_image_filled_add(d.canvas);
   evas_object_image_file_set(d.img, img_path, NULL);
   err = evas_object_image_load_error_get(d.img);
   if (err != EVAS_LOAD_ERROR_NONE)
     {
        goto panic;
     }
   else
     {
        evas_object_move(d.img, 0, 0);
        evas_object_resize(d.img, WIDTH, HEIGHT);
        evas_object_show(d.img);
        fprintf(stdout, "Image object added, type is: %s\n",
                evas_object_type_get(d.img));
     }
   /* border on the image's clipper, here just to emphasize its position */

See the full example.

Parameters

type in

void eo_cxx::evas::object::type_set ( ::efl::eina::optional< std::string > type_ ) const

inline

Sets the type of the given Evas object.

Parameters

type in

void eo_cxx::evas::object::size_hint_min_get	(	Evas_Coord *	w_,
		Evas_Coord *	h_
	)		const

inline

Retrieves the hints for an object's minimum size.

These are hints on the minimum sizes 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 NULL pointers on the hint components you're not interested in: they'll be ignored by the function.

See also: evas_object_size_hint_min_set() for an example

Parameters

w	Integer to use as the minimum width hint.
h	Integer to use as the minimum height hint.

void eo_cxx::evas::object::size_hint_min_set	(	Evas_Coord	w_,
		Evas_Coord	h_
	)		const

inline

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 0 will be treated as unset hint components, when queried by managers.

Example:

        evas_object_size_hint_min_set(
          rect, r_data->min_ptr->w, r_data->min_ptr->h);
        fprintf(stdout, "Changing min. size hints for %s rect. to (%d, %d)\n",
                name, r_data->min_ptr->w, r_data->min_ptr->h);
        return;

In this example the minimum size hints change the behavior of an Evas box when layouting its children. See the full example.

See also: evas_object_size_hint_min_get()

Parameters

w	Integer to use as the minimum width hint.
h	Integer to use as the minimum height hint.

bool eo_cxx::evas::object::freeze_events_get ( ) const

inline

Determine whether an object is set to freeze (discard) events.

Returns: freeze whether obj is set to freeze events (EINA_TRUE) or not (EINA_FALSE)

See also: evas_object_freeze_events_set(); evas_object_pass_events_get(); evas_object_repeat_events_get(); evas_object_propagate_events_get()

Since: 1.1

Parameters

freeze pass whether obj is to freeze events (EINA_TRUE) or not (EINA_FALSE)

void eo_cxx::evas::object::freeze_events_set ( bool freeze_ ) const

inline

Set whether an Evas object is to freeze (discard) events.

If freeze is EINA_TRUE, it will make events on obj to be discarded. Unlike evas_object_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.

If freeze is 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 also: evas_object_freeze_events_get(); evas_object_pass_events_set(); evas_object_repeat_events_set(); evas_object_propagate_events_set()

Since: 1.1

Parameters

freeze pass whether obj is to freeze events (EINA_TRUE) or not (EINA_FALSE)

const Evas_Map * eo_cxx::evas::object::map_get ( ) const

inline

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:

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);

Returns: map reference to map in use. This is an internal data structure, so do not modify it.

See also: evas_object_map_set()

Parameters

map	new map to use

void eo_cxx::evas::object::map_set ( const Evas_Map * map_ ) const

inline

Set current object transformation map.

This sets the map on a given object. It is copied from the map pointer, so there is no need to keep the 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:

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);

Note that the map points a uv coordinates match the image geometry. If the map parameter is NULL, the stored map will be freed and geometry prior to enabling/setting a map will be restored.

See also: evas_map_new()

Parameters

map	new map to use

void eo_cxx::evas::object::size_hint_aspect_get	(	Evas_Aspect_Control *	aspect_,
		Evas_Coord *	w_,
		Evas_Coord *	h_
	)		const

inline

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 resize its children accordingly to those policies.

For any policy, if any of the given aspect ratio terms are 0, the object's container should ignore the aspect and scale 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:

This is not a size enforcement in any way, it's just a hint that should be used whenever appropriate.

Note: Use NULL pointers on the hint components you're not interested in: they'll be ignored by the function.

Example:

   if (strcmp(ev->key, "c") == 0) /* cycle aspect control on obj */
     {
        Evas_Coord w, h;
        Evas_Aspect_Control aspect;
        evas_object_size_hint_aspect_get(d.rect, &aspect, &w, &h);
        aspect = (aspect + 1) % 5;
        evas_object_size_hint_aspect_set(d.rect, aspect, w, h);
        fprintf(stdout, "Changing aspect control to %s\n",
                _get_aspect_name(aspect));
        return;
     }

See the full example.

See also: evas_object_size_hint_aspect_set()

Parameters

aspect	The policy/type of aspect ratio to apply to `obj`.
w	Integer to use as aspect width ratio term.
h	Integer to use as aspect height ratio term.

void eo_cxx::evas::object::size_hint_aspect_set	(	Evas_Aspect_Control	aspect_,
		Evas_Coord	w_,
		Evas_Coord	h_
	)		const

inline

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 0, the object's container will ignore the aspect and scale obj to occupy the whole available area, for any given policy.

See also: evas_object_size_hint_aspect_get() for more information.

Parameters

aspect	The policy/type of aspect ratio to apply to `obj`.
w	Integer to use as aspect width ratio term.
h	Integer to use as aspect height ratio term.

short eo_cxx::evas::object::layer_get ( ) const

inline

Retrieves the layer of its canvas that the given object is part of.

Returns: Number of its layer

See also: evas_object_layer_set()

Parameters

l	The number of the layer to place the object on. Must be between EVAS_LAYER_MIN and EVAS_LAYER_MAX.

void eo_cxx::evas::object::layer_set ( short l_ ) const

inline

Sets the layer of its canvas that the given object will be part of.

If you don't use this function, you'll be dealing with an unique layer of objects, the default one. Additional layers are handy when you don't want a set of objects to interfere with another set with regard to stacking. Two layers are completely disjoint in that matter.

This is a low-level function, which you'd be using when something should be always on top, for example.

Warning: Be careful, it doesn't make sense to change the layer of smart objects' children. Smart objects have a layer of their own, which should contain all their children objects.

See also: evas_object_layer_get()

Parameters

l	The number of the layer to place the object on. Must be between EVAS_LAYER_MIN and EVAS_LAYER_MAX.

evas::object eo_cxx::evas::object::clip_get ( ) const

inline

Get the object clipping obj (if any).

This function returns the object clipping obj. If obj is not being clipped at all, NULL is returned. The object obj must be a valid .Evas_Object.

See also evas_object_clip_set(), evas_object_clip_unset() and evas_object_clipees_get().

Example:

        if (evas_object_clip_get(d.img) == d.clipper)
          {
             evas_object_clip_unset(d.img);
             fprintf(stdout, "off\n");
          }
        else
          {
             evas_object_clip_set(d.img, d.clipper);
             fprintf(stdout, "on\n");
          }
        return;

See the full example.

Parameters

clip	The object to clip `obj` by

void eo_cxx::evas::object::clip_set ( ::evas::object clip_ ) const

inline

Clip one object to another.

This function will clip the object obj to the area occupied by the object clip. This means the object obj will only be visible within the area occupied by the clipping object (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 RESULT = (OBJ * CLIP) / (255 * 255), 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 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; those that clip one or more objects become invisible themselves, 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 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:

Note: At the moment the only objects that can validly be used to clip other objects are rectangle objects. All other object types are invalid and the result of using them is undefined. The clip object clip must be a valid object, but can also be NULL, in which case the effect of this function is the same as calling evas_object_clip_unset() on the obj object.

Example:

   /* solid white clipper (note that it's the default color for a
    * rectangle) - it won't change clippees' colors, then (multiplying
    * by 255) */
   d.clipper = evas_object_rectangle_add(d.canvas);
   evas_object_move(d.clipper, WIDTH / 4, HEIGHT / 4);
   evas_object_resize(d.clipper, WIDTH / 2, HEIGHT / 2);
   evas_object_clip_set(d.img, d.clipper);
   evas_object_show(d.clipper);

See the full example.

Parameters

clip	The object to clip `obj` by

void eo_cxx::evas::object::size_hint_padding_get	(	Evas_Coord *	l_,
		Evas_Coord *	r_,
		Evas_Coord *	t_,
		Evas_Coord *	b_
	)		const

inline

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:

This is not a size enforcement in any way, it's just a hint that should be used whenever appropriate.

Note: Use NULL pointers on the hint components you're not interested in: they'll be ignored by the function.

Example:

        evas_object_size_hint_padding_set(
          rect, r_data->padding_ptr->l, r_data->padding_ptr->r,
          r_data->padding_ptr->t, r_data->padding_ptr->b);
        fprintf(stdout, "Changing padding size hints for %s rect."
                        " to (%d, %d, %d, %d)\n",
                name, r_data->padding_ptr->l, r_data->padding_ptr->r,
                r_data->padding_ptr->t, r_data->padding_ptr->b);
        return;

In this example the padding hints change the behavior of an Evas box when layouting its children. See the full example.

See also: evas_object_size_hint_padding_set()

Parameters

l	Integer to specify left padding.
r	Integer to specify right padding.
t	Integer to specify top padding.
b	Integer to specify bottom padding.

void eo_cxx::evas::object::size_hint_padding_set	(	Evas_Coord	l_,
		Evas_Coord	r_,
		Evas_Coord	t_,
		Evas_Coord	b_
	)		const

inline

Sets the hints for an object's padding space.

This is not a size enforcement in any way, it's just a hint that should be used whenever appropriate.

See also: evas_object_size_hint_padding_get() for more information

Parameters

l	Integer to specify left padding.
r	Integer to specify right padding.
t	Integer to specify top padding.
b	Integer to specify bottom padding.

bool eo_cxx::evas::object::repeat_events_get ( ) const

inline

Determine whether an object is set to repeat events.

Returns: whether obj is set to repeat events (EINA_TRUE) or not (EINA_FALSE)

See also: evas_object_repeat_events_set() for an example; evas_object_pass_events_get(); evas_object_propagate_events_get(); evas_object_freeze_events_get()

Parameters

repeat whether obj is to repeat events (EINA_TRUE) or not (EINA_FALSE)

void eo_cxx::evas::object::repeat_events_set ( bool repeat_ ) const

inline

Set whether an Evas object is to repeat events.

If repeat is EINA_TRUE, it will make events on obj to also be repeated for the next lower object in the objects' stack (see see evas_object_below_get()).

If repeat is EINA_FALSE, events occurring on obj will be processed only on it.

Example:

   if (strcmp(ev->key, "r") == 0)  /* toggle repeat events */
     {
        Eina_Bool repeat = evas_object_repeat_events_get(d.rects[d.cur_rect]);
        evas_object_repeat_events_set(d.rects[d.cur_rect], !repeat);
        fprintf(stdout, "%s rectangle is now set to%s repeat events\n",
                name, repeat ? " NOT" : "");
        return;
     }

See the full example.

See also: evas_object_repeat_events_get(); evas_object_pass_events_set(); evas_object_propagate_events_set(); evas_object_freeze_events_set()

Parameters

repeat whether obj is to repeat events (EINA_TRUE) or not (EINA_FALSE)

void eo_cxx::evas::object::size_hint_weight_get	(	double *	x_,
		double *	y_
	)		const

inline

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 proportion, see documentation of possible users, which in Evas are the box and 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 NULL pointers on the hint components you're not interested in: they'll be ignored by the function.; If obj is invalid, then the hint components will be set with 0.0

See also: evas_object_size_hint_weight_set() for an example

Parameters

x	Nonnegative double value to use as horizontal weight hint.
y	Nonnegative double value to use as vertical weight hint.

void eo_cxx::evas::object::size_hint_weight_set	(	double	x_,
		double	y_
	)		const

inline

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 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 weights to how much of its size to allocate for them in each axis. A container is supposed to, after 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:

        evas_object_size_hint_weight_set(
          rect, r_data->weight_ptr->x, r_data->weight_ptr->y);
        fprintf(stdout, "Changing weight hints for %s rect. to (%f, %f)\n",
                name, r_data->weight_ptr->x, r_data->weight_ptr->y);
        return;

In this example the weight hints change the behavior of an Evas box when layouting its children. See the full example.

Note: Default weight hint values are 0.0, for both axis.

See also: evas_object_size_hint_weight_get() for more information

Parameters

x	Nonnegative double value to use as horizontal weight hint.
y	Nonnegative double value to use as vertical weight hint.

efl::eina::optional< std::string > eo_cxx::evas::object::name_get ( ) const

inline

Retrieves the name of the given Evas object.

Returns: The name of the object or NULL, if no name has been given to it.

Example:

   fprintf(stdout, "An object got focused: %s\n",
           evas_object_name_get(event_info));
   fprintf(stdout, "Let's recheck it: %s\n",
           evas_object_name_get(evas_focus_get(e)));

See the full example.

Parameters

name	The given name.

void eo_cxx::evas::object::name_set ( ::efl::eina::optional< std::string > name_ ) const

inline

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:

d.bg = evas_object_rectangle_add(d.canvas);

evas_object_name_set(d.bg, "our dear rectangle");

See the full example.

Parameters

name	The given name.

void eo_cxx::evas::object::size_get	(	Evas_Coord *	w_,
		Evas_Coord *	h_
	)		const

inline

Retrieves the (rectangular) size of the given Evas object.

Parameters

w	in
h	in

void eo_cxx::evas::object::size_set	(	Evas_Coord	w_,
		Evas_Coord	h_
	)		const

inline

Changes the size of the given Evas object.

Parameters

w	in
h	in

bool eo_cxx::evas::object::focus_get ( ) const

inline

Retrieve whether an object has the focus.

Returns: EINA_TRUE if the object has the focus, EINA_FALSE otherwise.

If the passed object is the currently focused one, EINA_TRUE is returned. EINA_FALSE is returned, otherwise.

Example:

fprintf(stdout, "And again: %s\n", evas_object_focus_get(event_info) ?

"OK!" : "Oops, something is bad.");

See the full example here.

See also: evas_object_focus_set; evas_focus_get; evas_object_key_grab; evas_object_key_ungrab

Parameters

focus EINA_TRUE, to set it as focused or EINA_FALSE, to take away the focus from it.

void eo_cxx::evas::object::focus_set ( bool focus_ ) const

inline

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 focus is EINA_TRUE, 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:

evas_object_focus_set(d.bg, EINA_FALSE);

See the full example here.

See also: evas_object_focus_get; evas_focus_get; evas_object_key_grab; evas_object_key_ungrab

Parameters

focus EINA_TRUE, to set it as focused or EINA_FALSE, to take away the focus from it.

bool eo_cxx::evas::object::is_frame_object_get ( ) const

inline

Since: 1.2

Parameters

is_frame in

void eo_cxx::evas::object::is_frame_object_set ( bool is_frame_ ) const

inline

Since: 1.2

Parameters

is_frame in

bool eo_cxx::evas::object::map_enable_get ( ) const

inline

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().

Returns: the map enabled state

Parameters

enabled enabled state

void eo_cxx::evas::object::map_enable_set ( bool enabled_ ) const

inline

Enable or disable the map that is set.

Enable or disable the use of map for the object 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.

Parameters

enabled enabled state

void eo_cxx::evas::object::size_hint_align_get	(	double *	x_,
		double *	y_
	)		const

inline

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 NULL pointers on the hint components you're not interested in: they'll be ignored by the function.; If obj is invalid, then the hint components will be set with 0.5

See also: evas_object_size_hint_align_set() for more information

Parameters

x	Double, ranging from `0.0` to `1.0` or with the special value EVAS_HINT_FILL, to use as horizontal alignment hint.
y	Double, ranging from `0.0` to `1.0` or with the special value EVAS_HINT_FILL, to use as vertical alignment hint.

void eo_cxx::evas::object::size_hint_align_set	(	double	x_,
		double	y_
	)		const

inline

Sets the hints for an object's alignment.

These are hints on how to align an object inside the boundaries of a container/manager. Accepted values are in the 0.0 to 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 box and table smart objects.

For the horizontal component, 0.0 means to the left, 1.0 means to the right. Analogously, for the vertical component, 0.0 to the top, 1.0 means to the bottom.

See the following figure:

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:

        evas_object_size_hint_align_set(
          rect, r_data->align_ptr->x, r_data->align_ptr->y);
        fprintf(stdout, "Changing align hints for %s rect. to (%f, %f)\n",
                name, r_data->align_ptr->x, r_data->align_ptr->y);
        return;

In this example the alignment hints change the behavior of an Evas box when layouting its children. See the full example.

See also: evas_object_size_hint_align_get(); evas_object_size_hint_max_set(); evas_object_size_hint_padding_set()

Parameters

x	Double, ranging from `0.0` to `1.0` or with the special value EVAS_HINT_FILL, to use as horizontal alignment hint.
y	Double, ranging from `0.0` to `1.0` or with the special value EVAS_HINT_FILL, to use as vertical alignment hint.

bool eo_cxx::evas::object::propagate_events_get ( ) const

inline

Retrieve whether an Evas object is set to propagate events.

Returns: whether obj is set to propagate events (EINA_TRUE) or not (EINA_FALSE)

See also: evas_object_propagate_events_set(); evas_object_repeat_events_get(); evas_object_pass_events_get(); evas_object_freeze_events_get()

Parameters

propagate whether to propagate events (EINA_TRUE) or not (EINA_FALSE)

void eo_cxx::evas::object::propagate_events_set ( bool propagate_ ) const

inline

Set whether events on a smart object's member should get propagated up to its parent.

This function has no effect if obj is not a member of a smart object.

If prop is EINA_TRUE, events occurring on this object will be propagated on to the smart object of which obj is a member. If prop is EINA_FALSE, events occurring on this object will not be propagated on to the smart object of which obj is a member. The default value is EINA_TRUE.

See also: evas_object_propagate_events_get(); evas_object_repeat_events_set(); evas_object_pass_events_set(); evas_object_freeze_events_set()

Parameters

propagate whether to propagate events (EINA_TRUE) or not (EINA_FALSE)

bool eo_cxx::evas::object::pass_events_get ( ) const

inline

Determine whether an object is set to pass (ignore) events.

Returns: pass whether obj is set to pass events (EINA_TRUE) or not (EINA_FALSE)

Example:

   if (strcmp(ev->key, "p") == 0)  /* toggle pass events */
     {
        Eina_Bool pass = evas_object_pass_events_get(d.rects[d.cur_rect]);
        evas_object_pass_events_set(d.rects[d.cur_rect], !pass);
        fprintf(stdout, "%s rectangle is now set to%s pass (ignore) events\n",
                name, pass ? " NOT" : "");
        return;
     }

See the full example.

See also: evas_object_pass_events_set(); evas_object_repeat_events_get(); evas_object_propagate_events_get(); evas_object_freeze_events_get()

Parameters

pass	whether `obj` is to pass events (`EINA_TRUE`) or not (`EINA_FALSE`)

void eo_cxx::evas::object::pass_events_set ( bool pass_ ) const

inline

Set whether an Evas object is to pass (ignore) events.

If pass is EINA_TRUE, it will make events on obj to be ignored. They will be triggered on the next lower object (that is not set to pass events), instead (see evas_object_below_get()).

If pass is EINA_FALSE, events will be processed on that object as normal.

See also: evas_object_pass_events_get() for an example; evas_object_repeat_events_set(); evas_object_propagate_events_set(); evas_object_freeze_events_set()

Parameters

pass	whether `obj` is to pass events (`EINA_TRUE`) or not (`EINA_FALSE`)

void eo_cxx::evas::object::position_get	(	Evas_Coord *	x_,
		Evas_Coord *	y_
	)		const

inline

Retrieves the position of the given Evas object.

Parameters

x	in
y	in

void eo_cxx::evas::object::position_set	(	Evas_Coord	x_,
		Evas_Coord	y_
	)		const

inline

Move the given Evas object to the given location inside its canvas' viewport.

Parameters

x	in
y	in

efl::eina::optional<::evas::object > eo_cxx::evas::object::smart_clipped_clipper_get ( ) const

inline

Get the clipper object for the given clipped smart object.

Returns: the clipper object.

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

See also: evas_object_smart_clipped_smart_add()

efl::eina::optional<::evas::object > eo_cxx::evas::object::below_get ( ) const

inline

Get the Evas object stacked right below obj.

Returns: the Evas_Object directly below obj, if any, or NULL, if none

This function will traverse layers in its search, if there are objects on layers below the one obj is placed at.

See also: evas_object_layer_get(); evas_object_layer_set(); evas_object_below_get()

efl::eina::optional<::efl::eina::crange_list<::evas::object > > eo_cxx::evas::object::clipees_get ( ) const

inline

Return a list of objects currently clipped by obj.

Returns: a list of objects being clipped by obj

This returns the internal list handle that contains 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 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 obj must be a valid .Evas_Object.

See also evas_object_clip_set(), evas_object_clip_unset() and evas_object_clip_get().

Example:

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);
}

efl::eina::optional<::evas::object > eo_cxx::evas::object::above_get ( ) const

inline

Get the Evas object stacked right above obj.

Returns: the Evas_Object directly above obj, if any, or NULL, if none

This function will traverse layers in its search, if there are objects on layers above the one obj is placed at.

See also: evas_object_layer_get(); evas_object_layer_set(); evas_object_below_get()

Evas_Display_Mode eo_cxx::evas::object::size_hint_display_mode_get ( ) const

inline

Retrieves the hints for an object's display mode.

These are hints on the display mode 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

Parameters

dispmode display mode hint

void eo_cxx::evas::object::size_hint_display_mode_set ( Evas_Display_Mode dispmode_ ) const

inline

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.

Parameters

dispmode display mode hint

Data Structures

Public Member Functions

Static Public Member Functions

Member Function Documentation