src/bin/e_main.c

   1 #include "e.h"
   2 #ifdef __linux__
   3 # include <sys/prctl.h>
   4 #endif
   5
   6 #define MAX_LEVEL 80
   7
   8 #define TS_DO
   9 #ifdef TS_DO
  10 # define TS(x)                                                    \
  11   {                                                               \
  12      t1 = ecore_time_unix_get();                                  \
  13      printf("ESTART: %1.5f [%1.5f] - %s\n", t1 - t0, t1 - t2, x); \
  14      t2 = t1;                                                     \
  15   }
  16 static double t0, t1, t2;
  17 #else
  18 # define TS(x)
  19 #endif
  20 /*
  21  * i need to make more use of these when i'm baffled as to when something is
  22  * up. other hooks:
  23  *
  24  *      void *(*__malloc_hook)(size_t size, const void *caller);
  25  *
  26  *      void *(*__realloc_hook)(void *ptr, size_t size, const void *caller);
  27  *
  28  *      void *(*__memalign_hook)(size_t alignment, size_t size,
  29  *                               const void *caller);
  30  *
  31  *      void (*__free_hook)(void *ptr, const void *caller);
  32  *
  33  *      void (*__malloc_initialize_hook)(void);
  34  *
  35  *      void (*__after_morecore_hook)(void);
  36  *
  37
  38    static void my_init_hook(void);
  39    static void my_free_hook(void *p, const void *caller);
  40
  41    static void (*old_free_hook)(void *ptr, const void *caller) = NULL;
  42    void (*__free_hook)(void *ptr, const void *caller);
  43
  44    void (*__malloc_initialize_hook) (void) = my_init_hook;
  45    static void
  46    my_init_hook(void)
  47    {
  48    old_free_hook = __free_hook;
  49    __free_hook = my_free_hook;
  50    }
  51
  52    //void *magicfree = NULL;
  53
  54    static void
  55    my_free_hook(void *p, const void *caller)
  56    {
  57    __free_hook = old_free_hook;
  58    //   if ((p) && (p == magicfree))
  59    //     {
  60    //   printf("CAUGHT!!!!! %p ...\n", p);
  61    //   abort();
  62    //     }
  63    free(p);
  64    __free_hook = my_free_hook;
  65    }
  66  */
  67
  68 /* local function prototypes */
  69 static void      _e_main_shutdown(int errcode);
  70 static void      _e_main_shutdown_push(int (*func)(void));
  71 static void      _e_main_parse_arguments(int argc, char **argv);
  72 static Eina_Bool _e_main_cb_signal_exit(void *data EINA_UNUSED, int ev_type EINA_UNUSED, void *ev EINA_UNUSED);
  73 static Eina_Bool _e_main_cb_signal_hup(void *data EINA_UNUSED, int ev_type EINA_UNUSED, void *ev EINA_UNUSED);
  74 static Eina_Bool _e_main_cb_signal_user(void *data EINA_UNUSED, int ev_type EINA_UNUSED, void *ev);
  75 static int       _e_main_dirs_init(void);
  76 static int       _e_main_dirs_shutdown(void);
  77 static int       _e_main_path_init(void);
  78 static int       _e_main_path_shutdown(void);
  79 static int       _e_main_screens_init(void);
  80 static int       _e_main_screens_shutdown(void);
  81 static void      _e_main_desk_save(void);
  82 static void      _e_main_desk_restore(void);
  83 static void      _e_main_modules_load(Eina_Bool safe_mode);
  84 static Eina_Bool _e_main_cb_idle_before(void *data EINA_UNUSED);
  85 static Eina_Bool _e_main_cb_idle_after(void *data EINA_UNUSED);
  86 static void      _e_main_create_wm_ready(void);
  87 static void      _e_main_hooks_clean(void);
  88 static void      _e_main_hook_call(E_Main_Hook_Point hookpoint, void *data EINA_UNUSED);
  89
  90 /* local variables */
  91 static Eina_Bool really_know = EINA_FALSE;
  92 static Eina_Bool inloop = EINA_FALSE;
  93 static jmp_buf x_fatal_buff;
  94
  95 static int _e_main_lvl = 0;
  96 static int(*_e_main_shutdown_func[MAX_LEVEL]) (void);
  97
  98 static Ecore_Idle_Enterer *_idle_before = NULL;
  99 static Ecore_Idle_Enterer *_idle_after = NULL;
 100
 101 static Ecore_Event_Handler *mod_init_end = NULL;
 102
 103 static Eina_List *hooks = NULL;
 104
 105 static int _e_main_hooks_delete = 0;
 106 static int _e_main_hooks_walking = 0;
 107
 108 static Eina_Inlist *_e_main_hooks[] =
 109 {
 110    [E_MAIN_HOOK_MODULE_LOAD_DONE] = NULL,
 111    [E_MAIN_HOOK_E_INFO_READY] = NULL
 112 };
 113
 114 /* external variables */
 115 E_API Eina_Bool e_precache_end = EINA_FALSE;
 116 E_API Eina_Bool x_fatal = EINA_FALSE;
 117 E_API Eina_Bool good = EINA_FALSE;
 118 E_API Eina_Bool evil = EINA_FALSE;
 119 E_API Eina_Bool starting = EINA_TRUE;
 120 E_API Eina_Bool stopping = EINA_FALSE;
 121 E_API Eina_Bool restart = EINA_FALSE;
 122 E_API Eina_Bool e_nopause = EINA_FALSE;
 123 EINTERN const char *e_first_frame = NULL;
 124 EINTERN double e_first_frame_start_time = -1;
 125
 126 static Eina_Bool
 127 _xdg_check_str(const char *env, const char *str)
 128 {
 129    const char *p;
 130    size_t len;
 131
 132    len = strlen(str);
 133    for (p = strstr(env, str); p; p++, p = strstr(p, str))
 134      {
 135         if ((!p[len]) || (p[len] == ':')) return EINA_TRUE;
 136      }
 137    return EINA_FALSE;
 138 }
 139
 140 static void
 141 _xdg_data_dirs_augment(void)
 142 {
 143    const char *s;
 144    const char *p = e_prefix_get();
 145    char newpath[4096], buf[4096];
 146
 147    if (!p) return;
 148
 149    s = getenv("XDG_DATA_DIRS");
 150    if (s)
 151      {
 152         Eina_Bool pfxdata, pfx;
 153
 154         pfxdata = !_xdg_check_str(s, e_prefix_data_get());
 155         snprintf(newpath, sizeof(newpath), "%s/share", p);
 156         pfx = !_xdg_check_str(s, newpath);
 157         if (pfxdata || pfx)
 158           {
 159              snprintf(buf, sizeof(buf), "%s%s%s%s%s",
 160                pfxdata ? e_prefix_data_get() : "",
 161                pfxdata ? ":" : "",
 162                pfx ? newpath : "",
 163                pfx ? ":" : "",
 164                s);
 165              e_util_env_set("XDG_DATA_DIRS", buf);
 166           }
 167      }
 168    else
 169      {
 170         snprintf(buf, sizeof(buf), "%s:%s/share:/usr/local/share:/usr/share", e_prefix_data_get(), p);
 171         e_util_env_set("XDG_DATA_DIRS", buf);
 172      }
 173
 174    s = getenv("XDG_CONFIG_DIRS");
 175    snprintf(newpath, sizeof(newpath), "%s/etc/xdg", p);
 176    if (s)
 177      {
 178         if (!_xdg_check_str(s, newpath))
 179           {
 180              snprintf(buf, sizeof(buf), "%s:%s", newpath, s);
 181              e_util_env_set("XDG_CONFIG_DIRS", buf);
 182           }
 183      }
 184    else
 185      {
 186         snprintf(buf, sizeof(buf), "%s:/etc/xdg", newpath);
 187         e_util_env_set("XDG_CONFIG_DIRS", buf);
 188      }
 189
 190    if (!getenv("XDG_RUNTIME_DIR"))
 191      {
 192         const char *dir;
 193
 194         snprintf(buf, sizeof(buf), "/tmp/xdg-XXXXXX");
 195         dir = mkdtemp(buf);
 196         if (!dir) dir = "/tmp";
 197         else
 198           {
 199              e_util_env_set("XDG_RUNTIME_DIR", dir);
 200              snprintf(buf, sizeof(buf), "%s/.e-deleteme", dir);
 201              ecore_file_mkdir(buf);
 202           }
 203      }
 204
 205    /* set menu prefix so we get our e menu */
 206    if (!getenv("XDG_MENU_PREFIX"))
 207      {
 208         e_util_env_set("XDG_MENU_PREFIX", "e-");
 209      }
 210 }
 211
 212 static Eina_Bool
 213 _e_main_subsystem_defer(void *data EINA_UNUSED)
 214 {
 215    int argc;
 216    char **argv;
 217
 218    TRACE_DS_BEGIN(MAIN:SUBSYSTEMS DEFER);
 219
 220    ecore_app_args_get(&argc, &argv);
 221
 222    /* try to init delayed subsystems */
 223
 224    TRACE_DS_BEGIN(MAIN:DEFERRED INTERNAL SUBSYSTEMS INIT);
 225
 226    TS("[DEFERRED] Screens Init: win");
 227    if (!e_win_init())
 228      {
 229         e_error_message_show(_("Enlightenment cannot setup elementary trap!\n"));
 230         TRACE_DS_END();
 231         _e_main_shutdown(-1);
 232      }
 233    TS("[DEFERRED] Screens Init: win Done");
 234
 235    TS("[DEFERRED] E_Dnd Init");
 236    if (!e_dnd_init())
 237      {
 238         e_error_message_show(_("Enlightenment cannot set up its dnd system.\n"));
 239         _e_main_shutdown(-1);
 240      }
 241    TS("[DEFERRED] E_Dnd Init Done");
 242    _e_main_shutdown_push(e_dnd_shutdown);
 243
 244    TS("[DEFERRED] E_Scale Init");
 245    if (!e_scale_init())
 246      {
 247         e_error_message_show(_("Enlightenment cannot set up its scale system.\n"));
 248         TRACE_DS_END();
 249         _e_main_shutdown(-1);
 250      }
 251    TS("[DEFERRED] E_Scale Init Done");
 252    _e_main_shutdown_push(e_scale_shutdown);
 253
 254    TS("[DEFERRED] E_Test_Helper Init");
 255    e_test_helper_init();
 256    _e_main_shutdown_push(e_test_helper_shutdown);
 257    TS("[DEFERRED] E_Test_Helper Done");
 258
 259    TS("[DEFERRED] E_INFO_SERVER Init");
 260    e_info_server_init();
 261    _e_main_shutdown_push(e_info_server_shutdown);
 262    TS("[DEFERRED] E_INFO_SERVER Done");
 263
 264    TRACE_DS_END();
 265    TRACE_DS_BEGIN(MAIN:DEFERRED COMP JOB);
 266
 267    /* try to do deferred job of any subsystems*/
 268    TS("[DEFERRED] Compositor's deferred job");
 269    e_comp_deferred_job();
 270    TS("[DEFERRED] Compositor's deferred job Done");
 271
 272    TRACE_DS_END();
 273    if (e_config->use_e_policy)
 274      {
 275         TRACE_DS_BEGIN(MAIN:DEFERRED POLICY JOB);
 276
 277         TS("[DEFERRED] E_Policy's deferred job");
 278         e_policy_deferred_job();
 279         TS("[DEFERRED] E_Policy's deferred job Done");
 280
 281         TRACE_DS_END();
 282      }
 283    TRACE_DS_BEGIN(MAIN:DEFERRED MODULE JOB);
 284
 285    TS("[DEFERRED] E_Module's deferred job");
 286    e_module_deferred_job();
 287    TS("[DEFERRED] E_Module's deferred job Done");
 288
 289    TRACE_DS_END();
 290    TRACE_DS_END();
 291
 292    return ECORE_CALLBACK_DONE;
 293 }
 294
 295 static Eina_Bool
 296 _e_main_deferred_job_schedule(void *d EINA_UNUSED, int type EINA_UNUSED, void *ev EINA_UNUSED)
 297 {
 298    PRCTL("[Winsys] all modules loaded");
 299    ecore_idler_add(_e_main_subsystem_defer, NULL);
 300    return ECORE_CALLBACK_DONE;
 301 }
 302
 303 /* externally accessible functions */
 304 int
 305 main(int argc, char **argv)
 306 {
 307    Eina_Bool safe_mode = EINA_FALSE;
 308    double t = 0.0, tstart = 0.0;
 309    char *s = NULL, buff[32];
 310    struct sigaction action;
 311
 312 #ifdef __linux__
 313 # ifdef PR_SET_PTRACER
 314 #  ifdef PR_SET_PTRACER_ANY
 315    prctl(PR_SET_PTRACER, PR_SET_PTRACER_ANY);
 316 #  endif
 317 # endif
 318 #endif
 319 #ifdef TS_DO
 320    t0 = t1 = t2 = ecore_time_unix_get();
 321    printf("ESTART(main) %1.5f\n", t0);
 322 #endif
 323    TRACE_DS_BEGIN(MAIN:BEGIN STARTUP);
 324    TS("Begin Startup");
 325    PRCTL("[Winsys] start of main");
 326
 327    /* trap deadly bug signals and allow some form of sane recovery */
 328    /* or ability to gdb attach and debug at this point - better than your */
 329    /* wm/desktop vanishing and not knowing what happened */
 330
 331    /* don't install SIGBUS handler */
 332    /* Wayland shm sets up a sigbus handler for catching invalid shm region */
 333    /* access. If we setup our sigbus handler here, then the wl-shm sigbus */
 334    /* handler will not function properly */
 335    if (!getenv("NOTIFY_SOCKET"))
 336      {
 337         TS("Signal Trap");
 338         action.sa_sigaction = e_sigseg_act;
 339         action.sa_flags = SA_NODEFER | SA_RESETHAND | SA_SIGINFO;
 340         sigemptyset(&action.sa_mask);
 341         sigaction(SIGSEGV, &action, NULL);
 342
 343         action.sa_sigaction = e_sigill_act;
 344         action.sa_flags = SA_NODEFER | SA_RESETHAND | SA_SIGINFO;
 345         sigemptyset(&action.sa_mask);
 346         sigaction(SIGILL, &action, NULL);
 347
 348         action.sa_sigaction = e_sigfpe_act;
 349         action.sa_flags = SA_NODEFER | SA_RESETHAND | SA_SIGINFO;
 350         sigemptyset(&action.sa_mask);
 351         sigaction(SIGFPE, &action, NULL);
 352
 353         action.sa_sigaction = e_sigabrt_act;
 354         action.sa_flags = SA_NODEFER | SA_RESETHAND | SA_SIGINFO;
 355         sigemptyset(&action.sa_mask);
 356         sigaction(SIGABRT, &action, NULL);
 357         TS("Signal Trap Done");
 358      }
 359
 360    t = ecore_time_unix_get();
 361    s = getenv("E_START_TIME");
 362    if ((s) && (!getenv("E_RESTART_OK")))
 363      {
 364         tstart = atof(s);
 365         if ((t - tstart) < 5.0) safe_mode = EINA_TRUE;
 366      }
 367    tstart = t;
 368    snprintf(buff, sizeof(buff), "%1.1f", tstart);
 369    e_util_env_set("E_START_TIME", buff);
 370
 371    if (getenv("E_START_MTRACK"))
 372      e_util_env_set("MTRACK", NULL);
 373    TS("Eina Init");
 374    if (!eina_init())
 375      {
 376         e_error_message_show(_("Enlightenment cannot initialize Eina!\n"));
 377         _e_main_shutdown(-1);
 378      }
 379    TS("Eina Init Done");
 380    _e_main_shutdown_push(eina_shutdown);
 381
 382 #ifdef OBJECT_HASH_CHECK
 383    TS("E_Object Hash Init");
 384    e_object_hash_init();
 385    TS("E_Object Hash Init Done");
 386 #endif
 387
 388    TS("E_Log Init");
 389    if (!e_log_init())
 390      {
 391         e_error_message_show(_("Enlightenment could not create a logging domain!\n"));
 392         _e_main_shutdown(-1);
 393      }
 394    TS("E_Log Init Done");
 395    _e_main_shutdown_push(e_log_shutdown);
 396
 397    TS("Determine Prefix");
 398    if (!e_prefix_determine(argv[0]))
 399      {
 400         fprintf(stderr,
 401                 "ERROR: Enlightenment cannot determine it's installed\n"
 402                 "       prefix from the system or argv[0].\n"
 403                 "       This is because it is not on Linux AND has been\n"
 404                 "       executed strangely. This is unusual.\n");
 405      }
 406    TS("Determine Prefix Done");
 407
 408    /* for debugging by redirecting stdout of e to a log file to tail */
 409    setvbuf(stdout, NULL, _IONBF, 0);
 410
 411    TS("Parse Arguments");
 412    _e_main_parse_arguments(argc, argv);
 413    TS("Parse Arguments Done");
 414
 415    /*** Initialize Core EFL Libraries We Need ***/
 416
 417    TS("Eet Init");
 418    if (!eet_init())
 419      {
 420         e_error_message_show(_("Enlightenment cannot initialize Eet!\n"));
 421         _e_main_shutdown(-1);
 422      }
 423    TS("Eet Init Done");
 424    _e_main_shutdown_push(eet_shutdown);
 425
 426    /* Allow ecore to not load system modules.
 427     * Without it ecore_init will block until dbus authentication
 428     * and registration are complete.
 429     */
 430    ecore_app_no_system_modules();
 431
 432    TS("Ecore Init");
 433    if (!ecore_init())
 434      {
 435         e_error_message_show(_("Enlightenment cannot initialize Ecore!\n"));
 436         _e_main_shutdown(-1);
 437      }
 438    TS("Ecore Init Done");
 439    _e_main_shutdown_push(ecore_shutdown);
 440
 441    e_first_frame = getenv("E_FIRST_FRAME");
 442    if (e_first_frame && e_first_frame[0])
 443      e_first_frame_start_time = ecore_time_get();
 444    else
 445      e_first_frame = NULL;
 446
 447    TS("EIO Init");
 448    if (!eio_init())
 449      {
 450         e_error_message_show(_("Enlightenment cannot initialize EIO!\n"));
 451         _e_main_shutdown(-1);
 452      }
 453    TS("EIO Init Done");
 454    _e_main_shutdown_push(eio_shutdown);
 455
 456    ecore_app_args_set(argc, (const char **)argv);
 457
 458    TS("Ecore Event Handlers");
 459    if (!ecore_event_handler_add(ECORE_EVENT_SIGNAL_EXIT,
 460                                 _e_main_cb_signal_exit, NULL))
 461      {
 462         e_error_message_show(_("Enlightenment cannot set up an exit signal handler.\n"
 463                                "Perhaps you are out of memory?"));
 464         _e_main_shutdown(-1);
 465      }
 466    if (!ecore_event_handler_add(ECORE_EVENT_SIGNAL_HUP,
 467                                 _e_main_cb_signal_hup, NULL))
 468      {
 469         e_error_message_show(_("Enlightenment cannot set up a HUP signal handler.\n"
 470                                "Perhaps you are out of memory?"));
 471         _e_main_shutdown(-1);
 472      }
 473    if (!ecore_event_handler_add(ECORE_EVENT_SIGNAL_USER,
 474                                 _e_main_cb_signal_user, NULL))
 475      {
 476         e_error_message_show(_("Enlightenment cannot set up a USER signal handler.\n"
 477                                "Perhaps you are out of memory?"));
 478         _e_main_shutdown(-1);
 479      }
 480    TS("Ecore Event Handlers Done");
 481
 482    TS("Ecore_File Init");
 483    if (!ecore_file_init())
 484      {
 485         e_error_message_show(_("Enlightenment cannot initialize Ecore_File!\n"));
 486         _e_main_shutdown(-1);
 487      }
 488    TS("Ecore_File Init Done");
 489    _e_main_shutdown_push(ecore_file_shutdown);
 490
 491    _idle_before = ecore_idle_enterer_before_add(_e_main_cb_idle_before, NULL);
 492
 493    TS("XDG_DATA_DIRS Init");
 494    _xdg_data_dirs_augment();
 495    TS("XDG_DATA_DIRS Init Done");
 496
 497    TS("Ecore_Evas Init");
 498    if (!ecore_evas_init())
 499      {
 500         e_error_message_show(_("Enlightenment cannot initialize Ecore_Evas!\n"));
 501         _e_main_shutdown(-1);
 502      }
 503    TS("Ecore_Evas Init Done");
 504
 505    /* e doesn't sync to compositor - it should be one */
 506    ecore_evas_app_comp_sync_set(0);
 507
 508    TS("Edje Init");
 509    if (!edje_init())
 510      {
 511         e_error_message_show(_("Enlightenment cannot initialize Edje!\n"));
 512         _e_main_shutdown(-1);
 513      }
 514    TS("Edje Init Done");
 515    _e_main_shutdown_push(edje_shutdown);
 516
 517    /*** Initialize E Subsystems We Need ***/
 518
 519    TS("E Directories Init");
 520    /* setup directories we will be using for configurations storage etc. */
 521    if (!_e_main_dirs_init())
 522      {
 523         e_error_message_show(_("Enlightenment cannot create directories in your home directory.\n"
 524                                "Perhaps you have no home directory or the disk is full?"));
 525         _e_main_shutdown(-1);
 526      }
 527    TS("E Directories Init Done");
 528    _e_main_shutdown_push(_e_main_dirs_shutdown);
 529
 530    TS("E_Config Init");
 531    if (!e_config_init())
 532      {
 533         e_error_message_show(_("Enlightenment cannot set up its config system.\n"));
 534         _e_main_shutdown(-1);
 535      }
 536    TS("E_Config Init Done");
 537    _e_main_shutdown_push(e_config_shutdown);
 538
 539    TS("E_Env Init");
 540    if (!e_env_init())
 541      {
 542         e_error_message_show(_("Enlightenment cannot set up its environment.\n"));
 543         _e_main_shutdown(-1);
 544      }
 545    TS("E_Env Init Done");
 546    _e_main_shutdown_push(e_env_shutdown);
 547
 548    ecore_exe_run_priority_set(e_config->priority);
 549
 550    TS("E Paths Init");
 551    if (!_e_main_path_init())
 552      {
 553         e_error_message_show(_("Enlightenment cannot set up paths for finding files.\n"
 554                                "Perhaps you are out of memory?"));
 555         _e_main_shutdown(-1);
 556      }
 557    TS("E Paths Init Done");
 558    _e_main_shutdown_push(_e_main_path_shutdown);
 559
 560    ecore_animator_frametime_set(1.0 / e_config->framerate);
 561
 562    TS("E_Theme Init");
 563    if (!e_theme_init())
 564      {
 565         e_error_message_show(_("Enlightenment cannot set up its theme system.\n"));
 566         _e_main_shutdown(-1);
 567      }
 568    TS("E_Theme Init Done");
 569    _e_main_shutdown_push(e_theme_shutdown);
 570
 571    TS("E_Actions Init");
 572    if (!e_actions_init())
 573      {
 574         e_error_message_show(_("Enlightenment cannot set up its actions system.\n"));
 575         _e_main_shutdown(-1);
 576      }
 577    TS("E_Actions Init Done");
 578    _e_main_shutdown_push(e_actions_shutdown);
 579
 580    /* these just add event handlers and can't fail
 581     * timestamping them is dumb.
 582     */
 583    e_screensaver_preinit();
 584    e_zone_init();
 585    e_desk_init();
 586    e_slot_init();
 587
 588    TRACE_DS_BEGIN(MAIN:WAIT /dev/dri/card0);
 589    if (e_config->sleep_for_dri)
 590      {
 591         while(access("/dev/dri/card0", F_OK) != 0)
 592           {
 593              struct timespec req, rem;
 594              req.tv_sec = 0;
 595              req.tv_nsec = 50000000L;
 596              nanosleep(&req, &rem);
 597           }
 598      }
 599    TRACE_DS_END();
 600
 601    TS("E_Pointer Init");
 602    if (!e_pointer_init())
 603      {
 604         e_error_message_show(_("Enlightenment cannot set up its pointer system.\n"));
 605         _e_main_shutdown(-1);
 606      }
 607    TS("E_Pointer Init Done");
 608    _e_main_shutdown_push(e_pointer_shutdown);
 609
 610    TRACE_DS_BEGIN(MAIN:SCREEN INIT);
 611    TS("Screens Init");
 612    if (!_e_main_screens_init())
 613      {
 614         e_error_message_show(_("Enlightenment set up window management for all the screens on your system\n"
 615                                "failed. Perhaps another window manager is running?\n"));
 616         _e_main_shutdown(-1);
 617      }
 618    TS("Screens Init Done");
 619    _e_main_shutdown_push(_e_main_screens_shutdown);
 620    TRACE_DS_END();
 621
 622    TS("E_Screensaver Init");
 623    if (!e_screensaver_init())
 624      {
 625         e_error_message_show(_("Enlightenment cannot configure the X screensaver.\n"));
 626         _e_main_shutdown(-1);
 627      }
 628    TS("E_Screensaver Init Done");
 629    _e_main_shutdown_push(e_screensaver_shutdown);
 630
 631    TS("E_Comp Freeze");
 632    e_comp_all_freeze();
 633    TS("E_Comp Freeze Done");
 634
 635    TS("E_Grabinput Init");
 636    if (!e_grabinput_init())
 637      {
 638         e_error_message_show(_("Enlightenment cannot set up its grab input handling system.\n"));
 639         _e_main_shutdown(-1);
 640      }
 641    TS("E_Grabinput Init Done");
 642    _e_main_shutdown_push(e_grabinput_shutdown);
 643
 644    ecore_event_handler_add(E_EVENT_MODULE_INIT_END, _e_main_deferred_job_schedule, NULL);
 645
 646    TS("E_Module Init");
 647    if (!e_module_init())
 648      {
 649         e_error_message_show(_("Enlightenment cannot set up its module system.\n"));
 650         _e_main_shutdown(-1);
 651      }
 652    TS("E_Module Init Done");
 653    _e_main_shutdown_push(e_module_shutdown);
 654
 655    TS("E_Mouse Init");
 656    if (!e_mouse_update())
 657      {
 658         e_error_message_show(_("Enlightenment cannot configure the mouse settings.\n"));
 659         _e_main_shutdown(-1);
 660      }
 661    TS("E_Mouse Init Done");
 662
 663    TS("E_Icon Init");
 664    if (!e_icon_init())
 665      {
 666         e_error_message_show(_("Enlightenment cannot initialize the Icon Cache system.\n"));
 667         _e_main_shutdown(-1);
 668      }
 669    TS("E_Icon Init Done");
 670    _e_main_shutdown_push(e_icon_shutdown);
 671
 672    if (e_config->use_e_policy)
 673      {
 674         TS("E_Policy Init");
 675         if (!e_policy_init())
 676           {
 677              e_error_message_show(_("Enlightenment cannot setup policy system!\n"));
 678              _e_main_shutdown(-1);
 679           }
 680         TS("E_Policy Init Done");
 681         _e_main_shutdown_push(e_policy_shutdown);
 682      }
 683
 684    TS("E_Process Init");
 685    if (!e_process_init())
 686      {
 687         e_error_message_show(_("Enlightenment cannot setup process managing system!\n"));
 688         _e_main_shutdown(-1);
 689      }
 690    TS("E_Process Init Done");
 691    _e_main_shutdown_push(e_process_shutdown);
 692
 693    TS("E_Security Init");
 694    if (!e_security_init())
 695      {
 696         e_error_message_show(_("Enlightenment cannot setup security system!\n"));
 697         _e_main_shutdown(-1);
 698      }
 699    TS("E_Security Init Done");
 700    _e_main_shutdown_push(e_security_shutdown);
 701
 702    TS("Load Modules");
 703    _e_main_modules_load(safe_mode);
 704    TS("Load Modules Done");
 705
 706    TS("E_Comp Thaw");
 707    e_comp_all_thaw();
 708    TS("E_Comp Thaw Done");
 709
 710    _idle_after = ecore_idle_enterer_add(_e_main_cb_idle_after, NULL);
 711
 712    starting = EINA_FALSE;
 713    inloop = EINA_TRUE;
 714
 715    e_util_env_set("E_RESTART", "1");
 716
 717    TS("MAIN LOOP AT LAST");
 718
 719    if (e_config->create_wm_ready)
 720      _e_main_create_wm_ready();
 721
 722    TRACE_DS_END();
 723    if (!setjmp(x_fatal_buff))
 724      ecore_main_loop_begin();
 725    else
 726      CRI("FATAL: X Died. Connection gone. Abbreviated Shutdown\n");
 727
 728    inloop = EINA_FALSE;
 729    stopping = EINA_TRUE;
 730
 731    _e_main_desk_save();
 732    e_comp_internal_save();
 733
 734    _e_main_shutdown(0);
 735
 736    if (restart)
 737      {
 738         e_util_env_set("E_RESTART_OK", "1");
 739         if (getenv("E_START_MTRACK"))
 740           e_util_env_set("MTRACK", "track");
 741         ecore_app_restart();
 742      }
 743
 744    e_prefix_shutdown();
 745
 746    return 0;
 747 }
 748
 749 E_API double
 750 e_main_ts(const char *str)
 751 {
 752    double ret;
 753    t1 = ecore_time_unix_get();
 754    printf("ESTART: %1.5f [%1.5f] - %s\n", t1 - t0, t1 - t2, str);
 755    ret = t1 - t2;
 756    t2 = t1;
 757    return ret;
 758 }
 759
 760 /* local functions */
 761 static void
 762 _e_main_shutdown(int errcode)
 763 {
 764    int i = 0;
 765    char buf[PATH_MAX];
 766    const char *dir;
 767
 768    printf("E: Begin Shutdown Procedure!\n");
 769
 770    E_FREE_LIST(hooks, e_main_hook_del);
 771
 772    if (_idle_before) ecore_idle_enterer_del(_idle_before);
 773    _idle_before = NULL;
 774    if (_idle_after) ecore_idle_enterer_del(_idle_after);
 775    _idle_after = NULL;
 776
 777    dir = getenv("XDG_RUNTIME_DIR");
 778    if (dir)
 779      {
 780         char buf_env[PATH_MAX];
 781         snprintf(buf_env, sizeof(buf_env), "%s", dir);
 782         snprintf(buf, sizeof(buf), "%s/.e-deleteme", buf_env);
 783         if (ecore_file_exists(buf)) ecore_file_recursive_rm(buf_env);
 784      }
 785    for (i = (_e_main_lvl - 1); i >= 0; i--)
 786      (*_e_main_shutdown_func[i])();
 787 #ifdef OBJECT_HASH_CHECK
 788    e_object_hash_shutdown();
 789 #endif
 790    if (errcode < 0) exit(errcode);
 791 }
 792
 793 static void
 794 _e_main_shutdown_push(int (*func)(void))
 795 {
 796    _e_main_lvl++;
 797    if (_e_main_lvl > MAX_LEVEL)
 798      {
 799         _e_main_lvl--;
 800         e_error_message_show("WARNING: too many init levels. MAX = %i\n",
 801                              MAX_LEVEL);
 802         return;
 803      }
 804    _e_main_shutdown_func[_e_main_lvl - 1] = func;
 805 }
 806
 807 static void
 808 _e_main_parse_arguments(int argc, char **argv)
 809 {
 810    int i = 0;
 811
 812    /* handle some command-line parameters */
 813    for (i = 1; i < argc; i++)
 814      {
 815         if (!strcmp(argv[i], "-good"))
 816           {
 817              good = EINA_TRUE;
 818              evil = EINA_FALSE;
 819              printf("LA LA LA\n");
 820           }
 821         else if (!strcmp(argv[i], "-evil"))
 822           {
 823              good = EINA_FALSE;
 824              evil = EINA_TRUE;
 825              printf("MUHAHAHAHHAHAHAHAHA\n");
 826           }
 827         else if (!strcmp(argv[i], "-psychotic"))
 828           {
 829              good = EINA_TRUE;
 830              evil = EINA_TRUE;
 831              printf("MUHAHALALALALALALALA\n");
 832           }
 833         else if ((!strcmp(argv[i], "-profile")) && (i < (argc - 1)))
 834           {
 835              i++;
 836              if (!getenv("E_CONF_PROFILE"))
 837                e_util_env_set("E_CONF_PROFILE", argv[i]);
 838           }
 839         else if (!strcmp(argv[i], "-i-really-know-what-i-am-doing-and-accept-full-responsibility-for-it"))
 840           really_know = EINA_TRUE;
 841         else if (!strcmp(argv[i], "-nopause"))
 842           e_nopause = EINA_TRUE;
 843         else if ((!strcmp(argv[i], "-version")) ||
 844                  (!strcmp(argv[i], "--version")))
 845           {
 846              printf(_("Version: %s\n"), PACKAGE_VERSION);
 847              _e_main_shutdown(-1);
 848           }
 849         else if ((!strcmp(argv[i], "-h")) ||
 850                  (!strcmp(argv[i], "-help")) ||
 851                  (!strcmp(argv[i], "--help")))
 852           {
 853              printf
 854                (_(
 855                  "Options:\n"
 856                  "\t-display DISPLAY\n"
 857                  "\t\tConnect to display named DISPLAY.\n"
 858                  "\t\tEG: -display :1.0\n"
 859                  "\t-fake-xinerama-screen WxH+X+Y\n"
 860                  "\t\tAdd a FAKE xinerama screen (instead of the real ones)\n"
 861                  "\t\tgiven the geometry. Add as many as you like. They all\n"
 862                  "\t\treplace the real xinerama screens, if any. This can\n"
 863                  "\t\tbe used to simulate xinerama.\n"
 864                  "\t\tEG: -fake-xinerama-screen 800x600+0+0 -fake-xinerama-screen 800x600+800+0\n"
 865                  "\t-profile CONF_PROFILE\n"
 866                  "\t\tUse the configuration profile CONF_PROFILE instead of the user selected default or just \"default\".\n"
 867                  "\t-good\n"
 868                  "\t\tBe good.\n"
 869                  "\t-evil\n"
 870                  "\t\tBe evil.\n"
 871                  "\t-psychotic\n"
 872                  "\t\tBe psychotic.\n"
 873                  "\t-i-really-know-what-i-am-doing-and-accept-full-responsibility-for-it\n"
 874                  "\t\tIf you need this help, you don't need this option.\n"
 875                  "\t-version\n"
 876                  )
 877                );
 878              _e_main_shutdown(-1);
 879           }
 880      }
 881 }
 882
 883 EINTERN void
 884 _e_main_cb_x_fatal(void *data EINA_UNUSED)
 885 {
 886    e_error_message_show("Lost X Connection.\n");
 887    ecore_main_loop_quit();
 888    if (!x_fatal)
 889      {
 890         x_fatal = EINA_TRUE;
 891         if (inloop) longjmp(x_fatal_buff, -99);
 892      }
 893 }
 894
 895 static Eina_Bool
 896 _e_main_cb_signal_exit(void *data EINA_UNUSED, int ev_type EINA_UNUSED, void *ev EINA_UNUSED)
 897 {
 898    /* called on ctrl-c, kill (pid) (also SIGINT, SIGTERM and SIGQIT) */
 899    ecore_main_loop_quit();
 900    return ECORE_CALLBACK_RENEW;
 901 }
 902
 903 static Eina_Bool
 904 _e_main_cb_signal_hup(void *data EINA_UNUSED, int ev_type EINA_UNUSED, void *ev EINA_UNUSED)
 905 {
 906    restart = 1;
 907    ecore_main_loop_quit();
 908    return ECORE_CALLBACK_RENEW;
 909 }
 910
 911 static Eina_Bool
 912 _e_main_cb_signal_user(void *data EINA_UNUSED, int ev_type EINA_UNUSED, void *ev)
 913 {
 914    Ecore_Event_Signal_User *e = ev;
 915
 916    if (e->number == 1)
 917      {
 918 //        E_Action *a = e_action_find("configuration");
 919 //        if ((a) && (a->func.go)) a->func.go(NULL, NULL);
 920      }
 921    else if (e->number == 2)
 922      {
 923         // comp module has its own handler for this for enabling/disabling fps debug
 924      }
 925    return ECORE_CALLBACK_RENEW;
 926
 927 }
 928
 929 static int
 930 _e_main_dirs_init(void)
 931 {
 932    if(getenv("E_CONF_RO"))
 933      {
 934         return 1;
 935      }
 936
 937    const char *base;
 938    const char *dirs[] =
 939    {
 940       "backgrounds",
 941       "config",
 942       "themes",
 943       NULL
 944    };
 945
 946    base = e_user_dir_get();
 947    if (ecore_file_mksubdirs(base, dirs) != sizeof(dirs) / sizeof(dirs[0]) - 1)
 948      {
 949         e_error_message_show("Could not create one of the required "
 950                              "subdirectories of '%s'\n", base);
 951         return 0;
 952      }
 953
 954    return 1;
 955 }
 956
 957 static int
 958 _e_main_dirs_shutdown(void)
 959 {
 960    return 1;
 961 }
 962
 963 static int
 964 _e_main_path_init(void)
 965 {
 966    char buf[PATH_MAX];
 967
 968    /* setup data paths */
 969    path_data = e_path_new();
 970    if (!path_data)
 971      {
 972         e_error_message_show("Cannot allocate path for path_data\n");
 973         return 0;
 974      }
 975    e_prefix_data_concat_static(buf, "data");
 976    e_path_default_path_append(path_data, buf);
 977
 978    /* setup image paths */
 979    path_images = e_path_new();
 980    if (!path_images)
 981      {
 982         e_error_message_show("Cannot allocate path for path_images\n");
 983         return 0;
 984      }
 985    e_user_dir_concat_static(buf, "/images");
 986    e_path_default_path_append(path_images, buf);
 987    e_prefix_data_concat_static(buf, "data/images");
 988    e_path_default_path_append(path_images, buf);
 989
 990    /* setup font paths */
 991    path_fonts = e_path_new();
 992    if (!path_fonts)
 993      {
 994         e_error_message_show("Cannot allocate path for path_fonts\n");
 995         return 0;
 996      }
 997    e_user_dir_concat_static(buf, "/fonts");
 998    e_path_default_path_append(path_fonts, buf);
 999    e_prefix_data_concat_static(buf, "data/fonts");
1000    e_path_default_path_append(path_fonts, buf);
1001
1002    /* setup icon paths */
1003    path_icons = e_path_new();
1004    if (!path_icons)
1005      {
1006         e_error_message_show("Cannot allocate path for path_icons\n");
1007         return 0;
1008      }
1009    e_user_dir_concat_static(buf, "/icons");
1010    e_path_default_path_append(path_icons, buf);
1011    e_prefix_data_concat_static(buf, "data/icons");
1012    e_path_default_path_append(path_icons, buf);
1013
1014    /* setup module paths */
1015    path_modules = e_path_new();
1016    if (!path_modules)
1017      {
1018         e_error_message_show("Cannot allocate path for path_modules\n");
1019         return 0;
1020      }
1021    e_user_dir_concat_static(buf, "/modules");
1022    e_path_default_path_append(path_modules, buf);
1023    snprintf(buf, sizeof(buf), "%s/enlightenment/modules", e_prefix_lib_get());
1024    e_path_default_path_append(path_modules, buf);
1025    /* FIXME: eventually this has to go - moduels should have installers that
1026     * add appropriate install paths (if not installed to user homedir) to
1027     * e's module search dirs
1028     */
1029    snprintf(buf, sizeof(buf), "%s/enlightenment/modules_extra", e_prefix_lib_get());
1030    e_path_default_path_append(path_modules, buf);
1031
1032    /* setup background paths */
1033    path_backgrounds = e_path_new();
1034    if (!path_backgrounds)
1035      {
1036         e_error_message_show("Cannot allocate path for path_backgrounds\n");
1037         return 0;
1038      }
1039    e_user_dir_concat_static(buf, "/backgrounds");
1040    e_path_default_path_append(path_backgrounds, buf);
1041    e_prefix_data_concat_static(buf, "data/backgrounds");
1042    e_path_default_path_append(path_backgrounds, buf);
1043
1044    path_messages = e_path_new();
1045    if (!path_messages)
1046      {
1047         e_error_message_show("Cannot allocate path for path_messages\n");
1048         return 0;
1049      }
1050    e_user_dir_concat_static(buf, "/locale");
1051    e_path_default_path_append(path_messages, buf);
1052    e_path_default_path_append(path_messages, e_prefix_locale_get());
1053
1054    return 1;
1055 }
1056
1057 static int
1058 _e_main_path_shutdown(void)
1059 {
1060    if (path_data)
1061      {
1062         e_object_del(E_OBJECT(path_data));
1063         path_data = NULL;
1064      }
1065    if (path_images)
1066      {
1067         e_object_del(E_OBJECT(path_images));
1068         path_images = NULL;
1069      }
1070    if (path_fonts)
1071      {
1072         e_object_del(E_OBJECT(path_fonts));
1073         path_fonts = NULL;
1074      }
1075    if (path_icons)
1076      {
1077         e_object_del(E_OBJECT(path_icons));
1078         path_icons = NULL;
1079      }
1080    if (path_modules)
1081      {
1082         e_object_del(E_OBJECT(path_modules));
1083         path_modules = NULL;
1084      }
1085    if (path_backgrounds)
1086      {
1087         e_object_del(E_OBJECT(path_backgrounds));
1088         path_backgrounds = NULL;
1089      }
1090    if (path_messages)
1091      {
1092         e_object_del(E_OBJECT(path_messages));
1093         path_messages = NULL;
1094      }
1095    return 1;
1096 }
1097
1098 static int
1099 _e_main_screens_init(void)
1100 {
1101    TS("\tscreens: client");
1102    if (!e_client_init()) return 0;
1103
1104    TS("Compositor Init");
1105    PRCTL("[Winsys] start of compositor init");
1106    if (!e_comp_init())
1107      {
1108         e_error_message_show(_("Enlightenment cannot create a compositor.\n"));
1109         _e_main_shutdown(-1);
1110      }
1111
1112    PRCTL("[Winsys] end of compositor init");
1113    _e_main_desk_restore();
1114
1115    return 1;
1116 }
1117
1118 static int
1119 _e_main_screens_shutdown(void)
1120 {
1121    e_win_shutdown();
1122    e_comp_shutdown();
1123    e_client_shutdown();
1124
1125    e_slot_shutdown();
1126    e_desk_shutdown();
1127    e_zone_shutdown();
1128    return 1;
1129 }
1130
1131 static void
1132 _e_main_desk_save(void)
1133 {
1134    const Eina_List *l;
1135    char env[1024], name[1024];
1136    E_Zone *zone;
1137
1138    EINA_LIST_FOREACH(e_comp->zones, l, zone)
1139      {
1140         snprintf(name, sizeof(name), "DESK_%d_%d", 0, zone->num);
1141         snprintf(env, sizeof(env), "%d,%d", zone->desk_x_current, zone->desk_y_current);
1142         e_util_env_set(name, env);
1143      }
1144 }
1145
1146 static void
1147 _e_main_desk_restore(void)
1148 {
1149    E_Client *ec;
1150
1151    E_CLIENT_REVERSE_FOREACH(ec)
1152      if ((!e_client_util_ignored_get(ec)) && e_client_util_desk_visible(ec, e_desk_current_get(ec->zone)))
1153        {
1154           ec->want_focus = ec->take_focus = 1;
1155           break;
1156        }
1157 }
1158
1159 static Eina_Bool
1160 _e_main_modules_load_after(void *d EINA_UNUSED, int type EINA_UNUSED, void *ev EINA_UNUSED)
1161 {
1162    E_FREE_FUNC(mod_init_end, ecore_event_handler_del);
1163    return ECORE_CALLBACK_RENEW;
1164 }
1165
1166 static void
1167 _e_main_modules_load(Eina_Bool safe_mode)
1168 {
1169    if (!safe_mode)
1170      e_module_all_load();
1171    else
1172      {
1173         E_Module *m;
1174         char *crashmodule;
1175
1176         crashmodule = getenv("E_MODULE_LOAD");
1177         if (crashmodule) m = e_module_new(crashmodule);
1178
1179         if ((crashmodule) && (m))
1180           {
1181              e_module_disable(m);
1182              e_object_del(E_OBJECT(m));
1183
1184              e_error_message_show
1185                (_("Enlightenment crashed early on start and has<br>"
1186                   "been restarted. There was an error loading the<br>"
1187                   "module named: %s. This module has been disabled<br>"
1188                   "and will not be loaded."), crashmodule);
1189              e_util_dialog_show
1190                (_("Enlightenment crashed early on start and has been restarted"),
1191                _("Enlightenment crashed early on start and has been restarted.<br>"
1192                  "There was an error loading the module named: %s<br><br>"
1193                  "This module has been disabled and will not be loaded."), crashmodule);
1194              e_module_all_load();
1195           }
1196         else
1197           {
1198              e_error_message_show
1199                (_("Enlightenment crashed early on start and has<br>"
1200                   "been restarted. All modules have been disabled<br>"
1201                   "and will not be loaded to help remove any problem<br>"
1202                   "modules from your configuration. The module<br>"
1203                   "configuration dialog should let you select your<br>"
1204                   "modules again.\n"));
1205              e_util_dialog_show
1206                (_("Enlightenment crashed early on start and has been restarted"),
1207                _("Enlightenment crashed early on start and has been restarted.<br>"
1208                  "All modules have been disabled and will not be loaded to help<br>"
1209                  "remove any problem modules from your configuration.<br><br>"
1210                  "The module configuration dialog should let you select your<br>"
1211                  "modules again."));
1212           }
1213         mod_init_end = ecore_event_handler_add(E_EVENT_MODULE_INIT_END, _e_main_modules_load_after, NULL);
1214      }
1215 }
1216
1217 static Eina_Bool
1218 _e_main_cb_idle_before(void *data EINA_UNUSED)
1219 {
1220    e_client_idler_before();
1221    edje_thaw();
1222    return ECORE_CALLBACK_RENEW;
1223 }
1224
1225 static Eina_Bool
1226 _e_main_cb_idle_after(void *data EINA_UNUSED)
1227 {
1228    static int first_idle = 1;
1229
1230    eet_clearcache();
1231    edje_freeze();
1232
1233 #ifdef E_RELEASE_BUILD
1234    if (first_idle)
1235      {
1236         TS("SLEEP");
1237         first_idle = 0;
1238         e_precache_end = EINA_TRUE;
1239      }
1240 #else
1241    if (first_idle++ < 60)
1242      {
1243         TS("SLEEP");
1244         if (!first_idle)
1245           e_precache_end = EINA_TRUE;
1246      }
1247 #endif
1248
1249    return ECORE_CALLBACK_RENEW;
1250 }
1251
1252 static void
1253 _e_main_create_wm_ready(void)
1254 {
1255    FILE *_wmready_checker = NULL;
1256
1257    _wmready_checker = fopen("/run/.wm_ready", "wb");
1258    if (_wmready_checker)
1259      {
1260         TS("[WM] WINDOW MANAGER is READY!!!");
1261         PRCTL("[Winsys] WINDOW MANAGER is READY!!!");
1262         fclose(_wmready_checker);
1263
1264         /*TODO: Next lines should be removed. */
1265         FILE *_tmp_wm_ready_checker;
1266         _tmp_wm_ready_checker = fopen("/tmp/.wm_ready", "wb");
1267
1268         if (_tmp_wm_ready_checker)
1269           {
1270              TS("[WM] temporary wm_ready path is created.");
1271              PRCTL("[Winsys] temporary wm_ready path is created.");
1272              fclose(_tmp_wm_ready_checker);
1273           }
1274         else
1275           {
1276              TS("[WM] temporary wm_ready path create failed.");
1277              PRCTL("[Winsys] temporary wm_ready path create failed.");
1278           }
1279      }
1280    else
1281      {
1282         TS("[WM] WINDOW MANAGER is READY. BUT, failed to create .wm_ready file.");
1283         PRCTL("[Winsys] WINDOW MANAGER is READY. BUT, failed to create .wm_ready file.");
1284      }
1285 }
1286
1287 static void
1288 _e_main_hooks_clean(void)
1289 {
1290    Eina_Inlist *l;
1291    E_Main_Hook *mh;
1292    unsigned int x;
1293
1294    for (x = 0; x < E_MAIN_HOOK_LAST; x++)
1295      EINA_INLIST_FOREACH_SAFE(_e_main_hooks[x], l, mh)
1296        {
1297           if (!mh->delete_me) continue;
1298           _e_main_hooks[x] = eina_inlist_remove(_e_main_hooks[x],
1299                                                 EINA_INLIST_GET(mh));
1300           free(mh);
1301        }
1302 }
1303
1304 static void
1305 _e_main_hook_call(E_Main_Hook_Point hookpoint, void *data EINA_UNUSED)
1306 {
1307    E_Main_Hook *mh;
1308
1309    _e_main_hooks_walking++;
1310    EINA_INLIST_FOREACH(_e_main_hooks[hookpoint], mh)
1311      {
1312         if (mh->delete_me) continue;
1313         mh->func(mh->data);
1314      }
1315    _e_main_hooks_walking--;
1316    if ((_e_main_hooks_walking == 0) && (_e_main_hooks_delete > 0))
1317      _e_main_hooks_clean();
1318 }
1319
1320 E_API E_Main_Hook *
1321 e_main_hook_add(E_Main_Hook_Point hookpoint, E_Main_Hook_Cb func, const void *data)
1322 {
1323    E_Main_Hook *mh;
1324
1325    EINA_SAFETY_ON_TRUE_RETURN_VAL(hookpoint >= E_MAIN_HOOK_LAST, NULL);
1326    mh = E_NEW(E_Main_Hook, 1);
1327    EINA_SAFETY_ON_NULL_RETURN_VAL(mh, NULL);
1328    mh->hookpoint = hookpoint;
1329    mh->func = func;
1330    mh->data = (void*)data;
1331    _e_main_hooks[hookpoint] = eina_inlist_append(_e_main_hooks[hookpoint],
1332                                                  EINA_INLIST_GET(mh));
1333    return mh;
1334 }
1335
1336 E_API void
1337 e_main_hook_del(E_Main_Hook *mh)
1338 {
1339    mh->delete_me = 1;
1340    if (_e_main_hooks_walking == 0)
1341      {
1342         _e_main_hooks[mh->hookpoint] = eina_inlist_remove(_e_main_hooks[mh->hookpoint],
1343                                                           EINA_INLIST_GET(mh));
1344         free(mh);
1345      }
1346    else
1347      _e_main_hooks_delete++;
1348 }
1349
1350 E_API void
1351 e_main_hook_call(E_Main_Hook_Point hookpoint)
1352 {
1353    if ((hookpoint < 0) || (hookpoint >= E_MAIN_HOOK_LAST)) return;
1354
1355    _e_main_hook_call(hookpoint, NULL);
1356 }