2010-03-06 08:46:08 -08:00
|
|
|
#ifdef HAVE_CONFIG_H
|
|
|
|
# include "elementary_config.h"
|
|
|
|
#endif
|
|
|
|
|
2011-10-15 02:48:42 -07:00
|
|
|
#ifdef HAVE_FORK
|
2010-11-29 05:14:37 -08:00
|
|
|
#include <dlfcn.h> /* dlopen,dlclose,etc */
|
2011-10-15 02:48:42 -07:00
|
|
|
#endif
|
2009-01-13 01:20:53 -08:00
|
|
|
|
2010-03-06 08:46:08 -08:00
|
|
|
#ifdef HAVE_CRT_EXTERNS_H
|
|
|
|
# include <crt_externs.h>
|
2008-12-18 16:34:56 -08:00
|
|
|
#endif
|
|
|
|
|
|
|
|
#ifdef HAVE_EVIL
|
|
|
|
# include <Evil.h>
|
|
|
|
#endif
|
|
|
|
|
2008-09-29 23:58:56 -07:00
|
|
|
#include <Elementary.h>
|
|
|
|
#include "elm_priv.h"
|
|
|
|
|
2010-10-20 21:05:35 -07:00
|
|
|
#define SEMI_BROKEN_QUICKLAUNCH 1
|
2010-10-20 07:12:17 -07:00
|
|
|
|
2010-05-29 02:48:05 -07:00
|
|
|
static Elm_Version _version = { VMAJ, VMIN, VMIC, VREV };
|
|
|
|
EAPI Elm_Version *elm_version = &_version;
|
|
|
|
|
2010-07-15 23:38:59 -07:00
|
|
|
Eina_Bool
|
|
|
|
_elm_dangerous_call_check(const char *call)
|
|
|
|
{
|
|
|
|
char buf[256];
|
|
|
|
const char *eval;
|
2010-11-29 05:14:37 -08:00
|
|
|
|
2010-07-16 13:39:17 -07:00
|
|
|
snprintf(buf, sizeof(buf), "%i.%i.%i.%i", VMAJ, VMIN, VMIC, VREV);
|
2010-07-15 23:38:59 -07:00
|
|
|
eval = getenv("ELM_NO_FINGER_WAGGLING");
|
|
|
|
if ((eval) && (!strcmp(eval, buf)))
|
|
|
|
return 0;
|
|
|
|
printf("ELEMENTARY FINGER WAGGLE!!!!!!!!!!\n"
|
|
|
|
"\n"
|
|
|
|
" %s() used.\n"
|
|
|
|
"PLEASE see the API documentation for this function. This call\n"
|
|
|
|
"should almost never be used. Only in very special cases.\n"
|
|
|
|
"\n"
|
|
|
|
"To remove this warning please set the environment variable:\n"
|
|
|
|
" ELM_NO_FINGER_WAGGLING\n"
|
|
|
|
"To the value of the Elementary version + revision number. e.g.:\n"
|
|
|
|
" 1.2.5.40295\n"
|
|
|
|
"\n"
|
|
|
|
,
|
|
|
|
call);
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2010-11-29 05:14:37 -08:00
|
|
|
static Eina_Bool _elm_signal_exit(void *data,
|
|
|
|
int ev_type,
|
|
|
|
void *ev);
|
2008-11-14 22:09:04 -08:00
|
|
|
|
2011-04-24 01:18:00 -07:00
|
|
|
static Eina_Prefix *pfx = NULL;
|
2008-09-29 23:58:56 -07:00
|
|
|
char *_elm_appname = NULL;
|
2009-01-13 01:20:53 -08:00
|
|
|
const char *_elm_data_dir = NULL;
|
2009-09-28 21:35:35 -07:00
|
|
|
const char *_elm_lib_dir = NULL;
|
2009-09-11 07:21:58 -07:00
|
|
|
int _elm_log_dom = -1;
|
2009-01-13 01:20:53 -08:00
|
|
|
|
2009-12-01 05:32:48 -08:00
|
|
|
EAPI int ELM_EVENT_POLICY_CHANGED = 0;
|
|
|
|
|
2010-03-26 18:24:21 -07:00
|
|
|
static int _elm_init_count = 0;
|
2010-10-20 07:12:17 -07:00
|
|
|
static int _elm_sub_init_count = 0;
|
|
|
|
static int _elm_ql_init_count = 0;
|
2009-12-01 05:32:48 -08:00
|
|
|
static int _elm_policies[ELM_POLICY_LAST];
|
2009-02-25 03:00:07 -08:00
|
|
|
static Ecore_Event_Handler *_elm_exit_handler = NULL;
|
2010-10-20 21:05:35 -07:00
|
|
|
static Eina_Bool quicklaunch_on = 0;
|
2008-12-09 22:43:21 -08:00
|
|
|
|
2010-06-25 02:58:14 -07:00
|
|
|
static Eina_Bool
|
2010-11-29 05:14:37 -08:00
|
|
|
_elm_signal_exit(void *data __UNUSED__,
|
|
|
|
int ev_type __UNUSED__,
|
|
|
|
void *ev __UNUSED__)
|
2008-09-29 23:58:56 -07:00
|
|
|
{
|
|
|
|
elm_exit();
|
2010-06-25 02:58:14 -07:00
|
|
|
return ECORE_CALLBACK_PASS_ON;
|
2008-09-29 23:58:56 -07:00
|
|
|
}
|
|
|
|
|
2010-05-07 08:49:06 -07:00
|
|
|
void
|
2008-11-14 22:09:04 -08:00
|
|
|
_elm_rescale(void)
|
|
|
|
{
|
|
|
|
edje_scale_set(_elm_config->scale);
|
2010-11-05 01:37:31 -07:00
|
|
|
_elm_win_rescale(NULL, EINA_FALSE);
|
2011-10-05 15:18:22 -07:00
|
|
|
_elm_ews_wm_rescale(NULL, EINA_FALSE);
|
2008-11-14 22:09:04 -08:00
|
|
|
}
|
|
|
|
|
2011-04-24 02:51:48 -07:00
|
|
|
static void *app_mainfunc = NULL;
|
|
|
|
static const char *app_domain = NULL;
|
|
|
|
static const char *app_checkfile = NULL;
|
|
|
|
|
|
|
|
static const char *app_compile_bin_dir = NULL;
|
|
|
|
static const char *app_compile_lib_dir = NULL;
|
|
|
|
static const char *app_compile_data_dir = NULL;
|
|
|
|
static const char *app_compile_locale_dir = NULL;
|
|
|
|
static const char *app_prefix_dir = NULL;
|
|
|
|
static const char *app_bin_dir = NULL;
|
|
|
|
static const char *app_lib_dir = NULL;
|
|
|
|
static const char *app_data_dir = NULL;
|
|
|
|
static const char *app_locale_dir = NULL;
|
|
|
|
|
|
|
|
static Eina_Prefix *app_pfx = NULL;
|
|
|
|
|
|
|
|
static void
|
|
|
|
_prefix_check(void)
|
|
|
|
{
|
|
|
|
int argc = 0;
|
|
|
|
char **argv = NULL;
|
|
|
|
const char *dirs[4] = { NULL, NULL, NULL, NULL };
|
|
|
|
char *caps = NULL, *p1, *p2;
|
2011-04-26 19:42:50 -07:00
|
|
|
|
2011-04-24 02:51:48 -07:00
|
|
|
if (app_pfx) return;
|
|
|
|
if (!app_domain) return;
|
2011-04-26 19:42:50 -07:00
|
|
|
|
2011-04-24 02:51:48 -07:00
|
|
|
ecore_app_args_get(&argc, &argv);
|
|
|
|
if (argc < 1) return;
|
|
|
|
|
|
|
|
dirs[0] = app_compile_bin_dir;
|
|
|
|
dirs[1] = app_compile_lib_dir;
|
|
|
|
dirs[2] = app_compile_data_dir;
|
|
|
|
dirs[3] = app_compile_locale_dir;
|
|
|
|
|
|
|
|
if (!dirs[1]) dirs[1] = dirs[0];
|
|
|
|
if (!dirs[0]) dirs[0] = dirs[1];
|
|
|
|
if (!dirs[3]) dirs[3] = dirs[2];
|
|
|
|
if (!dirs[2]) dirs[2] = dirs[3];
|
|
|
|
|
|
|
|
if (app_domain)
|
|
|
|
{
|
|
|
|
caps = alloca(strlen(app_domain) + 1);
|
|
|
|
for (p1 = (char *)app_domain, p2 = caps; *p1; p1++, p2++)
|
|
|
|
*p2 = toupper(*p1);
|
|
|
|
*p2 = 0;
|
|
|
|
}
|
|
|
|
app_pfx = eina_prefix_new(argv[0], app_mainfunc, caps, app_domain,
|
|
|
|
app_checkfile, dirs[0], dirs[1], dirs[2], dirs[3]);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_prefix_shutdown(void)
|
|
|
|
{
|
|
|
|
if (app_pfx) eina_prefix_free(app_pfx);
|
|
|
|
if (app_domain) eina_stringshare_del(app_domain);
|
|
|
|
if (app_checkfile) eina_stringshare_del(app_checkfile);
|
|
|
|
if (app_compile_bin_dir) eina_stringshare_del(app_compile_bin_dir);
|
|
|
|
if (app_compile_lib_dir) eina_stringshare_del(app_compile_lib_dir);
|
|
|
|
if (app_compile_data_dir) eina_stringshare_del(app_compile_data_dir);
|
|
|
|
if (app_compile_locale_dir) eina_stringshare_del(app_compile_locale_dir);
|
|
|
|
if (app_prefix_dir) eina_stringshare_del(app_prefix_dir);
|
|
|
|
if (app_bin_dir) eina_stringshare_del(app_bin_dir);
|
|
|
|
if (app_lib_dir) eina_stringshare_del(app_lib_dir);
|
|
|
|
if (app_data_dir) eina_stringshare_del(app_data_dir);
|
|
|
|
if (app_locale_dir) eina_stringshare_del(app_locale_dir);
|
|
|
|
app_mainfunc = NULL;
|
|
|
|
app_domain = NULL;
|
|
|
|
app_checkfile = NULL;
|
|
|
|
app_compile_bin_dir = NULL;
|
|
|
|
app_compile_lib_dir = NULL;
|
|
|
|
app_compile_data_dir = NULL;
|
|
|
|
app_compile_locale_dir = NULL;
|
|
|
|
app_prefix_dir = NULL;
|
|
|
|
app_bin_dir = NULL;
|
|
|
|
app_lib_dir = NULL;
|
|
|
|
app_data_dir = NULL;
|
|
|
|
app_locale_dir = NULL;
|
|
|
|
app_pfx = NULL;
|
|
|
|
}
|
|
|
|
|
2010-10-20 07:12:17 -07:00
|
|
|
EAPI int
|
2010-11-29 05:14:37 -08:00
|
|
|
elm_init(int argc,
|
|
|
|
char **argv)
|
2009-02-25 03:00:07 -08:00
|
|
|
{
|
2010-03-26 18:24:21 -07:00
|
|
|
_elm_init_count++;
|
2010-10-20 07:12:17 -07:00
|
|
|
if (_elm_init_count > 1) return _elm_init_count;
|
2009-02-25 03:00:07 -08:00
|
|
|
elm_quicklaunch_init(argc, argv);
|
|
|
|
elm_quicklaunch_sub_init(argc, argv);
|
2011-04-24 02:51:48 -07:00
|
|
|
_prefix_shutdown();
|
2010-10-20 07:12:17 -07:00
|
|
|
return _elm_init_count;
|
2009-02-25 03:00:07 -08:00
|
|
|
}
|
|
|
|
|
2010-10-20 07:12:17 -07:00
|
|
|
EAPI int
|
2009-02-25 03:00:07 -08:00
|
|
|
elm_shutdown(void)
|
|
|
|
{
|
2010-03-26 18:24:21 -07:00
|
|
|
_elm_init_count--;
|
2010-10-20 07:12:17 -07:00
|
|
|
if (_elm_init_count > 0) return _elm_init_count;
|
2011-03-09 22:35:33 -08:00
|
|
|
_elm_win_shutdown();
|
|
|
|
while (_elm_win_deferred_free) ecore_main_loop_iterate();
|
2011-04-26 19:42:50 -07:00
|
|
|
// wrningz :(
|
2011-04-24 02:51:48 -07:00
|
|
|
// _prefix_shutdown();
|
2009-02-25 03:00:07 -08:00
|
|
|
elm_quicklaunch_sub_shutdown();
|
|
|
|
elm_quicklaunch_shutdown();
|
2010-10-20 07:12:17 -07:00
|
|
|
return _elm_init_count;
|
2009-02-25 03:00:07 -08:00
|
|
|
}
|
|
|
|
|
2011-04-24 02:51:48 -07:00
|
|
|
EAPI void
|
|
|
|
elm_app_info_set(void *mainfunc, const char *dom, const char *checkfile)
|
|
|
|
{
|
|
|
|
app_mainfunc = mainfunc;
|
|
|
|
eina_stringshare_replace(&app_domain, dom);
|
|
|
|
eina_stringshare_replace(&app_checkfile, checkfile);
|
|
|
|
}
|
|
|
|
|
|
|
|
EAPI void
|
|
|
|
elm_app_compile_bin_dir_set(const char *dir)
|
|
|
|
{
|
|
|
|
eina_stringshare_replace(&app_compile_bin_dir, dir);
|
|
|
|
}
|
|
|
|
|
|
|
|
EAPI void
|
|
|
|
elm_app_compile_lib_dir_set(const char *dir)
|
|
|
|
{
|
|
|
|
eina_stringshare_replace(&app_compile_lib_dir, dir);
|
|
|
|
}
|
|
|
|
|
|
|
|
EAPI void
|
|
|
|
elm_app_compile_data_dir_set(const char *dir)
|
|
|
|
{
|
|
|
|
eina_stringshare_replace(&app_compile_data_dir, dir);
|
|
|
|
}
|
|
|
|
|
|
|
|
EAPI void
|
|
|
|
elm_app_compile_locale_set(const char *dir)
|
|
|
|
{
|
|
|
|
eina_stringshare_replace(&app_compile_locale_dir, dir);
|
|
|
|
}
|
|
|
|
|
|
|
|
EAPI const char *
|
|
|
|
elm_app_prefix_dir_get(void)
|
|
|
|
{
|
|
|
|
if (app_prefix_dir) return app_prefix_dir;
|
|
|
|
_prefix_check();
|
|
|
|
if (!app_pfx) return "";
|
|
|
|
app_prefix_dir = eina_prefix_get(app_pfx);
|
|
|
|
return app_prefix_dir;
|
|
|
|
}
|
2011-04-26 19:42:50 -07:00
|
|
|
|
2011-04-24 02:51:48 -07:00
|
|
|
EAPI const char *
|
|
|
|
elm_app_bin_dir_get(void)
|
|
|
|
{
|
|
|
|
if (app_bin_dir) return app_bin_dir;
|
|
|
|
_prefix_check();
|
|
|
|
if (!app_pfx) return "";
|
|
|
|
app_bin_dir = eina_prefix_bin_get(app_pfx);
|
|
|
|
return app_bin_dir;
|
|
|
|
}
|
|
|
|
|
|
|
|
EAPI const char *
|
|
|
|
elm_app_lib_dir_get(void)
|
|
|
|
{
|
|
|
|
if (app_lib_dir) return app_lib_dir;
|
|
|
|
_prefix_check();
|
|
|
|
if (!app_pfx) return "";
|
|
|
|
app_lib_dir = eina_prefix_lib_get(app_pfx);
|
|
|
|
return app_lib_dir;
|
|
|
|
}
|
|
|
|
|
|
|
|
EAPI const char *
|
|
|
|
elm_app_data_dir_get(void)
|
|
|
|
{
|
|
|
|
if (app_data_dir) return app_data_dir;
|
|
|
|
_prefix_check();
|
|
|
|
if (!app_pfx) return "";
|
|
|
|
app_data_dir = eina_prefix_data_get(app_pfx);
|
|
|
|
return app_data_dir;
|
|
|
|
}
|
|
|
|
|
|
|
|
EAPI const char *
|
|
|
|
elm_app_locale_dir_get(void)
|
|
|
|
{
|
|
|
|
if (app_locale_dir) return app_locale_dir;
|
|
|
|
_prefix_check();
|
|
|
|
if (!app_pfx) return "";
|
|
|
|
app_locale_dir = eina_prefix_locale_get(app_pfx);
|
|
|
|
return app_locale_dir;
|
|
|
|
}
|
|
|
|
|
2009-09-12 02:37:29 -07:00
|
|
|
#ifdef ELM_EDBUS
|
2010-09-14 00:01:57 -07:00
|
|
|
static int _elm_need_e_dbus = 0;
|
2009-09-12 02:37:29 -07:00
|
|
|
#endif
|
2010-10-27 21:13:09 -07:00
|
|
|
EAPI Eina_Bool
|
2009-09-12 02:37:29 -07:00
|
|
|
elm_need_e_dbus(void)
|
|
|
|
{
|
|
|
|
#ifdef ELM_EDBUS
|
2010-10-27 21:13:09 -07:00
|
|
|
if (_elm_need_e_dbus++) return EINA_TRUE;
|
2009-09-12 02:37:29 -07:00
|
|
|
e_dbus_init();
|
2010-10-27 21:13:09 -07:00
|
|
|
return EINA_TRUE;
|
2010-11-29 05:14:37 -08:00
|
|
|
#else
|
2010-10-27 21:13:09 -07:00
|
|
|
return EINA_FALSE;
|
2010-09-14 00:01:57 -07:00
|
|
|
#endif
|
2009-09-12 02:37:29 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_elm_unneed_e_dbus(void)
|
|
|
|
{
|
|
|
|
#ifdef ELM_EDBUS
|
2010-10-22 14:41:27 -07:00
|
|
|
if (--_elm_need_e_dbus) return;
|
2010-09-14 00:01:57 -07:00
|
|
|
|
|
|
|
_elm_need_e_dbus = 0;
|
|
|
|
e_dbus_shutdown();
|
|
|
|
#endif
|
2009-09-12 02:37:29 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
#ifdef ELM_EFREET
|
2010-09-14 00:01:57 -07:00
|
|
|
static int _elm_need_efreet = 0;
|
2009-09-12 02:37:29 -07:00
|
|
|
#endif
|
2010-10-27 21:13:09 -07:00
|
|
|
EAPI Eina_Bool
|
2009-09-12 02:37:29 -07:00
|
|
|
elm_need_efreet(void)
|
|
|
|
{
|
|
|
|
#ifdef ELM_EFREET
|
2010-10-27 21:13:09 -07:00
|
|
|
if (_elm_need_efreet++) return EINA_TRUE;
|
2009-09-12 02:37:29 -07:00
|
|
|
efreet_init();
|
|
|
|
efreet_mime_init();
|
|
|
|
efreet_trash_init();
|
2010-11-26 01:05:12 -08:00
|
|
|
/*
|
2009-09-12 02:37:29 -07:00
|
|
|
{
|
|
|
|
Eina_List **list;
|
2010-11-29 05:14:37 -08:00
|
|
|
|
2009-09-12 02:37:29 -07:00
|
|
|
list = efreet_icon_extra_list_get();
|
|
|
|
if (list)
|
|
|
|
{
|
|
|
|
e_user_dir_concat_static(buf, "icons");
|
|
|
|
*list = eina_list_prepend(*list, (void *)eina_stringshare_add(buf));
|
|
|
|
e_prefix_data_concat_static(buf, "data/icons");
|
|
|
|
*list = eina_list_prepend(*list, (void *)eina_stringshare_add(buf));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
*/
|
2010-10-27 21:13:09 -07:00
|
|
|
return EINA_TRUE;
|
|
|
|
#else
|
|
|
|
return EINA_FALSE;
|
2009-09-12 02:37:29 -07:00
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_elm_unneed_efreet(void)
|
|
|
|
{
|
2009-10-08 02:31:15 -07:00
|
|
|
#ifdef ELM_EFREET
|
2010-10-22 14:41:27 -07:00
|
|
|
if (--_elm_need_efreet) return;
|
2010-09-14 00:01:57 -07:00
|
|
|
|
|
|
|
_elm_need_efreet = 0;
|
|
|
|
efreet_trash_shutdown();
|
|
|
|
efreet_mime_shutdown();
|
|
|
|
efreet_shutdown();
|
|
|
|
#endif
|
2009-09-12 02:37:29 -07:00
|
|
|
}
|
|
|
|
|
2010-10-20 21:05:35 -07:00
|
|
|
EAPI void
|
|
|
|
elm_quicklaunch_mode_set(Eina_Bool ql_on)
|
|
|
|
{
|
|
|
|
quicklaunch_on = ql_on;
|
|
|
|
}
|
|
|
|
|
2010-10-27 07:38:37 -07:00
|
|
|
EAPI Eina_Bool
|
|
|
|
elm_quicklaunch_mode_get(void)
|
|
|
|
{
|
|
|
|
return quicklaunch_on;
|
|
|
|
}
|
|
|
|
|
2010-10-20 07:12:17 -07:00
|
|
|
EAPI int
|
2010-11-29 05:14:37 -08:00
|
|
|
elm_quicklaunch_init(int argc,
|
|
|
|
char **argv)
|
2008-09-29 23:58:56 -07:00
|
|
|
{
|
2010-10-20 07:12:17 -07:00
|
|
|
_elm_ql_init_count++;
|
|
|
|
if (_elm_ql_init_count > 1) return _elm_ql_init_count;
|
2009-09-11 07:21:58 -07:00
|
|
|
eina_init();
|
|
|
|
_elm_log_dom = eina_log_domain_register("elementary", EINA_COLOR_LIGHTBLUE);
|
|
|
|
if (!_elm_log_dom)
|
|
|
|
{
|
2010-11-29 05:14:37 -08:00
|
|
|
EINA_LOG_ERR("could not register elementary log domain.");
|
|
|
|
_elm_log_dom = EINA_LOG_DOMAIN_GLOBAL;
|
2009-09-11 07:21:58 -07:00
|
|
|
}
|
|
|
|
|
2008-09-29 23:58:56 -07:00
|
|
|
eet_init();
|
2009-07-06 23:46:51 -07:00
|
|
|
ecore_init();
|
2011-06-25 07:30:10 -07:00
|
|
|
|
|
|
|
#ifdef HAVE_ELEMENTARY_EMAP
|
|
|
|
emap_init();
|
|
|
|
#endif
|
2008-09-29 23:58:56 -07:00
|
|
|
ecore_app_args_set(argc, (const char **)argv);
|
2009-12-01 05:32:48 -08:00
|
|
|
|
|
|
|
memset(_elm_policies, 0, sizeof(_elm_policies));
|
2010-10-22 14:41:27 -07:00
|
|
|
if (!ELM_EVENT_POLICY_CHANGED)
|
2009-12-01 05:32:48 -08:00
|
|
|
ELM_EVENT_POLICY_CHANGED = ecore_event_type_new();
|
|
|
|
|
2008-09-29 23:58:56 -07:00
|
|
|
ecore_file_init();
|
2009-11-14 17:52:25 -08:00
|
|
|
|
2009-02-25 03:00:07 -08:00
|
|
|
_elm_exit_handler = ecore_event_handler_add(ECORE_EVENT_SIGNAL_EXIT, _elm_signal_exit, NULL);
|
2009-07-06 23:46:51 -07:00
|
|
|
|
2010-03-26 18:19:05 -07:00
|
|
|
if (argv) _elm_appname = strdup(ecore_file_file_get(argv[0]));
|
2008-09-29 23:58:56 -07:00
|
|
|
|
2011-12-28 07:19:31 -08:00
|
|
|
pfx = eina_prefix_new(argv ? argv[0] : NULL, elm_quicklaunch_init,
|
2011-04-24 01:18:00 -07:00
|
|
|
"ELM", "elementary", "config/profile.cfg",
|
|
|
|
PACKAGE_LIB_DIR, /* don't have a bin dir currently */
|
|
|
|
PACKAGE_LIB_DIR,
|
|
|
|
PACKAGE_DATA_DIR,
|
|
|
|
LOCALE_DIR);
|
|
|
|
if (pfx)
|
2009-01-13 01:20:53 -08:00
|
|
|
{
|
2011-04-24 01:18:00 -07:00
|
|
|
_elm_data_dir = eina_stringshare_add(eina_prefix_data_get(pfx));
|
|
|
|
_elm_lib_dir = eina_stringshare_add(eina_prefix_lib_get(pfx));
|
2009-01-13 01:20:53 -08:00
|
|
|
}
|
2011-04-24 01:18:00 -07:00
|
|
|
if (!_elm_data_dir) _elm_data_dir = eina_stringshare_add("/");
|
|
|
|
if (!_elm_lib_dir) _elm_lib_dir = eina_stringshare_add("/");
|
2009-07-06 23:46:51 -07:00
|
|
|
|
2010-05-07 08:49:06 -07:00
|
|
|
_elm_config_init();
|
2010-10-20 07:12:17 -07:00
|
|
|
return _elm_ql_init_count;
|
2008-09-29 23:58:56 -07:00
|
|
|
}
|
|
|
|
|
2010-10-20 07:12:17 -07:00
|
|
|
EAPI int
|
2010-11-29 05:14:37 -08:00
|
|
|
elm_quicklaunch_sub_init(int argc,
|
|
|
|
char **argv)
|
2008-09-29 23:58:56 -07:00
|
|
|
{
|
2010-10-20 07:12:17 -07:00
|
|
|
_elm_sub_init_count++;
|
|
|
|
if (_elm_sub_init_count > 1) return _elm_sub_init_count;
|
2010-10-20 21:05:35 -07:00
|
|
|
if (quicklaunch_on)
|
2010-10-20 07:12:17 -07:00
|
|
|
{
|
2010-10-20 21:05:35 -07:00
|
|
|
#ifdef SEMI_BROKEN_QUICKLAUNCH
|
|
|
|
return _elm_sub_init_count;
|
2010-10-20 07:12:17 -07:00
|
|
|
#endif
|
|
|
|
}
|
2010-10-20 21:05:35 -07:00
|
|
|
if (!quicklaunch_on)
|
|
|
|
{
|
|
|
|
ecore_app_args_set(argc, (const char **)argv);
|
|
|
|
evas_init();
|
|
|
|
edje_init();
|
2010-11-18 01:30:46 -08:00
|
|
|
_elm_module_init();
|
2010-10-20 21:05:35 -07:00
|
|
|
_elm_config_sub_init();
|
|
|
|
ecore_evas_init(); // FIXME: check errors
|
2011-11-20 07:00:43 -08:00
|
|
|
#ifdef HAVE_ELEMENTARY_ECORE_IMF
|
2010-10-20 21:05:35 -07:00
|
|
|
ecore_imf_init();
|
2011-11-20 07:00:43 -08:00
|
|
|
#endif
|
|
|
|
#ifdef HAVE_ELEMENTARY_ECORE_CON
|
2011-07-26 22:59:01 -07:00
|
|
|
ecore_con_init();
|
|
|
|
ecore_con_url_init();
|
2011-11-20 07:00:43 -08:00
|
|
|
#endif
|
2011-10-05 15:18:22 -07:00
|
|
|
_elm_ews_wm_init();
|
2010-10-20 21:05:35 -07:00
|
|
|
}
|
2010-10-20 07:12:17 -07:00
|
|
|
return _elm_sub_init_count;
|
2009-02-25 03:00:07 -08:00
|
|
|
}
|
2008-12-09 22:33:24 -08:00
|
|
|
|
2010-10-20 07:12:17 -07:00
|
|
|
EAPI int
|
2009-02-25 03:00:07 -08:00
|
|
|
elm_quicklaunch_sub_shutdown(void)
|
|
|
|
{
|
2010-10-20 07:12:17 -07:00
|
|
|
_elm_sub_init_count--;
|
|
|
|
if (_elm_sub_init_count > 0) return _elm_sub_init_count;
|
2010-10-20 21:05:35 -07:00
|
|
|
if (quicklaunch_on)
|
|
|
|
{
|
|
|
|
#ifdef SEMI_BROKEN_QUICKLAUNCH
|
|
|
|
return _elm_sub_init_count;
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
if (!quicklaunch_on)
|
2010-10-20 07:12:17 -07:00
|
|
|
{
|
2010-10-20 21:05:35 -07:00
|
|
|
_elm_win_shutdown();
|
|
|
|
_elm_module_shutdown();
|
2011-10-05 15:18:22 -07:00
|
|
|
_elm_ews_wm_shutdown();
|
2011-11-20 07:00:43 -08:00
|
|
|
#ifdef HAVE_ELEMENTARY_ECORE_CON
|
2011-07-26 22:59:01 -07:00
|
|
|
ecore_con_url_shutdown();
|
|
|
|
ecore_con_shutdown();
|
2011-11-20 07:00:43 -08:00
|
|
|
#endif
|
|
|
|
#ifdef HAVE_ELEMENTARY_ECORE_IMF
|
2010-10-20 21:05:35 -07:00
|
|
|
ecore_imf_shutdown();
|
2011-11-20 07:00:43 -08:00
|
|
|
#endif
|
2010-10-20 21:05:35 -07:00
|
|
|
ecore_evas_shutdown();
|
2011-09-28 19:00:20 -07:00
|
|
|
_elm_config_sub_shutdown();
|
2010-11-01 14:10:07 -07:00
|
|
|
#define ENGINE_COMPARE(name) (!strcmp(_elm_config->engine, name))
|
|
|
|
if (ENGINE_COMPARE(ELM_SOFTWARE_X11) ||
|
|
|
|
ENGINE_COMPARE(ELM_SOFTWARE_16_X11) ||
|
|
|
|
ENGINE_COMPARE(ELM_XRENDER_X11) ||
|
|
|
|
ENGINE_COMPARE(ELM_OPENGL_X11) ||
|
|
|
|
ENGINE_COMPARE(ELM_SOFTWARE_SDL) ||
|
|
|
|
ENGINE_COMPARE(ELM_SOFTWARE_16_SDL) ||
|
|
|
|
ENGINE_COMPARE(ELM_OPENGL_SDL) ||
|
2011-11-02 12:26:29 -07:00
|
|
|
ENGINE_COMPARE(ELM_OPENGL_COCOA) ||
|
2010-11-01 14:10:07 -07:00
|
|
|
ENGINE_COMPARE(ELM_SOFTWARE_WIN32) ||
|
2011-10-05 15:18:22 -07:00
|
|
|
ENGINE_COMPARE(ELM_SOFTWARE_16_WINCE) ||
|
|
|
|
ENGINE_COMPARE(ELM_EWS))
|
2010-11-01 14:10:07 -07:00
|
|
|
#undef ENGINE_COMPARE
|
2010-11-29 05:14:37 -08:00
|
|
|
evas_cserve_disconnect();
|
2010-10-20 21:05:35 -07:00
|
|
|
edje_shutdown();
|
|
|
|
evas_shutdown();
|
2010-10-20 07:12:17 -07:00
|
|
|
}
|
|
|
|
return _elm_sub_init_count;
|
2009-02-25 03:00:07 -08:00
|
|
|
}
|
2009-01-13 01:20:53 -08:00
|
|
|
|
2010-10-20 07:12:17 -07:00
|
|
|
EAPI int
|
2009-02-25 03:00:07 -08:00
|
|
|
elm_quicklaunch_shutdown(void)
|
|
|
|
{
|
2010-10-20 07:12:17 -07:00
|
|
|
_elm_ql_init_count--;
|
|
|
|
if (_elm_ql_init_count > 0) return _elm_ql_init_count;
|
2011-04-24 01:18:00 -07:00
|
|
|
if (pfx) eina_prefix_free(pfx);
|
|
|
|
pfx = NULL;
|
2009-01-13 01:20:53 -08:00
|
|
|
eina_stringshare_del(_elm_data_dir);
|
|
|
|
_elm_data_dir = NULL;
|
2010-04-28 16:14:04 -07:00
|
|
|
eina_stringshare_del(_elm_lib_dir);
|
|
|
|
_elm_lib_dir = NULL;
|
2009-02-03 02:28:52 -08:00
|
|
|
|
2010-01-18 01:38:52 -08:00
|
|
|
free(_elm_appname);
|
2010-04-28 16:14:04 -07:00
|
|
|
_elm_appname = NULL;
|
2010-11-29 05:14:37 -08:00
|
|
|
|
2010-05-07 08:49:06 -07:00
|
|
|
_elm_config_shutdown();
|
2010-11-29 05:14:37 -08:00
|
|
|
|
2009-02-25 03:00:07 -08:00
|
|
|
ecore_event_handler_del(_elm_exit_handler);
|
|
|
|
_elm_exit_handler = NULL;
|
2009-07-06 23:46:51 -07:00
|
|
|
|
2010-04-28 16:14:04 -07:00
|
|
|
_elm_theme_shutdown();
|
2009-09-12 02:37:29 -07:00
|
|
|
_elm_unneed_efreet();
|
|
|
|
_elm_unneed_e_dbus();
|
2010-03-31 05:38:58 -07:00
|
|
|
_elm_unneed_ethumb();
|
2011-09-29 13:58:22 -07:00
|
|
|
_elm_unneed_web();
|
2008-09-29 23:58:56 -07:00
|
|
|
ecore_file_shutdown();
|
2011-06-25 07:30:10 -07:00
|
|
|
|
|
|
|
#ifdef HAVE_ELEMENTARY_EMAP
|
|
|
|
emap_shutdown();
|
|
|
|
#endif
|
|
|
|
|
2008-09-29 23:58:56 -07:00
|
|
|
ecore_shutdown();
|
|
|
|
eet_shutdown();
|
2009-09-11 07:21:58 -07:00
|
|
|
|
|
|
|
if ((_elm_log_dom > -1) && (_elm_log_dom != EINA_LOG_DOMAIN_GLOBAL))
|
|
|
|
{
|
2010-11-29 05:14:37 -08:00
|
|
|
eina_log_domain_unregister(_elm_log_dom);
|
|
|
|
_elm_log_dom = -1;
|
2009-09-11 07:21:58 -07:00
|
|
|
}
|
|
|
|
|
2010-09-13 00:56:23 -07:00
|
|
|
_elm_widget_type_clear();
|
2010-11-29 05:14:37 -08:00
|
|
|
|
2009-09-11 07:21:58 -07:00
|
|
|
eina_shutdown();
|
2010-10-20 07:12:17 -07:00
|
|
|
return _elm_ql_init_count;
|
2008-09-29 23:58:56 -07:00
|
|
|
}
|
|
|
|
|
2009-02-25 03:00:07 -08:00
|
|
|
EAPI void
|
|
|
|
elm_quicklaunch_seed(void)
|
|
|
|
{
|
2010-11-29 05:14:37 -08:00
|
|
|
#ifndef SEMI_BROKEN_QUICKLAUNCH
|
2010-10-20 21:05:35 -07:00
|
|
|
if (quicklaunch_on)
|
2009-02-25 03:00:07 -08:00
|
|
|
{
|
2010-10-20 21:05:35 -07:00
|
|
|
Evas_Object *win, *bg, *bt;
|
2010-11-29 05:14:37 -08:00
|
|
|
|
2010-10-20 21:05:35 -07:00
|
|
|
win = elm_win_add(NULL, "seed", ELM_WIN_BASIC);
|
|
|
|
bg = elm_bg_add(win);
|
|
|
|
elm_win_resize_object_add(win, bg);
|
|
|
|
evas_object_show(bg);
|
|
|
|
bt = elm_button_add(win);
|
|
|
|
elm_button_label_set(bt, " abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789~-_=+\\|]}[{;:'\",<.>/?");
|
|
|
|
elm_win_resize_object_add(win, bt);
|
|
|
|
ecore_main_loop_iterate();
|
|
|
|
evas_object_del(win);
|
|
|
|
ecore_main_loop_iterate();
|
2010-11-01 14:10:07 -07:00
|
|
|
#define ENGINE_COMPARE(name) (!strcmp(_elm_config->engine, name))
|
|
|
|
if (ENGINE_COMPARE(ELM_SOFTWARE_X11) ||
|
|
|
|
ENGINE_COMPARE(ELM_SOFTWARE_16_X11) ||
|
|
|
|
ENGINE_COMPARE(ELM_XRENDER_X11) ||
|
|
|
|
ENGINE_COMPARE(ELM_OPENGL_X11))
|
|
|
|
#undef ENGINE_COMPARE
|
2010-10-20 21:05:35 -07:00
|
|
|
{
|
|
|
|
# ifdef HAVE_ELEMENTARY_X
|
|
|
|
ecore_x_sync();
|
|
|
|
# endif
|
|
|
|
}
|
|
|
|
ecore_main_loop_iterate();
|
|
|
|
}
|
2010-11-29 05:14:37 -08:00
|
|
|
#endif
|
2009-02-25 03:00:07 -08:00
|
|
|
}
|
|
|
|
|
2011-10-20 14:14:39 -07:00
|
|
|
#ifdef HAVE_FORK
|
2009-02-25 03:00:07 -08:00
|
|
|
static void *qr_handle = NULL;
|
2011-10-20 14:14:39 -07:00
|
|
|
#endif
|
2010-11-29 05:14:37 -08:00
|
|
|
static int (*qr_main)(int argc,
|
|
|
|
char **argv) = NULL;
|
2009-02-25 03:00:07 -08:00
|
|
|
|
2009-06-17 08:35:19 -07:00
|
|
|
EAPI Eina_Bool
|
2010-11-29 05:14:37 -08:00
|
|
|
elm_quicklaunch_prepare(int argc __UNUSED__,
|
|
|
|
char **argv)
|
2009-02-25 03:00:07 -08:00
|
|
|
{
|
2009-03-01 01:33:41 -08:00
|
|
|
#ifdef HAVE_FORK
|
2009-02-25 03:00:07 -08:00
|
|
|
char *exe = elm_quicklaunch_exe_path_get(argv[0]);
|
|
|
|
if (!exe)
|
|
|
|
{
|
2010-11-29 05:14:37 -08:00
|
|
|
ERR("requested quicklaunch binary '%s' does not exist\n", argv[0]);
|
|
|
|
return EINA_FALSE;
|
2009-02-25 03:00:07 -08:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2010-11-29 05:14:37 -08:00
|
|
|
char *exe2, *p;
|
|
|
|
char *exename;
|
|
|
|
|
|
|
|
exe2 = malloc(strlen(exe) + 1 + 10);
|
|
|
|
strcpy(exe2, exe);
|
|
|
|
p = strrchr(exe2, '/');
|
|
|
|
if (p) p++;
|
|
|
|
else p = exe2;
|
|
|
|
exename = alloca(strlen(p) + 1);
|
|
|
|
strcpy(exename, p);
|
|
|
|
*p = 0;
|
|
|
|
strcat(p, "../lib/");
|
|
|
|
strcat(p, exename);
|
|
|
|
strcat(p, ".so");
|
|
|
|
if (!access(exe2, R_OK | X_OK))
|
|
|
|
{
|
|
|
|
free(exe);
|
|
|
|
exe = exe2;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
free(exe2);
|
2009-02-25 03:00:07 -08:00
|
|
|
}
|
|
|
|
qr_handle = dlopen(exe, RTLD_NOW | RTLD_GLOBAL);
|
2009-09-11 08:02:07 -07:00
|
|
|
if (!qr_handle)
|
|
|
|
{
|
2009-09-13 21:20:51 -07:00
|
|
|
fprintf(stderr, "dlerr: %s\n", dlerror());
|
2010-11-29 05:14:37 -08:00
|
|
|
WRN("dlopen('%s') failed: %s", exe, dlerror());
|
|
|
|
free(exe);
|
|
|
|
return EINA_FALSE;
|
2009-09-11 08:02:07 -07:00
|
|
|
}
|
|
|
|
INF("dlopen('%s') = %p", exe, qr_handle);
|
2009-02-25 03:00:07 -08:00
|
|
|
qr_main = dlsym(qr_handle, "elm_main");
|
2009-09-11 08:02:07 -07:00
|
|
|
INF("dlsym(%p, 'elm_main') = %p", qr_handle, qr_main);
|
2009-02-25 03:00:07 -08:00
|
|
|
if (!qr_main)
|
|
|
|
{
|
2010-11-29 05:14:37 -08:00
|
|
|
WRN("not quicklauncher capable: no elm_main in '%s'", exe);
|
|
|
|
dlclose(qr_handle);
|
|
|
|
qr_handle = NULL;
|
2010-12-24 01:58:20 -08:00
|
|
|
free(exe);
|
2010-11-29 05:14:37 -08:00
|
|
|
return EINA_FALSE;
|
2009-02-25 03:00:07 -08:00
|
|
|
}
|
2010-12-24 01:58:20 -08:00
|
|
|
free(exe);
|
2009-06-17 08:35:19 -07:00
|
|
|
return EINA_TRUE;
|
2009-03-01 01:33:41 -08:00
|
|
|
#else
|
2009-06-17 08:35:19 -07:00
|
|
|
return EINA_FALSE;
|
2010-10-19 11:25:57 -07:00
|
|
|
(void)argv;
|
2009-03-01 01:33:41 -08:00
|
|
|
#endif
|
2009-02-25 03:00:07 -08:00
|
|
|
}
|
|
|
|
|
2009-03-01 01:33:41 -08:00
|
|
|
#ifdef HAVE_FORK
|
2009-02-25 22:20:41 -08:00
|
|
|
static void
|
|
|
|
save_env(void)
|
|
|
|
{
|
|
|
|
int i, size;
|
|
|
|
extern char **environ;
|
|
|
|
char **oldenv, **p;
|
2009-07-06 23:46:51 -07:00
|
|
|
|
2009-02-25 22:20:41 -08:00
|
|
|
oldenv = environ;
|
2009-07-06 23:46:51 -07:00
|
|
|
|
2010-08-21 06:52:25 -07:00
|
|
|
for (i = 0, size = 0; environ[i]; i++)
|
2009-02-25 22:20:41 -08:00
|
|
|
size += strlen(environ[i]) + 1;
|
2009-07-06 23:46:51 -07:00
|
|
|
|
2009-02-25 22:20:41 -08:00
|
|
|
p = malloc((i + 1) * sizeof(char *));
|
|
|
|
if (!p) return;
|
2009-07-06 23:46:51 -07:00
|
|
|
|
2009-02-25 22:20:41 -08:00
|
|
|
environ = p;
|
2009-07-06 23:46:51 -07:00
|
|
|
|
2010-08-21 06:52:25 -07:00
|
|
|
for (i = 0; oldenv[i]; i++)
|
2009-02-25 22:20:41 -08:00
|
|
|
environ[i] = strdup(oldenv[i]);
|
|
|
|
environ[i] = NULL;
|
|
|
|
}
|
2010-11-29 05:14:37 -08:00
|
|
|
|
2009-03-01 01:33:41 -08:00
|
|
|
#endif
|
2009-02-25 22:20:41 -08:00
|
|
|
|
2009-06-17 08:35:19 -07:00
|
|
|
EAPI Eina_Bool
|
2010-11-29 05:14:37 -08:00
|
|
|
elm_quicklaunch_fork(int argc,
|
|
|
|
char **argv,
|
|
|
|
char *cwd,
|
|
|
|
void (postfork_func) (void *data),
|
|
|
|
void *postfork_data)
|
2009-02-25 03:00:07 -08:00
|
|
|
{
|
2009-03-01 01:33:41 -08:00
|
|
|
#ifdef HAVE_FORK
|
2009-02-25 03:00:07 -08:00
|
|
|
pid_t child;
|
|
|
|
int ret;
|
|
|
|
int real_argc;
|
|
|
|
char **real_argv;
|
2009-07-06 23:46:51 -07:00
|
|
|
|
2009-02-25 03:00:07 -08:00
|
|
|
// FIXME:
|
|
|
|
// need to accept current environment from elementary_run
|
|
|
|
if (!qr_main)
|
|
|
|
{
|
2010-11-29 05:14:37 -08:00
|
|
|
int i;
|
|
|
|
char **args;
|
|
|
|
|
|
|
|
child = fork();
|
|
|
|
if (child > 0) return EINA_TRUE;
|
|
|
|
else if (child < 0)
|
|
|
|
{
|
|
|
|
perror("could not fork");
|
|
|
|
return EINA_FALSE;
|
|
|
|
}
|
|
|
|
setsid();
|
|
|
|
if (chdir(cwd) != 0)
|
|
|
|
perror("could not chdir");
|
|
|
|
args = alloca((argc + 1) * sizeof(char *));
|
|
|
|
for (i = 0; i < argc; i++) args[i] = argv[i];
|
|
|
|
args[argc] = NULL;
|
|
|
|
WRN("%s not quicklaunch capable, fallback...", argv[0]);
|
|
|
|
execvp(argv[0], args);
|
|
|
|
ERR("failed to execute '%s': %s", argv[0], strerror(errno));
|
|
|
|
exit(-1);
|
2009-02-25 03:00:07 -08:00
|
|
|
}
|
|
|
|
child = fork();
|
2009-06-17 08:35:19 -07:00
|
|
|
if (child > 0) return EINA_TRUE;
|
2009-02-25 07:54:26 -08:00
|
|
|
else if (child < 0)
|
|
|
|
{
|
2010-11-29 05:14:37 -08:00
|
|
|
perror("could not fork");
|
|
|
|
return EINA_FALSE;
|
2009-02-25 07:54:26 -08:00
|
|
|
}
|
2009-02-25 22:20:41 -08:00
|
|
|
if (postfork_func) postfork_func(postfork_data);
|
2010-11-29 05:14:37 -08:00
|
|
|
|
2010-10-20 21:05:35 -07:00
|
|
|
if (quicklaunch_on)
|
2010-10-20 07:12:17 -07:00
|
|
|
{
|
2010-10-20 21:05:35 -07:00
|
|
|
#ifdef SEMI_BROKEN_QUICKLAUNCH
|
|
|
|
ecore_app_args_set(argc, (const char **)argv);
|
|
|
|
evas_init();
|
|
|
|
edje_init();
|
|
|
|
_elm_config_sub_init();
|
2010-11-01 14:10:07 -07:00
|
|
|
#define ENGINE_COMPARE(name) (!strcmp(_elm_config->engine, name))
|
|
|
|
if (ENGINE_COMPARE(ELM_SOFTWARE_X11) ||
|
|
|
|
ENGINE_COMPARE(ELM_SOFTWARE_16_X11) ||
|
|
|
|
ENGINE_COMPARE(ELM_XRENDER_X11) ||
|
|
|
|
ENGINE_COMPARE(ELM_OPENGL_X11))
|
|
|
|
#undef ENGINE_COMPARE
|
2010-10-20 21:05:35 -07:00
|
|
|
{
|
|
|
|
# ifdef HAVE_ELEMENTARY_X
|
|
|
|
ecore_x_init(NULL);
|
|
|
|
# endif
|
|
|
|
}
|
|
|
|
ecore_evas_init(); // FIXME: check errors
|
|
|
|
ecore_imf_init();
|
|
|
|
_elm_module_init();
|
2010-10-20 07:12:17 -07:00
|
|
|
#endif
|
|
|
|
}
|
2010-11-29 05:14:37 -08:00
|
|
|
|
2009-02-25 18:13:34 -08:00
|
|
|
setsid();
|
2009-02-25 07:54:26 -08:00
|
|
|
if (chdir(cwd) != 0)
|
|
|
|
perror("could not chdir");
|
2009-02-25 22:20:41 -08:00
|
|
|
// FIXME: this is very linux specific. it changes argv[0] of the process
|
|
|
|
// so ps etc. report what you'd expect. for other unixes and os's this
|
|
|
|
// may just not work
|
|
|
|
save_env();
|
2010-03-01 17:14:36 -08:00
|
|
|
if (argv)
|
2009-02-25 22:20:41 -08:00
|
|
|
{
|
2010-11-29 05:14:37 -08:00
|
|
|
char *lastarg, *p;
|
2009-02-25 22:20:41 -08:00
|
|
|
|
2010-11-29 05:14:37 -08:00
|
|
|
ecore_app_args_get(&real_argc, &real_argv);
|
|
|
|
lastarg = real_argv[real_argc - 1] + strlen(real_argv[real_argc - 1]);
|
|
|
|
for (p = real_argv[0]; p < lastarg; p++) *p = 0;
|
|
|
|
strcpy(real_argv[0], argv[0]);
|
2009-02-25 22:20:41 -08:00
|
|
|
}
|
|
|
|
ecore_app_args_set(argc, (const char **)argv);
|
2009-02-25 03:00:07 -08:00
|
|
|
ret = qr_main(argc, argv);
|
|
|
|
exit(ret);
|
2009-06-17 08:35:19 -07:00
|
|
|
return EINA_TRUE;
|
2009-03-01 01:33:41 -08:00
|
|
|
#else
|
2009-06-17 08:35:19 -07:00
|
|
|
return EINA_FALSE;
|
2010-10-19 11:25:57 -07:00
|
|
|
(void)argc;
|
|
|
|
(void)argv;
|
|
|
|
(void)cwd;
|
|
|
|
(void)postfork_func;
|
|
|
|
(void)postfork_data;
|
2009-07-06 23:46:51 -07:00
|
|
|
#endif
|
2009-02-25 03:00:07 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
EAPI void
|
|
|
|
elm_quicklaunch_cleanup(void)
|
|
|
|
{
|
2009-03-01 01:33:41 -08:00
|
|
|
#ifdef HAVE_FORK
|
2009-02-25 03:00:07 -08:00
|
|
|
if (qr_handle)
|
|
|
|
{
|
2010-11-29 05:14:37 -08:00
|
|
|
dlclose(qr_handle);
|
|
|
|
qr_handle = NULL;
|
|
|
|
qr_main = NULL;
|
2009-02-25 03:00:07 -08:00
|
|
|
}
|
2009-03-01 01:33:41 -08:00
|
|
|
#endif
|
2009-02-25 03:00:07 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
EAPI int
|
2010-11-29 05:14:37 -08:00
|
|
|
elm_quicklaunch_fallback(int argc,
|
|
|
|
char **argv)
|
2009-02-25 03:00:07 -08:00
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
elm_quicklaunch_init(argc, argv);
|
|
|
|
elm_quicklaunch_sub_init(argc, argv);
|
|
|
|
elm_quicklaunch_prepare(argc, argv);
|
|
|
|
ret = qr_main(argc, argv);
|
|
|
|
exit(ret);
|
2009-03-01 01:33:41 -08:00
|
|
|
return ret;
|
2009-02-25 03:00:07 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
EAPI char *
|
|
|
|
elm_quicklaunch_exe_path_get(const char *exe)
|
|
|
|
{
|
|
|
|
static char *path = NULL;
|
|
|
|
static Eina_List *pathlist = NULL;
|
2009-02-25 11:50:45 -08:00
|
|
|
const char *pathitr;
|
|
|
|
const Eina_List *l;
|
2009-02-25 03:00:07 -08:00
|
|
|
char buf[PATH_MAX];
|
|
|
|
if (exe[0] == '/') return strdup(exe);
|
|
|
|
if ((exe[0] == '.') && (exe[1] == '/')) return strdup(exe);
|
|
|
|
if ((exe[0] == '.') && (exe[1] == '.') && (exe[2] == '/')) return strdup(exe);
|
|
|
|
if (!path)
|
|
|
|
{
|
2010-11-29 05:14:37 -08:00
|
|
|
const char *p, *pp;
|
|
|
|
char *buf2;
|
|
|
|
path = getenv("PATH");
|
|
|
|
buf2 = alloca(strlen(path) + 1);
|
|
|
|
p = path;
|
|
|
|
pp = p;
|
|
|
|
for (;; )
|
|
|
|
{
|
|
|
|
if ((*p == ':') || (!*p))
|
|
|
|
{
|
|
|
|
int len;
|
|
|
|
|
|
|
|
len = p - pp;
|
|
|
|
strncpy(buf2, pp, len);
|
|
|
|
buf2[len] = 0;
|
|
|
|
pathlist = eina_list_append(pathlist, eina_stringshare_add(buf2));
|
|
|
|
if (!*p) break;
|
|
|
|
p++;
|
|
|
|
pp = p;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
if (!*p) break;
|
|
|
|
p++;
|
|
|
|
}
|
|
|
|
}
|
2009-02-25 03:00:07 -08:00
|
|
|
}
|
2009-02-25 11:50:45 -08:00
|
|
|
EINA_LIST_FOREACH(pathlist, l, pathitr)
|
2009-02-25 03:00:07 -08:00
|
|
|
{
|
2010-11-29 05:14:37 -08:00
|
|
|
snprintf(buf, sizeof(buf), "%s/%s", pathitr, exe);
|
|
|
|
if (!access(buf, R_OK | X_OK)) return strdup(buf);
|
2009-02-25 03:00:07 -08:00
|
|
|
}
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2008-09-29 23:58:56 -07:00
|
|
|
EAPI void
|
|
|
|
elm_run(void)
|
|
|
|
{
|
|
|
|
ecore_main_loop_begin();
|
|
|
|
}
|
|
|
|
|
|
|
|
EAPI void
|
|
|
|
elm_exit(void)
|
|
|
|
{
|
|
|
|
ecore_main_loop_quit();
|
|
|
|
}
|
2009-02-02 21:09:03 -08:00
|
|
|
|
2009-12-01 05:32:48 -08:00
|
|
|
EAPI Eina_Bool
|
2010-11-29 05:14:37 -08:00
|
|
|
elm_policy_set(unsigned int policy,
|
|
|
|
int value)
|
2009-12-01 05:32:48 -08:00
|
|
|
{
|
|
|
|
Elm_Event_Policy_Changed *ev;
|
|
|
|
|
|
|
|
if (policy >= ELM_POLICY_LAST)
|
|
|
|
return EINA_FALSE;
|
|
|
|
|
|
|
|
if (value == _elm_policies[policy])
|
|
|
|
return EINA_TRUE;
|
|
|
|
|
|
|
|
/* TODO: validade policy? */
|
|
|
|
|
|
|
|
ev = malloc(sizeof(*ev));
|
|
|
|
ev->policy = policy;
|
|
|
|
ev->new_value = value;
|
|
|
|
ev->old_value = _elm_policies[policy];
|
|
|
|
|
|
|
|
_elm_policies[policy] = value;
|
|
|
|
|
|
|
|
ecore_event_add(ELM_EVENT_POLICY_CHANGED, ev, NULL, NULL);
|
|
|
|
|
|
|
|
return EINA_TRUE;
|
|
|
|
}
|
|
|
|
|
|
|
|
EAPI int
|
|
|
|
elm_policy_get(unsigned int policy)
|
|
|
|
{
|
|
|
|
if (policy >= ELM_POLICY_LAST)
|
|
|
|
return 0;
|
|
|
|
return _elm_policies[policy];
|
|
|
|
}
|
|
|
|
|
2011-10-19 07:17:14 -07:00
|
|
|
EAPI void
|
|
|
|
elm_language_set(const char *lang)
|
|
|
|
{
|
|
|
|
setlocale(LC_ALL, lang);
|
|
|
|
_elm_win_translate();
|
|
|
|
}
|
|
|
|
|
2011-02-10 00:29:24 -08:00
|
|
|
EAPI Eina_Bool
|
|
|
|
elm_object_mirrored_get(const Evas_Object *obj)
|
|
|
|
{
|
|
|
|
EINA_SAFETY_ON_NULL_RETURN_VAL(obj, EINA_FALSE);
|
|
|
|
return elm_widget_mirrored_get(obj);
|
|
|
|
}
|
|
|
|
|
|
|
|
EAPI void
|
|
|
|
elm_object_mirrored_set(Evas_Object *obj, Eina_Bool mirrored)
|
|
|
|
{
|
|
|
|
EINA_SAFETY_ON_NULL_RETURN(obj);
|
|
|
|
elm_widget_mirrored_set(obj, mirrored);
|
|
|
|
}
|
|
|
|
|
|
|
|
EAPI Eina_Bool
|
|
|
|
elm_object_mirrored_automatic_get(const Evas_Object *obj)
|
|
|
|
{
|
|
|
|
EINA_SAFETY_ON_NULL_RETURN_VAL(obj, EINA_FALSE);
|
|
|
|
return elm_widget_mirrored_automatic_get(obj);
|
|
|
|
}
|
|
|
|
|
|
|
|
EAPI void
|
|
|
|
elm_object_mirrored_automatic_set(Evas_Object *obj, Eina_Bool automatic)
|
|
|
|
{
|
|
|
|
EINA_SAFETY_ON_NULL_RETURN(obj);
|
|
|
|
elm_widget_mirrored_automatic_set(obj, automatic);
|
|
|
|
}
|
|
|
|
|
2011-08-10 12:56:17 -07:00
|
|
|
/**
|
|
|
|
* @}
|
|
|
|
*/
|
|
|
|
|
2009-02-02 21:09:03 -08:00
|
|
|
EAPI void
|
2010-11-29 05:14:37 -08:00
|
|
|
elm_object_scale_set(Evas_Object *obj,
|
|
|
|
double scale)
|
2009-02-02 21:09:03 -08:00
|
|
|
{
|
2010-12-03 06:08:33 -08:00
|
|
|
EINA_SAFETY_ON_NULL_RETURN(obj);
|
2009-11-29 08:02:05 -08:00
|
|
|
elm_widget_scale_set(obj, scale);
|
2009-02-02 21:09:03 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
EAPI double
|
2009-02-25 07:54:26 -08:00
|
|
|
elm_object_scale_get(const Evas_Object *obj)
|
2009-02-02 21:09:03 -08:00
|
|
|
{
|
2010-12-03 06:08:33 -08:00
|
|
|
EINA_SAFETY_ON_NULL_RETURN_VAL(obj, 0.0);
|
2009-02-02 21:09:03 -08:00
|
|
|
return elm_widget_scale_get(obj);
|
|
|
|
}
|
|
|
|
|
2011-06-28 23:40:59 -07:00
|
|
|
EAPI void
|
2011-08-03 05:27:57 -07:00
|
|
|
elm_object_text_part_set(Evas_Object *obj, const char *part, const char *label)
|
2011-06-28 23:40:59 -07:00
|
|
|
{
|
|
|
|
EINA_SAFETY_ON_NULL_RETURN(obj);
|
2011-08-03 05:27:57 -07:00
|
|
|
elm_widget_text_part_set(obj, part, label);
|
2011-06-28 23:40:59 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
EAPI const char *
|
2011-08-03 05:27:57 -07:00
|
|
|
elm_object_text_part_get(const Evas_Object *obj, const char *part)
|
2011-06-28 23:40:59 -07:00
|
|
|
{
|
|
|
|
EINA_SAFETY_ON_NULL_RETURN_VAL(obj, NULL);
|
2011-08-03 05:27:57 -07:00
|
|
|
return elm_widget_text_part_get(obj, part);
|
2011-06-28 23:40:59 -07:00
|
|
|
}
|
|
|
|
|
2011-11-16 12:17:25 -08:00
|
|
|
EAPI void
|
|
|
|
elm_object_part_text_set(Evas_Object *obj, const char *part, const char *label)
|
|
|
|
{
|
|
|
|
EINA_SAFETY_ON_NULL_RETURN(obj);
|
|
|
|
elm_widget_text_part_set(obj, part, label);
|
|
|
|
}
|
|
|
|
|
|
|
|
EAPI const char *
|
|
|
|
elm_object_part_text_get(const Evas_Object *obj, const char *part)
|
|
|
|
{
|
|
|
|
EINA_SAFETY_ON_NULL_RETURN_VAL(obj, NULL);
|
|
|
|
return elm_widget_text_part_get(obj, part);
|
|
|
|
}
|
|
|
|
|
2011-10-19 07:17:14 -07:00
|
|
|
EAPI void
|
|
|
|
elm_object_domain_translatable_text_part_set(Evas_Object *obj, const char *part, const char *domain, const char *text)
|
|
|
|
{
|
|
|
|
EINA_SAFETY_ON_NULL_RETURN(obj);
|
|
|
|
elm_widget_domain_translatable_text_part_set(obj, part, domain, text);
|
|
|
|
}
|
|
|
|
|
|
|
|
EAPI const char *
|
|
|
|
elm_object_translatable_text_part_get(const Evas_Object *obj, const char *part)
|
|
|
|
{
|
|
|
|
EINA_SAFETY_ON_NULL_RETURN_VAL(obj, NULL);
|
|
|
|
return elm_widget_translatable_text_part_get(obj, part);
|
|
|
|
}
|
|
|
|
|
2011-11-17 13:02:31 -08:00
|
|
|
EAPI void
|
|
|
|
elm_object_part_content_set(Evas_Object *obj, const char *part, Evas_Object *content)
|
|
|
|
{
|
|
|
|
EINA_SAFETY_ON_NULL_RETURN(obj);
|
|
|
|
elm_widget_content_part_set(obj, part, content);
|
|
|
|
}
|
|
|
|
|
2011-07-27 02:49:14 -07:00
|
|
|
EAPI void
|
2011-08-03 05:27:57 -07:00
|
|
|
elm_object_content_part_set(Evas_Object *obj, const char *part, Evas_Object *content)
|
2011-07-27 02:49:14 -07:00
|
|
|
{
|
|
|
|
EINA_SAFETY_ON_NULL_RETURN(obj);
|
2011-08-03 05:27:57 -07:00
|
|
|
elm_widget_content_part_set(obj, part, content);
|
2011-07-27 02:49:14 -07:00
|
|
|
}
|
|
|
|
|
2011-11-17 13:02:31 -08:00
|
|
|
|
|
|
|
EAPI Evas_Object *
|
|
|
|
elm_object_part_content_get(const Evas_Object *obj, const char *part)
|
|
|
|
{
|
|
|
|
EINA_SAFETY_ON_NULL_RETURN_VAL(obj, NULL);
|
|
|
|
return elm_widget_content_part_get(obj, part);
|
|
|
|
}
|
|
|
|
|
2011-07-27 02:49:14 -07:00
|
|
|
EAPI Evas_Object *
|
2011-08-03 05:27:57 -07:00
|
|
|
elm_object_content_part_get(const Evas_Object *obj, const char *part)
|
2011-07-27 02:49:14 -07:00
|
|
|
{
|
|
|
|
EINA_SAFETY_ON_NULL_RETURN_VAL(obj, NULL);
|
2011-08-03 05:27:57 -07:00
|
|
|
return elm_widget_content_part_get(obj, part);
|
2011-07-27 02:49:14 -07:00
|
|
|
}
|
|
|
|
|
2011-11-17 13:02:31 -08:00
|
|
|
EAPI Evas_Object *
|
|
|
|
elm_object_part_content_unset(Evas_Object *obj, const char *part)
|
|
|
|
{
|
|
|
|
EINA_SAFETY_ON_NULL_RETURN_VAL(obj, NULL);
|
|
|
|
return elm_widget_content_part_unset(obj, part);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2011-07-27 02:49:14 -07:00
|
|
|
EAPI Evas_Object *
|
2011-08-03 05:27:57 -07:00
|
|
|
elm_object_content_part_unset(Evas_Object *obj, const char *part)
|
2011-07-27 02:49:14 -07:00
|
|
|
{
|
|
|
|
EINA_SAFETY_ON_NULL_RETURN_VAL(obj, NULL);
|
2011-08-03 05:27:57 -07:00
|
|
|
return elm_widget_content_part_unset(obj, part);
|
2011-07-27 02:49:14 -07:00
|
|
|
}
|
|
|
|
|
2010-11-29 05:14:45 -08:00
|
|
|
EAPI double
|
|
|
|
elm_scale_get(void)
|
|
|
|
{
|
|
|
|
return _elm_config->scale;
|
|
|
|
}
|
|
|
|
|
|
|
|
EAPI void
|
|
|
|
elm_scale_set(double scale)
|
|
|
|
{
|
|
|
|
if (_elm_config->scale == scale) return;
|
|
|
|
_elm_config->scale = scale;
|
|
|
|
_elm_rescale();
|
|
|
|
}
|
|
|
|
|
|
|
|
EAPI void
|
|
|
|
elm_scale_all_set(double scale)
|
|
|
|
{
|
2011-10-19 05:46:56 -07:00
|
|
|
elm_scale_set(scale);
|
|
|
|
_elm_config_all_update();
|
2010-11-29 05:14:45 -08:00
|
|
|
}
|
|
|
|
|
2011-08-25 00:00:39 -07:00
|
|
|
EAPI Eina_Bool
|
|
|
|
elm_password_show_last_get(void)
|
|
|
|
{
|
|
|
|
return _elm_config->password_show_last;
|
|
|
|
}
|
|
|
|
|
|
|
|
EAPI void
|
|
|
|
elm_password_show_last_set(Eina_Bool password_show_last)
|
|
|
|
{
|
|
|
|
if (_elm_config->password_show_last == password_show_last) return;
|
|
|
|
_elm_config->password_show_last = password_show_last;
|
|
|
|
edje_password_show_last_set(_elm_config->password_show_last);
|
|
|
|
}
|
|
|
|
|
|
|
|
EAPI double
|
|
|
|
elm_password_show_last_timeout_get(void)
|
|
|
|
{
|
|
|
|
return _elm_config->password_show_last_timeout;
|
|
|
|
}
|
|
|
|
|
|
|
|
EAPI void
|
|
|
|
elm_password_show_last_timeout_set(double password_show_last_timeout)
|
|
|
|
{
|
|
|
|
if (_elm_config->password_show_last_timeout == password_show_last_timeout) return;
|
|
|
|
_elm_config->password_show_last_timeout = password_show_last_timeout;
|
|
|
|
edje_password_show_last_timeout_set(_elm_config->password_show_last_timeout);
|
|
|
|
}
|
|
|
|
|
2009-04-22 21:03:27 -07:00
|
|
|
EAPI void
|
2010-11-29 05:14:37 -08:00
|
|
|
elm_object_style_set(Evas_Object *obj,
|
|
|
|
const char *style)
|
2009-04-22 21:03:27 -07:00
|
|
|
{
|
2010-12-03 06:08:33 -08:00
|
|
|
EINA_SAFETY_ON_NULL_RETURN(obj);
|
2009-04-22 21:03:27 -07:00
|
|
|
elm_widget_style_set(obj, style);
|
|
|
|
}
|
|
|
|
|
|
|
|
EAPI const char *
|
|
|
|
elm_object_style_get(const Evas_Object *obj)
|
|
|
|
{
|
2010-12-03 06:08:33 -08:00
|
|
|
EINA_SAFETY_ON_NULL_RETURN_VAL(obj, NULL);
|
2009-04-22 21:03:27 -07:00
|
|
|
return elm_widget_style_get(obj);
|
|
|
|
}
|
|
|
|
|
2009-08-16 04:35:55 -07:00
|
|
|
EAPI void
|
2010-11-29 05:14:37 -08:00
|
|
|
elm_object_disabled_set(Evas_Object *obj,
|
|
|
|
Eina_Bool disabled)
|
2009-08-16 04:35:55 -07:00
|
|
|
{
|
2010-12-03 06:08:33 -08:00
|
|
|
EINA_SAFETY_ON_NULL_RETURN(obj);
|
2009-08-16 04:35:55 -07:00
|
|
|
elm_widget_disabled_set(obj, disabled);
|
|
|
|
}
|
|
|
|
|
|
|
|
EAPI Eina_Bool
|
|
|
|
elm_object_disabled_get(const Evas_Object *obj)
|
|
|
|
{
|
2010-12-03 06:08:33 -08:00
|
|
|
EINA_SAFETY_ON_NULL_RETURN_VAL(obj, EINA_FALSE);
|
2009-08-16 04:35:55 -07:00
|
|
|
return elm_widget_disabled_get(obj);
|
|
|
|
}
|
|
|
|
|
2010-10-28 13:57:44 -07:00
|
|
|
EAPI Eina_Bool
|
|
|
|
elm_config_save(void)
|
|
|
|
{
|
|
|
|
return _elm_config_save();
|
|
|
|
}
|
|
|
|
|
|
|
|
EAPI void
|
|
|
|
elm_config_reload(void)
|
|
|
|
{
|
|
|
|
_elm_config_reload();
|
|
|
|
}
|
2010-10-25 06:08:19 -07:00
|
|
|
|
|
|
|
EAPI const char *
|
2010-10-28 13:57:44 -07:00
|
|
|
elm_profile_current_get(void)
|
2010-10-25 06:08:19 -07:00
|
|
|
{
|
|
|
|
return _elm_config_current_profile_get();
|
|
|
|
}
|
|
|
|
|
2010-10-28 13:57:44 -07:00
|
|
|
EAPI const char *
|
2010-11-29 05:14:37 -08:00
|
|
|
elm_profile_dir_get(const char *profile,
|
|
|
|
Eina_Bool is_user)
|
2010-10-25 06:08:19 -07:00
|
|
|
{
|
2010-10-28 13:57:44 -07:00
|
|
|
return _elm_config_profile_dir_get(profile, is_user);
|
2010-10-25 06:08:19 -07:00
|
|
|
}
|
|
|
|
|
2010-10-25 10:36:07 -07:00
|
|
|
EAPI void
|
|
|
|
elm_profile_dir_free(const char *p_dir)
|
|
|
|
{
|
|
|
|
free((void *)p_dir);
|
|
|
|
}
|
|
|
|
|
2010-10-25 06:08:19 -07:00
|
|
|
EAPI Eina_List *
|
|
|
|
elm_profile_list_get(void)
|
|
|
|
{
|
|
|
|
return _elm_config_profiles_list();
|
|
|
|
}
|
|
|
|
|
2010-10-25 10:36:07 -07:00
|
|
|
EAPI void
|
|
|
|
elm_profile_list_free(Eina_List *l)
|
|
|
|
{
|
2010-10-28 13:57:44 -07:00
|
|
|
const char *dir;
|
2010-10-25 10:36:07 -07:00
|
|
|
|
2010-10-28 13:57:44 -07:00
|
|
|
EINA_LIST_FREE(l, dir)
|
|
|
|
eina_stringshare_del(dir);
|
2010-10-25 10:36:07 -07:00
|
|
|
}
|
|
|
|
|
2010-10-25 06:08:19 -07:00
|
|
|
EAPI void
|
|
|
|
elm_profile_set(const char *profile)
|
|
|
|
{
|
2010-12-03 06:08:33 -08:00
|
|
|
EINA_SAFETY_ON_NULL_RETURN(profile);
|
2010-10-25 06:08:19 -07:00
|
|
|
_elm_config_profile_set(profile);
|
|
|
|
}
|
|
|
|
|
|
|
|
EAPI void
|
|
|
|
elm_profile_all_set(const char *profile)
|
|
|
|
{
|
2011-10-19 05:46:56 -07:00
|
|
|
_elm_config_profile_set(profile);
|
|
|
|
_elm_config_all_update();
|
2010-10-25 06:08:19 -07:00
|
|
|
}
|
|
|
|
|
2010-11-01 14:10:14 -07:00
|
|
|
EAPI const char *
|
|
|
|
elm_engine_current_get(void)
|
2012-02-14 18:29:57 -08:00
|
|
|
{
|
|
|
|
return elm_engine_get();
|
|
|
|
}
|
|
|
|
|
|
|
|
EAPI const char *
|
|
|
|
elm_engine_get(void)
|
2010-11-01 14:10:14 -07:00
|
|
|
{
|
|
|
|
return _elm_config->engine;
|
|
|
|
}
|
|
|
|
|
|
|
|
EAPI void
|
|
|
|
elm_engine_set(const char *engine)
|
|
|
|
{
|
2010-12-03 06:08:33 -08:00
|
|
|
EINA_SAFETY_ON_NULL_RETURN(engine);
|
2010-11-01 14:10:14 -07:00
|
|
|
|
|
|
|
_elm_config_engine_set(engine);
|
|
|
|
}
|
2010-11-18 02:01:24 -08:00
|
|
|
|
|
|
|
EAPI const Eina_List *
|
|
|
|
elm_text_classes_list_get(void)
|
|
|
|
{
|
|
|
|
return _elm_config_text_classes_get();
|
|
|
|
}
|
|
|
|
|
|
|
|
EAPI void
|
|
|
|
elm_text_classes_list_free(const Eina_List *list)
|
|
|
|
{
|
|
|
|
_elm_config_text_classes_free((Eina_List *)list);
|
|
|
|
}
|
|
|
|
|
|
|
|
EAPI const Eina_List *
|
|
|
|
elm_font_overlay_list_get(void)
|
|
|
|
{
|
|
|
|
return _elm_config_font_overlays_list();
|
|
|
|
}
|
|
|
|
|
|
|
|
EAPI void
|
|
|
|
elm_font_overlay_set(const char *text_class,
|
|
|
|
const char *font,
|
|
|
|
Evas_Font_Size size)
|
|
|
|
{
|
|
|
|
_elm_config_font_overlay_set(text_class, font, size);
|
|
|
|
}
|
|
|
|
|
|
|
|
EAPI void
|
|
|
|
elm_font_overlay_unset(const char *text_class)
|
|
|
|
{
|
|
|
|
_elm_config_font_overlay_remove(text_class);
|
|
|
|
}
|
|
|
|
|
|
|
|
EAPI void
|
|
|
|
elm_font_overlay_apply(void)
|
|
|
|
{
|
|
|
|
_elm_config_font_overlay_apply();
|
|
|
|
}
|
|
|
|
|
|
|
|
EAPI void
|
|
|
|
elm_font_overlay_all_apply(void)
|
|
|
|
{
|
2011-10-19 05:46:56 -07:00
|
|
|
elm_font_overlay_apply();
|
|
|
|
_elm_config_all_update();
|
2010-11-18 02:01:24 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
EAPI Elm_Font_Properties *
|
|
|
|
elm_font_properties_get(const char *font)
|
|
|
|
{
|
2010-12-03 06:08:33 -08:00
|
|
|
EINA_SAFETY_ON_NULL_RETURN_VAL(font, NULL);
|
2010-11-18 02:01:24 -08:00
|
|
|
return _elm_font_properties_get(NULL, font);
|
|
|
|
}
|
|
|
|
|
|
|
|
EAPI void
|
|
|
|
elm_font_properties_free(Elm_Font_Properties *efp)
|
|
|
|
{
|
|
|
|
const char *str;
|
|
|
|
|
2010-12-03 06:08:33 -08:00
|
|
|
EINA_SAFETY_ON_NULL_RETURN(efp);
|
2010-11-18 02:01:24 -08:00
|
|
|
EINA_LIST_FREE(efp->styles, str)
|
|
|
|
if (str) eina_stringshare_del(str);
|
|
|
|
if (efp->name) eina_stringshare_del(efp->name);
|
|
|
|
free(efp);
|
|
|
|
}
|
|
|
|
|
|
|
|
EAPI const char *
|
|
|
|
elm_font_fontconfig_name_get(const char *name,
|
|
|
|
const char *style)
|
|
|
|
{
|
|
|
|
char buf[256];
|
|
|
|
|
2010-12-03 06:08:33 -08:00
|
|
|
EINA_SAFETY_ON_NULL_RETURN_VAL(name, NULL);
|
2010-11-18 02:01:24 -08:00
|
|
|
if (!style || style[0] == 0) return eina_stringshare_add(name);
|
|
|
|
snprintf(buf, 256, "%s" ELM_FONT_TOKEN_STYLE "%s", name, style);
|
|
|
|
return eina_stringshare_add(buf);
|
|
|
|
}
|
|
|
|
|
|
|
|
EAPI void
|
|
|
|
elm_font_fontconfig_name_free(const char *name)
|
|
|
|
{
|
|
|
|
eina_stringshare_del(name);
|
|
|
|
}
|
|
|
|
|
|
|
|
EAPI Eina_Hash *
|
|
|
|
elm_font_available_hash_add(Eina_List *list)
|
|
|
|
{
|
|
|
|
Eina_Hash *font_hash;
|
|
|
|
Eina_List *l;
|
|
|
|
void *key;
|
|
|
|
|
|
|
|
font_hash = NULL;
|
|
|
|
|
|
|
|
/* populate with default font families */
|
|
|
|
font_hash = _elm_font_available_hash_add(font_hash, "Sans:style=Regular");
|
|
|
|
font_hash = _elm_font_available_hash_add(font_hash, "Sans:style=Bold");
|
|
|
|
font_hash = _elm_font_available_hash_add(font_hash, "Sans:style=Oblique");
|
|
|
|
font_hash = _elm_font_available_hash_add(font_hash,
|
|
|
|
"Sans:style=Bold Oblique");
|
|
|
|
|
|
|
|
font_hash = _elm_font_available_hash_add(font_hash, "Serif:style=Regular");
|
|
|
|
font_hash = _elm_font_available_hash_add(font_hash, "Serif:style=Bold");
|
|
|
|
font_hash = _elm_font_available_hash_add(font_hash, "Serif:style=Oblique");
|
|
|
|
font_hash = _elm_font_available_hash_add(font_hash,
|
|
|
|
"Serif:style=Bold Oblique");
|
|
|
|
|
|
|
|
font_hash = _elm_font_available_hash_add(font_hash,
|
|
|
|
"Monospace:style=Regular");
|
|
|
|
font_hash = _elm_font_available_hash_add(font_hash,
|
|
|
|
"Monospace:style=Bold");
|
|
|
|
font_hash = _elm_font_available_hash_add(font_hash,
|
|
|
|
"Monospace:style=Oblique");
|
|
|
|
font_hash = _elm_font_available_hash_add(font_hash,
|
|
|
|
"Monospace:style=Bold Oblique");
|
|
|
|
|
|
|
|
EINA_LIST_FOREACH(list, l, key)
|
|
|
|
font_hash = _elm_font_available_hash_add(font_hash, key);
|
|
|
|
|
|
|
|
return font_hash;
|
|
|
|
}
|
|
|
|
|
|
|
|
EAPI void
|
|
|
|
elm_font_available_hash_del(Eina_Hash *hash)
|
|
|
|
{
|
|
|
|
_elm_font_available_hash_del(hash);
|
|
|
|
}
|
|
|
|
|
2009-03-12 22:50:38 -07:00
|
|
|
EAPI Evas_Coord
|
|
|
|
elm_finger_size_get(void)
|
|
|
|
{
|
|
|
|
return _elm_config->finger_size;
|
|
|
|
}
|
|
|
|
|
|
|
|
EAPI void
|
|
|
|
elm_finger_size_set(Evas_Coord size)
|
|
|
|
{
|
|
|
|
if (_elm_config->finger_size == size) return;
|
|
|
|
_elm_config->finger_size = size;
|
2010-11-29 05:14:37 -08:00
|
|
|
_elm_rescale();
|
2009-03-12 22:50:38 -07:00
|
|
|
}
|
|
|
|
|
2010-01-15 01:32:43 -08:00
|
|
|
EAPI void
|
|
|
|
elm_finger_size_all_set(Evas_Coord size)
|
|
|
|
{
|
2011-10-19 05:46:56 -07:00
|
|
|
elm_finger_size_set(size);
|
|
|
|
_elm_config_all_update();
|
2010-01-15 01:32:43 -08:00
|
|
|
}
|
|
|
|
|
2010-11-29 05:14:45 -08:00
|
|
|
EAPI void
|
|
|
|
elm_coords_finger_size_adjust(int times_w,
|
|
|
|
Evas_Coord *w,
|
|
|
|
int times_h,
|
|
|
|
Evas_Coord *h)
|
|
|
|
{
|
|
|
|
if ((w) && (*w < (_elm_config->finger_size * times_w)))
|
|
|
|
*w = _elm_config->finger_size * times_w;
|
|
|
|
if ((h) && (*h < (_elm_config->finger_size * times_h)))
|
|
|
|
*h = _elm_config->finger_size * times_h;
|
|
|
|
}
|
|
|
|
|
2010-11-21 22:56:06 -08:00
|
|
|
EAPI void
|
|
|
|
elm_all_flush(void)
|
2010-10-04 09:55:32 -07:00
|
|
|
{
|
2010-11-21 22:56:06 -08:00
|
|
|
const Eina_List *l;
|
|
|
|
Evas_Object *obj;
|
|
|
|
|
2011-01-31 00:32:15 -08:00
|
|
|
edje_file_cache_flush();
|
|
|
|
edje_collection_cache_flush();
|
|
|
|
eet_clearcache();
|
2010-11-21 22:56:06 -08:00
|
|
|
EINA_LIST_FOREACH(_elm_win_list, l, obj)
|
|
|
|
{
|
|
|
|
Evas *e = evas_object_evas_get(obj);
|
|
|
|
evas_image_cache_flush(e);
|
|
|
|
evas_font_cache_flush(e);
|
|
|
|
evas_render_dump(e);
|
|
|
|
}
|
2010-10-04 09:55:32 -07:00
|
|
|
}
|
|
|
|
|
2010-11-22 22:10:58 -08:00
|
|
|
EAPI int
|
|
|
|
elm_cache_flush_interval_get(void)
|
|
|
|
{
|
|
|
|
return _elm_config->cache_flush_poll_interval;
|
|
|
|
}
|
|
|
|
|
|
|
|
EAPI void
|
|
|
|
elm_cache_flush_interval_set(int size)
|
|
|
|
{
|
|
|
|
if (_elm_config->cache_flush_poll_interval == size) return;
|
|
|
|
_elm_config->cache_flush_poll_interval = size;
|
|
|
|
|
|
|
|
_elm_recache();
|
|
|
|
}
|
|
|
|
|
|
|
|
EAPI void
|
|
|
|
elm_cache_flush_interval_all_set(int size)
|
|
|
|
{
|
2011-10-19 05:46:56 -07:00
|
|
|
elm_cache_flush_interval_set(size);
|
|
|
|
_elm_config_all_update();
|
2010-11-22 22:10:58 -08:00
|
|
|
}
|
|
|
|
|
2010-12-24 08:02:30 -08:00
|
|
|
EAPI Eina_Bool
|
2011-03-17 17:20:29 -07:00
|
|
|
elm_cache_flush_enabled_get(void)
|
2010-12-24 08:02:30 -08:00
|
|
|
{
|
|
|
|
return _elm_config->cache_flush_enable;
|
|
|
|
}
|
|
|
|
|
|
|
|
EAPI void
|
|
|
|
elm_cache_flush_enabled_set(Eina_Bool enabled)
|
|
|
|
{
|
|
|
|
enabled = !!enabled;
|
|
|
|
if (_elm_config->cache_flush_enable == enabled) return;
|
|
|
|
_elm_config->cache_flush_enable = enabled;
|
|
|
|
|
|
|
|
_elm_recache();
|
|
|
|
}
|
|
|
|
|
|
|
|
EAPI void
|
|
|
|
elm_cache_flush_enabled_all_set(Eina_Bool enabled)
|
|
|
|
{
|
2011-10-19 05:46:56 -07:00
|
|
|
elm_cache_flush_enabled_set(enabled);
|
|
|
|
_elm_config_all_update();
|
2010-12-24 08:02:30 -08:00
|
|
|
}
|
|
|
|
|
2010-11-21 22:56:06 -08:00
|
|
|
EAPI int
|
|
|
|
elm_font_cache_get(void)
|
|
|
|
{
|
|
|
|
return _elm_config->font_cache;
|
|
|
|
}
|
|
|
|
|
2010-10-04 09:55:32 -07:00
|
|
|
EAPI void
|
2010-11-21 22:56:06 -08:00
|
|
|
elm_font_cache_set(int size)
|
2010-10-04 09:55:32 -07:00
|
|
|
{
|
2010-11-21 22:56:06 -08:00
|
|
|
if (_elm_config->font_cache == size) return;
|
|
|
|
_elm_config->font_cache = size;
|
|
|
|
|
|
|
|
_elm_recache();
|
2010-10-04 09:55:32 -07:00
|
|
|
}
|
|
|
|
|
2010-11-21 22:56:06 -08:00
|
|
|
EAPI void
|
|
|
|
elm_font_cache_all_set(int size)
|
2010-10-04 09:55:32 -07:00
|
|
|
{
|
2011-10-19 05:46:56 -07:00
|
|
|
elm_font_cache_set(size);
|
|
|
|
_elm_config_all_update();
|
2010-10-04 09:55:32 -07:00
|
|
|
}
|
|
|
|
|
2010-11-21 22:56:06 -08:00
|
|
|
EAPI int
|
|
|
|
elm_image_cache_get(void)
|
|
|
|
{
|
|
|
|
return _elm_config->image_cache;
|
|
|
|
}
|
|
|
|
|
2010-10-04 09:55:32 -07:00
|
|
|
EAPI void
|
2010-11-21 22:56:06 -08:00
|
|
|
elm_image_cache_set(int size)
|
2010-10-04 09:55:32 -07:00
|
|
|
{
|
2010-11-21 22:56:06 -08:00
|
|
|
if (_elm_config->image_cache == size) return;
|
|
|
|
_elm_config->image_cache = size;
|
|
|
|
|
|
|
|
_elm_recache();
|
|
|
|
}
|
|
|
|
|
|
|
|
EAPI void
|
|
|
|
elm_image_cache_all_set(int size)
|
|
|
|
{
|
2011-10-19 05:46:56 -07:00
|
|
|
elm_image_cache_set(size);
|
|
|
|
_elm_config_all_update();
|
2010-10-04 09:55:32 -07:00
|
|
|
}
|
|
|
|
|
2010-11-22 22:10:58 -08:00
|
|
|
EAPI int
|
|
|
|
elm_edje_file_cache_get(void)
|
|
|
|
{
|
|
|
|
return _elm_config->edje_cache;
|
|
|
|
}
|
|
|
|
|
|
|
|
EAPI void
|
|
|
|
elm_edje_file_cache_set(int size)
|
|
|
|
{
|
|
|
|
if (_elm_config->edje_cache == size) return;
|
|
|
|
_elm_config->edje_cache = size;
|
|
|
|
|
|
|
|
_elm_recache();
|
|
|
|
}
|
|
|
|
|
|
|
|
EAPI void
|
|
|
|
elm_edje_file_cache_all_set(int size)
|
|
|
|
{
|
2011-10-19 05:46:56 -07:00
|
|
|
elm_edje_file_cache_set(size);
|
|
|
|
_elm_config_all_update();
|
2010-11-22 22:10:58 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
EAPI int
|
|
|
|
elm_edje_collection_cache_get(void)
|
|
|
|
{
|
|
|
|
return _elm_config->edje_collection_cache;
|
|
|
|
}
|
|
|
|
|
|
|
|
EAPI void
|
|
|
|
elm_edje_collection_cache_set(int size)
|
|
|
|
{
|
|
|
|
if (_elm_config->edje_collection_cache == size) return;
|
|
|
|
_elm_config->edje_collection_cache = size;
|
|
|
|
|
|
|
|
_elm_recache();
|
|
|
|
}
|
|
|
|
|
|
|
|
EAPI void
|
|
|
|
elm_edje_collection_cache_all_set(int size)
|
|
|
|
{
|
2011-10-19 05:46:56 -07:00
|
|
|
elm_edje_collection_cache_set(size);
|
|
|
|
_elm_config_all_update();
|
2010-11-22 22:10:58 -08:00
|
|
|
}
|
|
|
|
|
2010-05-19 06:17:02 -07:00
|
|
|
EAPI Eina_Bool
|
2010-10-21 11:58:40 -07:00
|
|
|
elm_object_focus_get(const Evas_Object *obj)
|
2010-05-19 06:17:02 -07:00
|
|
|
{
|
2010-12-03 06:08:33 -08:00
|
|
|
EINA_SAFETY_ON_NULL_RETURN_VAL(obj, EINA_FALSE);
|
2010-05-19 06:17:02 -07:00
|
|
|
return elm_widget_focus_get(obj);
|
|
|
|
}
|
|
|
|
|
2009-05-19 06:50:06 -07:00
|
|
|
EAPI void
|
2011-08-03 04:46:23 -07:00
|
|
|
elm_object_focus_set(Evas_Object *obj,
|
|
|
|
Eina_Bool focus)
|
2009-05-19 06:50:06 -07:00
|
|
|
{
|
2010-12-03 06:08:33 -08:00
|
|
|
EINA_SAFETY_ON_NULL_RETURN(obj);
|
2011-08-03 04:46:23 -07:00
|
|
|
if (focus)
|
|
|
|
{
|
|
|
|
if (elm_widget_focus_get(obj)) return;
|
|
|
|
elm_widget_focus_cycle(obj, ELM_FOCUS_NEXT);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
if (!elm_widget_can_focus_get(obj)) return;
|
|
|
|
elm_widget_focused_object_clear(obj);
|
|
|
|
}
|
|
|
|
}
|
2010-10-08 13:16:52 -07:00
|
|
|
|
2011-08-03 04:46:23 -07:00
|
|
|
EAPI void
|
|
|
|
elm_object_focus(Evas_Object *obj)
|
|
|
|
{
|
|
|
|
EINA_SAFETY_ON_NULL_RETURN(obj);
|
|
|
|
elm_object_focus_set(obj, EINA_TRUE);
|
2009-05-19 06:50:06 -07:00
|
|
|
}
|
2009-09-07 21:40:27 -07:00
|
|
|
|
2010-01-09 18:18:50 -08:00
|
|
|
EAPI void
|
|
|
|
elm_object_unfocus(Evas_Object *obj)
|
|
|
|
{
|
2010-12-03 06:08:33 -08:00
|
|
|
EINA_SAFETY_ON_NULL_RETURN(obj);
|
2011-08-03 04:46:23 -07:00
|
|
|
elm_object_focus_set(obj, EINA_FALSE);
|
2010-01-09 18:18:50 -08:00
|
|
|
}
|
|
|
|
|
2009-10-22 01:04:34 -07:00
|
|
|
EAPI void
|
2010-11-29 05:14:37 -08:00
|
|
|
elm_object_focus_allow_set(Evas_Object *obj,
|
|
|
|
Eina_Bool enable)
|
2009-10-22 01:04:34 -07:00
|
|
|
{
|
2010-12-03 06:08:33 -08:00
|
|
|
EINA_SAFETY_ON_NULL_RETURN(obj);
|
2009-10-22 01:04:34 -07:00
|
|
|
elm_widget_can_focus_set(obj, enable);
|
|
|
|
}
|
|
|
|
|
|
|
|
EAPI Eina_Bool
|
2010-03-23 20:06:00 -07:00
|
|
|
elm_object_focus_allow_get(const Evas_Object *obj)
|
2009-10-22 01:04:34 -07:00
|
|
|
{
|
2010-12-03 06:08:33 -08:00
|
|
|
EINA_SAFETY_ON_NULL_RETURN_VAL(obj, EINA_FALSE);
|
2010-10-22 14:41:22 -07:00
|
|
|
return (elm_widget_can_focus_get(obj)) || (elm_widget_child_can_focus_get(obj));
|
2009-10-22 01:04:34 -07:00
|
|
|
}
|
|
|
|
|
2010-10-19 07:17:03 -07:00
|
|
|
EAPI void
|
2010-11-29 05:14:37 -08:00
|
|
|
elm_object_focus_custom_chain_set(Evas_Object *obj,
|
|
|
|
Eina_List *objs)
|
2010-10-19 07:17:03 -07:00
|
|
|
{
|
2010-12-03 06:08:33 -08:00
|
|
|
EINA_SAFETY_ON_NULL_RETURN(obj);
|
2010-10-19 07:17:03 -07:00
|
|
|
elm_widget_focus_custom_chain_set(obj, objs);
|
|
|
|
}
|
|
|
|
|
|
|
|
EAPI void
|
|
|
|
elm_object_focus_custom_chain_unset(Evas_Object *obj)
|
|
|
|
{
|
2010-12-03 06:08:33 -08:00
|
|
|
EINA_SAFETY_ON_NULL_RETURN(obj);
|
2010-10-19 07:17:03 -07:00
|
|
|
elm_widget_focus_custom_chain_unset(obj);
|
|
|
|
}
|
|
|
|
|
|
|
|
EAPI const Eina_List *
|
|
|
|
elm_object_focus_custom_chain_get(const Evas_Object *obj)
|
|
|
|
{
|
2010-12-03 06:08:33 -08:00
|
|
|
EINA_SAFETY_ON_NULL_RETURN_VAL(obj, NULL);
|
2010-10-19 07:17:03 -07:00
|
|
|
return elm_widget_focus_custom_chain_get(obj);
|
|
|
|
}
|
|
|
|
|
|
|
|
EAPI void
|
2010-11-29 05:14:37 -08:00
|
|
|
elm_object_focus_custom_chain_append(Evas_Object *obj,
|
|
|
|
Evas_Object *child,
|
|
|
|
Evas_Object *relative_child)
|
2010-10-19 07:17:03 -07:00
|
|
|
{
|
2010-12-03 06:08:33 -08:00
|
|
|
EINA_SAFETY_ON_NULL_RETURN(obj);
|
|
|
|
EINA_SAFETY_ON_NULL_RETURN(child);
|
2010-10-19 07:17:03 -07:00
|
|
|
elm_widget_focus_custom_chain_append(obj, child, relative_child);
|
|
|
|
}
|
|
|
|
|
|
|
|
EAPI void
|
2010-11-29 05:14:37 -08:00
|
|
|
elm_object_focus_custom_chain_prepend(Evas_Object *obj,
|
|
|
|
Evas_Object *child,
|
|
|
|
Evas_Object *relative_child)
|
2010-10-19 07:17:03 -07:00
|
|
|
{
|
2010-12-03 06:08:33 -08:00
|
|
|
EINA_SAFETY_ON_NULL_RETURN(obj);
|
|
|
|
EINA_SAFETY_ON_NULL_RETURN(child);
|
2010-10-19 07:17:03 -07:00
|
|
|
elm_widget_focus_custom_chain_prepend(obj, child, relative_child);
|
|
|
|
}
|
|
|
|
|
2010-10-20 05:38:27 -07:00
|
|
|
EAPI void
|
2010-11-29 05:14:37 -08:00
|
|
|
elm_object_focus_cycle(Evas_Object *obj,
|
|
|
|
Elm_Focus_Direction dir)
|
2010-10-20 05:38:27 -07:00
|
|
|
{
|
2010-12-03 06:08:33 -08:00
|
|
|
EINA_SAFETY_ON_NULL_RETURN(obj);
|
2010-10-20 05:38:27 -07:00
|
|
|
elm_widget_focus_cycle(obj, dir);
|
|
|
|
}
|
|
|
|
|
|
|
|
EAPI void
|
2010-11-29 05:14:37 -08:00
|
|
|
elm_object_focus_direction_go(Evas_Object *obj,
|
|
|
|
int x,
|
|
|
|
int y)
|
2010-10-20 05:38:27 -07:00
|
|
|
{
|
2010-12-03 06:08:33 -08:00
|
|
|
EINA_SAFETY_ON_NULL_RETURN(obj);
|
2010-10-20 05:38:27 -07:00
|
|
|
elm_widget_focus_direction_go(obj, x, y);
|
|
|
|
}
|
|
|
|
|
2011-07-27 23:58:29 -07:00
|
|
|
EAPI void
|
|
|
|
elm_object_tree_unfocusable_set(Evas_Object *obj,
|
|
|
|
Eina_Bool tree_unfocusable)
|
|
|
|
{
|
|
|
|
EINA_SAFETY_ON_NULL_RETURN(obj);
|
|
|
|
elm_widget_tree_unfocusable_set(obj, tree_unfocusable);
|
|
|
|
}
|
|
|
|
|
|
|
|
EAPI Eina_Bool
|
|
|
|
elm_object_tree_unfocusable_get(const Evas_Object *obj)
|
|
|
|
{
|
|
|
|
EINA_SAFETY_ON_NULL_RETURN_VAL(obj, EINA_FALSE);
|
|
|
|
return elm_widget_tree_unfocusable_get(obj);
|
|
|
|
}
|
|
|
|
|
2010-11-21 22:56:06 -08:00
|
|
|
EAPI Eina_Bool
|
2010-11-29 05:15:09 -08:00
|
|
|
elm_focus_highlight_enabled_get(void)
|
2010-11-21 22:56:06 -08:00
|
|
|
{
|
|
|
|
return _elm_config->focus_highlight_enable;
|
|
|
|
}
|
|
|
|
|
|
|
|
EAPI void
|
2010-11-29 05:15:09 -08:00
|
|
|
elm_focus_highlight_enabled_set(Eina_Bool enable)
|
2010-11-21 22:56:06 -08:00
|
|
|
{
|
|
|
|
_elm_config->focus_highlight_enable = !!enable;
|
|
|
|
}
|
|
|
|
|
|
|
|
EAPI Eina_Bool
|
|
|
|
elm_focus_highlight_animate_get(void)
|
|
|
|
{
|
|
|
|
return _elm_config->focus_highlight_animate;
|
|
|
|
}
|
|
|
|
|
|
|
|
EAPI void
|
|
|
|
elm_focus_highlight_animate_set(Eina_Bool animate)
|
|
|
|
{
|
|
|
|
_elm_config->focus_highlight_animate = !!animate;
|
|
|
|
}
|
|
|
|
|
2010-12-06 04:46:10 -08:00
|
|
|
EAPI Eina_Bool
|
|
|
|
elm_scroll_bounce_enabled_get(void)
|
|
|
|
{
|
|
|
|
return _elm_config->thumbscroll_bounce_enable;
|
|
|
|
}
|
|
|
|
|
|
|
|
EAPI void
|
|
|
|
elm_scroll_bounce_enabled_set(Eina_Bool enabled)
|
|
|
|
{
|
|
|
|
_elm_config->thumbscroll_bounce_enable = enabled;
|
|
|
|
}
|
|
|
|
|
|
|
|
EAPI void
|
|
|
|
elm_scroll_bounce_enabled_all_set(Eina_Bool enabled)
|
|
|
|
{
|
2011-10-19 05:46:56 -07:00
|
|
|
elm_scroll_bounce_enabled_set(enabled);
|
|
|
|
_elm_config_all_update();
|
2010-12-06 04:46:10 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
EAPI double
|
|
|
|
elm_scroll_bounce_friction_get(void)
|
|
|
|
{
|
|
|
|
return _elm_config->thumbscroll_bounce_friction;
|
|
|
|
}
|
|
|
|
|
|
|
|
EAPI void
|
|
|
|
elm_scroll_bounce_friction_set(double friction)
|
|
|
|
{
|
|
|
|
_elm_config->thumbscroll_bounce_friction = friction;
|
|
|
|
}
|
|
|
|
|
|
|
|
EAPI void
|
|
|
|
elm_scroll_bounce_friction_all_set(double friction)
|
|
|
|
{
|
2011-10-19 05:46:56 -07:00
|
|
|
elm_scroll_bounce_friction_set(friction);
|
|
|
|
_elm_config_all_update();
|
2010-12-06 04:46:10 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
EAPI double
|
|
|
|
elm_scroll_page_scroll_friction_get(void)
|
|
|
|
{
|
|
|
|
return _elm_config->page_scroll_friction;
|
|
|
|
}
|
|
|
|
|
|
|
|
EAPI void
|
|
|
|
elm_scroll_page_scroll_friction_set(double friction)
|
|
|
|
{
|
|
|
|
_elm_config->page_scroll_friction = friction;
|
|
|
|
}
|
|
|
|
|
|
|
|
EAPI void
|
|
|
|
elm_scroll_page_scroll_friction_all_set(double friction)
|
|
|
|
{
|
2011-10-19 05:46:56 -07:00
|
|
|
elm_scroll_page_scroll_friction_set(friction);
|
|
|
|
_elm_config_all_update();
|
2010-12-06 04:46:10 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
EAPI double
|
|
|
|
elm_scroll_bring_in_scroll_friction_get(void)
|
|
|
|
{
|
|
|
|
return _elm_config->bring_in_scroll_friction;
|
|
|
|
}
|
|
|
|
|
|
|
|
EAPI void
|
|
|
|
elm_scroll_bring_in_scroll_friction_set(double friction)
|
|
|
|
{
|
|
|
|
_elm_config->bring_in_scroll_friction = friction;
|
|
|
|
}
|
|
|
|
|
|
|
|
EAPI void
|
|
|
|
elm_scroll_bring_in_scroll_friction_all_set(double friction)
|
|
|
|
{
|
2011-10-19 05:46:56 -07:00
|
|
|
elm_scroll_bring_in_scroll_friction_set(friction);
|
|
|
|
_elm_config_all_update();
|
2010-12-06 04:46:10 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
EAPI double
|
|
|
|
elm_scroll_zoom_friction_get(void)
|
|
|
|
{
|
|
|
|
return _elm_config->zoom_friction;
|
|
|
|
}
|
|
|
|
|
|
|
|
EAPI void
|
|
|
|
elm_scroll_zoom_friction_set(double friction)
|
|
|
|
{
|
|
|
|
_elm_config->zoom_friction = friction;
|
|
|
|
}
|
|
|
|
|
|
|
|
EAPI void
|
|
|
|
elm_scroll_zoom_friction_all_set(double friction)
|
|
|
|
{
|
2011-10-19 05:46:56 -07:00
|
|
|
elm_scroll_zoom_friction_set(friction);
|
|
|
|
_elm_config_all_update();
|
2010-12-06 04:46:10 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
EAPI Eina_Bool
|
|
|
|
elm_scroll_thumbscroll_enabled_get(void)
|
|
|
|
{
|
|
|
|
return _elm_config->thumbscroll_enable;
|
|
|
|
}
|
|
|
|
|
|
|
|
EAPI void
|
|
|
|
elm_scroll_thumbscroll_enabled_set(Eina_Bool enabled)
|
|
|
|
{
|
|
|
|
_elm_config->thumbscroll_enable = enabled;
|
|
|
|
}
|
|
|
|
|
|
|
|
EAPI void
|
|
|
|
elm_scroll_thumbscroll_enabled_all_set(Eina_Bool enabled)
|
|
|
|
{
|
2011-10-19 05:46:56 -07:00
|
|
|
elm_scroll_thumbscroll_enabled_set(enabled);
|
|
|
|
_elm_config_all_update();
|
2010-12-06 04:46:10 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
EAPI unsigned int
|
|
|
|
elm_scroll_thumbscroll_threshold_get(void)
|
|
|
|
{
|
|
|
|
return _elm_config->thumbscroll_threshold;
|
|
|
|
}
|
|
|
|
|
|
|
|
EAPI void
|
|
|
|
elm_scroll_thumbscroll_threshold_set(unsigned int threshold)
|
|
|
|
{
|
|
|
|
_elm_config->thumbscroll_threshold = threshold;
|
|
|
|
}
|
|
|
|
|
|
|
|
EAPI void
|
|
|
|
elm_scroll_thumbscroll_threshold_all_set(unsigned int threshold)
|
|
|
|
{
|
2011-10-19 05:46:56 -07:00
|
|
|
elm_scroll_thumbscroll_threshold_set(threshold);
|
|
|
|
_elm_config_all_update();
|
2010-12-06 04:46:10 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
EAPI double
|
|
|
|
elm_scroll_thumbscroll_momentum_threshold_get(void)
|
|
|
|
{
|
|
|
|
return _elm_config->thumbscroll_momentum_threshold;
|
|
|
|
}
|
|
|
|
|
|
|
|
EAPI void
|
|
|
|
elm_scroll_thumbscroll_momentum_threshold_set(double threshold)
|
|
|
|
{
|
|
|
|
_elm_config->thumbscroll_momentum_threshold = threshold;
|
|
|
|
}
|
|
|
|
|
|
|
|
EAPI void
|
|
|
|
elm_scroll_thumbscroll_momentum_threshold_all_set(double threshold)
|
|
|
|
{
|
2011-10-19 05:46:56 -07:00
|
|
|
elm_scroll_thumbscroll_momentum_threshold_set(threshold);
|
|
|
|
_elm_config_all_update();
|
2010-12-06 04:46:10 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
EAPI double
|
|
|
|
elm_scroll_thumbscroll_friction_get(void)
|
|
|
|
{
|
|
|
|
return _elm_config->thumbscroll_friction;
|
|
|
|
}
|
|
|
|
|
|
|
|
EAPI void
|
|
|
|
elm_scroll_thumbscroll_friction_set(double friction)
|
|
|
|
{
|
|
|
|
_elm_config->thumbscroll_friction = friction;
|
|
|
|
}
|
|
|
|
|
|
|
|
EAPI void
|
|
|
|
elm_scroll_thumbscroll_friction_all_set(double friction)
|
|
|
|
{
|
2011-10-19 05:46:56 -07:00
|
|
|
elm_scroll_thumbscroll_friction_set(friction);
|
|
|
|
_elm_config_all_update();
|
2010-12-06 04:46:10 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
EAPI double
|
|
|
|
elm_scroll_thumbscroll_border_friction_get(void)
|
|
|
|
{
|
|
|
|
return _elm_config->thumbscroll_border_friction;
|
|
|
|
}
|
|
|
|
|
|
|
|
EAPI void
|
|
|
|
elm_scroll_thumbscroll_border_friction_set(double friction)
|
|
|
|
{
|
2011-10-19 05:46:56 -07:00
|
|
|
if (friction < 0.0) friction = 0.0;
|
|
|
|
if (friction > 1.0) friction = 1.0;
|
2010-12-06 04:46:10 -08:00
|
|
|
_elm_config->thumbscroll_friction = friction;
|
|
|
|
}
|
|
|
|
|
|
|
|
EAPI void
|
|
|
|
elm_scroll_thumbscroll_border_friction_all_set(double friction)
|
|
|
|
{
|
2011-10-19 05:46:56 -07:00
|
|
|
elm_scroll_thumbscroll_border_friction_set(friction);
|
|
|
|
_elm_config_all_update();
|
2010-12-06 04:46:10 -08:00
|
|
|
}
|
|
|
|
|
2011-10-13 05:07:39 -07:00
|
|
|
EAPI double
|
|
|
|
elm_scroll_thumbscroll_sensitivity_friction_get(void)
|
|
|
|
{
|
|
|
|
return _elm_config->thumbscroll_sensitivity_friction;
|
|
|
|
}
|
|
|
|
|
|
|
|
EAPI void
|
|
|
|
elm_scroll_thumbscroll_sensitivity_friction_set(double friction)
|
|
|
|
{
|
2011-10-19 05:46:56 -07:00
|
|
|
if (friction < 0.1) friction = 0.1;
|
|
|
|
if (friction > 1.0) friction = 1.0;
|
2011-10-13 05:07:39 -07:00
|
|
|
_elm_config->thumbscroll_friction = friction;
|
|
|
|
}
|
|
|
|
|
|
|
|
EAPI void
|
|
|
|
elm_scroll_thumbscroll_sensitivity_friction_all_set(double friction)
|
|
|
|
{
|
2011-10-19 05:46:56 -07:00
|
|
|
elm_scroll_thumbscroll_sensitivity_friction_set(friction);
|
|
|
|
_elm_config_all_update();
|
2011-10-13 05:07:39 -07:00
|
|
|
}
|
|
|
|
|
2009-09-07 21:40:27 -07:00
|
|
|
EAPI void
|
|
|
|
elm_object_scroll_hold_push(Evas_Object *obj)
|
|
|
|
{
|
2010-12-03 06:08:33 -08:00
|
|
|
EINA_SAFETY_ON_NULL_RETURN(obj);
|
2009-09-07 21:40:27 -07:00
|
|
|
elm_widget_scroll_hold_push(obj);
|
|
|
|
}
|
|
|
|
|
|
|
|
EAPI void
|
|
|
|
elm_object_scroll_hold_pop(Evas_Object *obj)
|
|
|
|
{
|
2010-12-03 06:08:33 -08:00
|
|
|
EINA_SAFETY_ON_NULL_RETURN(obj);
|
2009-09-07 21:40:27 -07:00
|
|
|
elm_widget_scroll_hold_pop(obj);
|
|
|
|
}
|
|
|
|
|
|
|
|
EAPI void
|
|
|
|
elm_object_scroll_freeze_push(Evas_Object *obj)
|
|
|
|
{
|
2010-12-03 06:08:33 -08:00
|
|
|
EINA_SAFETY_ON_NULL_RETURN(obj);
|
2009-09-07 21:40:27 -07:00
|
|
|
elm_widget_scroll_freeze_push(obj);
|
|
|
|
}
|
|
|
|
|
2010-06-30 23:59:30 -07:00
|
|
|
EAPI void
|
2010-11-29 05:14:37 -08:00
|
|
|
elm_object_scroll_lock_x_set(Evas_Object *obj,
|
|
|
|
Eina_Bool lock)
|
2010-06-30 23:59:30 -07:00
|
|
|
{
|
2010-12-03 06:08:33 -08:00
|
|
|
EINA_SAFETY_ON_NULL_RETURN(obj);
|
2010-06-30 23:59:30 -07:00
|
|
|
elm_widget_drag_lock_x_set(obj, lock);
|
|
|
|
}
|
|
|
|
|
|
|
|
EAPI void
|
2010-11-29 05:14:37 -08:00
|
|
|
elm_object_scroll_lock_y_set(Evas_Object *obj,
|
|
|
|
Eina_Bool lock)
|
2010-06-30 23:59:30 -07:00
|
|
|
{
|
2010-12-03 06:08:33 -08:00
|
|
|
EINA_SAFETY_ON_NULL_RETURN(obj);
|
2010-06-30 23:59:30 -07:00
|
|
|
elm_widget_drag_lock_y_set(obj, lock);
|
|
|
|
}
|
|
|
|
|
|
|
|
EAPI Eina_Bool
|
|
|
|
elm_object_scroll_lock_x_get(const Evas_Object *obj)
|
|
|
|
{
|
2010-12-03 06:08:33 -08:00
|
|
|
EINA_SAFETY_ON_NULL_RETURN_VAL(obj, EINA_FALSE);
|
2010-06-30 23:59:30 -07:00
|
|
|
return elm_widget_drag_lock_x_get(obj);
|
|
|
|
}
|
|
|
|
|
|
|
|
EAPI Eina_Bool
|
|
|
|
elm_object_scroll_lock_y_get(const Evas_Object *obj)
|
|
|
|
{
|
2010-12-03 06:08:33 -08:00
|
|
|
EINA_SAFETY_ON_NULL_RETURN_VAL(obj, EINA_FALSE);
|
2010-06-30 23:59:30 -07:00
|
|
|
return elm_widget_drag_lock_y_get(obj);
|
|
|
|
}
|
|
|
|
|
2009-09-07 21:40:27 -07:00
|
|
|
EAPI void
|
|
|
|
elm_object_scroll_freeze_pop(Evas_Object *obj)
|
|
|
|
{
|
2010-12-03 06:08:33 -08:00
|
|
|
EINA_SAFETY_ON_NULL_RETURN(obj);
|
2009-09-07 21:40:27 -07:00
|
|
|
elm_widget_scroll_freeze_pop(obj);
|
|
|
|
}
|
2010-03-22 14:36:59 -07:00
|
|
|
|
|
|
|
EAPI Eina_Bool
|
|
|
|
elm_object_widget_check(const Evas_Object *obj)
|
|
|
|
{
|
2010-12-03 06:08:33 -08:00
|
|
|
EINA_SAFETY_ON_NULL_RETURN_VAL(obj, EINA_FALSE);
|
2010-03-22 14:36:59 -07:00
|
|
|
return elm_widget_is(obj);
|
|
|
|
}
|
|
|
|
|
|
|
|
EAPI Evas_Object *
|
|
|
|
elm_object_parent_widget_get(const Evas_Object *obj)
|
|
|
|
{
|
2010-12-03 06:08:33 -08:00
|
|
|
EINA_SAFETY_ON_NULL_RETURN_VAL(obj, NULL);
|
2010-03-22 14:36:59 -07:00
|
|
|
return elm_widget_parent_widget_get(obj);
|
|
|
|
}
|
2010-05-13 15:02:26 -07:00
|
|
|
|
2010-06-23 01:51:58 -07:00
|
|
|
EAPI Evas_Object *
|
|
|
|
elm_object_top_widget_get(const Evas_Object *obj)
|
|
|
|
{
|
2010-12-03 06:08:33 -08:00
|
|
|
EINA_SAFETY_ON_NULL_RETURN_VAL(obj, NULL);
|
2010-06-23 01:51:58 -07:00
|
|
|
return elm_widget_top_get(obj);
|
|
|
|
}
|
|
|
|
|
2010-05-13 15:02:26 -07:00
|
|
|
EAPI const char *
|
|
|
|
elm_object_widget_type_get(const Evas_Object *obj)
|
|
|
|
{
|
2010-12-03 06:08:33 -08:00
|
|
|
EINA_SAFETY_ON_NULL_RETURN_VAL(obj, NULL);
|
2010-05-13 15:02:26 -07:00
|
|
|
return elm_widget_type_get(obj);
|
|
|
|
}
|
2010-06-15 07:11:13 -07:00
|
|
|
|
2010-11-29 05:14:37 -08:00
|
|
|
EAPI void
|
|
|
|
elm_object_signal_emit(Evas_Object *obj,
|
|
|
|
const char *emission,
|
|
|
|
const char *source)
|
2010-06-15 07:11:13 -07:00
|
|
|
{
|
2010-12-03 06:08:33 -08:00
|
|
|
EINA_SAFETY_ON_NULL_RETURN(obj);
|
2010-11-29 05:14:37 -08:00
|
|
|
elm_widget_signal_emit(obj, emission, source);
|
2010-06-15 07:11:13 -07:00
|
|
|
}
|
2010-06-25 15:38:32 -07:00
|
|
|
|
2011-04-08 07:36:29 -07:00
|
|
|
EAPI void
|
2011-07-22 04:10:10 -07:00
|
|
|
elm_object_signal_callback_add(Evas_Object *obj, const char *emission, const char *source, Edje_Signal_Cb func, void *data)
|
2010-06-25 15:38:32 -07:00
|
|
|
{
|
2010-12-03 06:08:33 -08:00
|
|
|
EINA_SAFETY_ON_NULL_RETURN(obj);
|
|
|
|
EINA_SAFETY_ON_NULL_RETURN(func);
|
2010-06-28 08:32:20 -07:00
|
|
|
elm_widget_signal_callback_add(obj, emission, source, func, data);
|
2010-06-25 15:38:32 -07:00
|
|
|
}
|
|
|
|
|
2010-09-21 13:09:29 -07:00
|
|
|
EAPI void *
|
2011-07-22 04:10:10 -07:00
|
|
|
elm_object_signal_callback_del(Evas_Object *obj, const char *emission, const char *source, Edje_Signal_Cb func)
|
2010-06-25 15:38:32 -07:00
|
|
|
{
|
2010-12-03 06:08:33 -08:00
|
|
|
EINA_SAFETY_ON_NULL_RETURN_VAL(obj, NULL);
|
|
|
|
EINA_SAFETY_ON_NULL_RETURN_VAL(func, NULL);
|
2010-06-28 08:32:20 -07:00
|
|
|
return elm_widget_signal_callback_del(obj, emission, source, func);
|
2010-06-25 15:38:32 -07:00
|
|
|
}
|
2010-10-01 12:03:23 -07:00
|
|
|
|
2010-11-29 05:56:30 -08:00
|
|
|
EAPI void
|
|
|
|
elm_object_event_callback_add(Evas_Object *obj, Elm_Event_Cb func, const void *data)
|
|
|
|
{
|
2010-12-03 06:08:33 -08:00
|
|
|
EINA_SAFETY_ON_NULL_RETURN(obj);
|
|
|
|
EINA_SAFETY_ON_NULL_RETURN(func);
|
2010-11-29 05:56:30 -08:00
|
|
|
elm_widget_event_callback_add(obj, func, data);
|
|
|
|
}
|
|
|
|
|
|
|
|
EAPI void *
|
|
|
|
elm_object_event_callback_del(Evas_Object *obj, Elm_Event_Cb func, const void *data)
|
|
|
|
{
|
2010-12-03 06:08:33 -08:00
|
|
|
EINA_SAFETY_ON_NULL_RETURN_VAL(obj, NULL);
|
|
|
|
EINA_SAFETY_ON_NULL_RETURN_VAL(func, NULL);
|
2010-11-29 05:56:30 -08:00
|
|
|
return elm_widget_event_callback_del(obj, func, data);
|
|
|
|
}
|
2010-10-06 13:24:22 -07:00
|
|
|
|
2010-10-01 12:03:23 -07:00
|
|
|
EAPI void
|
|
|
|
elm_object_tree_dump(const Evas_Object *top)
|
|
|
|
{
|
|
|
|
#ifdef ELM_DEBUG
|
|
|
|
elm_widget_tree_dump(top);
|
2010-10-19 11:24:27 -07:00
|
|
|
#else
|
|
|
|
return;
|
|
|
|
(void)top;
|
2010-10-01 12:03:23 -07:00
|
|
|
#endif
|
|
|
|
}
|
2010-10-04 11:37:48 -07:00
|
|
|
|
|
|
|
EAPI void
|
2010-11-29 05:14:37 -08:00
|
|
|
elm_object_tree_dot_dump(const Evas_Object *top,
|
|
|
|
const char *file)
|
2010-10-04 11:37:48 -07:00
|
|
|
{
|
|
|
|
#ifdef ELM_DEBUG
|
2011-06-17 14:41:17 -07:00
|
|
|
FILE *f = fopen(file, "wb");
|
2010-10-04 11:37:48 -07:00
|
|
|
elm_widget_tree_dot_dump(top, f);
|
|
|
|
fclose(f);
|
2010-10-19 11:24:27 -07:00
|
|
|
#else
|
|
|
|
return;
|
|
|
|
(void)top;
|
|
|
|
(void)file;
|
2010-10-04 11:37:48 -07:00
|
|
|
#endif
|
|
|
|
}
|
2010-11-24 09:11:34 -08:00
|
|
|
|
|
|
|
EAPI void
|
|
|
|
elm_longpress_timeout_set(double longpress_timeout)
|
|
|
|
{
|
|
|
|
_elm_config->longpress_timeout = longpress_timeout;
|
|
|
|
}
|
|
|
|
|
|
|
|
EAPI double
|
|
|
|
elm_longpress_timeout_get(void)
|
|
|
|
{
|
|
|
|
return _elm_config->longpress_timeout;
|
|
|
|
}
|
2011-08-03 02:34:00 -07:00
|
|
|
|
2011-10-05 18:13:51 -07:00
|
|
|
EAPI Evas_Object *
|
2012-01-15 19:23:32 -08:00
|
|
|
elm_object_item_widget_get(const Elm_Object_Item *it)
|
2011-10-05 18:13:51 -07:00
|
|
|
{
|
2012-01-15 19:23:32 -08:00
|
|
|
return WIDGET(it);
|
2011-10-05 18:13:51 -07:00
|
|
|
}
|
|
|
|
|
2011-08-03 02:34:00 -07:00
|
|
|
EAPI void
|
|
|
|
elm_object_item_content_part_set(Elm_Object_Item *it,
|
2011-08-03 04:55:24 -07:00
|
|
|
const char *part,
|
2011-08-03 02:34:00 -07:00
|
|
|
Evas_Object *content)
|
|
|
|
{
|
2011-10-17 17:25:52 -07:00
|
|
|
_elm_widget_item_content_part_set((Elm_Widget_Item *) it, part, content);
|
2011-08-03 02:34:00 -07:00
|
|
|
}
|
|
|
|
|
2011-11-17 13:02:52 -08:00
|
|
|
EAPI void
|
|
|
|
elm_object_item_part_content_set(Elm_Object_Item *it,
|
|
|
|
const char *part,
|
|
|
|
Evas_Object *content)
|
|
|
|
{
|
|
|
|
_elm_widget_item_content_part_set((Elm_Widget_Item *) it, part, content);
|
|
|
|
}
|
|
|
|
|
2011-08-03 02:34:00 -07:00
|
|
|
EAPI Evas_Object *
|
|
|
|
elm_object_item_content_part_get(const Elm_Object_Item *it,
|
2011-08-03 04:55:24 -07:00
|
|
|
const char *part)
|
2011-08-03 02:34:00 -07:00
|
|
|
{
|
2011-10-17 17:25:52 -07:00
|
|
|
return _elm_widget_item_content_part_get((Elm_Widget_Item *) it, part);
|
2011-08-03 02:34:00 -07:00
|
|
|
}
|
|
|
|
|
2011-11-17 13:02:52 -08:00
|
|
|
EAPI Evas_Object *
|
|
|
|
elm_object_item_part_content_get(const Elm_Object_Item *it,
|
|
|
|
const char *part)
|
|
|
|
{
|
|
|
|
return _elm_widget_item_content_part_get((Elm_Widget_Item *) it, part);
|
|
|
|
}
|
|
|
|
|
2011-08-03 02:34:00 -07:00
|
|
|
EAPI Evas_Object *
|
2011-08-03 04:55:24 -07:00
|
|
|
elm_object_item_content_part_unset(Elm_Object_Item *it, const char *part)
|
2011-08-03 02:34:00 -07:00
|
|
|
{
|
2011-10-17 17:25:52 -07:00
|
|
|
return _elm_widget_item_content_part_unset((Elm_Widget_Item *) it, part);
|
2011-08-03 02:34:00 -07:00
|
|
|
}
|
|
|
|
|
2011-11-17 13:02:52 -08:00
|
|
|
EAPI Evas_Object *
|
|
|
|
elm_object_item_part_content_unset(Elm_Object_Item *it, const char *part)
|
|
|
|
{
|
|
|
|
return _elm_widget_item_content_part_unset((Elm_Widget_Item *) it, part);
|
|
|
|
}
|
|
|
|
|
2011-08-03 02:34:00 -07:00
|
|
|
EAPI void
|
|
|
|
elm_object_item_text_part_set(Elm_Object_Item *it,
|
2011-08-03 04:55:24 -07:00
|
|
|
const char *part,
|
2011-08-03 02:34:00 -07:00
|
|
|
const char *label)
|
|
|
|
{
|
2011-10-17 17:25:52 -07:00
|
|
|
_elm_widget_item_text_part_set((Elm_Widget_Item *) it, part, label);
|
2011-08-03 02:34:00 -07:00
|
|
|
}
|
|
|
|
|
2011-11-17 13:02:43 -08:00
|
|
|
EAPI void
|
|
|
|
elm_object_item_part_text_set(Elm_Object_Item *it,
|
|
|
|
const char *part,
|
|
|
|
const char *label)
|
|
|
|
{
|
|
|
|
_elm_widget_item_text_part_set((Elm_Widget_Item *) it, part, label);
|
|
|
|
}
|
|
|
|
|
2011-08-03 02:34:00 -07:00
|
|
|
EAPI const char *
|
2011-08-03 04:55:24 -07:00
|
|
|
elm_object_item_text_part_get(const Elm_Object_Item *it, const char *part)
|
2011-08-03 02:34:00 -07:00
|
|
|
{
|
2011-10-17 17:25:52 -07:00
|
|
|
return _elm_widget_item_text_part_get((Elm_Widget_Item *) it, part);
|
2011-11-17 13:02:43 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
EAPI const char *
|
|
|
|
elm_object_item_part_text_get(const Elm_Object_Item *it, const char *part)
|
|
|
|
{
|
|
|
|
return _elm_widget_item_text_part_get((Elm_Widget_Item *) it, part);
|
2011-08-03 02:34:00 -07:00
|
|
|
}
|
2011-08-19 04:47:30 -07:00
|
|
|
|
2012-01-10 15:35:29 -08:00
|
|
|
EAPI void
|
|
|
|
elm_object_access_info_set(Evas_Object *obj, const char *txt)
|
|
|
|
{
|
|
|
|
elm_widget_access_info_set(obj, txt);
|
|
|
|
}
|
|
|
|
|
|
|
|
EAPI Evas_Object *
|
|
|
|
elm_object_name_find(const Evas_Object *obj, const char *name, int recurse)
|
|
|
|
{
|
|
|
|
return elm_widget_name_find(obj, name, recurse);
|
|
|
|
}
|
|
|
|
|
2011-08-23 23:39:29 -07:00
|
|
|
EAPI void
|
|
|
|
elm_object_item_access_info_set(Elm_Object_Item *it, const char *txt)
|
|
|
|
{
|
2011-10-17 17:25:52 -07:00
|
|
|
_elm_widget_item_access_info_set((Elm_Widget_Item *) it, txt);
|
2011-08-23 23:39:29 -07:00
|
|
|
}
|
|
|
|
|
2011-09-10 08:54:43 -07:00
|
|
|
EAPI void *
|
|
|
|
elm_object_item_data_get(const Elm_Object_Item *it)
|
|
|
|
{
|
|
|
|
return elm_widget_item_data_get(it);
|
|
|
|
}
|
|
|
|
|
|
|
|
EAPI void
|
|
|
|
elm_object_item_data_set(Elm_Object_Item *it, void *data)
|
|
|
|
{
|
|
|
|
elm_widget_item_data_set(it, data);
|
|
|
|
}
|
2011-09-15 19:10:07 -07:00
|
|
|
|
|
|
|
EAPI void
|
|
|
|
elm_object_item_signal_emit(Elm_Object_Item *it, const char *emission, const char *source)
|
|
|
|
{
|
2011-10-17 17:25:52 -07:00
|
|
|
_elm_widget_item_signal_emit((Elm_Widget_Item *) it, emission, source);
|
2011-09-15 19:10:07 -07:00
|
|
|
}
|
2011-11-16 17:58:03 -08:00
|
|
|
|
2012-01-10 15:35:29 -08:00
|
|
|
EAPI void elm_object_item_disabled_set(Elm_Object_Item *it, Eina_Bool disabled)
|
2011-11-16 17:58:03 -08:00
|
|
|
{
|
|
|
|
_elm_widget_item_disabled_set((Elm_Widget_Item *) it, disabled);
|
|
|
|
}
|
|
|
|
|
2012-01-10 15:35:29 -08:00
|
|
|
EAPI Eina_Bool elm_object_item_disabled_get(const Elm_Object_Item *it)
|
2011-11-16 17:58:03 -08:00
|
|
|
{
|
|
|
|
return _elm_widget_item_disabled_get((Elm_Widget_Item *) it);
|
|
|
|
}
|
|
|
|
|
2012-01-10 15:35:29 -08:00
|
|
|
EAPI void elm_object_item_del_cb_set(Elm_Object_Item *it, Evas_Smart_Cb del_cb)
|
2012-01-02 03:46:32 -08:00
|
|
|
{
|
|
|
|
_elm_widget_item_del_cb_set((Elm_Widget_Item *) it, del_cb);
|
|
|
|
}
|
2012-01-03 16:15:03 -08:00
|
|
|
|
2012-01-09 02:48:06 -08:00
|
|
|
EAPI void elm_object_item_del(Elm_Object_Item *it)
|
|
|
|
{
|
|
|
|
_elm_widget_item_del((Elm_Widget_Item *) it);
|
|
|
|
}
|
|
|
|
|
2012-01-03 16:22:08 -08:00
|
|
|
EAPI void
|
2012-01-30 16:32:20 -08:00
|
|
|
elm_object_item_tooltip_text_set(Elm_Object_Item *it, const char *text)
|
2012-01-03 16:22:08 -08:00
|
|
|
{
|
2012-01-30 16:32:20 -08:00
|
|
|
elm_widget_item_tooltip_text_set(it, text);
|
2012-01-03 16:22:08 -08:00
|
|
|
}
|
|
|
|
|
2012-01-03 16:15:03 -08:00
|
|
|
EAPI void
|
2012-01-30 16:32:20 -08:00
|
|
|
elm_object_item_tooltip_content_cb_set(Elm_Object_Item *it, Elm_Tooltip_Item_Content_Cb func, const void *data, Evas_Smart_Cb del_cb)
|
2012-01-03 16:15:03 -08:00
|
|
|
{
|
2012-01-30 16:32:20 -08:00
|
|
|
elm_widget_item_tooltip_content_cb_set(it, func, data, del_cb);
|
2012-01-03 16:15:03 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
EAPI void
|
2012-01-30 16:32:20 -08:00
|
|
|
elm_object_item_tooltip_unset(Elm_Object_Item *it)
|
2012-01-03 16:15:03 -08:00
|
|
|
{
|
2012-01-30 16:32:20 -08:00
|
|
|
elm_widget_item_tooltip_unset(it);
|
2012-01-03 16:15:03 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
EAPI Eina_Bool
|
2012-01-30 16:32:20 -08:00
|
|
|
elm_object_item_tooltip_window_mode_set(Elm_Object_Item *it, Eina_Bool disable)
|
2012-01-03 16:15:03 -08:00
|
|
|
{
|
2012-01-30 16:32:20 -08:00
|
|
|
return elm_widget_item_tooltip_window_mode_set(it, disable);
|
2012-01-03 16:15:03 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
EAPI Eina_Bool
|
2012-01-30 16:32:20 -08:00
|
|
|
elm_object_item_tooltip_window_mode_get(const Elm_Object_Item *it)
|
2012-01-03 16:15:03 -08:00
|
|
|
{
|
2012-01-30 16:32:20 -08:00
|
|
|
return elm_widget_item_tooltip_window_mode_get(it);
|
2012-01-03 16:15:03 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
EAPI void
|
2012-01-30 16:32:20 -08:00
|
|
|
elm_object_item_tooltip_style_set(Elm_Object_Item *it, const char *style)
|
2012-01-03 16:15:03 -08:00
|
|
|
{
|
2012-01-30 16:32:20 -08:00
|
|
|
elm_widget_item_tooltip_style_set(it, style);
|
2012-01-03 16:15:03 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
EAPI const char *
|
2012-01-30 16:32:20 -08:00
|
|
|
elm_object_item_tooltip_style_get(const Elm_Object_Item *it)
|
2012-01-03 16:15:03 -08:00
|
|
|
{
|
2012-01-30 16:32:20 -08:00
|
|
|
return elm_widget_item_tooltip_style_get(it);
|
2012-01-03 16:15:03 -08:00
|
|
|
}
|
|
|
|
|
2012-01-15 19:23:32 -08:00
|
|
|
EINA_DEPRECATED EAPI Evas_Object *
|
|
|
|
elm_object_item_object_get(const Elm_Object_Item *it)
|
|
|
|
{
|
|
|
|
return elm_object_item_widget_get(it);
|
|
|
|
}
|
2012-01-20 02:13:56 -08:00
|
|
|
|
|
|
|
EAPI void
|
2012-01-30 16:32:20 -08:00
|
|
|
elm_object_item_cursor_set(Elm_Object_Item *it, const char *cursor)
|
2012-01-20 02:13:56 -08:00
|
|
|
{
|
2012-01-30 20:45:19 -08:00
|
|
|
elm_widget_item_cursor_set(it, cursor);
|
2012-01-20 02:13:56 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
EAPI const char *
|
2012-01-30 16:32:20 -08:00
|
|
|
elm_object_item_cursor_get(const Elm_Object_Item *it)
|
2012-01-20 02:13:56 -08:00
|
|
|
{
|
2012-01-30 16:32:20 -08:00
|
|
|
return elm_widget_item_cursor_get(it);
|
2012-01-20 02:13:56 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
EAPI void
|
2012-01-30 16:32:20 -08:00
|
|
|
elm_object_item_cursor_unset(Elm_Object_Item *it)
|
2012-01-20 02:13:56 -08:00
|
|
|
{
|
2012-01-30 16:32:20 -08:00
|
|
|
elm_widget_item_cursor_unset(it);
|
2012-01-20 02:13:56 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
EAPI void
|
2012-01-30 16:32:20 -08:00
|
|
|
elm_object_item_cursor_style_set(Elm_Object_Item *it, const char *style)
|
2012-01-20 02:13:56 -08:00
|
|
|
{
|
2012-01-30 16:32:20 -08:00
|
|
|
elm_widget_item_cursor_style_set(it, style);
|
2012-01-20 02:13:56 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
EAPI const char *
|
2012-01-30 16:32:20 -08:00
|
|
|
elm_object_item_cursor_style_get(const Elm_Object_Item *it)
|
2012-01-20 02:13:56 -08:00
|
|
|
{
|
2012-01-30 16:32:20 -08:00
|
|
|
return elm_widget_item_cursor_style_get(it);
|
2012-01-20 02:13:56 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
EAPI void
|
2012-01-30 16:32:20 -08:00
|
|
|
elm_object_item_cursor_engine_only_set(Elm_Object_Item *it, Eina_Bool engine_only)
|
2012-01-20 02:13:56 -08:00
|
|
|
{
|
2012-01-30 16:32:20 -08:00
|
|
|
elm_widget_item_cursor_engine_only_set(it, engine_only);
|
2012-01-20 02:13:56 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
EAPI Eina_Bool
|
2012-01-30 16:32:20 -08:00
|
|
|
elm_object_item_cursor_engine_only_get(const Elm_Object_Item *it)
|
2012-01-20 02:13:56 -08:00
|
|
|
{
|
2012-01-30 16:32:20 -08:00
|
|
|
return elm_widget_item_cursor_engine_only_get(it);
|
2012-01-20 02:13:56 -08:00
|
|
|
}
|