src/lib/elm_main.c

   1 #ifdef HAVE_CONFIG_H
   2 # include "elementary_config.h"
   3 #endif
   4
   5 #ifndef _GNU_SOURCE
   6 # define _GNU_SOURCE
   7 #endif
   8
   9 #include <dlfcn.h>      /* dlopen,dlclose,etc */
  10
  11 #ifdef HAVE_CRT_EXTERNS_H
  12 # include <crt_externs.h>
  13 #endif
  14
  15 #ifdef HAVE_EVIL
  16 # include <Evil.h>
  17 #endif
  18
  19 #include <Elementary.h>
  20 #include "elm_priv.h"
  21
  22 static Elm_Version _version = { VMAJ, VMIN, VMIC, VREV };
  23 EAPI Elm_Version *elm_version = &_version;
  24
  25 /**
  26  * @defgroup Start Getting Started
  27  *
  28  * To write an Elementary app, you can get started with the following:
  29  *
  30  * @code
  31  * #include <Elementary.h>
  32  * #ifndef ELM_LIB_QUICKLAUNCH
  33  * EAPI int
  34  * elm_main(int argc, char **argv)
  35  * {
  36  *    // create window(s) here and do any application init
  37  *    elm_run(); // run main loop
  38  *    elm_shutdown(); // after mainloop finishes running, shutdown
  39  *    return 0; // exit 0 for exit code
  40  * }
  41  * #endif
  42  * ELM_MAIN()
  43  * @endcode
  44  *
  45  * To take full advantage of the quicklaunch architecture for launching
  46  * processes as quickly as possible (saving time at startup time like
  47  * connecting to X11, loading and linking shared libraries) you may want to
  48  * use the following configure.in/configure.ac and Makefile.am and autogen.sh
  49  * script to generate your files. It is assumed your application uses the
  50  * main.c file for its code.
  51  *
  52  * configure.in/configure.ac:
  53  *
  54 @verbatim
  55 AC_INIT(myapp, 0.0.0, myname@mydomain.com)
  56 AC_PREREQ(2.52)
  57 AC_CONFIG_SRCDIR(configure.in)
  58
  59 AM_INIT_AUTOMAKE(1.6 dist-bzip2)
  60 AM_CONFIG_HEADER(config.h)
  61
  62 AC_C_BIGENDIAN
  63 AC_ISC_POSIX
  64 AC_PROG_CC
  65 AM_PROG_CC_STDC
  66 AC_HEADER_STDC
  67 AC_C_CONST
  68
  69 AC_LIBTOOL_WIN32_DLL
  70 define([AC_LIBTOOL_LANG_CXX_CONFIG], [:])dnl
  71 define([AC_LIBTOOL_LANG_F77_CONFIG], [:])dnl
  72 AC_PROG_LIBTOOL
  73
  74 PKG_CHECK_MODULES([ELEMENTARY], elementary)
  75
  76 AC_OUTPUT(Makefile)
  77 @endverbatim
  78  *
  79  * Makefile.am:
  80  *
  81 @verbatim
  82 AUTOMAKE_OPTIONS     = 1.4 foreign
  83 MAINTAINERCLEANFILES = Makefile.in
  84
  85 INCLUDES = -I$(top_srcdir) @ELEMENTARY_CFLAGS@
  86
  87 bin_PROGRAMS      = myapp
  88 myapp_LTLIBRARIES = myapp.la
  89
  90 myappdir = $(libdir)
  91
  92 myapp_la_SOURCES = main.c
  93 myapp_la_LIBADD = @ELEMENTARY_LIBS@
  94 myapp_la_CFLAGS =
  95 myapp_la_LDFLAGS = -module -avoid-version -no-undefined
  96
  97 myapp_SOURCES = main.c
  98 myapp_LDADD = @ELEMENTARY_LIBS@
  99 myapp_CFLAGS = -DELM_LIB_QUICKLAUNCH=1
 100 @endverbatim
 101  *
 102  * autogen.sh:
 103  *
 104 @verbatim
 105 #!/bin/sh
 106 rm -rf autom4te.cache
 107 rm -f aclocal.m4 ltmain.sh
 108 rm -rf m4
 109 mkdir m4
 110
 111 touch README
 112 echo "Running aclocal..." ; aclocal $ACLOCAL_FLAGS -I m4 || exit 1
 113 echo "Running autoheader..." ; autoheader || exit 1
 114 echo "Running autoconf..." ; autoconf || exit 1
 115 echo "Running libtoolize..." ; (libtoolize --copy --automake || glibtoolize --automake) || exit 1
 116 echo "Running automake..." ; automake --add-missing --copy --gnu || exit 1
 117
 118 if [ -z "$NOCONFIGURE" ]; then
 119   ./configure "$@"
 120 fi
 121 @endverbatim
 122  *
 123  * To gnerate all the things needed to bootstrap just run:
 124  *
 125 @verbatim
 126 ./autogen.sh
 127 @endverbatim
 128  *
 129  * This will generate Makefile.in's, the confgure script and everything else.
 130  * After this it works like all normal autotools projects:
 131 @verbatim
 132 ./configure
 133 make
 134 sudo make install
 135 @endverbatim
 136  *
 137  * Note sudo was assumed to get root permissions, as this would install in
 138  * /usr/local which is system-owned. Ue any way you like to gain root, or
 139  * specify a different prefix with configure:
 140  *
 141 @verbatim
 142 ./confiugre --prefix=$HOME/mysoftware
 143 @endverbatim
 144  *
 145  * Also remember that autotools buys you some useful commands like:
 146 @verbatim
 147 make uninstall
 148 @endverbatim
 149  *
 150  * This uninstalls the software after it was installed with "make install".
 151  * It is very useful to clear up what you built if you wish to clean the
 152  * system.
 153  *
 154 @verbatim
 155 make distcheck
 156 @endverbatim
 157  *
 158  * This firstly checks if your build tree is "clean" and ready for
 159  * distribution. It also builds a tarball (myapp-0.0.0.tar.gz) that is
 160  * ready to upload and distribute to the world, that contains the generated
 161  * Makefile.in's and configure script. The users do not need to run
 162  * autogen.sh - just configure and on. They don't need autotools installed.
 163  * This tarball also builds cleanly, has all the sources it needs to build
 164  * included (that is sources for your application, not libraries it depends
 165  * on like Elementary). It builds cleanly in a buildroot and does not
 166  * contain any files that are temporarily generated like binaries and other
 167  * build-gnerated files, so the tarball is clean, and no need to worry
 168  * about cleaning up your tree before packaging.
 169  *
 170 @verbatim
 171 make clean
 172 @endverbatim
 173  *
 174  * This cleans up all build files (binaries, objects etc.) from the tree.
 175  *
 176 @verbatim
 177 make distclean
 178 @endverbatim
 179  *
 180  * This cleans out all files from the build and from configure's output too.
 181  *
 182 @verbatim
 183 make maintainer-clean
 184 @endverbatim
 185  *
 186  * This deletes all the files autogen.sh will produce so the tree is clean
 187  * to be put into a revision-control system (like CVS, SVN or GIT for example).
 188  *
 189  * The above will build a library - libmyapp.so and install in the target
 190  * library directory (default is /usr/local/lib). You will also get a
 191  * myapp.a and myapp.la - these are useless and can be deleted. Libtool likes
 192  * to generate these all the time. You will also get a binary in the target
 193  * binary directory (default is /usr/local/bin). This is a "debug binary".
 194  * This will run and dlopen() the myapp.so and then jump to it's elm_main
 195  * function. This allows for easy debugging with GDB and Valgrind. When you
 196  * are ready to go to production do the following:
 197  *
 198  * 1. delete the myapp binary. i.e. rm /usr/local/bin/myapp
 199  *
 200  * 2. symlink the myapp binary to elementary_run (supplied by elementary).
 201  * i.e. ln -s elmentary_run /usr/local/bin/myapp
 202  *
 203  * 3. run elementary_quicklaunch as part of your graphical login session and
 204  * keep it running.
 205  *
 206  * This will man elementary_quicklaunch does pre-initialization before the
 207  * application needs to be run, saving the effort at the time the application
 208  * is needed, thus speeding up the time it takes to appear.
 209  *
 210  * If you don't want to use the quicklaunch infrastructure (which is
 211  * optional), you can execute the old fashioned way by just running the
 212  * myapp binary loader than will load the myapp.so for you, or you can
 213  * remove the split-file binary and put it into one binary as things always
 214  * have been with the following configure.in/configure.ac and Makfile.am
 215  * files:
 216  *
 217  * configure.in/configure.ac:
 218  *
 219 @verbatim
 220 AC_INIT(myapp, 0.0.0, myname@mydomain.com)
 221 AC_PREREQ(2.52)
 222 AC_CONFIG_SRCDIR(configure.in)
 223
 224 AM_INIT_AUTOMAKE(1.6 dist-bzip2)
 225 AM_CONFIG_HEADER(config.h)
 226
 227 AC_C_BIGENDIAN
 228 AC_ISC_POSIX
 229 AC_PROG_CC
 230 AM_PROG_CC_STDC
 231 AC_HEADER_STDC
 232 AC_C_CONST
 233
 234 PKG_CHECK_MODULES([ELEMENTARY], elementary)
 235
 236 AC_OUTPUT(Makefile)
 237 @endverbatim
 238  *
 239  * Makefile.am:
 240  *
 241 @verbatim
 242 AUTOMAKE_OPTIONS     = 1.4 foreign
 243 MAINTAINERCLEANFILES = Makefile.in
 244
 245 INCLUDES = -I$(top_srcdir) @ELEMENTARY_CFLAGS@
 246
 247 bin_PROGRAMS      = myapp
 248
 249 myapp_SOURCES = main.c
 250 myapp_LDADD = @ELEMENTARY_LIBS@
 251 myapp_CFLAGS =
 252 @endverbatim
 253  *
 254  * Notice that they are the same as before, just with libtool and library
 255  * building sections removed. Both ways work for building elementary
 256  * applications. It is up to you to decide what is best for you. If you just
 257  * follow the template above, you can do it both ways and can decide at build
 258  * time. The more advanced of you may suggest making it a configure option.
 259  * That is perfectly valid, bu has been left out here for simplicity, as our
 260  * aim to have an Elementary (and EFL) tutorial, not an autoconf & automake
 261  * document.
 262  *
 263  */
 264
 265 static int _elm_signal_exit(void *data, int ev_type, void *ev);
 266
 267 char *_elm_appname = NULL;
 268 const char *_elm_data_dir = NULL;
 269 const char *_elm_lib_dir = NULL;
 270 int _elm_log_dom = -1;
 271
 272 EAPI int ELM_EVENT_POLICY_CHANGED = 0;
 273
 274 static int _elm_init_count = 0;
 275 static int _elm_policies[ELM_POLICY_LAST];
 276 static Ecore_Event_Handler *_elm_exit_handler = NULL;
 277
 278 static int
 279 _elm_signal_exit(void *data __UNUSED__, int ev_type __UNUSED__, void *ev __UNUSED__)
 280 {
 281    elm_exit();
 282    return 1;
 283 }
 284
 285 void
 286 _elm_rescale(void)
 287 {
 288    edje_scale_set(_elm_config->scale);
 289    _elm_win_rescale();
 290 }
 291
 292 /**
 293  * @defgroup General General
 294  */
 295
 296 /**
 297  * Inititalise Elementary
 298  *
 299  * This call is exported only for use by the ELM_MAIN() macro. There is no
 300  * need to use this if you use this macro (which is highly advisable).
 301  * @ingroup General
 302  */
 303 EAPI void
 304 elm_init(int argc, char **argv)
 305 {
 306    _elm_init_count++;
 307    if (_elm_init_count != 1) return;
 308    elm_quicklaunch_init(argc, argv);
 309    elm_quicklaunch_sub_init(argc, argv);
 310 }
 311
 312 /**
 313  * Shut down Elementary
 314  *
 315  * This should be called at the end of your application just before it ceases
 316  * to do any more processing. This will clean up any permanent resources your
 317  * application may have allocated via Elementary that would otherwise persist
 318  * on an exit without this call.
 319  * @ingroup General
 320  */
 321 EAPI void
 322 elm_shutdown(void)
 323 {
 324    _elm_init_count--;
 325    if (_elm_init_count != 0) return;
 326    elm_quicklaunch_sub_shutdown();
 327    elm_quicklaunch_shutdown();
 328 }
 329
 330 #ifdef ELM_EDBUS
 331 static Eina_Bool _elm_need_e_dbus = EINA_FALSE;
 332 #endif
 333 EAPI void
 334 elm_need_e_dbus(void)
 335 {
 336 #ifdef ELM_EDBUS
 337    if (_elm_need_e_dbus) return;
 338    _elm_need_e_dbus = 1;
 339    e_dbus_init();
 340    e_hal_init();
 341 #endif
 342 }
 343
 344 static void
 345 _elm_unneed_e_dbus(void)
 346 {
 347 #ifdef ELM_EDBUS
 348    if (_elm_need_e_dbus)
 349      {
 350         _elm_need_e_dbus = 0;
 351         e_hal_shutdown();
 352         e_dbus_shutdown();
 353      }
 354 #endif
 355 }
 356
 357 #ifdef ELM_EFREET
 358 static Eina_Bool _elm_need_efreet = EINA_FALSE;
 359 #endif
 360 EAPI void
 361 elm_need_efreet(void)
 362 {
 363 #ifdef ELM_EFREET
 364    if (_elm_need_efreet) return;
 365    _elm_need_efreet = 1;
 366    efreet_init();
 367    efreet_mime_init();
 368    efreet_trash_init();
 369    /*
 370      {
 371         Eina_List **list;
 372
 373         list = efreet_icon_extra_list_get();
 374         if (list)
 375           {
 376              e_user_dir_concat_static(buf, "icons");
 377              *list = eina_list_prepend(*list, (void *)eina_stringshare_add(buf));
 378              e_prefix_data_concat_static(buf, "data/icons");
 379              *list = eina_list_prepend(*list, (void *)eina_stringshare_add(buf));
 380           }
 381      }
 382    */
 383 #endif
 384 }
 385
 386 static void
 387 _elm_unneed_efreet(void)
 388 {
 389 #ifdef ELM_EFREET
 390    if (_elm_need_efreet)
 391      {
 392         _elm_need_efreet = 0;
 393         efreet_trash_shutdown();
 394         efreet_mime_shutdown();
 395         efreet_shutdown();
 396      }
 397 #endif
 398 }
 399
 400 EAPI void
 401 elm_quicklaunch_init(int argc, char **argv)
 402 {
 403    char buf[PATH_MAX], *s;
 404
 405    eina_init();
 406    _elm_log_dom = eina_log_domain_register("elementary", EINA_COLOR_LIGHTBLUE);
 407    if (!_elm_log_dom)
 408      {
 409         EINA_LOG_ERR("could not register elementary log domain.");
 410         _elm_log_dom = EINA_LOG_DOMAIN_GLOBAL;
 411      }
 412
 413    eet_init();
 414    ecore_init();
 415    ecore_app_args_set(argc, (const char **)argv);
 416
 417    memset(_elm_policies, 0, sizeof(_elm_policies));
 418    if (ELM_EVENT_POLICY_CHANGED == 0)
 419      ELM_EVENT_POLICY_CHANGED = ecore_event_type_new();
 420
 421    ecore_file_init();
 422    evas_init();
 423    edje_init();
 424    ecore_evas_init(); // FIXME: check errors
 425    ecore_imf_init();
 426    _elm_module_init();
 427
 428    _elm_exit_handler = ecore_event_handler_add(ECORE_EVENT_SIGNAL_EXIT, _elm_signal_exit, NULL);
 429
 430    if (argv) _elm_appname = strdup(ecore_file_file_get(argv[0]));
 431
 432    if (!_elm_data_dir)
 433      {
 434         s = getenv("ELM_DATA_DIR");
 435         _elm_data_dir = eina_stringshare_add(s);
 436      }
 437    if (!_elm_data_dir)
 438      {
 439         s = getenv("ELM_PREFIX");
 440         if (s)
 441           {
 442              snprintf(buf, sizeof(buf), "%s/share/elementary", s);
 443              _elm_data_dir = eina_stringshare_add(buf);
 444           }
 445      }
 446    if (!_elm_lib_dir)
 447      {
 448         s = getenv("ELM_LIB_DIR");
 449         _elm_lib_dir = eina_stringshare_add(s);
 450      }
 451    if (!_elm_lib_dir)
 452      {
 453         s = getenv("ELM_PREFIX");
 454         if (s)
 455           {
 456              snprintf(buf, sizeof(buf), "%s/lib", s);
 457              _elm_lib_dir = eina_stringshare_add(buf);
 458           }
 459      }
 460 #ifdef HAVE_DLADDR
 461    if ((!_elm_data_dir) || (!_elm_lib_dir))
 462      {
 463         Dl_info elementary_dl;
 464         // libelementary.so/../../share/elementary/
 465         if (dladdr(elm_init, &elementary_dl))
 466           {
 467              char *dir, *dir2;
 468
 469              dir = ecore_file_dir_get(elementary_dl.dli_fname);
 470              if (dir)
 471                {
 472                   if (!_elm_lib_dir)
 473                     {
 474                        if (ecore_file_is_dir(dir))
 475                          _elm_lib_dir = eina_stringshare_add(dir);
 476                     }
 477                   if (!_elm_data_dir)
 478                     {
 479                        dir2 = ecore_file_dir_get(dir);
 480                        if (dir2)
 481                          {
 482                             snprintf(buf, sizeof(buf), "%s/share/elementary", dir2);
 483                             if (ecore_file_is_dir(buf))
 484                               _elm_data_dir = eina_stringshare_add(buf);
 485                             free(dir2);
 486                          }
 487                     }
 488                   free(dir);
 489                }
 490           }
 491      }
 492 #endif
 493    if (!_elm_data_dir)
 494      _elm_data_dir = eina_stringshare_add(PACKAGE_DATA_DIR);
 495   if (!_elm_data_dir)
 496      _elm_data_dir = eina_stringshare_add("/");
 497    if (!_elm_lib_dir)
 498      _elm_lib_dir = eina_stringshare_add(PACKAGE_LIB_DIR);
 499    if (!_elm_lib_dir)
 500      _elm_lib_dir = eina_stringshare_add("/");
 501
 502    _elm_config_init();
 503 }
 504
 505 EAPI void
 506 elm_quicklaunch_sub_init(int argc, char **argv)
 507 {
 508    ecore_app_args_set(argc, (const char **)argv);
 509    _elm_config_sub_init();
 510 }
 511
 512 EAPI void
 513 elm_quicklaunch_sub_shutdown(void)
 514 {
 515    _elm_win_shutdown();
 516    if ((_elm_config->engine == ELM_SOFTWARE_X11) ||
 517        (_elm_config->engine == ELM_SOFTWARE_16_X11) ||
 518        (_elm_config->engine == ELM_XRENDER_X11) ||
 519        (_elm_config->engine == ELM_OPENGL_X11) ||
 520        (_elm_config->engine == ELM_SOFTWARE_SDL) ||
 521        (_elm_config->engine == ELM_SOFTWARE_16_SDL) ||
 522        (_elm_config->engine == ELM_OPENGL_SDL) ||
 523        (_elm_config->engine == ELM_SOFTWARE_WIN32) ||
 524        (_elm_config->engine == ELM_SOFTWARE_16_WINCE))
 525      {
 526 #ifdef HAVE_ELEMENTARY_X
 527         ecore_x_disconnect();
 528 #endif
 529         evas_cserve_disconnect();
 530      }
 531 }
 532
 533 EAPI void
 534 elm_quicklaunch_shutdown(void)
 535 {
 536    eina_stringshare_del(_elm_data_dir);
 537    _elm_data_dir = NULL;
 538    eina_stringshare_del(_elm_lib_dir);
 539    _elm_lib_dir = NULL;
 540
 541    free(_elm_appname);
 542    _elm_appname = NULL;
 543
 544    _elm_config_shutdown();
 545
 546    ecore_event_handler_del(_elm_exit_handler);
 547    _elm_exit_handler = NULL;
 548
 549    _elm_theme_shutdown();
 550    _elm_unneed_efreet();
 551    _elm_unneed_e_dbus();
 552    _elm_unneed_ethumb();
 553    _elm_module_shutdown();
 554    ecore_imf_shutdown();
 555    ecore_evas_shutdown();
 556    edje_shutdown();
 557    evas_shutdown();
 558    ecore_file_shutdown();
 559    ecore_shutdown();
 560    eet_shutdown();
 561
 562    if ((_elm_log_dom > -1) && (_elm_log_dom != EINA_LOG_DOMAIN_GLOBAL))
 563      {
 564         eina_log_domain_unregister(_elm_log_dom);
 565         _elm_log_dom = -1;
 566      }
 567
 568    eina_shutdown();
 569 }
 570
 571 EAPI void
 572 elm_quicklaunch_seed(void)
 573 {
 574    Evas_Object *win, *bg, *bt;
 575
 576    win = elm_win_add(NULL, "seed", ELM_WIN_BASIC);
 577    bg = elm_bg_add(win);
 578    elm_win_resize_object_add(win, bg);
 579    evas_object_show(bg);
 580    bt = elm_button_add(win);
 581    elm_button_label_set(bt, " abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789~-_=+\\|]}[{;:'\",<.>/?");
 582    elm_win_resize_object_add(win, bt);
 583    ecore_main_loop_iterate();
 584    evas_object_del(win);
 585    ecore_main_loop_iterate();
 586    if ((_elm_config->engine == ELM_SOFTWARE_X11) ||
 587        (_elm_config->engine == ELM_SOFTWARE_16_X11) ||
 588        (_elm_config->engine == ELM_XRENDER_X11) ||
 589        (_elm_config->engine == ELM_OPENGL_X11))
 590      {
 591 #ifdef HAVE_ELEMENTARY_X
 592         ecore_x_sync();
 593 #endif
 594       }
 595    ecore_main_loop_iterate();
 596 }
 597
 598 static void *qr_handle = NULL;
 599 static int (*qr_main) (int argc, char **argv) = NULL;
 600
 601 EAPI Eina_Bool
 602 elm_quicklaunch_prepare(int argc __UNUSED__, char **argv)
 603 {
 604 #ifdef HAVE_FORK
 605    char *exe = elm_quicklaunch_exe_path_get(argv[0]);
 606    if (!exe)
 607      {
 608         ERR("requested quicklaunch binary '%s' does not exist\n", argv[0]);
 609         return EINA_FALSE;
 610      }
 611    else
 612      {
 613         char *exe2, *p;
 614         char *exename;
 615
 616         exe2 = malloc(strlen(exe) + 1 + 10);
 617         strcpy(exe2, exe);
 618         p = strrchr(exe2, '/');
 619         if (p) p++;
 620         else p = exe2;
 621         exename = alloca(strlen(p) + 1);
 622         strcpy(exename, p);
 623         *p = 0;
 624         strcat(p, "../lib/");
 625         strcat(p, exename);
 626         strcat(p, ".so");
 627         if (access(exe2, R_OK | X_OK) == 0)
 628           {
 629              free(exe);
 630              exe = exe2;
 631           }
 632         else
 633           free(exe2);
 634      }
 635    qr_handle = dlopen(exe, RTLD_NOW | RTLD_GLOBAL);
 636    if (!qr_handle)
 637      {
 638         fprintf(stderr, "dlerr: %s\n", dlerror());
 639         WRN("dlopen('%s') failed: %s", exe, dlerror());
 640         free(exe);
 641         return EINA_FALSE;
 642      }
 643    INF("dlopen('%s') = %p", exe, qr_handle);
 644    free(exe);
 645    qr_main = dlsym(qr_handle, "elm_main");
 646    INF("dlsym(%p, 'elm_main') = %p", qr_handle, qr_main);
 647    if (!qr_main)
 648      {
 649         WRN("not quicklauncher capable: no elm_main in '%s'", exe);
 650         dlclose(qr_handle);
 651         qr_handle = NULL;
 652         return EINA_FALSE;
 653      }
 654    return EINA_TRUE;
 655 #else
 656    return EINA_FALSE;
 657 #endif
 658 }
 659
 660 #ifdef HAVE_FORK
 661 static void
 662 save_env(void)
 663 {
 664    int i, size;
 665    extern char **environ;
 666    char **oldenv, **p;
 667
 668    oldenv = environ;
 669
 670    for (i = 0, size = 0; environ[i] != NULL; i++)
 671      size += strlen(environ[i]) + 1;
 672
 673    p = malloc((i + 1) * sizeof(char *));
 674    if (!p) return;
 675
 676    environ = p;
 677
 678    for (i = 0; oldenv[i] != NULL; i++)
 679      environ[i] = strdup(oldenv[i]);
 680    environ[i] = NULL;
 681 }
 682 #endif
 683
 684 EAPI Eina_Bool
 685 elm_quicklaunch_fork(int argc, char **argv, char *cwd, void (postfork_func) (void *data), void *postfork_data)
 686 {
 687 #ifdef HAVE_FORK
 688    pid_t child;
 689    int ret;
 690    int real_argc;
 691    char **real_argv;
 692
 693    // FIXME:
 694    // need to accept current environment from elementary_run
 695    if (!qr_main)
 696      {
 697         int i;
 698         char **args;
 699
 700         child = fork();
 701         if (child > 0) return EINA_TRUE;
 702         else if (child < 0)
 703           {
 704              perror("could not fork");
 705              return EINA_FALSE;
 706           }
 707         setsid();
 708         if (chdir(cwd) != 0)
 709           perror("could not chdir");
 710         args = alloca((argc + 1) * sizeof(char *));
 711         for (i = 0; i < argc; i++) args[i] = argv[i];
 712         args[argc] = NULL;
 713         WRN("%s not quicklaunch capable, fallback...", argv[0]);
 714         execvp(argv[0], args);
 715         ERR("failed to execute '%s': %s", argv[0], strerror(errno));
 716         exit(-1);
 717      }
 718    child = fork();
 719    if (child > 0) return EINA_TRUE;
 720    else if (child < 0)
 721      {
 722         perror("could not fork");
 723         return EINA_FALSE;
 724      }
 725    if (postfork_func) postfork_func(postfork_data);
 726
 727    setsid();
 728    if (chdir(cwd) != 0)
 729      perror("could not chdir");
 730    // FIXME: this is very linux specific. it changes argv[0] of the process
 731    // so ps etc. report what you'd expect. for other unixes and os's this
 732    // may just not work
 733    save_env();
 734    if (argv)
 735      {
 736         char *lastarg, *p;
 737
 738         ecore_app_args_get(&real_argc, &real_argv);
 739         lastarg = real_argv[real_argc - 1] + strlen(real_argv[real_argc - 1]);
 740         for (p = real_argv[0]; p < lastarg; p++) *p = 0;
 741         strcpy(real_argv[0], argv[0]);
 742      }
 743    ecore_app_args_set(argc, (const char **)argv);
 744    ret = qr_main(argc, argv);
 745    exit(ret);
 746    return EINA_TRUE;
 747 #else
 748    return EINA_FALSE;
 749 #endif
 750 }
 751
 752 EAPI void
 753 elm_quicklaunch_cleanup(void)
 754 {
 755 #ifdef HAVE_FORK
 756    if (qr_handle)
 757      {
 758         dlclose(qr_handle);
 759         qr_handle = NULL;
 760         qr_main = NULL;
 761      }
 762 #endif
 763 }
 764
 765 EAPI int
 766 elm_quicklaunch_fallback(int argc, char **argv)
 767 {
 768    int ret;
 769    elm_quicklaunch_init(argc, argv);
 770    elm_quicklaunch_sub_init(argc, argv);
 771    elm_quicklaunch_prepare(argc, argv);
 772    ret = qr_main(argc, argv);
 773    exit(ret);
 774    return ret;
 775 }
 776
 777 EAPI char *
 778 elm_quicklaunch_exe_path_get(const char *exe)
 779 {
 780    static char *path = NULL;
 781    static Eina_List *pathlist = NULL;
 782    const char *pathitr;
 783    const Eina_List *l;
 784    char buf[PATH_MAX];
 785    if (exe[0] == '/') return strdup(exe);
 786    if ((exe[0] == '.') && (exe[1] == '/')) return strdup(exe);
 787    if ((exe[0] == '.') && (exe[1] == '.') && (exe[2] == '/')) return strdup(exe);
 788    if (!path)
 789      {
 790         const char *p, *pp;
 791         char *buf2;
 792         path = getenv("PATH");
 793         buf2 = alloca(strlen(path) + 1);
 794         p = path;
 795         pp = p;
 796         for (;;)
 797           {
 798              if ((*p == ':') || (*p == 0))
 799                {
 800                   int len;
 801
 802                   len = p - pp;
 803                   strncpy(buf2, pp, len);
 804                   buf2[len] = 0;
 805                   pathlist = eina_list_append(pathlist, eina_stringshare_add(buf2));
 806                   if (*p == 0) break;
 807                   p++;
 808                   pp = p;
 809                }
 810              else
 811                {
 812                   if (*p == 0) break;
 813                   p++;
 814                }
 815           }
 816      }
 817    EINA_LIST_FOREACH(pathlist, l, pathitr)
 818      {
 819         snprintf(buf, sizeof(buf), "%s/%s", pathitr, exe);
 820         if (access(buf, R_OK | X_OK) == 0) return strdup(buf);
 821      }
 822    return NULL;
 823 }
 824
 825 /**
 826  * Run the main loop
 827  *
 828  * This call should be called just after all initialization is complete. This
 829  * function will not return until elm_exit() is called. It will keep looping
 830  * running the main event/processing loop for Elementary.
 831  * @ingroup General
 832  */
 833 EAPI void
 834 elm_run(void)
 835 {
 836    ecore_main_loop_begin();
 837 }
 838
 839 /**
 840  * Exit the main loop
 841  *
 842  * If this call is called, it will flag the main loop to cease processing and
 843  * return back to its parent function.
 844  * @ingroup General
 845  */
 846 EAPI void
 847 elm_exit(void)
 848 {
 849    ecore_main_loop_quit();
 850 }
 851
 852
 853 /**
 854  * Set new policy value.
 855  *
 856  * This will emit the ecore event ELM_EVENT_POLICY_CHANGED in the main
 857  * loop giving the event information Elm_Event_Policy_Changed with
 858  * policy identifier, new and old values.
 859  *
 860  * @param policy policy identifier as in Elm_Policy.
 861  * @param value policy value, depends on identifiers, usually there is
 862  *        an enumeration with the same prefix as the policy name, for
 863  *        example: ELM_POLICY_QUIT and Elm_Policy_Quit
 864  *        (ELM_POLICY_QUIT_NONE, ELM_POLICY_QUIT_LAST_WINDOW_CLOSED).
 865  *
 866  * @return @c EINA_TRUE on success or @c EINA_FALSE on error (right
 867  *         now just invalid policy identifier, but in future policy
 868  *         value might be enforced).
 869  */
 870 EAPI Eina_Bool
 871 elm_policy_set(unsigned int policy, int value)
 872 {
 873    Elm_Event_Policy_Changed *ev;
 874
 875    if (policy >= ELM_POLICY_LAST)
 876      return EINA_FALSE;
 877
 878    if (value == _elm_policies[policy])
 879      return EINA_TRUE;
 880
 881    /* TODO: validade policy? */
 882
 883    ev = malloc(sizeof(*ev));
 884    ev->policy = policy;
 885    ev->new_value = value;
 886    ev->old_value = _elm_policies[policy];
 887
 888    _elm_policies[policy] = value;
 889
 890    ecore_event_add(ELM_EVENT_POLICY_CHANGED, ev, NULL, NULL);
 891
 892    return EINA_TRUE;
 893 }
 894
 895 /**
 896  * Gets the policy value set for given identifier.
 897  *
 898  * @param policy policy identifier as in Elm_Policy.
 899  *
 900  * @return policy value. Will be 0 if policy identifier is invalid.
 901  */
 902 EAPI int
 903 elm_policy_get(unsigned int policy)
 904 {
 905    if (policy >= ELM_POLICY_LAST)
 906      return 0;
 907    return _elm_policies[policy];
 908 }
 909
 910 /**
 911  * Flush all caches & dump all data that can be to lean down to use less memory
 912  */
 913 EAPI void
 914 elm_all_flush(void)
 915 {
 916    const Eina_List *l;
 917    Evas_Object *obj;
 918
 919    EINA_LIST_FOREACH(_elm_win_list, l, obj)
 920      {
 921         Evas *e = evas_object_evas_get(obj);
 922         edje_file_cache_flush();
 923         edje_collection_cache_flush();
 924         evas_image_cache_flush(e);
 925         evas_font_cache_flush(e);
 926         evas_render_dump(e);
 927      }
 928 }
 929
 930 /**
 931  * @defgroup Scaling Selective Widget Scaling
 932  *
 933  * Different widgets can be scaled independently. These functions allow you to
 934  * manipulate this scaling on a per-widget basis. The object and all its
 935  * children get their scaling factors multiplied by the scale factor set.
 936  * This is multiplicative, in that if a child also has a scale size set it is
 937  * in turn multiplied by its parent's scale size. 1.0 means “don't scale”,
 938  * 2.0 is double size, 0.5 is half etc.
 939  */
 940
 941 /**
 942  * Set the scaling factor
 943  *
 944  * @param obj The object
 945  * @param scale Scale factor (from 0.0 up, with 1.0 == no scaling)
 946  * @ingroup Scaling
 947  */
 948 EAPI void
 949 elm_object_scale_set(Evas_Object *obj, double scale)
 950 {
 951    elm_widget_scale_set(obj, scale);
 952 }
 953
 954 /**
 955  * Get the scaling factor
 956  *
 957  * @param obj The object
 958  * @return The scaling factor set by elm_object_scale_set()
 959  * @ingroup Scaling
 960  */
 961 EAPI double
 962 elm_object_scale_get(const Evas_Object *obj)
 963 {
 964    return elm_widget_scale_get(obj);
 965 }
 966
 967 /**
 968  * @defgroup Styles Styles
 969  *
 970  * Widgets can have different styles of look. These generic API's set
 971  * styles of widgets, if they support them (and if the theme(s) do).
 972  */
 973
 974 /**
 975  * Set the style
 976  *
 977  * This sets the name of the style
 978  * @param obj The object
 979  * @param style The style name to use
 980  * @ingroup Styles
 981  */
 982 EAPI void
 983 elm_object_style_set(Evas_Object *obj, const char *style)
 984 {
 985    elm_widget_style_set(obj, style);
 986 }
 987
 988 /**
 989  * Get the style
 990  *
 991  * This gets the style being used for that widget. Note that the string
 992  * pointer is only valid as longas the object is valid and the style doesn't
 993  * change.
 994  *
 995  * @param obj The object
 996  * @return The style name
 997  * @ingroup Styles
 998  */
 999 EAPI const char *
1000 elm_object_style_get(const Evas_Object *obj)
1001 {
1002    return elm_widget_style_get(obj);
1003 }
1004
1005 /**
1006  * Set the disable state
1007  *
1008  * This sets the disable state for the widget.
1009  *
1010  * @param obj The object
1011  * @param disabled The state
1012  * @ingroup Styles
1013  */
1014 EAPI void
1015 elm_object_disabled_set(Evas_Object *obj, Eina_Bool disabled)
1016 {
1017    elm_widget_disabled_set(obj, disabled);
1018 }
1019
1020 /**
1021  * Get the disable state
1022  *
1023  * This gets the disable state for the widget.
1024  *
1025  * @param obj The object
1026  * @return True, if the widget is disabled
1027  * @ingroup Styles
1028  */
1029 EAPI Eina_Bool
1030 elm_object_disabled_get(const Evas_Object *obj)
1031 {
1032    return elm_widget_disabled_get(obj);
1033 }
1034
1035 /**
1036  * Get the global scaling factor
1037  *
1038  * This gets the globally configured scaling factor that is applied to all
1039  * objects.
1040  *
1041  * @return The scaling factor
1042  * @ingroup Scaling
1043  */
1044 EAPI double
1045 elm_scale_get(void)
1046 {
1047    return _elm_config->scale;
1048 }
1049
1050 /**
1051  * Set the global scaling factor
1052  *
1053  * This sets the globally configured scaling factor that is applied to all
1054  * objects.
1055  *
1056  * @param scale The scaling factor to set
1057  * @ingroup Scaling
1058  */
1059 EAPI void
1060 elm_scale_set(double scale)
1061 {
1062    if (_elm_config->scale == scale) return;
1063    _elm_config->scale = scale;
1064    _elm_rescale();
1065 }
1066
1067 /**
1068  * Set the global scaling factor for all applications on the display
1069  *
1070  * This sets the globally configured scaling factor that is applied to all
1071  * objects for all applications.
1072  * @param scale The scaling factor to set
1073  * @ingroup Scaling
1074  */
1075 EAPI void
1076 elm_scale_all_set(double scale)
1077 {
1078 #ifdef HAVE_ELEMENTARY_X
1079    static Ecore_X_Atom atom = 0;
1080    unsigned int scale_i = (unsigned int)(scale * 1000.0);
1081
1082    if (!atom) atom = ecore_x_atom_get("ENLIGHTENMENT_SCALE");
1083    ecore_x_window_prop_card32_set(ecore_x_window_root_first_get(),
1084                                   atom, &scale_i, 1);
1085 #endif
1086 }
1087
1088 /**
1089  * @defgroup Fingers Fingers
1090  *
1091  * Elementary is designed to be finger-friendly for touchscreens, and so in
1092  * addition to scaling for display resolution, it can also scale based on
1093  * finger "resolution" (or size).
1094  */
1095
1096 /**
1097  * Get the configured finger size
1098  *
1099  * This gets the globally configured finger size in pixels
1100  *
1101  * @return The finger size
1102  * @ingroup Fingers
1103  */
1104 EAPI Evas_Coord
1105 elm_finger_size_get(void)
1106 {
1107    return _elm_config->finger_size;
1108 }
1109
1110 /**
1111  * Set the configured finger size
1112  *
1113  * This sets the globally configured finger size in pixels
1114  *
1115  * @param size The finger size
1116  * @ingroup Fingers
1117  */
1118 EAPI void
1119 elm_finger_size_set(Evas_Coord size)
1120 {
1121    if (_elm_config->finger_size == size) return;
1122    _elm_config->finger_size = size;
1123    _elm_rescale();
1124 }
1125
1126 /**
1127  * Set the configured finger size for all applications on the display
1128  *
1129  * This sets the globally configured finger size in pixels for all applications
1130  * on the display
1131  *
1132  * @param size The finger size
1133  * @ingroup Fingers
1134  */
1135 EAPI void
1136 elm_finger_size_all_set(Evas_Coord size)
1137 {
1138 #ifdef HAVE_ELEMENTARY_X
1139    static Ecore_X_Atom atom = 0;
1140    unsigned int size_i = (unsigned int)size;
1141
1142    if (!atom) atom = ecore_x_atom_get("ENLIGHTENMENT_FINGER_SIZE");
1143    ecore_x_window_prop_card32_set(ecore_x_window_root_first_get(),
1144                                   atom, &size_i, 1);
1145 #endif
1146 }
1147
1148 /**
1149  * Adjust size of an element for finger usage
1150  *
1151  * This takes width and height sizes (in pixels) as input and a size multiple
1152  * (which is how many fingers you want to place within the area), and adjusts
1153  * the size tobe large enough to accomodate finger. On return the w and h
1154  * sizes poiner do by these parameters will be modified.
1155  *
1156  * @param times_w How many fingers should fit horizontally
1157  * @param w Pointer to the width size to adjust
1158  * @param times_h How many fingers should fit vertically
1159  * @param h Pointer to the height size to adjust
1160  * @ingroup Fingers
1161  */
1162 EAPI void
1163 elm_coords_finger_size_adjust(int times_w, Evas_Coord *w, int times_h, Evas_Coord *h)
1164 {
1165    if ((w) && (*w < (_elm_config->finger_size * times_w)))
1166      *w = _elm_config->finger_size * times_w;
1167    if ((h) && (*h < (_elm_config->finger_size * times_h)))
1168      *h = _elm_config->finger_size * times_h;
1169 }
1170
1171 /**
1172  * @defgroup Focus Focus
1173  *
1174  * Objects have focus. This is what determines where the keyboard input goes to
1175  * within the application window.
1176  */
1177
1178 /**
1179  * Get the focus of the object
1180  *
1181  * This gets the focused property of the object.
1182  *
1183  * @param obj The object
1184  * @return 1 if the object is focused, 0 if not.
1185  * @ingroup Focus
1186  */
1187 EAPI Eina_Bool
1188 elm_object_focus_get(Evas_Object *obj)
1189 {
1190    return elm_widget_focus_get(obj);
1191 }
1192
1193 /**
1194  * Set the focus to the object
1195  *
1196  * This sets the focus target for keyboard input to be the object indicated.
1197  *
1198  * @param obj The object
1199  * @ingroup Focus
1200  */
1201 EAPI void
1202 elm_object_focus(Evas_Object *obj)
1203 {
1204    if (!elm_widget_can_focus_get(obj)) return;
1205    elm_widget_focus_steal(obj);
1206 }
1207
1208 /**
1209  * Remove the focus from the object
1210  *
1211  * This removes the focus target for keyboard input from be the object
1212  * indicated.
1213  *
1214  * @param obj The object
1215  * @ingroup Focus
1216  */
1217 EAPI void
1218 elm_object_unfocus(Evas_Object *obj)
1219 {
1220    if (!elm_widget_can_focus_get(obj)) return;
1221    elm_widget_focused_object_clear(obj);
1222 }
1223
1224 /**
1225  * Set the ability for the object to focus
1226  *
1227  * This sets the ability for the object to be able to get keyboard focus or
1228  * not. By default all objects are able to be focused.
1229  *
1230  * @param obj The object
1231  * @param enable 1 if the object can be focused, 0 if not
1232  * @ingroup Focus
1233  */
1234 EAPI void
1235 elm_object_focus_allow_set(Evas_Object *obj, Eina_Bool enable)
1236 {
1237    elm_widget_can_focus_set(obj, enable);
1238 }
1239
1240 /**
1241  * Get the ability for the object to focus
1242  *
1243  * This gets the ability for the object to be able to get keyboard focus or
1244  * not. By default all objects are able to be focused.
1245  *
1246  * @param obj The object
1247  * @return 1 if the object is allowed to be focused, 0 if not.
1248  * @ingroup Focus
1249  */
1250 EAPI Eina_Bool
1251 elm_object_focus_allow_get(const Evas_Object *obj)
1252 {
1253    return elm_widget_can_focus_get(obj);
1254 }
1255
1256 /**
1257  * @defgroup Scrollhints Scrollhints
1258  *
1259  * Objects when inside a scroller can scroll, but this may not always be
1260  * desireable in certain situations. This allows an object to hint to itself
1261  * and parents to "not scroll" in one of 2 ways.
1262  *
1263  * 1. To hold on scrolling. This means just flicking and dragging may no
1264  * longer scroll, but pressing/dragging near an edge of the scroller will
1265  * still scroll. This is automastically used by the entry object when
1266  * selecting text.
1267  * 2. To totally freeze scrolling. This means it stops. until popped/released.
1268  */
1269
1270 /**
1271  * Push the scroll hold by 1
1272  *
1273  * This increments the scroll hold count by one. If it is more than 0 it will
1274  * take effect on the parents of the indicated object.
1275  *
1276  * @param obj The object
1277  * @ingroup Scrollhints
1278  */
1279 EAPI void
1280 elm_object_scroll_hold_push(Evas_Object *obj)
1281 {
1282    elm_widget_scroll_hold_push(obj);
1283 }
1284
1285 /**
1286  * Pop the scroll hold by 1
1287  *
1288  * This decrements the scroll hold count by one. If it is more than 0 it will
1289  * take effect on the parents of the indicated object.
1290  *
1291  * @param obj The object
1292  * @ingroup Scrollhints
1293  */
1294 EAPI void
1295 elm_object_scroll_hold_pop(Evas_Object *obj)
1296 {
1297    elm_widget_scroll_hold_pop(obj);
1298 }
1299
1300 /**
1301  * Push the scroll freeze by 1
1302  *
1303  * This increments the scroll freeze count by one. If it is more than 0 it will
1304  * take effect on the parents of the indicated object.
1305  *
1306  * @param obj The object
1307  * @ingroup Scrollhints
1308  */
1309 EAPI void
1310 elm_object_scroll_freeze_push(Evas_Object *obj)
1311 {
1312    elm_widget_scroll_freeze_push(obj);
1313 }
1314
1315 /**
1316  * Lock the scrolling of the given widget (and thus all parents)
1317  *
1318  * This locks the given object from scrolling in the X axis (and implicitly
1319  * also locks all parent scrollers too from doing the same).
1320  *
1321  * @param obj The object
1322  * @param lock The lock state (1 == locked, 0 == unlocked)
1323  * @ingroup Scrollhints
1324  */
1325 EAPI void
1326 elm_object_scroll_lock_x_set(Evas_Object *obj, Eina_Bool lock)
1327 {
1328    elm_widget_drag_lock_x_set(obj, lock);
1329 }
1330
1331 /**
1332  * Lock the scrolling of the given widget (and thus all parents)
1333  *
1334  * This locks the given object from scrolling in the Y axis (and implicitly
1335  * also locks all parent scrollers too from doing the same).
1336  *
1337  * @param obj The object
1338  * @param lock The lock state (1 == locked, 0 == unlocked)
1339  * @ingroup Scrollhints
1340  */
1341 EAPI void
1342 elm_object_scroll_lock_y_set(Evas_Object *obj, Eina_Bool lock)
1343 {
1344    elm_widget_drag_lock_y_set(obj, lock);
1345 }
1346
1347 /**
1348  * Get the scrolling lock of the given widget
1349  *
1350  * This gets the lock for X axis scrolling.
1351  *
1352  * @param obj The object
1353  * @ingroup Scrollhints
1354  */
1355 EAPI Eina_Bool
1356 elm_object_scroll_lock_x_get(const Evas_Object *obj)
1357 {
1358    return elm_widget_drag_lock_x_get(obj);
1359 }
1360
1361 /**
1362  * Get the scrolling lock of the given widget
1363  *
1364  * This gets the lock for X axis scrolling.
1365  *
1366  * @param obj The object
1367  * @ingroup Scrollhints
1368  */
1369 EAPI Eina_Bool
1370 elm_object_scroll_lock_y_get(const Evas_Object *obj)
1371 {
1372    return elm_widget_drag_lock_y_get(obj);
1373 }
1374
1375 /**
1376  * Pop the scroll freeze by 1
1377  *
1378  * This decrements the scroll freeze count by one. If it is more than 0 it will
1379  * take effect on the parents of the indicated object.
1380  *
1381  * @param obj The object
1382  * @ingroup Scrollhints
1383  */
1384 EAPI void
1385 elm_object_scroll_freeze_pop(Evas_Object *obj)
1386 {
1387    elm_widget_scroll_freeze_pop(obj);
1388 }
1389
1390
1391 /**
1392  * Check if the given Evas Object is an Elementary widget.
1393  *
1394  * @param obj the object to query.
1395  * @return @c EINA_TRUE if it is an elementary widget variant,
1396  *         @c EINA_FALSE otherwise
1397  */
1398 EAPI Eina_Bool
1399 elm_object_widget_check(const Evas_Object *obj)
1400 {
1401    return elm_widget_is(obj);
1402 }
1403
1404 /**
1405  * Get the first parent of the given object that is an Elementary widget.
1406  *
1407  * @param obj the object to query.
1408  * @return the parent object that is an Elementary widget, or @c NULL
1409  *         if no parent is, or no parents at all.
1410  */
1411 EAPI Evas_Object *
1412 elm_object_parent_widget_get(const Evas_Object *obj)
1413 {
1414    return elm_widget_parent_widget_get(obj);
1415 }
1416
1417 /**
1418  * Get the string that represents this Elementary widget.
1419  *
1420  * @note Elementary is weird and exposes itself as a single
1421  *       Evas_Object_Smart_Class of type "elm_widget", so
1422  *       evas_object_type_get() always return that, making debug and
1423  *       language bindings hard. This function tries to mitigate this
1424  *       problem, but the solution is to change Elementary to use
1425  *       proper inheritance.
1426  *
1427  * @param obj the object to query.
1428  * @return Elementary widget name, or @c NULL if not a valid widget.
1429  */
1430 EAPI const char *
1431 elm_object_widget_type_get(const Evas_Object *obj)
1432 {
1433    return elm_widget_type_get(obj);
1434 }