2013-06-26 23:27:30 -07:00
|
|
|
#ifndef _EVAS_H
|
|
|
|
# error You shall not include this header directly
|
|
|
|
#endif
|
2013-04-24 12:56:24 -07:00
|
|
|
|
|
|
|
/**
|
|
|
|
* @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.
|
2014-01-05 16:25:15 -08:00
|
|
|
* @return @c EINA_TRUE if it got the focus, @c EINA_FALSE otherwise.
|
2013-04-24 12:56:24 -07:00
|
|
|
* @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.
|
|
|
|
*
|
2013-05-28 18:27:10 -07:00
|
|
|
* This function only returns EINA_TRUE when a frame will be rendered. If the
|
2013-04-24 12:56:24 -07:00
|
|
|
* 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);
|
|
|
|
/**
|
|
|
|
* @}
|
|
|
|
*/
|
|
|
|
|
|
|
|
/**
|
2013-05-28 18:27:10 -07:00
|
|
|
* Convert/scale an output screen co-ordinate into canvas co-ordinates
|
2013-04-24 12:56:24 -07:00
|
|
|
*
|
|
|
|
* @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);
|
|
|
|
|
|
|
|
/**
|
2013-05-28 18:27:10 -07:00
|
|
|
* Convert/scale an output screen co-ordinate into canvas co-ordinates
|
2013-04-24 12:56:24 -07:00
|
|
|
*
|
|
|
|
* @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
|
2013-05-28 18:27:10 -07:00
|
|
|
* and initial value (no flags). This lets you set the default flags that
|
2013-04-24 12:56:24 -07:00
|
|
|
* 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);
|
|
|
|
|
|
|
|
/**
|
2014-01-06 21:28:45 -08:00
|
|
|
* Get the default set of flags an event begins with
|
2013-04-24 12:56:24 -07:00
|
|
|
*
|
|
|
|
* @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.
|
2013-05-28 18:27:10 -07:00
|
|
|
* @return The number of presses (0 if none active).
|
2013-04-24 12:56:24 -07:00
|
|
|
*
|
|
|
|
* @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);
|
|
|
|
|
2013-05-03 11:43:31 -07:00
|
|
|
/**
|
|
|
|
* Mouse move event feed from input.
|
|
|
|
*
|
|
|
|
* @param e The given canvas pointer.
|
|
|
|
* @param x The horizontal position of the mouse pointer relative to the 0,0 of
|
|
|
|
* the window/surface.
|
|
|
|
* @param y The vertical position of the mouse pointer relative to the 0,0 of
|
|
|
|
* the window/surface.
|
|
|
|
* @param timestamp The timestamp of the mouse move event.
|
|
|
|
* @param data The data for canvas.
|
|
|
|
*
|
|
|
|
* Similar to the evas_event_feed_mouse_move(), this function will inform Evas
|
|
|
|
* about mouse move events which were received by the input system, relative to
|
|
|
|
* the 0,0 of the window, not to the canvas 0,0. It will take care of doing any
|
|
|
|
* special transformation like adding the framespace offset to the mouse event.
|
|
|
|
*
|
|
|
|
* @since 1.8
|
|
|
|
* @see evas_event_feed_mouse_move
|
|
|
|
*/
|
|
|
|
EAPI void evas_event_input_mouse_move(Evas *e, int x, int y, unsigned int timestamp, const void *data) EINA_ARG_NONNULL(1);
|
|
|
|
|
2013-04-24 12:56:24 -07:00
|
|
|
/**
|
|
|
|
* 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);
|
2013-05-07 13:53:42 -07:00
|
|
|
|
2013-04-24 12:56:24 -07:00
|
|
|
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);
|
|
|
|
|
2013-05-07 13:53:42 -07:00
|
|
|
EAPI void evas_event_input_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_input_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_input_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);
|
2013-04-24 12:56:24 -07:00
|
|
|
/**
|
|
|
|
* 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);
|
|
|
|
|
2014-04-14 06:38:58 -07:00
|
|
|
/**
|
|
|
|
* Key down event feed with keycode
|
|
|
|
*
|
|
|
|
* @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.
|
|
|
|
* @param keycode Key scan code numeric value 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.
|
|
|
|
*
|
|
|
|
* @since 1.10
|
|
|
|
*/
|
|
|
|
EAPI void evas_event_feed_key_down_with_keycode(Evas *e, const char *keyname, const char *key, const char *string, const char *compose, unsigned int timestamp, const void *data, unsigned int keycode) EINA_ARG_NONNULL(1);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Key up event feed with keycode
|
|
|
|
*
|
|
|
|
* @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.
|
|
|
|
* @param keycode Key scan code numeric value 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.
|
|
|
|
*
|
|
|
|
* @since 1.10
|
|
|
|
*/
|
|
|
|
EAPI void evas_event_feed_key_up_with_keycode(Evas *e, const char *keyname, const char *key, const char *string, const char *compose, unsigned int timestamp, const void *data, unsigned int keycode) EINA_ARG_NONNULL(1);
|
|
|
|
|
2013-04-24 12:56:24 -07:00
|
|
|
/**
|
|
|
|
* 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);
|
|
|
|
|
2013-10-12 20:55:28 -07:00
|
|
|
/**
|
|
|
|
* Retrieve a list of Evas objects lying over a given position in
|
|
|
|
* a canvas.
|
|
|
|
*
|
|
|
|
* @param e A handle to the canvas.
|
|
|
|
* @param stop An Evas Object where to stop searching.
|
|
|
|
* @param x The horizontal coordinate of the position.
|
|
|
|
* @param y The vertical coordinate of the 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. It will enter the smart objects.
|
|
|
|
* It will not append to the list pass events as hidden objects.
|
|
|
|
* Call eina_list_free on the returned list after usage.
|
|
|
|
*
|
|
|
|
*/
|
2014-01-06 18:27:15 -08:00
|
|
|
EAPI Eina_List *evas_tree_objects_at_xy_get(Evas *e, Evas_Object *stop, int x, int y) EINA_WARN_UNUSED_RESULT EINA_ARG_NONNULL(1);
|
2013-10-12 20:55:28 -07:00
|
|
|
|
2013-04-24 12:56:24 -07:00
|
|
|
/**
|
|
|
|
* @}
|
|
|
|
*/
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @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.
|
2014-01-06 21:28:45 -08:00
|
|
|
* @param maxw Pointer to hold the return value in pixels of the maximum width
|
2013-04-24 12:56:24 -07:00
|
|
|
* @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
|
|
|
|
*
|
|
|
|
* @{
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
* 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);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* 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);
|
|
|
|
|
2013-07-19 02:37:11 -07:00
|
|
|
/**
|
|
|
|
* Set the position and (rectangular) size of the given Evas object.
|
|
|
|
*
|
|
|
|
* @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.
|
|
|
|
* @param w The new width of the Evas object.
|
|
|
|
* @param h The new height of the Evas object.
|
|
|
|
*
|
|
|
|
* The position, naturally, will be relative to the top left corner of
|
|
|
|
* the canvas' viewport.
|
|
|
|
*
|
|
|
|
* If the object get moved, the object's ::EVAS_CALLBACK_MOVE callback
|
|
|
|
* will be called.
|
|
|
|
*
|
|
|
|
* If the object get resized, the object's ::EVAS_CALLBACK_RESIZE callback
|
|
|
|
* will be called.
|
|
|
|
*
|
|
|
|
* @see evas_object_move()
|
|
|
|
* @see evas_object_resize()
|
|
|
|
* @see evas_object_geometry_get
|
|
|
|
*
|
|
|
|
* @since 1.8
|
|
|
|
* @ingroup Evas_Object_Group_Basic
|
|
|
|
*/
|
2014-01-05 16:25:15 -08:00
|
|
|
EAPI void evas_object_geometry_set(Evas_Object *obj, Evas_Coord x, Evas_Coord y, Evas_Coord w, Evas_Coord h) EINA_ARG_NONNULL(1);
|
2013-07-19 02:37:11 -07:00
|
|
|
|
|
|
|
|
2013-04-24 12:56:24 -07:00
|
|
|
/**
|
|
|
|
* 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);
|
|
|
|
|
|
|
|
|
2014-04-02 03:46:36 -07:00
|
|
|
#include "canvas/evas_common_interface.eo.legacy.h"
|
2014-04-02 06:15:28 -07:00
|
|
|
#include "canvas/evas_object.eo.legacy.h"
|
2013-04-24 12:56:24 -07:00
|
|
|
|
|
|
|
/**
|
|
|
|
* @}
|
|
|
|
*/
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @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
|
2014-04-03 05:14:46 -07:00
|
|
|
* non-default priority set. Except for thg
|
2013-04-24 12:56:24 -07:00
|
|
|
* 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);
|
|
|
|
|
2014-04-02 06:15:28 -07:00
|
|
|
|
|
|
|
/**
|
|
|
|
* @}
|
|
|
|
*/
|
|
|
|
|
2013-04-24 12:56:24 -07:00
|
|
|
/**
|
2014-04-02 06:15:28 -07:00
|
|
|
* @ingroup Evas_Object_Group_Map
|
2013-04-24 12:56:24 -07:00
|
|
|
*
|
|
|
|
* @{
|
|
|
|
*/
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @}
|
|
|
|
*/
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @ingroup Evas_Object_Group_Size_Hints
|
|
|
|
*
|
|
|
|
* @{
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @}
|
|
|
|
*/
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @ingroup Evas_Object_Group_Extras
|
|
|
|
*
|
|
|
|
* @{
|
|
|
|
*/
|
|
|
|
|
|
|
|
/**
|
2014-04-02 06:15:28 -07:00
|
|
|
* Set an attached data pointer to an object with a given string key.
|
2013-04-24 12:56:24 -07:00
|
|
|
*
|
2014-04-02 06:15:28 -07:00
|
|
|
* @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
|
2013-04-24 12:56:24 -07:00
|
|
|
*
|
2014-04-02 06:15:28 -07:00
|
|
|
* 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.
|
2013-04-24 12:56:24 -07:00
|
|
|
*
|
2014-04-02 06:15:28 -07:00
|
|
|
* 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.
|
2013-04-24 12:56:24 -07:00
|
|
|
*
|
2014-04-02 06:15:28 -07:00
|
|
|
* 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.
|
2013-04-24 12:56:24 -07:00
|
|
|
*
|
2014-04-02 06:15:28 -07:00
|
|
|
* @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.
|
2013-04-24 12:56:24 -07:00
|
|
|
*
|
2014-04-02 06:15:28 -07:00
|
|
|
* Example:
|
2013-04-24 12:56:24 -07:00
|
|
|
*
|
2014-04-02 06:15:28 -07:00
|
|
|
* @code
|
|
|
|
* int *my_data;
|
|
|
|
* extern Evas_Object *obj;
|
2013-04-24 12:56:24 -07:00
|
|
|
*
|
2014-04-02 06:15:28 -07:00
|
|
|
* 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
|
2013-04-24 12:56:24 -07:00
|
|
|
*/
|
2014-04-02 06:15:28 -07:00
|
|
|
EAPI void evas_object_data_set(Evas_Object *obj, const char *key, const void *data) EINA_ARG_NONNULL(1, 2);
|
2013-04-24 12:56:24 -07:00
|
|
|
|
|
|
|
/**
|
2014-04-02 06:15:28 -07:00
|
|
|
* 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
|
2013-04-24 12:56:24 -07:00
|
|
|
*
|
2014-04-02 06:15:28 -07:00
|
|
|
* 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.
|
2013-04-24 12:56:24 -07:00
|
|
|
*
|
2014-04-02 06:15:28 -07:00
|
|
|
* Example:
|
2013-04-24 12:56:24 -07:00
|
|
|
*
|
2014-04-02 06:15:28 -07:00
|
|
|
* @code
|
|
|
|
* int *my_data;
|
|
|
|
* extern Evas_Object *obj;
|
2013-04-24 12:56:24 -07:00
|
|
|
*
|
2014-04-02 06:15:28 -07:00
|
|
|
* 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
|
2013-04-24 12:56:24 -07:00
|
|
|
*/
|
2014-04-02 06:15:28 -07:00
|
|
|
EAPI void *evas_object_data_get(const Evas_Object *obj, const char *key) EINA_WARN_UNUSED_RESULT EINA_ARG_NONNULL(1, 2);
|
2013-04-24 12:56:24 -07:00
|
|
|
|
|
|
|
/**
|
2014-04-02 06:15:28 -07:00
|
|
|
* Delete an attached data pointer from an object.
|
2013-04-24 12:56:24 -07:00
|
|
|
*
|
2014-04-02 06:15:28 -07:00
|
|
|
* @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
|
2013-04-24 12:56:24 -07:00
|
|
|
*
|
2014-04-02 06:15:28 -07:00
|
|
|
* 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.
|
2013-04-24 12:56:24 -07:00
|
|
|
*
|
2014-04-02 06:15:28 -07:00
|
|
|
* Example:
|
|
|
|
*
|
|
|
|
* @code
|
|
|
|
* int *my_data;
|
|
|
|
* extern Evas_Object *obj;
|
|
|
|
*
|
|
|
|
* my_data = evas_object_data_del(obj, "name_of_my_data");
|
|
|
|
* @endcode
|
2013-04-24 12:56:24 -07:00
|
|
|
*/
|
2014-04-02 06:15:28 -07:00
|
|
|
EAPI void *evas_object_data_del(Evas_Object *obj, const char *key) EINA_ARG_NONNULL(1, 2);
|
|
|
|
|
2013-04-24 12:56:24 -07:00
|
|
|
/**
|
|
|
|
* @}
|
|
|
|
*/
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @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);
|
2013-08-28 19:21:20 -07:00
|
|
|
EAPI void evas_object_intercept_focus_set_callback_add(Evas_Object *obj, Evas_Object_Intercept_Focus_Set_Cb func, const void *data) EINA_ARG_NONNULL(1, 2);
|
|
|
|
EAPI void *evas_object_intercept_focus_set_callback_del(Evas_Object *obj, Evas_Object_Intercept_Focus_Set_Cb func) EINA_ARG_NONNULL(1, 2);
|
|
|
|
|
2013-04-24 12:56:24 -07:00
|
|
|
/**
|
|
|
|
* @}
|
|
|
|
*/
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @ingroup Evas_Object_Rectangle
|
|
|
|
*
|
|
|
|
* @{
|
|
|
|
*/
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Adds a rectangle to the given evas.
|
|
|
|
* @param e The given evas.
|
|
|
|
* @return The new rectangle object.
|
|
|
|
*
|
|
|
|
* @ingroup Evas_Object_Rectangle
|
|
|
|
*/
|
|
|
|
EAPI Evas_Object *evas_object_rectangle_add(Evas *e) EINA_WARN_UNUSED_RESULT EINA_ARG_NONNULL(1) EINA_MALLOC;
|
|
|
|
|
2014-03-31 04:54:02 -07:00
|
|
|
#include "canvas/evas_rectangle.eo.legacy.h"
|
2013-04-24 12:56:24 -07:00
|
|
|
/**
|
|
|
|
* @}
|
|
|
|
*/
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @ingroup Evas_Object_Image
|
|
|
|
*
|
|
|
|
* @{
|
|
|
|
*/
|
|
|
|
/**
|
|
|
|
* Creates a new image object on the given Evas @p e canvas.
|
|
|
|
*
|
|
|
|
* @param e The given canvas.
|
|
|
|
* @return The created image object handle.
|
|
|
|
*
|
|
|
|
* @note If you intend to @b display an image somehow in a GUI,
|
|
|
|
* besides binding it to a real image file/source (with
|
|
|
|
* evas_object_image_file_set(), for example), you'll have to tell
|
|
|
|
* this image object how to fill its space with the pixels it can get
|
|
|
|
* from the source. See evas_object_image_filled_add(), for a helper
|
|
|
|
* on the common case of scaling up an image source to the whole area
|
|
|
|
* of the image object.
|
|
|
|
*
|
|
|
|
* @see evas_object_image_fill_set()
|
|
|
|
*
|
|
|
|
* Example:
|
|
|
|
* @code
|
|
|
|
* img = evas_object_image_add(canvas);
|
|
|
|
* evas_object_image_file_set(img, "/path/to/img", NULL);
|
|
|
|
* @endcode
|
|
|
|
*/
|
|
|
|
EAPI Evas_Object *evas_object_image_add(Evas *e) EINA_WARN_UNUSED_RESULT EINA_ARG_NONNULL(1) EINA_MALLOC;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Creates a new image object that @b automatically scales its bound
|
|
|
|
* image to the object's area, on both axis.
|
|
|
|
*
|
|
|
|
* @param e The given canvas.
|
|
|
|
* @return The created image object handle.
|
|
|
|
*
|
|
|
|
* This is a helper function around evas_object_image_add() and
|
|
|
|
* evas_object_image_filled_set(). It has the same effect of applying
|
|
|
|
* those functions in sequence, which is a very common use case.
|
|
|
|
*
|
|
|
|
* @note Whenever this object gets resized, the bound image will be
|
|
|
|
* rescaled, too.
|
|
|
|
*
|
|
|
|
* @see evas_object_image_add()
|
|
|
|
* @see evas_object_image_filled_set()
|
|
|
|
* @see evas_object_image_fill_set()
|
|
|
|
*/
|
|
|
|
EAPI Evas_Object *evas_object_image_filled_add(Evas *e) EINA_WARN_UNUSED_RESULT EINA_ARG_NONNULL(1) EINA_MALLOC;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Sets the data for an image from memory to be loaded
|
|
|
|
*
|
|
|
|
* This is the same as evas_object_image_file_set() but the file to be loaded
|
|
|
|
* may exist at an address in memory (the data for the file, not the filename
|
|
|
|
* itself). The @p data at the address is copied and stored for future use, so
|
|
|
|
* no @p data needs to be kept after this call is made. It will be managed and
|
|
|
|
* freed for you when no longer needed. The @p size is limited to 2 gigabytes
|
|
|
|
* in size, and must be greater than 0. A @c NULL @p data pointer is also
|
|
|
|
* invalid. Set the filename to @c NULL to reset to empty state and have the
|
|
|
|
* image file data freed from memory using evas_object_image_file_set().
|
|
|
|
*
|
|
|
|
* The @p format is optional (pass @c NULL if you don't need/use it). It is
|
|
|
|
* used to help Evas guess better which loader to use for the data. It may
|
|
|
|
* simply be the "extension" of the file as it would normally be on disk
|
|
|
|
* such as "jpg" or "png" or "gif" etc.
|
|
|
|
*
|
|
|
|
* @param obj The given image object.
|
|
|
|
* @param data The image file data address
|
|
|
|
* @param size The size of the image file data in bytes
|
|
|
|
* @param format The format of the file (optional), or @c NULL if not needed
|
|
|
|
* @param key The image key in file, or @c NULL.
|
|
|
|
*/
|
|
|
|
EAPI void evas_object_image_memfile_set(Evas_Object *obj, void *data, int size, char *format, char *key) EINA_ARG_NONNULL(1, 2);
|
|
|
|
|
|
|
|
/**
|
2014-04-03 04:07:33 -07:00
|
|
|
* Set the native surface of a given image of the canvas
|
2013-04-24 12:56:24 -07:00
|
|
|
*
|
2014-04-03 04:07:33 -07:00
|
|
|
* @param obj The given canvas pointer.
|
|
|
|
* @param surf The new native surface.
|
2013-04-24 12:56:24 -07:00
|
|
|
*
|
2014-04-03 04:07:33 -07:00
|
|
|
* This function sets a native surface of a given canvas image.
|
2013-04-24 12:56:24 -07:00
|
|
|
*
|
|
|
|
*/
|
2014-04-03 04:07:33 -07:00
|
|
|
EAPI void evas_object_image_native_surface_set(Evas_Object *obj, Evas_Native_Surface *surf) EINA_ARG_NONNULL(1, 2);
|
2013-04-24 12:56:24 -07:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Preload an image object's image data in the background
|
|
|
|
*
|
|
|
|
* @param obj The given image object.
|
|
|
|
* @param cancel @c EINA_FALSE will add it the preloading work queue,
|
|
|
|
* @c EINA_TRUE will remove it (if it was issued before).
|
|
|
|
*
|
|
|
|
* This function requests the preload of the data image in the
|
|
|
|
* background. The work is queued before being processed (because
|
|
|
|
* there might be other pending requests of this type).
|
|
|
|
*
|
|
|
|
* Whenever the image data gets loaded, Evas will call
|
|
|
|
* #EVAS_CALLBACK_IMAGE_PRELOADED registered callbacks on @p obj (what
|
|
|
|
* may be immediately, if the data was already preloaded before).
|
|
|
|
*
|
|
|
|
* Use @c EINA_TRUE for @p cancel on scenarios where you don't need
|
|
|
|
* the image data preloaded anymore.
|
|
|
|
*
|
|
|
|
* @note Any evas_object_show() call after evas_object_image_preload()
|
|
|
|
* will make the latter to be @b cancelled, with the loading process
|
|
|
|
* now taking place @b synchronously (and, thus, blocking the return
|
|
|
|
* of the former until the image is loaded). It is highly advisable,
|
|
|
|
* then, that the user preload an image with it being @b hidden, just
|
|
|
|
* to be shown on the #EVAS_CALLBACK_IMAGE_PRELOADED event's callback.
|
|
|
|
*/
|
|
|
|
EAPI void evas_object_image_preload(Evas_Object *obj, Eina_Bool cancel) EINA_ARG_NONNULL(1);
|
|
|
|
|
|
|
|
/**
|
2014-04-03 04:07:33 -07:00
|
|
|
* Clear the source object on a proxy image object.
|
2013-04-24 12:56:24 -07:00
|
|
|
*
|
2014-04-03 04:07:33 -07:00
|
|
|
* @param obj Image object to clear source of.
|
|
|
|
* @return @c EINA_TRUE on success, @c EINA_FALSE on error.
|
2013-04-24 12:56:24 -07:00
|
|
|
*
|
2014-04-03 04:07:33 -07:00
|
|
|
* This is equivalent to calling evas_object_image_source_set() with a
|
|
|
|
* @c NULL source.
|
2013-04-24 12:56:24 -07:00
|
|
|
*/
|
2014-04-03 04:07:33 -07:00
|
|
|
EAPI Eina_Bool evas_object_image_source_unset(Evas_Object *obj) EINA_ARG_NONNULL(1);
|
2013-04-24 12:56:24 -07:00
|
|
|
|
|
|
|
/**
|
2014-04-03 04:07:33 -07:00
|
|
|
* Enable an image to be used as an alpha mask.
|
2013-04-24 12:56:24 -07:00
|
|
|
*
|
2014-04-03 04:07:33 -07:00
|
|
|
* This will set any flags, and discard any excess image data not used as an
|
|
|
|
* alpha mask.
|
2013-04-24 12:56:24 -07:00
|
|
|
*
|
2014-04-03 04:07:33 -07:00
|
|
|
* Note there is little point in using a image as alpha mask unless it has an
|
|
|
|
* alpha channel.
|
2013-04-24 12:56:24 -07:00
|
|
|
*
|
2014-04-03 04:07:33 -07:00
|
|
|
* @param obj Object to use as an alpha mask.
|
|
|
|
* @param ismask Use image as alphamask, must be true.
|
2013-04-24 12:56:24 -07:00
|
|
|
*/
|
2014-04-03 04:07:33 -07:00
|
|
|
EAPI void evas_object_image_alpha_mask_set(Evas_Object *obj, Eina_Bool ismask) EINA_ARG_NONNULL(1);
|
2013-04-24 12:56:24 -07:00
|
|
|
|
2014-04-03 04:07:33 -07:00
|
|
|
#include "canvas/evas_image.eo.legacy.h"
|
2013-04-24 12:56:24 -07:00
|
|
|
|
|
|
|
/**
|
|
|
|
* @}
|
|
|
|
*/
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @ingroup Evas_Object_Text
|
|
|
|
*
|
|
|
|
* @{
|
|
|
|
*/
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Creates a new text object on the provided canvas.
|
|
|
|
*
|
|
|
|
* @param e The canvas to create the text object on.
|
|
|
|
* @return @c NULL on error, a pointer to a new text object on
|
|
|
|
* success.
|
|
|
|
*
|
|
|
|
* Text objects are for simple, single line text elements. If you want
|
|
|
|
* more elaborated text blocks, see @ref Evas_Object_Textblock.
|
|
|
|
*
|
|
|
|
* @see evas_object_text_font_source_set()
|
|
|
|
* @see evas_object_text_font_set()
|
|
|
|
* @see evas_object_text_text_set()
|
|
|
|
*/
|
|
|
|
EAPI Evas_Object *evas_object_text_add(Evas *e) EINA_WARN_UNUSED_RESULT EINA_ARG_NONNULL(1) EINA_MALLOC;
|
|
|
|
|
2014-04-01 00:10:29 -07:00
|
|
|
#include "canvas/evas_text.eo.legacy.h"
|
2013-04-24 12:56:24 -07:00
|
|
|
|
|
|
|
/**
|
|
|
|
* @}
|
|
|
|
*/
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @ingroup Evas_Object_Textblock
|
|
|
|
*
|
|
|
|
* @{
|
|
|
|
*/
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Adds a textblock to the given evas.
|
|
|
|
* @param e The given evas.
|
|
|
|
* @return The new textblock object.
|
|
|
|
*/
|
|
|
|
EAPI Evas_Object *evas_object_textblock_add(Evas *e) EINA_WARN_UNUSED_RESULT EINA_ARG_NONNULL(1) EINA_MALLOC;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Return the plain version of the markup.
|
|
|
|
*
|
|
|
|
* Works as if you set the markup to a textblock and then retrieve the plain
|
|
|
|
* version of the text. i.e: <br> and <\n> will be replaced with \n, &...; with
|
|
|
|
* the actual char and etc.
|
|
|
|
*
|
|
|
|
* @param obj The textblock object to work with. (if @c NULL, tries the
|
|
|
|
* default).
|
|
|
|
* @param text The markup text (if @c NULL, return @c NULL).
|
|
|
|
* @return An allocated plain text version of the markup.
|
|
|
|
* @since 1.2
|
|
|
|
*/
|
|
|
|
EAPI char *evas_textblock_text_markup_to_utf8(const Evas_Object *obj, const char *text) EINA_WARN_UNUSED_RESULT EINA_MALLOC;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Return the markup version of the plain text.
|
|
|
|
*
|
|
|
|
* Replaces \\n -\> \<br/\> \\t -\> \<tab/\> and etc. Generally needed before you pass
|
|
|
|
* plain text to be set in a textblock.
|
|
|
|
*
|
|
|
|
* @param obj the textblock object to work with (if @c NULL, it just does the
|
|
|
|
* default behaviour, i.e with no extra object information).
|
2014-03-27 04:25:44 -07:00
|
|
|
* @param text The plain text (if @c NULL, return @c NULL).
|
|
|
|
* @return An allocated markup version of the plain text.
|
2013-04-24 12:56:24 -07:00
|
|
|
* @since 1.2
|
|
|
|
*/
|
|
|
|
EAPI char *evas_textblock_text_utf8_to_markup(const Evas_Object *obj, const char *text) EINA_WARN_UNUSED_RESULT EINA_MALLOC;
|
|
|
|
|
2014-03-31 04:54:02 -07:00
|
|
|
#include "canvas/evas_textblock.eo.legacy.h"
|
2013-04-24 12:56:24 -07:00
|
|
|
|
|
|
|
/**
|
|
|
|
* @}
|
|
|
|
*/
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @ingroup Evas_Object_Grid
|
|
|
|
*
|
|
|
|
* @{
|
|
|
|
*/
|
|
|
|
/**
|
|
|
|
* @brief Add a textgrid to the given Evas.
|
|
|
|
*
|
|
|
|
* @param e The given evas.
|
|
|
|
* @return The new textgrid object.
|
|
|
|
*
|
|
|
|
* This function adds a new textgrid object to the Evas @p e and returns the object.
|
|
|
|
*
|
|
|
|
* @since 1.7
|
|
|
|
*/
|
|
|
|
EAPI Evas_Object *evas_object_textgrid_add(Evas *e);
|
|
|
|
|
2014-03-31 04:54:02 -07:00
|
|
|
#include "canvas/evas_textgrid.eo.legacy.h"
|
2013-04-24 12:56:24 -07:00
|
|
|
|
|
|
|
/**
|
|
|
|
* @}
|
|
|
|
*/
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @ingroup Evas_Object_Line
|
|
|
|
*
|
|
|
|
* @{
|
|
|
|
*/
|
|
|
|
/**
|
|
|
|
* Adds a new evas line object to the given evas.
|
|
|
|
* @param e The given evas.
|
|
|
|
* @return The new evas line object.
|
|
|
|
*/
|
|
|
|
EAPI Evas_Object *evas_object_line_add(Evas *e) EINA_WARN_UNUSED_RESULT EINA_ARG_NONNULL(1) EINA_MALLOC;
|
|
|
|
|
2014-03-31 04:54:02 -07:00
|
|
|
#include "canvas/evas_line.eo.legacy.h"
|
2013-04-24 12:56:24 -07:00
|
|
|
|
|
|
|
/**
|
|
|
|
* @}
|
|
|
|
*/
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @ingroup Evas_Object_Polygon
|
|
|
|
*
|
|
|
|
* @{
|
|
|
|
*/
|
|
|
|
/**
|
|
|
|
* Adds a new evas polygon object to the given evas.
|
|
|
|
* @param e The given evas.
|
|
|
|
* @return A new evas polygon object.
|
|
|
|
*/
|
|
|
|
EAPI Evas_Object *evas_object_polygon_add(Evas *e) EINA_WARN_UNUSED_RESULT EINA_ARG_NONNULL(1) EINA_MALLOC;
|
|
|
|
|
2014-03-31 04:54:02 -07:00
|
|
|
#include "canvas/evas_polygon.eo.legacy.h"
|
2013-04-24 12:56:24 -07:00
|
|
|
/**
|
|
|
|
* @}
|
|
|
|
*/
|
|
|
|
|
|
|
|
/* @since 1.2 */
|
2014-04-02 06:15:28 -07:00
|
|
|
//EAPI void evas_object_is_frame_object_set(Evas_Object *obj, Eina_Bool is_frame);
|
2013-04-24 12:56:24 -07:00
|
|
|
|
|
|
|
/* @since 1.2 */
|
2014-04-02 06:15:28 -07:00
|
|
|
//EAPI Eina_Bool evas_object_is_frame_object_get(const Evas_Object *obj);
|
2013-04-24 12:56:24 -07:00
|
|
|
|
|
|
|
/**
|
|
|
|
* @}
|
|
|
|
*/
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @ingroup Evas_Group_Smart
|
|
|
|
*
|
|
|
|
* @{
|
|
|
|
*/
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @}
|
|
|
|
*/
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @ingroup Evas_Smart_Object_Group
|
|
|
|
*
|
|
|
|
* @{
|
|
|
|
*/
|
|
|
|
/**
|
|
|
|
* Instantiates a new smart object described by @p s.
|
|
|
|
*
|
|
|
|
* @param e the canvas on which to add the object
|
|
|
|
* @param s the #Evas_Smart describing the smart object
|
|
|
|
* @return a new #Evas_Object handle
|
|
|
|
*
|
|
|
|
* This is the function one should use when defining the public
|
|
|
|
* function @b adding an instance of the new smart object to a given
|
|
|
|
* canvas. It will take care of setting all of its internals to work
|
|
|
|
* as they should, if the user set things properly, as seem on the
|
|
|
|
* #EVAS_SMART_SUBCLASS_NEW, for example.
|
|
|
|
*
|
|
|
|
* @ingroup Evas_Smart_Object_Group
|
|
|
|
*/
|
|
|
|
EAPI Evas_Object *evas_object_smart_add(Evas *e, Evas_Smart *s) EINA_WARN_UNUSED_RESULT EINA_ARG_NONNULL(1, 2) EINA_MALLOC;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Set an Evas object as a member of a given smart object.
|
|
|
|
*
|
|
|
|
* @param obj The member object
|
|
|
|
* @param smart_obj The smart object
|
|
|
|
*
|
|
|
|
* Members will automatically be stacked and layered together with the
|
|
|
|
* smart object. The various stacking functions will operate on
|
|
|
|
* members relative to the other members instead of the entire canvas,
|
|
|
|
* since they now live on an exclusive layer (see
|
|
|
|
* evas_object_stack_above(), for more details).
|
|
|
|
*
|
|
|
|
* Any @p smart_obj object's specific implementation of the @c
|
|
|
|
* member_add() smart function will take place too, naturally.
|
|
|
|
*
|
|
|
|
* @see evas_object_smart_member_del()
|
|
|
|
* @see evas_object_smart_members_get()
|
|
|
|
*
|
|
|
|
* @ingroup Evas_Smart_Object_Group
|
|
|
|
*/
|
|
|
|
EAPI void evas_object_smart_member_add(Evas_Object *obj, Evas_Object *smart_obj) EINA_ARG_NONNULL(1, 2);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Removes a member object from a given smart object.
|
|
|
|
*
|
|
|
|
* @param obj the member object
|
|
|
|
* @ingroup Evas_Smart_Object_Group
|
|
|
|
*
|
|
|
|
* This removes a member object from a smart object, if it was added
|
|
|
|
* to any. The object will still be on the canvas, but no longer
|
|
|
|
* associated with whichever smart object it was associated with.
|
|
|
|
*
|
|
|
|
* @see evas_object_smart_member_add() for more details
|
|
|
|
* @see evas_object_smart_members_get()
|
|
|
|
*/
|
|
|
|
EAPI void evas_object_smart_member_del(Evas_Object *obj) EINA_ARG_NONNULL(1);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Add (register) a callback function to the smart event specified by
|
|
|
|
* @p event on the smart object @p obj.
|
|
|
|
*
|
|
|
|
* @param obj a smart object
|
|
|
|
* @param event the event's name string
|
|
|
|
* @param func the callback function
|
|
|
|
* @param data user data to be passed to the callback function
|
|
|
|
*
|
|
|
|
* Smart callbacks look very similar to Evas callbacks, but are
|
|
|
|
* implemented as smart object's custom ones.
|
|
|
|
*
|
|
|
|
* This function adds a function callback to an smart object when the
|
|
|
|
* event named @p event occurs in it. 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 smart callback function must have the ::Evas_Smart_Cb prototype
|
|
|
|
* definition. The first parameter (@p data) in this definition will
|
|
|
|
* have the same value passed to evas_object_smart_callback_add() as
|
|
|
|
* the @p data parameter, at runtime. The second parameter @p obj is a
|
|
|
|
* handle to the object on which the event occurred. The third
|
|
|
|
* parameter, @p event_info, is a pointer to data which is totally
|
|
|
|
* dependent on the smart object's implementation and semantic for the
|
|
|
|
* given event.
|
|
|
|
*
|
|
|
|
* There is an infrastructure for introspection on smart objects'
|
|
|
|
* events (see evas_smart_callbacks_descriptions_get()), but no
|
|
|
|
* internal smart objects on Evas implement them yet.
|
|
|
|
*
|
|
|
|
* @see @ref Evas_Smart_Object_Group_Callbacks for more details.
|
|
|
|
*
|
|
|
|
* @see evas_object_smart_callback_del()
|
|
|
|
* @ingroup Evas_Smart_Object_Group
|
|
|
|
*/
|
|
|
|
EAPI void evas_object_smart_callback_add(Evas_Object *obj, const char *event, Evas_Smart_Cb func, const void *data) EINA_ARG_NONNULL(1, 2, 3);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Add (register) a callback function to the smart event specified by
|
|
|
|
* @p event on the smart object @p obj. Except for the priority field,
|
|
|
|
* it's exactly the same as @ref evas_object_smart_callback_add
|
|
|
|
*
|
|
|
|
* @param obj a smart object
|
|
|
|
* @param event the event's name string
|
|
|
|
* @param priority The priority of the callback, lower values called first.
|
|
|
|
* @param func the callback function
|
|
|
|
* @param data user data to be passed to the callback function
|
|
|
|
*
|
|
|
|
* @see evas_object_smart_callback_add
|
|
|
|
* @since 1.1
|
|
|
|
* @ingroup Evas_Smart_Object_Group
|
|
|
|
*/
|
|
|
|
EAPI void evas_object_smart_callback_priority_add(Evas_Object *obj, const char *event, Evas_Callback_Priority priority, Evas_Smart_Cb func, const void *data);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Delete (unregister) a callback function from the smart event
|
|
|
|
* specified by @p event on the smart object @p obj.
|
|
|
|
*
|
|
|
|
* @param obj a smart object
|
|
|
|
* @param event the event's name string
|
|
|
|
* @param func the callback function
|
|
|
|
* @return the data pointer
|
|
|
|
*
|
|
|
|
* This function removes <b>the first</b> added smart callback on the
|
|
|
|
* object @p obj matching the event name @p event and the registered
|
|
|
|
* function pointer @p func. If the removal is successful it will also
|
|
|
|
* return the data pointer that was passed to
|
|
|
|
* evas_object_smart_callback_add() (that will be the same as the
|
|
|
|
* parameter) when the callback(s) was(were) added to the canvas. If
|
|
|
|
* not successful @c NULL will be returned.
|
|
|
|
*
|
|
|
|
* @see evas_object_smart_callback_add() for more details.
|
|
|
|
*
|
|
|
|
* @ingroup Evas_Smart_Object_Group
|
|
|
|
*/
|
|
|
|
EAPI void *evas_object_smart_callback_del(Evas_Object *obj, const char *event, Evas_Smart_Cb func) EINA_ARG_NONNULL(1, 2, 3);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Delete (unregister) a callback function from the smart event
|
|
|
|
* specified by @p event on the smart object @p obj.
|
|
|
|
*
|
|
|
|
* @param obj a smart object
|
|
|
|
* @param event the event's name string
|
|
|
|
* @param func the callback function
|
|
|
|
* @param data the data pointer that was passed to the callback
|
|
|
|
* @return the data pointer
|
|
|
|
*
|
|
|
|
* This function removes <b>the first</b> added smart callback on the
|
|
|
|
* object @p obj matching the event name @p event, 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_object_smart_callback_add() (that will be the same
|
|
|
|
* as the parameter) when the callback(s) was(were) added to the canvas.
|
|
|
|
* If not successful @c NULL will be returned. A common use would be to
|
|
|
|
* remove an exact match of a callback
|
|
|
|
*
|
|
|
|
* @see evas_object_smart_callback_add() for more details.
|
|
|
|
* @since 1.2
|
|
|
|
* @ingroup Evas_Smart_Object_Group
|
|
|
|
*
|
|
|
|
* @note To delete all smart event callbacks which match @p type and @p func,
|
|
|
|
* use evas_object_smart_callback_del().
|
|
|
|
*/
|
|
|
|
EAPI void *evas_object_smart_callback_del_full(Evas_Object *obj, const char *event, Evas_Smart_Cb func, const void *data) EINA_ARG_NONNULL(1, 2, 3);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Call a given smart callback on the smart object @p obj.
|
|
|
|
*
|
|
|
|
* @param obj the smart object
|
|
|
|
* @param event the event's name string
|
|
|
|
* @param event_info pointer to an event specific struct or information to
|
|
|
|
* pass to the callback functions registered on this smart event
|
|
|
|
*
|
|
|
|
* This should be called @b internally, from the smart object's own
|
|
|
|
* code, when some specific event has occurred and the implementor
|
|
|
|
* wants is to pertain to the object's events API (see @ref
|
|
|
|
* Evas_Smart_Object_Group_Callbacks). The documentation for the smart
|
|
|
|
* object should include a list of possible events and what type of @p
|
|
|
|
* event_info to expect for each of them. Also, when defining an
|
|
|
|
* #Evas_Smart_Class, smart object implementors are strongly
|
|
|
|
* encouraged to properly set the Evas_Smart_Class::callbacks
|
|
|
|
* callbacks description array, so that the users of the smart object
|
|
|
|
* can have introspection on its events API <b>at run time</b>.
|
|
|
|
*
|
|
|
|
* @ingroup Evas_Smart_Object_Group
|
|
|
|
*/
|
|
|
|
EAPI void evas_object_smart_callback_call(Evas_Object *obj, const char *event, void *event_info) EINA_ARG_NONNULL(1, 2);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Retrieve an Evas smart object's interface, by name string pointer.
|
|
|
|
*
|
|
|
|
* @param obj An Evas smart object.
|
|
|
|
* @param name Name string of the desired interface, which must be the
|
|
|
|
* same pointer used at the interface's declarion, when
|
|
|
|
* creating the smart object @a obj.
|
|
|
|
*
|
|
|
|
* @since 1.7
|
|
|
|
*
|
|
|
|
* @return The interface's handle pointer, if found, @c NULL
|
|
|
|
* otherwise.
|
|
|
|
*/
|
2014-04-02 00:27:36 -07:00
|
|
|
EAPI const void *evas_object_smart_interface_get(const Evas_Object *obj, const char *name);
|
2013-04-24 12:56:24 -07:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Retrieve an Evas smart object interface's <b>private data</b>.
|
|
|
|
*
|
|
|
|
* @param obj An Evas smart object.
|
|
|
|
* @param iface The given object's interface handle.
|
|
|
|
*
|
|
|
|
* @since 1.7
|
|
|
|
*
|
|
|
|
* @return The object interface's private data blob pointer, if found,
|
|
|
|
* @c NULL otherwise.
|
|
|
|
*/
|
2014-04-02 00:27:36 -07:00
|
|
|
EAPI void *evas_object_smart_interface_data_get(const Evas_Object *obj, const Evas_Smart_Interface *iface);
|
2013-04-24 12:56:24 -07:00
|
|
|
|
|
|
|
/**
|
|
|
|
* This gets the internal counter that counts the number of smart calculations
|
|
|
|
*
|
|
|
|
* @param e The canvas to get the calculate counter from
|
|
|
|
*
|
|
|
|
* Whenever evas performs smart object calculations on the whole canvas
|
|
|
|
* it increments a counter by 1. This is the smart object calculate counter
|
|
|
|
* that this function returns the value of. It starts at the value of 0 and
|
|
|
|
* will increase (and eventually wrap around to negative values and so on) by
|
|
|
|
* 1 every time objects are calculated. You can use this counter to ensure
|
|
|
|
* you don't re-do calculations withint the same calculation generation/run
|
|
|
|
* if the calculations maybe cause self-feeding effects.
|
|
|
|
*
|
|
|
|
* @ingroup Evas_Smart_Object_Group
|
|
|
|
* @since 1.1
|
|
|
|
*/
|
|
|
|
EAPI int evas_smart_objects_calculate_count_get(const Evas *e);
|
|
|
|
|
2014-04-02 00:27:36 -07:00
|
|
|
#include "canvas/evas_smart.eo.legacy.h"
|
2013-04-24 12:56:24 -07:00
|
|
|
/**
|
|
|
|
* @}
|
|
|
|
*/
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @ingroup Evas_Smart_Object_Clipped
|
|
|
|
*
|
|
|
|
* @{
|
|
|
|
*/
|
|
|
|
/**
|
|
|
|
* Get the clipper object for the given clipped smart object.
|
|
|
|
*
|
|
|
|
* @param obj the clipped smart object to retrieve associated clipper
|
|
|
|
* from.
|
|
|
|
* @return the clipper object.
|
|
|
|
*
|
|
|
|
* Use this function if you want to change any of this clipper's
|
|
|
|
* properties, like colors.
|
|
|
|
*
|
|
|
|
* @see evas_object_smart_clipped_smart_add()
|
|
|
|
*/
|
2014-03-11 04:51:35 -07:00
|
|
|
EAPI Evas_Object *evas_object_smart_clipped_clipper_get(const Evas_Object *obj) EINA_WARN_UNUSED_RESULT EINA_ARG_NONNULL(1);
|
2013-04-24 12:56:24 -07:00
|
|
|
|
2014-04-02 00:27:36 -07:00
|
|
|
#include "canvas/evas_smart_clipped.eo.legacy.h"
|
2013-04-24 12:56:24 -07:00
|
|
|
/**
|
|
|
|
* @}
|
|
|
|
*/
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @ingroup Evas_Object_Box
|
|
|
|
*
|
|
|
|
* @{
|
|
|
|
*/
|
2014-04-03 05:14:46 -07:00
|
|
|
|
|
|
|
/**
|
2013-04-24 12:56:24 -07:00
|
|
|
* Add a new box object on the provided canvas.
|
|
|
|
*
|
|
|
|
* @param evas The canvas to create the box object on.
|
|
|
|
* @return @c NULL on error, a pointer to a new box object on
|
|
|
|
* success.
|
|
|
|
*
|
|
|
|
* After instantiation, if a box object hasn't its layout function
|
|
|
|
* set, via evas_object_box_layout_set(), it will have it by default
|
|
|
|
* set to evas_object_box_layout_horizontal(). The remaining
|
|
|
|
* properties of the box must be set/retrieved via
|
|
|
|
* <c>evas_object_box_{h,v}_{align,padding}_{get,set)()</c>.
|
|
|
|
*/
|
|
|
|
EAPI Evas_Object *evas_object_box_add(Evas *evas) EINA_WARN_UNUSED_RESULT EINA_ARG_NONNULL(1) EINA_MALLOC;
|
|
|
|
|
|
|
|
/**
|
2014-04-03 05:14:46 -07:00
|
|
|
* Get a property's value (by its given numerical identifier), on a
|
|
|
|
* given box child element -- by a variable argument list
|
2013-04-24 12:56:24 -07:00
|
|
|
*
|
2014-04-03 05:14:46 -07:00
|
|
|
* @param o The box parenting the child element
|
|
|
|
* @param opt The box option structure bound to the child box element
|
|
|
|
* to get a property from
|
|
|
|
* @param property The numerical ID of the given property
|
|
|
|
* @param args The variable argument list with pointers to where to
|
|
|
|
* store the values of this property. They @b must point to variables
|
|
|
|
* of the same type the user has defined for them.
|
|
|
|
* @return @c EINA_TRUE on success, @c EINA_FALSE on failure.
|
2013-04-24 12:56:24 -07:00
|
|
|
*
|
2014-04-03 05:14:46 -07:00
|
|
|
* This is a variable argument list variant of the
|
|
|
|
* evas_object_box_option_property_get(). See its documentation for
|
|
|
|
* more details.
|
2013-04-24 12:56:24 -07:00
|
|
|
*/
|
2014-04-03 05:14:46 -07:00
|
|
|
EAPI Eina_Bool evas_object_box_option_property_vget(const Evas_Object *o, Evas_Object_Box_Option *opt, int property, va_list args) EINA_ARG_NONNULL(1, 2);
|
2013-04-24 12:56:24 -07:00
|
|
|
|
|
|
|
/**
|
2014-04-03 05:14:46 -07:00
|
|
|
* Set a property value (by its given numerical identifier), on a
|
|
|
|
* given box child element -- by a variable argument list
|
2013-04-24 12:56:24 -07:00
|
|
|
*
|
2014-04-03 05:14:46 -07:00
|
|
|
* @param o The box parenting the child element
|
|
|
|
* @param opt The box option structure bound to the child box element
|
|
|
|
* to set a property on
|
|
|
|
* @param property The numerical ID of the given property
|
|
|
|
* @param args The variable argument list implementing the value to
|
|
|
|
* be set for this property. It @b must be of the same type the user has
|
|
|
|
* defined for it.
|
|
|
|
* @return @c EINA_TRUE on success, @c EINA_FALSE on failure.
|
2013-04-24 12:56:24 -07:00
|
|
|
*
|
2014-04-03 05:14:46 -07:00
|
|
|
* This is a variable argument list variant of the
|
|
|
|
* evas_object_box_option_property_set(). See its documentation for
|
|
|
|
* more details.
|
2013-04-24 12:56:24 -07:00
|
|
|
*/
|
2014-04-03 05:14:46 -07:00
|
|
|
EAPI Eina_Bool evas_object_box_option_property_vset(Evas_Object *o, Evas_Object_Box_Option *opt, int property, va_list args) EINA_ARG_NONNULL(1, 2);
|
2013-04-24 12:56:24 -07:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Set a property value (by its given numerical identifier), on a
|
|
|
|
* given box child element
|
|
|
|
*
|
|
|
|
* @param o The box parenting the child element
|
|
|
|
* @param opt The box option structure bound to the child box element
|
|
|
|
* to set a property on
|
|
|
|
* @param property The numerical ID of the given property
|
|
|
|
* @param ... (List of) actual value(s) to be set for this
|
|
|
|
* property. It (they) @b must be of the same type the user has
|
|
|
|
* defined for it (them).
|
|
|
|
* @return @c EINA_TRUE on success, @c EINA_FALSE on failure.
|
|
|
|
*
|
|
|
|
* @note This call won't do anything for a canonical Evas box. Only
|
|
|
|
* users which have @b subclassed it, setting custom box items options
|
|
|
|
* (see #Evas_Object_Box_Option) on it, would benefit from this
|
|
|
|
* function. They'd have to implement it and set it to be the
|
|
|
|
* _Evas_Object_Box_Api::property_set smart class function of the box,
|
|
|
|
* which is originally set to @c NULL.
|
|
|
|
*
|
|
|
|
* @note This function will internally create a variable argument
|
|
|
|
* list, with the values passed after @p property, and call
|
|
|
|
* evas_object_box_option_property_vset() with this list and the same
|
|
|
|
* previous arguments.
|
|
|
|
*/
|
|
|
|
EAPI Eina_Bool evas_object_box_option_property_set(Evas_Object *o, Evas_Object_Box_Option *opt, int property, ...) EINA_ARG_NONNULL(1, 2);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Get a property's value (by its given numerical identifier), on a
|
|
|
|
* given box child element
|
|
|
|
*
|
|
|
|
* @param o The box parenting the child element
|
|
|
|
* @param opt The box option structure bound to the child box element
|
|
|
|
* to get a property from
|
|
|
|
* @param property The numerical ID of the given property
|
|
|
|
* @param ... (List of) pointer(s) where to store the value(s) set for
|
|
|
|
* this property. It (they) @b must point to variable(s) of the same
|
|
|
|
* type the user has defined for it (them).
|
|
|
|
* @return @c EINA_TRUE on success, @c EINA_FALSE on failure.
|
|
|
|
*
|
|
|
|
* @note This call won't do anything for a canonical Evas box. Only
|
|
|
|
* users which have @b subclassed it, getting custom box items options
|
|
|
|
* (see #Evas_Object_Box_Option) on it, would benefit from this
|
|
|
|
* function. They'd have to implement it and get it to be the
|
|
|
|
* _Evas_Object_Box_Api::property_get smart class function of the
|
|
|
|
* box, which is originally get to @c NULL.
|
|
|
|
*
|
|
|
|
* @note This function will internally create a variable argument
|
|
|
|
* list, with the values passed after @p property, and call
|
|
|
|
* evas_object_box_option_property_vget() with this list and the same
|
|
|
|
* previous arguments.
|
|
|
|
*/
|
|
|
|
EAPI Eina_Bool evas_object_box_option_property_get(const Evas_Object *o, Evas_Object_Box_Option *opt, int property, ...) EINA_ARG_NONNULL(1, 2);
|
|
|
|
|
|
|
|
/**
|
2014-04-03 05:14:46 -07:00
|
|
|
* Get the list of children objects in a given box object.
|
2013-04-24 12:56:24 -07:00
|
|
|
*
|
2014-04-03 05:14:46 -07:00
|
|
|
* @param o The box to retrieve an items list from
|
|
|
|
* @return A list of @p o's child objects, on success, or @c NULL,
|
|
|
|
* on errors (or if it has no child objects)
|
2013-04-24 12:56:24 -07:00
|
|
|
*
|
2014-04-03 05:14:46 -07:00
|
|
|
* The returned list should be freed with @c eina_list_free() when you
|
|
|
|
* no longer need it.
|
|
|
|
*
|
|
|
|
* @note This is a duplicate of the list kept by the box internally.
|
|
|
|
* It's up to the user to destroy it when it no longer needs it.
|
|
|
|
* It's possible to remove objects from the box when walking
|
|
|
|
* this list, but these removals won't be reflected on it.
|
2013-04-24 12:56:24 -07:00
|
|
|
*/
|
2014-04-03 05:14:46 -07:00
|
|
|
EAPI Eina_List *evas_object_box_children_get(const Evas_Object *o) EINA_WARN_UNUSED_RESULT EINA_ARG_NONNULL(1) EINA_MALLOC;
|
|
|
|
|
|
|
|
#include "canvas/evas_box.eo.legacy.h"
|
2013-04-24 12:56:24 -07:00
|
|
|
|
|
|
|
/**
|
|
|
|
* @}
|
|
|
|
*/
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @ingroup Evas_Object_Table
|
|
|
|
*
|
|
|
|
* @{
|
|
|
|
*/
|
|
|
|
/**
|
|
|
|
* @brief Create a new table.
|
|
|
|
*
|
|
|
|
* @param evas Canvas in which table will be added.
|
|
|
|
*/
|
|
|
|
EAPI Evas_Object *evas_object_table_add(Evas *evas) EINA_WARN_UNUSED_RESULT EINA_ARG_NONNULL(1) EINA_MALLOC;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Get the child of the table at the given coordinates
|
|
|
|
*
|
|
|
|
* @note This does not take into account col/row spanning
|
|
|
|
*/
|
|
|
|
EAPI Evas_Object *evas_object_table_child_get(const Evas_Object *o, unsigned short col, unsigned short row) EINA_ARG_NONNULL(1);
|
|
|
|
|
2014-04-02 00:46:53 -07:00
|
|
|
#include "canvas/evas_table.eo.legacy.h"
|
|
|
|
|
2013-04-24 12:56:24 -07:00
|
|
|
/**
|
|
|
|
* @}
|
|
|
|
*/
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @ingroup Evas_Object_Grid
|
|
|
|
*
|
|
|
|
* @{
|
|
|
|
*/
|
|
|
|
/**
|
|
|
|
* Create a new grid.
|
|
|
|
*
|
|
|
|
* It's set to a virtual size of 1x1 by default and add children with
|
|
|
|
* evas_object_grid_pack().
|
|
|
|
* @since 1.1
|
|
|
|
*/
|
|
|
|
EAPI Evas_Object *evas_object_grid_add(Evas *evas) EINA_WARN_UNUSED_RESULT EINA_ARG_NONNULL(1) EINA_MALLOC;
|
|
|
|
|
2014-04-02 07:53:53 -07:00
|
|
|
#include "canvas/evas_grid.eo.legacy.h"
|
2013-04-24 12:56:24 -07:00
|
|
|
|
|
|
|
/**
|
|
|
|
* @}
|
|
|
|
*/
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @ingroup Evas_Keys
|
|
|
|
*
|
|
|
|
* @{
|
|
|
|
*/
|
|
|
|
/**
|
|
|
|
* Returns a handle to the list of modifier keys registered in the
|
|
|
|
* canvas @p e. This is required to check for which modifiers are set
|
|
|
|
* at a given time with the evas_key_modifier_is_set() function.
|
|
|
|
*
|
|
|
|
* @param e The pointer to the Evas canvas
|
|
|
|
*
|
|
|
|
* @see evas_key_modifier_add
|
|
|
|
* @see evas_key_modifier_del
|
|
|
|
* @see evas_key_modifier_on
|
|
|
|
* @see evas_key_modifier_off
|
|
|
|
* @see evas_key_modifier_is_set
|
|
|
|
*
|
|
|
|
* @return An ::Evas_Modifier handle to query Evas' keys subsystem
|
|
|
|
* with evas_key_modifier_is_set(), or @c NULL on error.
|
|
|
|
*/
|
|
|
|
EAPI const Evas_Modifier *evas_key_modifier_get(const Evas *e) EINA_WARN_UNUSED_RESULT EINA_ARG_NONNULL(1);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Returns a handle to the list of lock keys registered in the canvas
|
|
|
|
* @p e. This is required to check for which locks are set at a given
|
|
|
|
* time with the evas_key_lock_is_set() function.
|
|
|
|
*
|
|
|
|
* @param e The pointer to the Evas canvas
|
|
|
|
*
|
|
|
|
* @see evas_key_lock_add
|
|
|
|
* @see evas_key_lock_del
|
|
|
|
* @see evas_key_lock_on
|
|
|
|
* @see evas_key_lock_off
|
|
|
|
* @see evas_key_lock_is_set
|
|
|
|
*
|
|
|
|
* @return An ::Evas_Lock handle to query Evas' keys subsystem with
|
|
|
|
* evas_key_lock_is_set(), or @c NULL on error.
|
|
|
|
*/
|
|
|
|
EAPI const Evas_Lock *evas_key_lock_get(const Evas *e) EINA_WARN_UNUSED_RESULT EINA_ARG_NONNULL(1);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Adds the @p keyname key to the current list of modifier keys.
|
|
|
|
*
|
|
|
|
* @param e The pointer to the Evas canvas
|
|
|
|
* @param keyname The name of the modifier key to add to the list of
|
|
|
|
* Evas modifiers.
|
|
|
|
*
|
|
|
|
* Modifiers are keys like shift, alt and ctrl, i.e., keys which are
|
|
|
|
* meant to be pressed together with others, altering the behavior of
|
|
|
|
* the secondly pressed keys somehow. Evas is so that these keys can
|
|
|
|
* be user defined.
|
|
|
|
*
|
|
|
|
* This call allows custom modifiers to be added to the Evas system at
|
|
|
|
* run time. It is then possible to set and unset modifier keys
|
|
|
|
* programmatically for other parts of the program to check and act
|
|
|
|
* on. Programmers using Evas would check for modifier keys on key
|
|
|
|
* event callbacks using evas_key_modifier_is_set().
|
|
|
|
*
|
|
|
|
* @see evas_key_modifier_del
|
|
|
|
* @see evas_key_modifier_get
|
|
|
|
* @see evas_key_modifier_on
|
|
|
|
* @see evas_key_modifier_off
|
|
|
|
* @see evas_key_modifier_is_set
|
|
|
|
*
|
|
|
|
* @note If the programmer instantiates the canvas by means of the
|
|
|
|
* ecore_evas_new() family of helper functions, Ecore will take
|
|
|
|
* care of registering on it all standard modifiers: "Shift",
|
|
|
|
* "Control", "Alt", "Meta", "Hyper", "Super".
|
|
|
|
*/
|
|
|
|
EAPI void evas_key_modifier_add(Evas *e, const char *keyname) EINA_ARG_NONNULL(1, 2);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Removes the @p keyname key from the current list of modifier keys
|
|
|
|
* on canvas @p e.
|
|
|
|
*
|
|
|
|
* @param e The pointer to the Evas canvas
|
|
|
|
* @param keyname The name of the key to remove from the modifiers list.
|
|
|
|
*
|
|
|
|
* @see evas_key_modifier_add
|
|
|
|
* @see evas_key_modifier_get
|
|
|
|
* @see evas_key_modifier_on
|
|
|
|
* @see evas_key_modifier_off
|
|
|
|
* @see evas_key_modifier_is_set
|
|
|
|
*/
|
|
|
|
EAPI void evas_key_modifier_del(Evas *e, const char *keyname) EINA_ARG_NONNULL(1, 2);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Adds the @p keyname key to the current list of lock keys.
|
|
|
|
*
|
|
|
|
* @param e The pointer to the Evas canvas
|
|
|
|
* @param keyname The name of the key to add to the locks list.
|
|
|
|
*
|
|
|
|
* Locks are keys like caps lock, num lock or scroll lock, i.e., keys
|
|
|
|
* which are meant to be pressed once -- toggling a binary state which
|
|
|
|
* is bound to it -- and thus altering the behavior of all
|
|
|
|
* subsequently pressed keys somehow, depending on its state. Evas is
|
|
|
|
* so that these keys can be defined by the user.
|
|
|
|
*
|
|
|
|
* This allows custom locks to be added to the evas system at run
|
|
|
|
* time. It is then possible to set and unset lock keys
|
|
|
|
* programmatically for other parts of the program to check and act
|
|
|
|
* on. Programmers using Evas would check for lock keys on key event
|
|
|
|
* callbacks using evas_key_lock_is_set().
|
|
|
|
*
|
|
|
|
* @see evas_key_lock_get
|
|
|
|
* @see evas_key_lock_del
|
|
|
|
* @see evas_key_lock_on
|
|
|
|
* @see evas_key_lock_off
|
|
|
|
* @see evas_key_lock_is_set
|
|
|
|
*
|
|
|
|
* @note If the programmer instantiates the canvas by means of the
|
|
|
|
* ecore_evas_new() family of helper functions, Ecore will take
|
|
|
|
* care of registering on it all standard lock keys: "Caps_Lock",
|
|
|
|
* "Num_Lock", "Scroll_Lock".
|
|
|
|
*/
|
|
|
|
EAPI void evas_key_lock_add(Evas *e, const char *keyname) EINA_ARG_NONNULL(1, 2);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Removes the @p keyname key from the current list of lock keys on
|
|
|
|
* canvas @p e.
|
|
|
|
*
|
|
|
|
* @param e The pointer to the Evas canvas
|
|
|
|
* @param keyname The name of the key to remove from the locks list.
|
|
|
|
*
|
|
|
|
* @see evas_key_lock_get
|
|
|
|
* @see evas_key_lock_add
|
|
|
|
* @see evas_key_lock_on
|
|
|
|
* @see evas_key_lock_off
|
|
|
|
*/
|
|
|
|
EAPI void evas_key_lock_del(Evas *e, const char *keyname) EINA_ARG_NONNULL(1, 2);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Enables or turns on programmatically the modifier key with name @p
|
|
|
|
* keyname.
|
|
|
|
*
|
|
|
|
* @param e The pointer to the Evas canvas
|
|
|
|
* @param keyname The name of the modifier to enable.
|
|
|
|
*
|
|
|
|
* The effect will be as if the key was pressed for the whole time
|
|
|
|
* between this call and a matching evas_key_modifier_off().
|
|
|
|
*
|
|
|
|
* @see evas_key_modifier_add
|
|
|
|
* @see evas_key_modifier_get
|
|
|
|
* @see evas_key_modifier_off
|
|
|
|
* @see evas_key_modifier_is_set
|
|
|
|
*/
|
|
|
|
EAPI void evas_key_modifier_on(Evas *e, const char *keyname) EINA_ARG_NONNULL(1, 2);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Disables or turns off programmatically the modifier key with name
|
|
|
|
* @p keyname.
|
|
|
|
*
|
|
|
|
* @param e The pointer to the Evas canvas
|
|
|
|
* @param keyname The name of the modifier to disable.
|
|
|
|
*
|
|
|
|
* @see evas_key_modifier_add
|
|
|
|
* @see evas_key_modifier_get
|
|
|
|
* @see evas_key_modifier_on
|
|
|
|
* @see evas_key_modifier_is_set
|
|
|
|
*/
|
|
|
|
EAPI void evas_key_modifier_off(Evas *e, const char *keyname) EINA_ARG_NONNULL(1, 2);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Enables or turns on programmatically the lock key with name @p
|
|
|
|
* keyname.
|
|
|
|
*
|
|
|
|
* @param e The pointer to the Evas canvas
|
|
|
|
* @param keyname The name of the lock to enable.
|
|
|
|
*
|
|
|
|
* The effect will be as if the key was put on its active state after
|
|
|
|
* this call.
|
|
|
|
*
|
|
|
|
* @see evas_key_lock_get
|
|
|
|
* @see evas_key_lock_add
|
|
|
|
* @see evas_key_lock_del
|
|
|
|
* @see evas_key_lock_off
|
|
|
|
*/
|
|
|
|
EAPI void evas_key_lock_on(Evas *e, const char *keyname) EINA_ARG_NONNULL(1, 2);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Disables or turns off programmatically the lock key with name @p
|
|
|
|
* keyname.
|
|
|
|
*
|
|
|
|
* @param e The pointer to the Evas canvas
|
|
|
|
* @param keyname The name of the lock to disable.
|
|
|
|
*
|
|
|
|
* The effect will be as if the key was put on its inactive state
|
|
|
|
* after this call.
|
|
|
|
*
|
|
|
|
* @see evas_key_lock_get
|
|
|
|
* @see evas_key_lock_add
|
|
|
|
* @see evas_key_lock_del
|
|
|
|
* @see evas_key_lock_on
|
|
|
|
*/
|
|
|
|
EAPI void evas_key_lock_off(Evas *e, const char *keyname) EINA_ARG_NONNULL(1, 2);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Creates a bit mask from the @p keyname @b modifier key. Values
|
|
|
|
* returned from different calls to it may be ORed together,
|
|
|
|
* naturally.
|
|
|
|
*
|
|
|
|
* @param e The canvas whom to query the bit mask from.
|
|
|
|
* @param keyname The name of the modifier key to create the mask for.
|
|
|
|
*
|
|
|
|
* @returns the bit mask or 0 if the @p keyname key wasn't registered as a
|
|
|
|
* modifier for canvas @p e.
|
|
|
|
*
|
|
|
|
* This function is meant to be using in conjunction with
|
|
|
|
* evas_object_key_grab()/evas_object_key_ungrab(). Go check their
|
|
|
|
* documentation for more information.
|
|
|
|
*
|
|
|
|
* @see evas_key_modifier_add
|
|
|
|
* @see evas_key_modifier_get
|
|
|
|
* @see evas_key_modifier_on
|
|
|
|
* @see evas_key_modifier_off
|
|
|
|
* @see evas_key_modifier_is_set
|
|
|
|
* @see evas_object_key_grab
|
|
|
|
* @see evas_object_key_ungrab
|
|
|
|
*/
|
|
|
|
EAPI Evas_Modifier_Mask evas_key_modifier_mask_get(const Evas *e, const char *keyname) EINA_WARN_UNUSED_RESULT EINA_ARG_NONNULL(1, 2);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @}
|
|
|
|
*/
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @ingroup Evas_Touch_Point_List
|
|
|
|
*
|
|
|
|
* @{
|
|
|
|
*/
|
|
|
|
/**
|
|
|
|
* Get the number of touched point in the evas.
|
|
|
|
*
|
|
|
|
* @param e The pointer to the Evas canvas.
|
|
|
|
* @return The number of touched point on the evas.
|
|
|
|
*
|
|
|
|
* New touched point is added to the list whenever touching the evas
|
|
|
|
* and point is removed whenever removing touched point from the evas.
|
|
|
|
*
|
|
|
|
* Example:
|
|
|
|
* @code
|
|
|
|
* extern Evas *evas;
|
|
|
|
* int count;
|
|
|
|
*
|
|
|
|
* count = evas_touch_point_list_count(evas);
|
|
|
|
* printf("The count of touch points: %i\n", count);
|
|
|
|
* @endcode
|
|
|
|
*
|
|
|
|
* @see evas_touch_point_list_nth_xy_get()
|
|
|
|
* @see evas_touch_point_list_nth_id_get()
|
|
|
|
* @see evas_touch_point_list_nth_state_get()
|
|
|
|
*/
|
|
|
|
EAPI unsigned int evas_touch_point_list_count(Evas *e) EINA_ARG_NONNULL(1);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* This function returns the nth touch point's co-ordinates.
|
|
|
|
*
|
|
|
|
* @param e The pointer to the Evas canvas.
|
|
|
|
* @param n The number of the touched point (0 being the first).
|
|
|
|
* @param x The pointer to a Evas_Coord to be filled in.
|
|
|
|
* @param y The pointer to a Evas_Coord to be filled in.
|
|
|
|
*
|
|
|
|
* Touch point's co-ordinates is updated whenever moving that point
|
|
|
|
* on the canvas.
|
|
|
|
*
|
|
|
|
* Example:
|
|
|
|
* @code
|
|
|
|
* extern Evas *evas;
|
|
|
|
* Evas_Coord x, y;
|
|
|
|
*
|
|
|
|
* if (evas_touch_point_list_count(evas))
|
|
|
|
* {
|
|
|
|
* evas_touch_point_nth_xy_get(evas, 0, &x, &y);
|
|
|
|
* printf("The first touch point's co-ordinate: (%i, %i)\n", x, y);
|
|
|
|
* }
|
|
|
|
* @endcode
|
|
|
|
*
|
|
|
|
* @see evas_touch_point_list_count()
|
|
|
|
* @see evas_touch_point_list_nth_id_get()
|
|
|
|
* @see evas_touch_point_list_nth_state_get()
|
|
|
|
*/
|
|
|
|
EAPI void evas_touch_point_list_nth_xy_get(Evas *e, unsigned int n, Evas_Coord *x, Evas_Coord *y) EINA_ARG_NONNULL(1);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* This function returns the @p id of nth touch point.
|
|
|
|
*
|
|
|
|
* @param e The pointer to the Evas canvas.
|
|
|
|
* @param n The number of the touched point (0 being the first).
|
|
|
|
* @return id of nth touch point, if the call succeeded, -1 otherwise.
|
|
|
|
*
|
|
|
|
* The point which comes from Mouse Event has @p id 0 and The point
|
|
|
|
* which comes from Multi Event has @p id that is same as Multi
|
|
|
|
* Event's device id.
|
|
|
|
*
|
|
|
|
* Example:
|
|
|
|
* @code
|
|
|
|
* extern Evas *evas;
|
|
|
|
* int id;
|
|
|
|
*
|
|
|
|
* if (evas_touch_point_list_count(evas))
|
|
|
|
* {
|
|
|
|
* id = evas_touch_point_nth_id_get(evas, 0);
|
|
|
|
* printf("The first touch point's id: %i\n", id);
|
|
|
|
* }
|
|
|
|
* @endcode
|
|
|
|
*
|
|
|
|
* @see evas_touch_point_list_count()
|
|
|
|
* @see evas_touch_point_list_nth_xy_get()
|
|
|
|
* @see evas_touch_point_list_nth_state_get()
|
|
|
|
*/
|
|
|
|
EAPI int evas_touch_point_list_nth_id_get(Evas *e, unsigned int n) EINA_ARG_NONNULL(1);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* This function returns the @p state of nth touch point.
|
|
|
|
*
|
|
|
|
* @param e The pointer to the Evas canvas.
|
|
|
|
* @param n The number of the touched point (0 being the first).
|
|
|
|
* @return @p state of nth touch point, if the call succeeded,
|
|
|
|
* EVAS_TOUCH_POINT_CANCEL otherwise.
|
|
|
|
*
|
|
|
|
* The point's @p state is EVAS_TOUCH_POINT_DOWN when pressed,
|
|
|
|
* EVAS_TOUCH_POINT_STILL when the point is not moved after pressed,
|
|
|
|
* EVAS_TOUCH_POINT_MOVE when moved at least once after pressed and
|
|
|
|
* EVAS_TOUCH_POINT_UP when released.
|
|
|
|
*
|
|
|
|
* Example:
|
|
|
|
* @code
|
|
|
|
* extern Evas *evas;
|
|
|
|
* Evas_Touch_Point_State state;
|
|
|
|
*
|
|
|
|
* if (evas_touch_point_list_count(evas))
|
|
|
|
* {
|
|
|
|
* state = evas_touch_point_nth_state_get(evas, 0);
|
|
|
|
* printf("The first touch point's state: %i\n", state);
|
|
|
|
* }
|
|
|
|
* @endcode
|
|
|
|
*
|
|
|
|
* @see evas_touch_point_list_count()
|
|
|
|
* @see evas_touch_point_list_nth_xy_get()
|
|
|
|
* @see evas_touch_point_list_nth_id_get()
|
|
|
|
*/
|
|
|
|
EAPI Evas_Touch_Point_State evas_touch_point_list_nth_state_get(Evas *e, unsigned int n) EINA_ARG_NONNULL(1);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @}
|
|
|
|
*/
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @since 1.8
|
|
|
|
*
|
|
|
|
* Adds an output to the canvas
|
|
|
|
*
|
|
|
|
* @parem e The canvas to add the output to
|
|
|
|
* @return The output
|
|
|
|
*
|
|
|
|
* @see evas_out_engine_info_set
|
|
|
|
* @see evas_output_viewport_set
|
|
|
|
* @see evas_output_size_set
|
|
|
|
*/
|
|
|
|
EAPI Evas_Out *evas_out_add(Evas *e);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @since 1.8
|
|
|
|
*
|
|
|
|
* Deletes an output
|
|
|
|
*
|
|
|
|
* @parem evo The output object
|
|
|
|
*
|
|
|
|
* @see evas_out_add
|
|
|
|
*/
|
|
|
|
EAPI void evas_output_del(Evas_Out *evo);
|
|
|
|
|
2014-04-03 05:14:46 -07:00
|
|
|
#include "canvas/evas_out.eo.legacy.h"
|