src/lib/ecore/ecore_private.h

   1 #ifndef _ECORE_PRIVATE_H
   2 #define _ECORE_PRIVATE_H
   3
   4 #include <assert.h>
   5
   6 extern int _ecore_log_dom;
   7 #ifdef  _ECORE_DEFAULT_LOG_DOM
   8 # undef _ECORE_DEFAULT_LOG_DOM
   9 #endif
  10 #define _ECORE_DEFAULT_LOG_DOM _ecore_log_dom
  11
  12 #ifdef ECORE_DEFAULT_LOG_COLOR
  13 # undef ECORE_DEFAULT_LOG_COLOR
  14 #endif
  15 #define ECORE_DEFAULT_LOG_COLOR EINA_COLOR_BLUE
  16
  17 #ifdef ERR
  18 # undef ERR
  19 #endif
  20 #define ERR(...) EINA_LOG_DOM_ERR(_ECORE_DEFAULT_LOG_DOM, __VA_ARGS__)
  21
  22 #ifdef DBG
  23 # undef DBG
  24 #endif
  25 #define DBG(...) EINA_LOG_DOM_DBG(_ECORE_DEFAULT_LOG_DOM, __VA_ARGS__)
  26
  27 #ifdef INF
  28 # undef INF
  29 #endif
  30 #define INF(...) EINA_LOG_DOM_INFO(_ECORE_DEFAULT_LOG_DOM, __VA_ARGS__)
  31
  32 #ifdef WRN
  33 # undef WRN
  34 #endif
  35 #define WRN(...) EINA_LOG_DOM_WARN(_ECORE_DEFAULT_LOG_DOM, __VA_ARGS__)
  36
  37 #ifdef CRIT
  38 # undef CRIT
  39 #endif
  40 #define CRIT(...) EINA_LOG_DOM_CRIT(_ECORE_DEFAULT_LOG_DOM, __VA_ARGS__)
  41
  42 #ifndef PATH_MAX
  43 # define PATH_MAX 4096
  44 #endif
  45
  46 #ifndef MIN
  47 # define MIN(x, y)          (((x) > (y)) ? (y) : (x))
  48 #endif
  49
  50 #ifndef MAX
  51 # define MAX(x, y)          (((x) > (y)) ? (x) : (y))
  52 #endif
  53
  54 #ifndef ABS
  55 # define ABS(x)             ((x) < 0 ? -(x) : (x))
  56 #endif
  57
  58 #ifndef CLAMP
  59 # define CLAMP(x, min, max) (((x) > (max)) ? (max) : (((x) < (min)) ? (min) : (x)))
  60 #endif
  61
  62 #define EVAS_FRAME_QUEUING        1 /* for test */
  63
  64 #define READBUFSIZ                65536
  65
  66 #define ECORE_MAGIC_NONE          0x1234fedc
  67 #define ECORE_MAGIC_EXE           0xf7e812f5
  68 #define ECORE_MAGIC_TIMER         0xf7d713f4
  69 #define ECORE_MAGIC_IDLER         0xf7c614f3
  70 #define ECORE_MAGIC_IDLE_ENTERER  0xf7b515f2
  71 #define ECORE_MAGIC_IDLE_EXITER   0xf7601afd
  72 #define ECORE_MAGIC_FD_HANDLER    0xf7a416f1
  73 #define ECORE_MAGIC_EVENT_HANDLER 0xf79317f0
  74 #define ECORE_MAGIC_EVENT_FILTER  0xf78218ff
  75 #define ECORE_MAGIC_EVENT         0xf77119fe
  76 #define ECORE_MAGIC_ANIMATOR      0xf7643ea5
  77 #define ECORE_MAGIC_POLLER        0xf7568127
  78 #define ECORE_MAGIC_PIPE          0xf7458226
  79 #define ECORE_MAGIC_WIN32_HANDLER 0xf7e8f1a3
  80 #define ECORE_MAGIC_JOB           0x76543210
  81
  82 typedef unsigned int Ecore_Magic;
  83 #define ECORE_MAGIC               Ecore_Magic __magic
  84
  85 #define ECORE_MAGIC_SET(d, m)      (d)->__magic = (m)
  86 #define ECORE_MAGIC_CHECK(d, m)    ((d) && ((d)->__magic == (m)))
  87 #define ECORE_MAGIC_FAIL(d, m, fn) _ecore_magic_fail((d), (d) ? (d)->__magic : 0, (m), (fn));
  88
  89 /* undef the following, we want our version */
  90 #undef FREE
  91 #define FREE(ptr)                  free(ptr); ptr = NULL;
  92
  93 #undef IF_FREE
  94 #define IF_FREE(ptr)               if (ptr) free(ptr); ptr = NULL;
  95
  96 #undef IF_FN_DEL
  97 #define IF_FN_DEL(_fn, ptr)        if (ptr) { _fn(ptr); ptr = NULL; }
  98
  99 EAPI void
 100 ecore_print_warning(const char *function,
 101                     const char *sparam);
 102
 103 /* convenience macros for checking pointer parameters for non-NULL */
 104 #undef CHECK_PARAM_POINTER_RETURN
 105 #define CHECK_PARAM_POINTER_RETURN(sparam, param, ret) \
 106   if (!(param))                                        \
 107     {                                                  \
 108        ecore_print_warning(__FUNCTION__, sparam);      \
 109        return ret;                                     \
 110     }
 111
 112 #undef CHECK_PARAM_POINTER
 113 #define CHECK_PARAM_POINTER(sparam, param)        \
 114   if (!(param))                                   \
 115     {                                             \
 116        ecore_print_warning(__FUNCTION__, sparam); \
 117        return;                                    \
 118     }
 119
 120 EAPI void _ecore_magic_fail(const void *d,
 121                             Ecore_Magic m,
 122                             Ecore_Magic req_m,
 123                             const char *fname);
 124
 125 void         _ecore_time_init(void);
 126
 127 Ecore_Timer *_ecore_timer_loop_add(double in,
 128                                    Ecore_Task_Cb func,
 129                                    const void *data);
 130 void        *_ecore_timer_del(Ecore_Timer *timer);
 131 void         _ecore_timer_delay(Ecore_Timer *timer,
 132                                 double add);
 133 void         _ecore_timer_shutdown(void);
 134 void         _ecore_timer_cleanup(void);
 135 void         _ecore_timer_enable_new(void);
 136 double       _ecore_timer_next_get(void);
 137 void         _ecore_timer_expired_timers_call(double when);
 138 int          _ecore_timers_exists(void);
 139
 140 int          _ecore_timer_expired_call(double when);
 141
 142 void         _ecore_idler_shutdown(void);
 143 int          _ecore_idler_all_call(void);
 144 int          _ecore_idler_exist(void);
 145
 146 void         _ecore_idle_enterer_shutdown(void);
 147 void         _ecore_idle_enterer_call(void);
 148 int          _ecore_idle_enterer_exist(void);
 149
 150 void         _ecore_idle_exiter_shutdown(void);
 151 void         _ecore_idle_exiter_call(void);
 152 int          _ecore_idle_exiter_exist(void);
 153
 154 void         _ecore_event_shutdown(void);
 155 int          _ecore_event_exist(void);
 156 Ecore_Event *_ecore_event_add(int type,
 157                               void *ev,
 158                               Ecore_End_Cb func_free,
 159                               void *data);
 160 void         _ecore_event_call(void);
 161 void        *_ecore_event_handler_del(Ecore_Event_Handler *event_handler);
 162
 163 Ecore_Timer *_ecore_exe_doomsday_clock_get(Ecore_Exe *exe);
 164 void         _ecore_exe_doomsday_clock_set(Ecore_Exe *exe,
 165                                            Ecore_Timer *dc);
 166
 167 void      *_ecore_event_signal_user_new(void);
 168 void      *_ecore_event_signal_hup_new(void);
 169 void      *_ecore_event_signal_exit_new(void);
 170 void      *_ecore_event_signal_power_new(void);
 171 void      *_ecore_event_signal_realtime_new(void);
 172
 173 void      *_ecore_main_fd_handler_del(Ecore_Fd_Handler *fd_handler);
 174
 175 Eina_Bool _ecore_fd_close_on_exec(int fd);
 176
 177 void       _ecore_main_shutdown(void);
 178
 179 #if defined (_WIN32) || defined (__lv2ppu__) || defined (HAVE_EXOTIC)
 180 static inline void _ecore_signal_shutdown(void) { }
 181
 182 static inline void _ecore_signal_init(void) { }
 183
 184 static inline void _ecore_signal_received_process(void) { }
 185
 186 static inline int _ecore_signal_count_get(void) { return 0; }
 187
 188 static inline void _ecore_signal_call(void) { }
 189
 190 #else
 191 void _ecore_signal_shutdown(void);
 192 void _ecore_signal_init(void);
 193 void _ecore_signal_received_process(void);
 194 int  _ecore_signal_count_get(void);
 195 void _ecore_signal_call(void);
 196 #endif
 197
 198 void       _ecore_exe_init(void);
 199 void       _ecore_exe_shutdown(void);
 200 #ifndef _WIN32
 201 Ecore_Exe *_ecore_exe_find(pid_t pid);
 202 void      *_ecore_exe_event_del_new(void);
 203 void       _ecore_exe_event_del_free(void *data,
 204                                      void *ev);
 205 #endif
 206
 207 void _ecore_animator_shutdown(void);
 208
 209 void _ecore_poller_shutdown(void);
 210
 211 void _ecore_fps_debug_init(void);
 212 void _ecore_fps_debug_shutdown(void);
 213 void _ecore_fps_debug_runtime_add(double t);
 214
 215 void _ecore_thread_init(void);
 216 void _ecore_thread_shutdown(void);
 217
 218 void _ecore_glib_init(void);
 219 void _ecore_glib_shutdown(void);
 220
 221 void _ecore_job_init(void);
 222 void _ecore_job_shutdown(void);
 223
 224 void _ecore_main_loop_init(void);
 225 void _ecore_main_loop_shutdown(void);
 226
 227 void _ecore_throttle(void);
 228
 229 void _ecore_main_call_flush(void);
 230
 231 extern int _ecore_main_lock_count;
 232 extern Eina_Lock _ecore_main_loop_lock;
 233
 234 static inline void
 235 _ecore_lock(void)
 236 {
 237 #ifdef HAVE_THREAD_SAFETY
 238    eina_lock_take(&_ecore_main_loop_lock);
 239 #else
 240    /* at least check we're not being called from a thread */
 241    EINA_MAIN_LOOP_CHECK_RETURN;
 242 #endif
 243    _ecore_main_lock_count++;
 244    /* assert(_ecore_main_lock_count == 1); */
 245 }
 246
 247 static inline void
 248 _ecore_unlock(void)
 249 {
 250    _ecore_main_lock_count--;
 251    /* assert(_ecore_main_lock_count == 0); */
 252 #ifdef HAVE_THREAD_SAFETY
 253    eina_lock_release(&_ecore_main_loop_lock);
 254 #endif
 255 }
 256
 257 /*
 258  * Callback wrappers all assume that ecore _ecore_lock has been called
 259  */
 260 static inline Eina_Bool
 261 _ecore_call_task_cb(Ecore_Task_Cb func,
 262                     void *data)
 263 {
 264    Eina_Bool r;
 265
 266    _ecore_unlock();
 267    r = func(data);
 268    _ecore_lock();
 269
 270    return r;
 271 }
 272
 273 static inline void *
 274 _ecore_call_data_cb(Ecore_Data_Cb func,
 275                     void *data)
 276 {
 277    void *r;
 278
 279    _ecore_unlock();
 280    r = func(data);
 281    _ecore_lock();
 282
 283    return r;
 284 }
 285
 286 static inline void
 287 _ecore_call_end_cb(Ecore_End_Cb func,
 288                    void *user_data,
 289                    void *func_data)
 290 {
 291    _ecore_unlock();
 292    func(user_data, func_data);
 293    _ecore_lock();
 294 }
 295
 296 static inline Eina_Bool
 297 _ecore_call_filter_cb(Ecore_Filter_Cb func,
 298                       void *data,
 299                       void *loop_data,
 300                       int type,
 301                       void *event)
 302 {
 303    Eina_Bool r;
 304
 305    _ecore_unlock();
 306    r = func(data, loop_data, type, event);
 307    _ecore_lock();
 308
 309    return r;
 310 }
 311
 312 static inline Eina_Bool
 313 _ecore_call_handler_cb(Ecore_Event_Handler_Cb func,
 314                        void *data,
 315                        int type,
 316                        void *event)
 317 {
 318    Eina_Bool r;
 319
 320    _ecore_unlock();
 321    r = func(data, type, event);
 322    _ecore_lock();
 323
 324    return r;
 325 }
 326
 327 static inline void
 328 _ecore_call_prep_cb(Ecore_Fd_Prep_Cb func,
 329                     void *data,
 330                     Ecore_Fd_Handler *fd_handler)
 331 {
 332    _ecore_unlock();
 333    func(data, fd_handler);
 334    _ecore_lock();
 335 }
 336
 337 static inline Eina_Bool
 338 _ecore_call_fd_cb(Ecore_Fd_Cb func,
 339                   void *data,
 340                   Ecore_Fd_Handler *fd_handler)
 341 {
 342    Eina_Bool r;
 343
 344    _ecore_unlock();
 345    r = func(data, fd_handler);
 346    _ecore_lock();
 347
 348    return r;
 349 }
 350
 351 extern int _ecore_fps_debug;
 352 extern double _ecore_time_loop_time;
 353 extern Eina_Bool _ecore_glib_always_integrate;
 354 extern Ecore_Select_Function main_loop_select;
 355
 356 Eina_Bool ecore_mempool_init(void);
 357 void ecore_mempool_shutdown(void);
 358 #define GENERIC_ALLOC_FREE_HEADER(TYPE, Type) \
 359   TYPE *Type##_calloc(unsigned int);          \
 360   void Type##_mp_free(TYPE *e);
 361 #define GENERIC_ALLOC_SIZE_DECLARE(TYPE)      \
 362   size_t _ecore_sizeof_##TYPE = sizeof (TYPE);
 363
 364 GENERIC_ALLOC_FREE_HEADER(Ecore_Animator, ecore_animator);
 365 GENERIC_ALLOC_FREE_HEADER(Ecore_Event_Handler, ecore_event_handler);
 366 GENERIC_ALLOC_FREE_HEADER(Ecore_Event_Filter, ecore_event_filter);
 367 GENERIC_ALLOC_FREE_HEADER(Ecore_Event, ecore_event);
 368 GENERIC_ALLOC_FREE_HEADER(Ecore_Idle_Exiter, ecore_idle_exiter);
 369 GENERIC_ALLOC_FREE_HEADER(Ecore_Idle_Enterer, ecore_idle_enterer);
 370 GENERIC_ALLOC_FREE_HEADER(Ecore_Idler, ecore_idler);
 371 GENERIC_ALLOC_FREE_HEADER(Ecore_Job, ecore_job);
 372 GENERIC_ALLOC_FREE_HEADER(Ecore_Timer, ecore_timer);
 373 GENERIC_ALLOC_FREE_HEADER(Ecore_Poller, ecore_poller);
 374 GENERIC_ALLOC_FREE_HEADER(Ecore_Pipe, ecore_pipe);
 375 GENERIC_ALLOC_FREE_HEADER(Ecore_Fd_Handler, ecore_fd_handler);
 376 #ifdef _WIN32
 377 GENERIC_ALLOC_FREE_HEADER(Ecore_Win32_Handler, ecore_win32_handler);
 378 #endif
 379
 380 #undef GENERIC_ALLOC_FREE_HEADER
 381
 382 #endif