Tizen Native API
Typedefs | Defines
Evas
EFL

Evas provide a clean display canvas API.

See Evas for more details

Typedefs

typedef struct _Evas_Version Evas_Version
 The version of Evas.
typedef enum _Evas_Callback_Type Evas_Callback_Type
 Identifier of callbacks to be set for Evas canvases or Evas objects.
typedef short Evas_Callback_Priority
 Callback priority value. Range is -32k to 32k. The lower the number, the higher the priority.
typedef enum _Evas_Button_Flags Evas_Button_Flags
 Enumeration for Mouse Button events.
typedef enum _Evas_Event_Flags Evas_Event_Flags
 Enumeration for events.
typedef enum
_Evas_Touch_Point_State 		Evas_Touch_Point_State
 Enumeration for touch point states.
typedef enum
_Evas_Font_Hinting_Flags 		Evas_Font_Hinting_Flags
 Enumeration for font hinting.
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.
typedef struct _Evas_Position Evas_Position
 Associates the given point in Canvas and Output.
typedef struct
_Evas_Precision_Position 		Evas_Precision_Position
 Associates the given point in Canvas and Output, with sub-pixel precision.
typedef struct _Evas_Smart_Class Evas_Smart_Class
 A smart object base class definition.
typedef struct
_Evas_Smart_Interface 		Evas_Smart_Interface
 A smart object base interface definition.
typedef struct
_Evas_Smart_Cb_Description 		Evas_Smart_Cb_Description
 A smart object callback description, used to provide introspection.
typedef void Evas_Performance
 Evas Performance handle.
typedef struct _Evas_Modifier Evas_Modifier
 Opaque type containing information on which modifier keys are registered in an Evas canvas.
typedef struct _Evas_Lock Evas_Lock
 Opaque type containing information on which lock keys are registered in an Evas canvas.
typedef struct _Evas_Smart Evas_Smart
 Evas Smart Object handle.
typedef struct _Evas_Native_Surface Evas_Native_Surface
 Generic datatype for engine specific native surface information.
typedef struct _Evas_Video_Surface Evas_Video_Surface
 A generic data type for video specific surface information.
typedef unsigned long long Evas_Modifier_Mask
 An Evas modifier mask type.
typedef int Evas_Coord
 Evas x y coordinates.
typedef int Evas_Font_Size
 Evas Font Sizes.
typedef int Evas_Angle
 Evas angle.
typedef enum _Evas_Aspect_Control Evas_Aspect_Control
 Enumeration for aspect types or policies for scaling size hints, used for evas_object_size_hint_aspect_set().
typedef enum _Evas_Display_Mode Evas_Display_Mode
 Enumeration for object's display modes.
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
 Enumeration for load errors.
typedef enum _Evas_Alloc_Error Evas_Alloc_Error
 Enumeration for allocation errors.
typedef enum _Evas_Fill_Spread Evas_Fill_Spread
 Enumeration for spread of image fill.
typedef enum
_Evas_Pixel_Import_Pixel_Format 		Evas_Pixel_Import_Pixel_Format
 Enumeration for aspect types or policies.
typedef enum
_Evas_Native_Surface_Type 		Evas_Native_Surface_Type
 Native surface types that image object supports.
typedef enum _Evas_Border_Fill_Mode Evas_Border_Fill_Mode
 Enumeration for border fill mode.
typedef enum _Evas_Image_Scale_Hint Evas_Image_Scale_Hint
 Enumeration for image scale hints.
typedef enum
_Evas_Image_Animated_Loop_Hint 		Evas_Image_Animated_Loop_Hint
 Enumeration for animated loop hints.
typedef enum
_Evas_Engine_Render_Mode 		Evas_Engine_Render_Mode
 Enumeration for engine rendering modes.
typedef enum
_Evas_Image_Content_Hint 		Evas_Image_Content_Hint
 Enumeration for image content hints.
typedef enum _Evas_Device_Class Evas_Device_Class
 Enumeration for device class.
typedef void(* Evas_Async_Events_Put_Cb )(void *target, Evas_Callback_Type type, void *event_info)
 Evas Async events put function signature.

Defines

#define EVAS_CALLBACK_PRIORITY_BEFORE   -100
 Slightly more prioritized than default.
#define EVAS_CALLBACK_PRIORITY_DEFAULT   0
 Default callback priority level.
#define EVAS_CALLBACK_PRIORITY_AFTER   100
 Slightly less prioritized than default.
#define EVAS_VIDEO_SURFACE_VERSION   1
 Definition of the magic version number to know what the video surf struct looks like.
#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()

Evas

Date:
2000 (created)

Table of Contents

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 is small and lean, and is 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.

What Evas is not?

Evas is not a widget set or widget toolkit, however it is their base. See Elementary for a toolkit based on Evas, Edje, 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 does not create windows or report windows updates to your system, but just draws the pixels and report to the user the areas that were changed.

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 executes a series of commands, as in the pseudo code:

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

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 on how to redraw sections of the screen whenever needed. Each successive command is 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 that more and more logic and display rendering code needs to be written each time the application needs to figure out how to minimise redraws so that display is fast and interactive, and keeps track of redraw logic. The power comes at a high-price, with lots of extra code and work. Programmers not very familiar with graphics programming often make mistakes at this level and produce code that is sub optimal. Those familiar with this kind of programming 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:

 * Redraw from position (0, 0) to position (50, 50):
 *
 * // what is 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);
 *

You 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! You 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 you quickly realize that 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:

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

This may look longer, but when the display needs to be refreshed or updated, you move, resize, show, or hide the objects that need to change. You can simply think at the object logic level, and the canvas software does the rest of the work for you, figuring out what actually changed in the canvas since it had been 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 you 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, and so on. Since Evas also is portable across different display systems, this also gives you 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, and push buttons.

Next Steps

After you understood what Evas is and installed it in your system you should proceed to understand the programming interface for all objects, and then see the specifics for the most used elements. You should take a while to learn Ecore and Edje as they likely save you tons of work compared to using just Evas directly.

Recommended reading:

Define Documentation

#define EVAS_CALLBACK_PRIORITY_AFTER   100

Slightly less prioritized than default.

Since (EFL) :
1.1
#define EVAS_CALLBACK_PRIORITY_BEFORE   -100

Slightly more prioritized than default.

Since (EFL) :
1.1
#define EVAS_CALLBACK_PRIORITY_DEFAULT   0

Default callback priority level.

Since (EFL) :
1.1
#define EVAS_VIDEO_SURFACE_VERSION   1

Definition of the magic version number to know what the video surf struct looks like.

Since (EFL) :
1.1

Typedef Documentation

typedef enum _Evas_Alloc_Error Evas_Alloc_Error

Enumeration for allocation errors.

Possible allocation errors returned.

typedef enum _Evas_Aspect_Control Evas_Aspect_Control

Enumeration for aspect types or policies for scaling size hints, used for evas_object_size_hint_aspect_set().

Aspect types or policies for scaling size hints, used for evas_object_size_hint_aspect_set()

typedef void(* Evas_Async_Events_Put_Cb)(void *target, Evas_Callback_Type type, void *event_info)

Evas Async events put function signature.

Since :
2.3.1
typedef enum _Evas_Border_Fill_Mode Evas_Border_Fill_Mode

Enumeration for border fill mode.

How an image's center region (the complement to the border region) should be rendered by Evas

typedef enum _Evas_Button_Flags Evas_Button_Flags

Enumeration for Mouse Button events.

Flags for Mouse Button events

Evas_Callback_Priority

Callback priority value. Range is -32k to 32k. The lower the number, the higher the priority.

Since (EFL) :
1.1
See also:
EVAS_CALLBACK_PRIORITY_AFTER
EVAS_CALLBACK_PRIORITY_BEFORE
EVAS_CALLBACK_PRIORITY_DEFAULT
typedef enum _Evas_Callback_Type Evas_Callback_Type

Identifier of callbacks to be set for Evas canvases or Evas objects.

The following figure illustrates some Evas callbacks:

evas-callbacks.png
See also:
evas_object_event_callback_add()
evas_event_callback_add() The types of events triggering a callback
typedef struct _Evas_Coord_Size Evas_Coord_Size

Evas_Coord size.

Since (EFL) :
1.8
typedef enum _Evas_Display_Mode Evas_Display_Mode

Enumeration for object's display modes.

Object display mode type related with compress and expand or etc mode

typedef enum _Evas_Event_Flags Evas_Event_Flags

Enumeration for events.

Flags for Events

typedef enum _Evas_Fill_Spread Evas_Fill_Spread

Enumeration for spread of image fill.

Fill types used for evas_object_image_fill_spread_set()

typedef enum _Evas_Font_Hinting_Flags Evas_Font_Hinting_Flags

Enumeration for font hinting.

Flags for Font Hinting

typedef enum _Evas_Image_Content_Hint Evas_Image_Content_Hint

Enumeration for image content hints.

How an image's data is to be treated by Evas, for optimization

typedef enum _Evas_Image_Scale_Hint Evas_Image_Scale_Hint

Enumeration for image scale hints.

How an image's data is to be treated by Evas, with regard to scaling cache

typedef enum _Evas_Load_Error Evas_Load_Error

Enumeration for load errors.

Evas image load error codes one can get - see evas_load_error_str()

typedef enum _Evas_Native_Surface_Type Evas_Native_Surface_Type

Native surface types that image object supports.

See also:
Evas_Native_Surface
evas_object_image_native_surface_set()
typedef enum _Evas_Pixel_Import_Pixel_Format Evas_Pixel_Import_Pixel_Format

Enumeration for aspect types or policies.

Pixel format for import call. See evas_object_image_pixels_import()

Evas_Smart_Interface

A smart object base interface definition.

Since (EFL) :
1.7
Remarks:
An Evas interface is exactly like the OO-concept: It is a 'contract' or API that the object is declared to support. A smart object may have more than one interface, thus extending the behavior it gets from sub-classing.
Evas_Video_Surface

A generic data type for video specific surface information.

Since (EFL) :
1.1
See also:
evas_object_image_video_surface_set
evas_object_image_video_surface_get

Enumeration Type Documentation

enum _Evas_Alloc_Error

Enumeration for allocation errors.

Enumerator:
EVAS_ALLOC_ERROR_NONE 

No allocation error

EVAS_ALLOC_ERROR_FATAL 

Allocation failed despite attempts to free up memory

EVAS_ALLOC_ERROR_RECOVERED 

Allocation succeeded, but extra memory had to be found by freeing up speculative resources

enum _Evas_Aspect_Control

Enumeration for aspect types or policies for scaling size hints, used for evas_object_size_hint_aspect_set().

Enumerator:
EVAS_ASPECT_CONTROL_NONE 

Unset scaling preference

EVAS_ASPECT_CONTROL_NEITHER 

Same effect as unset preference on scaling

EVAS_ASPECT_CONTROL_HORIZONTAL 

Use all horizontal container space to place an object, using the given aspect

EVAS_ASPECT_CONTROL_VERTICAL 

Use all vertical container space to place an object, using the given aspect

EVAS_ASPECT_CONTROL_BOTH 

Use all horizontal and vertical container spaces to place an object (never growing it out of those bounds), using the given aspect

enum _Evas_Border_Fill_Mode

Enumeration for border fill mode.

Enumerator:
EVAS_BORDER_FILL_NONE 

Image's center region is not to be rendered

EVAS_BORDER_FILL_DEFAULT 

Image's center region is to be blended with objects underneath it, if it has transparency. This is the default behavior for image objects

EVAS_BORDER_FILL_SOLID 

Image's center region is to be made solid, even if it has transparency on it

enum _Evas_Button_Flags

Enumeration for Mouse Button events.

Enumerator:
EVAS_BUTTON_NONE 

No extra mouse button data

EVAS_BUTTON_DOUBLE_CLICK 

Second press of a double click

EVAS_BUTTON_TRIPLE_CLICK 

Third press of a triple click

enum _Evas_Callback_Type

Identifier of callbacks to be set for Evas canvases or Evas objects.

The following figure illustrates some Evas callbacks:

evas-callbacks.png
See also:
evas_object_event_callback_add()
evas_event_callback_add()
Enumerator:
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 

Hold Event, Informational purpose event to indicate something

EVAS_CALLBACK_CHANGED_SIZE_HINTS 

Size hints changed event

EVAS_CALLBACK_IMAGE_PRELOADED 

Image has been preloaded

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

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 (EFL) :
1.2
EVAS_CALLBACK_RENDER_POST 

Called just after rendering stops on the canvas target

Since (EFL) :
1.2
EVAS_CALLBACK_IMAGE_RESIZE 

Image size is changed

Since (EFL) :
1.8
EVAS_CALLBACK_DEVICE_CHANGED 

Devices added, removed or changed on canvas

Since (EFL) :
1.8
EVAS_CALLBACK_LAST 

Last element/sentinel -- not really an event

enum _Evas_Device_Class

Enumeration for device class.

Enumerator:
EVAS_DEVICE_CLASS_NONE 

Not a device

Since (EFL) :
1.8
EVAS_DEVICE_CLASS_SEAT 

The user/seat (the user themselves)

Since (EFL) :
1.8
EVAS_DEVICE_CLASS_KEYBOARD 

Regular keyboard, numberpad or attached buttons

Since (EFL) :
1.8
EVAS_DEVICE_CLASS_MOUSE 

Mouse, trackball or touchpad relative motion device

Since (EFL) :
1.8
EVAS_DEVICE_CLASS_TOUCH 

Touchscreen with fingers or stylus

Since (EFL) :
1.8
EVAS_DEVICE_CLASS_PEN 

Special pen device

Since (EFL) :
1.8
EVAS_DEVICE_CLASS_POINTER 

Laser pointer, wii-style or "minority report" pointing device

Since (EFL) :
1.8
EVAS_DEVICE_CLASS_GAMEPAD 

Gamepad controller or joystick

Since (EFL) :
1.8
enum _Evas_Display_Mode

Enumeration for object's display modes.

Enumerator:
EVAS_DISPLAY_MODE_NONE 

Default display mode

EVAS_DISPLAY_MODE_INHERIT 

Object display mode depends on its ancestor display mode

EVAS_DISPLAY_MODE_COMPRESS 

Give compress display mode hint to object

EVAS_DISPLAY_MODE_EXPAND 

Give expand display mode hint to object

EVAS_DISPLAY_MODE_DONT_CHANGE 

Object does not change display mode

enum _Evas_Event_Flags

Enumeration for events.

Enumerator:
EVAS_EVENT_FLAG_NONE 

No fancy flags set

EVAS_EVENT_FLAG_ON_HOLD 

The 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 for some indications visually, but should not actually perform anything.

EVAS_EVENT_FLAG_ON_SCROLL 

The event occurs while scrolling
For example, DOWN event occurs during scrolling; the event should be used for informational purposes and maybe for some indications visually, but should not actually perform anything.

enum _Evas_Fill_Spread

Enumeration for spread of image fill.

Enumerator:
EVAS_TEXTURE_REFLECT 

Image fill tiling mode - tiling reflects

EVAS_TEXTURE_REPEAT 

Tiling repeats

EVAS_TEXTURE_RESTRICT 

Tiling clamps - range offset ignored

EVAS_TEXTURE_RESTRICT_REFLECT 

Tiling clamps and any range offset reflects

EVAS_TEXTURE_RESTRICT_REPEAT 

Tiling clamps and any range offset repeats

EVAS_TEXTURE_PAD 

Tiling extends with end values

enum _Evas_Font_Hinting_Flags

Enumeration for font hinting.

Enumerator:
EVAS_FONT_HINTING_NONE 

No font hinting

EVAS_FONT_HINTING_AUTO 

Automatic font hinting

EVAS_FONT_HINTING_BYTECODE 

Bytecode font hinting

enum _Evas_Image_Animated_Loop_Hint

Enumeration for animated loop hints.

Enumerator:
EVAS_IMAGE_ANIMATED_HINT_LOOP 

Image's animation mode is loop like 1->2->3->1->2->3

EVAS_IMAGE_ANIMATED_HINT_PINGPONG 

Image's animation mode is pingpong like 1->2->3->2->1-> ...

enum _Evas_Image_Content_Hint

Enumeration for image content hints.

Enumerator:
EVAS_IMAGE_CONTENT_HINT_NONE 

No hint at all

EVAS_IMAGE_CONTENT_HINT_DYNAMIC 

The contents change over time

EVAS_IMAGE_CONTENT_HINT_STATIC 

The contents do not change over time

enum _Evas_Image_Scale_Hint

Enumeration for image scale hints.

Enumerator:
EVAS_IMAGE_SCALE_HINT_NONE 

No scale hint at all

EVAS_IMAGE_SCALE_HINT_DYNAMIC 

Image is being re-scaled over time, thus turning scaling cache off for its data

EVAS_IMAGE_SCALE_HINT_STATIC 

Image is not being re-scaled over time, thus turning scaling cache on for its data

enum _Evas_Load_Error

Enumeration for load errors.

Enumerator:
EVAS_LOAD_ERROR_NONE 

No error on load

EVAS_LOAD_ERROR_GENERIC 

A non-specific error occurred

EVAS_LOAD_ERROR_DOES_NOT_EXIST 

File (or file path) does not exist

EVAS_LOAD_ERROR_PERMISSION_DENIED 

Permission denied to an existing file (or path)

EVAS_LOAD_ERROR_RESOURCE_ALLOCATION_FAILED 

Allocation of resources failure prevented load

EVAS_LOAD_ERROR_CORRUPT_FILE 

File corrupt (but is detected as a known format)

EVAS_LOAD_ERROR_UNKNOWN_FORMAT 

File is not a known format

enum _Evas_Native_Surface_Type

Native surface types that image object supports.

See also:
Evas_Native_Surface
evas_object_image_native_surface_set()
Enumerator:
EVAS_NATIVE_SURFACE_NONE 

No surface type

EVAS_NATIVE_SURFACE_X11 

X Window system based type. pixmap id or visual of the pixmap

EVAS_NATIVE_SURFACE_OPENGL 

OpenGL system based type. texture or framebuffer id

EVAS_NATIVE_SURFACE_TBM 

Tizen system based type. This is used for tizen buffer manager.

EVAS_NATIVE_SURFACE_EVASGL 

Evas GL based type. evas gl surface

enum _Evas_Pixel_Import_Pixel_Format

Enumeration for aspect types or policies.

Enumerator:
EVAS_PIXEL_FORMAT_NONE 

No pixel format

EVAS_PIXEL_FORMAT_ARGB32 

ARGB 32bit pixel format with A in the high byte per 32bit pixel word

EVAS_PIXEL_FORMAT_YUV420P_601 

YUV 420 Planar format with CCIR 601 color encoding with contiguous planes in the order Y, U and V

enum _Evas_Touch_Point_State

Enumeration for touch point states.

Enumerator:
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