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 eina_list_last_data_get(X)   eina_list_data_get(eina_list_last(X))
#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_Idlere_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;                                         \
       }                                                          \
  }