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 * @defgroup Start Getting Started
36 * To write an Elementary app, you can get started with the following:
39 * #include <Elementary.h>
40 * #ifndef ELM_LIB_QUICKLAUNCH
42 * elm_main(int argc, char **argv)
44 * // create window(s) here and do any application init
45 * elm_run(); // run main loop
46 * elm_shutdown(); // after mainloop finishes running, shutdown
47 * return 0; // exit 0 for exit code
53 * To take full advantage of the quicklaunch architecture for launching
54 * processes as quickly as possible (saving time at startup time like
55 * connecting to X11, loading and linking shared libraries) you may want to
56 * use the following configure.in/configure.ac and Makefile.am and autogen.sh
57 * script to generate your files. It is assumed your application uses the
58 * main.c file for its code.
60 * configure.in/configure.ac:
63 AC_INIT(myapp, 0.0.0, myname@mydomain.com)
65 AC_CONFIG_SRCDIR(configure.in)
67 AM_INIT_AUTOMAKE(1.6 dist-bzip2)
68 AM_CONFIG_HEADER(config.h)
78 define([AC_LIBTOOL_LANG_CXX_CONFIG], [:])dnl
79 define([AC_LIBTOOL_LANG_F77_CONFIG], [:])dnl
82 PKG_CHECK_MODULES([ELEMENTARY], elementary)
90 AUTOMAKE_OPTIONS = 1.4 foreign
91 MAINTAINERCLEANFILES = Makefile.in
93 INCLUDES = -I$(top_srcdir) @ELEMENTARY_CFLAGS@
96 myapp_LTLIBRARIES = myapp.la
100 myapp_la_SOURCES = main.c
101 myapp_la_LIBADD = @ELEMENTARY_LIBS@
103 myapp_la_LDFLAGS = -module -avoid-version -no-undefined
105 myapp_SOURCES = main.c
106 myapp_LDADD = @ELEMENTARY_LIBS@
107 myapp_CFLAGS = -DELM_LIB_QUICKLAUNCH=1
114 rm -rf autom4te.cache
115 rm -f aclocal.m4 ltmain.sh
120 echo "Running aclocal..." ; aclocal $ACLOCAL_FLAGS -I m4 || exit 1
121 echo "Running autoheader..." ; autoheader || exit 1
122 echo "Running autoconf..." ; autoconf || exit 1
123 echo "Running libtoolize..." ; (libtoolize --copy --automake || glibtoolize --automake) || exit 1
124 echo "Running automake..." ; automake --add-missing --copy --gnu || exit 1
126 if [ -z "$NOCONFIGURE" ]; then
131 * To gnerate all the things needed to bootstrap just run:
137 * This will generate Makefile.in's, the confgure script and everything else.
138 * After this it works like all normal autotools projects:
145 * Note sudo was assumed to get root permissions, as this would install in
146 * /usr/local which is system-owned. Ue any way you like to gain root, or
147 * specify a different prefix with configure:
150 ./confiugre --prefix=$HOME/mysoftware
153 * Also remember that autotools buys you some useful commands like:
158 * This uninstalls the software after it was installed with "make install".
159 * It is very useful to clear up what you built if you wish to clean the
166 * This firstly checks if your build tree is "clean" and ready for
167 * distribution. It also builds a tarball (myapp-0.0.0.tar.gz) that is
168 * ready to upload and distribute to the world, that contains the generated
169 * Makefile.in's and configure script. The users do not need to run
170 * autogen.sh - just configure and on. They don't need autotools installed.
171 * This tarball also builds cleanly, has all the sources it needs to build
172 * included (that is sources for your application, not libraries it depends
173 * on like Elementary). It builds cleanly in a buildroot and does not
174 * contain any files that are temporarily generated like binaries and other
175 * build-gnerated files, so the tarball is clean, and no need to worry
176 * about cleaning up your tree before packaging.
182 * This cleans up all build files (binaries, objects etc.) from the tree.
188 * This cleans out all files from the build and from configure's output too.
191 make maintainer-clean
194 * This deletes all the files autogen.sh will produce so the tree is clean
195 * to be put into a revision-control system (like CVS, SVN or GIT for example).
197 * The above will build a library - libmyapp.so and install in the target
198 * library directory (default is /usr/local/lib). You will also get a
199 * myapp.a and myapp.la - these are useless and can be deleted. Libtool likes
200 * to generate these all the time. You will also get a binary in the target
201 * binary directory (default is /usr/local/bin). This is a "debug binary".
202 * This will run and dlopen() the myapp.so and then jump to it's elm_main
203 * function. This allows for easy debugging with GDB and Valgrind. When you
204 * are ready to go to production do the following:
206 * 1. delete the myapp binary. i.e. rm /usr/local/bin/myapp
208 * 2. symlink the myapp binary to elementary_run (supplied by elementary).
209 * i.e. ln -s elmentary_run /usr/local/bin/myapp
211 * 3. run elementary_quicklaunch as part of your graphical login session and
214 * This will man elementary_quicklaunch does pre-initialization before the
215 * application needs to be run, saving the effort at the time the application
216 * is needed, thus speeding up the time it takes to appear.
218 * If you don't want to use the quicklaunch infrastructure (which is
219 * optional), you can execute the old fashioned way by just running the
220 * myapp binary loader than will load the myapp.so for you, or you can
221 * remove the split-file binary and put it into one binary as things always
222 * have been with the following configure.in/configure.ac and Makfile.am
225 * configure.in/configure.ac:
228 AC_INIT(myapp, 0.0.0, myname@mydomain.com)
230 AC_CONFIG_SRCDIR(configure.in)
232 AM_INIT_AUTOMAKE(1.6 dist-bzip2)
233 AM_CONFIG_HEADER(config.h)
242 PKG_CHECK_MODULES([ELEMENTARY], elementary)
250 AUTOMAKE_OPTIONS = 1.4 foreign
251 MAINTAINERCLEANFILES = Makefile.in
253 INCLUDES = -I$(top_srcdir) @ELEMENTARY_CFLAGS@
257 myapp_SOURCES = main.c
258 myapp_LDADD = @ELEMENTARY_LIBS@
262 * Notice that they are the same as before, just with libtool and library
263 * building sections removed. Both ways work for building elementary
264 * applications. It is up to you to decide what is best for you. If you just
265 * follow the template above, you can do it both ways and can decide at build
266 * time. The more advanced of you may suggest making it a configure option.
267 * That is perfectly valid, bu has been left out here for simplicity, as our
268 * aim to have an Elementary (and EFL) tutorial, not an autoconf & automake
273 static int _elm_signal_exit(void *data, int ev_type, void *ev);
275 char *_elm_appname = NULL;
276 const char *_elm_data_dir = NULL;
277 const char *_elm_lib_dir = NULL;
278 int _elm_log_dom = -1;
280 EAPI int ELM_EVENT_POLICY_CHANGED = 0;
282 static int _elm_init_count = 0;
283 static int _elm_policies[ELM_POLICY_LAST];
284 static Ecore_Event_Handler *_elm_exit_handler = NULL;
287 _elm_signal_exit(void *data __UNUSED__, int ev_type __UNUSED__, void *ev __UNUSED__)
296 edje_scale_set(_elm_config->scale);
300 static Eina_List *widtypes = NULL;
303 _elm_widtype_register(const char **ptr)
305 widtypes = eina_list_append(widtypes, (void *)ptr);
309 _elm_widtype_clear(void)
313 EINA_LIST_FREE(widtypes, ptr)
315 eina_stringshare_del(*ptr);
320 // This code is just for temporary usage.
321 // This needs to be included into AUL avatar.
327 buf = getenv("ELM_THEME");
328 if (buf != NULL && ((!strcmp(buf, "beat") || !strcmp(buf, "kessler"))))
329 setenv("ELM_MODULES","ctxpopup_copypasteUI>entry/api",1);
333 * @defgroup General General
338 * Inititalise Elementary
340 * This call is exported only for use by the ELM_MAIN() macro. There is no
341 * need to use this if you use this macro (which is highly advisable).
345 elm_init(int argc, char **argv)
348 if (_elm_init_count != 1) return;
350 elm_quicklaunch_init(argc, argv);
351 elm_quicklaunch_sub_init(argc, argv);
355 * Shut down Elementary
357 * This should be called at the end of your application just before it ceases
358 * to do any more processing. This will clean up any permanent resources your
359 * application may have allocated via Elementary that would otherwise persist
360 * on an exit without this call.
367 if (_elm_init_count != 0) return;
368 elm_quicklaunch_sub_shutdown();
369 elm_quicklaunch_shutdown();
373 static Eina_Bool _elm_need_e_dbus = EINA_FALSE;
376 elm_need_e_dbus(void)
379 if (_elm_need_e_dbus) return;
380 _elm_need_e_dbus = 1;
387 _elm_unneed_e_dbus(void)
390 if (_elm_need_e_dbus)
392 _elm_need_e_dbus = 0;
400 static Eina_Bool _elm_need_efreet = EINA_FALSE;
403 elm_need_efreet(void)
406 if (_elm_need_efreet) return;
407 _elm_need_efreet = 1;
415 list = efreet_icon_extra_list_get();
418 e_user_dir_concat_static(buf, "icons");
419 *list = eina_list_prepend(*list, (void *)eina_stringshare_add(buf));
420 e_prefix_data_concat_static(buf, "data/icons");
421 *list = eina_list_prepend(*list, (void *)eina_stringshare_add(buf));
429 _elm_unneed_efreet(void)
432 if (_elm_need_efreet)
434 _elm_need_efreet = 0;
435 efreet_trash_shutdown();
436 efreet_mime_shutdown();
443 elm_quicklaunch_init(int argc, char **argv)
445 char buf[PATH_MAX], *s;
448 _elm_log_dom = eina_log_domain_register("elementary", EINA_COLOR_LIGHTBLUE);
451 EINA_LOG_ERR("could not register elementary log domain.");
452 _elm_log_dom = EINA_LOG_DOMAIN_GLOBAL;
457 ecore_app_args_set(argc, (const char **)argv);
459 memset(_elm_policies, 0, sizeof(_elm_policies));
460 if (ELM_EVENT_POLICY_CHANGED == 0)
461 ELM_EVENT_POLICY_CHANGED = ecore_event_type_new();
466 ecore_evas_init(); // FIXME: check errors
470 _elm_exit_handler = ecore_event_handler_add(ECORE_EVENT_SIGNAL_EXIT, _elm_signal_exit, NULL);
472 if (argv) _elm_appname = strdup(ecore_file_file_get(argv[0]));
476 s = getenv("ELM_DATA_DIR");
477 _elm_data_dir = eina_stringshare_add(s);
481 s = getenv("ELM_PREFIX");
484 snprintf(buf, sizeof(buf), "%s/share/elementary", s);
485 _elm_data_dir = eina_stringshare_add(buf);
490 s = getenv("ELM_LIB_DIR");
491 _elm_lib_dir = eina_stringshare_add(s);
495 s = getenv("ELM_PREFIX");
498 snprintf(buf, sizeof(buf), "%s/lib", s);
499 _elm_lib_dir = eina_stringshare_add(buf);
503 if ((!_elm_data_dir) || (!_elm_lib_dir))
505 Dl_info elementary_dl;
506 // libelementary.so/../../share/elementary/
507 if (dladdr(elm_init, &elementary_dl))
511 dir = ecore_file_dir_get(elementary_dl.dli_fname);
516 if (ecore_file_is_dir(dir))
517 _elm_lib_dir = eina_stringshare_add(dir);
521 dir2 = ecore_file_dir_get(dir);
524 snprintf(buf, sizeof(buf), "%s/share/elementary", dir2);
525 if (ecore_file_is_dir(buf))
526 _elm_data_dir = eina_stringshare_add(buf);
536 _elm_data_dir = eina_stringshare_add(PACKAGE_DATA_DIR);
538 _elm_data_dir = eina_stringshare_add("/");
540 _elm_lib_dir = eina_stringshare_add(PACKAGE_LIB_DIR);
542 _elm_lib_dir = eina_stringshare_add("/");
548 elm_quicklaunch_sub_init(int argc, char **argv)
550 ecore_app_args_set(argc, (const char **)argv);
551 _elm_config_sub_init();
555 elm_quicklaunch_sub_shutdown(void)
558 if ((_elm_config->engine == ELM_SOFTWARE_X11) ||
559 (_elm_config->engine == ELM_SOFTWARE_16_X11) ||
560 (_elm_config->engine == ELM_XRENDER_X11) ||
561 (_elm_config->engine == ELM_OPENGL_X11) ||
562 (_elm_config->engine == ELM_SOFTWARE_SDL) ||
563 (_elm_config->engine == ELM_SOFTWARE_16_SDL) ||
564 (_elm_config->engine == ELM_OPENGL_SDL) ||
565 (_elm_config->engine == ELM_SOFTWARE_WIN32) ||
566 (_elm_config->engine == ELM_SOFTWARE_16_WINCE))
568 #ifdef HAVE_ELEMENTARY_X
569 ecore_x_disconnect();
571 evas_cserve_disconnect();
576 elm_quicklaunch_shutdown(void)
578 eina_stringshare_del(_elm_data_dir);
579 _elm_data_dir = NULL;
580 eina_stringshare_del(_elm_lib_dir);
586 _elm_config_shutdown();
588 ecore_event_handler_del(_elm_exit_handler);
589 _elm_exit_handler = NULL;
591 _elm_theme_shutdown();
592 _elm_unneed_efreet();
593 _elm_unneed_e_dbus();
594 _elm_unneed_ethumb();
595 _elm_module_shutdown();
596 ecore_imf_shutdown();
597 ecore_evas_shutdown();
600 ecore_file_shutdown();
604 if ((_elm_log_dom > -1) && (_elm_log_dom != EINA_LOG_DOMAIN_GLOBAL))
606 eina_log_domain_unregister(_elm_log_dom);
610 _elm_widtype_clear();
616 elm_quicklaunch_seed(void)
618 Evas_Object *win, *bg, *bt;
620 win = elm_win_add(NULL, "seed", ELM_WIN_BASIC);
621 bg = elm_bg_add(win);
622 elm_win_resize_object_add(win, bg);
623 evas_object_show(bg);
624 bt = elm_button_add(win);
625 elm_button_label_set(bt, " abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789~-_=+\\|]}[{;:'\",<.>/?");
626 elm_win_resize_object_add(win, bt);
627 ecore_main_loop_iterate();
628 evas_object_del(win);
629 ecore_main_loop_iterate();
630 if ((_elm_config->engine == ELM_SOFTWARE_X11) ||
631 (_elm_config->engine == ELM_SOFTWARE_16_X11) ||
632 (_elm_config->engine == ELM_XRENDER_X11) ||
633 (_elm_config->engine == ELM_OPENGL_X11))
635 #ifdef HAVE_ELEMENTARY_X
639 ecore_main_loop_iterate();
642 static void *qr_handle = NULL;
643 static int (*qr_main) (int argc, char **argv) = NULL;
646 elm_quicklaunch_prepare(int argc __UNUSED__, char **argv)
649 char *exe = elm_quicklaunch_exe_path_get(argv[0]);
652 ERR("requested quicklaunch binary '%s' does not exist\n", argv[0]);
660 exe2 = malloc(strlen(exe) + 1 + 10);
662 p = strrchr(exe2, '/');
665 exename = alloca(strlen(p) + 1);
668 strcat(p, "../lib/");
671 if (access(exe2, R_OK | X_OK) == 0)
679 qr_handle = dlopen(exe, RTLD_NOW | RTLD_GLOBAL);
682 fprintf(stderr, "dlerr: %s\n", dlerror());
683 WRN("dlopen('%s') failed: %s", exe, dlerror());
687 INF("dlopen('%s') = %p", exe, qr_handle);
689 qr_main = dlsym(qr_handle, "elm_main");
690 INF("dlsym(%p, 'elm_main') = %p", qr_handle, qr_main);
693 WRN("not quicklauncher capable: no elm_main in '%s'", exe);
709 extern char **environ;
714 for (i = 0, size = 0; environ[i] != NULL; i++)
715 size += strlen(environ[i]) + 1;
717 p = malloc((i + 1) * sizeof(char *));
722 for (i = 0; oldenv[i] != NULL; i++)
723 environ[i] = strdup(oldenv[i]);
729 elm_quicklaunch_fork(int argc, char **argv, char *cwd, void (postfork_func) (void *data), void *postfork_data)
738 // need to accept current environment from elementary_run
745 if (child > 0) return EINA_TRUE;
748 perror("could not fork");
753 perror("could not chdir");
754 args = alloca((argc + 1) * sizeof(char *));
755 for (i = 0; i < argc; i++) args[i] = argv[i];
757 WRN("%s not quicklaunch capable, fallback...", argv[0]);
758 execvp(argv[0], args);
759 ERR("failed to execute '%s': %s", argv[0], strerror(errno));
763 if (child > 0) return EINA_TRUE;
766 perror("could not fork");
769 if (postfork_func) postfork_func(postfork_data);
773 perror("could not chdir");
774 // FIXME: this is very linux specific. it changes argv[0] of the process
775 // so ps etc. report what you'd expect. for other unixes and os's this
782 ecore_app_args_get(&real_argc, &real_argv);
783 lastarg = real_argv[real_argc - 1] + strlen(real_argv[real_argc - 1]);
784 for (p = real_argv[0]; p < lastarg; p++) *p = 0;
785 strcpy(real_argv[0], argv[0]);
787 ecore_app_args_set(argc, (const char **)argv);
788 ret = qr_main(argc, argv);
797 elm_quicklaunch_cleanup(void)
810 elm_quicklaunch_fallback(int argc, char **argv)
813 elm_quicklaunch_init(argc, argv);
814 elm_quicklaunch_sub_init(argc, argv);
815 elm_quicklaunch_prepare(argc, argv);
816 ret = qr_main(argc, argv);
822 elm_quicklaunch_exe_path_get(const char *exe)
824 static char *path = NULL;
825 static Eina_List *pathlist = NULL;
829 if (exe[0] == '/') return strdup(exe);
830 if ((exe[0] == '.') && (exe[1] == '/')) return strdup(exe);
831 if ((exe[0] == '.') && (exe[1] == '.') && (exe[2] == '/')) return strdup(exe);
836 path = getenv("PATH");
837 buf2 = alloca(strlen(path) + 1);
842 if ((*p == ':') || (*p == 0))
847 strncpy(buf2, pp, len);
849 pathlist = eina_list_append(pathlist, eina_stringshare_add(buf2));
861 EINA_LIST_FOREACH(pathlist, l, pathitr)
863 snprintf(buf, sizeof(buf), "%s/%s", pathitr, exe);
864 if (access(buf, R_OK | X_OK) == 0) return strdup(buf);
872 * This call should be called just after all initialization is complete. This
873 * function will not return until elm_exit() is called. It will keep looping
874 * running the main event/processing loop for Elementary.
880 ecore_main_loop_begin();
886 * If this call is called, it will flag the main loop to cease processing and
887 * return back to its parent function.
893 ecore_main_loop_quit();
898 * Set new policy value.
900 * This will emit the ecore event ELM_EVENT_POLICY_CHANGED in the main
901 * loop giving the event information Elm_Event_Policy_Changed with
902 * policy identifier, new and old values.
904 * @param policy policy identifier as in Elm_Policy.
905 * @param value policy value, depends on identifiers, usually there is
906 * an enumeration with the same prefix as the policy name, for
907 * example: ELM_POLICY_QUIT and Elm_Policy_Quit
908 * (ELM_POLICY_QUIT_NONE, ELM_POLICY_QUIT_LAST_WINDOW_CLOSED).
910 * @return @c EINA_TRUE on success or @c EINA_FALSE on error (right
911 * now just invalid policy identifier, but in future policy
912 * value might be enforced).
915 elm_policy_set(unsigned int policy, int value)
917 Elm_Event_Policy_Changed *ev;
919 if (policy >= ELM_POLICY_LAST)
922 if (value == _elm_policies[policy])
925 /* TODO: validade policy? */
927 ev = malloc(sizeof(*ev));
929 ev->new_value = value;
930 ev->old_value = _elm_policies[policy];
932 _elm_policies[policy] = value;
934 ecore_event_add(ELM_EVENT_POLICY_CHANGED, ev, NULL, NULL);
940 * Gets the policy value set for given identifier.
942 * @param policy policy identifier as in Elm_Policy.
944 * @return policy value. Will be 0 if policy identifier is invalid.
947 elm_policy_get(unsigned int policy)
949 if (policy >= ELM_POLICY_LAST)
951 return _elm_policies[policy];
955 * Flush all caches & dump all data that can be to lean down to use less memory
963 EINA_LIST_FOREACH(_elm_win_list, l, obj)
965 Evas *e = evas_object_evas_get(obj);
966 edje_file_cache_flush();
967 edje_collection_cache_flush();
968 evas_image_cache_flush(e);
969 evas_font_cache_flush(e);
975 * @defgroup Scaling Selective Widget Scaling
978 * Different widgets can be scaled independently. These functions allow you to
979 * manipulate this scaling on a per-widget basis. The object and all its
980 * children get their scaling factors multiplied by the scale factor set.
981 * This is multiplicative, in that if a child also has a scale size set it is
982 * in turn multiplied by its parent's scale size. 1.0 means “don't scale”,
983 * 2.0 is double size, 0.5 is half etc.
987 * Set the scaling factor
989 * @param obj The object
990 * @param scale Scale factor (from 0.0 up, with 1.0 == no scaling)
994 elm_object_scale_set(Evas_Object *obj, double scale)
996 elm_widget_scale_set(obj, scale);
1000 * Get the scaling factor
1002 * @param obj The object
1003 * @return The scaling factor set by elm_object_scale_set()
1007 elm_object_scale_get(const Evas_Object *obj)
1009 return elm_widget_scale_get(obj);
1013 * @defgroup Styles Styles
1016 * Widgets can have different styles of look. These generic API's set
1017 * styles of widgets, if they support them (and if the theme(s) do).
1023 * This sets the name of the style
1024 * @param obj The object
1025 * @param style The style name to use
1029 elm_object_style_set(Evas_Object *obj, const char *style)
1031 elm_widget_style_set(obj, style);
1037 * This gets the style being used for that widget. Note that the string
1038 * pointer is only valid as longas the object is valid and the style doesn't
1041 * @param obj The object
1042 * @return The style name
1046 elm_object_style_get(const Evas_Object *obj)
1048 return elm_widget_style_get(obj);
1052 * Set the disable state
1054 * This sets the disable state for the widget.
1056 * @param obj The object
1057 * @param disabled The state
1061 elm_object_disabled_set(Evas_Object *obj, Eina_Bool disabled)
1063 elm_widget_disabled_set(obj, disabled);
1067 * Get the disable state
1069 * This gets the disable state for the widget.
1071 * @param obj The object
1072 * @return True, if the widget is disabled
1076 elm_object_disabled_get(const Evas_Object *obj)
1078 return elm_widget_disabled_get(obj);
1082 * Get the global scaling factor
1084 * This gets the globally configured scaling factor that is applied to all
1087 * @return The scaling factor
1093 return _elm_config->scale;
1097 * Set the global scaling factor
1099 * This sets the globally configured scaling factor that is applied to all
1102 * @param scale The scaling factor to set
1106 elm_scale_set(double scale)
1108 if (_elm_config->scale == scale) return;
1109 _elm_config->scale = scale;
1114 * Set the global scaling factor for all applications on the display
1116 * This sets the globally configured scaling factor that is applied to all
1117 * objects for all applications.
1118 * @param scale The scaling factor to set
1122 elm_scale_all_set(double scale)
1124 #ifdef HAVE_ELEMENTARY_X
1125 static Ecore_X_Atom atom = 0;
1126 unsigned int scale_i = (unsigned int)(scale * 1000.0);
1128 if (!atom) atom = ecore_x_atom_get("ENLIGHTENMENT_SCALE");
1129 ecore_x_window_prop_card32_set(ecore_x_window_root_first_get(),
1135 * @defgroup Fingers Fingers
1138 * Elementary is designed to be finger-friendly for touchscreens, and so in
1139 * addition to scaling for display resolution, it can also scale based on
1140 * finger "resolution" (or size).
1144 * Get the configured finger size
1146 * This gets the globally configured finger size in pixels
1148 * @return The finger size
1152 elm_finger_size_get(void)
1154 return _elm_config->finger_size;
1158 * Set the configured finger size
1160 * This sets the globally configured finger size in pixels
1162 * @param size The finger size
1166 elm_finger_size_set(Evas_Coord size)
1168 if (_elm_config->finger_size == size) return;
1169 _elm_config->finger_size = size;
1174 * Set the configured finger size for all applications on the display
1176 * This sets the globally configured finger size in pixels for all applications
1179 * @param size The finger size
1183 elm_finger_size_all_set(Evas_Coord size)
1185 #ifdef HAVE_ELEMENTARY_X
1186 static Ecore_X_Atom atom = 0;
1187 unsigned int size_i = (unsigned int)size;
1189 if (!atom) atom = ecore_x_atom_get("ENLIGHTENMENT_FINGER_SIZE");
1190 ecore_x_window_prop_card32_set(ecore_x_window_root_first_get(),
1196 * Adjust size of an element for finger usage
1198 * This takes width and height sizes (in pixels) as input and a size multiple
1199 * (which is how many fingers you want to place within the area), and adjusts
1200 * the size tobe large enough to accomodate finger. On return the w and h
1201 * sizes poiner do by these parameters will be modified.
1203 * @param times_w How many fingers should fit horizontally
1204 * @param w Pointer to the width size to adjust
1205 * @param times_h How many fingers should fit vertically
1206 * @param h Pointer to the height size to adjust
1210 elm_coords_finger_size_adjust(int times_w, Evas_Coord *w, int times_h, Evas_Coord *h)
1212 if ((w) && (*w < (_elm_config->finger_size * times_w)))
1213 *w = _elm_config->finger_size * times_w;
1214 if ((h) && (*h < (_elm_config->finger_size * times_h)))
1215 *h = _elm_config->finger_size * times_h;
1219 * @defgroup Focus Focus
1222 * Objects have focus. This is what determines where the keyboard input goes to
1223 * within the application window.
1227 * Get the focus of the object
1229 * This gets the focused property of the object.
1231 * @param obj The object
1232 * @return 1 if the object is focused, 0 if not.
1236 elm_object_focus_get(Evas_Object *obj)
1238 return elm_widget_focus_get(obj);
1242 * Set the focus to the object
1244 * This sets the focus target for keyboard input to be the object indicated.
1246 * @param obj The object
1250 elm_object_focus(Evas_Object *obj)
1252 if (!elm_widget_can_focus_get(obj)) return;
1253 elm_widget_focus_steal(obj);
1257 * Remove the focus from the object
1259 * This removes the focus target for keyboard input from be the object
1262 * @param obj The object
1266 elm_object_unfocus(Evas_Object *obj)
1268 if (!elm_widget_can_focus_get(obj)) return;
1269 elm_widget_focused_object_clear(obj);
1273 * Set the ability for the object to focus
1275 * This sets the ability for the object to be able to get keyboard focus or
1276 * not. By default all objects are able to be focused.
1278 * @param obj The object
1279 * @param enable 1 if the object can be focused, 0 if not
1283 elm_object_focus_allow_set(Evas_Object *obj, Eina_Bool enable)
1285 elm_widget_can_focus_set(obj, enable);
1289 * Get the ability for the object to focus
1291 * This gets the ability for the object to be able to get keyboard focus or
1292 * not. By default all objects are able to be focused.
1294 * @param obj The object
1295 * @return 1 if the object is allowed to be focused, 0 if not.
1299 elm_object_focus_allow_get(const Evas_Object *obj)
1301 return elm_widget_can_focus_get(obj);
1305 * @defgroup Scrollhints Scrollhints
1308 * Objects when inside a scroller can scroll, but this may not always be
1309 * desireable in certain situations. This allows an object to hint to itself
1310 * and parents to "not scroll" in one of 2 ways.
1312 * 1. To hold on scrolling. This means just flicking and dragging may no
1313 * longer scroll, but pressing/dragging near an edge of the scroller will
1314 * still scroll. This is automastically used by the entry object when
1316 * 2. To totally freeze scrolling. This means it stops. until popped/released.
1320 * Push the scroll hold by 1
1322 * This increments the scroll hold count by one. If it is more than 0 it will
1323 * take effect on the parents of the indicated object.
1325 * @param obj The object
1326 * @ingroup Scrollhints
1329 elm_object_scroll_hold_push(Evas_Object *obj)
1331 elm_widget_scroll_hold_push(obj);
1335 * Pop the scroll hold by 1
1337 * This decrements the scroll hold count by one. If it is more than 0 it will
1338 * take effect on the parents of the indicated object.
1340 * @param obj The object
1341 * @ingroup Scrollhints
1344 elm_object_scroll_hold_pop(Evas_Object *obj)
1346 elm_widget_scroll_hold_pop(obj);
1350 * Push the scroll freeze by 1
1352 * This increments the scroll freeze count by one. If it is more than 0 it will
1353 * take effect on the parents of the indicated object.
1355 * @param obj The object
1356 * @ingroup Scrollhints
1359 elm_object_scroll_freeze_push(Evas_Object *obj)
1361 elm_widget_scroll_freeze_push(obj);
1365 * Lock the scrolling of the given widget (and thus all parents)
1367 * This locks the given object from scrolling in the X axis (and implicitly
1368 * also locks all parent scrollers too from doing the same).
1370 * @param obj The object
1371 * @param lock The lock state (1 == locked, 0 == unlocked)
1372 * @ingroup Scrollhints
1375 elm_object_scroll_lock_x_set(Evas_Object *obj, Eina_Bool lock)
1377 elm_widget_drag_lock_x_set(obj, lock);
1381 * Lock the scrolling of the given widget (and thus all parents)
1383 * This locks the given object from scrolling in the Y axis (and implicitly
1384 * also locks all parent scrollers too from doing the same).
1386 * @param obj The object
1387 * @param lock The lock state (1 == locked, 0 == unlocked)
1388 * @ingroup Scrollhints
1391 elm_object_scroll_lock_y_set(Evas_Object *obj, Eina_Bool lock)
1393 elm_widget_drag_lock_y_set(obj, lock);
1397 * Get the scrolling lock of the given widget
1399 * This gets the lock for X axis scrolling.
1401 * @param obj The object
1402 * @ingroup Scrollhints
1405 elm_object_scroll_lock_x_get(const Evas_Object *obj)
1407 return elm_widget_drag_lock_x_get(obj);
1411 * Get the scrolling lock of the given widget
1413 * This gets the lock for X axis scrolling.
1415 * @param obj The object
1416 * @ingroup Scrollhints
1419 elm_object_scroll_lock_y_get(const Evas_Object *obj)
1421 return elm_widget_drag_lock_y_get(obj);
1425 * Pop the scroll freeze by 1
1427 * This decrements the scroll freeze count by one. If it is more than 0 it will
1428 * take effect on the parents of the indicated object.
1430 * @param obj The object
1431 * @ingroup Scrollhints
1434 elm_object_scroll_freeze_pop(Evas_Object *obj)
1436 elm_widget_scroll_freeze_pop(obj);
1441 * Check if the given Evas Object is an Elementary widget.
1443 * @param obj the object to query.
1444 * @return @c EINA_TRUE if it is an elementary widget variant,
1445 * @c EINA_FALSE otherwise
1448 elm_object_widget_check(const Evas_Object *obj)
1450 return elm_widget_is(obj);
1454 * Get the first parent of the given object that is an Elementary widget.
1456 * @param obj the object to query.
1457 * @return the parent object that is an Elementary widget, or @c NULL
1458 * if no parent is, or no parents at all.
1461 elm_object_parent_widget_get(const Evas_Object *obj)
1463 return elm_widget_parent_widget_get(obj);
1467 * Get the string that represents this Elementary widget.
1469 * @note Elementary is weird and exposes itself as a single
1470 * Evas_Object_Smart_Class of type "elm_widget", so
1471 * evas_object_type_get() always return that, making debug and
1472 * language bindings hard. This function tries to mitigate this
1473 * problem, but the solution is to change Elementary to use
1474 * proper inheritance.
1476 * @param obj the object to query.
1477 * @return Elementary widget name, or @c NULL if not a valid widget.
1480 elm_object_widget_type_get(const Evas_Object *obj)
1482 return elm_widget_type_get(obj);