2 # include "elementary_config.h"
9 #include <dlfcn.h> /* dlopen,dlclose,etc */
11 #ifdef HAVE_CRT_EXTERNS_H
12 # include <crt_externs.h>
19 #include <Elementary.h>
22 static Elm_Version _version = { VMAJ, VMIN, VMIC, VREV };
23 EAPI Elm_Version *elm_version = &_version;
28 * This group includes functions of elm_main.c
33 _elm_dangerous_call_check(const char *call)
38 snprintf(buf, sizeof(buf), "%i.%i.%i.%i", VMAJ, VMIN, VMIC, VREV);
39 eval = getenv("ELM_NO_FINGER_WAGGLING");
40 if ((eval) && (!strcmp(eval, buf)))
42 printf("ELEMENTARY FINGER WAGGLE!!!!!!!!!!\n"
45 "PLEASE see the API documentation for this function. This call\n"
46 "should almost never be used. Only in very special cases.\n"
48 "To remove this warning please set the environment variable:\n"
49 " ELM_NO_FINGER_WAGGLING\n"
50 "To the value of the Elementary version + revision number. e.g.:\n"
59 * @defgroup Start Getting Started
62 * To write an Elementary app, you can get started with the following:
65 * #include <Elementary.h>
66 * #ifndef ELM_LIB_QUICKLAUNCH
68 * elm_main(int argc, char **argv)
70 * // create window(s) here and do any application init
71 * elm_run(); // run main loop
72 * elm_shutdown(); // after mainloop finishes running, shutdown
73 * return 0; // exit 0 for exit code
79 * To take full advantage of the quicklaunch architecture for launching
80 * processes as quickly as possible (saving time at startup time like
81 * connecting to X11, loading and linking shared libraries) you may want to
82 * use the following configure.in/configure.ac and Makefile.am and autogen.sh
83 * script to generate your files. It is assumed your application uses the
84 * main.c file for its code.
86 * configure.in/configure.ac:
89 AC_INIT(myapp, 0.0.0, myname@mydomain.com)
91 AC_CONFIG_SRCDIR(configure.in)
93 AM_INIT_AUTOMAKE(1.6 dist-bzip2)
94 AM_CONFIG_HEADER(config.h)
104 define([AC_LIBTOOL_LANG_CXX_CONFIG], [:])dnl
105 define([AC_LIBTOOL_LANG_F77_CONFIG], [:])dnl
108 PKG_CHECK_MODULES([ELEMENTARY], elementary)
116 AUTOMAKE_OPTIONS = 1.4 foreign
117 MAINTAINERCLEANFILES = Makefile.in
119 INCLUDES = -I$(top_srcdir) @ELEMENTARY_CFLAGS@
122 myapp_LTLIBRARIES = myapp.la
126 myapp_la_SOURCES = main.c
127 myapp_la_LIBADD = @ELEMENTARY_LIBS@
129 myapp_la_LDFLAGS = -module -avoid-version -no-undefined
131 myapp_SOURCES = main.c
132 myapp_LDADD = @ELEMENTARY_LIBS@
133 myapp_CFLAGS = -DELM_LIB_QUICKLAUNCH=1
140 rm -rf autom4te.cache
141 rm -f aclocal.m4 ltmain.sh
146 echo "Running aclocal..." ; aclocal $ACLOCAL_FLAGS -I m4 || exit 1
147 echo "Running autoheader..." ; autoheader || exit 1
148 echo "Running autoconf..." ; autoconf || exit 1
149 echo "Running libtoolize..." ; (libtoolize --copy --automake || glibtoolize --automake) || exit 1
150 echo "Running automake..." ; automake --add-missing --copy --gnu || exit 1
152 if [ -z "$NOCONFIGURE" ]; then
157 * To gnerate all the things needed to bootstrap just run:
163 * This will generate Makefile.in's, the confgure script and everything else.
164 * After this it works like all normal autotools projects:
171 * Note sudo was assumed to get root permissions, as this would install in
172 * /usr/local which is system-owned. Ue any way you like to gain root, or
173 * specify a different prefix with configure:
176 ./confiugre --prefix=$HOME/mysoftware
179 * Also remember that autotools buys you some useful commands like:
184 * This uninstalls the software after it was installed with "make install".
185 * It is very useful to clear up what you built if you wish to clean the
192 * This firstly checks if your build tree is "clean" and ready for
193 * distribution. It also builds a tarball (myapp-0.0.0.tar.gz) that is
194 * ready to upload and distribute to the world, that contains the generated
195 * Makefile.in's and configure script. The users do not need to run
196 * autogen.sh - just configure and on. They don't need autotools installed.
197 * This tarball also builds cleanly, has all the sources it needs to build
198 * included (that is sources for your application, not libraries it depends
199 * on like Elementary). It builds cleanly in a buildroot and does not
200 * contain any files that are temporarily generated like binaries and other
201 * build-gnerated files, so the tarball is clean, and no need to worry
202 * about cleaning up your tree before packaging.
208 * This cleans up all build files (binaries, objects etc.) from the tree.
214 * This cleans out all files from the build and from configure's output too.
217 make maintainer-clean
220 * This deletes all the files autogen.sh will produce so the tree is clean
221 * to be put into a revision-control system (like CVS, SVN or GIT for example).
223 * The above will build a library - libmyapp.so and install in the target
224 * library directory (default is /usr/local/lib). You will also get a
225 * myapp.a and myapp.la - these are useless and can be deleted. Libtool likes
226 * to generate these all the time. You will also get a binary in the target
227 * binary directory (default is /usr/local/bin). This is a "debug binary".
228 * This will run and dlopen() the myapp.so and then jump to it's elm_main
229 * function. This allows for easy debugging with GDB and Valgrind. When you
230 * are ready to go to production do the following:
232 * 1. delete the myapp binary. i.e. rm /usr/local/bin/myapp
234 * 2. symlink the myapp binary to elementary_run (supplied by elementary).
235 * i.e. ln -s elmentary_run /usr/local/bin/myapp
237 * 3. run elementary_quicklaunch as part of your graphical login session and
240 * This will man elementary_quicklaunch does pre-initialization before the
241 * application needs to be run, saving the effort at the time the application
242 * is needed, thus speeding up the time it takes to appear.
244 * If you don't want to use the quicklaunch infrastructure (which is
245 * optional), you can execute the old fashioned way by just running the
246 * myapp binary loader than will load the myapp.so for you, or you can
247 * remove the split-file binary and put it into one binary as things always
248 * have been with the following configure.in/configure.ac and Makfile.am
251 * configure.in/configure.ac:
254 AC_INIT(myapp, 0.0.0, myname@mydomain.com)
256 AC_CONFIG_SRCDIR(configure.in)
258 AM_INIT_AUTOMAKE(1.6 dist-bzip2)
259 AM_CONFIG_HEADER(config.h)
268 PKG_CHECK_MODULES([ELEMENTARY], elementary)
276 AUTOMAKE_OPTIONS = 1.4 foreign
277 MAINTAINERCLEANFILES = Makefile.in
279 INCLUDES = -I$(top_srcdir) @ELEMENTARY_CFLAGS@
283 myapp_SOURCES = main.c
284 myapp_LDADD = @ELEMENTARY_LIBS@
288 * Notice that they are the same as before, just with libtool and library
289 * building sections removed. Both ways work for building elementary
290 * applications. It is up to you to decide what is best for you. If you just
291 * follow the template above, you can do it both ways and can decide at build
292 * time. The more advanced of you may suggest making it a configure option.
293 * That is perfectly valid, but has been left out here for simplicity, as our
294 * aim to have an Elementary (and EFL) tutorial, not an autoconf & automake
299 static Eina_Bool _elm_signal_exit(void *data, int ev_type, void *ev);
301 char *_elm_appname = NULL;
302 const char *_elm_data_dir = NULL;
303 const char *_elm_lib_dir = NULL;
304 int _elm_log_dom = -1;
306 EAPI int ELM_EVENT_POLICY_CHANGED = 0;
308 static int _elm_init_count = 0;
309 static int _elm_policies[ELM_POLICY_LAST];
310 static Ecore_Event_Handler *_elm_exit_handler = NULL;
313 _elm_signal_exit(void *data __UNUSED__, int ev_type __UNUSED__, void *ev __UNUSED__)
316 return ECORE_CALLBACK_PASS_ON;
322 edje_scale_set(_elm_config->scale);
326 static Eina_List *widtypes = NULL;
329 _elm_widtype_register(const char **ptr)
331 widtypes = eina_list_append(widtypes, (void *)ptr);
335 _elm_widtype_clear(void)
339 EINA_LIST_FREE(widtypes, ptr)
341 eina_stringshare_del(*ptr);
347 * @defgroup General General
352 * Inititalise Elementary
354 * This call is exported only for use by the ELM_MAIN() macro. There is no
355 * need to use this if you use this macro (which is highly advisable).
359 elm_init(int argc, char **argv)
362 if (_elm_init_count != 1) return;
363 elm_quicklaunch_init(argc, argv);
364 elm_quicklaunch_sub_init(argc, argv);
368 * Shut down Elementary
370 * This should be called at the end of your application just before it ceases
371 * to do any more processing. This will clean up any permanent resources your
372 * application may have allocated via Elementary that would otherwise persist
373 * on an exit without this call.
380 if (_elm_init_count != 0) return;
381 elm_quicklaunch_sub_shutdown();
382 elm_quicklaunch_shutdown();
386 static Eina_Bool _elm_need_e_dbus = EINA_FALSE;
389 elm_need_e_dbus(void)
392 if (_elm_need_e_dbus) return;
393 _elm_need_e_dbus = 1;
400 _elm_unneed_e_dbus(void)
403 if (_elm_need_e_dbus)
405 _elm_need_e_dbus = 0;
413 static Eina_Bool _elm_need_efreet = EINA_FALSE;
416 elm_need_efreet(void)
419 if (_elm_need_efreet) return;
420 _elm_need_efreet = 1;
428 list = efreet_icon_extra_list_get();
431 e_user_dir_concat_static(buf, "icons");
432 *list = eina_list_prepend(*list, (void *)eina_stringshare_add(buf));
433 e_prefix_data_concat_static(buf, "data/icons");
434 *list = eina_list_prepend(*list, (void *)eina_stringshare_add(buf));
442 _elm_unneed_efreet(void)
445 if (_elm_need_efreet)
447 _elm_need_efreet = 0;
448 efreet_trash_shutdown();
449 efreet_mime_shutdown();
456 elm_quicklaunch_init(int argc, char **argv)
458 char buf[PATH_MAX], *s;
461 _elm_log_dom = eina_log_domain_register("elementary", EINA_COLOR_LIGHTBLUE);
464 EINA_LOG_ERR("could not register elementary log domain.");
465 _elm_log_dom = EINA_LOG_DOMAIN_GLOBAL;
470 ecore_app_args_set(argc, (const char **)argv);
472 memset(_elm_policies, 0, sizeof(_elm_policies));
473 if (ELM_EVENT_POLICY_CHANGED == 0)
474 ELM_EVENT_POLICY_CHANGED = ecore_event_type_new();
479 ecore_evas_init(); // FIXME: check errors
483 _elm_exit_handler = ecore_event_handler_add(ECORE_EVENT_SIGNAL_EXIT, _elm_signal_exit, NULL);
485 if (argv) _elm_appname = strdup(ecore_file_file_get(argv[0]));
489 s = getenv("ELM_DATA_DIR");
490 _elm_data_dir = eina_stringshare_add(s);
494 s = getenv("ELM_PREFIX");
497 snprintf(buf, sizeof(buf), "%s/share/elementary", s);
498 _elm_data_dir = eina_stringshare_add(buf);
503 s = getenv("ELM_LIB_DIR");
504 _elm_lib_dir = eina_stringshare_add(s);
508 s = getenv("ELM_PREFIX");
511 snprintf(buf, sizeof(buf), "%s/lib", s);
512 _elm_lib_dir = eina_stringshare_add(buf);
516 if ((!_elm_data_dir) || (!_elm_lib_dir))
518 Dl_info elementary_dl;
519 // libelementary.so/../../share/elementary/
520 if (dladdr(elm_init, &elementary_dl))
524 dir = ecore_file_dir_get(elementary_dl.dli_fname);
529 if (ecore_file_is_dir(dir))
530 _elm_lib_dir = eina_stringshare_add(dir);
534 dir2 = ecore_file_dir_get(dir);
537 snprintf(buf, sizeof(buf), "%s/share/elementary", dir2);
538 if (ecore_file_is_dir(buf))
539 _elm_data_dir = eina_stringshare_add(buf);
549 _elm_data_dir = eina_stringshare_add(PACKAGE_DATA_DIR);
551 _elm_data_dir = eina_stringshare_add("/");
553 _elm_lib_dir = eina_stringshare_add(PACKAGE_LIB_DIR);
555 _elm_lib_dir = eina_stringshare_add("/");
561 elm_quicklaunch_sub_init(int argc, char **argv)
563 ecore_app_args_set(argc, (const char **)argv);
564 _elm_config_sub_init();
568 elm_quicklaunch_sub_shutdown(void)
571 if ((_elm_config->engine == ELM_SOFTWARE_X11) ||
572 (_elm_config->engine == ELM_SOFTWARE_16_X11) ||
573 (_elm_config->engine == ELM_XRENDER_X11) ||
574 (_elm_config->engine == ELM_OPENGL_X11) ||
575 (_elm_config->engine == ELM_SOFTWARE_SDL) ||
576 (_elm_config->engine == ELM_SOFTWARE_16_SDL) ||
577 (_elm_config->engine == ELM_OPENGL_SDL) ||
578 (_elm_config->engine == ELM_SOFTWARE_WIN32) ||
579 (_elm_config->engine == ELM_SOFTWARE_16_WINCE))
581 #ifdef HAVE_ELEMENTARY_X
582 ecore_x_disconnect();
584 evas_cserve_disconnect();
589 elm_quicklaunch_shutdown(void)
591 eina_stringshare_del(_elm_data_dir);
592 _elm_data_dir = NULL;
593 eina_stringshare_del(_elm_lib_dir);
599 _elm_config_shutdown();
601 ecore_event_handler_del(_elm_exit_handler);
602 _elm_exit_handler = NULL;
604 _elm_theme_shutdown();
605 _elm_unneed_efreet();
606 _elm_unneed_e_dbus();
607 _elm_unneed_ethumb();
608 _elm_module_shutdown();
609 ecore_imf_shutdown();
610 ecore_evas_shutdown();
613 ecore_file_shutdown();
617 if ((_elm_log_dom > -1) && (_elm_log_dom != EINA_LOG_DOMAIN_GLOBAL))
619 eina_log_domain_unregister(_elm_log_dom);
623 _elm_widtype_clear();
629 elm_quicklaunch_seed(void)
631 Evas_Object *win, *bg, *bt;
633 win = elm_win_add(NULL, "seed", ELM_WIN_BASIC);
634 bg = elm_bg_add(win);
635 elm_win_resize_object_add(win, bg);
636 evas_object_show(bg);
637 bt = elm_button_add(win);
638 elm_button_label_set(bt, " abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789~-_=+\\|]}[{;:'\",<.>/?");
639 elm_win_resize_object_add(win, bt);
640 ecore_main_loop_iterate();
641 evas_object_del(win);
642 ecore_main_loop_iterate();
643 if ((_elm_config->engine == ELM_SOFTWARE_X11) ||
644 (_elm_config->engine == ELM_SOFTWARE_16_X11) ||
645 (_elm_config->engine == ELM_XRENDER_X11) ||
646 (_elm_config->engine == ELM_OPENGL_X11))
648 #ifdef HAVE_ELEMENTARY_X
652 ecore_main_loop_iterate();
655 static void *qr_handle = NULL;
656 static int (*qr_main) (int argc, char **argv) = NULL;
659 elm_quicklaunch_prepare(int argc __UNUSED__, char **argv)
662 char *exe = elm_quicklaunch_exe_path_get(argv[0]);
665 ERR("requested quicklaunch binary '%s' does not exist\n", argv[0]);
673 exe2 = malloc(strlen(exe) + 1 + 10);
675 p = strrchr(exe2, '/');
678 exename = alloca(strlen(p) + 1);
681 strcat(p, "../lib/");
684 if (access(exe2, R_OK | X_OK) == 0)
692 qr_handle = dlopen(exe, RTLD_NOW | RTLD_GLOBAL);
695 fprintf(stderr, "dlerr: %s\n", dlerror());
696 WRN("dlopen('%s') failed: %s", exe, dlerror());
700 INF("dlopen('%s') = %p", exe, qr_handle);
702 qr_main = dlsym(qr_handle, "elm_main");
703 INF("dlsym(%p, 'elm_main') = %p", qr_handle, qr_main);
706 WRN("not quicklauncher capable: no elm_main in '%s'", exe);
722 extern char **environ;
727 for (i = 0, size = 0; environ[i]; i++)
728 size += strlen(environ[i]) + 1;
730 p = malloc((i + 1) * sizeof(char *));
735 for (i = 0; oldenv[i]; i++)
736 environ[i] = strdup(oldenv[i]);
742 elm_quicklaunch_fork(int argc, char **argv, char *cwd, void (postfork_func) (void *data), void *postfork_data)
751 // need to accept current environment from elementary_run
758 if (child > 0) return EINA_TRUE;
761 perror("could not fork");
766 perror("could not chdir");
767 args = alloca((argc + 1) * sizeof(char *));
768 for (i = 0; i < argc; i++) args[i] = argv[i];
770 WRN("%s not quicklaunch capable, fallback...", argv[0]);
771 execvp(argv[0], args);
772 ERR("failed to execute '%s': %s", argv[0], strerror(errno));
776 if (child > 0) return EINA_TRUE;
779 perror("could not fork");
782 if (postfork_func) postfork_func(postfork_data);
786 perror("could not chdir");
787 // FIXME: this is very linux specific. it changes argv[0] of the process
788 // so ps etc. report what you'd expect. for other unixes and os's this
795 ecore_app_args_get(&real_argc, &real_argv);
796 lastarg = real_argv[real_argc - 1] + strlen(real_argv[real_argc - 1]);
797 for (p = real_argv[0]; p < lastarg; p++) *p = 0;
798 strcpy(real_argv[0], argv[0]);
800 ecore_app_args_set(argc, (const char **)argv);
801 ret = qr_main(argc, argv);
810 elm_quicklaunch_cleanup(void)
823 elm_quicklaunch_fallback(int argc, char **argv)
826 elm_quicklaunch_init(argc, argv);
827 elm_quicklaunch_sub_init(argc, argv);
828 elm_quicklaunch_prepare(argc, argv);
829 ret = qr_main(argc, argv);
835 elm_quicklaunch_exe_path_get(const char *exe)
837 static char *path = NULL;
838 static Eina_List *pathlist = NULL;
842 if (exe[0] == '/') return strdup(exe);
843 if ((exe[0] == '.') && (exe[1] == '/')) return strdup(exe);
844 if ((exe[0] == '.') && (exe[1] == '.') && (exe[2] == '/')) return strdup(exe);
849 path = getenv("PATH");
850 buf2 = alloca(strlen(path) + 1);
855 if ((*p == ':') || (*p == 0))
860 strncpy(buf2, pp, len);
862 pathlist = eina_list_append(pathlist, eina_stringshare_add(buf2));
874 EINA_LIST_FOREACH(pathlist, l, pathitr)
876 snprintf(buf, sizeof(buf), "%s/%s", pathitr, exe);
877 if (access(buf, R_OK | X_OK) == 0) return strdup(buf);
885 * This call should be called just after all initialization is complete. This
886 * function will not return until elm_exit() is called. It will keep looping
887 * running the main event/processing loop for Elementary.
893 ecore_main_loop_begin();
899 * If this call is called, it will flag the main loop to cease processing and
900 * return back to its parent function.
906 ecore_main_loop_quit();
911 * Set new policy value.
913 * This will emit the ecore event ELM_EVENT_POLICY_CHANGED in the main
914 * loop giving the event information Elm_Event_Policy_Changed with
915 * policy identifier, new and old values.
917 * @param policy policy identifier as in Elm_Policy.
918 * @param value policy value, depends on identifiers, usually there is
919 * an enumeration with the same prefix as the policy name, for
920 * example: ELM_POLICY_QUIT and Elm_Policy_Quit
921 * (ELM_POLICY_QUIT_NONE, ELM_POLICY_QUIT_LAST_WINDOW_CLOSED).
923 * @return @c EINA_TRUE on success or @c EINA_FALSE on error (right
924 * now just invalid policy identifier, but in future policy
925 * value might be enforced).
928 elm_policy_set(unsigned int policy, int value)
930 Elm_Event_Policy_Changed *ev;
932 if (policy >= ELM_POLICY_LAST)
935 if (value == _elm_policies[policy])
938 /* TODO: validade policy? */
940 ev = malloc(sizeof(*ev));
942 ev->new_value = value;
943 ev->old_value = _elm_policies[policy];
945 _elm_policies[policy] = value;
947 ecore_event_add(ELM_EVENT_POLICY_CHANGED, ev, NULL, NULL);
953 * Gets the policy value set for given identifier.
955 * @param policy policy identifier as in Elm_Policy.
957 * @return policy value. Will be 0 if policy identifier is invalid.
960 elm_policy_get(unsigned int policy)
962 if (policy >= ELM_POLICY_LAST)
964 return _elm_policies[policy];
968 * Flush all caches & dump all data that can be to lean down to use less memory
976 EINA_LIST_FOREACH(_elm_win_list, l, obj)
978 Evas *e = evas_object_evas_get(obj);
979 edje_file_cache_flush();
980 edje_collection_cache_flush();
981 evas_image_cache_flush(e);
982 evas_font_cache_flush(e);
988 * @defgroup Scaling Selective Widget Scaling
991 * Different widgets can be scaled independently. These functions allow you to
992 * manipulate this scaling on a per-widget basis. The object and all its
993 * children get their scaling factors multiplied by the scale factor set.
994 * This is multiplicative, in that if a child also has a scale size set it is
995 * in turn multiplied by its parent's scale size. 1.0 means “don't scale”,
996 * 2.0 is double size, 0.5 is half etc.
1000 * Set the scaling factor
1002 * @param obj The object
1003 * @param scale Scale factor (from 0.0 up, with 1.0 == no scaling)
1007 elm_object_scale_set(Evas_Object *obj, double scale)
1009 elm_widget_scale_set(obj, scale);
1013 * Get the scaling factor
1015 * @param obj The object
1016 * @return The scaling factor set by elm_object_scale_set()
1020 elm_object_scale_get(const Evas_Object *obj)
1022 return elm_widget_scale_get(obj);
1026 * @defgroup Styles Styles
1029 * Widgets can have different styles of look. These generic API's set
1030 * styles of widgets, if they support them (and if the theme(s) do).
1036 * This sets the name of the style
1037 * @param obj The object
1038 * @param style The style name to use
1042 elm_object_style_set(Evas_Object *obj, const char *style)
1044 elm_widget_style_set(obj, style);
1050 * This gets the style being used for that widget. Note that the string
1051 * pointer is only valid as longas the object is valid and the style doesn't
1054 * @param obj The object
1055 * @return The style name
1059 elm_object_style_get(const Evas_Object *obj)
1061 return elm_widget_style_get(obj);
1065 * Set the disable state
1067 * This sets the disable state for the widget.
1069 * @param obj The object
1070 * @param disabled The state
1074 elm_object_disabled_set(Evas_Object *obj, Eina_Bool disabled)
1076 elm_widget_disabled_set(obj, disabled);
1080 * Get the disable state
1082 * This gets the disable state for the widget.
1084 * @param obj The object
1085 * @return True, if the widget is disabled
1089 elm_object_disabled_get(const Evas_Object *obj)
1091 return elm_widget_disabled_get(obj);
1095 * Get the global scaling factor
1097 * This gets the globally configured scaling factor that is applied to all
1100 * @return The scaling factor
1106 return _elm_config->scale;
1110 * Set the global scaling factor
1112 * This sets the globally configured scaling factor that is applied to all
1115 * @param scale The scaling factor to set
1119 elm_scale_set(double scale)
1121 if (_elm_config->scale == scale) return;
1122 _elm_config->scale = scale;
1127 * Set the global scaling factor for all applications on the display
1129 * This sets the globally configured scaling factor that is applied to all
1130 * objects for all applications.
1131 * @param scale The scaling factor to set
1135 elm_scale_all_set(double scale)
1137 #ifdef HAVE_ELEMENTARY_X
1138 static Ecore_X_Atom atom = 0;
1139 unsigned int scale_i = (unsigned int)(scale * 1000.0);
1141 if (!atom) atom = ecore_x_atom_get("ENLIGHTENMENT_SCALE");
1142 ecore_x_window_prop_card32_set(ecore_x_window_root_first_get(),
1148 * @defgroup Fingers Fingers
1151 * Elementary is designed to be finger-friendly for touchscreens, and so in
1152 * addition to scaling for display resolution, it can also scale based on
1153 * finger "resolution" (or size).
1157 * Get the configured finger size
1159 * This gets the globally configured finger size in pixels
1161 * @return The finger size
1165 elm_finger_size_get(void)
1167 return _elm_config->finger_size;
1171 * Set the configured finger size
1173 * This sets the globally configured finger size in pixels
1175 * @param size The finger size
1179 elm_finger_size_set(Evas_Coord size)
1181 if (_elm_config->finger_size == size) return;
1182 _elm_config->finger_size = size;
1187 * Set the configured finger size for all applications on the display
1189 * This sets the globally configured finger size in pixels for all applications
1192 * @param size The finger size
1196 elm_finger_size_all_set(Evas_Coord size)
1198 #ifdef HAVE_ELEMENTARY_X
1199 static Ecore_X_Atom atom = 0;
1200 unsigned int size_i = (unsigned int)size;
1202 if (!atom) atom = ecore_x_atom_get("ENLIGHTENMENT_FINGER_SIZE");
1203 ecore_x_window_prop_card32_set(ecore_x_window_root_first_get(),
1209 elm_autocapitalization_allow_all_set(Eina_Bool on)
1211 #ifdef HAVE_ELEMENTARY_X
1212 static Ecore_X_Atom atom = 0;
1213 unsigned int on_i = (unsigned int)on;
1215 if (!atom) atom = ecore_x_atom_get("ENLIGHTENMENT_AUTOCAPITAL_ALLOW");
1216 ecore_x_window_prop_card32_set(ecore_x_window_root_first_get(),
1222 elm_autoperiod_allow_all_set(Eina_Bool on)
1224 #ifdef HAVE_ELEMENTARY_X
1225 static Ecore_X_Atom atom = 0;
1226 unsigned int on_i = (unsigned int)on;
1228 if (!atom) atom = ecore_x_atom_get("ENLIGHTENMENT_AUTOPERIOD_ALLOW");
1229 ecore_x_window_prop_card32_set(ecore_x_window_root_first_get(),
1236 * Adjust size of an element for finger usage
1238 * This takes width and height sizes (in pixels) as input and a size multiple
1239 * (which is how many fingers you want to place within the area), and adjusts
1240 * the size tobe large enough to accomodate finger. On return the w and h
1241 * sizes poiner do by these parameters will be modified.
1243 * @param times_w How many fingers should fit horizontally
1244 * @param w Pointer to the width size to adjust
1245 * @param times_h How many fingers should fit vertically
1246 * @param h Pointer to the height size to adjust
1250 elm_coords_finger_size_adjust(int times_w, Evas_Coord *w, int times_h, Evas_Coord *h)
1252 if ((w) && (*w < (_elm_config->finger_size * times_w)))
1253 *w = _elm_config->finger_size * times_w;
1254 if ((h) && (*h < (_elm_config->finger_size * times_h)))
1255 *h = _elm_config->finger_size * times_h;
1259 * @defgroup Focus Focus
1262 * Objects have focus. This is what determines where the keyboard input goes to
1263 * within the application window.
1267 * Get the focus of the object
1269 * This gets the focused property of the object.
1271 * @param obj The object
1272 * @return 1 if the object is focused, 0 if not.
1276 elm_object_focus_get(Evas_Object *obj)
1278 return elm_widget_focus_get(obj);
1282 * Set the focus to the object
1284 * This sets the focus target for keyboard input to be the object indicated.
1286 * @param obj The object
1290 elm_object_focus(Evas_Object *obj)
1292 if (!elm_widget_can_focus_get(obj)) return;
1293 elm_widget_focus_steal(obj);
1297 * Remove the focus from the object
1299 * This removes the focus target for keyboard input from be the object
1302 * @param obj The object
1306 elm_object_unfocus(Evas_Object *obj)
1308 if (!elm_widget_can_focus_get(obj)) return;
1309 elm_widget_focused_object_clear(obj);
1313 * Set the ability for the object to focus
1315 * This sets the ability for the object to be able to get keyboard focus or
1316 * not. By default all objects are able to be focused.
1318 * @param obj The object
1319 * @param enable 1 if the object can be focused, 0 if not
1323 elm_object_focus_allow_set(Evas_Object *obj, Eina_Bool enable)
1325 elm_widget_can_focus_set(obj, enable);
1329 * Get the ability for the object to focus
1331 * This gets the ability for the object to be able to get keyboard focus or
1332 * not. By default all objects are able to be focused.
1334 * @param obj The object
1335 * @return 1 if the object is allowed to be focused, 0 if not.
1339 elm_object_focus_allow_get(const Evas_Object *obj)
1341 return elm_widget_can_focus_get(obj);
1345 * @defgroup Scrollhints Scrollhints
1348 * Objects when inside a scroller can scroll, but this may not always be
1349 * desireable in certain situations. This allows an object to hint to itself
1350 * and parents to "not scroll" in one of 2 ways.
1352 * 1. To hold on scrolling. This means just flicking and dragging may no
1353 * longer scroll, but pressing/dragging near an edge of the scroller will
1354 * still scroll. This is automastically used by the entry object when
1356 * 2. To totally freeze scrolling. This means it stops. until popped/released.
1360 * Push the scroll hold by 1
1362 * This increments the scroll hold count by one. If it is more than 0 it will
1363 * take effect on the parents of the indicated object.
1365 * @param obj The object
1366 * @ingroup Scrollhints
1369 elm_object_scroll_hold_push(Evas_Object *obj)
1371 elm_widget_scroll_hold_push(obj);
1375 * Pop the scroll hold by 1
1377 * This decrements the scroll hold count by one. If it is more than 0 it will
1378 * take effect on the parents of the indicated object.
1380 * @param obj The object
1381 * @ingroup Scrollhints
1384 elm_object_scroll_hold_pop(Evas_Object *obj)
1386 elm_widget_scroll_hold_pop(obj);
1390 * Push the scroll freeze by 1
1392 * This increments the scroll freeze count by one. If it is more than 0 it will
1393 * take effect on the parents of the indicated object.
1395 * @param obj The object
1396 * @ingroup Scrollhints
1399 elm_object_scroll_freeze_push(Evas_Object *obj)
1401 elm_widget_scroll_freeze_push(obj);
1405 * Lock the scrolling of the given widget (and thus all parents)
1407 * This locks the given object from scrolling in the X axis (and implicitly
1408 * also locks all parent scrollers too from doing the same).
1410 * @param obj The object
1411 * @param lock The lock state (1 == locked, 0 == unlocked)
1412 * @ingroup Scrollhints
1415 elm_object_scroll_lock_x_set(Evas_Object *obj, Eina_Bool lock)
1417 elm_widget_drag_lock_x_set(obj, lock);
1421 * Lock the scrolling of the given widget (and thus all parents)
1423 * This locks the given object from scrolling in the Y axis (and implicitly
1424 * also locks all parent scrollers too from doing the same).
1426 * @param obj The object
1427 * @param lock The lock state (1 == locked, 0 == unlocked)
1428 * @ingroup Scrollhints
1431 elm_object_scroll_lock_y_set(Evas_Object *obj, Eina_Bool lock)
1433 elm_widget_drag_lock_y_set(obj, lock);
1437 * Get the scrolling lock of the given widget
1439 * This gets the lock for X axis scrolling.
1441 * @param obj The object
1442 * @ingroup Scrollhints
1445 elm_object_scroll_lock_x_get(const Evas_Object *obj)
1447 return elm_widget_drag_lock_x_get(obj);
1451 * Get the scrolling lock of the given widget
1453 * This gets the lock for X axis scrolling.
1455 * @param obj The object
1456 * @ingroup Scrollhints
1459 elm_object_scroll_lock_y_get(const Evas_Object *obj)
1461 return elm_widget_drag_lock_y_get(obj);
1465 * Pop the scroll freeze by 1
1467 * This decrements the scroll freeze count by one. If it is more than 0 it will
1468 * take effect on the parents of the indicated object.
1470 * @param obj The object
1471 * @ingroup Scrollhints
1474 elm_object_scroll_freeze_pop(Evas_Object *obj)
1476 elm_widget_scroll_freeze_pop(obj);
1481 * Check if the given Evas Object is an Elementary widget.
1483 * @param obj the object to query.
1484 * @return @c EINA_TRUE if it is an elementary widget variant,
1485 * @c EINA_FALSE otherwise
1488 elm_object_widget_check(const Evas_Object *obj)
1490 return elm_widget_is(obj);
1494 * Get the first parent of the given object that is an Elementary widget.
1496 * @param obj the object to query.
1497 * @return the parent object that is an Elementary widget, or @c NULL
1498 * if no parent is, or no parents at all.
1501 elm_object_parent_widget_get(const Evas_Object *obj)
1503 return elm_widget_parent_widget_get(obj);
1507 * Get the top level parent of an Elementary widget.
1509 * @param obj The object to query.
1510 * @return The top level Elementary widget, or @c NULL if parent cannot be
1514 elm_object_top_widget_get(const Evas_Object *obj)
1516 return elm_widget_top_get(obj);
1520 * Get the string that represents this Elementary widget.
1522 * @note Elementary is weird and exposes itself as a single
1523 * Evas_Object_Smart_Class of type "elm_widget", so
1524 * evas_object_type_get() always return that, making debug and
1525 * language bindings hard. This function tries to mitigate this
1526 * problem, but the solution is to change Elementary to use
1527 * proper inheritance.
1529 * @param obj the object to query.
1530 * @return Elementary widget name, or @c NULL if not a valid widget.
1533 elm_object_widget_type_get(const Evas_Object *obj)
1535 return elm_widget_type_get(obj);
1539 * Send a signal to the widget edje object.
1541 * This function sends a signal to the edje object of the obj. An edje program
1542 * can respond to a signal by specifying matching 'signal' and
1545 * @param obj The object
1546 * @param emission The signal's name.
1547 * @param source The signal's source.
1550 EAPI void elm_object_signal_emit(Evas_Object *obj, const char *emission, const char *source)
1552 elm_widget_signal_emit(obj, emission, source);
1556 * Add a callback for a signal emitted by widget edje object.
1558 * This function connects a callback function to a signal emitted by the
1559 * edje object of the obj.
1560 * Globs can occur in either the emission or source name.
1562 * @param obj The object
1563 * @param emission The signal's name.
1564 * @param source The signal's source.
1565 * @param func The callback function to be executed when the signal is
1567 * @param data A pointer to data to pass in to the callback function.
1570 EAPI void elm_object_signal_callback_add(Evas_Object *obj, const char *emission, const char *source, void (*func) (void *data, Evas_Object *o, const char *emission, const char *source), void *data)
1572 elm_widget_signal_callback_add(obj, emission, source, func, data);
1576 * Remove a signal-triggered callback from an widget edje object.
1578 * This function removes a callback, previoulsy attached to a signal emitted
1579 * by the edje object of the obj.
1580 * The parameters emission, source and func must match exactly those passed to
1581 * a previous call to elm_object_signal_callback_add(). The data pointer that
1582 * was passed to this call will be returned.
1584 * @param obj The object
1585 * @param emission The signal's name.
1586 * @param source The signal's source.
1587 * @param func The callback function to be executed when the signal is
1589 * @return The data pointer
1592 EAPI void *elm_object_signal_callback_del(Evas_Object *obj, const char *emission, const char *source, void (*func) (void *data, Evas_Object *o, const char *emission, const char *source))
1594 return elm_widget_signal_callback_del(obj, emission, source, func);