efl

1
#include "edje_private.h"
2

3
static Edje_Version _version = { VMAJ, VMIN, VMIC, VREV };
4
EAPI Edje_Version * edje_version = &_version;
5

6
static int _edje_init_count = 0;
7
static Eina_Bool _need_imf = EINA_FALSE;
8

9
int _edje_default_log_dom = -1;
10
Eina_Mempool *_edje_real_part_mp = NULL;
11
Eina_Mempool *_edje_real_part_state_mp = NULL;
12

13
Eina_Cow *_edje_calc_params_map_cow = NULL;
14
Eina_Cow *_edje_calc_params_physics_cow = NULL;
15

16
Edje_Global *_edje_global_obj = NULL;
17

18
static const Edje_Calc_Params_Map default_calc_map = {
19
   { 0, 0, 0 }, { 0, 0 }, { 0.0, 0.0, 0.0 }, { 0, 0, 0, 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0.0, 0.0 }, NULL, 0
20
};
21

22
static const Edje_Calc_Params_Physics default_calc_physics = {
23
   0.0, 0.0, 0.0, 0.0, 0.0, { 0.0, 0.0 }, { 0.0, 0.0 }, 0, 0, { { 0, 0, 0 }, { 0, 0, 0 } }, 0, 0, 0, 0
24
};
25

26
#ifdef HAVE_EPHYSICS
27
static void _edje_ephysics_clear(void);
28
#endif
29

30

31
/*============================================================================*
32
*                                   API                                      *
33
*============================================================================*/
34
EAPI int
35
edje_init(void)
36
{
37
   Eina_Strbuf *str;
38

39
   if (++_edje_init_count != 1)
40
     return _edje_init_count;
41

42
   EINA_SAFETY_ON_FALSE_RETURN_VAL(eina_init(), --_edje_init_count);
43

44
   _edje_default_log_dom = eina_log_domain_register
45
       ("edje", EDJE_DEFAULT_LOG_COLOR);
46
   if (_edje_default_log_dom < 0)
47
     {
48
        EINA_LOG_ERR("Edje Can not create a general log domain.");
49
        goto shutdown_eina;
50
     }
51

52
   if (!ecore_init())
53
     {
54
        ERR("Ecore init failed");
55
        goto unregister_log_domain;
56
     }
57

58
   if (!embryo_init())
59
     {
60
        ERR("Embryo init failed");
61
        goto shutdown_ecore;
62
     }
63

64
   if (!eet_init())
65
     {
66
        ERR("Eet init failed");
67
        goto shutdown_embryo;
68
     }
69

70
   if (!evas_init())
71
     {
72
        ERR("Evas init failed");
73
        goto shutdown_eet;
74
     }
75

76
   if (!efreet_init())
77
     {
78
        ERR("Efreet init failed");
79
        goto shutdown_evas;
80
     }
81

82
   _edje_scale = FROM_DOUBLE(1.0);
83
   _edje_global_obj = efl_add(EDJE_GLOBAL_CLASS, efl_main_loop_get());
84
   EINA_SAFETY_ON_TRUE_GOTO(!_edje_global_obj, shutdown_efreet);
85
   EINA_SAFETY_ON_TRUE_GOTO(!efl_provider_register(efl_main_loop_get(), EFL_GFX_COLOR_CLASS_MIXIN, _edje_global_obj), shutdown_efreet);
86
   EINA_SAFETY_ON_TRUE_GOTO(!efl_provider_register(efl_main_loop_get(), EFL_GFX_TEXT_CLASS_INTERFACE, _edje_global_obj), shutdown_efreet);
87
   EINA_SAFETY_ON_TRUE_GOTO(!efl_provider_register(efl_main_loop_get(), EFL_GFX_SIZE_CLASS_INTERFACE, _edje_global_obj), shutdown_efreet);
88

89
   _edje_edd_init();
90
   _edje_text_init();
91
   _edje_box_init();
92
   _edje_external_init();
93
   _edje_module_init();
94
   _edje_message_init();
95
   _edje_multisense_init();
96
   edje_signal_init();
97
   _edje_class_init();
98

99
   _edje_real_part_mp = eina_mempool_add("chained_mempool",
100
                                         "Edje_Real_Part", NULL,
101
                                         sizeof (Edje_Real_Part), 256);
102
   if (!_edje_real_part_mp)
103
     {
104
        ERR("Mempool for Edje_Real_Part cannot be allocated.");
105
        goto shutdown_all;
106
     }
107

108
   _edje_real_part_state_mp = eina_mempool_add("chained_mempool",
109
                                               "Edje_Real_Part_State", NULL,
110
                                               sizeof (Edje_Real_Part_State), 64);
111
   if (!_edje_real_part_state_mp)
112
     {
113
        ERR("Mempool for Edje_Real_Part_State cannot be allocated.");
114
        goto shutdown_all;
115
     }
116

117
   _edje_calc_params_map_cow = eina_cow_add("Edje Calc Params Map", sizeof (Edje_Calc_Params_Map), 8, &default_calc_map, EINA_TRUE);
118
   EINA_SAFETY_ON_NULL_GOTO(_edje_calc_params_map_cow, shutdown_all);
119
   _edje_calc_params_physics_cow = eina_cow_add("Edje Calc Params Physics", sizeof (Edje_Calc_Params_Physics), 8, &default_calc_physics, EINA_TRUE);
120
   EINA_SAFETY_ON_NULL_GOTO(_edje_calc_params_physics_cow, shutdown_all);
121

122
   _edje_language = eina_stringshare_add(getenv("LANGUAGE"));
123

124
   str = eina_strbuf_new();
125
   eina_strbuf_append_printf(str, "%s/edje", efreet_cache_home_get());
126
   _edje_cache_path = eina_stringshare_add(eina_strbuf_string_get(str));
127
   eina_strbuf_free(str);
128

129
   eina_log_timing(_edje_default_log_dom,
130
                   EINA_LOG_STATE_STOP,
131
                   EINA_LOG_STATE_INIT);
132

133
   return _edje_init_count;
134

135
shutdown_all:
136
   eina_cow_del(_edje_calc_params_map_cow);
137
   eina_cow_del(_edje_calc_params_physics_cow);
138
   _edje_calc_params_map_cow = NULL;
139
   _edje_calc_params_physics_cow = NULL;
140
   eina_mempool_del(_edje_real_part_state_mp);
141
   eina_mempool_del(_edje_real_part_mp);
142
   _edje_real_part_state_mp = NULL;
143
   _edje_real_part_mp = NULL;
144
   _edje_class_shutdown();
145
   _edje_message_shutdown();
146
   _edje_module_shutdown();
147
   _edje_external_shutdown();
148
   _edje_box_shutdown();
149
   _edje_internal_proxy_shutdown();
150
   _edje_text_class_hash_free();
151
   _edje_size_class_hash_free();
152
   _edje_edd_shutdown();
153
   if (_edje_global_obj)
154
     {
155
        efl_provider_unregister(efl_main_loop_get(), EFL_GFX_COLOR_CLASS_MIXIN, _edje_global_obj);
156
        efl_provider_unregister(efl_main_loop_get(), EFL_GFX_TEXT_CLASS_INTERFACE, _edje_global_obj);
157
        efl_provider_unregister(efl_main_loop_get(), EFL_GFX_SIZE_CLASS_INTERFACE, _edje_global_obj);
158
        efl_del(_edje_global_obj);
159
        _edje_global_obj = NULL;
160
     }
161
shutdown_efreet:
162
   efreet_shutdown();
163
shutdown_evas:
164
   evas_shutdown();
165
shutdown_eet:
166
   eet_shutdown();
167
shutdown_embryo:
168
   embryo_shutdown();
169
shutdown_ecore:
170
   ecore_shutdown();
171
unregister_log_domain:
172
   eina_log_domain_unregister(_edje_default_log_dom);
173
   _edje_default_log_dom = -1;
174
shutdown_eina:
175
   eina_shutdown();
176
   return --_edje_init_count;
177
}
178

179
static int _edje_users = 0;
180

181
static void
182
_edje_shutdown_core(void)
183
{
184
   if (_edje_users > 0) return;
185

186
   eina_log_timing(_edje_default_log_dom,
187
                   EINA_LOG_STATE_START,
188
                   EINA_LOG_STATE_SHUTDOWN);
189

190
   _edje_file_cache_shutdown();
191
   _edje_color_class_hash_free();
192

193
   eina_stringshare_del(_edje_cache_path);
194
   eina_stringshare_del(_edje_language);
195
   _edje_cache_path = NULL;
196
   _edje_language = NULL;
197

198
   eina_mempool_del(_edje_real_part_state_mp);
199
   eina_mempool_del(_edje_real_part_mp);
200
   _edje_real_part_state_mp = NULL;
201
   _edje_real_part_mp = NULL;
202

203
   _edje_class_shutdown();
204
   edje_signal_shutdown();
205
   _edje_multisense_shutdown();
206
   _edje_message_shutdown();
207
   _edje_module_shutdown();
208
   _edje_external_shutdown();
209
   _edje_internal_proxy_shutdown();
210
   _edje_box_shutdown();
211
   _edje_text_class_hash_free();
212
   _edje_size_class_hash_free();
213
   _edje_edd_shutdown();
214
   efl_provider_unregister(efl_main_loop_get(), EFL_GFX_COLOR_CLASS_MIXIN, _edje_global_obj);
215
   efl_provider_unregister(efl_main_loop_get(), EFL_GFX_TEXT_CLASS_INTERFACE, _edje_global_obj);
216
   efl_provider_unregister(efl_main_loop_get(), EFL_GFX_SIZE_CLASS_INTERFACE, _edje_global_obj);
217
   efl_del(_edje_global_obj);
218
   _edje_global_obj = NULL;
219

220
   eina_cow_del(_edje_calc_params_map_cow);
221
   eina_cow_del(_edje_calc_params_physics_cow);
222
   _edje_calc_params_map_cow = NULL;
223
   _edje_calc_params_physics_cow = NULL;
224

225
#ifdef HAVE_ECORE_IMF
226
   if (_need_imf)
227
     {
228
        ecore_imf_shutdown();
229
        _need_imf = EINA_FALSE;
230
     }
231
#endif
232

233
#ifdef HAVE_EPHYSICS
234
   _edje_ephysics_clear();
235
#endif
236

237
   efreet_shutdown();
238
   ecore_shutdown();
239
   evas_shutdown();
240
   eet_shutdown();
241
   embryo_shutdown();
242
   eina_log_domain_unregister(_edje_default_log_dom);
243
   _edje_default_log_dom = -1;
244
   eina_shutdown();
245
}
246

247
void
248
_edje_lib_ref(void)
249
{
250
   _edje_users++;
251
}
252

253
void
254
_edje_lib_unref(void)
255
{
256
   _edje_users--;
257
   if (_edje_users != 0) return;
258
   if (_edje_init_count == 0) _edje_shutdown_core();
259
}
260

261
EAPI int
262
edje_shutdown(void)
263
{
264
   if (_edje_init_count <= 0)
265
     {
266
        ERR("Init count not greater than 0 in shutdown.");
267
        return 0;
268
     }
269
   if (--_edje_init_count != 0)
270
     return _edje_init_count;
271

272
   _edje_shutdown_core();
273

274
   return _edje_init_count;
275
}
276

277
/* Private Routines */
278
void
279
_edje_class_init(void)
280
{
281
   if (!_edje_color_class_member)
282
     _edje_color_class_member = efl_add(EFL_OBSERVABLE_CLASS, efl_main_loop_get());
283
   if (!_edje_text_class_member)
284
     _edje_text_class_member = efl_add(EFL_OBSERVABLE_CLASS, efl_main_loop_get());
285
   if (!_edje_size_class_member)
286
     _edje_size_class_member = efl_add(EFL_OBSERVABLE_CLASS, efl_main_loop_get());
287
}
288

289
void
290
_edje_class_shutdown(void)
291
{
292
   if (_edje_color_class_member)
293
     {
294
        efl_del(_edje_color_class_member);
295
        _edje_color_class_member = NULL;
296
     }
297
   if (_edje_text_class_member)
298
     {
299
        efl_del(_edje_text_class_member);
300
        _edje_text_class_member = NULL;
301
     }
302
   if (_edje_size_class_member)
303
     {
304
        efl_del(_edje_size_class_member);
305
        _edje_size_class_member = NULL;
306
     }
307
}
308

309
void
310
_edje_del(Edje *ed)
311
{
312
   Edje_Text_Insert_Filter_Callback *cb;
313

314
   if (ed->processing_messages)
315
     {
316
        ed->delete_me = EINA_TRUE;
317
        return;
318
     }
319
   _edje_message_del(ed);
320
   _edje_signal_callback_free(ed->callbacks);
321
   ed->callbacks = NULL;
322
   _edje_file_del(ed);
323
   if (ed->path) eina_stringshare_del(ed->path);
324
   if (ed->group) eina_stringshare_del(ed->group);
325
   if (ed->parent) eina_stringshare_del(ed->parent);
326
   ed->path = NULL;
327
   ed->group = NULL;
328
   ed->parent = NULL;
329
   eina_hash_free(ed->color_classes);
330
   eina_hash_free(ed->text_classes);
331
   eina_hash_free(ed->size_classes);
332
   ed->color_classes = NULL;
333
   ed->text_classes = NULL;
334
   ed->size_classes = NULL;
335
   EINA_LIST_FREE(ed->text_insert_filter_callbacks, cb)
336
     {
337
        eina_stringshare_del(cb->part);
338
        free(cb);
339
     }
340
   EINA_LIST_FREE(ed->markup_filter_callbacks, cb)
341
     {
342
        eina_stringshare_del(cb->part);
343
        free(cb);
344
     }
345

346
   efl_observable_observer_clean(_edje_color_class_member, ed->obj);
347
   efl_observable_observer_clean(_edje_text_class_member, ed->obj);
348
   efl_observable_observer_clean(_edje_size_class_member, ed->obj);
349
}
350

351
void
352
_edje_ref(Edje *ed)
353
{
354
   if (ed->references <= 0) return;
355
   ed->references++;
356
}
357

358
void
359
_edje_unref(Edje *ed)
360
{
361
   ed->references--;
362
   if (ed->references == 0) _edje_del(ed);
363
}
364

365
void
366
_edje_need_imf(void)
367
{
368
   if (_need_imf) return;
369
#ifdef HAVE_ECORE_IMF
370
   _need_imf = EINA_TRUE;
371
   ecore_imf_init();
372
#endif
373
}
374

375
#ifdef HAVE_EPHYSICS
376
Edje_Ephysics *_edje_ephysics = NULL;
377

378
Eina_Bool
379
_edje_ephysics_load(void)
380
{
381
   if (_edje_ephysics)
382
     {
383
        if (!_edje_ephysics->mod)
384
          {
385
             ERR("Cannot find libephysics at runtime!");
386
             return EINA_FALSE;
387
          }
388
        return EINA_TRUE;
389
     }
390
   _edje_ephysics = calloc(1, sizeof(Edje_Ephysics));
391
   if (!_edje_ephysics) return EINA_FALSE;
392
# define LOAD(x)                                        \
393
   if (!_edje_ephysics->mod) {                          \
394
      if ((_edje_ephysics->mod = eina_module_new(x))) { \
395
         if (!eina_module_load(_edje_ephysics->mod)) {  \
396
            eina_module_free(_edje_ephysics->mod);      \
397
            _edje_ephysics->mod = NULL;                 \
398
         }                                              \
399
      }                                                 \
400
   }
401
# if defined(_WIN32) || defined(__CYGWIN__)
402
   LOAD("libephysics-1.dll");
403
   LOAD("libephysics1.dll");
404
   LOAD("libephysics.dll");
405
   if (!_edje_ephysics->mod)
406
     ERR("Could not find libephysics-1.dll, libephysics1.dll, libephysics.dll");
407
# elif defined(__APPLE__) && defined(__MACH__)
408
   LOAD("libephysics.1.dylib");
409
   LOAD("libephysics.1.so");
410
   LOAD("libephysics.so.1");
411
   if (!_edje_ephysics->mod)
412
     ERR("Could not find libephysics.1.dylib, libephysics.1.so, libephysics.so.1");
413
# else
414
   LOAD("libephysics.so.1");
415
   if (!_edje_ephysics->mod)
416
     ERR("Could not find libephysics.so.1");
417
# endif
418
# undef LOAD
419
   if (!_edje_ephysics->mod) return EINA_FALSE;
420
# define SYM(x) \
421
   if (!(_edje_ephysics->x = eina_module_symbol_get(_edje_ephysics->mod, #x))) { \
422
      ERR("Cannot find symbol '%s' in'%s", #x, eina_module_file_get(_edje_ephysics->mod)); \
423
      goto err; \
424
   }
425
   SYM(ephysics_init);
426
   SYM(ephysics_shutdown);
427
   SYM(ephysics_world_new);
428
   SYM(ephysics_world_del);
429
   SYM(ephysics_world_event_callback_add)
430
   SYM(ephysics_world_rate_set)
431
   SYM(ephysics_world_gravity_set)
432
   SYM(ephysics_world_render_geometry_set);
433
   SYM(ephysics_world_render_geometry_get);
434
   SYM(ephysics_quaternion_set)
435
   SYM(ephysics_quaternion_get)
436
   SYM(ephysics_quaternion_normalize)
437
   SYM(ephysics_body_box_add)
438
   SYM(ephysics_body_sphere_add)
439
   SYM(ephysics_body_cylinder_add)
440
   SYM(ephysics_body_soft_box_add)
441
   SYM(ephysics_body_soft_sphere_add)
442
   SYM(ephysics_body_soft_cylinder_add)
443
   SYM(ephysics_body_cloth_add)
444
   SYM(ephysics_body_top_boundary_add)
445
   SYM(ephysics_body_bottom_boundary_add)
446
   SYM(ephysics_body_right_boundary_add)
447
   SYM(ephysics_body_left_boundary_add)
448
   SYM(ephysics_body_front_boundary_add)
449
   SYM(ephysics_body_back_boundary_add)
450
   SYM(ephysics_body_central_impulse_apply)
451
   SYM(ephysics_body_torque_impulse_apply)
452
   SYM(ephysics_body_central_force_apply)
453
   SYM(ephysics_body_torque_apply)
454
   SYM(ephysics_body_forces_clear)
455
   SYM(ephysics_body_linear_velocity_set)
456
   SYM(ephysics_body_angular_velocity_set)
457
   SYM(ephysics_body_stop)
458
   SYM(ephysics_body_rotation_set)
459
   SYM(ephysics_body_forces_get)
460
   SYM(ephysics_body_torques_get)
461
   SYM(ephysics_body_linear_velocity_get)
462
   SYM(ephysics_body_angular_velocity_get)
463
   SYM(ephysics_body_linear_movement_enable_set)
464
   SYM(ephysics_body_angular_movement_enable_set)
465
   SYM(ephysics_body_move)
466
   SYM(ephysics_body_geometry_get)
467
   SYM(ephysics_body_resize)
468
   SYM(ephysics_body_material_set)
469
   SYM(ephysics_body_density_set)
470
   SYM(ephysics_body_mass_set)
471
   SYM(ephysics_body_soft_body_hardness_set)
472
   SYM(ephysics_body_restitution_set)
473
   SYM(ephysics_body_friction_set)
474
   SYM(ephysics_body_damping_set)
475
   SYM(ephysics_body_sleeping_threshold_set)
476
   SYM(ephysics_body_light_set)
477
   SYM(ephysics_body_back_face_culling_set)
478
   SYM(ephysics_body_evas_object_update)
479
   SYM(ephysics_body_face_evas_object_set)
480
   SYM(ephysics_body_evas_object_set)
481
   SYM(ephysics_body_event_callback_add)
482
   SYM(ephysics_body_data_set)
483
   SYM(ephysics_body_data_get)
484
   SYM(ephysics_body_rotation_get)
485
#undef SYM
486
   return EINA_TRUE;
487
err:
488
   if (_edje_ephysics->mod)
489
     {
490
        eina_module_free(_edje_ephysics->mod);
491
        _edje_ephysics->mod = NULL;
492
     }
493
   return EINA_FALSE;
494
}
495

496
static void
497
_edje_ephysics_clear(void)
498
{
499
   if (_edje_ephysics)
500
     {
501
        if (_edje_ephysics->mod)
502
          eina_module_free(_edje_ephysics->mod);
503
        free(_edje_ephysics);
504
        _edje_ephysics = NULL;
505
     }
506
}
507
#endif
508

509