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 void       _ecore_main_shutdown(void);
 176
 177 #if defined (_WIN32) || defined (__lv2ppu__) || defined (HAVE_EXOTIC)
 178 static inline void _ecore_signal_shutdown(void) { }
 179
 180 static inline void _ecore_signal_init(void) { }
 181
 182 static inline void _ecore_signal_received_process(void) { }
 183
 184 static inline int _ecore_signal_count_get(void) { return 0; }
 185
 186 static inline void _ecore_signal_call(void) { }
 187
 188 #else
 189 void _ecore_signal_shutdown(void);
 190 void _ecore_signal_init(void);
 191 void _ecore_signal_received_process(void);
 192 int  _ecore_signal_count_get(void);
 193 void _ecore_signal_call(void);
 194 #endif
 195
 196 void       _ecore_exe_init(void);
 197 void       _ecore_exe_shutdown(void);
 198 #ifndef _WIN32
 199 Ecore_Exe *_ecore_exe_find(pid_t pid);
 200 void      *_ecore_exe_event_del_new(void);
 201 void       _ecore_exe_event_del_free(void *data,
 202                                      void *ev);
 203 #endif
 204
 205 void _ecore_animator_shutdown(void);
 206
 207 void _ecore_poller_shutdown(void);
 208
 209 void _ecore_fps_debug_init(void);
 210 void _ecore_fps_debug_shutdown(void);
 211 void _ecore_fps_debug_runtime_add(double t);
 212
 213 void _ecore_thread_init(void);
 214 void _ecore_thread_shutdown(void);
 215
 216 void _ecore_glib_init(void);
 217 void _ecore_glib_shutdown(void);
 218
 219 void _ecore_job_init(void);
 220 void _ecore_job_shutdown(void);
 221
 222 void _ecore_main_loop_init(void);
 223 void _ecore_main_loop_shutdown(void);
 224
 225 void _ecore_throttle(void);
 226
 227 void _ecore_main_call_flush(void);
 228
 229 extern int _ecore_main_lock_count;
 230 extern Eina_Lock _ecore_main_loop_lock;
 231
 232 static inline void
 233 _ecore_lock(void)
 234 {
 235 #ifdef HAVE_THREAD_SAFETY
 236    eina_lock_take(&_ecore_main_loop_lock);
 237 #else
 238    /* at least check we're not being called from a thread */
 239    EINA_MAIN_LOOP_CHECK_RETURN;
 240 #endif
 241    _ecore_main_lock_count++;
 242    /* assert(_ecore_main_lock_count == 1); */
 243 }
 244
 245 static inline void
 246 _ecore_unlock(void)
 247 {
 248    _ecore_main_lock_count--;
 249    /* assert(_ecore_main_lock_count == 0); */
 250 #ifdef HAVE_THREAD_SAFETY
 251    eina_lock_release(&_ecore_main_loop_lock);
 252 #endif
 253 }
 254
 255 /*
 256  * Callback wrappers all assume that ecore _ecore_lock has been called
 257  */
 258 static inline Eina_Bool
 259 _ecore_call_task_cb(Ecore_Task_Cb func,
 260                     void *data)
 261 {
 262    Eina_Bool r;
 263
 264    _ecore_unlock();
 265    r = func(data);
 266    _ecore_lock();
 267
 268    return r;
 269 }
 270
 271 static inline void *
 272 _ecore_call_data_cb(Ecore_Data_Cb func,
 273                     void *data)
 274 {
 275    void *r;
 276
 277    _ecore_unlock();
 278    r = func(data);
 279    _ecore_lock();
 280
 281    return r;
 282 }
 283
 284 static inline void
 285 _ecore_call_end_cb(Ecore_End_Cb func,
 286                    void *user_data,
 287                    void *func_data)
 288 {
 289    _ecore_unlock();
 290    func(user_data, func_data);
 291    _ecore_lock();
 292 }
 293
 294 static inline Eina_Bool
 295 _ecore_call_filter_cb(Ecore_Filter_Cb func,
 296                       void *data,
 297                       void *loop_data,
 298                       int type,
 299                       void *event)
 300 {
 301    Eina_Bool r;
 302
 303    _ecore_unlock();
 304    r = func(data, loop_data, type, event);
 305    _ecore_lock();
 306
 307    return r;
 308 }
 309
 310 static inline Eina_Bool
 311 _ecore_call_handler_cb(Ecore_Event_Handler_Cb func,
 312                        void *data,
 313                        int type,
 314                        void *event)
 315 {
 316    Eina_Bool r;
 317
 318    _ecore_unlock();
 319    r = func(data, type, event);
 320    _ecore_lock();
 321
 322    return r;
 323 }
 324
 325 static inline void
 326 _ecore_call_prep_cb(Ecore_Fd_Prep_Cb func,
 327                     void *data,
 328                     Ecore_Fd_Handler *fd_handler)
 329 {
 330    _ecore_unlock();
 331    func(data, fd_handler);
 332    _ecore_lock();
 333 }
 334
 335 static inline Eina_Bool
 336 _ecore_call_fd_cb(Ecore_Fd_Cb func,
 337                   void *data,
 338                   Ecore_Fd_Handler *fd_handler)
 339 {
 340    Eina_Bool r;
 341
 342    _ecore_unlock();
 343    r = func(data, fd_handler);
 344    _ecore_lock();
 345
 346    return r;
 347 }
 348
 349 extern int _ecore_fps_debug;
 350 extern double _ecore_time_loop_time;
 351 extern Eina_Bool _ecore_glib_always_integrate;
 352 extern Ecore_Select_Function main_loop_select;
 353
 354 Eina_Bool ecore_mempool_init(void);
 355 void ecore_mempool_shutdown(void);
 356 #define GENERIC_ALLOC_FREE_HEADER(TYPE, Type) \
 357   TYPE *Type##_calloc(unsigned int);          \
 358   void Type##_mp_free(TYPE *e);
 359 #define GENERIC_ALLOC_SIZE_DECLARE(TYPE)      \
 360   size_t _ecore_sizeof_##TYPE = sizeof (TYPE);
 361
 362 GENERIC_ALLOC_FREE_HEADER(Ecore_Animator, ecore_animator);
 363 GENERIC_ALLOC_FREE_HEADER(Ecore_Event_Handler, ecore_event_handler);
 364 GENERIC_ALLOC_FREE_HEADER(Ecore_Event_Filter, ecore_event_filter);
 365 GENERIC_ALLOC_FREE_HEADER(Ecore_Event, ecore_event);
 366 GENERIC_ALLOC_FREE_HEADER(Ecore_Idle_Exiter, ecore_idle_exiter);
 367 GENERIC_ALLOC_FREE_HEADER(Ecore_Idle_Enterer, ecore_idle_enterer);
 368 GENERIC_ALLOC_FREE_HEADER(Ecore_Idler, ecore_idler);
 369 GENERIC_ALLOC_FREE_HEADER(Ecore_Job, ecore_job);
 370 GENERIC_ALLOC_FREE_HEADER(Ecore_Timer, ecore_timer);
 371 GENERIC_ALLOC_FREE_HEADER(Ecore_Poller, ecore_poller);
 372 GENERIC_ALLOC_FREE_HEADER(Ecore_Pipe, ecore_pipe);
 373 GENERIC_ALLOC_FREE_HEADER(Ecore_Fd_Handler, ecore_fd_handler);
 374 #ifdef _WIN32
 375 GENERIC_ALLOC_FREE_HEADER(Ecore_Win32_Handler, ecore_win32_handler);
 376 #endif
 377
 378 #undef GENERIC_ALLOC_FREE_HEADER
 379
 380 #endif