Enlightenment API

Application programming interface to be used by modules to extend Enlightenment. More...

Data Structures
struct	_E_Before_Idler
struct	_E_Rect
Defines
#define	USE_IPC
#define	_FILE_OFFSET_BITS   64
#define	_POSIX_HOST_NAME_MAX   255
#define	EAPI
#define	EINTERN
#define	strdupa(str)   strcpy(alloca(strlen(str) + 1), str)
#define	strndupa(str, len)   strncpy(alloca(len + 1), str, len)
#define	MAX(x, y)   (((x) > (y)) ? (x) : (y))
#define	E_FN_DEL(_fn, _h)   if (_h) { _fn((void*)_h); _h = NULL; }
#define	E_INTERSECTS(x, y, w, h, xx, yy, ww, hh)   (((x) < ((xx) + (ww))) && ((y) < ((yy) + (hh))) && (((x) + (w)) > (xx)) && (((y) + (h)) > (yy)))
#define	E_INSIDE(x, y, xx, yy, ww, hh)   (((x) < ((xx) + (ww))) && ((y) < ((yy) + (hh))) && ((x) >= (xx)) && ((y) >= (yy)))
#define	E_CONTAINS(x, y, w, h, xx, yy, ww, hh)   (((xx) >= (x)) && (((x) + (w)) >= ((xx) + (ww))) && ((yy) >= (y)) && (((y) + (h)) >= ((yy) + (hh))))
#define	E_SPANS_COMMON(x1, w1, x2, w2)   (!((((x2) + (w2)) <= (x1)) || ((x2) >= ((x1) + (w1)))))
#define	E_REALLOC(p, s, n)   p = (s *)realloc(p, sizeof(s) * n)
#define	E_NEW(s, n)   (s *)calloc(n, sizeof(s))
#define	E_NEW_RAW(s, n)   (s *)malloc(n * sizeof(s))
#define	E_FREE(p)   do { free(p); p = NULL; } while (0)
#define	E_FREE_LIST(list, free)
#define	E_LIST_FOREACH(list, func)
#define	E_LIST_HANDLER_APPEND(list, type, callback, data)
#define	E_CLAMP(x, min, max)   (x < min ? min : (x > max ? max : x))
#define	E_RECTS_CLIP_TO_RECT(_x, _y, _w, _h, _cx, _cy, _cw, _ch)
#define	E_REMOTE_OPTIONS   1
#define	E_REMOTE_OUT   2
#define	E_WM_IN   3
#define	E_REMOTE_IN   4
#define	E_ENUM   5
#define	E_LIB_IN   6
#define	E_TYPEDEFS   1
#define	SMARTERRNR()   return
#define	SMARTERR(x)   return x
Typedefs
typedef struct _E_Before_Idler	E_Before_Idler
typedef struct _E_Rect	E_Rect
Functions
void *	alloca (size_t)
EAPI E_Before_Idler *	e_main_idler_before_add (int(*func)(void *data), void *data, int once)
EAPI void	e_main_idler_before_del (E_Before_Idler *eb)
EAPI double	e_main_ts (const char *str)
EAPI void	e_alert_composite_win (Ecore_X_Window root, Ecore_X_Window win)
Variables
EAPI E_Path *	path_data
EAPI E_Path *	path_images
EAPI E_Path *	path_fonts
EAPI E_Path *	path_themes
EAPI E_Path *	path_icons
EAPI E_Path *	path_modules
EAPI E_Path *	path_backgrounds
EAPI E_Path *	path_messages
EAPI Eina_Bool	good
EAPI Eina_Bool	evil
EAPI Eina_Bool	starting
EAPI Eina_Bool	stopping
EAPI Eina_Bool	restart
EAPI Eina_Bool	e_nopause
EAPI Eina_Bool	e_precache_end
EAPI Eina_Bool	x_fatal

---

Detailed Description

Application programming interface to be used by modules to extend Enlightenment.

---

Define Documentation

#define E_FREE_LIST	(	list,
		free		)

Value:

do                                \
    {                               \
       void *_tmp_;                 \
       EINA_LIST_FREE(list, _tmp_) \
         {                          \
            free(_tmp_);            \
         }                          \
    }                               \
  while (0)

#define E_LIST_FOREACH	(	list,
		func		)

Value:

do                                \
    {                               \
       void *_tmp_;                 \
       const Eina_List *_list, *_list2;  \
       EINA_LIST_FOREACH_SAFE(list, _list, _list2, _tmp_) \
         {                          \
            func(_tmp_);            \
         }                          \
    }                               \
  while (0)

#define E_LIST_HANDLER_APPEND	(	list,
		type,
		callback,
		data		)

Value:

do \
    { \
       Ecore_Event_Handler *_eh; \
       _eh = ecore_event_handler_add(type, (Ecore_Event_Handler_Cb)callback, data); \
       if (_eh) \
         list = eina_list_append(list, _eh); \
       else \
         fprintf(stderr, "E_LIST_HANDLER_APPEND\n"); \
    } \
  while (0)

#define E_RECTS_CLIP_TO_RECT	(	_x,
		_y,
		_w,
		_h,
		_cx,
		_cy,
		_cw,
		_ch		)

Value:

{                                                               \
     if (E_INTERSECTS(_x, _y, _w, _h, _cx, _cy, _cw, _ch))        \
       {                                                          \
          if ((int)_x < (int)(_cx))                               \
            {                                                     \
               _w += _x - (_cx);                                  \
               _x = (_cx);                                        \
               if ((int)_w < 0) _w = 0;                           \
            }                                                     \
          if ((int)(_x + _w) > (int)((_cx) + (_cw)))              \
            _w = (_cx) + (_cw) - _x;                              \
          if ((int)_y < (int)(_cy))                               \
            {                                                     \
               _h += _y - (_cy);                                  \
               _y = (_cy);                                        \
               if ((int)_h < 0) _h = 0;                           \
            }                                                     \
          if ((int)(_y + _h) > (int)((_cy) + (_ch)))              \
            _h = (_cy) + (_ch) - _y;                              \
       }                                                          \
     else                                                         \
       {                                                          \
          _w = 0; _h = 0;                                         \
       }                                                          \
  }