src/lib/edje_main.c

   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 int _edje_default_log_dom = -1;
   8 Eina_Mempool *_edje_real_part_mp = NULL;
   9 Eina_Mempool *_edje_real_part_state_mp = NULL;
  10
  11 /*============================================================================*
  12  *                                   API                                      *
  13  *============================================================================*/
  14
  15
  16 EAPI int
  17 edje_init(void)
  18 {
  19    if (++_edje_init_count != 1)
  20      return _edje_init_count;
  21
  22    srand(time(NULL));
  23
  24    if (!eina_init())
  25      return --_edje_init_count;
  26
  27    _edje_default_log_dom = eina_log_domain_register
  28      ("edje", EDJE_DEFAULT_LOG_COLOR);
  29    if (_edje_default_log_dom < 0)
  30      {
  31         EINA_LOG_ERR("Edje Can not create a general log domain.");
  32         goto shutdown_eina;
  33      }
  34
  35    if (!ecore_init())
  36      {
  37         ERR("Ecore init failed");
  38         goto unregister_log_domain;
  39      }
  40
  41    if (!embryo_init())
  42      {
  43         ERR("Embryo init failed");
  44         goto shutdown_ecore;
  45      }
  46
  47    if (!eet_init())
  48      {
  49         ERR("Eet init failed");
  50         goto shutdown_embryo;
  51      }
  52
  53 #ifdef HAVE_EIO
  54    if (!eio_init())
  55      {
  56         ERR("Eio init failed");
  57         goto shutdown_eet;
  58      }
  59 #endif
  60
  61    _edje_scale = FROM_DOUBLE(1.0);
  62
  63    _edje_edd_init();
  64    _edje_text_init();
  65    _edje_box_init();
  66    _edje_external_init();
  67    _edje_module_init();
  68    _edje_message_init();
  69    _edje_multisense_init();
  70
  71    _edje_real_part_mp = eina_mempool_add("chained_mempool",
  72                                          "Edje_Real_Part", NULL,
  73                                          sizeof (Edje_Real_Part), 32);
  74    if (!_edje_real_part_mp)
  75      {
  76         ERR("Mempool for Edje_Real_Part cannot be allocated.");
  77         goto shutdown_all;
  78      }
  79
  80    _edje_real_part_state_mp = eina_mempool_add("chained_mempool",
  81                                                "Edje_Real_Part_State", NULL,
  82                                                sizeof (Edje_Real_Part_State), 32);
  83    if (!_edje_real_part_state_mp)
  84      {
  85         ERR("Mempool for Edje_Real_Part_State cannot be allocated.");
  86         goto shutdown_all;
  87      }
  88
  89    return _edje_init_count;
  90
  91  shutdown_all:
  92    eina_mempool_del(_edje_real_part_state_mp);
  93    eina_mempool_del(_edje_real_part_mp);
  94    _edje_real_part_state_mp = NULL;
  95    _edje_real_part_mp = NULL;
  96    _edje_message_shutdown();
  97    _edje_module_shutdown();
  98    _edje_external_shutdown();
  99    _edje_box_shutdown();
 100    _edje_text_class_members_free();
 101    _edje_text_class_hash_free();
 102    _edje_edd_shutdown();
 103 #ifdef HAVE_EIO
 104    eio_shutdown();
 105  shutdown_eet:
 106 #endif
 107    eet_shutdown();
 108  shutdown_embryo:
 109    embryo_shutdown();
 110  shutdown_ecore:
 111    ecore_shutdown();
 112  unregister_log_domain:
 113    eina_log_domain_unregister(_edje_default_log_dom);
 114    _edje_default_log_dom = -1;
 115  shutdown_eina:
 116    eina_shutdown();
 117    return --_edje_init_count;
 118 }
 119
 120 static int _edje_users = 0;
 121
 122 static void
 123 _edje_shutdown_core(void)
 124 {
 125    if (_edje_users > 0) return;
 126
 127    _edje_file_cache_shutdown();
 128    _edje_color_class_members_free();
 129    _edje_color_class_hash_free();
 130
 131    eina_mempool_del(_edje_real_part_state_mp);
 132    eina_mempool_del(_edje_real_part_mp);
 133    _edje_real_part_state_mp = NULL;
 134    _edje_real_part_mp = NULL;
 135
 136    _edje_multisense_shutdown();
 137    _edje_message_shutdown();
 138    _edje_module_shutdown();
 139    _edje_external_shutdown();
 140    _edje_box_shutdown();
 141    _edje_text_class_members_free();
 142    _edje_text_class_hash_free();
 143    _edje_edd_shutdown();
 144
 145 #ifdef HAVE_EIO
 146    eio_shutdown();
 147 #endif
 148    eet_shutdown();
 149    embryo_shutdown();
 150    ecore_shutdown();
 151    eina_log_domain_unregister(_edje_default_log_dom);
 152    _edje_default_log_dom = -1;
 153    eina_shutdown();
 154 }
 155
 156 void
 157 _edje_lib_ref(void)
 158 {
 159    _edje_users++;
 160 }
 161
 162 void
 163 _edje_lib_unref(void)
 164 {
 165    _edje_users--;
 166    if (_edje_users != 0) return;
 167    if (_edje_init_count == 0) _edje_shutdown_core();
 168 }
 169
 170 EAPI int
 171 edje_shutdown(void)
 172 {
 173    if (_edje_init_count <= 0)
 174      {
 175         ERR("Init count not greater than 0 in shutdown.");
 176         return 0;
 177      }
 178    if (--_edje_init_count != 0)
 179      return _edje_init_count;
 180
 181    if (_edje_timer)
 182      ecore_animator_del(_edje_timer);
 183    _edje_timer = NULL;
 184
 185    _edje_shutdown_core();
 186
 187    return _edje_init_count;
 188 }
 189
 190 /* Private Routines */
 191 static void
 192 _class_member_free(Eina_Hash *hash,
 193                    void (*_edje_class_member_direct_del)(const char *class, void *l))
 194 {
 195    const char *color_class;
 196    Eina_Iterator *it;
 197    Eina_List *class_kill = NULL;
 198
 199    if (hash)
 200      {
 201         it = eina_hash_iterator_key_new(hash);
 202         EINA_ITERATOR_FOREACH(it, color_class)
 203           class_kill = eina_list_append(class_kill, color_class);
 204         eina_iterator_free(it);
 205         EINA_LIST_FREE(class_kill, color_class)
 206           {
 207              void *l;
 208
 209              l = eina_hash_find(hash, color_class);
 210              _edje_class_member_direct_del(color_class, l);
 211           }
 212         eina_hash_free(hash);
 213      }
 214 }
 215
 216 void
 217 _edje_del(Edje *ed)
 218 {
 219    Edje_Running_Program *runp;
 220    Edje_Pending_Program *pp;
 221    Edje_Signal_Callback *escb;
 222    Edje_Text_Class *tc;
 223    Edje_Text_Insert_Filter_Callback *cb;
 224
 225    if (ed->processing_messages)
 226      {
 227         ed->delete_me = 1;
 228         return;
 229      }
 230    _edje_message_del(ed);
 231    _edje_callbacks_patterns_clean(ed);
 232    _edje_file_del(ed);
 233    if (ed->path) eina_stringshare_del(ed->path);
 234    if (ed->group) eina_stringshare_del(ed->group);
 235    if (ed->parent) eina_stringshare_del(ed->parent);
 236    ed->path = NULL;
 237    ed->group = NULL;
 238    if ((ed->actions) || (ed->pending_actions))
 239      {
 240         _edje_animators = eina_list_remove(_edje_animators, ed);
 241      }
 242    EINA_LIST_FREE(ed->actions, runp)
 243      free(runp);
 244    EINA_LIST_FREE(ed->pending_actions, pp)
 245      free(pp);
 246    EINA_LIST_FREE(ed->callbacks, escb)
 247      {
 248         if (escb->signal) eina_stringshare_del(escb->signal);
 249         if (escb->source) eina_stringshare_del(escb->source);
 250         free(escb);
 251      }
 252    eina_hash_free(ed->color_classes);
 253    EINA_LIST_FREE(ed->text_classes, tc)
 254      {
 255         if (tc->name) eina_stringshare_del(tc->name);
 256         if (tc->font) eina_stringshare_del(tc->font);
 257         free(tc);
 258      }
 259    EINA_LIST_FREE(ed->text_insert_filter_callbacks, cb)
 260      {
 261         eina_stringshare_del(cb->part);
 262         free(cb);
 263      }
 264    EINA_LIST_FREE(ed->markup_filter_callbacks, cb)
 265      {
 266         eina_stringshare_del(cb->part);
 267         free(cb);
 268      }
 269
 270    _class_member_free(ed->members.text_class, _edje_text_class_member_direct_del);
 271    _class_member_free(ed->members.color_class, _edje_color_class_member_direct_del);
 272    free(ed);
 273 }
 274
 275 void
 276 _edje_clean_objects(Edje *ed)
 277 {
 278    evas_object_del(ed->base.clipper);
 279    ed->base.evas = NULL;
 280    ed->obj = NULL;
 281    ed->base.clipper = NULL;
 282 }
 283
 284 void
 285 _edje_ref(Edje *ed)
 286 {
 287    if (ed->references <= 0) return;
 288    ed->references++;
 289 }
 290
 291 void
 292 _edje_unref(Edje *ed)
 293 {
 294    ed->references--;
 295    if (ed->references == 0) _edje_del(ed);
 296 }