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