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 /*
  22  * i need to make more use of these when i'm baffled as to when something is
  23  * up. other hooks:
  24  *
  25  *      void *(*__malloc_hook)(size_t size, const void *caller);
  26  *
  27  *      void *(*__realloc_hook)(void *ptr, size_t size, const void *caller);
  28  *
  29  *      void *(*__memalign_hook)(size_t alignment, size_t size,
  30  *                               const void *caller);
  31  *
  32  *      void (*__free_hook)(void *ptr, const void *caller);
  33  *
  34  *      void (*__malloc_initialize_hook)(void);
  35  *
  36  *      void (*__after_morecore_hook)(void);
  37  *
  38
  39    static void my_init_hook(void);
  40    static void my_free_hook(void *p, const void *caller);
  41
  42    static void (*old_free_hook)(void *ptr, const void *caller) = NULL;
  43    void (*__free_hook)(void *ptr, const void *caller);
  44
  45    void (*__malloc_initialize_hook) (void) = my_init_hook;
  46    static void
  47    my_init_hook(void)
  48    {
  49    old_free_hook = __free_hook;
  50    __free_hook = my_free_hook;
  51    }
  52
  53    //void *magicfree = NULL;
  54
  55    static void
  56    my_free_hook(void *p, const void *caller)
  57    {
  58    __free_hook = old_free_hook;
  59    //   if ((p) && (p == magicfree))
  60    //     {
  61    //   printf("CAUGHT!!!!! %p ...\n", p);
  62    //   abort();
  63    //     }
  64    free(p);
  65    __free_hook = my_free_hook;
  66    }
  67  */
  68
  69 /* local function prototypes */
  70 static void      _e_main_shutdown(int errcode);
  71 static void      _e_main_shutdown_push(int (*func)(void));
  72 static void      _e_main_parse_arguments(int argc, char **argv);
  73 static Eina_Bool _e_main_cb_signal_exit(void *data EINA_UNUSED, int ev_type EINA_UNUSED, void *ev EINA_UNUSED);
  74 static Eina_Bool _e_main_cb_signal_hup(void *data EINA_UNUSED, int ev_type EINA_UNUSED, void *ev EINA_UNUSED);
  75 static Eina_Bool _e_main_cb_signal_user(void *data EINA_UNUSED, int ev_type EINA_UNUSED, void *ev);
  76 static int       _e_main_dirs_init(void);
  77 static int       _e_main_dirs_shutdown(void);
  78 static int       _e_main_path_init(void);
  79 static int       _e_main_path_shutdown(void);
  80 static void      _e_main_test_formats(void);
  81 static int       _e_main_screens_init(void);
  82 static int       _e_main_screens_shutdown(void);
  83 static void      _e_main_desk_save(void);
  84 static void      _e_main_desk_restore(void);
  85 static void      _e_main_efreet_paths_init(void);
  86 static void      _e_main_modules_load(Eina_Bool safe_mode);
  87 static Eina_Bool _e_main_cb_idle_before(void *data EINA_UNUSED);
  88 static Eina_Bool _e_main_cb_idle_after(void *data EINA_UNUSED);
  89 static Eina_Bool _e_main_cb_startup_fake_end(void *data EINA_UNUSED);
  90
  91 /* local variables */
  92 static Eina_Bool really_know = EINA_FALSE;
  93 static Eina_Bool locked = EINA_FALSE;
  94 static Eina_Bool inloop = EINA_FALSE;
  95 static jmp_buf x_fatal_buff;
  96
  97 static int _e_main_lvl = 0;
  98 static int(*_e_main_shutdown_func[MAX_LEVEL]) (void);
  99
 100 static Ecore_Idle_Enterer *_idle_before = NULL;
 101 static Ecore_Idle_Enterer *_idle_after = NULL;
 102
 103 static Ecore_Event_Handler *mod_init_end = NULL;
 104
 105 /* external variables */
 106 E_API Eina_Bool e_precache_end = EINA_FALSE;
 107 E_API Eina_Bool x_fatal = EINA_FALSE;
 108 E_API Eina_Bool good = EINA_FALSE;
 109 E_API Eina_Bool evil = EINA_FALSE;
 110 E_API Eina_Bool starting = EINA_TRUE;
 111 E_API Eina_Bool stopping = EINA_FALSE;
 112 E_API Eina_Bool restart = EINA_FALSE;
 113 E_API Eina_Bool e_nopause = EINA_FALSE;
 114 EINTERN const char *e_first_frame = NULL;
 115 EINTERN double e_first_frame_start_time = -1;
 116
 117 static Eina_Bool
 118 _xdg_check_str(const char *env, const char *str)
 119 {
 120    const char *p;
 121    size_t len;
 122
 123    len = strlen(str);
 124    for (p = strstr(env, str); p; p++, p = strstr(p, str))
 125      {
 126         if ((!p[len]) || (p[len] == ':')) return EINA_TRUE;
 127      }
 128    return EINA_FALSE;
 129 }
 130
 131 static void
 132 _xdg_data_dirs_augment(void)
 133 {
 134    const char *s;
 135    const char *p = e_prefix_get();
 136    char newpath[4096], buf[4096];
 137
 138    if (!p) return;
 139
 140    s = getenv("XDG_DATA_DIRS");
 141    if (s)
 142      {
 143         Eina_Bool pfxdata, pfx;
 144
 145         pfxdata = !_xdg_check_str(s, e_prefix_data_get());
 146         snprintf(newpath, sizeof(newpath), "%s/share", p);
 147         pfx = !_xdg_check_str(s, newpath);
 148         if (pfxdata || pfx)
 149           {
 150              snprintf(buf, sizeof(buf), "%s%s%s%s%s",
 151                pfxdata ? e_prefix_data_get() : "",
 152                pfxdata ? ":" : "",
 153                pfx ? newpath : "",
 154                pfx ? ":" : "",
 155                s);
 156              e_util_env_set("XDG_DATA_DIRS", buf);
 157           }
 158      }
 159    else
 160      {
 161         snprintf(buf, sizeof(buf), "%s:%s/share:/usr/local/share:/usr/share", e_prefix_data_get(), p);
 162         e_util_env_set("XDG_DATA_DIRS", buf);
 163      }
 164
 165    s = getenv("XDG_CONFIG_DIRS");
 166    snprintf(newpath, sizeof(newpath), "%s/etc/xdg", p);
 167    if (s)
 168      {
 169         if (!_xdg_check_str(s, newpath))
 170           {
 171              snprintf(buf, sizeof(buf), "%s:%s", newpath, s);
 172              e_util_env_set("XDG_CONFIG_DIRS", buf);
 173           }
 174      }
 175    else
 176      {
 177         snprintf(buf, sizeof(buf), "%s:/etc/xdg", newpath);
 178         e_util_env_set("XDG_CONFIG_DIRS", buf);
 179      }
 180
 181    if (!getenv("XDG_RUNTIME_DIR"))
 182      {
 183         const char *dir;
 184
 185         snprintf(buf, sizeof(buf), "/tmp/xdg-XXXXXX");
 186         dir = mkdtemp(buf);
 187         if (!dir) dir = "/tmp";
 188         else
 189           {
 190              e_util_env_set("XDG_RUNTIME_DIR", dir);
 191              snprintf(buf, sizeof(buf), "%s/.e-deleteme", dir);
 192              ecore_file_mkdir(buf);
 193           }
 194      }
 195
 196    /* set menu prefix so we get our e menu */
 197    if (!getenv("XDG_MENU_PREFIX"))
 198      {
 199         e_util_env_set("XDG_MENU_PREFIX", "e-");
 200      }
 201 }
 202
 203 static Eina_Bool
 204 _e_main_shelf_init_job(void *data EINA_UNUSED)
 205 {
 206    e_shelf_config_update();
 207    return ECORE_CALLBACK_CANCEL;
 208 }
 209
 210 /* externally accessible functions */
 211 int
 212 main(int argc, char **argv)
 213 {
 214    Eina_Bool nostartup = EINA_FALSE;
 215    Eina_Bool safe_mode = EINA_FALSE;
 216    Eina_Bool after_restart = EINA_FALSE;
 217    Eina_Bool waslocked = EINA_FALSE;
 218    double t = 0.0, tstart = 0.0;
 219    char *s = NULL, buff[32];
 220    struct sigaction action;
 221
 222 #ifdef __linux__
 223 # ifdef PR_SET_PTRACER
 224 #  ifdef PR_SET_PTRACER_ANY
 225    prctl(PR_SET_PTRACER, PR_SET_PTRACER_ANY);
 226 #  endif
 227 # endif
 228 #endif
 229
 230 #ifdef TS_DO
 231    t0 = t1 = t2 = ecore_time_unix_get();
 232 #endif
 233    TS("Begin Startup");
 234
 235    /* trap deadly bug signals and allow some form of sane recovery */
 236    /* or ability to gdb attach and debug at this point - better than your */
 237    /* wm/desktop vanishing and not knowing what happened */
 238    if (!getenv("NOTIFY_SOCKET"))
 239      {
 240         TS("Signal Trap");
 241         action.sa_sigaction = e_sigseg_act;
 242         action.sa_flags = SA_NODEFER | SA_RESETHAND | SA_SIGINFO;
 243         sigemptyset(&action.sa_mask);
 244         sigaction(SIGSEGV, &action, NULL);
 245
 246         action.sa_sigaction = e_sigill_act;
 247         action.sa_flags = SA_NODEFER | SA_RESETHAND | SA_SIGINFO;
 248         sigemptyset(&action.sa_mask);
 249         sigaction(SIGILL, &action, NULL);
 250
 251         action.sa_sigaction = e_sigfpe_act;
 252         action.sa_flags = SA_NODEFER | SA_RESETHAND | SA_SIGINFO;
 253         sigemptyset(&action.sa_mask);
 254         sigaction(SIGFPE, &action, NULL);
 255
 256 #ifndef HAVE_WAYLAND_ONLY
 257         action.sa_sigaction = e_sigbus_act;
 258         action.sa_flags = SA_NODEFER | SA_RESETHAND | SA_SIGINFO;
 259         sigemptyset(&action.sa_mask);
 260         sigaction(SIGBUS, &action, NULL);
 261 #endif
 262
 263         action.sa_sigaction = e_sigabrt_act;
 264         action.sa_flags = SA_NODEFER | SA_RESETHAND | SA_SIGINFO;
 265         sigemptyset(&action.sa_mask);
 266         sigaction(SIGABRT, &action, NULL);
 267         TS("Signal Trap Done");
 268      }
 269
 270    t = ecore_time_unix_get();
 271    s = getenv("E_START_TIME");
 272    if ((s) && (!getenv("E_RESTART_OK")))
 273      {
 274         tstart = atof(s);
 275         if ((t - tstart) < 5.0) safe_mode = EINA_TRUE;
 276      }
 277    tstart = t;
 278    snprintf(buff, sizeof(buff), "%1.1f", tstart);
 279    e_util_env_set("E_START_TIME", buff);
 280
 281    if (getenv("E_START_MTRACK"))
 282      e_util_env_set("MTRACK", NULL);
 283    TS("Eina Init");
 284    if (!eina_init())
 285      {
 286         e_error_message_show(_("Enlightenment cannot initialize Eina!\n"));
 287         _e_main_shutdown(-1);
 288      }
 289    _e_main_shutdown_push(eina_shutdown);
 290    if (!e_log_init())
 291      {
 292         e_error_message_show(_("Enlightenment could not create a logging domain!\n"));
 293         _e_main_shutdown(-1);
 294      }
 295 #ifdef TS_DO
 296 #undef TS
 297 # define TS(x)                                                    \
 298   {                                                               \
 299      t1 = ecore_time_unix_get();                                  \
 300      printf("ESTART: %1.5f [%1.5f] - %s\n", t1 - t0, t1 - t2, x); \
 301      t2 = t1;                                                     \
 302   }
 303 #endif
 304    TS("Eina Init Done");
 305    _e_main_shutdown_push(e_log_shutdown);
 306
 307    TS("Determine Prefix");
 308    if (!e_prefix_determine(argv[0]))
 309      {
 310         fprintf(stderr,
 311                 "ERROR: Enlightenment cannot determine it's installed\n"
 312                 "       prefix from the system or argv[0].\n"
 313                 "       This is because it is not on Linux AND has been\n"
 314                 "       executed strangely. This is unusual.\n");
 315      }
 316    TS("Determine Prefix Done");
 317
 318    /* for debugging by redirecting stdout of e to a log file to tail */
 319    setvbuf(stdout, NULL, _IONBF, 0);
 320
 321    TS("Environment Variables");
 322    if (getenv("E_RESTART")) after_restart = EINA_TRUE;
 323    if (getenv("DESKTOP_STARTUP_ID"))
 324      e_util_env_set("DESKTOP_STARTUP_ID", NULL);
 325    e_util_env_set("E_RESTART_OK", NULL);
 326    e_util_env_set("PANTS", "ON");
 327    e_util_env_set("DESKTOP", "Enlightenment");
 328    TS("Environment Variables Done");
 329
 330    TS("Parse Arguments");
 331    _e_main_parse_arguments(argc, argv);
 332    TS("Parse Arguments Done");
 333
 334    /*** Initialize Core EFL Libraries We Need ***/
 335
 336    TS("Eet Init");
 337    if (!eet_init())
 338      {
 339         e_error_message_show(_("Enlightenment cannot initialize Eet!\n"));
 340         _e_main_shutdown(-1);
 341      }
 342    TS("Eet Init Done");
 343    _e_main_shutdown_push(eet_shutdown);
 344
 345    TS("Ecore Init");
 346    if (!ecore_init())
 347      {
 348         e_error_message_show(_("Enlightenment cannot initialize Ecore!\n"));
 349         _e_main_shutdown(-1);
 350      }
 351    TS("Ecore Init Done");
 352    _e_main_shutdown_push(ecore_shutdown);
 353
 354    e_first_frame = getenv("E_FIRST_FRAME");
 355    if (e_first_frame && (!e_first_frame[0]))
 356      e_first_frame = NULL;
 357    else
 358      e_first_frame_start_time = ecore_time_get();
 359
 360    TS("EIO Init");
 361    if (!eio_init())
 362      {
 363         e_error_message_show(_("Enlightenment cannot initialize EIO!\n"));
 364         _e_main_shutdown(-1);
 365      }
 366    TS("EIO Init Done");
 367    _e_main_shutdown_push(eio_shutdown);
 368
 369    ecore_app_args_set(argc, (const char **)argv);
 370
 371    TS("Ecore Event Handlers");
 372    if (!ecore_event_handler_add(ECORE_EVENT_SIGNAL_EXIT,
 373                                 _e_main_cb_signal_exit, NULL))
 374      {
 375         e_error_message_show(_("Enlightenment cannot set up an exit signal handler.\n"
 376                                "Perhaps you are out of memory?"));
 377         _e_main_shutdown(-1);
 378      }
 379    if (!ecore_event_handler_add(ECORE_EVENT_SIGNAL_HUP,
 380                                 _e_main_cb_signal_hup, NULL))
 381      {
 382         e_error_message_show(_("Enlightenment cannot set up a HUP signal handler.\n"
 383                                "Perhaps you are out of memory?"));
 384         _e_main_shutdown(-1);
 385      }
 386    if (!ecore_event_handler_add(ECORE_EVENT_SIGNAL_USER,
 387                                 _e_main_cb_signal_user, NULL))
 388      {
 389         e_error_message_show(_("Enlightenment cannot set up a USER signal handler.\n"
 390                                "Perhaps you are out of memory?"));
 391         _e_main_shutdown(-1);
 392      }
 393    TS("Ecore Event Handlers Done");
 394
 395    TS("Ecore_File Init");
 396    if (!ecore_file_init())
 397      {
 398         e_error_message_show(_("Enlightenment cannot initialize Ecore_File!\n"));
 399         _e_main_shutdown(-1);
 400      }
 401    TS("Ecore_File Init Done");
 402    _e_main_shutdown_push(ecore_file_shutdown);
 403
 404    TS("Ecore_Con Init");
 405    if (!ecore_con_init())
 406      {
 407         e_error_message_show(_("Enlightenment cannot initialize Ecore_Con!\n"));
 408         _e_main_shutdown(-1);
 409      }
 410    TS("Ecore_Con Init Done");
 411    _e_main_shutdown_push(ecore_con_shutdown);
 412
 413    TS("Ecore_Ipc Init");
 414    if (!ecore_ipc_init())
 415      {
 416         e_error_message_show(_("Enlightenment cannot initialize Ecore_Ipc!\n"));
 417         _e_main_shutdown(-1);
 418      }
 419    TS("Ecore_Ipc Init Done");
 420    _e_main_shutdown_push(ecore_ipc_shutdown);
 421
 422    _idle_before = ecore_idle_enterer_before_add(_e_main_cb_idle_before, NULL);
 423
 424    _xdg_data_dirs_augment();
 425
 426    TS("Ecore_Evas Init");
 427    if (!ecore_evas_init())
 428      {
 429         e_error_message_show(_("Enlightenment cannot initialize Ecore_Evas!\n"));
 430         _e_main_shutdown(-1);
 431      }
 432    TS("Ecore_Evas Init Done");
 433 //   _e_main_shutdown_push(ecore_evas_shutdown);
 434
 435    TS("Elementary Init");
 436    if (!elm_init(argc, argv))
 437      {
 438         e_error_message_show(_("Enlightenment cannot initialize Elementary!\n"));
 439         _e_main_shutdown(-1);
 440      }
 441    TS("Elementary Init Done");
 442    //_e_main_shutdown_push(elm_shutdown);
 443
 444    TS("Emotion Init");
 445    if (!emotion_init())
 446      {
 447         e_error_message_show(_("Enlightenment cannot initialize Emotion!\n"));
 448         _e_main_shutdown(-1);
 449      }
 450    TS("Emotion Init Done");
 451    _e_main_shutdown_push((void *)emotion_shutdown);
 452
 453    /* e doesn't sync to compositor - it should be one */
 454    ecore_evas_app_comp_sync_set(0);
 455
 456    TS("Ecore_Evas Engine Check");
 457 #ifdef HAVE_WAYLAND_ONLY
 458    if (!ecore_evas_engine_type_supported_get(ECORE_EVAS_ENGINE_WAYLAND_SHM))
 459      {
 460         e_error_message_show(_("Enlightenment found ecore_evas doesn't support the Wayland SHM\n"
 461                                "rendering in Evas. Please check your installation of Evas and\n"
 462                                 "Ecore and check they support the Wayland SHM rendering engine."));
 463         _e_main_shutdown(-1);
 464      }
 465 #else
 466    if (!ecore_evas_engine_type_supported_get(ECORE_EVAS_ENGINE_SOFTWARE_XCB))
 467      {
 468         if (!ecore_evas_engine_type_supported_get(ECORE_EVAS_ENGINE_SOFTWARE_XLIB))
 469           {
 470              e_error_message_show(_("Enlightenment found ecore_evas doesn't support the Software X11\n"
 471                                     "rendering in Evas. Please check your installation of Evas and\n"
 472                                     "Ecore and check they support the Software X11 rendering engine."));
 473              _e_main_shutdown(-1);
 474           }
 475      }
 476 #endif
 477    if (!ecore_evas_engine_type_supported_get(ECORE_EVAS_ENGINE_SOFTWARE_BUFFER))
 478      {
 479         e_error_message_show(_("Enlightenment found ecore_evas doesn't support the Software Buffer\n"
 480                                "rendering in Evas. Please check your installation of Evas and\n"
 481                                "Ecore and check they support the Software Buffer rendering engine."));
 482         _e_main_shutdown(-1);
 483      }
 484    TS("Ecore_Evas Engine Check Done");
 485
 486    TS("Edje Init");
 487    if (!edje_init())
 488      {
 489         e_error_message_show(_("Enlightenment cannot initialize Edje!\n"));
 490         _e_main_shutdown(-1);
 491      }
 492    TS("Edje Init Done");
 493    _e_main_shutdown_push(edje_shutdown);
 494    edje_freeze();
 495
 496    /*** Initialize E Subsystems We Need ***/
 497
 498    TS("E Intl Init");
 499    if (!e_intl_init())
 500      {
 501         e_error_message_show(_("Enlightenment cannot initialize E_Intl!\n"));
 502         _e_main_shutdown(-1);
 503      }
 504    TS("E Intl Init Done");
 505    _e_main_shutdown_push(e_intl_shutdown);
 506
 507 #ifndef HAVE_WAYLAND_ONLY
 508    /* init white box of death alert */
 509    TS("E_Alert Init");
 510    if (!e_alert_init())
 511      {
 512         e_error_message_show(_("Enlightenment cannot initialize its emergency alert system.\n"
 513                                "Have you set your DISPLAY variable?"));
 514         _e_main_shutdown(-1);
 515      }
 516    TS("E_Alert Init Done");
 517    _e_main_shutdown_push(e_alert_shutdown);
 518 #endif
 519
 520 #if 0
 521 //#ifdef HAVE_WAYLAND
 522    /* init uuid store for window/surface properties */
 523    TS("E_UUID_Store Init");
 524    if (!e_uuid_store_init())
 525      {
 526         e_error_message_show(_("Enlightenment cannot initialize its UUID store.\n"));
 527         _e_main_shutdown(-1);
 528      }
 529    TS("E_UUID_Store Init Done");
 530    _e_main_shutdown_push(e_uuid_store_shutdown);
 531 #endif
 532
 533    TS("E_Configure Init");
 534    e_configure_init();
 535    TS("E_Configure Init Done");
 536
 537    TS("E Directories Init");
 538    /* setup directories we will be using for configurations storage etc. */
 539    if (!_e_main_dirs_init())
 540      {
 541         e_error_message_show(_("Enlightenment cannot create directories in your home directory.\n"
 542                                "Perhaps you have no home directory or the disk is full?"));
 543         _e_main_shutdown(-1);
 544      }
 545    TS("E Directories Init Done");
 546    _e_main_shutdown_push(_e_main_dirs_shutdown);
 547
 548    TS("E_Filereg Init");
 549    if (!e_filereg_init())
 550      {
 551         e_error_message_show(_("Enlightenment cannot set up its file registry system.\n"));
 552         _e_main_shutdown(-1);
 553      }
 554    TS("E_Filereg Init Done");
 555    _e_main_shutdown_push(e_filereg_shutdown);
 556
 557    TS("E_Config Init");
 558    if (!e_config_init())
 559      {
 560         e_error_message_show(_("Enlightenment cannot set up its config system.\n"));
 561         _e_main_shutdown(-1);
 562      }
 563    TS("E_Config Init Done");
 564    _e_main_shutdown_push(e_config_shutdown);
 565
 566    TS("E_Env Init");
 567    if (!e_env_init())
 568      {
 569         e_error_message_show(_("Enlightenment cannot set up its environment.\n"));
 570         _e_main_shutdown(-1);
 571      }
 572    TS("E_Env Init Done");
 573    _e_main_shutdown_push(e_env_shutdown);
 574
 575    efreet_desktop_environment_set(e_config->desktop_environment);
 576    e_util_env_set("E_ICON_THEME", e_config->icon_theme);
 577    ecore_exe_run_priority_set(e_config->priority);
 578    locked |= e_config->desklock_start_locked;
 579
 580    s = getenv("E_DESKLOCK_LOCKED");
 581    if ((s) && (!strcmp(s, "locked"))) waslocked = EINA_TRUE;
 582
 583    TS("E Paths Init");
 584    if (!_e_main_path_init())
 585      {
 586         e_error_message_show(_("Enlightenment cannot set up paths for finding files.\n"
 587                                "Perhaps you are out of memory?"));
 588         _e_main_shutdown(-1);
 589      }
 590    TS("E Paths Init Done");
 591    _e_main_shutdown_push(_e_main_path_shutdown);
 592
 593    TS("E_Ipc Init");
 594    if (!e_ipc_init()) _e_main_shutdown(-1);
 595    TS("E_Ipc Init Done");
 596    _e_main_shutdown_push(e_ipc_shutdown);
 597
 598    edje_frametime_set(1.0 / e_config->framerate);
 599
 600    TS("E_Font Init");
 601    if (!e_font_init())
 602      {
 603         e_error_message_show(_("Enlightenment cannot set up its font system.\n"));
 604         _e_main_shutdown(-1);
 605      }
 606    TS("E_Font Init Done");
 607    _e_main_shutdown_push(e_font_shutdown);
 608
 609    TS("E_Font Apply");
 610    e_font_apply();
 611    TS("E_Font Apply Done");
 612
 613    TS("E_Theme Init");
 614    if (!e_theme_init())
 615      {
 616         e_error_message_show(_("Enlightenment cannot set up its theme system.\n"));
 617         _e_main_shutdown(-1);
 618      }
 619    TS("E_Theme Init Done");
 620    _e_main_shutdown_push(e_theme_shutdown);
 621
 622    TS("E_Moveresize Init");
 623    e_moveresize_init();
 624    TS("E_Moveresize Init Done");
 625    _e_main_shutdown_push(e_moveresize_shutdown);
 626
 627    if (e_config->show_splash)
 628      e_init_status_set(_("Setup Message Bus"));
 629    TS("E_Msgbus Init");
 630    if (e_msgbus_init())
 631      _e_main_shutdown_push(e_msgbus_shutdown);
 632    TS("E_Msgbus Init Done");
 633
 634    TS("Efreet Init");
 635    if (!efreet_init())
 636      {
 637         e_error_message_show(_("Enlightenment cannot initialize the FDO desktop system.\n"
 638                                "Perhaps you lack permissions on ~/.cache/efreet or are\n"
 639                                "out of memory or disk space?"));
 640         _e_main_shutdown(-1);
 641      }
 642    TS("Efreet Init Done");
 643    _e_main_shutdown_push(efreet_shutdown);
 644
 645    if (e_config->show_splash)
 646      e_init_status_set(_("Starting International Support"));
 647    TS("E_Intl Post Init");
 648    if (!e_intl_post_init())
 649      {
 650         e_error_message_show(_("Enlightenment cannot set up its intl system.\n"));
 651         _e_main_shutdown(-1);
 652      }
 653    TS("E_Intl Post Init Done");
 654    _e_main_shutdown_push(e_intl_post_shutdown);
 655
 656    e_screensaver_preinit();
 657
 658    if (e_config->show_splash)
 659      e_init_status_set(_("Setup Actions"));
 660    TS("E_Actions Init");
 661    if (!e_actions_init())
 662      {
 663         e_error_message_show(_("Enlightenment cannot set up its actions system.\n"));
 664         _e_main_shutdown(-1);
 665      }
 666    TS("E_Actions Init Done");
 667    _e_main_shutdown_push(e_actions_shutdown);
 668
 669    /* these just add event handlers and can't fail
 670     * timestamping them is dumb.
 671     */
 672    e_zone_init();
 673    e_desk_init();
 674    e_exehist_init();
 675
 676    if (e_config->show_splash)
 677      e_init_status_set(_("Setup Powersave Modes"));
 678    TS("E_Powersave Init");
 679    if (!e_powersave_init())
 680      {
 681         e_error_message_show(_("Enlightenment cannot set up its powersave modes.\n"));
 682         _e_main_shutdown(-1);
 683      }
 684    TS("E_Powersave Init Done");
 685    _e_main_shutdown_push(e_powersave_shutdown);
 686
 687    if (e_config->show_splash)
 688      e_init_status_set(_("Setup Screensaver"));
 689    TS("E_Screensaver Init");
 690    if (!e_screensaver_init())
 691      {
 692         e_error_message_show(_("Enlightenment cannot configure the X screensaver.\n"));
 693         _e_main_shutdown(-1);
 694      }
 695    TS("E_Screensaver Init Done");
 696    _e_main_shutdown_push(e_screensaver_shutdown);
 697
 698    if (e_config->show_splash)
 699      e_init_status_set(_("Setup Screens"));
 700    TS("Screens Init");
 701    if (!_e_main_screens_init())
 702      {
 703         e_error_message_show(_("Enlightenment set up window management for all the screens on your system\n"
 704                                "failed. Perhaps another window manager is running?\n"));
 705         _e_main_shutdown(-1);
 706      }
 707    TS("Screens Init Done");
 708    _e_main_shutdown_push(_e_main_screens_shutdown);
 709
 710    TS("E_Pointer Init");
 711    if (!e_pointer_init())
 712      {
 713         e_error_message_show(_("Enlightenment cannot set up its pointer system.\n"));
 714         _e_main_shutdown(-1);
 715      }
 716    TS("E_Pointer Init Done");
 717    _e_main_shutdown_push(e_pointer_shutdown);
 718    e_menu_init();
 719
 720    TS("E_Scale Init");
 721    if (!e_scale_init())
 722      {
 723         e_error_message_show(_("Enlightenment cannot set up its scale system.\n"));
 724         _e_main_shutdown(-1);
 725      }
 726    TS("E_Scale Init Done");
 727    _e_main_shutdown_push(e_scale_shutdown);
 728
 729    if (e_config->show_splash)
 730      {
 731         TS("E_Splash Init");
 732         if (!e_init_init())
 733           {
 734              e_error_message_show(_("Enlightenment cannot set up its init screen.\n"));
 735              _e_main_shutdown(-1);
 736           }
 737         TS("E_Splash Init Done");
 738         _e_main_shutdown_push(e_init_shutdown);
 739      }
 740    if (!((!e_config->show_splash) || (after_restart)))
 741      e_init_show();
 742
 743    if (!really_know)
 744      {
 745         TS("Test File Format Support");
 746         _e_main_test_formats();
 747         TS("Test File Format Support Done");
 748      }
 749    else
 750      {
 751         efreet_icon_extension_add(".svg");
 752         efreet_icon_extension_add(".jpg");
 753         efreet_icon_extension_add(".png");
 754         efreet_icon_extension_add(".edj");
 755      }
 756
 757    if (e_config->show_splash)
 758      e_init_status_set(_("Setup ACPI"));
 759    TS("E_Acpi Init");
 760    e_acpi_init();
 761    TS("E_Acpi Init Done");
 762    _e_main_shutdown_push(e_acpi_shutdown);
 763
 764    if (e_config->show_splash)
 765      e_init_status_set(_("Setup Backlight"));
 766    TS("E_Backlight Init");
 767    if (!e_backlight_init())
 768      {
 769         e_error_message_show(_("Enlightenment cannot configure the backlight.\n"));
 770         _e_main_shutdown(-1);
 771      }
 772    TS("E_Backlight Init Done");
 773
 774    if (e_config->show_splash)
 775      e_init_status_set(_("Setup DPMS"));
 776    TS("E_Dpms Init");
 777    if (!e_dpms_init())
 778      {
 779         e_error_message_show(_("Enlightenment cannot configure the DPMS settings.\n"));
 780         _e_main_shutdown(-1);
 781      }
 782    TS("E_Dpms Init Done");
 783    _e_main_shutdown_push(e_dpms_shutdown);
 784
 785    if (e_config->show_splash)
 786      e_init_status_set(_("Setup Desklock"));
 787    TS("E_Desklock Init");
 788    if (!e_desklock_init())
 789      {
 790         e_error_message_show(_("Enlightenment cannot set up its desk locking system.\n"));
 791         _e_main_shutdown(-1);
 792      }
 793    TS("E_Desklock Init Done");
 794    _e_main_shutdown_push(e_desklock_shutdown);
 795
 796    if (waslocked || (locked && ((!after_restart) || (!getenv("E_DESKLOCK_UNLOCKED")))))
 797      e_desklock_show(EINA_TRUE);
 798
 799    if (e_config->show_splash)
 800      e_init_status_set(_("Setup Paths"));
 801    TS("Efreet Paths");
 802    _e_main_efreet_paths_init();
 803    TS("Efreet Paths Done");
 804
 805    if (e_config->show_splash)
 806      e_init_status_set(_("Setup System Controls"));
 807    TS("E_Sys Init");
 808    if (!e_sys_init())
 809      {
 810         e_error_message_show(_("Enlightenment cannot initialize the System Command system.\n"));
 811         _e_main_shutdown(-1);
 812      }
 813    TS("E_Sys Init Done");
 814    _e_main_shutdown_push(e_sys_shutdown);
 815
 816    if (e_config->show_splash)
 817      e_init_status_set(_("Setup Execution System"));
 818    TS("E_Exec Init");
 819    if (!e_exec_init())
 820      {
 821         e_error_message_show(_("Enlightenment cannot set up its exec system.\n"));
 822         _e_main_shutdown(-1);
 823      }
 824    TS("E_Exec Init Done");
 825
 826    TS("E_Comp Freeze");
 827    e_comp_all_freeze();
 828    TS("E_Comp Freeze Done");
 829
 830    if (e_config->show_splash)
 831      e_init_status_set(_("Setup Filemanager"));
 832    TS("E_Fm2 Init");
 833    if (!e_fm2_init())
 834      {
 835         e_error_message_show(_("Enlightenment cannot initialize the File manager.\n"));
 836         _e_main_shutdown(-1);
 837      }
 838    TS("E_Fm2 Init Done");
 839    _e_main_shutdown_push(e_fm2_shutdown);
 840
 841    if (e_config->show_splash)
 842      e_init_status_set(_("Setup Message System"));
 843    TS("E_Msg Init");
 844    if (!e_msg_init())
 845      {
 846         e_error_message_show(_("Enlightenment cannot set up its msg system.\n"));
 847         _e_main_shutdown(-1);
 848      }
 849    TS("E_Msg Init Done");
 850    _e_main_shutdown_push(e_msg_shutdown);
 851
 852    if (e_config->show_splash)
 853      e_init_status_set(_("Setup Grab Input Handling"));
 854    TS("E_Grabinput Init");
 855    if (!e_grabinput_init())
 856      {
 857         e_error_message_show(_("Enlightenment cannot set up its grab input handling system.\n"));
 858         _e_main_shutdown(-1);
 859      }
 860    TS("E_Grabinput Init Done");
 861    _e_main_shutdown_push(e_grabinput_shutdown);
 862
 863    if (e_config->show_splash)
 864      e_init_status_set(_("Setup Modules"));
 865    TS("E_Module Init");
 866    if (!e_module_init())
 867      {
 868         e_error_message_show(_("Enlightenment cannot set up its module system.\n"));
 869         _e_main_shutdown(-1);
 870      }
 871    TS("E_Module Init Done");
 872    _e_main_shutdown_push(e_module_shutdown);
 873
 874    if (e_config->show_splash)
 875      e_init_status_set(_("Setup Remembers"));
 876    TS("E_Remember Init");
 877    if (!e_remember_init(after_restart ? E_STARTUP_RESTART : E_STARTUP_START))
 878      {
 879         e_error_message_show(_("Enlightenment cannot setup remember settings.\n"));
 880         _e_main_shutdown(-1);
 881      }
 882    TS("E_Remember Init Done");
 883    _e_main_shutdown_push(e_remember_shutdown);
 884
 885    if (e_config->show_splash)
 886      e_init_status_set(_("Setup Gadcon"));
 887    TS("E_Gadcon Init");
 888    if (!e_gadcon_init())
 889      {
 890         e_error_message_show(_("Enlightenment cannot set up its gadget control system.\n"));
 891         _e_main_shutdown(-1);
 892      }
 893    TS("E_Gadcon Init Done");
 894    _e_main_shutdown_push(e_gadcon_shutdown);
 895
 896    if (e_config->show_splash)
 897      e_init_status_set(_("Setup Toolbars"));
 898    TS("E_Toolbar Init");
 899    if (!e_toolbar_init())
 900      {
 901         e_error_message_show(_("Enlightenment cannot set up its toolbars.\n"));
 902         _e_main_shutdown(-1);
 903      }
 904    TS("E_Toolbar Init Done");
 905    _e_main_shutdown_push(e_toolbar_shutdown);
 906
 907    if (e_config->show_splash)
 908      e_init_status_set(_("Setup Wallpaper"));
 909    TS("E_Bg Init");
 910    if (!e_bg_init())
 911      {
 912         e_error_message_show(_("Enlightenment cannot set up its desktop background system.\n"));
 913         _e_main_shutdown(-1);
 914      }
 915    TS("E_Bg Init Done");
 916    _e_main_shutdown_push(e_bg_shutdown);
 917
 918    if (e_config->show_splash)
 919      e_init_status_set(_("Setup Mouse"));
 920    TS("E_Mouse Init");
 921    if (!e_mouse_update())
 922      {
 923         e_error_message_show(_("Enlightenment cannot configure the mouse settings.\n"));
 924         _e_main_shutdown(-1);
 925      }
 926    TS("E_Mouse Init Done");
 927
 928    if (e_config->show_splash)
 929      e_init_status_set(_("Setup Bindings"));
 930    TS("E_Bindings Init");
 931    if (!e_bindings_init())
 932      {
 933         e_error_message_show(_("Enlightenment cannot set up its bindings system.\n"));
 934         _e_main_shutdown(-1);
 935      }
 936    TS("E_Bindings Init Done");
 937    _e_main_shutdown_push(e_bindings_shutdown);
 938
 939    if (e_config->show_splash)
 940      e_init_status_set(_("Setup Thumbnailer"));
 941    TS("E_Thumb Init");
 942    if (!e_thumb_init())
 943      {
 944         e_error_message_show(_("Enlightenment cannot initialize the Thumbnailing system.\n"));
 945         _e_main_shutdown(-1);
 946      }
 947    TS("E_Thumb Init Done");
 948    _e_main_shutdown_push(e_thumb_shutdown);
 949
 950    TS("E_Icon Init");
 951    if (!e_icon_init())
 952      {
 953         e_error_message_show(_("Enlightenment cannot initialize the Icon Cache system.\n"));
 954         _e_main_shutdown(-1);
 955      }
 956    TS("E_Icon Init Done");
 957    _e_main_shutdown_push(e_icon_shutdown);
 958
 959    TS("E_Update Init");
 960    if (!e_update_init())
 961      {
 962         e_error_message_show(_("Enlightenment cannot initialize the Update system.\n"));
 963         _e_main_shutdown(-1);
 964      }
 965    TS("E_Update Init Done");
 966    _e_main_shutdown_push(e_update_shutdown);
 967
 968    if (e_config->show_splash)
 969      e_init_status_set(_("Setup Desktop Environment"));
 970    TS("E_Deskenv Init");
 971    if (!e_deskenv_init())
 972      {
 973         e_error_message_show(_("Enlightenment cannot initialize its desktop environment.\n"));
 974         _e_main_shutdown(-1);
 975      }
 976    TS("E_Deskenv Init Done");
 977    _e_main_shutdown_push(e_deskenv_shutdown);
 978
 979    if (e_config->show_splash)
 980      e_init_status_set(_("Setup File Ordering"));
 981    TS("E_Order Init");
 982    if (!e_order_init())
 983      {
 984         e_error_message_show(_("Enlightenment cannot set up its order file system.\n"));
 985         _e_main_shutdown(-1);
 986      }
 987    TS("E_Order Init Done");
 988    _e_main_shutdown_push(e_order_shutdown);
 989
 990    TS("E_Comp_Canvas Keys Grab");
 991    e_comp_canvas_keys_grab();
 992    TS("E_Comp_Canvas Keys Grab Done");
 993
 994    if (e_config->show_splash)
 995      e_init_status_set(_("Load Modules"));
 996    TS("Load Modules");
 997    _e_main_modules_load(safe_mode);
 998    TS("Load Modules Done");
 999
1000    TS("Run Startup Apps");
1001    if (!nostartup)
1002      {
1003         if (after_restart)
1004           e_startup(E_STARTUP_RESTART);
1005         else
1006           e_startup(E_STARTUP_START);
1007      }
1008    TS("Run Startup Apps Done");
1009
1010    if (e_config->show_splash && (!after_restart))
1011      ecore_timer_add(2.0, _e_main_cb_startup_fake_end, NULL);
1012
1013    TS("E_Comp Thaw");
1014    e_comp_all_thaw();
1015    TS("E_Comp Thaw Done");
1016
1017    TS("E_Test Init");
1018    e_test();
1019    TS("E_Test Done");
1020
1021    if (e_config->show_splash)
1022      e_init_status_set(_("Setup Shelves"));
1023    TS("E_Shelf Init");
1024    if (!e_shelf_init())
1025      {
1026         e_error_message_show(_("Enlightenment cannot set up its module system.\n"));
1027         _e_main_shutdown(-1);
1028      }
1029    TS("E_Shelf Init Done");
1030
1031    ecore_idle_enterer_before_add(_e_main_shelf_init_job, NULL);
1032
1033    _idle_after = ecore_idle_enterer_add(_e_main_cb_idle_after, NULL);
1034
1035    if (e_config->show_splash)
1036      e_init_status_set(_("Almost Done"));
1037
1038    starting = EINA_FALSE;
1039    inloop = EINA_TRUE;
1040
1041    e_util_env_set("E_RESTART", "1");
1042
1043    TS("MAIN LOOP AT LAST");
1044    if (!setjmp(x_fatal_buff))
1045      ecore_main_loop_begin();
1046    else
1047      CRI("FATAL: X Died. Connection gone. Abbreviated Shutdown\n");
1048
1049    inloop = EINA_FALSE;
1050    stopping = EINA_TRUE;
1051
1052    //if (!x_fatal) e_canvas_idle_flush();
1053
1054    e_config_save_flush();
1055    _e_main_desk_save();
1056    e_remember_internal_save();
1057    e_comp_internal_save();
1058
1059    _e_main_shutdown(0);
1060
1061    if (restart)
1062      {
1063         e_util_env_set("E_RESTART_OK", "1");
1064         if (getenv("E_START_MTRACK"))
1065           e_util_env_set("MTRACK", "track");
1066         ecore_app_restart();
1067      }
1068
1069    e_prefix_shutdown();
1070
1071    return 0;
1072 }
1073
1074 E_API double
1075 e_main_ts(const char *str)
1076 {
1077    double ret;
1078    t1 = ecore_time_unix_get();
1079    printf("ESTART: %1.5f [%1.5f] - %s\n", t1 - t0, t1 - t2, str);
1080    ret = t1 - t2;
1081    t2 = t1;
1082    return ret;
1083 }
1084
1085 /* local functions */
1086 static void
1087 _e_main_shutdown(int errcode)
1088 {
1089    int i = 0;
1090    char buf[PATH_MAX];
1091    const char *dir;
1092
1093    printf("E: Begin Shutdown Procedure!\n");
1094
1095    if (_idle_before) ecore_idle_enterer_del(_idle_before);
1096    _idle_before = NULL;
1097    if (_idle_after) ecore_idle_enterer_del(_idle_after);
1098    _idle_after = NULL;
1099
1100    dir = getenv("XDG_RUNTIME_DIR");
1101    if (dir)
1102      {
1103         snprintf(buf, sizeof(buf), "%s/.e-deleteme", dir);
1104         if (ecore_file_exists(buf)) ecore_file_recursive_rm(dir);
1105      }
1106    for (i = (_e_main_lvl - 1); i >= 0; i--)
1107      (*_e_main_shutdown_func[i])();
1108    if (errcode < 0) exit(errcode);
1109 }
1110
1111 static void
1112 _e_main_shutdown_push(int (*func)(void))
1113 {
1114    _e_main_lvl++;
1115    if (_e_main_lvl > MAX_LEVEL)
1116      {
1117         _e_main_lvl--;
1118         e_error_message_show("WARNING: too many init levels. MAX = %i\n",
1119                              MAX_LEVEL);
1120         return;
1121      }
1122    _e_main_shutdown_func[_e_main_lvl - 1] = func;
1123 }
1124
1125 static void
1126 _e_main_parse_arguments(int argc, char **argv)
1127 {
1128    char *s = NULL;
1129    int i = 0;
1130
1131    /* handle some command-line parameters */
1132    for (i = 1; i < argc; i++)
1133      {
1134         if ((!strcmp(argv[i], "-display")) && (i < (argc - 1)))
1135           {
1136              i++;
1137              e_util_env_set("DISPLAY", argv[i]);
1138           }
1139         else if ((!strcmp(argv[i], "-fake-xinerama-screen")) && (i < (argc - 1)))
1140           {
1141              int x, y, w, h;
1142
1143              i++;
1144              if (sscanf(argv[i], "%ix%i+%i+%i", &w, &h, &x, &y) == 4)
1145                e_xinerama_fake_screen_add(x, y, w, h);
1146           }
1147         else if (!strcmp(argv[i], "-good"))
1148           {
1149              good = EINA_TRUE;
1150              evil = EINA_FALSE;
1151              printf("LA LA LA\n");
1152           }
1153         else if (!strcmp(argv[i], "-evil"))
1154           {
1155              good = EINA_FALSE;
1156              evil = EINA_TRUE;
1157              printf("MUHAHAHAHHAHAHAHAHA\n");
1158           }
1159         else if (!strcmp(argv[i], "-psychotic"))
1160           {
1161              good = EINA_TRUE;
1162              evil = EINA_TRUE;
1163              printf("MUHAHALALALALALALALA\n");
1164           }
1165         else if ((!strcmp(argv[i], "-profile")) && (i < (argc - 1)))
1166           {
1167              i++;
1168              if (!getenv("E_CONF_PROFILE"))
1169                e_util_env_set("E_CONF_PROFILE", argv[i]);
1170           }
1171         else if (!strcmp(argv[i], "-i-really-know-what-i-am-doing-and-accept-full-responsibility-for-it"))
1172           really_know = EINA_TRUE;
1173         else if (!strcmp(argv[i], "-locked"))
1174           locked = EINA_TRUE;
1175         else if (!strcmp(argv[i], "-nopause"))
1176           e_nopause = EINA_TRUE;
1177         else if ((!strcmp(argv[i], "-version")) ||
1178                  (!strcmp(argv[i], "--version")))
1179           {
1180              printf(_("Version: %s\n"), PACKAGE_VERSION);
1181              _e_main_shutdown(-1);
1182           }
1183         else if ((!strcmp(argv[i], "-h")) ||
1184                  (!strcmp(argv[i], "-help")) ||
1185                  (!strcmp(argv[i], "--help")))
1186           {
1187              printf
1188                (_(
1189                  "Options:\n"
1190                  "\t-display DISPLAY\n"
1191                  "\t\tConnect to display named DISPLAY.\n"
1192                  "\t\tEG: -display :1.0\n"
1193                  "\t-fake-xinerama-screen WxH+X+Y\n"
1194                  "\t\tAdd a FAKE xinerama screen (instead of the real ones)\n"
1195                  "\t\tgiven the geometry. Add as many as you like. They all\n"
1196                  "\t\treplace the real xinerama screens, if any. This can\n"
1197                  "\t\tbe used to simulate xinerama.\n"
1198                  "\t\tEG: -fake-xinerama-screen 800x600+0+0 -fake-xinerama-screen 800x600+800+0\n"
1199                  "\t-profile CONF_PROFILE\n"
1200                  "\t\tUse the configuration profile CONF_PROFILE instead of the user selected default or just \"default\".\n"
1201                  "\t-good\n"
1202                  "\t\tBe good.\n"
1203                  "\t-evil\n"
1204                  "\t\tBe evil.\n"
1205                  "\t-psychotic\n"
1206                  "\t\tBe psychotic.\n"
1207                  "\t-locked\n"
1208                  "\t\tStart with desklock on, so password will be asked.\n"
1209                  "\t-i-really-know-what-i-am-doing-and-accept-full-responsibility-for-it\n"
1210                  "\t\tIf you need this help, you don't need this option.\n"
1211                  "\t-version\n"
1212                  )
1213                );
1214              _e_main_shutdown(-1);
1215           }
1216      }
1217
1218    /* fix up DISPLAY to be :N.0 if no .screen is in it */
1219    s = getenv("DISPLAY");
1220    if (s)
1221      {
1222         char *p, buff[4096];
1223
1224         if (!(p = strrchr(s, ':')))
1225           {
1226              snprintf(buff, sizeof(buff), "%s:0.0", s);
1227              e_util_env_set("DISPLAY", buff);
1228           }
1229         else
1230           {
1231              if (!strrchr(p, '.'))
1232                {
1233                   snprintf(buff, sizeof(buff), "%s.0", s);
1234                   e_util_env_set("DISPLAY", buff);
1235                }
1236           }
1237      }
1238
1239    /* we want to have been launched by enlightenment_start. there is a very */
1240    /* good reason we want to have been launched this way, thus check */
1241    if (!getenv("E_START"))
1242      {
1243         e_error_message_show(_("You are executing enlightenment directly. This is\n"
1244                                "bad. Please do not execute the \"enlightenment\"\n"
1245                                "binary. Use the \"enlightenment_start\" launcher. It\n"
1246                                "will handle setting up environment variables, paths,\n"
1247                                "and launching any other required services etc.\n"
1248                                "before enlightenment itself begins running.\n"));
1249         _e_main_shutdown(-1);
1250      }
1251 }
1252
1253 EINTERN void
1254 _e_main_cb_x_fatal(void *data EINA_UNUSED)
1255 {
1256    e_error_message_show("Lost X Connection.\n");
1257    ecore_main_loop_quit();
1258    if (!x_fatal)
1259      {
1260         x_fatal = EINA_TRUE;
1261         if (inloop) longjmp(x_fatal_buff, -99);
1262      }
1263 }
1264
1265 static Eina_Bool
1266 _e_main_cb_signal_exit(void *data EINA_UNUSED, int ev_type EINA_UNUSED, void *ev EINA_UNUSED)
1267 {
1268    /* called on ctrl-c, kill (pid) (also SIGINT, SIGTERM and SIGQIT) */
1269    e_sys_action_do(E_SYS_EXIT, NULL);
1270    return ECORE_CALLBACK_RENEW;
1271 }
1272
1273 static Eina_Bool
1274 _e_main_cb_signal_hup(void *data EINA_UNUSED, int ev_type EINA_UNUSED, void *ev EINA_UNUSED)
1275 {
1276    e_sys_action_do(E_SYS_RESTART, NULL);
1277    return ECORE_CALLBACK_RENEW;
1278 }
1279
1280 static Eina_Bool
1281 _e_main_cb_signal_user(void *data EINA_UNUSED, int ev_type EINA_UNUSED, void *ev)
1282 {
1283    Ecore_Event_Signal_User *e = ev;
1284
1285    if (e->number == 1)
1286      {
1287 //        E_Action *a = e_action_find("configuration");
1288 //        if ((a) && (a->func.go)) a->func.go(NULL, NULL);
1289      }
1290    else if (e->number == 2)
1291      {
1292         // comp module has its own handler for this for enabling/disabling fps debug
1293      }
1294    return ECORE_CALLBACK_RENEW;
1295
1296 }
1297
1298 static int
1299 _e_main_dirs_init(void)
1300 {
1301    const char *base;
1302    const char *dirs[] =
1303    {
1304       "images",
1305       "fonts",
1306       "themes",
1307       "icons",
1308       "backgrounds",
1309       "applications",
1310       "applications/menu",
1311       "applications/menu/favorite",
1312       "applications/menu/all",
1313       "applications/bar",
1314       "applications/bar/default",
1315       "applications/startup",
1316       "applications/restart",
1317       "applications/trash",
1318       "applications/desk-lock",
1319       "applications/desk-unlock",
1320       "modules",
1321       "config",
1322       "locale",
1323       "input_methods",
1324       NULL
1325    };
1326
1327    base = e_user_dir_get();
1328    if (ecore_file_mksubdirs(base, dirs) != sizeof(dirs) / sizeof(dirs[0]) - 1)
1329      {
1330         e_error_message_show("Could not create one of the required "
1331                              "subdirectories of '%s'\n", base);
1332         return 0;
1333      }
1334
1335    return 1;
1336 }
1337
1338 static int
1339 _e_main_dirs_shutdown(void)
1340 {
1341    return 1;
1342 }
1343
1344 static int
1345 _e_main_path_init(void)
1346 {
1347    char buf[PATH_MAX];
1348
1349    /* setup data paths */
1350    path_data = e_path_new();
1351    if (!path_data)
1352      {
1353         e_error_message_show("Cannot allocate path for path_data\n");
1354         return 0;
1355      }
1356    e_prefix_data_concat_static(buf, "data");
1357    e_path_default_path_append(path_data, buf);
1358    e_path_user_path_set(path_data, &(e_config->path_append_data));
1359
1360    /* setup image paths */
1361    path_images = e_path_new();
1362    if (!path_images)
1363      {
1364         e_error_message_show("Cannot allocate path for path_images\n");
1365         return 0;
1366      }
1367    e_user_dir_concat_static(buf, "/images");
1368    e_path_default_path_append(path_images, buf);
1369    e_prefix_data_concat_static(buf, "data/images");
1370    e_path_default_path_append(path_images, buf);
1371    e_path_user_path_set(path_images, &(e_config->path_append_images));
1372
1373    /* setup font paths */
1374    path_fonts = e_path_new();
1375    if (!path_fonts)
1376      {
1377         e_error_message_show("Cannot allocate path for path_fonts\n");
1378         return 0;
1379      }
1380    e_user_dir_concat_static(buf, "/fonts");
1381    e_path_default_path_append(path_fonts, buf);
1382    e_prefix_data_concat_static(buf, "data/fonts");
1383    e_path_default_path_append(path_fonts, buf);
1384    e_path_user_path_set(path_fonts, &(e_config->path_append_fonts));
1385
1386    /* setup icon paths */
1387    path_icons = e_path_new();
1388    if (!path_icons)
1389      {
1390         e_error_message_show("Cannot allocate path for path_icons\n");
1391         return 0;
1392      }
1393    e_user_dir_concat_static(buf, "/icons");
1394    e_path_default_path_append(path_icons, buf);
1395    e_prefix_data_concat_static(buf, "data/icons");
1396    e_path_default_path_append(path_icons, buf);
1397    e_path_user_path_set(path_icons, &(e_config->path_append_icons));
1398
1399    /* setup module paths */
1400    path_modules = e_path_new();
1401    if (!path_modules)
1402      {
1403         e_error_message_show("Cannot allocate path for path_modules\n");
1404         return 0;
1405      }
1406    e_user_dir_concat_static(buf, "/modules");
1407    e_path_default_path_append(path_modules, buf);
1408    snprintf(buf, sizeof(buf), "%s/enlightenment/modules", e_prefix_lib_get());
1409    e_path_default_path_append(path_modules, buf);
1410    /* FIXME: eventually this has to go - moduels should have installers that
1411     * add appropriate install paths (if not installed to user homedir) to
1412     * e's module search dirs
1413     */
1414    snprintf(buf, sizeof(buf), "%s/enlightenment/modules_extra", e_prefix_lib_get());
1415    e_path_default_path_append(path_modules, buf);
1416    e_path_user_path_set(path_modules, &(e_config->path_append_modules));
1417
1418    /* setup background paths */
1419    path_backgrounds = e_path_new();
1420    if (!path_backgrounds)
1421      {
1422         e_error_message_show("Cannot allocate path for path_backgrounds\n");
1423         return 0;
1424      }
1425    e_user_dir_concat_static(buf, "/backgrounds");
1426    e_path_default_path_append(path_backgrounds, buf);
1427    e_prefix_data_concat_static(buf, "data/backgrounds");
1428    e_path_default_path_append(path_backgrounds, buf);
1429    e_path_user_path_set(path_backgrounds, &(e_config->path_append_backgrounds));
1430
1431    path_messages = e_path_new();
1432    if (!path_messages)
1433      {
1434         e_error_message_show("Cannot allocate path for path_messages\n");
1435         return 0;
1436      }
1437    e_user_dir_concat_static(buf, "/locale");
1438    e_path_default_path_append(path_messages, buf);
1439    e_path_default_path_append(path_messages, e_prefix_locale_get());
1440    e_path_user_path_set(path_messages, &(e_config->path_append_messages));
1441
1442    return 1;
1443 }
1444
1445 static int
1446 _e_main_path_shutdown(void)
1447 {
1448    if (path_data)
1449      {
1450         e_object_del(E_OBJECT(path_data));
1451         path_data = NULL;
1452      }
1453    if (path_images)
1454      {
1455         e_object_del(E_OBJECT(path_images));
1456         path_images = NULL;
1457      }
1458    if (path_fonts)
1459      {
1460         e_object_del(E_OBJECT(path_fonts));
1461         path_fonts = NULL;
1462      }
1463    if (path_icons)
1464      {
1465         e_object_del(E_OBJECT(path_icons));
1466         path_icons = NULL;
1467      }
1468    if (path_modules)
1469      {
1470         e_object_del(E_OBJECT(path_modules));
1471         path_modules = NULL;
1472      }
1473    if (path_backgrounds)
1474      {
1475         e_object_del(E_OBJECT(path_backgrounds));
1476         path_backgrounds = NULL;
1477      }
1478    if (path_messages)
1479      {
1480         e_object_del(E_OBJECT(path_messages));
1481         path_messages = NULL;
1482      }
1483    return 1;
1484 }
1485
1486 static void
1487 _e_main_test_formats(void)
1488 {
1489    Evas *evas;
1490    Ecore_Evas *ee;
1491    Evas_Object *im, *txt;
1492    Evas_Coord tw, th;
1493    char buff[PATH_MAX];
1494
1495    if (e_config->show_splash)
1496      e_init_status_set(_("Testing Format Support"));
1497
1498    if (!(ee = ecore_evas_buffer_new(1, 1)))
1499      {
1500         e_error_message_show(_("Enlightenment found Evas can't create a buffer canvas. Please check\n"
1501                                "Evas has Software Buffer engine support.\n"));
1502         _e_main_shutdown(-1);
1503      }
1504    evas = ecore_evas_get(ee);
1505    im = evas_object_image_add(evas);
1506
1507    e_prefix_data_concat_static(buff, "data/images/test.svg");
1508    evas_object_image_file_set(im, buff, NULL);
1509    if (evas_object_image_load_error_get(im) != EVAS_LOAD_ERROR_NONE)
1510      {
1511         e_error_message_show(_("Enlightenment found Evas can't load SVG files. "
1512                                "Check Evas has SVG loader support.\n"));
1513      }
1514    else
1515      efreet_icon_extension_add(".svg");
1516
1517    e_prefix_data_concat_static(buff, "data/images/test.jpg");
1518    evas_object_image_file_set(im, buff, NULL);
1519    if (evas_object_image_load_error_get(im) != EVAS_LOAD_ERROR_NONE)
1520      {
1521         e_error_message_show(_("Enlightenment found Evas can't load JPEG files. "
1522                                "Check Evas has JPEG loader support.\n"));
1523         _e_main_shutdown(-1);
1524      }
1525    efreet_icon_extension_add(".jpg");
1526
1527    e_prefix_data_concat_static(buff, "data/images/test.png");
1528    evas_object_image_file_set(im, buff, NULL);
1529    if (evas_object_image_load_error_get(im) != EVAS_LOAD_ERROR_NONE)
1530      {
1531         e_error_message_show(_("Enlightenment found Evas can't load PNG files. "
1532                                "Check Evas has PNG loader support.\n"));
1533         _e_main_shutdown(-1);
1534      }
1535    efreet_icon_extension_add(".png");
1536
1537    e_prefix_data_concat_static(buff, "data/images/test.edj");
1538    evas_object_image_file_set(im, buff, "images/0");
1539    if (evas_object_image_load_error_get(im) != EVAS_LOAD_ERROR_NONE)
1540      {
1541         e_error_message_show(_("Enlightenment found Evas can't load EET files. "
1542                                "Check Evas has EET loader support.\n"));
1543         _e_main_shutdown(-1);
1544      }
1545    efreet_icon_extension_add(".edj");
1546
1547    evas_object_del(im);
1548
1549    txt = evas_object_text_add(evas);
1550    evas_object_text_font_set(txt, "Sans", 10);
1551    evas_object_text_text_set(txt, "Hello");
1552    evas_object_geometry_get(txt, NULL, NULL, &tw, &th);
1553    if ((tw <= 0) && (th <= 0))
1554      {
1555         e_error_message_show(_("Enlightenment found Evas can't load the 'Sans' font. Check Evas has fontconfig\n"
1556                                "support and system fontconfig defines a 'Sans' font.\n"));
1557         _e_main_shutdown(-1);
1558      }
1559    evas_object_del(txt);
1560    ecore_evas_free(ee);
1561 }
1562
1563 static int
1564 _e_main_screens_init(void)
1565 {
1566    TS("\tscreens: client");
1567    if (!e_client_init()) return 0;
1568    TS("\tscreens: win");
1569    if (!e_win_init()) return 0;
1570 #ifndef HAVE_WAYLAND_ONLY
1571    TS("E_Xkb Init");
1572    if (!e_xkb_init())
1573      {
1574         e_error_message_show(_("Enlightenment cannot setup XKB Keyboard layouts.\n"));
1575         _e_main_shutdown(-1);
1576      }
1577    TS("E_Xkb Init Done");
1578 #endif
1579
1580    TS("Compositor Init");
1581    if (!e_comp_init())
1582      {
1583         e_error_message_show(_("Enlightenment cannot create a compositor.\n"));
1584         _e_main_shutdown(-1);
1585      }
1586
1587    _e_main_desk_restore();
1588
1589 #ifndef HAVE_WAYLAND_ONLY
1590    if (e_config->show_splash)
1591      e_init_status_set(_("Setup DND"));
1592    TS("E_Dnd Init");
1593    if (!e_dnd_init())
1594      {
1595         e_error_message_show(_("Enlightenment cannot set up its dnd system.\n"));
1596         _e_main_shutdown(-1);
1597      }
1598    TS("E_Dnd Init Done");
1599    _e_main_shutdown_push(e_dnd_shutdown);
1600 #endif
1601
1602    return 1;
1603 }
1604
1605 static int
1606 _e_main_screens_shutdown(void)
1607 {
1608    e_win_shutdown();
1609    e_menu_shutdown();
1610    e_shelf_shutdown();
1611    e_comp_shutdown();
1612    e_client_shutdown();
1613    e_exehist_shutdown();
1614    e_backlight_shutdown();
1615    e_exec_shutdown();
1616
1617    e_desk_shutdown();
1618    e_zone_shutdown();
1619    return 1;
1620 }
1621
1622 static void
1623 _e_main_desk_save(void)
1624 {
1625    const Eina_List *l;
1626    char env[1024], name[1024];
1627    E_Zone *zone;
1628
1629    EINA_LIST_FOREACH(e_comp->zones, l, zone)
1630      {
1631         snprintf(name, sizeof(name), "DESK_%d_%d", 0, zone->num);
1632         snprintf(env, sizeof(env), "%d,%d", zone->desk_x_current, zone->desk_y_current);
1633         e_util_env_set(name, env);
1634      }
1635 }
1636
1637 static void
1638 _e_main_desk_restore(void)
1639 {
1640    const Eina_List *l;
1641    E_Zone *zone;
1642    char *env;
1643    char name[1024];
1644
1645    EINA_LIST_FOREACH(e_comp->zones, l, zone)
1646      {
1647         E_Desk *desk;
1648         int desk_x, desk_y;
1649
1650         snprintf(name, sizeof(name), "DESK_%d_%d", 0, zone->num);
1651         env = getenv(name);
1652         if (!env) continue;
1653         if (!sscanf(env, "%d,%d", &desk_x, &desk_y)) continue;
1654         desk = e_desk_at_xy_get(zone, desk_x, desk_y);
1655         if (!desk) continue;
1656         e_desk_show(desk);
1657      }
1658 }
1659
1660 static void
1661 _e_main_efreet_paths_init(void)
1662 {
1663    Eina_List **list;
1664
1665    if ((list = efreet_icon_extra_list_get()))
1666      {
1667         char buff[PATH_MAX];
1668
1669         e_user_dir_concat_static(buff, "icons");
1670         *list = eina_list_prepend(*list, (void *)eina_stringshare_add(buff));
1671         e_prefix_data_concat_static(buff, "data/icons");
1672         *list = eina_list_prepend(*list, (void *)eina_stringshare_add(buff));
1673      }
1674 }
1675
1676 static Eina_Bool
1677 _e_main_modules_load_after(void *d EINA_UNUSED, int type EINA_UNUSED, void *ev EINA_UNUSED)
1678 {
1679    e_int_config_modules(NULL, NULL);
1680    E_FREE_FUNC(mod_init_end, ecore_event_handler_del);
1681    return ECORE_CALLBACK_RENEW;
1682 }
1683
1684 static void
1685 _e_main_modules_load(Eina_Bool safe_mode)
1686 {
1687    if (!safe_mode)
1688      e_module_all_load();
1689    else
1690      {
1691         E_Module *m;
1692         char *crashmodule;
1693
1694         crashmodule = getenv("E_MODULE_LOAD");
1695         if (crashmodule) m = e_module_new(crashmodule);
1696
1697         if ((crashmodule) && (m))
1698           {
1699              e_module_disable(m);
1700              e_object_del(E_OBJECT(m));
1701
1702              e_error_message_show
1703                (_("Enlightenment crashed early on start and has<br>"
1704                   "been restarted. There was an error loading the<br>"
1705                   "module named: %s. This module has been disabled<br>"
1706                   "and will not be loaded."), crashmodule);
1707              e_util_dialog_show
1708                (_("Enlightenment crashed early on start and has been restarted"),
1709                _("Enlightenment crashed early on start and has been restarted.<br>"
1710                  "There was an error loading the module named: %s<br><br>"
1711                  "This module has been disabled and will not be loaded."), crashmodule);
1712              e_module_all_load();
1713           }
1714         else
1715           {
1716              e_error_message_show
1717                (_("Enlightenment crashed early on start and has<br>"
1718                   "been restarted. All modules have been disabled<br>"
1719                   "and will not be loaded to help remove any problem<br>"
1720                   "modules from your configuration. The module<br>"
1721                   "configuration dialog should let you select your<br>"
1722                   "modules again.\n"));
1723              e_util_dialog_show
1724                (_("Enlightenment crashed early on start and has been restarted"),
1725                _("Enlightenment crashed early on start and has been restarted.<br>"
1726                  "All modules have been disabled and will not be loaded to help<br>"
1727                  "remove any problem modules from your configuration.<br><br>"
1728                  "The module configuration dialog should let you select your<br>"
1729                  "modules again."));
1730           }
1731         mod_init_end = ecore_event_handler_add(E_EVENT_MODULE_INIT_END, _e_main_modules_load_after, NULL);
1732      }
1733 }
1734
1735 static Eina_Bool
1736 _e_main_cb_idle_before(void *data EINA_UNUSED)
1737 {
1738    e_menu_idler_before();
1739    e_client_idler_before();
1740    e_pointer_idler_before();
1741    edje_thaw();
1742    return ECORE_CALLBACK_RENEW;
1743 }
1744
1745 static Eina_Bool
1746 _e_main_cb_idle_after(void *data EINA_UNUSED)
1747 {
1748    static int first_idle = 1;
1749
1750    eet_clearcache();
1751    edje_freeze();
1752
1753 #ifdef E_RELEASE_BUILD
1754    if (first_idle)
1755      {
1756         TS("SLEEP");
1757         first_idle = 0;
1758         e_precache_end = EINA_TRUE;
1759      }
1760 #else
1761    if (first_idle++ < 60)
1762      {
1763         TS("SLEEP");
1764         if (!first_idle)
1765           e_precache_end = EINA_TRUE;
1766      }
1767 #endif
1768
1769    return ECORE_CALLBACK_RENEW;
1770 }
1771
1772 static Eina_Bool
1773 _e_main_cb_startup_fake_end(void *data EINA_UNUSED)
1774 {
1775    e_init_hide();
1776    return ECORE_CALLBACK_CANCEL;
1777 }