Evas: Split Evas headers

Now, Evas.h includes three new files:
- Evas_Eo.h: Eo API functions (functions defines, enums, base id).
- Evas_Legacy.h: contains the API functions related to objects
- Evas_Common.h: common data (structs, enums...) +
functions not related to objects.

This phase is needed for the EFL 1.8 release to disable Eo APIs if we
consider it is not enough mature to be used by applications.

1 files changed, 8309 insertions, 0 deletions

diff --git a/src/lib/evas/Evas_Legacy.h b/src/lib/evas/Evas_Legacy.h
new file mode 100644
index 0000000000..5efa2b7d03
--- /dev/null
+++ b/src/lib/evas/Evas_Legacy.h
@@ -0,0 +1,8309 @@
+
+/**
+ * @ingroup Evas_Canvas
+ *
+ * @{
+ */
+/**
+ * Creates a new empty evas.
+ *
+ * Note that before you can use the evas, you will to at a minimum:
+ * @li Set its render method with @ref evas_output_method_set .
+ * @li Set its viewport size with @ref evas_output_viewport_set .
+ * @li Set its size of the canvas with @ref evas_output_size_set .
+ * @li Ensure that the render engine is given the correct settings
+ *     with @ref 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
+ *       @ref Ecore_Evas_Group such as @c ecore_evas_new(). See
+ *       @ref Ecore.
+ *
+ * @attention it is recommended that one calls evas_init() before
+ *       creating new canvas.
+ *
+ * @return A new uninitialised Evas canvas on success. Otherwise, @c NULL.
+ * @ingroup Evas_Canvas
+ */
+EAPI Evas             *evas_new(void) EINA_WARN_UNUSED_RESULT EINA_MALLOC;
+
+/**
+ * Frees the given evas and any objects created on it.
+ *
+ * Any objects with 'free' callbacks will have those callbacks called
+ * in this function.
+ *
+ * @param   e The given evas.
+ *
+ * @ingroup Evas_Canvas
+ */
+EAPI void              evas_free(Evas *e)  EINA_ARG_NONNULL(1);
+
+/**
+ * Inform to the evas that it got the focus.
+ *
+ * @param e The evas to change information.
+ * @ingroup Evas_Canvas
+ */
+EAPI void              evas_focus_in(Evas *e);
+
+/**
+ * Inform to the evas that it lost the focus.
+ *
+ * @param e The evas to change information.
+ * @ingroup Evas_Canvas
+ */
+EAPI void              evas_focus_out(Evas *e);
+
+/**
+ * Get the focus state known by the given evas
+ *
+ * @param e The evas to query information.
+ * @ingroup Evas_Canvas
+ */
+EAPI Eina_Bool         evas_focus_state_get(const Evas *e);
+
+/**
+ * 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.
+ *
+ * @param e The evas to change information.
+ * @ingroup Evas_Canvas
+ */
+EAPI void              evas_nochange_push(Evas *e);
+
+/**
+ * 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.
+ *
+ * @param e The evas to change information.
+ * @ingroup Evas_Canvas
+ */
+EAPI void              evas_nochange_pop(Evas *e);
+
+/**
+ * Attaches a specific pointer to the evas for fetching later
+ *
+ * @param e The canvas to attach the pointer to
+ * @param data The pointer to attach
+ * @ingroup Evas_Canvas
+ */
+EAPI void              evas_data_attach_set(Evas *e, void *data) EINA_ARG_NONNULL(1);
+
+/**
+ * Returns the pointer attached by evas_data_attach_set()
+ *
+ * @param e The canvas to attach the pointer to
+ * @return The pointer attached
+ * @ingroup Evas_Canvas
+ */
+EAPI void             *evas_data_attach_get(const Evas *e) EINA_WARN_UNUSED_RESULT EINA_ARG_NONNULL(1);
+
+/**
+ * Add a damage rectangle.
+ *
+ * @param e The given canvas pointer.
+ * @param x The rectangle's left position.
+ * @param y The rectangle's top position.
+ * @param w The rectangle's width.
+ * @param h The rectangle's height.
+ *
+ * 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).
+ *
+ * @ingroup Evas_Canvas
+ */
+EAPI void              evas_damage_rectangle_add(Evas *e, int x, int y, int w, int h) EINA_ARG_NONNULL(1);
+
+/**
+ * Add an "obscured region" to an Evas canvas.
+ *
+ * @param e The given canvas pointer.
+ * @param x The rectangle's top left corner's horizontal coordinate.
+ * @param y The rectangle's top left corner's vertical coordinate
+ * @param w The rectangle's width.
+ * @param h The rectangle's height.
+ *
+ * This is the function by which one tells an Evas canvas that a part
+ * of it <b>must not</b> 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 @b has to be repainted again, call the
+ * function evas_obscured_clear().
+ *
+ * @note This is a <b>very low level function</b>, which most of
+ * Evas' users wouldn't care about.
+ *
+ * @note This function does @b 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
+ * evas_damage_rectangle_add()).
+ *
+ * @see evas_obscured_clear()
+ * @see evas_render_updates()
+ *
+ * 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".
+ *
+ * @ingroup Evas_Canvas
+ */
+EAPI void              evas_obscured_rectangle_add(Evas *e, int x, int y, int w, int h) EINA_ARG_NONNULL(1);
+
+/**
+ * Remove all "obscured regions" from an Evas canvas.
+ *
+ * @param e The given canvas pointer.
+ *
+ * This function removes all the rectangles from the obscured regions
+ * list of the canvas @p e. It takes obscured areas added with
+ * evas_obscured_rectangle_add() and make them again a regions that @b
+ * have to be repainted on rendering updates.
+ *
+ * @note This is a <b>very low level function</b>, which most of
+ * Evas' users wouldn't care about.
+ *
+ * @note This function does @b 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
+ * evas_damage_rectangle_add()).
+ *
+ * @see evas_obscured_rectangle_add() for an example
+ * @see evas_render_updates()
+ *
+ * @ingroup Evas_Canvas
+ */
+EAPI void              evas_obscured_clear(Evas *e) EINA_ARG_NONNULL(1);
+
+/**
+ * Render the given Evas canvas asynchronously.
+ *
+ * @param e The canvas to render.
+ * @param func Optional function to call with the list of updated areas.
+ * @param data User data to pass to @p func.
+ *
+ * @return EINA_TRUE if the canvas will render, EINA_FALSE otherwise.
+ *
+ * This function only returns EINA_TRUE whne a frame will be rendered. If the
+ * previous frame is still rendering, EINA_FALSE will be returned so the users
+ * know not to wait for the updates callback and just return to their main
+ * loop.
+ *
+ * If a @p 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
+ * @f evas_render_updates_free().
+ * The list is given in the @p event_info parameter of the callback function.
+ *
+ * @ingroup Evas_Canvas
+ * @since 1.8
+ */
+EAPI Eina_Bool         evas_render_async(Evas *e) EINA_ARG_NONNULL(1);
+
+/**
+ * Force immediate renderization of the given Evas canvas.
+ *
+ * @param e The given canvas pointer.
+ * @return A newly allocated list of updated rectangles of the canvas
+ *        (@c Eina_Rectangle structs). Free this list with
+ *        evas_render_updates_free().
+ *
+ * This function forces an immediate renderization update of the given
+ * canvas @p e.
+ *
+ * @note This is a <b>very low level function</b>, which most of
+ * Evas' users wouldn't care about. One would use it, for example, to
+ * grab an Evas' canvas update regions and paint them back, using the
+ * canvas' pixmap, on a displaying system working below Evas.
+ *
+ * @note Evas is a stateful canvas. If no operations changing its
+ * state took place since the last rendering action, you won't see no
+ * changes and this call will be a no-op.
+ *
+ * Example code follows.
+ * @dontinclude evas-events.c
+ * @skip add an obscured
+ * @until d.obscured = !d.obscured;
+ *
+ * See the full @ref Example_Evas_Events "example".
+ *
+ * @ingroup Evas_Canvas
+ */
+EAPI Eina_List        *evas_render_updates(Evas *e) EINA_WARN_UNUSED_RESULT EINA_ARG_NONNULL(1);
+
+/**
+ * Force renderization of the given canvas.
+ *
+ * @param e The given canvas pointer.
+ *
+ * @ingroup Evas_Canvas
+ */
+EAPI void              evas_render(Evas *e) EINA_ARG_NONNULL(1);
+
+/**
+ * Update the canvas internal objects but not triggering immediate
+ * renderization.
+ *
+ * @param e The given canvas pointer.
+ *
+ * This function updates the canvas internal objects not triggering
+ * renderization. To force renderization function evas_render() should
+ * be used.
+ *
+ * @see evas_render.
+ *
+ * @ingroup Evas_Canvas
+ */
+EAPI void              evas_norender(Evas *e) EINA_ARG_NONNULL(1);
+
+/**
+ * Make the canvas discard internally cached data used for rendering.
+ *
+ * @param e The given canvas pointer.
+ *
+ * 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.
+ *
+ * @ingroup Evas_Canvas
+ */
+EAPI void              evas_render_idle_flush(Evas *e) EINA_ARG_NONNULL(1);
+
+/**
+ * Make the canvas discard as much data as possible used by the engine at
+ * runtime.
+ *
+ * @param e The given canvas pointer.
+ *
+ * This function will unload images, delete textures and much more, where
+ * possible. You may also want to call evas_render_idle_flush() immediately
+ * prior to this to perhaps discard a little more, though evas_render_dump()
+ * should implicitly delete most of what evas_render_idle_flush() might
+ * discard too.
+ *
+ * @ingroup Evas_Canvas
+ */
+EAPI void              evas_render_dump(Evas *e) EINA_ARG_NONNULL(1);
+
+
+/**
+ * @}
+ */
+
+
+/**
+ * @ingroup Evas_Output_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 @p render_method can be found using
+ * @ref evas_render_method_lookup .
+ *
+ * @param   e             The given evas.
+ * @param   render_method The numeric engine value to use.
+ *
+ * @attention it is mandatory that one calls evas_init() before
+ *       setting the output method.
+ *
+ * @ingroup Evas_Output_Method
+ */
+EAPI void              evas_output_method_set(Evas *e, int render_method) EINA_ARG_NONNULL(1);
+
+/**
+ * Retrieves the number of the output engine used for the given evas.
+ * @param   e The given evas.
+ * @return  The ID number of the output engine being used.  @c 0 is
+ *          returned if there is an error.
+ * @ingroup Evas_Output_Method
+ */
+EAPI int               evas_output_method_get(const Evas *e) EINA_WARN_UNUSED_RESULT EINA_ARG_NONNULL(1);
+
+/**
+ * Retrieves the current render engine info struct from the given evas.
+ *
+ * The returned structure is publicly modifiable.  The contents are
+ * valid until either @ref evas_engine_info_set or @ref evas_render
+ * are called.
+ *
+ * This structure does not need to be freed by the caller.
+ *
+ * @param   e The given evas.
+ * @return  A pointer to the Engine Info structure.  @c NULL is returned if
+ *          an engine has not yet been assigned.
+ * @ingroup Evas_Output_Method
+ */
+EAPI Evas_Engine_Info *evas_engine_info_get(const Evas *e) EINA_WARN_UNUSED_RESULT EINA_ARG_NONNULL(1);
+
+/**
+ * Applies the engine settings for the given evas from the given @c
+ * Evas_Engine_Info structure.
+ *
+ * To get the Evas_Engine_Info structure to use, call @ref
+ * evas_engine_info_get .  Do not try to obtain a pointer to an
+ * @c 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 @p info pointer should be considered invalid.
+ *
+ * @param   e    The pointer to the Evas Canvas
+ * @param   info The pointer to the Engine Info to use
+ * @return  @c EINA_TRUE if no error occurred, @c EINA_FALSE otherwise.
+ * @ingroup Evas_Output_Method
+ */
+EAPI Eina_Bool         evas_engine_info_set(Evas *e, Evas_Engine_Info *info) EINA_ARG_NONNULL(1);
+/**
+ * @}
+ */
+
+/**
+ * @ingroup Evas_Output_Size
+ *
+ * @{
+ */
+/**
+ * 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 @p w and @p h depend on the engine used by the
+ * evas.
+ *
+ * @param   e The given evas.
+ * @param   w The width in output units, usually pixels.
+ * @param   h The height in output units, usually pixels.
+ * @ingroup Evas_Output_Size
+ */
+EAPI void              evas_output_size_set(Evas *e, int w, int h) EINA_ARG_NONNULL(1);
+
+/**
+ * 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 @p w or @p h is @c NULL, then it is ignored.  If @p e is
+ * invalid, the returned results are undefined.
+ *
+ * @param   e The given evas.
+ * @param   w The pointer to an integer to store the width in.
+ * @param   h The pointer to an integer to store the height in.
+ * @ingroup Evas_Output_Size
+ */
+EAPI void              evas_output_size_get(const Evas *e, int *w, int *h) EINA_ARG_NONNULL(1);
+
+/**
+ * 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.
+ *
+ * @param   e The given evas.
+ * @param   x The top-left corner x value of the viewport.
+ * @param   y The top-left corner y value of the viewport.
+ * @param   w The width of the viewport.  Must be greater than 0.
+ * @param   h The height of the viewport.  Must be greater than 0.
+ * @ingroup Evas_Output_Size
+ */
+EAPI void              evas_output_viewport_set(Evas *e, Evas_Coord x, Evas_Coord y, Evas_Coord w, Evas_Coord h) EINA_ARG_NONNULL(1);
+
+/**
+ * Get the render engine's output viewport co-ordinates in canvas units.
+ * @param e The pointer to the Evas Canvas
+ * @param x The pointer to a x variable to be filled in
+ * @param y The pointer to a y variable to be filled in
+ * @param w The pointer to a width variable to be filled in
+ * @param h The pointer to a height variable to be filled in
+ * @ingroup Evas_Output_Size
+ *
+ * Calling this function writes the current canvas output viewport
+ * size and location values into the variables pointed to by @p x, @p
+ * y, @p w and @p h.  On success the variables have the output
+ * location and size values written to them in canvas units. Any of @p
+ * x, @p y, @p w or @p h that are @c NULL will not be written to. If @p e
+ * is invalid, the results are undefined.
+ *
+ * Example:
+ * @code
+ * extern Evas *evas;
+ * Evas_Coord x, y, width, height;
+ *
+ * evas_output_viewport_get(evas, &x, &y, &w, &h);
+ * @endcode
+ */
+EAPI void              evas_output_viewport_get(const Evas *e, Evas_Coord *x, Evas_Coord *y, Evas_Coord *w, Evas_Coord *h) EINA_ARG_NONNULL(1);
+
+/**
+ * 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 where
+ * the output is not drawn. This is mainly used in ecore_evas to draw borders
+ *
+ * The units used for @p w and @p h depend on the engine used by the
+ * evas.
+ *
+ * @param   e The given evas.
+ * @param   x The left coordinate in output units, usually pixels.
+ * @param   y The top coordinate in output units, usually pixels.
+ * @param   w The width in output units, usually pixels.
+ * @param   h The height in output units, usually pixels.
+ * @ingroup Evas_Output_Size
+ * @since 1.1
+ */
+EAPI void              evas_output_framespace_set(Evas *e, Evas_Coord x, Evas_Coord y, Evas_Coord w, Evas_Coord h);
+
+/**
+ * Get the render engine's output framespace co-ordinates in canvas units.
+ *
+ * @param e The pointer to the Evas Canvas
+ * @param x The pointer to a x variable to be filled in
+ * @param y The pointer to a y variable to be filled in
+ * @param w The pointer to a width variable to be filled in
+ * @param h The pointer to a height variable to be filled in
+ * @ingroup Evas_Output_Size
+ * @since 1.1
+ */
+EAPI void              evas_output_framespace_get(const Evas *e, Evas_Coord *x, Evas_Coord *y, Evas_Coord *w, Evas_Coord *h);
+/**
+ * @}
+ */
+
+/**
+ * Convert/scale an ouput screen co-ordinate into canvas co-ordinates
+ *
+ * @param e The pointer to the Evas Canvas
+ * @param x The screen/output x co-ordinate
+ * @return The screen co-ordinate translated to canvas unit co-ordinates
+ * @ingroup Evas_Coord_Mapping_Group
+ *
+ * This function takes in a horizontal co-ordinate as the @p x
+ * parameter and converts it into canvas units, accounting for output
+ * size, viewport size and location, returning it as the function
+ * return value. If @p e is invalid, the results are undefined.
+ *
+ * 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
+ */
+EAPI Evas_Coord        evas_coord_screen_x_to_world(const Evas *e, int x) EINA_WARN_UNUSED_RESULT EINA_ARG_NONNULL(1);
+
+/**
+ * Convert/scale an ouput screen co-ordinate into canvas co-ordinates
+ *
+ * @param e The pointer to the Evas Canvas
+ * @param y The screen/output y co-ordinate
+ * @return The screen co-ordinate translated to canvas unit co-ordinates
+ * @ingroup Evas_Coord_Mapping_Group
+ *
+ * This function takes in a vertical co-ordinate as the @p y parameter
+ * and converts it into canvas units, accounting for output size,
+ * viewport size and location, returning it as the function return
+ * value. If @p e is invalid, the results are undefined.
+ *
+ * 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
+ */
+EAPI Evas_Coord        evas_coord_screen_y_to_world(const Evas *e, int y) EINA_WARN_UNUSED_RESULT EINA_ARG_NONNULL(1);
+
+/**
+ * Convert/scale a canvas co-ordinate into output screen co-ordinates
+ *
+ * @param e The pointer to the Evas Canvas
+ * @param x The canvas x co-ordinate
+ * @return The output/screen co-ordinate translated to output co-ordinates
+ * @ingroup Evas_Coord_Mapping_Group
+ *
+ * This function takes in a horizontal co-ordinate as the @p x
+ * parameter and converts it into output units, accounting for output
+ * size, viewport size and location, returning it as the function
+ * return value. If @p e is invalid, the results are undefined.
+ *
+ * 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
+ */
+EAPI int               evas_coord_world_x_to_screen(const Evas *e, Evas_Coord x) EINA_WARN_UNUSED_RESULT EINA_ARG_NONNULL(1);
+
+/**
+ * Convert/scale a canvas co-ordinate into output screen co-ordinates
+ *
+ * @param e The pointer to the Evas Canvas
+ * @param y The canvas y co-ordinate
+ * @return The output/screen co-ordinate translated to output co-ordinates
+ * @ingroup Evas_Coord_Mapping_Group
+ *
+ * This function takes in a vertical co-ordinate as the @p x parameter
+ * and converts it into output units, accounting for output size,
+ * viewport size and location, returning it as the function return
+ * value. If @p e is invalid, the results are undefined.
+ *
+ * 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
+ */
+EAPI int               evas_coord_world_y_to_screen(const Evas *e, Evas_Coord y) EINA_WARN_UNUSED_RESULT EINA_ARG_NONNULL(1);
+
+/**
+ * @defgroup Evas_Pointer_Group Pointer (Mouse) Functions
+ *
+ * Functions that deal with the status of the pointer (mouse cursor).
+ *
+ * @ingroup Evas_Canvas
+ */
+
+/**
+ * This function returns the current known pointer co-ordinates
+ *
+ * @param e The pointer to the Evas Canvas
+ * @param x The pointer to an integer to be filled in
+ * @param y The pointer to an integer to be filled in
+ * @ingroup Evas_Pointer_Group
+ *
+ * This function returns the current known screen/output co-ordinates
+ * of the mouse pointer and sets the contents of the integers pointed
+ * to by @p x and @p y to contain these co-ordinates. If @p e is not a
+ * valid canvas the results of this function are undefined.
+ *
+ * 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
+ */
+EAPI void              evas_pointer_output_xy_get(const Evas *e, int *x, int *y) EINA_ARG_NONNULL(1);
+
+/**
+ * This function returns the current known pointer co-ordinates
+ *
+ * @param e The pointer to the Evas Canvas
+ * @param x The pointer to a Evas_Coord to be filled in
+ * @param y The pointer to a Evas_Coord to be filled in
+ * @ingroup Evas_Pointer_Group
+ *
+ * This function returns the current known canvas unit co-ordinates of
+ * the mouse pointer and sets the contents of the Evas_Coords pointed
+ * to by @p x and @p y to contain these co-ordinates. If @p e is not a
+ * valid canvas the results of this function are undefined.
+ *
+ * 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
+ */
+EAPI void              evas_pointer_canvas_xy_get(const Evas *e, Evas_Coord *x, Evas_Coord *y) EINA_ARG_NONNULL(1);
+
+/**
+ * Returns a bitmask with the mouse buttons currently pressed, set to 1
+ *
+ * @param e The pointer to the Evas Canvas
+ * @return A bitmask of the currently depressed buttons on the canvas
+ * @ingroup Evas_Pointer_Group
+ *
+ * Calling this function will return a 32-bit integer with the
+ * appropriate bits set to 1 that 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 calls to evas_event_feed_mouse_down(),
+ * evas_event_feed_mouse_down_data(), evas_event_feed_mouse_up() and
+ * evas_event_feed_mouse_up_data() will 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 @p e is not a valid canvas, the return value is undefined.
+ *
+ * Example:
+ * @code
+ * extern Evas *evas;
+ * int button_mask, i;
+ *
+ * button_mask = evas_pointer_button_down_mask_get(evas);
+ * printf("Buttons currently pressed:\n");
+ * for (i = 0; i < 32; i++)
+ *   {
+ *     if ((button_mask & (1 << i)) != 0) printf("Button %i\n", i + 1);
+ *   }
+ * @endcode
+ */
+EAPI int               evas_pointer_button_down_mask_get(const Evas *e) EINA_WARN_UNUSED_RESULT EINA_ARG_NONNULL(1);
+
+/**
+ * Returns whether the mouse pointer is logically inside the canvas
+ *
+ * @param e The pointer to the Evas Canvas
+ * @return An integer that is 1 if the mouse is inside the canvas, 0 otherwise
+ * @ingroup Evas_Pointer_Group
+ *
+ * When this function is called it will return a value of either 0 or
+ * 1, depending on if evas_event_feed_mouse_in(),
+ * evas_event_feed_mouse_in_data(), or evas_event_feed_mouse_out(),
+ * evas_event_feed_mouse_out_data() have been called to feed in a
+ * mouse enter event into the canvas.
+ *
+ * A return value of 1 indicates the mouse is logically inside the
+ * canvas, and 0 implies it is logically outside the canvas.
+ *
+ * A canvas begins with the mouse being assumed outside (0).
+ *
+ * If @p e is not a valid canvas, the return value is undefined.
+ *
+ * Example:
+ * @code
+ * extern Evas *evas;
+ *
+ * if (evas_pointer_inside_get(evas)) printf("Mouse is in!\n");
+ * else printf("Mouse is out!\n");
+ * @endcode
+ */
+EAPI Eina_Bool         evas_pointer_inside_get(const Evas *e) EINA_WARN_UNUSED_RESULT EINA_ARG_NONNULL(1);
+
+EAPI void              evas_sync(Evas *e) EINA_ARG_NONNULL(1);
+
+/**
+ * @}
+ */
+
+/**
+ * @ingroup Evas_Canvas_Events
+ *
+ * @{
+ */
+
+/**
+ * Add (register) a callback function to a given canvas event.
+ *
+ * @param e Canvas to attach a callback to
+ * @param type The type of event that will trigger the callback
+ * @param func The (callback) function to be called when the event is
+ *        triggered
+ * @param data The data pointer to be passed to @p func
+ *
+ * This function adds a function callback to the canvas @p e when the
+ * event of type @p type occurs on it. The function pointer is @p
+ * func.
+ *
+ * In the event of a memory allocation error during the addition of
+ * the callback to the canvas, evas_alloc_error() should be used to
+ * determine the nature of the error, if any, and the program should
+ * sensibly try and recover.
+ *
+ * A callback function must have the ::Evas_Event_Cb prototype
+ * definition. The first parameter (@p data) in this definition will
+ * have the same value passed to evas_event_callback_add() as the @p
+ * data parameter, at runtime. The second parameter @p e is the canvas
+ * pointer on which the event occurred. The third parameter @p
+ * event_info is a pointer to a data structure that may or may not be
+ * passed to the callback, depending on the event type that triggered
+ * the callback. This is so because some events don't carry extra
+ * context with them, but others do.
+ *
+ * The event type @p type to trigger the function may be one of
+ * #EVAS_CALLBACK_RENDER_FLUSH_PRE, #EVAS_CALLBACK_RENDER_FLUSH_POST,
+ * #EVAS_CALLBACK_CANVAS_FOCUS_IN, #EVAS_CALLBACK_CANVAS_FOCUS_OUT,
+ * #EVAS_CALLBACK_CANVAS_OBJECT_FOCUS_IN and
+ * #EVAS_CALLBACK_CANVAS_OBJECT_FOCUS_OUT. This determines the kind of
+ * event that will trigger the callback to be called. Only the last
+ * two of the event types listed here provide useful event information
+ * data -- a pointer to the recently focused Evas object. For the
+ * others the @p event_info pointer is going to be @c NULL.
+ *
+ * Example:
+ * @dontinclude evas-events.c
+ * @skip evas_event_callback_add(d.canvas, EVAS_CALLBACK_RENDER_FLUSH_PRE
+ * @until two canvas event callbacks
+ *
+ * Looking to the callbacks registered above,
+ * @dontinclude evas-events.c
+ * @skip called when our rectangle gets focus
+ * @until let's have our events back
+ *
+ * we see that the canvas flushes its rendering pipeline
+ * (#EVAS_CALLBACK_RENDER_FLUSH_PRE) whenever the @c _resize_cb
+ * routine takes place: it has to redraw that image at a different
+ * size. Also, the callback on an object being focused comes just
+ * after we focus it explicitly, on code.
+ *
+ * See the full @ref Example_Evas_Events "example".
+ *
+ * @note Be careful not to add the same callback multiple times, if
+ * that's not what you want, because Evas won't check if a callback
+ * existed before exactly as the one being registered (and thus, call
+ * it more than once on the event, in this case). This would make
+ * sense if you passed different functions and/or callback data, only.
+ */
+EAPI void  evas_event_callback_add(Evas *e, Evas_Callback_Type type, Evas_Event_Cb func, const void *data) EINA_ARG_NONNULL(1, 3);
+
+/**
+ * Add (register) a callback function to a given canvas event with a
+ * non-default priority set. Except for the priority field, it's exactly the
+ * same as @ref evas_event_callback_add
+ *
+ * @param e Canvas to attach a callback to
+ * @param type The type of event that will trigger the callback
+ * @param priority The priority of the callback, lower values called first.
+ * @param func The (callback) function to be called when the event is
+ *        triggered
+ * @param data The data pointer to be passed to @p func
+ *
+ * @see evas_event_callback_add
+ * @since 1.1
+ */
+EAPI void  evas_event_callback_priority_add(Evas *e, Evas_Callback_Type type, Evas_Callback_Priority priority, Evas_Event_Cb func, const void *data) EINA_ARG_NONNULL(1, 4);
+
+/**
+ * Delete a callback function from the canvas.
+ *
+ * @param e Canvas to remove a callback from
+ * @param type The type of event that was triggering the callback
+ * @param func The function that was to be called when the event was triggered
+ * @return The data pointer that was to be passed to the callback
+ *
+ * This function removes the most recently added callback from the
+ * canvas @p e which was triggered by the event type @p type and was
+ * calling the function @p func when triggered. If the removal is
+ * successful it will also return the data pointer that was passed to
+ * evas_event_callback_add() when the callback was added to the
+ * canvas. If not successful @c NULL will be returned.
+ *
+ * Example:
+ * @code
+ * extern Evas *e;
+ * void *my_data;
+ * void focus_in_callback(void *data, Evas *e, void *event_info);
+ *
+ * my_data = evas_event_callback_del(ebject, EVAS_CALLBACK_CANVAS_FOCUS_IN, focus_in_callback);
+ * @endcode
+ */
+EAPI void *evas_event_callback_del(Evas *e, Evas_Callback_Type type, Evas_Event_Cb func) EINA_ARG_NONNULL(1, 3);
+
+/**
+ * Delete (unregister) a callback function registered to a given
+ * canvas event.
+ *
+ * @param e Canvas to remove an event callback from
+ * @param type The type of event that was triggering the callback
+ * @param func The function that was to be called when the event was
+ *        triggered
+ * @param data The data pointer that was to be passed to the callback
+ * @return The data pointer that was to be passed to the callback
+ *
+ * This function removes <b>the first</b> added callback from the
+ * canvas @p e matching the event type @p type, the registered
+ * function pointer @p func and the callback data pointer @p data. If
+ * the removal is successful it will also return the data pointer that
+ * was passed to evas_event_callback_add() (that will be the same as
+ * the parameter) when the callback(s) was(were) added to the
+ * canvas. If not successful @c NULL will be returned. A common use
+ * would be to remove an exact match of a callback.
+ *
+ * Example:
+ * @dontinclude evas-events.c
+ * @skip evas_event_callback_del_full(evas, EVAS_CALLBACK_RENDER_FLUSH_PRE,
+ * @until _object_focus_in_cb, NULL);
+ *
+ * See the full @ref Example_Evas_Events "example".
+ *
+ * @note For deletion of canvas events callbacks filtering by just
+ * type and function pointer, user evas_event_callback_del().
+ */
+EAPI void *evas_event_callback_del_full(Evas *e, Evas_Callback_Type type, Evas_Event_Cb func, const void *data) EINA_ARG_NONNULL(1, 3);
+
+/**
+ * Push a callback on the post-event callback stack
+ *
+ * @param e Canvas to push the callback on
+ * @param func The function that to be called when the stack is unwound
+ * @param data The data pointer to be passed to the callback
+ *
+ * Evas has a stack of callbacks that get called after all the callbacks for
+ * an event have triggered (all the objects it triggers on and all the callbacks
+ * in each object triggered). When all these have been called, the stack is
+ * unwond from most recently to least recently pushed item and removed from the
+ * stack calling the callback set for it.
+ *
+ * This is intended for doing reverse logic-like processing, example - when a
+ * child object that happens to get the event later is meant to be able to
+ * "steal" functions from a parent and thus on unwind of this stack have its
+ * function called first, thus being able to set flags, or return 0 from the
+ * post-callback that stops all other post-callbacks in the current stack from
+ * being called (thus basically allowing a child to take control, if the event
+ * callback prepares information ready for taking action, but the post callback
+ * actually does the action).
+ *
+ */
+EAPI void  evas_post_event_callback_push(Evas *e, Evas_Object_Event_Post_Cb func, const void *data);
+
+/**
+ * Remove a callback from the post-event callback stack
+ *
+ * @param e Canvas to push the callback on
+ * @param func The function that to be called when the stack is unwound
+ *
+ * This removes a callback from the stack added with
+ * evas_post_event_callback_push(). The first instance of the function in
+ * the callback stack is removed from being executed when the stack is
+ * unwound. Further instances may still be run on unwind.
+ */
+EAPI void  evas_post_event_callback_remove(Evas *e, Evas_Object_Event_Post_Cb func);
+
+/**
+ * Remove a callback from the post-event callback stack
+ *
+ * @param e Canvas to push the callback on
+ * @param func The function that to be called when the stack is unwound
+ * @param data The data pointer to be passed to the callback
+ *
+ * This removes a callback from the stack added with
+ * evas_post_event_callback_push(). The first instance of the function and data
+ * in the callback stack is removed from being executed when the stack is
+ * unwound. Further instances may still be run on unwind.
+ */
+EAPI void  evas_post_event_callback_remove_full(Evas *e, Evas_Object_Event_Post_Cb func, const void *data);
+
+/**
+ * @}
+ */
+
+/**
+ * @ingroup Evas_Event_Feeding_Group
+ *
+ * @{
+ */
+
+/**
+ * Set the default set of flags an event begins with
+ *
+ * @param e The canvas to set the default event flags of
+ * @param flags The default flags to use
+ *
+ * Events in evas can have an event_flags member. This starts out with
+ * and initial value (no flags). this lets you set the default flags that
+ * an event begins with to be @p flags
+ *
+ * @since 1.2
+ */
+EAPI void             evas_event_default_flags_set(Evas *e, Evas_Event_Flags flags) EINA_ARG_NONNULL(1);
+
+/**
+ * Get the defaulty set of flags an event begins with
+ *
+ * @param e The canvas to get the default event flags from
+ * @return The default event flags for that canvas
+ *
+ * This gets the default event flags events are produced with when fed in.
+ *
+ * @see evas_event_default_flags_set()
+ * @since 1.2
+ */
+EAPI Evas_Event_Flags evas_event_default_flags_get(const Evas *e) EINA_ARG_NONNULL(1);
+
+/**
+ * Freeze all input events processing.
+ *
+ * @param e The canvas to freeze input events processing on.
+ *
+ * This function will indicate to Evas that the canvas @p e is to have
+ * all input event processing frozen until a matching
+ * evas_event_thaw() function is called on the same canvas. All events
+ * of this kind during the freeze will get @b discarded. Every freeze
+ * call must be matched by a thaw call in order to completely thaw out
+ * a canvas (i.e. these calls may be nested). The most common use is
+ * when you don't want the user to interact with your user interface
+ * when you're populating a view or changing the layout.
+ *
+ * Example:
+ * @dontinclude evas-events.c
+ * @skip freeze input for 3 seconds
+ * @until }
+ * @dontinclude evas-events.c
+ * @skip let's have our events back
+ * @until }
+ *
+ * See the full @ref Example_Evas_Events "example".
+ *
+ * If you run that example, you'll see the canvas ignoring all input
+ * events for 3 seconds, when the "f" key is pressed. In a more
+ * realistic code we would be freezing while a toolkit or Edje was
+ * doing some UI changes, thawing it back afterwards.
+ */
+EAPI void             evas_event_freeze(Evas *e) EINA_ARG_NONNULL(1);
+
+/**
+ * Thaw a canvas out after freezing (for input events).
+ *
+ * @param e The canvas to thaw out.
+ *
+ * This will thaw out a canvas after a matching evas_event_freeze()
+ * call. If this call completely thaws out a canvas, i.e., there's no
+ * other unbalanced call to evas_event_freeze(), events will start to
+ * be processed again, but any "missed" events will @b not be
+ * evaluated.
+ *
+ * See evas_event_freeze() for an example.
+ */
+EAPI void             evas_event_thaw(Evas *e) EINA_ARG_NONNULL(1);
+
+/**
+ * Return the freeze count on input events of a given canvas.
+ *
+ * @param e The canvas to fetch the freeze count from.
+ *
+ * This returns the number of times the canvas has been told to freeze
+ * input events. It is possible to call evas_event_freeze() multiple
+ * times, and these must be matched by evas_event_thaw() calls. This
+ * call allows the program to discover just how many times things have
+ * been frozen in case it may want to break out of a deep freeze state
+ * where the count is high.
+ *
+ * Example:
+ * @code
+ * extern Evas *evas;
+ *
+ * while (evas_event_freeze_get(evas) > 0) evas_event_thaw(evas);
+ * @endcode
+ *
+ */
+EAPI int              evas_event_freeze_get(const Evas *e) EINA_WARN_UNUSED_RESULT EINA_ARG_NONNULL(1);
+
+/**
+ * After thaw of a canvas, re-evaluate the state of objects and call callbacks
+ *
+ * @param e The canvas to evaluate after a thaw
+ *
+ * This is normally called after evas_event_thaw() to re-evaluate mouse
+ * containment and other states and thus also call callbacks for mouse in and
+ * out on new objects if the state change demands it.
+ */
+EAPI void             evas_event_thaw_eval(Evas *e) EINA_ARG_NONNULL(1);
+/**
+ * @}
+ */
+
+/**
+ * @ingroup Evas_Event_Feeding_Group
+ *
+ * @{
+ */
+
+/**
+ * Get the number of mouse or multi presses currently active
+ *
+ * @p e The given canvas pointer.
+ * @return The numer of presses (0 if none active).
+ *
+ * @since 1.2
+ */
+EAPI int  evas_event_down_count_get(const Evas *e) EINA_ARG_NONNULL(1);
+
+/**
+ * Mouse down event feed.
+ *
+ * @param e The given canvas pointer.
+ * @param b The button number.
+ * @param flags The evas button flags.
+ * @param timestamp The timestamp of the mouse down event.
+ * @param data The data for canvas.
+ *
+ * This function will set some evas properties that is necessary when
+ * the mouse button is pressed. It prepares information to be treated
+ * by the callback function.
+ *
+ */
+EAPI void evas_event_feed_mouse_down(Evas *e, int b, Evas_Button_Flags flags, unsigned int timestamp, const void *data) EINA_ARG_NONNULL(1);
+
+/**
+ * Mouse up event feed.
+ *
+ * @param e The given canvas pointer.
+ * @param b The button number.
+ * @param flags evas button flags.
+ * @param timestamp The timestamp of the mouse up event.
+ * @param data The data for canvas.
+ *
+ * This function will set some evas properties that is necessary when
+ * the mouse button is released. It prepares information to be treated
+ * by the callback function.
+ *
+ */
+EAPI void evas_event_feed_mouse_up(Evas *e, int b, Evas_Button_Flags flags, unsigned int timestamp, const void *data) EINA_ARG_NONNULL(1);
+
+/**
+ * Mouse move event feed.
+ *
+ * @param e The given canvas pointer.
+ * @param x The horizontal position of the mouse pointer.
+ * @param y The vertical position of the mouse pointer.
+ * @param timestamp The timestamp of the mouse up event.
+ * @param data The data for canvas.
+ *
+ * This function will set some evas properties that is necessary when
+ * the mouse is moved from its last position. It prepares information
+ * to be treated by the callback function.
+ *
+ */
+EAPI void evas_event_feed_mouse_move(Evas *e, int x, int y, unsigned int timestamp, const void *data) EINA_ARG_NONNULL(1);
+
+/**
+ * Mouse in event feed.
+ *
+ * @param e The given canvas pointer.
+ * @param timestamp The timestamp of the mouse up event.
+ * @param data The data for canvas.
+ *
+ * This function will set some evas properties that is necessary when
+ * the mouse in event happens. It prepares information to be treated
+ * by the callback function.
+ *
+ */
+EAPI void evas_event_feed_mouse_in(Evas *e, unsigned int timestamp, const void *data) EINA_ARG_NONNULL(1);
+
+/**
+ * Mouse out event feed.
+ *
+ * @param e The given canvas pointer.
+ * @param timestamp Timestamp of the mouse up event.
+ * @param data The data for canvas.
+ *
+ * This function will set some evas properties that is necessary when
+ * the mouse out event happens. It prepares information to be treated
+ * by the callback function.
+ *
+ */
+EAPI void evas_event_feed_mouse_out(Evas *e, unsigned int timestamp, const void *data) EINA_ARG_NONNULL(1);
+EAPI void evas_event_feed_multi_down(Evas *e, int d, int x, int y, double rad, double radx, double rady, double pres, double ang, double fx, double fy, Evas_Button_Flags flags, unsigned int timestamp, const void *data);
+EAPI void evas_event_feed_multi_up(Evas *e, int d, int x, int y, double rad, double radx, double rady, double pres, double ang, double fx, double fy, Evas_Button_Flags flags, unsigned int timestamp, const void *data);
+EAPI void evas_event_feed_multi_move(Evas *e, int d, int x, int y, double rad, double radx, double rady, double pres, double ang, double fx, double fy, unsigned int timestamp, const void *data);
+
+/**
+ * Mouse cancel event feed.
+ *
+ * @param e The given canvas pointer.
+ * @param timestamp The timestamp of the mouse up event.
+ * @param data The data for canvas.
+ *
+ * This function will call evas_event_feed_mouse_up() when a
+ * mouse cancel event happens.
+ *
+ */
+EAPI void evas_event_feed_mouse_cancel(Evas *e, unsigned int timestamp, const void *data) EINA_ARG_NONNULL(1);
+
+/**
+ * Mouse wheel event feed.
+ *
+ * @param e The given canvas pointer.
+ * @param direction The wheel mouse direction.
+ * @param z How much mouse wheel was scrolled up or down.
+ * @param timestamp The timestamp of the mouse up event.
+ * @param data The data for canvas.
+ *
+ * This function will set some evas properties that is necessary when
+ * the mouse wheel is scrolled up or down. It prepares information to
+ * be treated by the callback function.
+ *
+ */
+EAPI void evas_event_feed_mouse_wheel(Evas *e, int direction, int z, unsigned int timestamp, const void *data) EINA_ARG_NONNULL(1);
+
+/**
+ * Key down event feed
+ *
+ * @param e The canvas to thaw out
+ * @param keyname  Name of the key
+ * @param key The key pressed.
+ * @param string A String
+ * @param compose The compose string
+ * @param timestamp Timestamp of the mouse up event
+ * @param data Data for canvas.
+ *
+ * This function will set some evas properties that is necessary when
+ * a key is pressed. It prepares information to be treated by the
+ * callback function.
+ *
+ */
+EAPI void evas_event_feed_key_down(Evas *e, const char *keyname, const char *key, const char *string, const char *compose, unsigned int timestamp, const void *data) EINA_ARG_NONNULL(1);
+
+/**
+ * Key up event feed
+ *
+ * @param e The canvas to thaw out
+ * @param keyname  Name of the key
+ * @param key The key released.
+ * @param string string
+ * @param compose compose
+ * @param timestamp Timestamp of the mouse up event
+ * @param data Data for canvas.
+ *
+ * This function will set some evas properties that is necessary when
+ * a key is released. It prepares information to be treated by the
+ * callback function.
+ *
+ */
+EAPI void evas_event_feed_key_up(Evas *e, const char *keyname, const char *key, const char *string, const char *compose, unsigned int timestamp, const void *data) EINA_ARG_NONNULL(1);
+
+/**
+ * Hold event feed
+ *
+ * @param e The given canvas pointer.
+ * @param hold The hold.
+ * @param timestamp The timestamp of the mouse up event.
+ * @param data The data for canvas.
+ *
+ * This function makes the object to stop sending events.
+ *
+ */
+EAPI void evas_event_feed_hold(Evas *e, int hold, unsigned int timestamp, const void *data) EINA_ARG_NONNULL(1);
+
+/**
+ * Re feed event.
+ *
+ * @param e The given canvas pointer.
+ * @param event_copy the event to refeed
+ * @param event_type Event type
+ *
+ * This function re-feeds the event pointed by event_copy
+ *
+ * This function call evas_event_feed_* functions, so it can
+ * cause havoc if not used wisely. Please use it responsibly.
+ */
+EAPI void evas_event_refeed_event(Evas *e, void *event_copy, Evas_Callback_Type event_type) EINA_ARG_NONNULL(1);
+
+/**
+ * @}
+ */
+
+/**
+ * @ingroup Evas_Image_Group
+ *
+ * @{
+ */
+
+/**
+ * Flush the image cache of the canvas.
+ *
+ * @param e The given evas pointer.
+ *
+ * This function flushes image cache of canvas.
+ *
+ */
+EAPI void      evas_image_cache_flush(Evas *e) EINA_ARG_NONNULL(1);
+
+/**
+ * Reload the image cache
+ *
+ * @param e The given evas pointer.
+ *
+ * This function reloads the image cache of canvas.
+ *
+ */
+EAPI void      evas_image_cache_reload(Evas *e) EINA_ARG_NONNULL(1);
+
+/**
+ * Set the image cache.
+ *
+ * @param e The given evas pointer.
+ * @param size The cache size.
+ *
+ * This function sets the image cache of canvas in bytes.
+ *
+ */
+EAPI void      evas_image_cache_set(Evas *e, int size) EINA_ARG_NONNULL(1);
+
+/**
+ * Get the image cache
+ *
+ * @param e The given evas pointer.
+ *
+ * This function returns the image cache size of canvas in bytes.
+ *
+ */
+EAPI int       evas_image_cache_get(const Evas *e) EINA_WARN_UNUSED_RESULT EINA_ARG_NONNULL(1);
+
+/**
+ * Get the maximum image size evas can possibly handle
+ *
+ * @param e The given evas pointer.
+ * @param maxw Pointer to hold the return value in pixels of the maxumum width
+ * @param maxh Pointer to hold the return value in pixels of the maximum height
+ *
+ * This function returns the larges image or surface size that evas can handle
+ * in pixels, and if there is one, returns @c EINA_TRUE. It returns
+ * @c EINA_FALSE if no extra constraint on maximum image size exists. You still
+ * should check the return values of @p maxw and @p maxh as there may still be
+ * a limit, just a much higher one.
+ *
+ * @since 1.1
+ */
+EAPI Eina_Bool evas_image_max_size_get(const Evas *e, int *maxw, int *maxh) EINA_ARG_NONNULL(1);
+/**
+ * @}
+ */
+
+/**
+ * @ingroup Evas_Font_Group
+ *
+ * @{
+ */
+
+/**
+ * Changes the font hinting for the given evas.
+ *
+ * @param e The given evas.
+ * @param hinting The hinting to use, one of #EVAS_FONT_HINTING_NONE,
+ *        #EVAS_FONT_HINTING_AUTO, #EVAS_FONT_HINTING_BYTECODE.
+ * @ingroup Evas_Font_Group
+ */
+EAPI void                    evas_font_hinting_set(Evas *e, Evas_Font_Hinting_Flags hinting) EINA_ARG_NONNULL(1);
+
+/**
+ * Retrieves the font hinting used by the given evas.
+ *
+ * @param e The given evas to query.
+ * @return The hinting in use, one of #EVAS_FONT_HINTING_NONE,
+ *         #EVAS_FONT_HINTING_AUTO, #EVAS_FONT_HINTING_BYTECODE.
+ * @ingroup Evas_Font_Group
+ */
+EAPI Evas_Font_Hinting_Flags evas_font_hinting_get(const Evas *e) EINA_WARN_UNUSED_RESULT EINA_ARG_NONNULL(1);
+
+/**
+ * Checks if the font hinting is supported by the given evas.
+ *
+ * @param e The given evas to query.
+ * @param hinting The hinting to use, one of #EVAS_FONT_HINTING_NONE,
+ *        #EVAS_FONT_HINTING_AUTO, #EVAS_FONT_HINTING_BYTECODE.
+ * @return @c EINA_TRUE if it is supported, @c EINA_FALSE otherwise.
+ * @ingroup Evas_Font_Group
+ */
+EAPI Eina_Bool               evas_font_hinting_can_hint(const Evas *e, Evas_Font_Hinting_Flags hinting) EINA_WARN_UNUSED_RESULT EINA_ARG_NONNULL(1);
+
+/**
+ * Force the given evas and associated engine to flush its font cache.
+ *
+ * @param e The given evas to flush font cache.
+ * @ingroup Evas_Font_Group
+ */
+EAPI void                    evas_font_cache_flush(Evas *e) EINA_ARG_NONNULL(1);
+
+/**
+ * Changes the size of font cache of the given evas.
+ *
+ * @param e The given evas to flush font cache.
+ * @param size The size, in bytes.
+ *
+ * @ingroup Evas_Font_Group
+ */
+EAPI void                    evas_font_cache_set(Evas *e, int size) EINA_ARG_NONNULL(1);
+
+/**
+ * Changes the size of font cache of the given evas.
+ *
+ * @param e The given evas to flush font cache.
+ * @return The size, in bytes.
+ *
+ * @ingroup Evas_Font_Group
+ */
+EAPI int                     evas_font_cache_get(const Evas *e) EINA_WARN_UNUSED_RESULT EINA_ARG_NONNULL(1);
+
+/**
+ * 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.
+ *
+ * @param e The evas instance to query.
+ * @return a newly allocated list of strings. Do not change the
+ *         strings.  Be sure to call evas_font_available_list_free()
+ *         after you're done.
+ *
+ * @ingroup Evas_Font_Group
+ */
+EAPI Eina_List              *evas_font_available_list(const Evas *e) EINA_WARN_UNUSED_RESULT EINA_ARG_NONNULL(1);
+
+/**
+ * Free list of font descriptions returned by evas_font_dir_available_list().
+ *
+ * @param e The evas instance that returned such list.
+ * @param available the list returned by evas_font_dir_available_list().
+ *
+ * @ingroup Evas_Font_Group
+ */
+EAPI void                    evas_font_available_list_free(Evas *e, Eina_List *available) EINA_ARG_NONNULL(1);
+
+/**
+ * @defgroup Evas_Font_Path_Group Font Path Functions
+ *
+ * Functions that edit the paths being used to load fonts.
+ *
+ * @ingroup Evas_Font_Group
+ */
+
+/**
+ * Removes all font paths loaded into memory for the given evas.
+ * @param   e The given evas.
+ * @ingroup Evas_Font_Path_Group
+ */
+EAPI void                    evas_font_path_clear(Evas *e) EINA_ARG_NONNULL(1);
+
+/**
+ * Appends a font path to the list of font paths used by the given evas.
+ * @param   e    The given evas.
+ * @param   path The new font path.
+ * @ingroup Evas_Font_Path_Group
+ */
+EAPI void                    evas_font_path_append(Evas *e, const char *path) EINA_ARG_NONNULL(1, 2);
+
+/**
+ * Prepends a font path to the list of font paths used by the given evas.
+ * @param   e The given evas.
+ * @param   path The new font path.
+ * @ingroup Evas_Font_Path_Group
+ */
+EAPI void                    evas_font_path_prepend(Evas *e, const char *path) EINA_ARG_NONNULL(1, 2);
+
+/**
+ * Retrieves the list of font paths used by the given evas.
+ * @param   e The given evas.
+ * @return  The list of font paths used.
+ * @ingroup Evas_Font_Path_Group
+ */
+EAPI const Eina_List        *evas_font_path_list(const Evas *e) EINA_WARN_UNUSED_RESULT EINA_ARG_NONNULL(1);
+/**
+ * @}
+ */
+
+/**
+ * @ingroup Evas_Object_Group_Basic
+ *
+ * @{
+ */
+
+/**
+ * Clip one object to another.
+ *
+ * @param obj The object to be clipped
+ * @param clip The object to clip @p obj by
+ *
+ * This function will clip the object @p obj to the area occupied by
+ * the object @p clip. This means the object @p obj will only be
+ * visible within the area occupied by the clipping object (@p clip).
+ *
+ * The color of the object being clipped will be multiplied by the
+ * color of the clipping one, so the resulting color for the former
+ * will be <code>RESULT = (OBJ * CLIP) / (255 * 255)</code>, per color
+ * element (red, green, blue and alpha).
+ *
+ * Clipping is recursive, so clipping objects may be clipped by
+ * others, and their color will in term be multiplied. You may @b not
+ * set up circular clipping lists (i.e. object 1 clips object 2, which
+ * clips object 1): the behavior of Evas is undefined in this case.
+ *
+ * Objects which do not clip others are visible in the canvas as
+ * normal; <b>those that clip one or more objects become invisible
+ * themselves</b>, only affecting what they clip. If an object ceases
+ * to have other objects being clipped by it, it will become visible
+ * again.
+ *
+ * The visibility of an object affects the objects that are clipped by
+ * it, so if the object clipping others is not shown (as in
+ * evas_object_show()), the objects clipped by it will not be shown
+ * either.
+ *
+ * If @p obj was being clipped by another object when this function is
+ * called, it gets implicitly removed from the old clipper's domain
+ * and is made now to be clipped by its new clipper.
+ *
+ * The following figure illustrates some clipping in Evas:
+ *
+ * @image html clipping.png
+ * @image rtf clipping.png
+ * @image latex clipping.eps
+ *
+ * @note At the moment the <b>only objects that can validly be used to
+ * clip other objects are rectangle objects</b>. All other object
+ * types are invalid and the result of using them is undefined. The
+ * clip object @p clip must be a valid object, but can also be @c
+ * NULL, in which case the effect of this function is the same as
+ * calling evas_object_clip_unset() on the @p obj object.
+ *
+ * Example:
+ * @dontinclude evas-object-manipulation.c
+ * @skip solid white clipper (note that it's the default color for a
+ * @until evas_object_show(d.clipper);
+ *
+ * See the full @ref Example_Evas_Object_Manipulation "example".
+ */
+EAPI void             evas_object_clip_set(Evas_Object *obj, Evas_Object *clip) EINA_ARG_NONNULL(1, 2);
+
+/**
+ * Get the object clipping @p obj (if any).
+ *
+ * @param obj The object to get the clipper from
+ *
+ * This function returns the object clipping @p obj. If @p obj is
+ * not being clipped at all, @c NULL is returned. The object @p obj
+ * must be a valid ::Evas_Object.
+ *
+ * See also evas_object_clip_set(), evas_object_clip_unset() and
+ * evas_object_clipees_get().
+ *
+ * Example:
+ * @dontinclude evas-object-manipulation.c
+ * @skip if (evas_object_clip_get(d.img) == d.clipper)
+ * @until return
+ *
+ * See the full @ref Example_Evas_Object_Manipulation "example".
+ */
+EAPI Evas_Object     *evas_object_clip_get(const Evas_Object *obj) EINA_WARN_UNUSED_RESULT EINA_ARG_NONNULL(1);
+
+/**
+ * Disable/cease clipping on a clipped @p obj object.
+ *
+ * @param obj The object to cease clipping on
+ *
+ * This function disables clipping for the object @p obj, if it was
+ * already clipped, i.e., its visibility and color get detached from
+ * the previous clipper. If it wasn't, this has no effect. The object
+ * @p obj must be a valid ::Evas_Object.
+ *
+ * See also evas_object_clip_set() (for an example),
+ * evas_object_clipees_get() and evas_object_clip_get().
+ *
+ */
+EAPI void             evas_object_clip_unset(Evas_Object *obj);
+
+/**
+ * Return a list of objects currently clipped by @p obj.
+ *
+ * @param obj The object to get a list of clippees from
+ * @return a list of objects being clipped by @p obj
+ *
+ * This returns the internal list handle that contains all objects
+ * clipped by the object @p obj. If none are clipped by it, the call
+ * returns @c NULL. This list is only valid until the clip list is
+ * changed and should be fetched again with another call to
+ * evas_object_clipees_get() if any objects being clipped by this
+ * object are unclipped, clipped by a new object, deleted or get the
+ * clipper deleted. These operations will invalidate the list
+ * returned, so it should not be used anymore after that point. Any
+ * use of the list after this may have undefined results, possibly
+ * leading to crashes. The object @p obj must be a valid
+ * ::Evas_Object.
+ *
+ * See also evas_object_clip_set(), evas_object_clip_unset() and
+ * evas_object_clip_get().
+ *
+ * Example:
+ * @code
+ * extern Evas_Object *obj;
+ * Evas_Object *clipper;
+ *
+ * clipper = evas_object_clip_get(obj);
+ * if (clipper)
+ *   {
+ *     Eina_List *clippees, *l;
+ *     Evas_Object *obj_tmp;
+ *
+ *     clippees = evas_object_clipees_get(clipper);
+ *     printf("Clipper clips %i objects\n", eina_list_count(clippees));
+ *     EINA_LIST_FOREACH(clippees, l, obj_tmp)
+ *       evas_object_show(obj_tmp);
+ *   }
+ * @endcode
+ */
+EAPI const Eina_List *evas_object_clipees_get(const Evas_Object *obj) EINA_WARN_UNUSED_RESULT EINA_ARG_NONNULL(1);
+
+/**
+ * Test if any object is clipped by @p obj.
+ *
+ * @param obj The object to get a list of clippees from
+ * @return EINA_TRUE if @p obj clip any object.
+ * @since 1.8
+ */
+EAPI Eina_Bool evas_object_clipees_has(const Evas_Object *eo_obj) EINA_WARN_UNUSED_RESULT EINA_ARG_NONNULL(1);
+
+/**
+ * Sets or unsets a given object as the currently focused one on its
+ * canvas.
+ *
+ * @param obj The object to be focused or unfocused.
+ * @param focus @c EINA_TRUE, to set it as focused or @c EINA_FALSE,
+ * to take away the focus from it.
+ *
+ * Changing focus only affects where (key) input events go. There can
+ * be only one object focused at any time. If @p focus is @c EINA_TRUE,
+ * @p obj will be set as the currently focused object and it will
+ * receive all keyboard events that are not exclusive key grabs on
+ * other objects.
+ *
+ * Example:
+ * @dontinclude evas-events.c
+ * @skip evas_object_focus_set
+ * @until evas_object_focus_set
+ *
+ * See the full example @ref Example_Evas_Events "here".
+ *
+ * @see evas_object_focus_get
+ * @see evas_focus_get
+ * @see evas_object_key_grab
+ * @see evas_object_key_ungrab
+ */
+EAPI void             evas_object_focus_set(Evas_Object *obj, Eina_Bool focus) EINA_ARG_NONNULL(1);
+
+/**
+ * Retrieve whether an object has the focus.
+ *
+ * @param obj The object to retrieve focus information from.
+ * @return @c EINA_TRUE if the object has the focus, @c EINA_FALSE otherwise.
+ *
+ * If the passed object is the currently focused one, @c EINA_TRUE is
+ * returned. @c EINA_FALSE is returned, otherwise.
+ *
+ * Example:
+ * @dontinclude evas-events.c
+ * @skip And again
+ * @until something is bad
+ *
+ * See the full example @ref Example_Evas_Events "here".
+ *
+ * @see evas_object_focus_set
+ * @see evas_focus_get
+ * @see evas_object_key_grab
+ * @see evas_object_key_ungrab
+ */
+EAPI Eina_Bool        evas_object_focus_get(const Evas_Object *obj) EINA_WARN_UNUSED_RESULT EINA_ARG_NONNULL(1);
+
+/**
+ * Sets the layer of its canvas that the given object will be part of.
+ *
+ * @param   obj The given Evas object.
+ * @param   l   The number of the layer to place the object on.
+ *          Must be between #EVAS_LAYER_MIN and #EVAS_LAYER_MAX.
+ *
+ * If you don't use this function, you'll be dealing with an @b 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 @b 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 evas_object_layer_get()
+ */
+EAPI void             evas_object_layer_set(Evas_Object *obj, short l) EINA_ARG_NONNULL(1);
+
+/**
+ * Retrieves the layer of its canvas that the given object is part of.
+ *
+ * @param   obj The given Evas object to query layer from
+ * @return  Number of its layer
+ *
+ * @see evas_object_layer_set()
+ */
+EAPI short            evas_object_layer_get(const Evas_Object *obj) EINA_WARN_UNUSED_RESULT EINA_ARG_NONNULL(1);
+
+/**
+ * Sets the name of the given Evas object to the given name.
+ *
+ * @param   obj  The given object.
+ * @param   name The given name.
+ *
+ * There might be occasions where one would like to name his/her
+ * objects.
+ *
+ * Example:
+ * @dontinclude evas-events.c
+ * @skip d.bg = evas_object_rectangle_add(d.canvas);
+ * @until evas_object_name_set(d.bg, "our dear rectangle");
+ *
+ * See the full @ref Example_Evas_Events "example".
+ */
+EAPI void             evas_object_name_set(Evas_Object *obj, const char *name) EINA_ARG_NONNULL(1);
+
+/**
+ * Retrieves the name of the given Evas object.
+ *
+ * @param   obj The given object.
+ * @return  The name of the object or @c NULL, if no name has been given
+ *          to it.
+ *
+ * Example:
+ * @dontinclude evas-events.c
+ * @skip fprintf(stdout, "An object got focused: %s\n",
+ * @until evas_focus_get
+ *
+ * See the full @ref Example_Evas_Events "example".
+ */
+EAPI const char      *evas_object_name_get(const Evas_Object *obj) EINA_WARN_UNUSED_RESULT EINA_ARG_NONNULL(1);
+
+/**
+ * Increments object reference count to defer its deletion.
+ *
+ * @param obj The given Evas object to reference
+ *
+ * This increments the reference count of an object, which if greater
+ * than 0 will defer deletion by evas_object_del() until all
+ * references are released back (counter back to 0). References cannot
+ * go below 0 and unreferencing past that will result in the reference
+ * count being limited to 0. References are limited to <c>2^32 - 1</c>
+ * for an object. Referencing it more than this will result in it
+ * being limited to this value.
+ *
+ * @see evas_object_unref()
+ * @see evas_object_del()
+ *
+ * @note This is a <b>very simple</b> reference counting mechanism! For
+ * instance, Evas is not ready to check for pending references on a
+ * canvas deletion, or things like that. This is useful on scenarios
+ * where, inside a code block, callbacks exist which would possibly
+ * delete an object we are operating on afterwards. Then, one would
+ * evas_object_ref() it on the beginning of the block and
+ * evas_object_unref() it on the end. It would then be deleted at this
+ * point, if it should be.
+ *
+ * Example:
+ * @code
+ *  evas_object_ref(obj);
+ *
+ *  // action here...
+ *  evas_object_smart_callback_call(obj, SIG_SELECTED, NULL);
+ *  // more action here...
+ *  evas_object_unref(obj);
+ * @endcode
+ *
+ * @ingroup Evas_Object_Group_Basic
+ * @since 1.1
+ */
+EAPI void             evas_object_ref(Evas_Object *obj);
+
+/**
+ * Decrements object reference count.
+ *
+ * @param obj The given Evas object to unreference
+ *
+ * This decrements the reference count of an object. If the object has
+ * had evas_object_del() called on it while references were more than
+ * 0, it will be deleted at the time this function is called and puts
+ * the counter back to 0. See evas_object_ref() for more information.
+ *
+ * @see evas_object_ref() (for an example)
+ * @see evas_object_del()
+ *
+ * @ingroup Evas_Object_Group_Basic
+ * @since 1.1
+ */
+EAPI void             evas_object_unref(Evas_Object *obj);
+
+/**
+ * Get the object reference count.
+ *
+ * @param obj The given Evas object to query
+ *
+ * This gets the reference count for an object (normally 0 until it is
+ * referenced). Values of 1 or greater mean that someone is holding a
+ * reference to this object that needs to be unreffed before it can be
+ * deleted.
+ *
+ * @see evas_object_ref()
+ * @see evas_object_unref()
+ * @see evas_object_del()
+ *
+ * @ingroup Evas_Object_Group_Basic
+ * @since 1.2
+ */
+EAPI int              evas_object_ref_get(const Evas_Object *obj);
+
+/**
+ * Marks the given Evas object for deletion (when Evas will free its
+ * memory).
+ *
+ * @param obj The given Evas object.
+ *
+ * This call will mark @p obj for deletion, which will take place
+ * whenever it has no more references to it (see evas_object_ref() and
+ * evas_object_unref()).
+ *
+ * At actual deletion time, which may or may not be just after this
+ * call, ::EVAS_CALLBACK_DEL and ::EVAS_CALLBACK_FREE callbacks will
+ * be called. If the object currently had the focus, its
+ * ::EVAS_CALLBACK_FOCUS_OUT callback will also be called.
+ *
+ * @see evas_object_ref()
+ * @see evas_object_unref()
+ *
+ * @ingroup Evas_Object_Group_Basic
+ */
+EAPI void             evas_object_del(Evas_Object *obj) EINA_ARG_NONNULL(1);
+
+/**
+ * Move the given Evas object to the given location inside its
+ * canvas' viewport.
+ *
+ * @param obj The given Evas object.
+ * @param x   X position to move the object to, in canvas units.
+ * @param y   Y position to move the object to, in canvas units.
+ *
+ * Besides being moved, the object's ::EVAS_CALLBACK_MOVE callback
+ * will be called.
+ *
+ * @note Naturally, newly created objects are placed at the canvas'
+ * origin: <code>0, 0</code>.
+ *
+ * Example:
+ * @dontinclude evas-object-manipulation.c
+ * @skip evas_object_image_border_set(d.clipper_border, 3, 3, 3, 3);
+ * @until evas_object_show
+ *
+ * See the full @ref Example_Evas_Object_Manipulation "example".
+ *
+ * @ingroup Evas_Object_Group_Basic
+ */
+EAPI void             evas_object_move(Evas_Object *obj, Evas_Coord x, Evas_Coord y) EINA_ARG_NONNULL(1);
+
+/**
+ * Changes the size of the given Evas object.
+ *
+ * @param obj The given Evas object.
+ * @param w   The new width of the Evas object.
+ * @param h   The new height of the Evas object.
+ *
+ * Besides being resized, the object's ::EVAS_CALLBACK_RESIZE callback
+ * will be called.
+ *
+ * @note Newly created objects have zeroed dimensions. Then, you most
+ * probably want to use evas_object_resize() on them after they are
+ * created.
+ *
+ * @note Be aware that resizing an object changes its drawing area,
+ * but that does imply the object is rescaled! For instance, images
+ * are filled inside their drawing area using the specifications of
+ * evas_object_image_fill_set(). Thus to scale the image to match
+ * exactly your drawing area, you need to change the
+ * evas_object_image_fill_set() as well.
+ *
+ * @note This is more evident in images, but text, textblock, lines
+ * and polygons will behave similarly. Check their specific APIs to
+ * know how to achieve your desired behavior. Consider the following
+ * example:
+ *
+ * @code
+ * // rescale image to fill exactly its area without tiling:
+ * evas_object_resize(img, w, h);
+ * evas_object_image_fill_set(img, 0, 0, w, h);
+ * @endcode
+ *
+ * @ingroup Evas_Object_Group_Basic
+ */
+EAPI void             evas_object_resize(Evas_Object *obj, Evas_Coord w, Evas_Coord h) EINA_ARG_NONNULL(1);
+
+/**
+ * Retrieves the position and (rectangular) size of the given Evas
+ * object.
+ *
+ * @param obj The given Evas object.
+ * @param x Pointer to an integer in which to store the X coordinate
+ *          of the object.
+ * @param y Pointer to an integer in which to store the Y coordinate
+ *          of the object.
+ * @param w Pointer to an integer in which to store the width of the
+ *          object.
+ * @param h Pointer to an integer in which to store the height of the
+ *          object.
+ *
+ * The position, naturally, will be relative to the top left corner of
+ * the canvas' viewport.
+ *
+ * @note Use @c NULL pointers on the geometry components you're not
+ * interested in: they'll be ignored by the function.
+ *
+ * Example:
+ * @dontinclude evas-events.c
+ * @skip int w, h, cw, ch;
+ * @until return
+ *
+ * See the full @ref Example_Evas_Events "example".
+ *
+ * @ingroup Evas_Object_Group_Basic
+ */
+EAPI void             evas_object_geometry_get(const Evas_Object *obj, Evas_Coord *x, Evas_Coord *y, Evas_Coord *w, Evas_Coord *h) EINA_ARG_NONNULL(1);
+
+/**
+ * Makes the given Evas object visible.
+ *
+ * @param obj The given Evas object.
+ *
+ * Besides becoming visible, the object's ::EVAS_CALLBACK_SHOW
+ * callback will be called.
+ *
+ * @see evas_object_hide() for more on object visibility.
+ * @see evas_object_visible_get()
+ *
+ * @ingroup Evas_Object_Group_Basic
+ */
+EAPI void             evas_object_show(Evas_Object *obj) EINA_ARG_NONNULL(1);
+
+/**
+ * Makes the given Evas object invisible.
+ *
+ * @param obj The given Evas object.
+ *
+ * Hidden objects, besides not being shown at all in your canvas,
+ * won't be checked for changes on the canvas rendering
+ * process. Furthermore, they will not catch input events. Thus, they
+ * are much ligher (in processing needs) than an object that is
+ * invisible due to indirect causes, such as being clipped or out of
+ * the canvas' viewport.
+ *
+ * Besides becoming hidden, @p obj object's ::EVAS_CALLBACK_SHOW
+ * callback will be called.
+ *
+ * @note All objects are created in the hidden state! If you want them
+ * shown, use evas_object_show() after their creation.
+ *
+ * @see evas_object_show()
+ * @see evas_object_visible_get()
+ *
+ * Example:
+ * @dontinclude evas-object-manipulation.c
+ * @skip if (evas_object_visible_get(d.clipper))
+ * @until return
+ *
+ * See the full @ref Example_Evas_Object_Manipulation "example".
+ *
+ * @ingroup Evas_Object_Group_Basic
+ */
+EAPI void             evas_object_hide(Evas_Object *obj) EINA_ARG_NONNULL(1);
+
+/**
+ * Retrieves whether or not the given Evas object is visible.
+ *
+ * @param   obj The given Evas object.
+ * @return @c EINA_TRUE if the object is visible, @c EINA_FALSE
+ * otherwise.
+ *
+ * This retrieves an object's visibility as the one enforced by
+ * evas_object_show() and evas_object_hide().
+ *
+ * @note The value returned isn't, by any means, influenced by
+ * clippers covering @p obj, it being out of its canvas' viewport or
+ * stacked below other object.
+ *
+ * @see evas_object_show()
+ * @see evas_object_hide() (for an example)
+ *
+ * @ingroup Evas_Object_Group_Basic
+ */
+EAPI Eina_Bool        evas_object_visible_get(const Evas_Object *obj) EINA_WARN_UNUSED_RESULT EINA_ARG_NONNULL(1);
+
+/**
+ * Sets the general/main color of the given Evas object to the given
+ * one.
+ *
+ * @param obj The given Evas object.
+ * @param r   The red component of the given color.
+ * @param g   The green component of the given color.
+ * @param b   The blue component of the given color.
+ * @param a   The alpha component of the given color.
+ *
+ * @see evas_object_color_get() (for an example)
+ * @note These color values are expected to be premultiplied by @p a.
+ *
+ * @ingroup Evas_Object_Group_Basic
+ */
+EAPI void             evas_object_color_set(Evas_Object *obj, int r, int g, int b, int a) EINA_ARG_NONNULL(1);
+
+/**
+ * Retrieves the general/main color of the given Evas object.
+ *
+ * @param obj The given Evas object to retrieve color from.
+ * @param r Pointer to an integer in which to store the red component
+ *          of the color.
+ * @param g Pointer to an integer in which to store the green
+ *          component of the color.
+ * @param b Pointer to an integer in which to store the blue component
+ *          of the color.
+ * @param a Pointer to an integer in which to store the alpha
+ *          component of the color.
+ *
+ * Retrieves the “main” color's RGB component (and alpha channel)
+ * values, <b>which range from 0 to 255</b>. For the alpha channel,
+ * which defines the object's transparency level, 0 means totally
+ * transparent, while 255 means opaque. These color values are
+ * premultiplied by the alpha value.
+ *
+ * Usually you’ll use this attribute for text and rectangle objects,
+ * where the “main” color is their unique one. If set for objects
+ * which themselves have colors, like the images one, those colors get
+ * modulated by this one.
+ *
+ * @note All newly created Evas rectangles get the default color
+ * values of <code>255 255 255 255</code> (opaque white).
+ *
+ * @note Use @c NULL pointers on the components you're not interested
+ * in: they'll be ignored by the function.
+ *
+ * Example:
+ * @dontinclude evas-object-manipulation.c
+ * @skip int alpha, r, g, b;
+ * @until return
+ *
+ * See the full @ref Example_Evas_Object_Manipulation "example".
+ *
+ * @ingroup Evas_Object_Group_Basic
+ */
+EAPI void             evas_object_color_get(const Evas_Object *obj, int *r, int *g, int *b, int *a) EINA_ARG_NONNULL(1);
+
+/**
+ * Retrieves the Evas canvas that the given object lives on.
+ *
+ * @param   obj The given Evas object.
+ * @return  A pointer to the canvas where the object is on.
+ *
+ * This function is most useful at code contexts where you need to
+ * operate on the canvas but have only the object pointer.
+ *
+ * @ingroup Evas_Object_Group_Basic
+ */
+EAPI Evas            *evas_object_evas_get(const Evas_Object *obj) EINA_WARN_UNUSED_RESULT EINA_ARG_NONNULL(1);
+
+/**
+ * Retrieves the type of the given Evas object.
+ *
+ * @param obj The given object.
+ * @return The type of the object.
+ *
+ * For Evas' builtin types, the return strings will be one of:
+ *   - <c>"rectangle"</c>,
+ *   - <c>"line"</c>,
+ *   - <c>"polygon"</c>,
+ *   - <c>"text"</c>,
+ *   - <c>"textblock"</c> and
+ *   - <c>"image"</c>.
+ *
+ * For Evas smart objects (see @ref Evas_Smart_Group), the name of the
+ * smart class itself is returned on this call. For the built-in smart
+ * objects, these names are:
+ *   - <c>"EvasObjectSmartClipped"</c>, for the clipped smart object
+ *   - <c>"Evas_Object_Box"</c>, for the box object and
+ *   - <c>"Evas_Object_Table"</c>, for the table object.
+ *
+ * Example:
+ * @dontinclude evas-object-manipulation.c
+ * @skip d.img = evas_object_image_filled_add(d.canvas);
+ * @until border on the
+ *
+ * See the full @ref Example_Evas_Object_Manipulation "example".
+ */
+EAPI const char      *evas_object_type_get(const Evas_Object *obj) EINA_WARN_UNUSED_RESULT EINA_ARG_NONNULL(1);
+
+/**
+ * Raise @p obj to the top of its layer.
+ *
+ * @param obj the object to raise
+ *
+ * @p obj will, then, be the highest one in the layer it belongs
+ * to. Object on other layers won't get touched.
+ *
+ * @see evas_object_stack_above()
+ * @see evas_object_stack_below()
+ * @see evas_object_lower()
+ */
+EAPI void             evas_object_raise(Evas_Object *obj) EINA_ARG_NONNULL(1);
+
+/**
+ * Lower @p obj to the bottom of its layer.
+ *
+ * @param obj the object to lower
+ *
+ * @p obj will, then, be the lowest one in the layer it belongs
+ * to. Objects on other layers won't get touched.
+ *
+ * @see evas_object_stack_above()
+ * @see evas_object_stack_below()
+ * @see evas_object_raise()
+ */
+EAPI void             evas_object_lower(Evas_Object *obj) EINA_ARG_NONNULL(1);
+
+/**
+ * Stack @p obj immediately above @p above
+ *
+ * @param obj the object to stack
+ * @param above the object above which to stack
+ *
+ * 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 <b>objects belonging to
+ * the same layer</b> in a given canvas, otherwise it will fail (and
+ * accomplish nothing).
+ *
+ * If you have smart objects on your canvas and @p obj is a member of
+ * one of them, then @p above must also be a member of the same
+ * smart object.
+ *
+ * Similarly, if @p obj is not a member of a smart object, @p above
+ * must not be either.
+ *
+ * @see evas_object_layer_get()
+ * @see evas_object_layer_set()
+ * @see evas_object_stack_below()
+ */
+EAPI void             evas_object_stack_above(Evas_Object *obj, Evas_Object *above) EINA_ARG_NONNULL(1, 2);
+
+/**
+ * Stack @p obj immediately below @p below
+ *
+ * @param obj the object to stack
+ * @param below the object below which to stack
+ *
+ * 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 <b>objects belonging to
+ * the same layer</b> in a given canvas, otherwise it will fail (and
+ * accomplish nothing).
+ *
+ * If you have smart objects on your canvas and @p obj is a member of
+ * one of them, then @p below must also be a member of the same
+ * smart object.
+ *
+ * Similarly, if @p obj is not a member of a smart object, @p below
+ * must not be either.
+ *
+ * @see evas_object_layer_get()
+ * @see evas_object_layer_set()
+ * @see evas_object_stack_below()
+ */
+EAPI void             evas_object_stack_below(Evas_Object *obj, Evas_Object *below) EINA_ARG_NONNULL(1, 2);
+
+/**
+ * Get the Evas object stacked right above @p obj
+ *
+ * @param obj an #Evas_Object
+ * @return the #Evas_Object directly above @p obj, if any, or @c NULL,
+ * if none
+ *
+ * This function will traverse layers in its search, if there are
+ * objects on layers above the one @p obj is placed at.
+ *
+ * @see evas_object_layer_get()
+ * @see evas_object_layer_set()
+ * @see evas_object_below_get()
+ *
+ */
+EAPI Evas_Object     *evas_object_above_get(const Evas_Object *obj) EINA_WARN_UNUSED_RESULT EINA_ARG_NONNULL(1);
+
+/**
+ * Get the Evas object stacked right below @p obj
+ *
+ * @param obj an #Evas_Object
+ * @return the #Evas_Object directly below @p obj, if any, or @c NULL,
+ * if none
+ *
+ * This function will traverse layers in its search, if there are
+ * objects on layers below the one @p obj is placed at.
+ *
+ * @see evas_object_layer_get()
+ * @see evas_object_layer_set()
+ * @see evas_object_below_get()
+ */
+EAPI Evas_Object     *evas_object_below_get(const Evas_Object *obj) EINA_WARN_UNUSED_RESULT EINA_ARG_NONNULL(1);
+/**
+ * @}
+ */
+
+/**
+ * @ingroup Evas_Object_Group_Events
+ *
+ * @{
+ */
+
+/**
+ * Add (register) a callback function to a given Evas object event.
+ *
+ * @param obj Object to attach a callback to
+ * @param type The type of event that will trigger the callback
+ * @param func The function to be called when the event is triggered
+ * @param data The data pointer to be passed to @p func
+ *
+ * This function adds a function callback to an object when the event
+ * of type @p type occurs on object @p obj. The function is @p 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 callback function must have the ::Evas_Object_Event_Cb prototype
+ * definition. The first parameter (@p data) in this definition will
+ * have the same value passed to evas_object_event_callback_add() as
+ * the @p data parameter, at runtime. The second parameter @p e is the
+ * canvas pointer on which the event occurred. The third parameter is
+ * a pointer to the object on which event occurred. Finally, the
+ * fourth parameter @p event_info is a pointer to a data structure
+ * that may or may not be passed to the callback, depending on the
+ * event type that triggered the callback. This is so because some
+ * events don't carry extra context with them, but others do.
+ *
+ * The event type @p type to trigger the function may be one of
+ * #EVAS_CALLBACK_MOUSE_IN, #EVAS_CALLBACK_MOUSE_OUT,
+ * #EVAS_CALLBACK_MOUSE_DOWN, #EVAS_CALLBACK_MOUSE_UP,
+ * #EVAS_CALLBACK_MOUSE_MOVE, #EVAS_CALLBACK_MOUSE_WHEEL,
+ * #EVAS_CALLBACK_MULTI_DOWN, #EVAS_CALLBACK_MULTI_UP,
+ * #EVAS_CALLBACK_MULTI_MOVE, #EVAS_CALLBACK_FREE,
+ * #EVAS_CALLBACK_KEY_DOWN, #EVAS_CALLBACK_KEY_UP,
+ * #EVAS_CALLBACK_FOCUS_IN, #EVAS_CALLBACK_FOCUS_OUT,
+ * #EVAS_CALLBACK_SHOW, #EVAS_CALLBACK_HIDE, #EVAS_CALLBACK_MOVE,
+ * #EVAS_CALLBACK_RESIZE, #EVAS_CALLBACK_RESTACK, #EVAS_CALLBACK_DEL,
+ * #EVAS_CALLBACK_HOLD, #EVAS_CALLBACK_CHANGED_SIZE_HINTS,
+ * #EVAS_CALLBACK_IMAGE_PRELOADED or #EVAS_CALLBACK_IMAGE_UNLOADED.
+ *
+ * This determines the kind of event that will trigger the callback.
+ * What follows is a list explaining better the nature of each type of
+ * event, along with their associated @p event_info pointers:
+ *
+ * - #EVAS_CALLBACK_MOUSE_IN: @p event_info is a pointer to an
+ *   #Evas_Event_Mouse_In struct\n\n
+ *   This event is triggered when the mouse pointer enters the area
+ *   (not shaded by other objects) of the object @p obj. This may
+ *   occur by the mouse pointer being moved by
+ *   evas_event_feed_mouse_move() calls, or by the object being shown,
+ *   raised, moved, resized, or other objects being moved out of the
+ *   way, hidden or lowered, whatever may cause the mouse pointer to
+ *   get on top of @p obj, having been on top of another object
+ *   previously.
+ *
+ * - #EVAS_CALLBACK_MOUSE_OUT: @p event_info is a pointer to an
+ *   #Evas_Event_Mouse_Out struct\n\n
+ *   This event is triggered exactly like #EVAS_CALLBACK_MOUSE_IN is,
+ *   but it occurs when the mouse pointer exits an object's area. Note
+ *   that no mouse out events will be reported if the mouse pointer is
+ *   implicitly grabbed to an object (mouse buttons are down, having
+ *   been pressed while the pointer was over that object). In these
+ *   cases, mouse out events will be reported once all buttons are
+ *   released, if the mouse pointer has left the object's area. The
+ *   indirect ways of taking off the mouse pointer from an object,
+ *   like cited above, for #EVAS_CALLBACK_MOUSE_IN, also apply here,
+ *   naturally.
+ *
+ * - #EVAS_CALLBACK_MOUSE_DOWN: @p event_info is a pointer to an
+ *   #Evas_Event_Mouse_Down struct\n\n
+ *   This event is triggered by a mouse button being pressed while the
+ *   mouse pointer is over an object. If the pointer mode for Evas is
+ *   #EVAS_OBJECT_POINTER_MODE_AUTOGRAB (default), this causes this
+ *   object to <b>passively grab the mouse</b> until all mouse buttons
+ *   have been released: all future mouse events will be reported to
+ *   only this object until no buttons are down. That includes mouse
+ *   move events, mouse in and mouse out events, and further button
+ *   presses. When all buttons are released, event propagation will
+ *   occur as normal (see #Evas_Object_Pointer_Mode).
+ *
+ * - #EVAS_CALLBACK_MOUSE_UP: @p event_info is a pointer to an
+ *   #Evas_Event_Mouse_Up struct\n\n
+ *   This event is triggered by a mouse button being released while
+ *   the mouse pointer is over an object's area (or when passively
+ *   grabbed to an object).
+ *
+ * - #EVAS_CALLBACK_MOUSE_MOVE: @p event_info is a pointer to an
+ *   #Evas_Event_Mouse_Move struct\n\n
+ *   This event is triggered by the mouse pointer being moved while
+ *   over an object's area (or while passively grabbed to an object).
+ *
+ * - #EVAS_CALLBACK_MOUSE_WHEEL: @p event_info is a pointer to an
+ *   #Evas_Event_Mouse_Wheel struct\n\n
+ *   This event is triggered by the mouse wheel being rolled while the
+ *   mouse pointer is over an object (or passively grabbed to an
+ *   object).
+ *
+ * - #EVAS_CALLBACK_MULTI_DOWN: @p event_info is a pointer to an
+ *   #Evas_Event_Multi_Down struct
+ *
+ * - #EVAS_CALLBACK_MULTI_UP: @p event_info is a pointer to an
+ *   #Evas_Event_Multi_Up struct
+ *
+ * - #EVAS_CALLBACK_MULTI_MOVE: @p event_info is a pointer to an
+ *   #Evas_Event_Multi_Move struct
+ *
+ * - #EVAS_CALLBACK_FREE: @p event_info is @c NULL \n\n
+ *   This event is triggered just before Evas is about to free all
+ *   memory used by an object and remove all references to it. This is
+ *   useful for programs to use if they attached data to an object and
+ *   want to free it when the object is deleted. The object is still
+ *   valid when this callback is called, but after it returns, there
+ *   is no guarantee on the object's validity.
+ *
+ * - #EVAS_CALLBACK_KEY_DOWN: @p event_info is a pointer to an
+ *   #Evas_Event_Key_Down struct\n\n
+ *   This callback is called when a key is pressed and the focus is on
+ *   the object, or a key has been grabbed to a particular object
+ *   which wants to intercept the key press regardless of what object
+ *   has the focus.
+ *
+ * - #EVAS_CALLBACK_KEY_UP: @p event_info is a pointer to an
+ *   #Evas_Event_Key_Up struct \n\n
+ *   This callback is called when a key is released and the focus is
+ *   on the object, or a key has been grabbed to a particular object
+ *   which wants to intercept the key release regardless of what
+ *   object has the focus.
+ *
+ * - #EVAS_CALLBACK_FOCUS_IN: @p event_info is @c NULL \n\n
+ *   This event is called when an object gains the focus. When it is
+ *   called the object has already gained the focus.
+ *
+ * - #EVAS_CALLBACK_FOCUS_OUT: @p event_info is @c NULL \n\n
+ *   This event is triggered when an object loses the focus. When it
+ *   is called the object has already lost the focus.
+ *
+ * - #EVAS_CALLBACK_SHOW: @p event_info is @c NULL \n\n
+ *   This event is triggered by the object being shown by
+ *   evas_object_show().
+ *
+ * - #EVAS_CALLBACK_HIDE: @p event_info is @c NULL \n\n
+ *   This event is triggered by an object being hidden by
+ *   evas_object_hide().
+ *
+ * - #EVAS_CALLBACK_MOVE: @p event_info is @c NULL \n\n
+ *   This event is triggered by an object being
+ *   moved. evas_object_move() can trigger this, as can any
+ *   object-specific manipulations that would mean the object's origin
+ *   could move.
+ *
+ * - #EVAS_CALLBACK_RESIZE: @p event_info is @c NULL \n\n
+ *   This event is triggered by an object being resized. Resizes can
+ *   be triggered by evas_object_resize() or by any object-specific
+ *   calls that may cause the object to resize.
+ *
+ * - #EVAS_CALLBACK_RESTACK: @p event_info is @c NULL \n\n
+ *   This event is triggered by an object being re-stacked. Stacking
+ *   changes can be triggered by
+ *   evas_object_stack_below()/evas_object_stack_above() and others.
+ *
+ * - #EVAS_CALLBACK_DEL: @p event_info is @c NULL.
+ *
+ * - #EVAS_CALLBACK_HOLD: @p event_info is a pointer to an
+ *   #Evas_Event_Hold struct
+ *
+ * - #EVAS_CALLBACK_CHANGED_SIZE_HINTS: @p event_info is @c NULL.
+ *
+ * - #EVAS_CALLBACK_IMAGE_PRELOADED: @p event_info is @c NULL.
+ *
+ * - #EVAS_CALLBACK_IMAGE_UNLOADED: @p event_info is @c NULL.
+ *
+ * @note Be careful not to add the same callback multiple times, if
+ * that's not what you want, because Evas won't check if a callback
+ * existed before exactly as the one being registered (and thus, call
+ * it more than once on the event, in this case). This would make
+ * sense if you passed different functions and/or callback data, only.
+ *
+ * Example:
+ * @dontinclude evas-events.c
+ * @skip evas_object_event_callback_add(
+ * @until }
+ *
+ * See the full example @ref Example_Evas_Events "here".
+ *
+ */
+EAPI void      evas_object_event_callback_add(Evas_Object *obj, Evas_Callback_Type type, Evas_Object_Event_Cb func, const void *data) EINA_ARG_NONNULL(1, 3);
+
+/**
+ * Add (register) a callback function to a given Evas object event with a
+ * non-default priority set. Except for the priority field, it's exactly the
+ * same as @ref evas_object_event_callback_add
+ *
+ * @param obj Object to attach a callback to
+ * @param type The type of event that will trigger the callback
+ * @param priority The priority of the callback, lower values called first.
+ * @param func The function to be called when the event is triggered
+ * @param data The data pointer to be passed to @p func
+ *
+ * @see evas_object_event_callback_add
+ * @since 1.1
+ */
+EAPI void      evas_object_event_callback_priority_add(Evas_Object *obj, Evas_Callback_Type type, Evas_Callback_Priority priority, Evas_Object_Event_Cb func, const void *data) EINA_ARG_NONNULL(1, 4);
+
+/**
+ * Delete a callback function from an object
+ *
+ * @param obj Object to remove a callback from
+ * @param type The type of event that was triggering the callback
+ * @param func The function that was to be called when the event was triggered
+ * @return The data pointer that was to be passed to the callback
+ *
+ * This function removes the most recently added callback from the
+ * object @p obj which was triggered by the event type @p type and was
+ * calling the function @p func when triggered. If the removal is
+ * successful it will also return the data pointer that was passed to
+ * evas_object_event_callback_add() when the callback was added to the
+ * object. If not successful @c NULL will be returned.
+ *
+ * Example:
+ * @code
+ * extern Evas_Object *object;
+ * void *my_data;
+ * void up_callback(void *data, Evas *e, Evas_Object *obj, void *event_info);
+ *
+ * my_data = evas_object_event_callback_del(object, EVAS_CALLBACK_MOUSE_UP, up_callback);
+ * @endcode
+ */
+EAPI void     *evas_object_event_callback_del(Evas_Object *obj, Evas_Callback_Type type, Evas_Object_Event_Cb func) EINA_ARG_NONNULL(1, 3);
+
+/**
+ * Delete (unregister) a callback function registered to a given
+ * Evas object event.
+ *
+ * @param obj Object to remove a callback from
+ * @param type The type of event that was triggering the callback
+ * @param func The function that was to be called when the event was
+ * triggered
+ * @param data The data pointer that was to be passed to the callback
+ * @return The data pointer that was to be passed to the callback
+ *
+ * This function removes the most recently added callback from the
+ * object @p obj, which was triggered by the event type @p type and was
+ * calling the function @p func with data @p data, when triggered. If
+ * the removal is successful it will also return the data pointer that
+ * was passed to evas_object_event_callback_add() (that will be the
+ * same as the parameter) when the callback was added to the
+ * object. In errors, @c NULL will be returned.
+ *
+ * @note For deletion of Evas object events callbacks filtering by
+ * just type and function pointer, user
+ * evas_object_event_callback_del().
+ *
+ * Example:
+ * @code
+ * extern Evas_Object *object;
+ * void *my_data;
+ * void up_callback(void *data, Evas *e, Evas_Object *obj, void *event_info);
+ *
+ * my_data = evas_object_event_callback_del_full(object, EVAS_CALLBACK_MOUSE_UP, up_callback, data);
+ * @endcode
+ */
+EAPI void     *evas_object_event_callback_del_full(Evas_Object *obj, Evas_Callback_Type type, Evas_Object_Event_Cb func, const void *data) EINA_ARG_NONNULL(1, 3);
+
+/**
+ * Set whether an Evas object is to pass (ignore) events.
+ *
+ * @param obj the Evas object to operate on
+ * @param pass whether @p obj is to pass events (@c EINA_TRUE) or not
+ * (@c EINA_FALSE)
+ *
+ * If @p pass is @c EINA_TRUE, it will make events on @p obj to be @b
+ * ignored. They will be triggered on the @b next lower object (that
+ * is not set to pass events), instead (see evas_object_below_get()).
+ *
+ * If @p pass is @c EINA_FALSE, events will be processed on that
+ * object as normal.
+ *
+ * @see evas_object_pass_events_get() for an example
+ * @see evas_object_repeat_events_set()
+ * @see evas_object_propagate_events_set()
+ * @see evas_object_freeze_events_set()
+ */
+EAPI void      evas_object_pass_events_set(Evas_Object *obj, Eina_Bool pass) EINA_ARG_NONNULL(1);
+
+/**
+ * Determine whether an object is set to pass (ignore) events.
+ *
+ * @param obj the Evas object to get information from.
+ * @return pass whether @p obj is set to pass events (@c EINA_TRUE) or not
+ * (@c EINA_FALSE)
+ *
+ * Example:
+ * @dontinclude evas-stacking.c
+ * @skip if (strcmp(ev->keyname, "p") == 0)
+ * @until }
+ *
+ * See the full @ref Example_Evas_Stacking "example".
+ *
+ * @see evas_object_pass_events_set()
+ * @see evas_object_repeat_events_get()
+ * @see evas_object_propagate_events_get()
+ * @see evas_object_freeze_events_get()
+ */
+EAPI Eina_Bool evas_object_pass_events_get(const Evas_Object *obj) EINA_WARN_UNUSED_RESULT EINA_ARG_NONNULL(1);
+
+/**
+ * Set whether an Evas object is to repeat events.
+ *
+ * @param obj the Evas object to operate on
+ * @param repeat whether @p obj is to repeat events (@c EINA_TRUE) or not
+ * (@c EINA_FALSE)
+ *
+ * If @p repeat is @c EINA_TRUE, it will make events on @p obj to also
+ * be repeated for the @b next lower object in the objects' stack (see
+ * see evas_object_below_get()).
+ *
+ * If @p repeat is @c EINA_FALSE, events occurring on @p obj will be
+ * processed only on it.
+ *
+ * Example:
+ * @dontinclude evas-stacking.c
+ * @skip if (strcmp(ev->keyname, "r") == 0)
+ * @until }
+ *
+ * See the full @ref Example_Evas_Stacking "example".
+ *
+ * @see evas_object_repeat_events_get()
+ * @see evas_object_pass_events_set()
+ * @see evas_object_propagate_events_set()
+ * @see evas_object_freeze_events_set()
+ */
+EAPI void      evas_object_repeat_events_set(Evas_Object *obj, Eina_Bool repeat) EINA_ARG_NONNULL(1);
+
+/**
+ * Determine whether an object is set to repeat events.
+ *
+ * @param obj the given Evas object pointer
+ * @return whether @p obj is set to repeat events (@c EINA_TRUE)
+ * or not (@c EINA_FALSE)
+ *
+ * @see evas_object_repeat_events_set() for an example
+ * @see evas_object_pass_events_get()
+ * @see evas_object_propagate_events_get()
+ * @see evas_object_freeze_events_get()
+ */
+EAPI Eina_Bool evas_object_repeat_events_get(const Evas_Object *obj) EINA_WARN_UNUSED_RESULT EINA_ARG_NONNULL(1);
+
+/**
+ * Set whether events on a smart object's member should get propagated
+ * up to its parent.
+ *
+ * @param obj the smart object's child to operate on
+ * @param prop whether to propagate events (@c EINA_TRUE) or not
+ * (@c EINA_FALSE)
+ *
+ * This function has @b no effect if @p obj is not a member of a smart
+ * object.
+ *
+ * If @p prop is @c EINA_TRUE, events occurring on this object will be
+ * propagated on to the smart object of which @p obj is a member.  If
+ * @p prop is @c EINA_FALSE, events occurring on this object will @b
+ * not be propagated on to the smart object of which @p obj is a
+ * member.  The default value is @c EINA_TRUE.
+ *
+ * @see evas_object_propagate_events_get()
+ * @see evas_object_repeat_events_set()
+ * @see evas_object_pass_events_set()
+ * @see evas_object_freeze_events_set()
+ */
+EAPI void      evas_object_propagate_events_set(Evas_Object *obj, Eina_Bool prop) EINA_ARG_NONNULL(1);
+
+/**
+ * Retrieve whether an Evas object is set to propagate events.
+ *
+ * @param obj the given Evas object pointer
+ * @return whether @p obj is set to propagate events (@c EINA_TRUE)
+ * or not (@c EINA_FALSE)
+ *
+ * @see evas_object_propagate_events_set()
+ * @see evas_object_repeat_events_get()
+ * @see evas_object_pass_events_get()
+ * @see evas_object_freeze_events_get()
+ */
+EAPI Eina_Bool evas_object_propagate_events_get(const Evas_Object *obj) EINA_WARN_UNUSED_RESULT EINA_ARG_NONNULL(1);
+
+/**
+ * Set whether an Evas object is to freeze (discard) events.
+ *
+ * @param obj the Evas object to operate on
+ * @param freeze pass whether @p obj is to freeze events (@c EINA_TRUE) or not
+ * (@c EINA_FALSE)
+ *
+ * If @p freeze is @c EINA_TRUE, it will make events on @p obj to be @b
+ * discarded. Unlike evas_object_pass_events_set(), events will not be
+ * passed to @b next lower object. This API can be used for blocking
+ * events while @p obj is on transiting.
+ *
+ * If @p freeze is @c EINA_FALSE, events will be processed on that
+ * object as normal.
+ *
+ * @see evas_object_freeze_events_get()
+ * @see evas_object_pass_events_set()
+ * @see evas_object_repeat_events_set()
+ * @see evas_object_propagate_events_set()
+ * @since 1.1
+ */
+EAPI void      evas_object_freeze_events_set(Evas_Object *obj, Eina_Bool freeze) EINA_ARG_NONNULL(1);
+
+/**
+ * Determine whether an object is set to freeze (discard) events.
+ *
+ * @param obj the Evas object to get information from.
+ * @return freeze whether @p obj is set to freeze events (@c EINA_TRUE) or
+ * not (@c EINA_FALSE)
+ *
+ * @see evas_object_freeze_events_set()
+ * @see evas_object_pass_events_get()
+ * @see evas_object_repeat_events_get()
+ * @see evas_object_propagate_events_get()
+ * @since 1.1
+ */
+EAPI Eina_Bool evas_object_freeze_events_get(const Evas_Object *obj) EINA_WARN_UNUSED_RESULT EINA_ARG_NONNULL(1);
+/**
+ * @}
+ */
+
+/**
+ * @ingroup Evas_Object_Group_Map
+ *
+ * @{
+ */
+
+/**
+ * Enable or disable the map that is set.
+ *
+ * Enable or disable the use of map for the object @p obj.
+ * On enable, the object geometry will be saved, and the new geometry will
+ * change (position and size) to reflect the map geometry set.
+ *
+ * If the object doesn't have a map set (with evas_object_map_set()), the
+ * initial geometry will be undefined. It is advised to always set a map
+ * to the object first, and then call this function to enable its use.
+ *
+ * @param obj object to enable the map on
+ * @param enabled enabled state
+ */
+EAPI void            evas_object_map_enable_set(Evas_Object *obj, Eina_Bool enabled);
+
+/**
+ * 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().
+ *
+ * @param obj object to get the map enabled state from
+ * @return the map enabled state
+ */
+EAPI Eina_Bool       evas_object_map_enable_get(const Evas_Object *obj);
+
+/**
+ * Set current object transformation map.
+ *
+ * This sets the map on a given object. It is copied from the @p map pointer,
+ * so there is no need to keep the @p map object if you don't need it anymore.
+ *
+ * A map is a set of 4 points which have canvas x, y coordinates per point,
+ * with an optional z point value as a hint for perspective correction, if it
+ * is available. As well each point has u and v coordinates. These are like
+ * "texture coordinates" in OpenGL in that they define a point in the source
+ * image that is mapped to that map vertex/point. The u corresponds to the x
+ * coordinate of this mapped point and v, the y coordinate. Note that these
+ * coordinates describe a bounding region to sample. If you have a 200x100
+ * source image and want to display it at 200x100 with proper pixel
+ * precision, then do:
+ *
+ * @code
+ * Evas_Map *m = evas_map_new(4);
+ * evas_map_point_coord_set(m, 0,   0,   0, 0);
+ * evas_map_point_coord_set(m, 1, 200,   0, 0);
+ * evas_map_point_coord_set(m, 2, 200, 100, 0);
+ * evas_map_point_coord_set(m, 3,   0, 100, 0);
+ * evas_map_point_image_uv_set(m, 0,   0,   0);
+ * evas_map_point_image_uv_set(m, 1, 200,   0);
+ * evas_map_point_image_uv_set(m, 2, 200, 100);
+ * evas_map_point_image_uv_set(m, 3,   0, 100);
+ * evas_object_map_set(obj, m);
+ * evas_map_free(m);
+ * @endcode
+ *
+ * Note that the map points a uv coordinates match the image geometry. If
+ * the @p map parameter is NULL, the stored map will be freed and geometry
+ * prior to enabling/setting a map will be restored.
+ *
+ * @param obj object to change transformation map
+ * @param map new map to use
+ *
+ * @see evas_map_new()
+ */
+EAPI void            evas_object_map_set(Evas_Object *obj, const Evas_Map *map);
+
+/**
+ * Get current object transformation map.
+ *
+ * This returns the current internal map set on the indicated object. It is
+ * intended for read-only access and is only valid as long as the object is
+ * not deleted or the map on the object is not changed. If you wish to modify
+ * the map and set it back do the following:
+ *
+ * @code
+ * const Evas_Map *m = evas_object_map_get(obj);
+ * Evas_Map *m2 = evas_map_dup(m);
+ * evas_map_util_rotate(m2, 30.0, 0, 0);
+ * evas_object_map_set(obj, m2);
+ * evas_map_free(m2);
+ * @endcode
+ *
+ * @param obj object to query transformation map.
+ * @return map reference to map in use. This is an internal data structure, so
+ * do not modify it.
+ *
+ * @see evas_object_map_set()
+ */
+EAPI const Evas_Map *evas_object_map_get(const Evas_Object *obj);
+/**
+ * @}
+ */
+
+/**
+ * @ingroup Evas_Object_Group_Size_Hints
+ *
+ * @{
+ */
+
+/**
+ * Retrieves the hints for an object's minimum size.
+ *
+ * @param obj The given Evas object to query hints from.
+ * @param w Pointer to an integer in which to store the minimum width.
+ * @param h Pointer to an integer in which to store the minimum height.
+ *
+ * These are hints on the minimim sizes @p obj should have. This is
+ * not a size enforcement in any way, it's just a hint that should be
+ * used whenever appropriate.
+ *
+ * @note Use @c NULL pointers on the hint components you're not
+ * interested in: they'll be ignored by the function.
+ *
+ * @see evas_object_size_hint_min_set() for an example
+ */
+EAPI void evas_object_size_hint_min_get(const Evas_Object *obj, Evas_Coord *w, Evas_Coord *h) EINA_ARG_NONNULL(1);
+
+/**
+ * Sets the hints for an object's minimum size.
+ *
+ * @param obj The given Evas object to query hints from.
+ * @param w Integer to use as the minimum width hint.
+ * @param h Integer to use as the minimum height hint.
+ *
+ * This is not a size enforcement in any way, it's just a hint that
+ * should be used whenever appropriate.
+ *
+ * Values @c 0 will be treated as unset hint components, when queried
+ * by managers.
+ *
+ * Example:
+ * @dontinclude evas-hints.c
+ * @skip evas_object_size_hint_min_set
+ * @until return
+ *
+ * In this example the minimum size hints change the behavior of an
+ * Evas box when layouting its children. See the full @ref
+ * Example_Evas_Size_Hints "example".
+ *
+ * @see evas_object_size_hint_min_get()
+ */
+EAPI void evas_object_size_hint_min_set(Evas_Object *obj, Evas_Coord w, Evas_Coord h) EINA_ARG_NONNULL(1);
+
+/**
+ * Retrieves the hints for an object's maximum size.
+ *
+ * @param obj The given Evas object to query hints from.
+ * @param w Pointer to an integer in which to store the maximum width.
+ * @param h Pointer to an integer in which to store the maximum height.
+ *
+ * These are hints on the maximum sizes @p obj should have. This is
+ * not a size enforcement in any way, it's just a hint that should be
+ * used whenever appropriate.
+ *
+ * @note Use @c NULL pointers on the hint components you're not
+ * interested in: they'll be ignored by the function.
+ *
+ * @see evas_object_size_hint_max_set()
+ */
+EAPI void evas_object_size_hint_max_get(const Evas_Object *obj, Evas_Coord *w, Evas_Coord *h) EINA_ARG_NONNULL(1);
+
+/**
+ * Sets the hints for an object's maximum size.
+ *
+ * @param obj The given Evas object to query hints from.
+ * @param w Integer to use as the maximum width hint.
+ * @param h Integer to use as the maximum height hint.
+ *
+ * This is not a size enforcement in any way, it's just a hint that
+ * should be used whenever appropriate.
+ *
+ * Values @c -1 will be treated as unset hint components, when queried
+ * by managers.
+ *
+ * Example:
+ * @dontinclude evas-hints.c
+ * @skip evas_object_size_hint_max_set
+ * @until return
+ *
+ * In this example the maximum size hints change the behavior of an
+ * Evas box when layouting its children. See the full @ref
+ * Example_Evas_Size_Hints "example".
+ *
+ * @see evas_object_size_hint_max_get()
+ */
+EAPI void evas_object_size_hint_max_set(Evas_Object *obj, Evas_Coord w, Evas_Coord h) EINA_ARG_NONNULL(1);
+
+/**
+ * Retrieves the hints for an object's display mode
+ *
+ * @param obj The given Evas object to query hints from.
+ *
+ * These are hints on the display mode @p obj. This is
+ * not a size enforcement in any way, it's just a hint that can be
+ * used whenever appropriate.
+ * This mode can be used object's display mode like commpress or expand
+ *
+ * @see evas_object_size_hint_display_mode_set()
+ */
+EAPI Evas_Display_Mode evas_object_size_hint_display_mode_get(const Evas_Object *obj) EINA_ARG_NONNULL(1);
+
+/**
+ * Sets the hints for an object's disply mode
+ *
+ * @param obj The given Evas object to query hints from.
+ * @param dispmode to use as the display mode hint.
+ *
+ * This is not a size enforcement in any way, it's just a hint that
+ * can be used whenever appropriate.
+ *
+ * @see evas_object_size_hint_display_mode_get()
+ */
+EAPI void evas_object_size_hint_display_mode_set(Evas_Object *obj, Evas_Display_Mode dispmode) EINA_ARG_NONNULL(1);
+
+/**
+ * Retrieves the hints for an object's optimum size.
+ *
+ * @param obj The given Evas object to query hints from.
+ * @param w Pointer to an integer in which to store the requested width.
+ * @param h Pointer to an integer in which to store the requested height.
+ *
+ * These are hints on the optimum sizes @p obj should have. This is
+ * not a size enforcement in any way, it's just a hint that should be
+ * used whenever appropriate.
+ *
+ * @note Use @c NULL pointers on the hint components you're not
+ * interested in: they'll be ignored by the function.
+ *
+ * @see evas_object_size_hint_request_set()
+ */
+EAPI void evas_object_size_hint_request_get(const Evas_Object *obj, Evas_Coord *w, Evas_Coord *h) EINA_ARG_NONNULL(1);
+
+/**
+ * Sets the hints for an object's optimum size.
+ *
+ * @param obj The given Evas object to query hints from.
+ * @param w Integer to use as the preferred width hint.
+ * @param h Integer to use as the preferred height hint.
+ *
+ * This is not a size enforcement in any way, it's just a hint that
+ * should be used whenever appropriate.
+ *
+ * Values @c 0 will be treated as unset hint components, when queried
+ * by managers.
+ *
+ * @see evas_object_size_hint_request_get()
+ */
+EAPI void evas_object_size_hint_request_set(Evas_Object *obj, Evas_Coord w, Evas_Coord h) EINA_ARG_NONNULL(1);
+
+/**
+ * Retrieves the hints for an object's aspect ratio.
+ *
+ * @param obj The given Evas object to query hints from.
+ * @param aspect Returns the policy/type of aspect ratio applied to @p obj.
+ * @param w Pointer to an integer in which to store the aspect's width
+ * ratio term.
+ * @param h Pointer to an integer in which to store the aspect's
+ * height ratio term.
+ *
+ * The different aspect ratio policies are documented in the
+ * #Evas_Aspect_Control type. A container respecting these size hints
+ * would @b resize its children accordingly to those policies.
+ *
+ * For any policy, if any of the given aspect ratio terms are @c 0,
+ * the object's container should ignore the aspect and scale @p obj to
+ * occupy the whole available area. If they are both positive
+ * integers, that proportion will be respected, under each scaling
+ * policy.
+ *
+ * These images illustrate some of the #Evas_Aspect_Control policies:
+ *
+ * @image html any-policy.png
+ * @image rtf any-policy.png
+ * @image latex any-policy.eps
+ *
+ * @image html aspect-control-none-neither.png
+ * @image rtf aspect-control-none-neither.png
+ * @image latex aspect-control-none-neither.eps
+ *
+ * @image html aspect-control-both.png
+ * @image rtf aspect-control-both.png
+ * @image latex aspect-control-both.eps
+ *
+ * @image html aspect-control-horizontal.png
+ * @image rtf aspect-control-horizontal.png
+ * @image latex aspect-control-horizontal.eps
+ *
+ * This is not a size enforcement in any way, it's just a hint that
+ * should be used whenever appropriate.
+ *
+ * @note Use @c NULL pointers on the hint components you're not
+ * interested in: they'll be ignored by the function.
+ *
+ * Example:
+ * @dontinclude evas-aspect-hints.c
+ * @skip if (strcmp(ev->keyname, "c") == 0)
+ * @until }
+ *
+ * See the full @ref Example_Evas_Aspect_Hints "example".
+ *
+ * @see evas_object_size_hint_aspect_set()
+ */
+EAPI void evas_object_size_hint_aspect_get(const Evas_Object *obj, Evas_Aspect_Control *aspect, Evas_Coord *w, Evas_Coord *h) EINA_ARG_NONNULL(1);
+
+/**
+ * Sets the hints for an object's aspect ratio.
+ *
+ * @param obj The given Evas object to query hints from.
+ * @param aspect The policy/type of aspect ratio to apply to @p obj.
+ * @param w Integer to use as aspect width ratio term.
+ * @param h Integer to use as aspect height ratio term.
+ *
+ * This is not a size enforcement in any way, it's just a hint that should
+ * be used whenever appropriate.
+ *
+ * If any of the given aspect ratio terms are @c 0,
+ * the object's container will ignore the aspect and scale @p obj to
+ * occupy the whole available area, for any given policy.
+ *
+ * @see evas_object_size_hint_aspect_get() for more information.
+ */
+EAPI void evas_object_size_hint_aspect_set(Evas_Object *obj, Evas_Aspect_Control aspect, Evas_Coord w, Evas_Coord h) EINA_ARG_NONNULL(1);
+
+/**
+ * Retrieves the hints for on object's alignment.
+ *
+ * @param obj The given Evas object to query hints from.
+ * @param x Pointer to a double in which to store the horizontal
+ * alignment hint.
+ * @param y Pointer to a double in which to store the vertical
+ * alignment hint.
+ *
+ * This is not a size enforcement in any way, it's just a hint that
+ * should be used whenever appropriate.
+ *
+ * @note Use @c NULL pointers on the hint components you're not
+ * interested in: they'll be ignored by the function.
+ * @note If @c obj is invalid, then the hint components will be set with 0.5
+ *
+ * @see evas_object_size_hint_align_set() for more information
+ */
+EAPI void evas_object_size_hint_align_get(const Evas_Object *obj, double *x, double *y) EINA_ARG_NONNULL(1);
+
+/**
+ * Sets the hints for an object's alignment.
+ *
+ * @param obj The given Evas object to query hints from.
+ * @param x Double, ranging from @c 0.0 to @c 1.0 or with the
+ * special value #EVAS_HINT_FILL, to use as horizontal alignment hint.
+ * @param y Double, ranging from @c 0.0 to @c 1.0 or with the
+ * special value #EVAS_HINT_FILL, to use as vertical alignment hint.
+ *
+ * These are hints on how to align an object <b>inside the boundaries
+ * of a container/manager</b>. Accepted values are in the @c 0.0 to @c
+ * 1.0 range, with the special value #EVAS_HINT_FILL used to specify
+ * "justify" or "fill" by some users. In this case, maximum size hints
+ * should be enforced with higher priority, if they are set. Also, any
+ * padding hint set on objects should add up to the alignment space on
+ * the final scene composition.
+ *
+ * See documentation of possible users: in Evas, they are the @ref
+ * Evas_Object_Box "box" and @ref Evas_Object_Table "table" smart
+ * objects.
+ *
+ * For the horizontal component, @c 0.0 means to the left, @c 1.0
+ * means to the right. Analogously, for the vertical component, @c 0.0
+ * to the top, @c 1.0 means to the bottom.
+ *
+ * See the following figure:
+ *
+ * @image html alignment-hints.png
+ * @image rtf alignment-hints.png
+ * @image latex alignment-hints.eps
+ *
+ * This is not a size enforcement in any way, it's just a hint that
+ * should be used whenever appropriate.
+ *
+ * @note Default alignment hint values are 0.5, for both axis.
+ *
+ * Example:
+ * @dontinclude evas-hints.c
+ * @skip evas_object_size_hint_align_set
+ * @until return
+ *
+ * In this example the alignment hints change the behavior of an Evas
+ * box when layouting its children. See the full @ref
+ * Example_Evas_Size_Hints "example".
+ *
+ * @see evas_object_size_hint_align_get()
+ * @see evas_object_size_hint_max_set()
+ * @see evas_object_size_hint_padding_set()
+ */
+EAPI void evas_object_size_hint_align_set(Evas_Object *obj, double x, double y) EINA_ARG_NONNULL(1);
+
+/**
+ * Retrieves the hints for an object's weight.
+ *
+ * @param obj The given Evas object to query hints from.
+ * @param x Pointer to a double in which to store the horizontal weight.
+ * @param y Pointer to a double in which to store the vertical weight.
+ *
+ * Accepted values are zero or positive values. Some users might use
+ * this hint as a boolean, but some might consider it as a @b
+ * proportion, see documentation of possible users, which in Evas are
+ * the @ref Evas_Object_Box "box" and @ref Evas_Object_Table "table"
+ * smart objects.
+ *
+ * This is not a size enforcement in any way, it's just a hint that
+ * should be used whenever appropriate.
+ *
+ * @note Use @c NULL pointers on the hint components you're not
+ * interested in: they'll be ignored by the function.
+ * @note If @c obj is invalid, then the hint components will be set with 0.0
+ *
+ * @see evas_object_size_hint_weight_set() for an example
+ */
+EAPI void evas_object_size_hint_weight_get(const Evas_Object *obj, double *x, double *y) EINA_ARG_NONNULL(1);
+
+/**
+ * Sets the hints for an object's weight.
+ *
+ * @param obj The given Evas object to query hints from.
+ * @param x Nonnegative double value to use as horizontal weight hint.
+ * @param y Nonnegative double value to use as vertical weight hint.
+ *
+ * This is not a size enforcement in any way, it's just a hint that
+ * should be used whenever appropriate.
+ *
+ * This is a hint on how a container object should @b resize a given
+ * child within its area. Containers may adhere to the simpler logic
+ * of just expanding the child object's dimensions to fit its own (see
+ * the #EVAS_HINT_EXPAND helper weight macro) or the complete one of
+ * taking each child's weight hint as real @b weights to how much of
+ * its size to allocate for them in each axis. A container is supposed
+ * to, after @b normalizing the weights of its children (with weight
+ * hints), distribute the space it has to layout them by those factors
+ * -- most weighted children get larger in this process than the least
+ * ones.
+ *
+ * Example:
+ * @dontinclude evas-hints.c
+ * @skip evas_object_size_hint_weight_set
+ * @until return
+ *
+ * In this example the weight hints change the behavior of an Evas box
+ * when layouting its children. See the full @ref
+ * Example_Evas_Size_Hints "example".
+ *
+ * @note Default weight hint values are 0.0, for both axis.
+ *
+ * @see evas_object_size_hint_weight_get() for more information
+ */
+EAPI void evas_object_size_hint_weight_set(Evas_Object *obj, double x, double y) EINA_ARG_NONNULL(1);
+
+/**
+ * Retrieves the hints for an object's padding space.
+ *
+ * @param obj The given Evas object to query hints from.
+ * @param l Pointer to an integer in which to store left padding.
+ * @param r Pointer to an integer in which to store right padding.
+ * @param t Pointer to an integer in which to store top padding.
+ * @param b Pointer to an integer in which to store bottom padding.
+ *
+ * Padding is extra space an object takes on each of its delimiting
+ * rectangle sides, in canvas units. This space will be rendered
+ * transparent, naturally, as in the following figure:
+ *
+ * @image html padding-hints.png
+ * @image rtf padding-hints.png
+ * @image latex padding-hints.eps
+ *
+ * This is not a size enforcement in any way, it's just a hint that
+ * should be used whenever appropriate.
+ *
+ * @note Use @c NULL pointers on the hint components you're not
+ * interested in: they'll be ignored by the function.
+ *
+ * Example:
+ * @dontinclude evas-hints.c
+ * @skip evas_object_size_hint_padding_set
+ * @until return
+ *
+ * In this example the padding hints change the behavior of an Evas box
+ * when layouting its children. See the full @ref
+ * Example_Evas_Size_Hints "example".
+ *
+ * @see evas_object_size_hint_padding_set()
+ */
+EAPI void evas_object_size_hint_padding_get(const Evas_Object *obj, Evas_Coord *l, Evas_Coord *r, Evas_Coord *t, Evas_Coord *b) EINA_ARG_NONNULL(1);
+
+/**
+ * Sets the hints for an object's padding space.
+ *
+ * @param obj The given Evas object to query hints from.
+ * @param l Integer to specify left padding.
+ * @param r Integer to specify right padding.
+ * @param t Integer to specify top padding.
+ * @param b Integer to specify bottom padding.
+ *
+ * This is not a size enforcement in any way, it's just a hint that
+ * should be used whenever appropriate.
+ *
+ * @see evas_object_size_hint_padding_get() for more information
+ */
+EAPI void evas_object_size_hint_padding_set(Evas_Object *obj, Evas_Coord l, Evas_Coord r, Evas_Coord t, Evas_Coord b) EINA_ARG_NONNULL(1);
+/**
+ * @}
+ */
+
+/**
+ * @ingroup Evas_Object_Group_Extras
+ *
+ * @{
+ */
+
+/**
+ * Set an attached data pointer to an object with a given string key.
+ *
+ * @param obj The object to attach the data pointer to
+ * @param key The string key for the data to access it
+ * @param data The pointer to the data to be attached
+ *
+ * This attaches the pointer @p data to the object @p obj, given the
+ * access string @p key. This pointer will stay "hooked" to the object
+ * until a new pointer with the same string key is attached with
+ * evas_object_data_set() or it is deleted with
+ * evas_object_data_del(). On deletion of the object @p obj, the
+ * pointers will not be accessible from the object anymore.
+ *
+ * You can find the pointer attached under a string key using
+ * evas_object_data_get(). It is the job of the calling application to
+ * free any data pointed to by @p data when it is no longer required.
+ *
+ * If @p data is @c NULL, the old value stored at @p key will be
+ * removed but no new value will be stored. This is synonymous with
+ * calling evas_object_data_del() with @p obj and @p key.
+ *
+ * @note This function is very handy when you have data associated
+ * specifically to an Evas object, being of use only when dealing with
+ * it. Than you don't have the burden to a pointer to it elsewhere,
+ * using this family of functions.
+ *
+ * Example:
+ *
+ * @code
+ * int *my_data;
+ * extern Evas_Object *obj;
+ *
+ * my_data = malloc(500);
+ * evas_object_data_set(obj, "name_of_data", my_data);
+ * printf("The data that was attached was %p\n", evas_object_data_get(obj, "name_of_data"));
+ * @endcode
+ */
+EAPI void                     evas_object_data_set(Evas_Object *obj, const char *key, const void *data) EINA_ARG_NONNULL(1, 2);
+
+/**
+ * Return an attached data pointer on an Evas object by its given
+ * string key.
+ *
+ * @param obj The object to which the data was attached
+ * @param key The string key the data was stored under
+ * @return The data pointer stored, or @c NULL if none was stored
+ *
+ * This function will return the data pointer attached to the object
+ * @p obj, stored using the string key @p key. If the object is valid
+ * and a data pointer was stored under the given key, that pointer
+ * will be returned. If this is not the case, @c NULL will be
+ * returned, signifying an invalid object or a non-existent key. It is
+ * possible that a @c NULL pointer was stored given that key, but this
+ * situation is non-sensical and thus can be considered an error as
+ * well. @c NULL pointers are never stored as this is the return value
+ * if an error occurs.
+ *
+ * Example:
+ *
+ * @code
+ * int *my_data;
+ * extern Evas_Object *obj;
+ *
+ * my_data = evas_object_data_get(obj, "name_of_my_data");
+ * if (my_data) printf("Data stored was %p\n", my_data);
+ * else printf("No data was stored on the object\n");
+ * @endcode
+ */
+EAPI void                    *evas_object_data_get(const Evas_Object *obj, const char *key) EINA_WARN_UNUSED_RESULT EINA_ARG_NONNULL(1, 2);
+
+/**
+ * Delete an attached data pointer from an object.
+ *
+ * @param obj The object to delete the data pointer from
+ * @param key The string key the data was stored under
+ * @return The original data pointer stored at @p key on @p obj
+ *
+ * This will remove the stored data pointer from @p obj stored under
+ * @p key and return this same pointer, if actually there was data
+ * there, or @c NULL, if nothing was stored under that key.
+ *
+ * Example:
+ *
+ * @code
+ * int *my_data;
+ * extern Evas_Object *obj;
+ *
+ * my_data = evas_object_data_del(obj, "name_of_my_data");
+ * @endcode
+ */
+EAPI void                    *evas_object_data_del(Evas_Object *obj, const char *key) EINA_ARG_NONNULL(1, 2);
+
+/**
+ * Set pointer behavior.
+ *
+ * @param obj
+ * @param setting desired behavior.
+ *
+ * This function has direct effect on event callbacks related to
+ * mouse.
+ *
+ * If @p setting is EVAS_OBJECT_POINTER_MODE_AUTOGRAB, then when mouse
+ * is down at this object, events will be restricted to it as source,
+ * mouse moves, for example, will be emitted even if outside this
+ * object area.
+ *
+ * If @p setting is EVAS_OBJECT_POINTER_MODE_NOGRAB, then events will
+ * be emitted just when inside this object area.
+ *
+ * The default value is EVAS_OBJECT_POINTER_MODE_AUTOGRAB.
+ *
+ * @ingroup Evas_Object_Group_Extras
+ */
+EAPI void                     evas_object_pointer_mode_set(Evas_Object *obj, Evas_Object_Pointer_Mode setting) EINA_ARG_NONNULL(1);
+
+/**
+ * Determine how pointer will behave.
+ * @param obj
+ * @return pointer behavior.
+ * @ingroup Evas_Object_Group_Extras
+ */
+EAPI Evas_Object_Pointer_Mode evas_object_pointer_mode_get(const Evas_Object *obj) EINA_WARN_UNUSED_RESULT EINA_ARG_NONNULL(1);
+
+/**
+ * Sets whether or not the given Evas object is to be drawn anti-aliased.
+ *
+ * @param   obj The given Evas object.
+ * @param   antialias 1 if the object is to be anti_aliased, 0 otherwise.
+ * @ingroup Evas_Object_Group_Extras
+ */
+EAPI void                     evas_object_anti_alias_set(Evas_Object *obj, Eina_Bool antialias) EINA_ARG_NONNULL(1);
+
+/**
+ * Retrieves whether or not the given Evas object is to be drawn anti_aliased.
+ * @param   obj The given Evas object.
+ * @return  @c 1 if the object is to be anti_aliased.  @c 0 otherwise.
+ * @ingroup Evas_Object_Group_Extras
+ */
+EAPI Eina_Bool                evas_object_anti_alias_get(const Evas_Object *obj) EINA_WARN_UNUSED_RESULT EINA_ARG_NONNULL(1);
+
+/**
+ * Sets the scaling factor for an Evas object. Does not affect all
+ * objects.
+ *
+ * @param obj The given Evas object.
+ * @param scale The scaling factor. <c>1.0</c> means no scaling,
+ *        default size.
+ *
+ * This will multiply the object's dimension by the given factor, thus
+ * altering its geometry (width and height). Useful when you want
+ * scalable UI elements, possibly at run time.
+ *
+ * @note Only text and textblock objects have scaling change
+ * handlers. Other objects won't change visually on this call.
+ *
+ * @see evas_object_scale_get()
+ *
+ * @ingroup Evas_Object_Group_Extras
+ */
+EAPI void                     evas_object_scale_set(Evas_Object *obj, double scale) EINA_ARG_NONNULL(1);
+
+/**
+ * Retrieves the scaling factor for the given Evas object.
+ *
+ * @param   obj The given Evas object.
+ * @return  The scaling factor.
+ *
+ * @ingroup Evas_Object_Group_Extras
+ *
+ * @see evas_object_scale_set()
+ */
+EAPI double                   evas_object_scale_get(const Evas_Object *obj) EINA_WARN_UNUSED_RESULT EINA_ARG_NONNULL(1);
+
+/**
+ * Sets the render_op to be used for rendering the Evas object.
+ * @param   obj The given Evas object.
+ * @param   op one of the Evas_Render_Op values.
+ * @ingroup Evas_Object_Group_Extras
+ */
+EAPI void                     evas_object_render_op_set(Evas_Object *obj, Evas_Render_Op op) EINA_ARG_NONNULL(1);
+
+/**
+ * Retrieves the current value of the operation used for rendering the Evas object.
+ * @param   obj The given Evas object.
+ * @return  one of the enumerated values in Evas_Render_Op.
+ * @ingroup Evas_Object_Group_Extras
+ */
+EAPI Evas_Render_Op           evas_object_render_op_get(const Evas_Object *obj) EINA_WARN_UNUSED_RESULT EINA_ARG_NONNULL(1);
+
+/**
+ * Set whether to use precise (usually expensive) point collision
+ * detection for a given Evas object.
+ *
+ * @param obj The given object.
+ * @param precise Whether to use precise point collision detection or
+ * not. The default value is false.
+ *
+ * Use this function to make Evas treat objects' transparent areas as
+ * @b not belonging to it with regard to mouse pointer events. By
+ * default, all of the object's boundary rectangle will be taken in
+ * account for them.
+ *
+ * @warning By using precise point collision detection you'll be
+ * making Evas more resource intensive.
+ *
+ * Example code follows.
+ * @dontinclude evas-events.c
+ * @skip if (strcmp(ev->keyname, "p") == 0)
+ * @until }
+ *
+ * See the full example @ref Example_Evas_Events "here".
+ *
+ * @see evas_object_precise_is_inside_get()
+ * @ingroup Evas_Object_Group_Extras
+ */
+EAPI void                     evas_object_precise_is_inside_set(Evas_Object *obj, Eina_Bool precise) EINA_ARG_NONNULL(1);
+
+/**
+ * Determine whether an object is set to use precise point collision
+ * detection.
+ *
+ * @param obj The given object.
+ * @return whether @p obj is set to use precise point collision
+ * detection or not The default value is false.
+ *
+ * @see evas_object_precise_is_inside_set() for an example
+ *
+ * @ingroup Evas_Object_Group_Extras
+ */
+EAPI Eina_Bool                evas_object_precise_is_inside_get(const Evas_Object *obj) EINA_WARN_UNUSED_RESULT EINA_ARG_NONNULL(1);
+
+/**
+ * Set a hint flag on the given Evas object that it's used as a "static
+ * clipper".
+ *
+ * @param obj The given object.
+ * @param is_static_clip @c EINA_TRUE if it's to be used as a static
+ * clipper, @c EINA_FALSE otherwise.
+ *
+ * This is a hint to Evas that this object is used as a big static
+ * clipper and shouldn't be moved with children and otherwise
+ * considered specially. The default value for new objects is
+ * @c EINA_FALSE.
+ *
+ * @see evas_object_static_clip_get()
+ *
+ * @ingroup Evas_Object_Group_Extras
+ */
+EAPI void                     evas_object_static_clip_set(Evas_Object *obj, Eina_Bool is_static_clip) EINA_ARG_NONNULL(1);
+
+/**
+ * Get the "static clipper" hint flag for a given Evas object.
+ *
+ * @param obj The given object.
+ * @return @c EINA_TRUE if it's set as a static clipper,
+ * @c EINA_FALSE otherwise.
+ *
+ * @see evas_object_static_clip_set() for more details
+ *
+ * @ingroup Evas_Object_Group_Extras
+ */
+EAPI Eina_Bool                evas_object_static_clip_get(const Evas_Object *obj) EINA_WARN_UNUSED_RESULT EINA_ARG_NONNULL(1);
+/**
+ * @}
+ */
+
+/**
+ * @ingroup Evas_Object_Group_Find
+ *
+ * @{
+ */
+
+/**
+ * Retrieve the object that currently has focus.
+ *
+ * @param e The Evas canvas to query for focused object on.
+ * @return The object that has focus or @c NULL if there is not one.
+ *
+ * Evas can have (at most) one of its objects focused at a time.
+ * Focused objects will be the ones having <b>key events</b> delivered
+ * to, which the programmer can act upon by means of
+ * 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
+ * @p e or @c NULL, if none.
+ *
+ * @see evas_object_focus_set
+ * @see evas_object_focus_get
+ * @see evas_object_key_grab
+ * @see evas_object_key_ungrab
+ *
+ * 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 @c event_info is exactly a pointer to that
+ * focused rectangle. See the full @ref Example_Evas_Events "example".
+ *
+ * @ingroup Evas_Object_Group_Find
+ */
+EAPI Evas_Object *evas_focus_get(const Evas *e) EINA_WARN_UNUSED_RESULT EINA_ARG_NONNULL(1);
+
+/**
+ * Retrieves the object on the given evas with the given name.
+ * @param   e    The given evas.
+ * @param   name The given name.
+ * @return  If successful, the Evas object with the given name.  Otherwise,
+ *          @c NULL.
+ *
+ * This looks for the evas object given a name by evas_object_name_set(). 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.
+ *
+ * @ingroup Evas_Object_Group_Find
+ */
+EAPI Evas_Object *evas_object_name_find(const Evas *e, const char *name) EINA_WARN_UNUSED_RESULT EINA_ARG_NONNULL(1);
+
+/**
+ * Retrieves the object from children of the given object with the given name.
+ * @param   obj  The parent (smart) object whose children to search.
+ * @param   name The given name.
+ * @param   recurse Set to the number of child levels to recurse (0 == don't recurse, 1 == only look at the children of @p obj or their immediate children, but no further etc.).
+ * @return  If successful, the Evas object with the given name.  Otherwise,
+ *          @c NULL.
+ *
+ * This looks for the evas object given a name by evas_object_name_set(), but
+ * it ONLY looks at the children of the object *p obj, and will only recurse
+ * into those children if @p recurse is greater than 0. If the name is not
+ * unique within immediate children (or the whole child tree) then it is not
+ * defined which child object will be returned. If @p recurse is set to -1 then
+ * it will recurse without limit.
+ *
+ * @since 1.2
+ *
+ * @ingroup Evas_Object_Group_Find
+ */
+EAPI Evas_Object *evas_object_name_child_find(const Evas_Object *obj, const char *name, int recurse) EINA_WARN_UNUSED_RESULT EINA_ARG_NONNULL(1);
+
+/**
+ * Retrieve the Evas object stacked at the top of a given position in
+ * a canvas
+ *
+ * @param   e A handle to the canvas.
+ * @param   x The horizontal coordinate of the position
+ * @param   y The vertical coordinate of the position
+ * @param   include_pass_events_objects Boolean flag to include or not
+ * objects which pass events in this calculation
+ * @param   include_hidden_objects Boolean flag to include or not hidden
+ * objects in this calculation
+ * @return  The Evas object that is over all other objects at the given
+ * position.
+ *
+ * This function will traverse all the layers of the given canvas,
+ * from top to bottom, querying for objects with areas covering the
+ * given position. The user can remove from the query
+ * objects which are hidden and/or which are set to pass events.
+ *
+ * @warning This function will @b skip objects parented by smart
+ * objects, acting only on the ones at the "top level", with regard to
+ * object parenting.
+ */
+EAPI Evas_Object *evas_object_top_at_xy_get(const Evas *e, Evas_Coord x, Evas_Coord y, Eina_Bool include_pass_events_objects, Eina_Bool include_hidden_objects) EINA_WARN_UNUSED_RESULT EINA_ARG_NONNULL(1);
+
+/**
+ * Retrieve the Evas object stacked at the top at the position of the
+ * mouse cursor, over a given canvas
+ *
+ * @param   e A handle to the canvas.
+ * @return  The Evas object that is over all other objects at the mouse
+ * pointer's position
+ *
+ * This function will traverse all the layers of the given canvas,
+ * from top to bottom, querying for objects with areas covering the
+ * mouse pointer's position, over @p e.
+ *
+ * @warning This function will @b skip objects parented by smart
+ * objects, acting only on the ones at the "top level", with regard to
+ * object parenting.
+ */
+EAPI Evas_Object *evas_object_top_at_pointer_get(const Evas *e) EINA_WARN_UNUSED_RESULT EINA_ARG_NONNULL(1);
+
+/**
+ * Retrieve the Evas object stacked at the top of a given rectangular
+ * region in a canvas
+ *
+ * @param   e A handle to the canvas.
+ * @param   x The top left corner's horizontal coordinate for the
+ * rectangular region
+ * @param   y The top left corner's vertical coordinate for the
+ * rectangular region
+ * @param   w The width of the rectangular region
+ * @param   h The height of the rectangular region
+ * @param   include_pass_events_objects Boolean flag to include or not
+ * objects which pass events in this calculation
+ * @param   include_hidden_objects Boolean flag to include or not hidden
+ * objects in this calculation
+ * @return  The Evas object that is over all other objects at the given
+ * rectangular region.
+ *
+ * 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 @p e. The user can remove
+ * from the query objects which are hidden and/or which are set to
+ * pass events.
+ *
+ * @warning This function will @b skip objects parented by smart
+ * objects, acting only on the ones at the "top level", with regard to
+ * object parenting.
+ */
+EAPI Evas_Object *evas_object_top_in_rectangle_get(const Evas *e, Evas_Coord x, Evas_Coord y, Evas_Coord w, Evas_Coord h, Eina_Bool include_pass_events_objects, Eina_Bool include_hidden_objects) EINA_WARN_UNUSED_RESULT EINA_ARG_NONNULL(1);
+
+/**
+ * Retrieve a list of Evas objects lying over a given position in
+ * a canvas
+ *
+ * @param   e A handle to the canvas.
+ * @param   x The horizontal coordinate of the position
+ * @param   y The vertical coordinate of the position
+ * @param   include_pass_events_objects Boolean flag to include or not
+ * objects which pass events in this calculation
+ * @param   include_hidden_objects Boolean flag to include or not hidden
+ * objects in this calculation
+ * @return  The list of Evas objects that are over the given position
+ * in @p e
+ *
+ * This function will traverse all the layers of the given canvas,
+ * from top to bottom, querying for objects with areas covering the
+ * given position. The user can remove from query
+ * objects which are hidden and/or which are set to pass events.
+ *
+ * @warning This function will @b skip objects parented by smart
+ * objects, acting only on the ones at the "top level", with regard to
+ * object parenting.
+ */
+EAPI Eina_List   *evas_objects_at_xy_get(const Evas *e, Evas_Coord x, Evas_Coord y, Eina_Bool include_pass_events_objects, Eina_Bool include_hidden_objects) EINA_WARN_UNUSED_RESULT EINA_ARG_NONNULL(1);
+EAPI Eina_List   *evas_objects_in_rectangle_get(const Evas *e, Evas_Coord x, Evas_Coord y, Evas_Coord w, Evas_Coord h, Eina_Bool include_pass_events_objects, Eina_Bool include_hidden_objects) EINA_WARN_UNUSED_RESULT EINA_ARG_NONNULL(1);
+
+/**
+ * Get the lowest (stacked) Evas object on the canvas @p e.
+ *
+ * @param e a valid canvas pointer
+ * @return a pointer to the lowest object on it, if any, or @c NULL,
+ * otherwise
+ *
+ * This function will take all populated layers in the canvas into
+ * account, getting the lowest object for the lowest layer, naturally.
+ *
+ * @see evas_object_layer_get()
+ * @see evas_object_layer_set()
+ * @see evas_object_below_get()
+ * @see evas_object_above_get()
+ *
+ * @warning This function will @b skip objects parented by smart
+ * objects, acting only on the ones at the "top level", with regard to
+ * object parenting.
+ */
+EAPI Evas_Object *evas_object_bottom_get(const Evas *e) EINA_WARN_UNUSED_RESULT EINA_ARG_NONNULL(1);
+
+/**
+ * Get the highest (stacked) Evas object on the canvas @p e.
+ *
+ * @param e a valid canvas pointer
+ * @return a pointer to the highest object on it, if any, or @c NULL,
+ * otherwise
+ *
+ * This function will take all populated layers in the canvas into
+ * account, getting the highest object for the highest layer,
+ * naturally.
+ *
+ * @see evas_object_layer_get()
+ * @see evas_object_layer_set()
+ * @see evas_object_below_get()
+ * @see evas_object_above_get()
+ *
+ * @warning This function will @b skip objects parented by smart
+ * objects, acting only on the ones at the "top level", with regard to
+ * object parenting.
+ */
+EAPI Evas_Object *evas_object_top_get(const Evas *e) EINA_WARN_UNUSED_RESULT EINA_ARG_NONNULL(1);
+/**
+ * @}
+ */
+
+/**
+ * @ingroup Evas_Object_Group_Interceptors
+ *
+ * @{
+ */
+
+/**
+ * Set the callback function that intercepts a show event of a object.
+ *
+ * @param obj The given canvas object pointer.
+ * @param func The given function to be the callback function.
+ * @param data The data passed to the callback function.
+ *
+ * This function sets a callback function to intercepts a show event
+ * of a canvas object.
+ *
+ * @see evas_object_intercept_show_callback_del().
+ *
+ */
+EAPI void  evas_object_intercept_show_callback_add(Evas_Object *obj, Evas_Object_Intercept_Show_Cb func, const void *data) EINA_ARG_NONNULL(1, 2);
+
+/**
+ * Unset the callback function that intercepts a show event of a
+ * object.
+ *
+ * @param obj The given canvas object pointer.
+ * @param func The given callback function.
+ *
+ * This function sets a callback function to intercepts a show event
+ * of a canvas object.
+ *
+ * @see evas_object_intercept_show_callback_add().
+ *
+ */
+EAPI void *evas_object_intercept_show_callback_del(Evas_Object *obj, Evas_Object_Intercept_Show_Cb func) EINA_ARG_NONNULL(1, 2);
+
+/**
+ * Set the callback function that intercepts a hide event of a object.
+ *
+ * @param obj The given canvas object pointer.
+ * @param func The given function to be the callback function.
+ * @param data The data passed to the callback function.
+ *
+ * This function sets a callback function to intercepts a hide event
+ * of a canvas object.
+ *
+ * @see evas_object_intercept_hide_callback_del().
+ *
+ */
+EAPI void  evas_object_intercept_hide_callback_add(Evas_Object *obj, Evas_Object_Intercept_Hide_Cb func, const void *data) EINA_ARG_NONNULL(1, 2);
+
+/**
+ * Unset the callback function that intercepts a hide event of a
+ * object.
+ *
+ * @param obj The given canvas object pointer.
+ * @param func The given callback function.
+ *
+ * This function sets a callback function to intercepts a hide event
+ * of a canvas object.
+ *
+ * @see evas_object_intercept_hide_callback_add().
+ *
+ */
+EAPI void *evas_object_intercept_hide_callback_del(Evas_Object *obj, Evas_Object_Intercept_Hide_Cb func) EINA_ARG_NONNULL(1, 2);
+
+/**
+ * Set the callback function that intercepts a move event of a object.
+ *
+ * @param obj The given canvas object pointer.
+ * @param func The given function to be the callback function.
+ * @param data The data passed to the callback function.
+ *
+ * This function sets a callback function to intercepts a move event
+ * of a canvas object.
+ *
+ * @see evas_object_intercept_move_callback_del().
+ *
+ */
+EAPI void  evas_object_intercept_move_callback_add(Evas_Object *obj, Evas_Object_Intercept_Move_Cb func, const void *data) EINA_ARG_NONNULL(1, 2);
+
+/**
+ * Unset the callback function that intercepts a move event of a
+ * object.
+ *
+ * @param obj The given canvas object pointer.
+ * @param func The given callback function.
+ *
+ * This function sets a callback function to intercepts a move event
+ * of a canvas object.
+ *
+ * @see evas_object_intercept_move_callback_add().
+ *
+ */
+EAPI void *evas_object_intercept_move_callback_del(Evas_Object *obj, Evas_Object_Intercept_Move_Cb func) EINA_ARG_NONNULL(1, 2);
+
+EAPI void  evas_object_intercept_resize_callback_add(Evas_Object *obj, Evas_Object_Intercept_Resize_Cb func, const void *data) EINA_ARG_NONNULL(1, 2);
+EAPI void *evas_object_intercept_resize_callback_del(Evas_Object *obj, Evas_Object_Intercept_Resize_Cb func) EINA_ARG_NONNULL(1, 2);
+EAPI void  evas_object_intercept_raise_callback_add(Evas_Object *obj, Evas_Object_Intercept_Raise_Cb func, const void *data) EINA_ARG_NONNULL(1, 2);
+EAPI void *evas_object_intercept_raise_callback_del(Evas_Object *obj, Evas_Object_Intercept_Raise_Cb func) EINA_ARG_NONNULL(1, 2);
+EAPI void  evas_object_intercept_lower_callback_add(Evas_Object *obj, Evas_Object_Intercept_Lower_Cb func, const void *data) EINA_ARG_NONNULL(1, 2);
+EAPI void *evas_object_intercept_lower_callback_del(Evas_Object *obj, Evas_Object_Intercept_Lower_Cb func) EINA_ARG_NONNULL(1, 2);
+EAPI void  evas_object_intercept_stack_above_callback_add(Evas_Object *obj, Evas_Object_Intercept_Stack_Above_Cb func, const void *data) EINA_ARG_NONNULL(1, 2);
+EAPI void *evas_object_intercept_stack_above_callback_del(Evas_Object *obj, Evas_Object_Intercept_Stack_Above_Cb func) EINA_ARG_NONNULL(1, 2);
+EAPI void  evas_object_intercept_stack_below_callback_add(Evas_Object *obj, Evas_Object_Intercept_Stack_Below_Cb func, const void *data) EINA_ARG_NONNULL(1, 2);
+EAPI void *evas_object_intercept_stack_below_callback_del(Evas_Object *obj, Evas_Object_Intercept_Stack_Below_Cb func) EINA_ARG_NONNULL(1, 2);
+EAPI void  evas_object_intercept_layer_set_callback_add(Evas_Object *obj, Evas_Object_Intercept_Layer_Set_Cb func, const void *data) EINA_ARG_NONNULL(1, 2);
+EAPI void *evas_object_intercept_layer_set_callback_del(Evas_Object *obj, Evas_Object_Intercept_Layer_Set_Cb func) EINA_ARG_NONNULL(1, 2);
+EAPI void  evas_object_intercept_color_set_callback_add(Evas_Object *obj, Evas_Object_Intercept_Color_Set_Cb func, const void *data) EINA_ARG_NONNULL(1, 2);
+EAPI void *evas_object_intercept_color_set_callback_del(Evas_Object *obj, Evas_Object_Intercept_Color_Set_Cb func) EINA_ARG_NONNULL(1, 2);
+EAPI void  evas_object_intercept_clip_set_callback_add(Evas_Object *obj, Evas_Object_Intercept_Clip_Set_Cb func, const void *data) EINA_ARG_NONNULL(1, 2);
+EAPI void *evas_object_intercept_clip_set_callback_del(Evas_Object *obj, Evas_Object_Intercept_Clip_Set_Cb func) EINA_ARG_NONNULL(1, 2);
+EAPI void  evas_object_intercept_clip_unset_callback_add(Evas_Object *obj, Evas_Object_Intercept_Clip_Unset_Cb func, const void *data) EINA_ARG_NONNULL(1, 2);
+EAPI void *evas_object_intercept_clip_unset_callback_del(Evas_Object *obj, Evas_Object_Intercept_Clip_Unset_Cb func) EINA_ARG_NONNULL(1, 2);
+/**
+ * @}
+ */
+
+/**
+ * @ingroup Evas_Object_Rectangle
+ *
+ * @{
+ */
+
+/**
+ * Adds a rectangle to the given evas.
+ * @param   e The given evas.
+ * @return  The new rectangle object.