You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
 
 
 
 
 
 

19384 lines
684 KiB

/**
@page evas_main Evas
@date 2000 (created)
@section toc Table of Contents
@li @ref evas_main_intro
@li @ref evas_main_work
@li @ref evas_main_compiling
@li @ref evas_main_next_steps
@li @ref evas_main_intro_example
@section evas_main_intro Introduction
Evas is a clean display canvas API for several target display systems
that can draw anti-aliased text, smooth super and sub-sampled scaled
images, alpha-blend objects and much more.
It abstracts any need to know much about what the characteristics of
your display system are or what graphics calls are used to draw them
and how. It deals on an object level where all you do is create and
manipulate objects in a canvas, set their properties, and the rest is
done for you.
Evas optimises the rendering pipeline to minimise effort in redrawing
changes made to the canvas and so takes this work out of the
programmers hand, saving a lot of time and energy.
It's small and lean, designed to work on embedded systems all the way
to large and powerful multi-cpu workstations. It can be compiled to
only have the features you need for your target platform if you so
wish, thus keeping it small and lean. It has several display
back-ends, letting it display on several display systems, making it
portable for cross-device and cross-platform development.
@subsection evas_main_intro_not_evas What Evas is not?
Evas is not a widget set or widget toolkit, however it is their
base. See Elementary (http://docs.enlightenment.org/auto/elementary/)
for a toolkit based on Evas, Edje, @ref Ecore and other Enlightenment
technologies.
It is not dependent or aware of main loops, input or output
systems. Input should be polled from various sources and fed to
Evas. Similarly, it will not create windows or report windows updates
to your system, rather just drawing the pixels and reporting to the
user the areas that were changed. Of course these operations are quite
common and thus they are ready to use in @ref Ecore, particularly in
@ref Ecore_Evas_Group.
@section evas_main_work How does Evas work?
Evas is a canvas display library. This is markedly different from most
display and windowing systems as a canvas is structural and is also a
state engine, whereas most display and windowing systems are immediate
mode display targets. Evas handles the logic between a structural
display via its state engine, and controls the target windowing system
in order to produce rendered results of the current canvas' state on
the display.
Immediate mode display systems retain very little, or no state. A
program will execute a series of commands, as in the pseudo code:
@verbatim
draw line from position (0, 0) to position (100, 200);
draw rectangle from position (10, 30) to position (50, 500);
bitmap_handle = create_bitmap();
scale bitmap_handle to size 100 x 100;
draw image bitmap_handle at position (10, 30);
@endverbatim
The series of commands is executed by the windowing system and the
results are displayed on the screen (normally). Once the commands are
executed the display system has little or no idea of how to reproduce
this image again, and so has to be instructed by the application how
to redraw sections of the screen whenever needed. Each successive
command will be executed as instructed by the application and either
emulated by software or sent to the graphics hardware on the device to
be performed.
The advantage of such a system is that it is simple, and gives a
program tight control over how something looks and is drawn. Given the
increasing complexity of displays and demands by users to have better
looking interfaces, more and more work is needing to be done at this
level by the internals of widget sets, custom display widgets and
other programs. This means more and more logic and display rendering
code needs to be written time and time again, each time the
application needs to figure out how to minimise redraws so that
display is fast and interactive, and keep track of redraw logic. The
power comes at a high-price, lots of extra code and work. Programmers
not very familiar with graphics programming will often make mistakes
at this level and produce code that is sub optimal. Those familiar
with this kind of programming will simply get bored by writing the
same code again and again.
For example, if in the above scene, the windowing system requires the
application to redraw the area from 0, 0 to 50, 50 (also referred as
"expose event"), then the programmer must calculate manually the
updates and repaint it again:
@verbatim
Redraw from position (0, 0) to position (50, 50):
// what was in area (0, 0, 50, 50)?
// 1. intersection part of line (0, 0) to (100, 200)?
draw line from position (0, 0) to position (25, 50);
// 2. intersection part of rectangle (10, 30) to (50, 500)?
draw rectangle from position (10, 30) to position (50, 50)
// 3. intersection part of image at (10, 30), size 100 x 100?
bitmap_subimage = subregion from position (0, 0) to position (40, 20)
draw image bitmap_subimage at position (10, 30);
@endverbatim
The clever reader might have noticed that, if all elements in the
above scene are opaque, then the system is doing useless paints: part
of the line is behind the rectangle, and part of the rectangle is
behind the image. These useless paints tend to be very costly, as
pixels tend to be 4 bytes in size, thus an overlapping region of 100 x
100 pixels is around 40000 useless writes! The developer could write
code to calculate the overlapping areas and avoid painting then, but
then it should be mixed with the "expose event" handling mentioned
above and quickly one realizes the initially simpler method became
really complex.
Evas is a structural system in which the programmer creates and
manages display objects and their properties, and as a result of this
higher level state management, the canvas is able to redraw the set of
objects when needed to represent the current state of the canvas.
For example, the pseudo code:
@verbatim
line_handle = create_line();
set line_handle from position (0, 0) to position (100, 200);
show line_handle;
rectangle_handle = create_rectangle();
move rectangle_handle to position (10, 30);
resize rectangle_handle to size 40 x 470;
show rectangle_handle;
bitmap_handle = create_bitmap();
scale bitmap_handle to size 100 x 100;
move bitmap_handle to position (10, 30);
show bitmap_handle;
render scene;
@endverbatim
This may look longer, but when the display needs to be refreshed or
updated, the programmer only moves, resizes, shows, hides etc. the
objects that need to change. The programmer simply thinks at the
object logic level, and the canvas software does the rest of the work
for them, figuring out what actually changed in the canvas since it
was last drawn, how to most efficiently redraw the canvas and its
contents to reflect the current state, and then it can go off and do
the actual drawing of the canvas.
This lets the programmer think in a more natural way when dealing with
a display, and saves time and effort of working out how to load and
display images, render given the current display system etc. Since
Evas also is portable across different display systems, this also
gives the programmer the ability to have their code ported and
displayed on different display systems with very little work.
Evas can be seen as a display system that stands somewhere between a
widget set and an immediate mode display system. It retains basic
display logic, but does very little high-level logic such as
scrollbars, sliders, push buttons etc.
@section evas_main_compiling How to compile
Evas is a library your application links to. The procedure for this is
very simple. You simply have to compile your application with the
appropriate compiler flags that the @c pkg-config script outputs. For
example:
Compiling C or C++ files into object files:
@verbatim
gcc -c -o main.o main.c `pkg-config --cflags evas`
@endverbatim
Linking object files into a binary executable:
@verbatim
gcc -o my_application main.o `pkg-config --libs evas`
@endverbatim
See @ref pkgconfig
@section evas_main_next_steps Next Steps
After you understood what Evas is and installed it in your system
you should proceed understanding the programming interface for all
objects, then see the specific for the most used elements. We'd
recommend you to take a while to learn @ref Ecore, Edje
(http://docs.enlightenment.org/auto/edje/) and Elementary
(http://docs.enlightenment.org/auto/elementary/) as they will
likely save you tons of work compared to using just Evas directly.
Recommended reading:
@li @ref Evas_Object_Group, where you'll get how to basically
manipulate generic objects lying on an Evas canvas, handle canvas
and object events, etc.
@li @ref Evas_Object_Rectangle, to learn about the most basic object
type on Evas -- the rectangle.
@li @ref Evas_Object_Polygon, to learn how to create polygon elements
on the canvas.
@li @ref Evas_Line_Group, to learn how to create line elements on the
canvas.
@li @ref Evas_Object_Image, to learn about image objects, over which
Evas can do a plethora of operations.
@li @ref Evas_Object_Text, to learn how to create textual elements on
the canvas.
@li @ref Evas_Object_Textblock, to learn how to create multiline
textual elements on the canvas.
@li @ref Evas_Smart_Object_Group and @ref Evas_Smart_Group, to define
new objects that provide @b custom functions to handle clipping,
hiding, moving, resizing, color setting and more. These could
be as simple as a group of objects that move together (see @ref
Evas_Smart_Object_Clipped) up to implementations of what
ends to be a widget, providing some intelligence (thus the name)
to Evas objects -- like a button or check box, for example.
@section evas_main_intro_example Introductory Example
@include evas-buffer-simple.c
More examples can be found at @ref evas_examples.
*/
#ifndef _EVAS_H
#define _EVAS_H
#include <time.h>
#include <Eina.h>
/* This include has been added to support Eo in Evas */
#include <Eo.h>
#ifdef EAPI
# undef EAPI
#endif
#ifdef _WIN32
# ifdef EFL_EVAS_BUILD
# ifdef DLL_EXPORT
# define EAPI __declspec(dllexport)
# else
# define EAPI
# endif /* ! DLL_EXPORT */
# else
# define EAPI __declspec(dllimport)
# endif /* ! EFL_EVAS_BUILD */
#else
# ifdef __GNUC__
# if __GNUC__ >= 4
# define EAPI __attribute__ ((visibility("default")))
# else
# define EAPI
# endif
# else
# define EAPI
# endif
#endif /* ! _WIN32 */
#ifdef __cplusplus
extern "C" {
#endif
#define EVAS_VERSION_MAJOR 1
#define EVAS_VERSION_MINOR 8
typedef struct _Evas_Version
{
int major;
int minor;
int micro;
int revision;
} Evas_Version;
EAPI extern Evas_Version * evas_version;
/**
* @file
* @brief These routines are used for Evas library interaction.
*
* @todo check boolean return values and convert to Eina_Bool
* @todo change all api to use EINA_SAFETY_*
* @todo finish api documentation
*/
/* BiDi exposed stuff */
/*FIXME: document */
typedef enum _Evas_BiDi_Direction
{
EVAS_BIDI_DIRECTION_NATURAL,
EVAS_BIDI_DIRECTION_NEUTRAL = EVAS_BIDI_DIRECTION_NATURAL,
EVAS_BIDI_DIRECTION_LTR,
EVAS_BIDI_DIRECTION_RTL
} Evas_BiDi_Direction;
/**
* Identifier of callbacks to be set for Evas canvases or Evas
* objects.
*
* The following figure illustrates some Evas callbacks:
*
* @image html evas-callbacks.png
* @image rtf evas-callbacks.png
* @image latex evas-callbacks.eps
*
* @see evas_object_event_callback_add()
* @see evas_event_callback_add()
*/
typedef enum _Evas_Callback_Type
{
/*
* The following events are only for use with Evas objects, with
* evas_object_event_callback_add():
*/
EVAS_CALLBACK_MOUSE_IN, /**< Mouse In Event */
EVAS_CALLBACK_MOUSE_OUT, /**< Mouse Out Event */
EVAS_CALLBACK_MOUSE_DOWN, /**< Mouse Button Down Event */
EVAS_CALLBACK_MOUSE_UP, /**< Mouse Button Up Event */
EVAS_CALLBACK_MOUSE_MOVE, /**< Mouse Move Event */
EVAS_CALLBACK_MOUSE_WHEEL, /**< Mouse Wheel Event */
EVAS_CALLBACK_MULTI_DOWN, /**< Multi-touch Down Event */
EVAS_CALLBACK_MULTI_UP, /**< Multi-touch Up Event */
EVAS_CALLBACK_MULTI_MOVE, /**< Multi-touch Move Event */
EVAS_CALLBACK_FREE, /**< Object Being Freed (Called after Del) */
EVAS_CALLBACK_KEY_DOWN, /**< Key Press Event */
EVAS_CALLBACK_KEY_UP, /**< Key Release Event */
EVAS_CALLBACK_FOCUS_IN, /**< Focus In Event */
EVAS_CALLBACK_FOCUS_OUT, /**< Focus Out Event */
EVAS_CALLBACK_SHOW, /**< Show Event */
EVAS_CALLBACK_HIDE, /**< Hide Event */
EVAS_CALLBACK_MOVE, /**< Move Event */
EVAS_CALLBACK_RESIZE, /**< Resize Event */
EVAS_CALLBACK_RESTACK, /**< Restack Event */
EVAS_CALLBACK_DEL, /**< Object Being Deleted (called before Free) */
EVAS_CALLBACK_HOLD, /**< Events go on/off hold */
EVAS_CALLBACK_CHANGED_SIZE_HINTS, /**< Size hints changed event */
EVAS_CALLBACK_IMAGE_PRELOADED, /**< Image has been preloaded */
/*
* The following events are only for use with Evas canvases, with
* evas_event_callback_add():
*/
EVAS_CALLBACK_CANVAS_FOCUS_IN, /**< Canvas got focus as a whole */
EVAS_CALLBACK_CANVAS_FOCUS_OUT, /**< Canvas lost focus as a whole */
EVAS_CALLBACK_RENDER_FLUSH_PRE, /**< Called just before rendering is updated on the canvas target */
EVAS_CALLBACK_RENDER_FLUSH_POST, /**< Called just after rendering is updated on the canvas target */
EVAS_CALLBACK_CANVAS_OBJECT_FOCUS_IN, /**< Canvas object got focus */
EVAS_CALLBACK_CANVAS_OBJECT_FOCUS_OUT, /**< Canvas object lost focus */
/*
* More Evas object event types - see evas_object_event_callback_add():
*/
EVAS_CALLBACK_IMAGE_UNLOADED, /**< Image data has been unloaded (by some mechanism in Evas that throw out original image data) */
EVAS_CALLBACK_RENDER_PRE, /**< Called just before rendering starts on the canvas target @since 1.2 */
EVAS_CALLBACK_RENDER_POST, /**< Called just after rendering stops on the canvas target @since 1.2 */
EVAS_CALLBACK_IMAGE_RESIZE, /**< Image size is changed @since 1.8 */
EVAS_CALLBACK_DEVICE_CHANGED, /**< Devices added, removed or changed on canvas @since 1.8 */
EVAS_CALLBACK_LAST /**< kept as last element/sentinel -- not really an event */
} Evas_Callback_Type; /**< The types of events triggering a callback */
EAPI extern const Eo_Event_Description _EVAS_EVENT_MOUSE_IN;
EAPI extern const Eo_Event_Description _EVAS_EVENT_MOUSE_OUT;
EAPI extern const Eo_Event_Description _EVAS_EVENT_MOUSE_DOWN;
EAPI extern const Eo_Event_Description _EVAS_EVENT_MOUSE_UP;
EAPI extern const Eo_Event_Description _EVAS_EVENT_MOUSE_MOVE;
EAPI extern const Eo_Event_Description _EVAS_EVENT_MOUSE_WHEEL;
EAPI extern const Eo_Event_Description _EVAS_EVENT_MULTI_DOWN;
EAPI extern const Eo_Event_Description _EVAS_EVENT_MULTI_UP;
EAPI extern const Eo_Event_Description _EVAS_EVENT_MULTI_MOVE;
EAPI extern const Eo_Event_Description _EVAS_EVENT_FREE;
EAPI extern const Eo_Event_Description _EVAS_EVENT_KEY_DOWN;
EAPI extern const Eo_Event_Description _EVAS_EVENT_KEY_UP;
EAPI extern const Eo_Event_Description _EVAS_EVENT_FOCUS_IN;
EAPI extern const Eo_Event_Description _EVAS_EVENT_FOCUS_OUT;
EAPI extern const Eo_Event_Description _EVAS_EVENT_SHOW;
EAPI extern const Eo_Event_Description _EVAS_EVENT_HIDE;
EAPI extern const Eo_Event_Description _EVAS_EVENT_MOVE;
EAPI extern const Eo_Event_Description _EVAS_EVENT_RESIZE;
EAPI extern const Eo_Event_Description _EVAS_EVENT_RESTACK;
EAPI extern const Eo_Event_Description _EVAS_EVENT_DEL;
EAPI extern const Eo_Event_Description _EVAS_EVENT_HOLD;
EAPI extern const Eo_Event_Description _EVAS_EVENT_CHANGED_SIZE_HINTS;
EAPI extern const Eo_Event_Description _EVAS_EVENT_IMAGE_PRELOADED;
EAPI extern const Eo_Event_Description _EVAS_EVENT_IMAGE_RESIZE;
EAPI extern const Eo_Event_Description _EVAS_EVENT_CANVAS_FOCUS_IN;
EAPI extern const Eo_Event_Description _EVAS_EVENT_CANVAS_FOCUS_OUT;
EAPI extern const Eo_Event_Description _EVAS_EVENT_RENDER_FLUSH_PRE;
EAPI extern const Eo_Event_Description _EVAS_EVENT_RENDER_FLUSH_POST;
EAPI extern const Eo_Event_Description _EVAS_EVENT_CANVAS_OBJECT_FOCUS_IN;
EAPI extern const Eo_Event_Description _EVAS_EVENT_CANVAS_OBJECT_FOCUS_OUT;
EAPI extern const Eo_Event_Description _EVAS_EVENT_IMAGE_UNLOADED;
EAPI extern const Eo_Event_Description _EVAS_EVENT_RENDER_PRE;
EAPI extern const Eo_Event_Description _EVAS_EVENT_RENDER_POST;
#define EVAS_EVENT_MOUSE_IN (&(_EVAS_EVENT_MOUSE_IN))
#define EVAS_EVENT_MOUSE_OUT (&(_EVAS_EVENT_MOUSE_OUT))
#define EVAS_EVENT_MOUSE_DOWN (&(_EVAS_EVENT_MOUSE_DOWN))
#define EVAS_EVENT_MOUSE_UP (&(_EVAS_EVENT_MOUSE_UP))
#define EVAS_EVENT_MOUSE_MOVE (&(_EVAS_EVENT_MOUSE_MOVE))
#define EVAS_EVENT_MOUSE_WHEEL (&(_EVAS_EVENT_MOUSE_WHEEL))
#define EVAS_EVENT_MULTI_DOWN (&(_EVAS_EVENT_MULTI_DOWN))
#define EVAS_EVENT_MULTI_UP (&(_EVAS_EVENT_MULTI_UP))
#define EVAS_EVENT_MULTI_MOVE (&(_EVAS_EVENT_MULTI_MOVE))
#define EVAS_EVENT_FREE (&(_EVAS_EVENT_FREE))
#define EVAS_EVENT_KEY_DOWN (&(_EVAS_EVENT_KEY_DOWN))
#define EVAS_EVENT_KEY_UP (&(_EVAS_EVENT_KEY_UP))
#define EVAS_EVENT_FOCUS_IN (&(_EVAS_EVENT_FOCUS_IN))
#define EVAS_EVENT_FOCUS_OUT (&(_EVAS_EVENT_FOCUS_OUT))
#define EVAS_EVENT_SHOW (&(_EVAS_EVENT_SHOW))
#define EVAS_EVENT_HIDE (&(_EVAS_EVENT_HIDE))
#define EVAS_EVENT_MOVE (&(_EVAS_EVENT_MOVE))
#define EVAS_EVENT_RESIZE (&(_EVAS_EVENT_RESIZE))
#define EVAS_EVENT_RESTACK (&(_EVAS_EVENT_RESTACK))
#define EVAS_EVENT_DEL (&(_EVAS_EVENT_DEL))
#define EVAS_EVENT_HOLD (&(_EVAS_EVENT_HOLD))
#define EVAS_EVENT_CHANGED_SIZE_HINTS (&(_EVAS_EVENT_CHANGED_SIZE_HINTS))
#define EVAS_EVENT_IMAGE_PRELOADED (&(_EVAS_EVENT_IMAGE_PRELOADED))
#define EVAS_EVENT_IMAGE_RESIZE (&(_EVAS_EVENT_IMAGE_RESIZE))
#define EVAS_EVENT_CANVAS_FOCUS_IN (&(_EVAS_EVENT_CANVAS_FOCUS_IN))
#define EVAS_EVENT_CANVAS_FOCUS_OUT (&(_EVAS_EVENT_CANVAS_FOCUS_OUT))
#define EVAS_EVENT_RENDER_FLUSH_PRE (&(_EVAS_EVENT_RENDER_FLUSH_PRE))
#define EVAS_EVENT_RENDER_FLUSH_POST (&(_EVAS_EVENT_RENDER_FLUSH_POST))
#define EVAS_EVENT_CANVAS_OBJECT_FOCUS_IN (&(_EVAS_EVENT_CANVAS_OBJECT_FOCUS_IN))
#define EVAS_EVENT_CANVAS_OBJECT_FOCUS_OUT (&(_EVAS_EVENT_CANVAS_OBJECT_FOCUS_OUT))
#define EVAS_EVENT_IMAGE_UNLOADED (&(_EVAS_EVENT_IMAGE_UNLOADED))
#define EVAS_EVENT_RENDER_PRE (&(_EVAS_EVENT_RENDER_PRE))
#define EVAS_EVENT_RENDER_POST (&(_EVAS_EVENT_RENDER_POST))
/**
* @def EVAS_CALLBACK_PRIORITY_BEFORE
* Slightly more prioritized than default.
* @since 1.1
*/
#define EVAS_CALLBACK_PRIORITY_BEFORE -100
/**
* @def EVAS_CALLBACK_PRIORITY_DEFAULT
* Default callback priority level
* @since 1.1
*/
#define EVAS_CALLBACK_PRIORITY_DEFAULT 0
/**
* @def EVAS_CALLBACK_PRIORITY_AFTER
* Slightly less prioritized than default.
* @since 1.1
*/
#define EVAS_CALLBACK_PRIORITY_AFTER 100
/**
* @typedef Evas_Callback_Priority
*
* Callback priority value. Range is -32k - 32k. The lower the number, the
* bigger the priority.
*
* @see EVAS_CALLBACK_PRIORITY_AFTER
* @see EVAS_CALLBACK_PRIORITY_BEFORE
* @see EVAS_CALLBACK_PRIORITY_DEFAULT
*
* @since 1.1
*/
typedef Eo_Callback_Priority Evas_Callback_Priority;
EAPI extern const Eo_Event_Description _CLICKED_EVENT;
EAPI extern const Eo_Event_Description _CLICKED_DOUBLE_EVENT;
EAPI extern const Eo_Event_Description _CLICKED_TRIPLE_EVENT;
EAPI extern const Eo_Event_Description _PRESSED_EVENT;
EAPI extern const Eo_Event_Description _UNPRESSED_EVENT;
EAPI extern const Eo_Event_Description _LONGPRESSED_EVENT;
EAPI extern const Eo_Event_Description _REPEATED_EVENT;
EAPI extern const Eo_Event_Description _SCROLL_EVENT;
EAPI extern const Eo_Event_Description _SCROLL_ANIM_START_EVENT;
EAPI extern const Eo_Event_Description _SCROLL_ANIM_STOP_EVENT;
EAPI extern const Eo_Event_Description _SCROLL_DRAG_START_EVENT;
EAPI extern const Eo_Event_Description _SCROLL_DRAG_STOP_EVENT;
EAPI extern const Eo_Event_Description _ZOOM_START_EVENT;
EAPI extern const Eo_Event_Description _ZOOM_STOP_EVENT;
EAPI extern const Eo_Event_Description _ZOOM_CHANGE_EVENT;
EAPI extern const Eo_Event_Description _SELECTED_EVENT;
EAPI extern const Eo_Event_Description _UNSELECTED_EVENT;
EAPI extern const Eo_Event_Description _SELECTION_PASTE_EVENT;
EAPI extern const Eo_Event_Description _SELECTION_COPY_EVENT;
EAPI extern const Eo_Event_Description _SELECTION_CUT_EVENT;
EAPI extern const Eo_Event_Description _SELECTION_START_EVENT;
EAPI extern const Eo_Event_Description _SELECTION_CHANGED_EVENT;
EAPI extern const Eo_Event_Description _SELECTION_CLEARED_EVENT;
EAPI extern const Eo_Event_Description _DRAG_EVENT;
EAPI extern const Eo_Event_Description _DRAG_START_EVENT;
EAPI extern const Eo_Event_Description _DRAG_STOP_EVENT;
EAPI extern const Eo_Event_Description _DRAG_END_EVENT;
EAPI extern const Eo_Event_Description _DRAG_START_UP_EVENT;
EAPI extern const Eo_Event_Description _DRAG_START_DOWN_EVENT;
EAPI extern const Eo_Event_Description _DRAG_START_RIGHT_EVENT;
EAPI extern const Eo_Event_Description _DRAG_START_LEFT_EVENT;
#define EVAS_SMART_CLICKED_EVENT (&(_CLICKED_EVENT))
#define EVAS_SMART_CLICKED_DOUBLE_EVENT (&(_CLICKED_DOUBLE_EVENT))
#define EVAS_SMART_CLICKED_TRIPLE_EVENT (&(_CLICKED_TRIPLE_EVENT))
#define EVAS_SMART_PRESSED_EVENT (&(_PRESSED_EVENT))
#define EVAS_SMART_UNPRESSED_EVENT (&(_UNPRESSED_EVENT))
#define EVAS_SMART_LONGPRESSED_EVENT (&(_LONGPRESSED_EVENT))
#define EVAS_SMART_REPEATED_EVENT (&(_REPEATED_EVENT))
#define EVAS_SMART_SCROLL_EVENT (&(_SCROLL_EVENT))
#define EVAS_SMART_SCROLL_ANIM_START_EVENT (&(_SCROLL_ANIM_START_EVENT))
#define EVAS_SMART_SCROLL_ANIM_STOP_EVENT (&(_SCROLL_ANIM_STOP_EVENT))
#define EVAS_SMART_SCROLL_DRAG_START_EVENT (&(_SCROLL_DRAG_START_EVENT))
#define EVAS_SMART_SCROLL_DRAG_STOP_EVENT (&(_SCROLL_DRAG_STOP_EVENT))
#define EVAS_SMART_ZOOM_START_EVENT (&(_ZOOM_START_EVENT))
#define EVAS_SMART_ZOOM_STOP_EVENT (&(_ZOOM_STOP_EVENT))
#define EVAS_SMART_ZOOM_CHANGE_EVENT (&(_ZOOM_CHANGE_EVENT))
#define EVAS_SMART_SELECTED_EVENT (&(_SELECTED_EVENT))
#define EVAS_SMART_UNSELECTED_EVENT (&(_UNSELECTED_EVENT))
#define EVAS_SMART_SELECTION_PASTE_EVENT (&(_SELECTION_PASTE_EVENT))
#define EVAS_SMART_SELECTION_COPY_EVENT (&(_SELECTION_COPY_EVENT))
#define EVAS_SMART_SELECTION_CUT_EVENT (&(_SELECTION_CUT_EVENT))
#define EVAS_SMART_SELECTION_START_EVENT (&(_SELECTION_START_EVENT))
#define EVAS_SMART_SELECTION_CHANGED_EVENT (&(_SELECTION_CHANGED_EVENT))
#define EVAS_SMART_SELECTION_CLEARED_EVENT (&(_SELECTION_CLEARED_EVENT))
#define EVAS_SMART_DRAG_EVENT (&(_DRAG_EVENT))
#define EVAS_SMART_DRAG_START_EVENT (&(_DRAG_START_EVENT))
#define EVAS_SMART_DRAG_STOP_EVENT (&(_DRAG_STOP_EVENT))
#define EVAS_SMART_DRAG_END_EVENT (&(_DRAG_END_EVENT))
#define EVAS_SMART_DRAG_START_UP_EVENT (&(_DRAG_START_UP_EVENT))
#define EVAS_SMART_DRAG_START_DOWN_EVENT (&(_DRAG_START_DOWN_EVENT))
#define EVAS_SMART_DRAG_START_RIGHT_EVENT (&(_DRAG_START_RIGHT_EVENT))
#define EVAS_SMART_DRAG_START_LEFT_EVENT (&(_DRAG_START_LEFT_EVENT))
const Eo_Class *evas_smart_signal_interface_get(void) EINA_CONST;
const Eo_Class *evas_smart_clickable_interface_get(void) EINA_CONST;
const Eo_Class *evas_smart_scrollable_interface_get(void) EINA_CONST;
const Eo_Class *evas_smart_zoomable_interface_get(void) EINA_CONST;
const Eo_Class *evas_smart_selectable_interface_get(void) EINA_CONST;
const Eo_Class *evas_smart_draggable_interface_get(void) EINA_CONST;
#define EVAS_SMART_SIGNAL_INTERFACE evas_smart_signal_interface_get()
#define EVAS_SMART_CLICKABLE_INTERFACE evas_smart_clickable_interface_get()
#define EVAS_SMART_SCROLLABLE_INTERFACE evas_smart_scrollable_interface_get()
#define EVAS_SMART_ZOOMABLE_INTERFACE evas_smart_zoomable_interface_get()
#define EVAS_SMART_SELECTABLE_INTERFACE evas_smart_selectable_interface_get()
#define EVAS_SMART_DRAGGABLE_INTERFACE evas_smart_draggable_interface_get()
/**
* Flags for Mouse Button events
*/
typedef enum _Evas_Button_Flags
{
EVAS_BUTTON_NONE = 0, /**< No extra mouse button data */
EVAS_BUTTON_DOUBLE_CLICK = (1 << 0), /**< This mouse button press was the 2nd press of a double click */
EVAS_BUTTON_TRIPLE_CLICK = (1 << 1) /**< This mouse button press was the 3rd press of a triple click */
} Evas_Button_Flags; /**< Flags for Mouse Button events */
/**
* Flags for Events
*/
typedef enum _Evas_Event_Flags
{
EVAS_EVENT_FLAG_NONE = 0, /**< No fancy flags set */
EVAS_EVENT_FLAG_ON_HOLD = (1 << 0), /**< This event is being delivered but should be put "on hold" until the on hold flag is unset. the event should be used for informational purposes and maybe some indications visually, but not actually perform anything */
EVAS_EVENT_FLAG_ON_SCROLL = (1 << 1) /**< This event flag indicates the event occurs while scrolling; for example, DOWN event occurs during scrolling; the event should be used for informational purposes and maybe some indications visually, but not actually perform anything */
} Evas_Event_Flags; /**< Flags for Events */
/**
* State of Evas_Coord_Touch_Point
*/
typedef enum _Evas_Touch_Point_State
{
EVAS_TOUCH_POINT_DOWN, /**< Touch point is pressed down */
EVAS_TOUCH_POINT_UP, /**< Touch point is released */
EVAS_TOUCH_POINT_MOVE, /**< Touch point is moved */
EVAS_TOUCH_POINT_STILL, /**< Touch point is not moved after pressed */
EVAS_TOUCH_POINT_CANCEL /**< Touch point is cancelled */
} Evas_Touch_Point_State;
/**
* Flags for Font Hinting
* @ingroup Evas_Font_Group
*/
typedef enum _Evas_Font_Hinting_Flags
{
EVAS_FONT_HINTING_NONE, /**< No font hinting */
EVAS_FONT_HINTING_AUTO, /**< Automatic font hinting */
EVAS_FONT_HINTING_BYTECODE /**< Bytecode font hinting */
} Evas_Font_Hinting_Flags; /**< Flags for Font Hinting */
/**
* Colorspaces for pixel data supported by Evas
* @ingroup Evas_Object_Image
*/
typedef enum _Evas_Colorspace
{
EVAS_COLORSPACE_ARGB8888, /**< ARGB 32 bits per pixel, high-byte is Alpha, accessed 1 32bit word at a time */
/* these are not currently supported - but planned for the future */
EVAS_COLORSPACE_YCBCR422P601_PL, /**< YCbCr 4:2:2 Planar, ITU.BT-601 specifications. The data pointed to is just an array of row pointer, pointing to the Y rows, then the Cb, then Cr rows */
EVAS_COLORSPACE_YCBCR422P709_PL, /**< YCbCr 4:2:2 Planar, ITU.BT-709 specifications. The data pointed to is just an array of row pointer, pointing to the Y rows, then the Cb, then Cr rows */
EVAS_COLORSPACE_RGB565_A5P, /**< 16bit rgb565 + Alpha plane at end - 5 bits of the 8 being used per alpha byte */
EVAS_COLORSPACE_GRY8, /**< 8bit grayscale */
EVAS_COLORSPACE_YCBCR422601_PL, /**< YCbCr 4:2:2, ITU.BT-601 specifications. The data pointed to is just an array of row pointer, pointing to line of Y,Cb,Y,Cr bytes */
EVAS_COLORSPACE_YCBCR420NV12601_PL, /**< YCbCr 4:2:0, ITU.BT-601 specification. The data pointed to is just an array of row pointer, pointing to the Y rows, then the Cb,Cr rows. */
EVAS_COLORSPACE_YCBCR420TM12601_PL, /**< YCbCr 4:2:0, ITU.BT-601 specification. The data pointed to is just an array of tiled row pointer, pointing to the Y rows, then the Cb,Cr rows. */
} Evas_Colorspace; /**< Colorspaces for pixel data supported by Evas */
/**
* How to pack items into cells in a table.
* @ingroup Evas_Object_Table
*
* @see evas_object_table_homogeneous_set() for an explanation of the function of
* each one.
*/
typedef enum _Evas_Object_Table_Homogeneous_Mode
{
EVAS_OBJECT_TABLE_HOMOGENEOUS_NONE = 0,
EVAS_OBJECT_TABLE_HOMOGENEOUS_TABLE = 1,
EVAS_OBJECT_TABLE_HOMOGENEOUS_ITEM = 2
} Evas_Object_Table_Homogeneous_Mode; /**< Table cell pack mode. */
typedef struct _Evas_Coord_Rectangle Evas_Coord_Rectangle; /**< A generic rectangle handle */
typedef struct _Evas_Point Evas_Point; /**< integer point */
typedef struct _Evas_Coord_Point Evas_Coord_Point; /**< Evas_Coord point */
typedef struct _Evas_Coord_Precision_Point Evas_Coord_Precision_Point; /**< Evas_Coord point with sub-pixel precision */
typedef struct _Evas_Coord_Size Evas_Coord_Size; /** <Evas_Coord size @since 1.8 */
typedef struct _Evas_Coord_Precision_Size Evas_Coord_Precision_Size; /** <Evas_Coord size with sub-pixel precision @since 1.8 */
typedef struct _Evas_Position Evas_Position; /**< associates given point in Canvas and Output */
typedef struct _Evas_Precision_Position Evas_Precision_Position; /**< associates given point in Canvas and Output, with sub-pixel precision */
/**
* @typedef Evas_Smart_Class
*
* A smart object's @b base class definition
*
* @ingroup Evas_Smart_Group
*/
typedef struct _Evas_Smart_Class Evas_Smart_Class;
/**
* @typedef Evas_Smart_Interface
*
* A smart object's @b base interface definition
*
* An Evas interface is exactly like the OO-concept: an 'contract' or
* API a given object is declared to support. A smart object may have
* more than one interface, thus extending the behavior it gets from
* sub-classing.
*
* @since 1.7
*
* @ingroup Evas_Smart_Group
*/
typedef struct _Evas_Smart_Interface Evas_Smart_Interface;
/**
* @typedef Evas_Smart_Cb_Description
*
* A smart object callback description, used to provide introspection
*
* @ingroup Evas_Smart_Group
*/
typedef struct _Evas_Smart_Cb_Description Evas_Smart_Cb_Description;
/**
* @typedef Evas_Map
*
* An opaque handle to map points
*
* @see evas_map_new()
* @see evas_map_free()
* @see evas_map_dup()
*
* @ingroup Evas_Object_Group_Map
*/
typedef struct _Evas_Map Evas_Map;
/**
* @typedef Evas
*
* An opaque handle to an Evas canvas.
*
* @see evas_new()
* @see evas_free()
*
* @ingroup Evas_Canvas
*/
typedef Eo Evas;
/**
* @typedef Evas_Public_Data
* Public data for an Evas.
* @ingroup Evas_Canvas
*/
typedef struct _Evas_Public_Data Evas_Public_Data;
/**
* @typedef Evas_Object
* An Evas Object handle.
* @ingroup Evas_Object_Group
*/
typedef Eo Evas_Object;
/**
* @typedef Evas_Object_Protected_Data
* Protected data for an Evas Object.
* @ingroup Evas_Object_Group
*/
typedef struct _Evas_Object_Protected_Data Evas_Object_Protected_Data;
typedef void Evas_Performance; /**< An Evas Performance handle */
typedef struct _Evas_Modifier Evas_Modifier; /**< An opaque type containing information on which modifier keys are registered in an Evas canvas */
typedef struct _Evas_Lock Evas_Lock; /**< An opaque type containing information on which lock keys are registered in an Evas canvas */
typedef struct _Evas_Smart Evas_Smart; /**< An Evas Smart Object handle */
typedef struct _Evas_Native_Surface Evas_Native_Surface; /**< A generic datatype for engine specific native surface information */
/**
* @typedef Evas_Video_Surface
*
* A generic datatype for video specific surface information
* @see evas_object_image_video_surface_set
* @see evas_object_image_video_surface_get
* @since 1.1
*/
typedef struct _Evas_Video_Surface Evas_Video_Surface;
typedef unsigned long long Evas_Modifier_Mask; /**< An Evas modifier mask type */
typedef int Evas_Coord;
typedef int Evas_Font_Size;
typedef int Evas_Angle;
struct _Evas_Coord_Rectangle /**< A rectangle in Evas_Coord */
{
Evas_Coord x; /**< top-left x co-ordinate of rectangle */
Evas_Coord y; /**< top-left y co-ordinate of rectangle */
Evas_Coord w; /**< width of rectangle */
Evas_Coord h; /**< height of rectangle */
};
struct _Evas_Coord_Point
{
Evas_Coord x; /**< x co-ordinate */
Evas_Coord y; /**< y co-ordinate */
};
struct _Evas_Coord_Size
{
Evas_Coord w; /**< width */
Evas_Coord h; /**< height */
};
struct _Evas_Coord_Precision_Size
{
Evas_Coord w; /** < width */
Evas_Coord h; /** < height */
double wsub; /** < subpixel precision for width */
double ysub; /** < subpixel precision for height */
};
struct _Evas_Coord_Precision_Point
{
Evas_Coord x, y;
double xsub, ysub;
};
struct _Evas_Point
{
int x, y;
};
struct _Evas_Position
{
Evas_Point output;
Evas_Coord_Point canvas; /**< position on the canvas */
};
struct _Evas_Precision_Position
{
Evas_Point output;
Evas_Coord_Precision_Point canvas;
};
typedef enum _Evas_Aspect_Control
{
EVAS_ASPECT_CONTROL_NONE = 0, /**< Preference on scaling unset */
EVAS_ASPECT_CONTROL_NEITHER = 1, /**< Same effect as unset preference on scaling */
EVAS_ASPECT_CONTROL_HORIZONTAL = 2, /**< Use all horizontal container space to place an object, using the given aspect */
EVAS_ASPECT_CONTROL_VERTICAL = 3, /**< Use all vertical container space to place an object, using the given aspect */
EVAS_ASPECT_CONTROL_BOTH = 4 /**< Use all horizontal @b and vertical container spaces to place an object (never growing it out of those bounds), using the given aspect */
} Evas_Aspect_Control; /**< Aspect types/policies for scaling size hints, used for evas_object_size_hint_aspect_set() */
typedef enum _Evas_Display_Mode
{
EVAS_DISPLAY_MODE_NONE = 0, /**<Default mode */
EVAS_DISPLAY_MODE_INHERIT = 1, /**< Use this mode when object's display mode depend on ancestor's */
EVAS_DISPLAY_MODE_COMPRESS = 2, /**< Use this mode want to give comppress display mode hint to object */
EVAS_DISPLAY_MODE_EXPAND = 3, /**< Use this mode want to give expand display mode hint to object */
EVAS_DISPLAY_MODE_DONT_CHANGE = 4 /**< Use this mode when object should not change display mode */
} Evas_Display_Mode; /**< object's display mode type related with compress/expand or etc mode */
typedef struct _Evas_Pixel_Import_Source Evas_Pixel_Import_Source; /**< A source description of pixels for importing pixels */
typedef struct _Evas_Engine_Info Evas_Engine_Info; /**< A generic Evas Engine information structure */
typedef struct _Evas_Device Evas_Device; /**< A source device handle - where the event came from */
typedef struct _Evas_Event_Mouse_Down Evas_Event_Mouse_Down; /**< Event structure for #EVAS_CALLBACK_MOUSE_DOWN event callbacks */
typedef struct _Evas_Event_Mouse_Up Evas_Event_Mouse_Up; /**< Event structure for #EVAS_CALLBACK_MOUSE_UP event callbacks */
typedef struct _Evas_Event_Mouse_In Evas_Event_Mouse_In; /**< Event structure for #EVAS_CALLBACK_MOUSE_IN event callbacks */
typedef struct _Evas_Event_Mouse_Out Evas_Event_Mouse_Out; /**< Event structure for #EVAS_CALLBACK_MOUSE_OUT event callbacks */
typedef struct _Evas_Event_Mouse_Move Evas_Event_Mouse_Move; /**< Event structure for #EVAS_CALLBACK_MOUSE_MOVE event callbacks */
typedef struct _Evas_Event_Mouse_Wheel Evas_Event_Mouse_Wheel; /**< Event structure for #EVAS_CALLBACK_MOUSE_WHEEL event callbacks */
typedef struct _Evas_Event_Multi_Down Evas_Event_Multi_Down; /**< Event structure for #EVAS_CALLBACK_MULTI_DOWN event callbacks */
typedef struct _Evas_Event_Multi_Up Evas_Event_Multi_Up; /**< Event structure for #EVAS_CALLBACK_MULTI_UP event callbacks */
typedef struct _Evas_Event_Multi_Move Evas_Event_Multi_Move; /**< Event structure for #EVAS_CALLBACK_MULTI_MOVE event callbacks */
typedef struct _Evas_Event_Key_Down Evas_Event_Key_Down; /**< Event structure for #EVAS_CALLBACK_KEY_DOWN event callbacks */
typedef struct _Evas_Event_Key_Up Evas_Event_Key_Up; /**< Event structure for #EVAS_CALLBACK_KEY_UP event callbacks */
typedef struct _Evas_Event_Hold Evas_Event_Hold; /**< Event structure for #EVAS_CALLBACK_HOLD event callbacks */
typedef enum _Evas_Load_Error
{
EVAS_LOAD_ERROR_NONE = 0, /**< No error on load */
EVAS_LOAD_ERROR_GENERIC = 1, /**< A non-specific error occurred */
EVAS_LOAD_ERROR_DOES_NOT_EXIST = 2, /**< File (or file path) does not exist */
EVAS_LOAD_ERROR_PERMISSION_DENIED = 3, /**< Permission denied to an existing file (or path) */
EVAS_LOAD_ERROR_RESOURCE_ALLOCATION_FAILED = 4, /**< Allocation of resources failure prevented load */
EVAS_LOAD_ERROR_CORRUPT_FILE = 5, /**< File corrupt (but was detected as a known format) */
EVAS_LOAD_ERROR_UNKNOWN_FORMAT = 6 /**< File is not a known format */
} Evas_Load_Error; /**< Evas image load error codes one can get - see evas_load_error_str() too. */
typedef enum _Evas_Alloc_Error
{
EVAS_ALLOC_ERROR_NONE = 0, /**< No allocation error */
EVAS_ALLOC_ERROR_FATAL = 1, /**< Allocation failed despite attempts to free up memory */
EVAS_ALLOC_ERROR_RECOVERED = 2 /**< Allocation succeeded, but extra memory had to be found by freeing up speculative resources */
} Evas_Alloc_Error; /**< Possible allocation errors returned by evas_alloc_error() */
typedef enum _Evas_Fill_Spread
{
EVAS_TEXTURE_REFLECT = 0, /**< image fill tiling mode - tiling reflects */
EVAS_TEXTURE_REPEAT = 1, /**< tiling repeats */
EVAS_TEXTURE_RESTRICT = 2, /**< tiling clamps - range offset ignored */
EVAS_TEXTURE_RESTRICT_REFLECT = 3, /**< tiling clamps and any range offset reflects */
EVAS_TEXTURE_RESTRICT_REPEAT = 4, /**< tiling clamps and any range offset repeats */
EVAS_TEXTURE_PAD = 5 /**< tiling extends with end values */
} Evas_Fill_Spread; /**< Fill types used for evas_object_image_fill_spread_set() */
typedef enum _Evas_Pixel_Import_Pixel_Format
{
EVAS_PIXEL_FORMAT_NONE = 0, /**< No pixel format */
EVAS_PIXEL_FORMAT_ARGB32 = 1, /**< ARGB 32bit pixel format with A in the high byte per 32bit pixel word */
EVAS_PIXEL_FORMAT_YUV420P_601 = 2 /**< YUV 420 Planar format with CCIR 601 color encoding with contiguous planes in the order Y, U and V */
} Evas_Pixel_Import_Pixel_Format; /**< Pixel format for import call. See evas_object_image_pixels_import() */
struct _Evas_Pixel_Import_Source
{
Evas_Pixel_Import_Pixel_Format format; /**< pixel format type ie ARGB32, YUV420P_601 etc. */
int w, h; /**< width and height of source in pixels */
void **rows; /**< an array of pointers (size depends on format) pointing to left edge of each scanline */
};
/* magic version number to know what the native surf struct looks like */
#define EVAS_NATIVE_SURFACE_VERSION 2
typedef enum _Evas_Native_Surface_Type
{
EVAS_NATIVE_SURFACE_NONE,
EVAS_NATIVE_SURFACE_X11,
EVAS_NATIVE_SURFACE_OPENGL
} Evas_Native_Surface_Type;
struct _Evas_Native_Surface
{
int version;
Evas_Native_Surface_Type type;
union {
struct
{
void *visual; /**< visual of the pixmap to use (Visual) */
unsigned long pixmap; /**< pixmap id to use (Pixmap) */
} x11;
struct
{
unsigned int texture_id; /**< opengl texture id to use from glGenTextures() */
unsigned int framebuffer_id; /**< 0 if not a FBO, FBO id otherwise from glGenFramebuffers() */
unsigned int internal_format; /**< same as 'internalFormat' for glTexImage2D() */
unsigned int format; /**< same as 'format' for glTexImage2D() */
unsigned int x, y, w, h; /**< region inside the texture to use (image size is assumed as texture size, with 0, 0 being the top-left and co-ordinates working down to the right and bottom being positive) */
} opengl;
} data;
};
/**
* @def EVAS_VIDEO_SURFACE_VERSION
* Magic version number to know what the video surf struct looks like
* @since 1.1
*/
#define EVAS_VIDEO_SURFACE_VERSION 1
typedef void (*Evas_Video_Cb)(void *data, Evas_Object *obj, const Evas_Video_Surface *surface);
typedef void (*Evas_Video_Coord_Cb)(void *data, Evas_Object *obj, const Evas_Video_Surface *surface, Evas_Coord a, Evas_Coord b);
struct _Evas_Video_Surface
{
int version;
Evas_Video_Coord_Cb move; /**< Move the video surface to this position */
Evas_Video_Coord_Cb resize; /**< Resize the video surface to that size */
Evas_Video_Cb show; /**< Show the video overlay surface */
Evas_Video_Cb hide; /**< Hide the video overlay surface */
Evas_Video_Cb update_pixels; /**< Please update the Evas_Object_Image pixels when called */
Evas_Object *parent;
void *data;
};
#define EVAS_LAYER_MIN -32768 /**< bottom-most layer number */
#define EVAS_LAYER_MAX 32767 /**< top-most layer number */
#define EVAS_COLOR_SPACE_ARGB 0 /**< Not used for anything */
#define EVAS_COLOR_SPACE_AHSV 1 /**< Not used for anything */
#define EVAS_TEXT_INVALID -1 /**< Not used for anything */
#define EVAS_TEXT_SPECIAL -2 /**< Not used for anything */
#define EVAS_HINT_EXPAND 1.0 /**< Use with evas_object_size_hint_weight_set(), evas_object_size_hint_weight_get(), evas_object_size_hint_expand_set(), evas_object_size_hint_expand_get() */
#define EVAS_HINT_FILL -1.0 /**< Use with evas_object_size_hint_align_set(), evas_object_size_hint_align_get(), evas_object_size_hint_fill_set(), evas_object_size_hint_fill_get() */
#define evas_object_size_hint_fill_set evas_object_size_hint_align_set /**< Convenience macro to make it easier to understand that align is also used for fill properties (as fill is mutually exclusive to align) */
#define evas_object_size_hint_fill_get evas_object_size_hint_align_get /**< Convenience macro to make it easier to understand that align is also used for fill properties (as fill is mutually exclusive to align) */
#define evas_object_size_hint_expand_set evas_object_size_hint_weight_set /**< Convenience macro to make it easier to understand that weight is also used for expand properties */
#define evas_object_size_hint_expand_get evas_object_size_hint_weight_get /**< Convenience macro to make it easier to understand that weight is also used for expand properties */
/**
* How the object should be rendered to output.
* @ingroup Evas_Object_Group_Extras
*/
typedef enum _Evas_Render_Op
{
EVAS_RENDER_BLEND = 0, /**< default op: d = d*(1-sa) + s */
EVAS_RENDER_BLEND_REL = 1, /**< d = d*(1 - sa) + s*da */
EVAS_RENDER_COPY = 2, /**< d = s */
EVAS_RENDER_COPY_REL = 3, /**< d = s*da */
EVAS_RENDER_ADD = 4, /* d = d + s */
EVAS_RENDER_ADD_REL = 5, /**< d = d + s*da */
EVAS_RENDER_SUB = 6, /**< d = d - s */
EVAS_RENDER_SUB_REL = 7, /* d = d - s*da */
EVAS_RENDER_TINT = 8, /**< d = d*s + d*(1 - sa) + s*(1 - da) */
EVAS_RENDER_TINT_REL = 9, /**< d = d*(1 - sa + s) */
EVAS_RENDER_MASK = 10, /**< d = d*sa */
EVAS_RENDER_MUL = 11 /**< d = d*s */
} Evas_Render_Op; /**< How the object should be rendered to output. */
typedef enum _Evas_Border_Fill_Mode
{
EVAS_BORDER_FILL_NONE = 0, /**< Image's center region is @b not to be rendered */
EVAS_BORDER_FILL_DEFAULT = 1, /**< Image's center region is to be @b blended with objects underneath it, if it has transparency. This is the default behavior for image objects */
EVAS_BORDER_FILL_SOLID = 2 /**< Image's center region is to be made solid, even if it has transparency on it */
} Evas_Border_Fill_Mode; /**< How an image's center region (the complement to the border region) should be rendered by Evas */
typedef enum _Evas_Image_Scale_Hint
{
EVAS_IMAGE_SCALE_HINT_NONE = 0, /**< No scale hint at all */
EVAS_IMAGE_SCALE_HINT_DYNAMIC = 1, /**< Image is being re-scaled over time, thus turning scaling cache @b off for its data */
EVAS_IMAGE_SCALE_HINT_STATIC = 2 /**< Image is not being re-scaled over time, thus turning scaling cache @b on for its data */
} Evas_Image_Scale_Hint; /**< How an image's data is to be treated by Evas, with regard to scaling cache */
typedef enum _Evas_Image_Animated_Loop_Hint
{
EVAS_IMAGE_ANIMATED_HINT_NONE = 0,
EVAS_IMAGE_ANIMATED_HINT_LOOP = 1, /**< Image's animation mode is loop like 1->2->3->1->2->3 */
EVAS_IMAGE_ANIMATED_HINT_PINGPONG = 2 /**< Image's animation mode is pingpong like 1->2->3->2->1-> ... */
} Evas_Image_Animated_Loop_Hint;
typedef enum _Evas_Engine_Render_Mode
{
EVAS_RENDER_MODE_BLOCKING = 0,
EVAS_RENDER_MODE_NONBLOCKING = 1,
} Evas_Engine_Render_Mode;
typedef enum _Evas_Image_Content_Hint
{
EVAS_IMAGE_CONTENT_HINT_NONE = 0, /**< No hint at all */
EVAS_IMAGE_CONTENT_HINT_DYNAMIC = 1, /**< The contents will change over time */
EVAS_IMAGE_CONTENT_HINT_STATIC = 2 /**< The contents won't change over time */
} Evas_Image_Content_Hint; /**< How an image's data is to be treated by Evas, for optimization */
typedef enum _Evas_Device_Class
{
EVAS_DEVICE_CLASS_NONE, /**< Not a device @since 1.8 */
EVAS_DEVICE_CLASS_SEAT, /**< The user/seat (the user themselves) @since 1.8 */
EVAS_DEVICE_CLASS_KEYBOARD, /**< A regular keyboard, numberpad or attached buttons @since 1.8 */
EVAS_DEVICE_CLASS_MOUSE, /**< A mouse, trackball or touchpad relative motion device @since 1.8 */
EVAS_DEVICE_CLASS_TOUCH, /**< A touchscreen with fingers or stylus @since 1.8 */
EVAS_DEVICE_CLASS_PEN, /**< A special pen device @since 1.8 */
EVAS_DEVICE_CLASS_POINTER, /**< A laser pointer, wii-style or "minority report" pointing device @since 1.8 */
EVAS_DEVICE_CLASS_GAMEPAD /**< A gamepad controller or joystick @since 1.8 */
} Evas_Device_Class;
struct _Evas_Engine_Info /** Generic engine information. Generic info is useless */
{
int magic; /**< Magic number */
};
struct _Evas_Event_Mouse_Down /** Mouse button press event */
{
int button; /**< Mouse button number that went down (1 - 32) */
Evas_Point output; /**< The X/Y location of the cursor */
Evas_Coord_Point canvas; /**< The X/Y location of the cursor */
void *data;
Evas_Modifier *modifiers; /**< modifier keys pressed during the event */
Evas_Lock *locks;
Evas_Button_Flags flags; /**< button flags set during the event */
unsigned int timestamp;
Evas_Event_Flags event_flags;
Evas_Device *dev;
};
struct _Evas_Event_Mouse_Up /** Mouse button release event */
{
int button; /**< Mouse button number that was raised (1 - 32) */
Evas_Point output; /**< The X/Y location of the cursor */
Evas_Coord_Point canvas; /**< The X/Y location of the cursor */
void *data;
Evas_Modifier *modifiers; /**< modifier keys pressed during the event */
Evas_Lock *locks;
Evas_Button_Flags flags; /**< button flags set during the event */
unsigned int timestamp;
Evas_Event_Flags event_flags;
Evas_Device *dev;
};
struct _Evas_Event_Mouse_In /** Mouse enter event */
{
int buttons; /**< Button pressed mask, Bits set to 1 are buttons currently pressed (bit 0 = mouse button 1, bit 1 = mouse button 2 etc.) */
Evas_Point output; /**< The X/Y location of the cursor */
Evas_Coord_Point canvas; /**< The X/Y location of the cursor */
void *data;
Evas_Modifier *modifiers; /**< modifier keys pressed during the event */
Evas_Lock *locks;
unsigned int timestamp;
Evas_Event_Flags event_flags;
Evas_Device *dev;
};
struct _Evas_Event_Mouse_Out /** Mouse leave event */
{
int buttons; /**< Button pressed mask, Bits set to 1 are buttons currently pressed (bit 0 = mouse button 1, bit 1 = mouse button 2 etc.) */
Evas_Point output; /**< The X/Y location of the cursor */
Evas_Coord_Point canvas; /**< The X/Y location of the cursor */
void *data;
Evas_Modifier *modifiers; /**< modifier keys pressed during the event */
Evas_Lock *locks;
unsigned int timestamp;
Evas_Event_Flags event_flags;
Evas_Device *dev;
};
struct _Evas_Event_Mouse_Move /** Mouse move event */
{
int buttons; /**< Button pressed mask, Bits set to 1 are buttons currently pressed (bit 0 = mouse button 1, bit 1 = mouse button 2 etc.) */
Evas_Position cur; /**< Current mouse position */
Evas_Position prev; /**< Previous mouse position */
void *data;
Evas_Modifier *modifiers; /**< modifier keys pressed during the event */
Evas_Lock *locks;
unsigned int timestamp;
Evas_Event_Flags event_flags;
Evas_Device *dev;
};
struct _Evas_Event_Mouse_Wheel /** Wheel event */
{
int direction; /* 0 = default up/down wheel FIXME: more wheel types */
int z; /* ...,-2,-1 = down, 1,2,... = up */
Evas_Point output; /**< The X/Y location of the cursor */
Evas_Coord_Point canvas; /**< The X/Y location of the cursor */
void *data;
Evas_Modifier *modifiers; /**< modifier keys pressed during the event */
Evas_Lock *locks;
unsigned int timestamp;
Evas_Event_Flags event_flags;
Evas_Device *dev;
};
struct _Evas_Event_Multi_Down /** Multi button press event */
{
int device; /**< Multi device number that went down (1 or more for extra touches) */
double radius, radius_x, radius_y;
double pressure, angle;
Evas_Point output;
Evas_Coord_Precision_Point canvas;
void *data;
Evas_Modifier *modifiers; /**< modifier keys pressed during the event */
Evas_Lock *locks;
Evas_Button_Flags flags; /**< button flags set during the event */
unsigned int timestamp;
Evas_Event_Flags event_flags;
Evas_Device *dev;
};
struct _Evas_Event_Multi_Up /** Multi button release event */
{
int device; /**< Multi device number that went up (1 or more for extra touches) */
double radius, radius_x, radius_y;
double pressure, angle;
Evas_Point output;
Evas_Coord_Precision_Point canvas;
void *data;
Evas_Modifier *modifiers; /**< modifier keys pressed during the event */
Evas_Lock *locks;
Evas_Button_Flags flags; /**< button flags set during the event */
unsigned int timestamp;
Evas_Event_Flags event_flags;
Evas_Device *dev;
};
struct _Evas_Event_Multi_Move /** Multi button down event */
{
int device; /**< Multi device number that moved (1 or more for extra touches) */
double radius, radius_x, radius_y;
double pressure, angle;
Evas_Precision_Position cur;
void *data;
Evas_Modifier *modifiers; /**< modifier keys pressed during the event */
Evas_Lock *locks;
unsigned int timestamp;
Evas_Event_Flags event_flags;
Evas_Device *dev;
};
struct _Evas_Event_Key_Down /** Key press event */
{
char *keyname; /**< the name string of the key pressed */
void *data;
Evas_Modifier *modifiers; /**< modifier keys pressed during the event */
Evas_Lock *locks;
const char *key; /**< The logical key : (eg shift+1 == exclamation) */
const char *string; /**< A UTF8 string if this keystroke has produced a visible string to be ADDED */
const char *compose; /**< A UTF8 string if this keystroke has modified a string in the middle of being composed - this string replaces the previous one */
unsigned int timestamp;
Evas_Event_Flags event_flags;
Evas_Device *dev;
};
struct _Evas_Event_Key_Up /** Key release event */
{
char *keyname; /**< the name string of the key released */
void *data;
Evas_Modifier *modifiers; /**< modifier keys pressed during the event */
Evas_Lock *locks;
const char *key; /**< The logical key : (eg shift+1 == exclamation) */
const char *string; /**< A UTF8 string if this keystroke has produced a visible string to be ADDED */
const char *compose; /**< A UTF8 string if this keystroke has modified a string in the middle of being composed - this string replaces the previous one */
unsigned int timestamp;
Evas_Event_Flags event_flags;
Evas_Device *dev;
};
struct _Evas_Event_Hold /** Hold change event */
{
int hold; /**< The hold flag */
void *data;
unsigned int timestamp;
Evas_Event_Flags event_flags;
Evas_Device *dev;
};
/**
* How the mouse pointer should be handled by Evas.
*
* In the mode #EVAS_OBJECT_POINTER_MODE_AUTOGRAB, when a mouse button
* is pressed down over an object and held, with the mouse pointer
* being moved outside of it, the pointer still behaves as being bound
* to that object, albeit out of its drawing region. When the button
* is released, the event will be fed to the object, that may check if
* the final position is over it or not and do something about it.
*
* In the mode #EVAS_OBJECT_POINTER_MODE_NOGRAB, the pointer will
* always be bound to the object right below it.
*
* @ingroup Evas_Object_Group_Extras
*/
typedef enum _Evas_Object_Pointer_Mode
{
EVAS_OBJECT_POINTER_MODE_AUTOGRAB, /**< default, X11-like */
EVAS_OBJECT_POINTER_MODE_NOGRAB, /**< pointer always bound to the object right below it */
EVAS_OBJECT_POINTER_MODE_NOGRAB_NO_REPEAT_UPDOWN /**< useful on object with "repeat events" enabled, where mouse/touch up and down events WONT be repeated to objects and these objects wont be auto-grabbed. @since 1.2 */
} Evas_Object_Pointer_Mode; /**< How the mouse pointer should be handled by Evas. */
typedef void (*Evas_Smart_Cb)(void *data, Evas_Object *obj, void *event_info); /**< Evas smart objects' "smart callback" function signature */
typedef void (*Evas_Event_Cb)(void *data, Evas *e, void *event_info); /**< Evas event callback function signature */
typedef Eina_Bool (*Evas_Object_Event_Post_Cb)(void *data, Evas *e);
typedef void (*Evas_Object_Event_Cb)(void *data, Evas *e, Evas_Object *obj, void *event_info); /**< Evas object event callback function signature */
typedef void (*Evas_Async_Events_Put_Cb)(void *target, Evas_Callback_Type type, void *event_info);
/**
* @defgroup Evas_Main_Group Top Level Functions
* @ingroup Evas
*
* Functions that affect Evas as a whole.
*/
/**
* Initialize Evas
*
* @return The init counter value.
*
* This function initializes Evas and increments a counter of the
* number of calls to it. It returns the new counter's value.
*
* @see evas_shutdown().
*
* Most EFL users wouldn't be using this function directly, because
* they wouldn't access Evas directly by themselves. Instead, they
* would be using higher level helpers, like @c ecore_evas_init().
* See http://docs.enlightenment.org/auto/ecore/.
*
* You should be using this if your use is something like the
* following. The buffer engine is just one of the many ones Evas
* provides.
*
* @dontinclude evas-buffer-simple.c
* @skip int main
* @until return -1;
* And being the canvas creation something like:
* @skip static Evas *create_canvas
* @until evas_output_viewport_set(canvas,
*
* Note that this is code creating an Evas canvas with no usage of
* Ecore helpers at all -- no linkage with Ecore on this scenario,
* thus. Again, this wouldn't be on Evas common usage for most
* developers. See the full @ref Example_Evas_Buffer_Simple "example".
*
* @ingroup Evas_Main_Group
*/
EAPI int evas_init(void);
/**
* Shutdown Evas
*
* @return Evas' init counter value.
*
* This function finalizes Evas, decrementing the counter of the
* number of calls to the function evas_init(). This new value for the
* counter is returned.
*
* @see evas_init().
*
* If you were the sole user of Evas, by means of evas_init(), you can
* check if it's being properly shut down by expecting a return value
* of 0.
*
* Example code follows.
* @dontinclude evas-buffer-simple.c
* @skip // NOTE: use ecore_evas_buffer_new
* @until evas_shutdown
* Where that function would contain:
* @skip evas_free(canvas)
* @until evas_free(canvas)
*
* Most users would be using ecore_evas_shutdown() instead, like told
* in evas_init(). See the full @ref Example_Evas_Buffer_Simple
* "example".
*
* @ingroup Evas_Main_Group
*/
EAPI int evas_shutdown(void);
/**
* Return if any allocation errors have occurred during the prior function
* @return The allocation error flag
*
* This function will return if any memory allocation errors occurred during,
* and what kind they were. The return value will be one of
* EVAS_ALLOC_ERROR_NONE, EVAS_ALLOC_ERROR_FATAL or EVAS_ALLOC_ERROR_RECOVERED
* with each meaning something different.
*
* EVAS_ALLOC_ERROR_NONE means that no errors occurred at all and the function
* worked as expected.
*
* EVAS_ALLOC_ERROR_FATAL means the function was completely unable to perform
* its job and will have exited as cleanly as possible. The programmer
* should consider this as a sign of very low memory and should try and safely
* recover from the prior functions failure (or try free up memory elsewhere
* and try again after more memory is freed).
*
* EVAS_ALLOC_ERROR_RECOVERED means that an allocation error occurred, but was
* recovered from by evas finding memory of its own it has allocated and
* freeing what it sees as not really usefully allocated memory. What is freed
* may vary. Evas may reduce the resolution of images, free cached images or
* fonts, trhow out pre-rendered data, reduce the complexity of change lists
* etc. Evas and the program will function as per normal after this, but this
* is a sign of low memory, and it is suggested that the program try and
* identify memory it doesn't need, and free it.
*
* Example:
* @code
* extern Evas_Object *object;
* void callback (void *data, Evas *e, Evas_Object *obj, void *event_info);
*
* evas_object_event_callback_add(object, EVAS_CALLBACK_MOUSE_DOWN, callback, NULL);
* if (evas_alloc_error() == EVAS_ALLOC_ERROR_FATAL)
* {
* fprintf(stderr, "ERROR: Completely unable to attach callback. Must\n");
* fprintf(stderr, " destroy object now as it cannot be used.\n");
* evas_object_del(object);
* object = NULL;
* fprintf(stderr, "WARNING: Memory is really low. Cleaning out RAM.\n");
* my_memory_cleanup();
* }
* if (evas_alloc_error() == EVAS_ALLOC_ERROR_RECOVERED)
* {
* fprintf(stderr, "WARNING: Memory is really low. Cleaning out RAM.\n");
* my_memory_cleanup();
* }
* @endcode
*
* @ingroup Evas_Main_Group
*/
EAPI Evas_Alloc_Error evas_alloc_error(void);
/**
* @brief Get evas' internal asynchronous events read file descriptor.
*
* @return The canvas' asynchronous events read file descriptor.
*
* Evas' asynchronous events are meant to be dealt with internally,
* i. e., when building stuff to be glued together into the EFL
* infrastructure -- a module, for example. The context which demands
* its use is when calculations need to be done out of the main
* thread, asynchronously, and some action must be performed after
* that.
*
* An example of actual use of this API is for image asynchronous
* preload inside evas. If the canvas was instantiated through
* ecore-evas usage, ecore itself will take care of calling those
* events' processing.
*
* This function returns the read file descriptor where to get the
* asynchronous events of the canvas. Naturally, other mainloops,
* apart from ecore, may make use of it.
*
* @ingroup Evas_Main_Group
*/
EAPI int evas_async_events_fd_get(void) EINA_WARN_UNUSED_RESULT;
/**
* @brief Trigger the processing of all events waiting on the file
* descriptor returned by evas_async_events_fd_get().
*
* @return The number of events processed.
*
* All asynchronous events queued up by evas_async_events_put() are
* processed here. More precisely, the callback functions, informed
* together with other event parameters, when queued, get called (with
* those parameters), in that order.
*
* @ingroup Evas_Main_Group
*/
EAPI int evas_async_events_process(void);
/**
* Insert asynchronous events on the canvas.
*
* @param target The target to be affected by the events.
* @param type The type of callback function.
* @param event_info Information about the event.
* @param func The callback function pointer.
*
* This is the way, for a routine running outside evas' main thread,
* to report an asynchronous event. A callback function is informed,
* whose call is to happen after evas_async_events_process() is
* called.
*
* @ingroup Evas_Main_Group
*/
EAPI Eina_Bool evas_async_events_put(const void *target, Evas_Callback_Type type, void *event_info, Evas_Async_Events_Put_Cb func) EINA_ARG_NONNULL(1, 4);
/**
* @defgroup Evas_Canvas Canvas Functions
* @ingroup Evas
*
* Low level Evas canvas functions. Sub groups will present more high
* level ones, though.
*
* Most of these functions deal with low level Evas actions, like:
* @li create/destroy raw canvases, not bound to any displaying engine
* @li tell a canvas i got focused (in a windowing context, for example)
* @li tell a canvas a region should not be calculated anymore in rendering
* @li tell a canvas to render its contents, immediately
*
* Most users will be using Evas by means of the @c Ecore_Evas
* wrapper, which deals with all the above mentioned issues
* automatically for them. Thus, you'll be looking at this section
* only if you're building low level stuff.
*
* The groups within present you functions that deal with the canvas
* directly, too, and not yet with its @b objects. They are the
* functions you need to use at a minimum to get a working canvas.
*
* Some of the functions in this group are exemplified @ref
* Example_Evas_Events "here".
*/
/**
* 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
* Ecore_Evas such as @c ecore_evas_new(). See
* http://docs.enlightenment.org/auto/ecore/.
*
* @attention it is recommended that one calls evas_init() before
* creating new canvas.
*
* @return A new uninitialised Evas canvas on success. Otherwise, @c NULL.
* @ingroup Evas_Canvas
*/
EAPI Evas *evas_new(void) EINA_WARN_UNUSED_RESULT EINA_MALLOC;
/**
* Frees the given evas and any objects created on it.
*
* Any objects with 'free' callbacks will have those callbacks called
* in this function.
*
* @param e The given evas.
*
* @ingroup Evas_Canvas
*/
EAPI void evas_free(Evas *e) EINA_ARG_NONNULL(1);
/**
* Inform to the evas that it got the focus.
*
* @param e The evas to change information.
* @ingroup Evas_Canvas
*/
EAPI void evas_focus_in(Evas *e);
/**
* Inform to the evas that it lost the focus.
*
* @param e The evas to change information.
* @ingroup Evas_Canvas
*/
EAPI void evas_focus_out(Evas *e);
/**
* Get the focus state known by the given evas
*
* @param e The evas to query information.
* @ingroup Evas_Canvas
*/
EAPI Eina_Bool evas_focus_state_get(const Evas *e);
/**
* Push the nochange flag up 1
*
* This tells evas, that while the nochange flag is greater than 0, do not
* mark objects as "changed" when making changes.
*
* @param e The evas to change information.
* @ingroup Evas_Canvas
*/
EAPI void evas_nochange_push(Evas *e);
/**
* Pop the nochange flag down 1
*
* This tells evas, that while the nochange flag is greater than 0, do not
* mark objects as "changed" when making changes.
*
* @param e The evas to change information.
* @ingroup Evas_Canvas
*/
EAPI void evas_nochange_pop(Evas *e);
/**
* Attaches a specific pointer to the evas for fetching later
*
* @param e The canvas to attach the pointer to
* @param data The pointer to attach
* @ingroup Evas_Canvas
*/
EAPI void evas_data_attach_set(Evas *e, void *data) EINA_ARG_NONNULL(1);
/**
* Returns the pointer attached by evas_data_attach_set()
*
* @param e The canvas to attach the pointer to
* @return The pointer attached
* @ingroup Evas_Canvas
*/
EAPI void *evas_data_attach_get(const Evas *e) EINA_WARN_UNUSED_RESULT EINA_ARG_NONNULL(1);
/**
* Add a damage rectangle.
*
* @param e The given canvas pointer.
* @param x The rectangle's left position.
* @param y The rectangle's top position.
* @param w The rectangle's width.
* @param h The rectangle's height.
*
* This is the function by which one tells evas that a part of the
* canvas has to be repainted.
*
* @note All newly created Evas rectangles get the default color values of 255 255 255 255 (opaque white).
*
* @ingroup Evas_Canvas
*/
EAPI void evas_damage_rectangle_add(Evas *e, int x, int y, int w, int h) EINA_ARG_NONNULL(1);
/**
* Add an "obscured region" to an Evas canvas.
*
* @param e The given canvas pointer.
* @param x The rectangle's top left corner's horizontal coordinate.
* @param y The rectangle's top left corner's vertical coordinate
* @param w The rectangle's width.
* @param h The rectangle's height.
*
* This is the function by which one tells an Evas canvas that a part
* of it <b>must not</b> be repainted. The region must be
* rectangular and its coordinates inside the canvas viewport are
* passed in the call. After this call, the region specified won't
* participate in any form in Evas' calculations and actions during
* its rendering updates, having its displaying content frozen as it
* was just after this function took place.
*
* We call it "obscured region" because the most common use case for
* this rendering (partial) freeze is something else (most probably
* other canvas) being on top of the specified rectangular region,
* thus shading it completely from the user's final scene in a
* display. To avoid unnecessary processing, one should indicate to the
* obscured canvas not to bother about the non-important area.
*
* The majority of users won't have to worry about this function, as
* they'll be using just one canvas in their applications, with
* nothing inset or on top of it in any form.
*
* To make this region one that @b has to be repainted again, call the
* function evas_obscured_clear().
*
* @note This is a <b>very low level function</b>, which most of
* Evas' users wouldn't care about.
*
* @note This function does @b not flag the canvas as having its state
* changed. If you want to re-render it afterwards expecting new
* contents, you have to add "damage" regions yourself (see
* evas_damage_rectangle_add()).
*
* @see evas_obscured_clear()
* @see evas_render_updates()
*
* Example code follows.
* @dontinclude evas-events.c
* @skip add an obscured
* @until evas_obscured_clear(evas);
*
* In that example, pressing the "Ctrl" and "o" keys will impose or
* remove an obscured region in the middle of the canvas. You'll get
* the same contents at the time the key was pressed, if toggling it
* on, until you toggle it off again (make sure the animation is
* running on to get the idea better). See the full @ref
* Example_Evas_Events "example".
*
* @ingroup Evas_Canvas
*/
EAPI void evas_obscured_rectangle_add(Evas *e, int x, int y, int w, int h) EINA_ARG_NONNULL(1);
/**
* Remove all "obscured regions" from an Evas canvas.
*
* @param e The given canvas pointer.
*
* This function removes all the rectangles from the obscured regions
* list of the canvas @p e. It takes obscured areas added with
* evas_obscured_rectangle_add() and make them again a regions that @b
* have to be repainted on rendering updates.
*
* @note This is a <b>very low level function</b>, which most of
* Evas' users wouldn't care about.
*
* @note This function does @b not flag the canvas as having its state
* changed. If you want to re-render it afterwards expecting new
* contents, you have to add "damage" regions yourself (see
* evas_damage_rectangle_add()).
*
* @see evas_obscured_rectangle_add() for an example
* @see evas_render_updates()
*
* @ingroup Evas_Canvas
*/
EAPI void evas_obscured_clear(Evas *e) EINA_ARG_NONNULL(1);
/**
* Render the given Evas canvas asynchronously.
*
* @param e The canvas to render.
* @param func Optional function to call with the list of updated areas.
* @param data User data to pass to @p func.
*
* @return EINA_TRUE if the canvas will render, EINA_FALSE otherwise.
*
* This function only returns EINA_TRUE whne a frame will be rendered. If the
* previous frame is still rendering, EINA_FALSE will be returned so the users
* know not to wait for the updates callback and just return to their main
* loop.
*
* If a @p func callback is given, a list of updated areas will be generated
* and the function will be called from the main thread after the rendered
* frame is flushed to the screen. The resulting list should be freed with
* @f evas_render_updates_free().
* The list is given in the @p event_info parameter of the callback function.
*
* @ingroup Evas_Canvas
* @since 1.8
*/
EAPI Eina_Bool evas_render_async(Evas *e, Evas_Event_Cb func, void *data) 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);
/**
* Free the rectangles returned by evas_render_updates().
*
* @param updates The list of updated rectangles of the canvas.
*
* This function removes the region from the render updates list. It
* makes the region doesn't be render updated anymore.
*
* @see evas_render_updates() for an example
*
* @ingroup Evas_Canvas
*/
EAPI void evas_render_updates_free(Eina_List *updates);
/**
* 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);
/**
* @defgroup Evas_Output_Method Render Engine Functions
*
* Functions that are used to set the render engine for a given
* function, and then get that engine working.
*
* The following code snippet shows how they can be used to
* initialise an evas that uses the X11 software engine:
* @code
* Evas *evas;
* Evas_Engine_Info_Software_X11 *einfo;
* extern Display *display;
* extern Window win;
*
* evas_init();
*
* evas = evas_new();
* evas_output_method_set(evas, evas_render_method_lookup("software_x11"));
* evas_output_size_set(evas, 640, 480);
* evas_output_viewport_set(evas, 0, 0, 640, 480);
* einfo = (Evas_Engine_Info_Software_X11 *)evas_engine_info_get(evas);
* einfo->info.display = display;
* einfo->info.visual = DefaultVisual(display, DefaultScreen(display));
* einfo->info.colormap = DefaultColormap(display, DefaultScreen(display));
* einfo->info.drawable = win;
* einfo->info.depth = DefaultDepth(display, DefaultScreen(display));
* evas_engine_info_set(evas, (Evas_Engine_Info *)einfo);
* @endcode
*
* @ingroup Evas_Canvas
*/
/**
* Look up a numeric ID from a string name of a rendering engine.
*
* @param name the name string of an engine
* @return A numeric (opaque) ID for the rendering engine
* @ingroup Evas_Output_Method
*
* This function looks up a numeric return value for the named engine
* in the string @p name. This is a normal C string, NUL byte
* terminated. The name is case sensitive. If the rendering engine is
* available, a numeric ID for that engine is returned that is not
* 0. If the engine is not available, 0 is returned, indicating an
* invalid engine.
*
* The programmer should NEVER rely on the numeric ID of an engine
* unless it is returned by this function. Programs should NOT be
* written accessing render method ID's directly, without first
* obtaining it from this function.
*
* @attention it is mandatory that one calls evas_init() before
* looking up the render method.
*
* Example:
* @code
* int engine_id;
* Evas *evas;
*
* evas_init();
*
* evas = evas_new();
* if (!evas)
* {
* fprintf(stderr, "ERROR: Canvas creation failed. Fatal error.\n");
* exit(-1);
* }
* engine_id = evas_render_method_lookup("software_x11");
* if (!engine_id)
* {
* fprintf(stderr, "ERROR: Requested rendering engine is absent.\n");
* exit(-1);
* }
* evas_output_method_set(evas, engine_id);
* @endcode
*/
EAPI int evas_render_method_lookup(const char *name) EINA_WARN_UNUSED_RESULT EINA_ARG_NONNULL(1);
/**
* List all the rendering engines compiled into the copy of the Evas library
*
* @return A linked list whose data members are C strings of engine names
* @ingroup Evas_Output_Method
*
* Calling this will return a handle (pointer) to an Evas linked
* list. Each node in the linked list will have the data pointer be a
* (char *) pointer to the name string of the rendering engine
* available. The strings should never be modified, neither should the
* list be modified. This list should be cleaned up as soon as the
* program no longer needs it using evas_render_method_list_free(). If
* no engines are available from Evas, @c NULL will be returned.
*
* Example:
* @code
* Eina_List *engine_list, *l;
* char *engine_name;
*
* engine_list = evas_render_method_list();
* if (!engine_list)
* {
* fprintf(stderr, "ERROR: Evas supports no engines! Exit.\n");
* exit(-1);
* }
* printf("Available Evas Engines:\n");
* EINA_LIST_FOREACH(engine_list, l, engine_name)
* printf("%s\n", engine_name);
* evas_render_method_list_free(engine_list);
* @endcode
*/
EAPI Eina_List *evas_render_method_list(void) EINA_WARN_UNUSED_RESULT;
/**
* This function should be called to free a list of engine names
*
* @param list The Eina_List base pointer for the engine list to be freed
* @ingroup Evas_Output_Method
*
* When this function is called it will free the engine list passed in
* as @p list. The list should only be a list of engines generated by
* calling evas_render_method_list(). If @p list is NULL, nothing will
* happen.
*
* Example:
* @code
* Eina_List *engine_list, *l;
* char *engine_name;
*
* engine_list = evas_render_method_list();
* if (!engine_list)
* {
* fprintf(stderr, "ERROR: Evas supports no engines! Exit.\n");
* exit(-1);
* }
* printf("Available Evas Engines:\n");
* EINA_LIST_FOREACH(engine_list, l, engine_name)
* printf("%s\n", engine_name);
* evas_render_method_list_free(engine_list);
* @endcode
*/
EAPI void evas_render_method_list_free(Eina_List *list);
/**
* 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);
/**
* @defgroup Evas_Output_Size Output and Viewport Resizing Functions
*
* Functions that set and retrieve the output and viewport size of an
* evas.
*
* @ingroup Evas_Canvas
*/
/**
* 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);
/**
* @defgroup Evas_Coord_Mapping_Group Coordinate Mapping Functions
*
* Functions that are used to map coordinates from the canvas to the
* screen or the screen to the canvas.
*
* @ingroup Evas_Canvas
*/
/**
* Convert/scale an ouput screen co-ordinate into canvas co-ordinates
*
* @param e The pointer to the Evas Canvas
* @param x The screen/output x co-ordinate
* @return The screen co-ordinate translated to canvas unit co-ordinates
* @ingroup Evas_Coord_Mapping_Group
*
* This function takes in a horizontal co-ordinate as the @p x
* parameter and converts it into canvas units, accounting for output
* size, viewport size and location, returning it as the function
* return value. If @p e is invalid, the results are undefined.
*
* Example:
* @code
* extern Evas *evas;
* extern int screen_x;
* Evas_Coord canvas_x;
*
* canvas_x = evas_coord_screen_x_to_world(evas, screen_x);
* @endcode
*/
EAPI Evas_Coord evas_coord_screen_x_to_world(const Evas *e, int x) EINA_WARN_UNUSED_RESULT EINA_ARG_NONNULL(1);
/**
* Convert/scale an ouput screen co-ordinate into canvas co-ordinates
*
* @param e The pointer to the Evas Canvas
* @param y The screen/output y co-ordinate
* @return The screen co-ordinate translated to canvas unit co-ordinates
* @ingroup Evas_Coord_Mapping_Group
*
* This function takes in a vertical co-ordinate as the @p y parameter
* and converts it into canvas units, accounting for output size,
* viewport size and location, returning it as the function return
* value. If @p e is invalid, the results are undefined.
*
* Example:
* @code
* extern Evas *evas;
* extern int screen_y;
* Evas_Coord canvas_y;
*
* canvas_y = evas_coord_screen_y_to_world(evas, screen_y);
* @endcode
*/
EAPI Evas_Coord evas_coord_screen_y_to_world(const Evas *e, int y) EINA_WARN_UNUSED_RESULT EINA_ARG_NONNULL(1);
/**
* Convert/scale a canvas co-ordinate into output screen co-ordinates
*
* @param e The pointer to the Evas Canvas
* @param x The canvas x co-ordinate
* @return The output/screen co-ordinate translated to output co-ordinates
* @ingroup Evas_Coord_Mapping_Group
*
* This function takes in a horizontal co-ordinate as the @p x
* parameter and converts it into output units, accounting for output
* size, viewport size and location, returning it as the function
* return value. If @p e is invalid, the results are undefined.
*
* Example:
* @code
* extern Evas *evas;
* int screen_x;
* extern Evas_Coord canvas_x;
*
* screen_x = evas_coord_world_x_to_screen(evas, canvas_x);
* @endcode
*/
EAPI int evas_coord_world_x_to_screen(const Evas *e, Evas_Coord x) EINA_WARN_UNUSED_RESULT EINA_ARG_NONNULL(1);
/**
* Convert/scale a canvas co-ordinate into output screen co-ordinates
*
* @param e The pointer to the Evas Canvas
* @param y The canvas y co-ordinate
* @return The output/screen co-ordinate translated to output co-ordinates
* @ingroup Evas_Coord_Mapping_Group
*
* This function takes in a vertical co-ordinate as the @p x parameter
* and converts it into output units, accounting for output size,
* viewport size and location, returning it as the function return
* value. If @p e is invalid, the results are undefined.
*
* Example:
* @code
* extern Evas *evas;
* int screen_y;
* extern Evas_Coord canvas_y;
*
* screen_y = evas_coord_world_y_to_screen(evas, canvas_y);
* @endcode
*/
EAPI int evas_coord_world_y_to_screen(const Evas *e, Evas_Coord y) EINA_WARN_UNUSED_RESULT EINA_ARG_NONNULL(1);
/**
* @defgroup Evas_Pointer_Group Pointer (Mouse) Functions
*
* Functions that deal with the status of the pointer (mouse cursor).
*
* @ingroup Evas_Canvas
*/
/**
* This function returns the current known pointer co-ordinates
*
* @param e The pointer to the Evas Canvas
* @param x The pointer to an integer to be filled in
* @param y The pointer to an integer to be filled in
* @ingroup Evas_Pointer_Group
*
* This function returns the current known screen/output co-ordinates
* of the mouse pointer and sets the contents of the integers pointed
* to by @p x and @p y to contain these co-ordinates. If @p e is not a
* valid canvas the results of this function are undefined.
*
* Example:
* @code
* extern Evas *evas;
* int mouse_x, mouse_y;
*
* evas_pointer_output_xy_get(evas, &mouse_x, &mouse_y);
* printf("Mouse is at screen position %i, %i\n", mouse_x, mouse_y);
* @endcode
*/
EAPI void evas_pointer_output_xy_get(const Evas *e, int *x, int *y) EINA_ARG_NONNULL(1);
/**
* This function returns the current known pointer co-ordinates
*
* @param e The pointer to the Evas Canvas
* @param x The pointer to a Evas_Coord to be filled in
* @param y The pointer to a Evas_Coord to be filled in
* @ingroup Evas_Pointer_Group
*
* This function returns the current known canvas unit co-ordinates of
* the mouse pointer and sets the contents of the Evas_Coords pointed
* to by @p x and @p y to contain these co-ordinates. If @p e is not a
* valid canvas the results of this function are undefined.
*
* Example:
* @code
* extern Evas *evas;
* Evas_Coord mouse_x, mouse_y;
*
* evas_pointer_output_xy_get(evas, &mouse_x, &mouse_y);
* printf("Mouse is at canvas position %f, %f\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);
#define EVAS_CLASS evas_class_get()
const Eo_Class *evas_class_get(void) EINA_CONST;
extern EAPI Eo_Op EVAS_CANVAS_BASE_ID;
enum
{
EVAS_CANVAS_SUB_ID_OUTPUT_METHOD_SET,
EVAS_CANVAS_SUB_ID_OUTPUT_METHOD_GET,
EVAS_CANVAS_SUB_ID_ENGINE_INFO_GET,
EVAS_CANVAS_SUB_ID_ENGINE_INFO_SET,
EVAS_CANVAS_SUB_ID_OUTPUT_SIZE_SET,
EVAS_CANVAS_SUB_ID_OUTPUT_SIZE_GET,
EVAS_CANVAS_SUB_ID_OUTPUT_VIEWPORT_SET,
EVAS_CANVAS_SUB_ID_OUTPUT_VIEWPORT_GET,
EVAS_CANVAS_SUB_ID_OUTPUT_FRAMESPACE_SET,
EVAS_CANVAS_SUB_ID_OUTPUT_FRAMESPACE_GET,
EVAS_CANVAS_SUB_ID_COORD_SCREEN_X_TO_WORLD,
EVAS_CANVAS_SUB_ID_COORD_SCREEN_Y_TO_WORLD,
EVAS_CANVAS_SUB_ID_COORD_WORLD_X_TO_SCREEN,
EVAS_CANVAS_SUB_ID_COORD_WORLD_Y_TO_SCREEN,
EVAS_CANVAS_SUB_ID_POINTER_OUTPUT_XY_GET,
EVAS_CANVAS_SUB_ID_POINTER_CANVAS_XY_GET,
EVAS_CANVAS_SUB_ID_POINTER_BUTTON_DOWN_MASK_GET,
EVAS_CANVAS_SUB_ID_POINTER_INSIDE_GET,
EVAS_CANVAS_SUB_ID_DATA_ATTACH_SET,
EVAS_CANVAS_SUB_ID_DATA_ATTACH_GET,
EVAS_CANVAS_SUB_ID_FOCUS_IN,
EVAS_CANVAS_SUB_ID_FOCUS_OUT,
EVAS_CANVAS_SUB_ID_FOCUS_STATE_GET,
EVAS_CANVAS_SUB_ID_NOCHANGE_PUSH,
EVAS_CANVAS_SUB_ID_NOCHANGE_POP,
EVAS_CANVAS_SUB_ID_EVENT_DEFAULT_FLAGS_SET,
EVAS_CANVAS_SUB_ID_EVENT_DEFAULT_FLAGS_GET,
EVAS_CANVAS_SUB_ID_EVENT_FEED_MOUSE_DOWN,
EVAS_CANVAS_SUB_ID_EVENT_FEED_MOUSE_UP,
EVAS_CANVAS_SUB_ID_EVENT_FEED_MOUSE_CANCEL,
EVAS_CANVAS_SUB_ID_EVENT_FEED_MOUSE_WHEEL,
EVAS_CANVAS_SUB_ID_EVENT_FEED_MOUSE_MOVE,
EVAS_CANVAS_SUB_ID_EVENT_FEED_MOUSE_IN,
EVAS_CANVAS_SUB_ID_EVENT_FEED_MOUSE_OUT,
EVAS_CANVAS_SUB_ID_EVENT_FEED_MULTI_DOWN,
EVAS_CANVAS_SUB_ID_EVENT_FEED_MULTI_UP,
EVAS_CANVAS_SUB_ID_EVENT_FEED_MULTI_MOVE,
EVAS_CANVAS_SUB_ID_EVENT_FEED_KEY_DOWN,
EVAS_CANVAS_SUB_ID_EVENT_FEED_KEY_UP,
EVAS_CANVAS_SUB_ID_EVENT_FEED_HOLD,
EVAS_CANVAS_SUB_ID_EVENT_REFEED_EVENT,
EVAS_CANVAS_SUB_ID_EVENT_DOWN_COUNT_GET,
EVAS_CANVAS_SUB_ID_FOCUS_GET,
EVAS_CANVAS_SUB_ID_FONT_PATH_CLEAR,
EVAS_CANVAS_SUB_ID_FONT_PATH_APPEND,
EVAS_CANVAS_SUB_ID_FONT_PATH_PREPEND,
EVAS_CANVAS_SUB_ID_FONT_PATH_LIST,
EVAS_CANVAS_SUB_ID_FONT_HINTING_SET,
EVAS_CANVAS_SUB_ID_FONT_HINTING_GET,
EVAS_CANVAS_SUB_ID_FONT_HINTING_CAN_HINT,
EVAS_CANVAS_SUB_ID_FONT_CACHE_FLUSH,
EVAS_CANVAS_SUB_ID_FONT_CACHE_SET,
EVAS_CANVAS_SUB_ID_FONT_CACHE_GET,
EVAS_CANVAS_SUB_ID_FONT_AVAILABLE_LIST,
EVAS_CANVAS_SUB_ID_KEY_MODIFIER_GET,
EVAS_CANVAS_SUB_ID_KEY_LOCK_GET,
EVAS_CANVAS_SUB_ID_KEY_MODIFIER_ADD,
EVAS_CANVAS_SUB_ID_KEY_MODIFIER_DEL,
EVAS_CANVAS_SUB_ID_KEY_LOCK_ADD,
EVAS_CANVAS_SUB_ID_KEY_LOCK_DEL,
EVAS_CANVAS_SUB_ID_KEY_MODIFIER_ON,
EVAS_CANVAS_SUB_ID_KEY_MODIFIER_OFF,
EVAS_CANVAS_SUB_ID_KEY_LOCK_ON,
EVAS_CANVAS_SUB_ID_KEY_LOCK_OFF,
EVAS_CANVAS_SUB_ID_KEY_MODIFIER_MASK_GET,
EVAS_CANVAS_SUB_ID_DAMAGE_RECTANGLE_ADD,
EVAS_CANVAS_SUB_ID_OBSCURED_RECTANGLE_ADD,
EVAS_CANVAS_SUB_ID_OBSCURED_CLEAR,
EVAS_CANVAS_SUB_ID_RENDER_UPDATES,
EVAS_CANVAS_SUB_ID_RENDER,
EVAS_CANVAS_SUB_ID_NORENDER,
EVAS_CANVAS_SUB_ID_RENDER_IDLE_FLUSH,
EVAS_CANVAS_SUB_ID_SYNC,
EVAS_CANVAS_SUB_ID_RENDER_DUMP,
EVAS_CANVAS_SUB_ID_OBJECT_BOTTOM_GET,
EVAS_CANVAS_SUB_ID_OBJECT_TOP_GET,
EVAS_CANVAS_SUB_ID_TOUCH_POINT_LIST_COUNT,
EVAS_CANVAS_SUB_ID_TOUCH_POINT_LIST_NTH_XY_GET,
EVAS_CANVAS_SUB_ID_TOUCH_POINT_LIST_NTH_ID_GET,
EVAS_CANVAS_SUB_ID_TOUCH_POINT_LIST_NTH_STATE_GET,
EVAS_CANVAS_SUB_ID_IMAGE_CACHE_FLUSH,
EVAS_CANVAS_SUB_ID_IMAGE_CACHE_RELOAD,
EVAS_CANVAS_SUB_ID_IMAGE_CACHE_SET,
EVAS_CANVAS_SUB_ID_IMAGE_CACHE_GET,
EVAS_CANVAS_SUB_ID_IMAGE_MAX_SIZE_GET,
EVAS_CANVAS_SUB_ID_OBJECT_NAME_FIND,
EVAS_CANVAS_SUB_ID_OBJECT_TOP_AT_XY_GET,
EVAS_CANVAS_SUB_ID_OBJECT_TOP_IN_RECTANGLE_GET,
EVAS_CANVAS_SUB_ID_OBJECTS_AT_XY_GET,
EVAS_CANVAS_SUB_ID_OBJECTS_IN_RECTANGLE_GET,
EVAS_CANVAS_SUB_ID_SMART_OBJECTS_CALCULATE,
EVAS_CANVAS_SUB_ID_SMART_OBJECTS_CALCULATE_COUNT_GET,
EVAS_CANVAS_SUB_ID_RENDER_ASYNC,
EVAS_CANVAS_SUB_ID_LAST
};
#define EVAS_CANVAS_ID(sub_id) (EVAS_CANVAS_BASE_ID + sub_id)
/**
* @def evas_canvas_output_method_set
* @since 1.8
*
* Sets the output engine for the given evas.
*
* @param[in] render_method
*
* @see evas_output_method_set
*/
#define evas_canvas_output_method_set(render_method) EVAS_CANVAS_ID(EVAS_CANVAS_SUB_ID_OUTPUT_METHOD_SET), EO_TYPECHECK(int, render_method)
/**
* @def evas_canvas_output_method_get
* @since 1.8
*
* Retrieves the number of the output engine used for the given evas.
*
* @param[out] ret
*
* @see evas_output_method_get
*/
#define evas_canvas_output_method_get(ret) EVAS_CANVAS_ID(EVAS_CANVAS_SUB_ID_OUTPUT_METHOD_GET), EO_TYPECHECK(int *, ret)
/**
* @def evas_canvas_engine_info_get
* @since 1.8
*
* Retrieves the current render engine info struct from the given evas.
*
* @param[out] ret
*
* @see evas_engine_info_get
*/
#define evas_canvas_engine_info_get(ret) EVAS_CANVAS_ID(EVAS_CANVAS_SUB_ID_ENGINE_INFO_GET), EO_TYPECHECK(Evas_Engine_Info **, ret)
/**
* @def evas_canvas_engine_info_set
* @since 1.8
*
* Applies the engine settings for the given evas from the given @c
* Evas_Engine_Info structure.
*
* @param[in] info
* @param[out] ret
*
* @see evas_engine_info_set
*/
#define evas_canvas_engine_info_set(info, ret) EVAS_CANVAS_ID(EVAS_CANVAS_SUB_ID_ENGINE_INFO_SET), EO_TYPECHECK(Evas_Engine_Info *, info), EO_TYPECHECK(Eina_Bool *, ret)
/**
* @def evas_canvas_output_size_set
* @since 1.8
*
* Sets the output size of the render engine of the given evas.
*
* @param[in] w
* @param[in] h
*
* @see evas_output_size_set
*/
#define evas_canvas_output_size_set(w, h) EVAS_CANVAS_ID(EVAS_CANVAS_SUB_ID_OUTPUT_SIZE_SET), EO_TYPECHECK(int, w), EO_TYPECHECK(int, h)
/**
* @def evas_canvas_output_size_get
* @since 1.8
*
* Retrieve the output size of the render engine of the given evas.
*
* @param[out] w
* @param[out] h
*
* @see evas_output_size_get
*/
#define evas_canvas_output_size_get(w, h) EVAS_CANVAS_ID(EVAS_CANVAS_SUB_ID_OUTPUT_SIZE_GET), EO_TYPECHECK(int *, w), EO_TYPECHECK(int *, h)
/**
* @def evas_canvas_output_viewport_set
* @since 1.8
*
* Sets the output viewport of the given evas in evas units.
*
* @param[in] x
* @param[in] y
* @param[in] w
* @param[in] h
*
* @see evas_output_viewport_set
*/
#define evas_canvas_output_viewport_set(x, y, w, h) EVAS_CANVAS_ID(EVAS_CANVAS_SUB_ID_OUTPUT_VIEWPORT_SET), EO_TYPECHECK(Evas_Coord, x), EO_TYPECHECK(Evas_Coord, y), EO_TYPECHECK(Evas_Coord, w), EO_TYPECHECK(Evas_Coord, h)
/**
* @def evas_canvas_output_viewport_get
* @since 1.8
*
* Get the render engine's output viewport co-ordinates in canvas units.
*
* @param[out] x
* @param[out] y
* @param[out] w
* @param[out] h
*
* @see evas_output_viewport_get
*/
#define evas_canvas_output_viewport_get(x, y, w, h) EVAS_CANVAS_ID(EVAS_CANVAS_SUB_ID_OUTPUT_VIEWPORT_GET), EO_TYPECHECK(Evas_Coord *, x), EO_TYPECHECK(Evas_Coord *, y), EO_TYPECHECK(Evas_Coord *, w), EO_TYPECHECK(Evas_Coord *, h)
/**
* @def evas_canvas_output_framespace_set
* @since 1.8
*
* Sets the output framespace size of the render engine of the given evas.
*
* @param[in] x
* @param[in] y
* @param[in] w
* @param[in] h
*
* @see evas_output_framespace_set
*/
#define evas_canvas_output_framespace_set(x, y, w, h) EVAS_CANVAS_ID(EVAS_CANVAS_SUB_ID_OUTPUT_FRAMESPACE_SET), EO_TYPECHECK(Evas_Coord, x), EO_TYPECHECK(Evas_Coord, y), EO_TYPECHECK(Evas_Coord, w), EO_TYPECHECK(Evas_Coord, h)
/**
* @def evas_canvas_output_framespace_get
* @since 1.8
*
* Get the render engine's output framespace co-ordinates in canvas units.
*
* @param[out] x
* @param[out] y
* @param[out] w
* @param[out] h
*
* @see evas_output_framespace_get
*/
#define evas_canvas_output_framespace_get(x, y, w, h) EVAS_CANVAS_ID(EVAS_CANVAS_SUB_ID_OUTPUT_FRAMESPACE_GET), EO_TYPECHECK(Evas_Coord *, x), EO_TYPECHECK(Evas_Coord *, y), EO_TYPECHECK(Evas_Coord *, w), EO_TYPECHECK(Evas_Coord *, h)
/**
* @def evas_canvas_coord_screen_x_to_world
* @since 1.8
*
* Convert/scale an ouput screen co-ordinate into canvas co-ordinates
*
* @param[in] x
* @param[out] ret
*
* @see evas_coord_screen_x_to_world
*/
#define evas_canvas_coord_screen_x_to_world(x, ret) EVAS_CANVAS_ID(EVAS_CANVAS_SUB_ID_COORD_SCREEN_X_TO_WORLD), EO_TYPECHECK(int, x), EO_TYPECHECK(Evas_Coord *, ret)
/**
* @def evas_canvas_coord_screen_y_to_world
* @since 1.8
*
* Convert/scale an ouput screen co-ordinate into canvas co-ordinates
*
* @param[in] y
* @param[out] ret
*
* @see evas_coord_screen_y_to_world
*/
#define evas_canvas_coord_screen_y_to_world(y, ret) EVAS_CANVAS_ID(EVAS_CANVAS_SUB_ID_COORD_SCREEN_Y_TO_WORLD), EO_TYPECHECK(int, y), EO_TYPECHECK(Evas_Coord *, ret)
/**
* @def evas_canvas_coord_world_x_to_screen
* @since 1.8
*
* Convert/scale a canvas co-ordinate into output screen co-ordinates
*
* @param[in] x
* @param[out] ret
*
* @see evas_coord_world_x_to_screen
*/
#define evas_canvas_coord_world_x_to_screen(x, ret) EVAS_CANVAS_ID(EVAS_CANVAS_SUB_ID_COORD_WORLD_X_TO_SCREEN), EO_TYPECHECK(Evas_Coord, x), EO_TYPECHECK(int *, ret)
/**
* @def evas_canvas_coord_world_y_to_screen
* @since 1.8
*
* Convert/scale a canvas co-ordinate into output screen co-ordinates
*
* @param[in] y
* @param[out] ret
*
* @see evas_coord_world_y_to_screen
*/
#define evas_canvas_coord_world_y_to_screen(y, ret) EVAS_CANVAS_ID(EVAS_CANVAS_SUB_ID_COORD_WORLD_Y_TO_SCREEN), EO_TYPECHECK(Evas_Coord, y), EO_TYPECHECK(int *, ret)
/**
* @def evas_canvas_pointer_output_xy_get
* @since 1.8
*
* This function returns the current known pointer co-ordinates
*
* @param[out] x
* @param[out] y
*
* @see evas_pointer_output_xy_get
*/
#define evas_canvas_pointer_output_xy_get(x, y) EVAS_CANVAS_ID(EVAS_CANVAS_SUB_ID_POINTER_OUTPUT_XY_GET), EO_TYPECHECK(int *, x), EO_TYPECHECK(int *, y)
/**
* @def evas_canvas_pointer_canvas_xy_get
* @since 1.8
*
* This function returns the current known pointer co-ordinates
*
* @param[out] x
* @param[out] y
*
* @see evas_pointer_canvas_xy_get
*/
#define evas_canvas_pointer_canvas_xy_get(x, y) EVAS_CANVAS_ID(EVAS_CANVAS_SUB_ID_POINTER_CANVAS_XY_GET), EO_TYPECHECK(Evas_Coord *, x), EO_TYPECHECK(Evas_Coord *, y)
/**
* @def evas_canvas_pointer_button_down_mask_get
* @since 1.8
*
* Returns a bitmask with the mouse buttons currently pressed, set to 1
*
* @param[out] ret
*
* @see evas_pointer_button_down_mask_get
*/
#define evas_canvas_pointer_button_down_mask_get(ret) EVAS_CANVAS_ID(EVAS_CANVAS_SUB_ID_POINTER_BUTTON_DOWN_MASK_GET), EO_TYPECHECK(int *, ret)
/**
* @def evas_canvas_pointer_inside_get
* @since 1.8
*
* Returns whether the mouse pointer is logically inside the canvas
*
* @param[out] ret
*
* @see evas_pointer_inside_get
*/
#define evas_canvas_pointer_inside_get(ret) EVAS_CANVAS_ID(EVAS_CANVAS_SUB_ID_POINTER_INSIDE_GET), EO_TYPECHECK(Eina_Bool *, ret)
/**
* @def evas_canvas_data_attach_set
* @since 1.8
*
* Attaches a specific pointer to the evas for fetching later
*
* @param[in] data
*
* @see evas_data_attach_set
*/
#define evas_canvas_data_attach_set(data) EVAS_CANVAS_ID(EVAS_CANVAS_SUB_ID_DATA_ATTACH_SET), EO_TYPECHECK(void *, data)
/**
* @def evas_canvas_data_attach_get
* @since 1.8
*
* Returns the pointer attached by evas_data_attach_set()
*
* @param[out] ret
*
* @see evas_data_attach_get