enlightenment/efl
enlightenment
/
efl
8
7
Fork 14
Code Issues 13 Pull Requests 3 Projects Releases Wiki Activity

efreet: Use dbus daemon 

SVN revision: 78809
This commit is contained in:
Sebastian Dransfeld 2012-11-02 01:46:44 +00:00
parent ac97a87b85
commit e94d0c6eb1
12 changed files with 264 additions and 840 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

89
legacy/efreet/src/bin/efreet_desktop_cache_create.c
View File

@ -36,12 +36,6 @@ static Eina_Hash *generic_name = NULL;
static Eina_Hash *comment = NULL; static Eina_Hash *comment = NULL;
static Eina_Hash *exec = NULL; static Eina_Hash *exec = NULL;
static int
strcmplen(const void *data1, const void *data2)
{
return strncmp(data1, data2, eina_stringshare_strlen(data1));
}
static int static int
cache_add(const char *path, const char *file_id, int priority __UNUSED__, int *changed) cache_add(const char *path, const char *file_id, int priority __UNUSED__, int *changed)
{ {
@ -214,9 +208,8 @@ main(int argc, char **argv)
Efreet_Cache_Version version; Efreet_Cache_Version version;
Eina_List *dirs = NULL; Eina_List *dirs = NULL;
Eina_List *systemdirs = NULL; Eina_List *systemdirs = NULL;
Efreet_Cache_Array_String *user_dirs = NULL;
Eina_List *extra_dirs = NULL; Eina_List *extra_dirs = NULL;
Eina_List *store_dirs = NULL; Eina_List *l = NULL;
int priority = 0; int priority = 0;
char *dir = NULL; char *dir = NULL;
char *path; char *path;
@ -272,12 +265,6 @@ main(int argc, char **argv)
if (!ecore_file_mkpath(file)) goto efreet_error; if (!ecore_file_mkpath(file)) goto efreet_error;
efreet_setowner(file); efreet_setowner(file);
} }
snprintf(file, sizeof(file), "%s/efreet/update", efreet_cache_home_get());
if (!ecore_file_exists(file))
{
if (!ecore_file_mkpath(file)) goto efreet_error;
efreet_setowner(file);
}
/* lock process, so that we only run one copy of this program */ /* lock process, so that we only run one copy of this program */
lockfd = cache_lock_file(); lockfd = cache_lock_file();
@ -287,13 +274,6 @@ main(int argc, char **argv)
if (!edd) goto edd_error; if (!edd) goto edd_error;
/* read user dirs from old cache */ /* read user dirs from old cache */
ef = eet_open(efreet_desktop_cache_file(), EET_FILE_MODE_READ);
if (ef)
{
user_dirs = eet_data_read(ef, efreet_array_string_edd(), EFREET_CACHE_DESKTOP_DIRS);
eet_close(ef);
}
ef = eet_open(efreet_desktop_util_cache_file(), EET_FILE_MODE_READ); ef = eet_open(efreet_desktop_util_cache_file(), EET_FILE_MODE_READ);
if (ef) if (ef)
{ {
@ -349,61 +329,8 @@ main(int argc, char **argv)
systemdirs = eina_list_append(systemdirs, path); systemdirs = eina_list_append(systemdirs, path);
} }
if (user_dirs) EINA_LIST_FOREACH(extra_dirs, l, path)
{ if (!cache_scan(path, NULL, priority, 0, &changed)) goto error;
unsigned int j;
for (j = 0; j < user_dirs->array_count; j++)
{
if (eina_list_search_unsorted_list(systemdirs, strcmplen, user_dirs->array[j]))
continue;
if (!ecore_file_is_dir(user_dirs->array[j])) continue;
if (!cache_scan(user_dirs->array[j], NULL, priority, 0, &changed)) goto error;
store_dirs = eina_list_append(store_dirs, user_dirs->array[j]);
}
store_dirs = eina_list_sort(store_dirs, -1, EINA_COMPARE_CB(strcmp));
}
if (extra_dirs)
{
Eina_List *l;
EINA_LIST_FOREACH(extra_dirs, l, path)
{
if (eina_list_search_unsorted_list(systemdirs, strcmplen, path))
continue;
if (eina_list_search_unsorted_list(store_dirs, EINA_COMPARE_CB(strcmp), path))
continue;
if (!ecore_file_is_dir(path)) continue;
/* If we scan a passed dir, we must have changed */
changed = 1;
if (!cache_scan(path, NULL, priority, 0, &changed)) goto error;
store_dirs = eina_list_append(store_dirs, path);
}
store_dirs = eina_list_sort(store_dirs, -1, EINA_COMPARE_CB(strcmp));
}
if (user_dirs)
efreet_cache_array_string_free(user_dirs);
/* store user dirs */
if (store_dirs)
{
Eina_List *l;
user_dirs = NEW(Efreet_Cache_Array_String, 1);
user_dirs->array = NEW(char *, eina_list_count(store_dirs));
user_dirs->array_count = 0;
EINA_LIST_FOREACH(store_dirs, l, path)
user_dirs->array[user_dirs->array_count++] = path;
eet_data_write(ef, efreet_array_string_edd(), EFREET_CACHE_DESKTOP_DIRS, user_dirs, 1);
IF_FREE(user_dirs->array);
free(user_dirs);
}
/* store util */ /* store util */
#define STORE_HASH_ARRAY(_hash) \ #define STORE_HASH_ARRAY(_hash) \
@ -496,24 +423,16 @@ main(int argc, char **argv)
unlink(file); unlink(file);
} }
/* touch update file */
snprintf(file, sizeof(file), "%s/efreet/update/desktop_data.update", efreet_cache_home_get());
tmpfd = open(file, O_CREAT | O_WRONLY, S_IRUSR | S_IWUSR);
if (tmpfd >= 0)
{ {
char c = 'n'; char c = 'n';
efreet_fsetowner(tmpfd);
if (changed) c = 'c'; if (changed) c = 'c';
if (write(tmpfd, &c, 1) != 1) perror("write");
close(tmpfd);
printf("%c\n", c); printf("%c\n", c);
} }
EINA_LIST_FREE(systemdirs, dir) EINA_LIST_FREE(systemdirs, dir)
eina_stringshare_del(dir); eina_stringshare_del(dir);
eina_list_free(extra_dirs); eina_list_free(extra_dirs);
eina_list_free(store_dirs);
efreet_shutdown(); efreet_shutdown();
ecore_shutdown(); ecore_shutdown();
eet_shutdown(); eet_shutdown();
@ -524,7 +443,6 @@ main(int argc, char **argv)
error: error:
IF_FREE(dir); IF_FREE(dir);
edd_error: edd_error:
if (user_dirs) efreet_cache_array_string_free(user_dirs);
if (old_file_ids) if (old_file_ids)
{ {
eina_hash_free(old_file_ids->hash); eina_hash_free(old_file_ids->hash);
@ -539,7 +457,6 @@ eet_error:
EINA_LIST_FREE(systemdirs, dir) EINA_LIST_FREE(systemdirs, dir)
eina_stringshare_del(dir); eina_stringshare_del(dir);
eina_list_free(extra_dirs); eina_list_free(extra_dirs);
eina_list_free(store_dirs);
eina_log_domain_unregister(_efreet_desktop_cache_log_dom); eina_log_domain_unregister(_efreet_desktop_cache_log_dom);
eina_shutdown(); eina_shutdown();
eina_error: eina_error:

97
legacy/efreet/src/bin/efreet_icon_cache_create.c
View File

@ -694,77 +694,6 @@ icon_theme_free(Efreet_Cache_Icon_Theme *theme)
free(theme); free(theme);
} }
/**
* @internal
* @return EINA_TRUE if data adds new
*/
static Eina_Bool
add_data(Eet_File *ef, Eina_Array *data, const char *key)
{
Efreet_Cache_Array_String *add;
unsigned int i, j;
Eina_Bool added = EINA_FALSE;
add = eet_data_read(ef, efreet_array_string_edd(), key);
if (!add) return EINA_TRUE;
/* loop once to check added */
for (i = 0; i < data->count; i++)
{
int found = 0;
for (j = 0; j < add->array_count; ++j)
{
if (!strcmp(add->array[j], data->data[i]))
{
found = 1;
break;
}
}
if (!found)
{
added = EINA_TRUE;
break;
}
}
/* loop again to add all data */
for (i = 0; i < add->array_count; i++)
{
int found = 0;
for (j = 0; j < data->count; ++j)
{
if (!strcmp(add->array[i], data->data[j]))
{
found = 1;
break;
}
}
if (!found)
eina_array_push(data, add->array[i]);
}
IF_FREE(add->array);
free(add);
return added;
}
static void
save_data(Eet_File *ef, Eina_Array *data, const char *key)
{
Efreet_Cache_Array_String *save;
unsigned int i;
if (!data || !data->count) return;
save = NEW(Efreet_Cache_Array_String, 1);
save->array = NEW(char *, data->count);
save->array_count = 0;
for (i = 0; i < data->count; ++i)
save->array[save->array_count++] = data->data[i];
eet_data_write(ef, efreet_array_string_edd(), key, save, 1);
IF_FREE(save->array);
free(save);
}
int int
main(int argc, char **argv) main(int argc, char **argv)
{ {
@ -790,7 +719,6 @@ main(int argc, char **argv)
Eina_Bool changed = EINA_FALSE; Eina_Bool changed = EINA_FALSE;
Eina_Bool flush = EINA_FALSE; Eina_Bool flush = EINA_FALSE;
int lockfd = -1; int lockfd = -1;
int tmpfd = -1;
char **keys; char **keys;
int num, i; int num, i;
@ -822,6 +750,7 @@ main(int argc, char **argv)
printf(" -v Verbose mode\n"); printf(" -v Verbose mode\n");
printf(" -e .ext1 .ext2 Extensions\n"); printf(" -e .ext1 .ext2 Extensions\n");
printf(" -d dir1 dir2 Extra dirs\n"); printf(" -d dir1 dir2 Extra dirs\n");
printf(" -f Flush\n");
exit(0); exit(0);
} }
else if (!strcmp(argv[i], "-e")) else if (!strcmp(argv[i], "-e"))
@ -834,6 +763,8 @@ main(int argc, char **argv)
while ((i < (argc - 1)) && (argv[(i + 1)][0] != '-')) while ((i < (argc - 1)) && (argv[(i + 1)][0] != '-'))
eina_array_push(extra_dirs, argv[++i]); eina_array_push(extra_dirs, argv[++i]);
} }
else if (!strcmp(argv[i], "-d"))
flush = EINA_TRUE;
} }
if (!eet_init()) return -1; if (!eet_init()) return -1;
@ -852,12 +783,6 @@ main(int argc, char **argv)
if (!ecore_file_mkpath(file)) return -1; if (!ecore_file_mkpath(file)) return -1;
efreet_setowner(file); efreet_setowner(file);
} }
snprintf(file, sizeof(file), "%s/efreet/update", efreet_cache_home_get());
if (!ecore_file_exists(file))
{
if (!ecore_file_mkpath(file)) return -1;
efreet_setowner(file);
}
/* lock process, so that we only run one copy of this program */ /* lock process, so that we only run one copy of this program */
lockfd = cache_lock_file(); lockfd = cache_lock_file();
@ -894,10 +819,6 @@ main(int argc, char **argv)
theme_version->major = EFREET_ICON_CACHE_MAJOR; theme_version->major = EFREET_ICON_CACHE_MAJOR;
theme_version->minor = EFREET_ICON_CACHE_MINOR; theme_version->minor = EFREET_ICON_CACHE_MINOR;
if (add_data(theme_ef, exts, EFREET_CACHE_ICON_EXTENSIONS))
flush = EINA_TRUE;
if (add_data(theme_ef, extra_dirs, EFREET_CACHE_ICON_EXTRA_DIRS))
flush = EINA_TRUE;
if (flush) if (flush)
changed = EINA_TRUE; changed = EINA_TRUE;
@ -1004,7 +925,7 @@ main(int argc, char **argv)
INF("generated: '%s' %i (%i)", INF("generated: '%s' %i (%i)",
theme->theme.name.internal, theme->theme.name.internal,
changed, theme->changed,
eina_hash_population(icons)); eina_hash_population(icons));
icons_it = eina_hash_iterator_tuple_new(icons); icons_it = eina_hash_iterator_tuple_new(icons);
@ -1017,6 +938,7 @@ main(int argc, char **argv)
} }
eina_hash_free(themes); eina_hash_free(themes);
eina_hash_free(icons); eina_hash_free(icons);
changed = EINA_TRUE;
} }
eet_data_write(icon_ef, efreet_version_edd(), EFREET_CACHE_VERSION, icon_version, 1); eet_data_write(icon_ef, efreet_version_edd(), EFREET_CACHE_VERSION, icon_version, 1);
@ -1110,24 +1032,15 @@ main(int argc, char **argv)
/* save data */ /* save data */
eet_data_write(theme_ef, efreet_version_edd(), EFREET_CACHE_VERSION, theme_version, 1); eet_data_write(theme_ef, efreet_version_edd(), EFREET_CACHE_VERSION, theme_version, 1);
save_data(theme_ef, exts, EFREET_CACHE_ICON_EXTENSIONS);
save_data(theme_ef, extra_dirs, EFREET_CACHE_ICON_EXTRA_DIRS);
eet_close(theme_ef); eet_close(theme_ef);
efreet_setowner(efreet_icon_theme_cache_file()); efreet_setowner(efreet_icon_theme_cache_file());
free(theme_version); free(theme_version);
/* touch update file */
snprintf(file, sizeof(file), "%s/efreet/update/icon_data.update", efreet_cache_home_get());
tmpfd = open(file, O_CREAT | O_WRONLY, S_IRUSR | S_IWUSR);
if (tmpfd >= 0)
{ {
char c = 'n'; char c = 'n';
efreet_fsetowner(tmpfd);
if (changed) c = 'c'; if (changed) c = 'c';
if (write(tmpfd, &c, 1) != 1) perror("write");
close(tmpfd);
printf("%c\n", c); printf("%c\n", c);
} }

3
legacy/efreet/src/bin/efreetd.c
View File

@ -45,7 +45,8 @@ dbus_error:
ecore_file_error: ecore_file_error:
ecore_shutdown(); ecore_shutdown();
ecore_error: ecore_error:
eina_log_domain_unregister(efreetd_log_dom); if (efreetd_log_dom >= 0)
eina_log_domain_unregister(efreetd_log_dom);
efreetd_log_dom = -1; efreetd_log_dom = -1;
eina_shutdown(); eina_shutdown();
return 1; return 1;

137
legacy/efreet/src/bin/efreetd_cache.c
View File

@ -12,6 +12,7 @@
#include "Efreet.h" #include "Efreet.h"
#define EFREET_MODULE_LOG_DOM efreetd_log_dom #define EFREET_MODULE_LOG_DOM efreetd_log_dom
#include "efreet_private.h" #include "efreet_private.h"
#include "efreetd_cache.h"
static Eina_Hash *change_monitors = NULL; static Eina_Hash *change_monitors = NULL;
@ -22,9 +23,11 @@ static Ecore_Exe *desktop_cache_exe = NULL;
static Ecore_Timer *icon_cache_timer = NULL; static Ecore_Timer *icon_cache_timer = NULL;
static Ecore_Timer *desktop_cache_timer = NULL; static Ecore_Timer *desktop_cache_timer = NULL;
static Eina_List *desktop_system_dirs = NULL;
static Eina_List *desktop_extra_dirs = NULL; static Eina_List *desktop_extra_dirs = NULL;
static Eina_List *icon_extra_dirs = NULL; static Eina_List *icon_extra_dirs = NULL;
static Eina_List *icon_extra_exts = NULL; static Eina_List *icon_exts = NULL;
static Eina_Bool icon_flush = EINA_FALSE;
static void desktop_changes_monitor_add(const char *path); static void desktop_changes_monitor_add(const char *path);
@ -37,6 +40,8 @@ icon_cache_update_cache_cb(void *data __UNUSED__)
icon_cache_timer = NULL; icon_cache_timer = NULL;
if ((!icon_flush) && (!icon_exts)) return ECORE_CALLBACK_CANCEL;
/* TODO: Queue if already running */ /* TODO: Queue if already running */
prio = ecore_exe_run_priority_get(); prio = ecore_exe_run_priority_get();
ecore_exe_run_priority_set(19); ecore_exe_run_priority_set(19);
@ -53,29 +58,35 @@ icon_cache_update_cache_cb(void *data __UNUSED__)
eina_strlcat(file, p, sizeof(file)); eina_strlcat(file, p, sizeof(file));
} }
} }
if (icon_extra_exts) if (icon_exts)
{ {
Eina_List *ll; Eina_List *ll;
char *p; char *p;
eina_strlcat(file, " -e", sizeof(file)); eina_strlcat(file, " -e", sizeof(file));
EINA_LIST_FOREACH(icon_extra_exts, ll, p) EINA_LIST_FOREACH(icon_exts, ll, p)
{ {
eina_strlcat(file, " ", sizeof(file)); eina_strlcat(file, " ", sizeof(file));
eina_strlcat(file, p, sizeof(file)); eina_strlcat(file, p, sizeof(file));
} }
} }
icon_cache_exe = ecore_exe_run(file, NULL); if (icon_flush)
eina_strlcat(file, " -f", sizeof(file));
icon_flush = EINA_FALSE;
icon_cache_exe =
ecore_exe_pipe_run(file, ECORE_EXE_PIPE_READ|ECORE_EXE_PIPE_READ_LINE_BUFFERED, NULL);
ecore_exe_run_priority_set(prio); ecore_exe_run_priority_set(prio);
return ECORE_CALLBACK_CANCEL; return ECORE_CALLBACK_CANCEL;
} }
static void static void
cache_icon_update(void) cache_icon_update(Eina_Bool flush)
{ {
if (icon_cache_timer) if (icon_cache_timer)
ecore_timer_del(icon_cache_timer); ecore_timer_del(icon_cache_timer);
if (flush)
icon_flush = flush;
icon_cache_timer = ecore_timer_add(0.2, icon_cache_update_cache_cb, NULL); icon_cache_timer = ecore_timer_add(0.2, icon_cache_update_cache_cb, NULL);
} }
@ -104,20 +115,13 @@ desktop_cache_update_cache_cb(void *data __UNUSED__)
} }
} }
INF("Run desktop cache creation: %s", file); INF("Run desktop cache creation: %s", file);
desktop_cache_exe = ecore_exe_run(file, NULL); desktop_cache_exe =
ecore_exe_pipe_run(file, ECORE_EXE_PIPE_READ|ECORE_EXE_PIPE_READ_LINE_BUFFERED, NULL);
ecore_exe_run_priority_set(prio); ecore_exe_run_priority_set(prio);
return ECORE_CALLBACK_CANCEL; return ECORE_CALLBACK_CANCEL;
} }
static void
cache_desktop_update(void)
{
if (desktop_cache_timer)
ecore_timer_del(desktop_cache_timer);
desktop_cache_timer = ecore_timer_add(0.2, desktop_cache_update_cache_cb, NULL);
}
static Eina_Bool static Eina_Bool
cache_exe_data_cb(void *data __UNUSED__, int type __UNUSED__, void *event) cache_exe_data_cb(void *data __UNUSED__, int type __UNUSED__, void *event)
{ {
@ -139,6 +143,7 @@ cache_exe_data_cb(void *data __UNUSED__, int type __UNUSED__, void *event)
if ((ev->lines) && (*ev->lines->line == 'c')) if ((ev->lines) && (*ev->lines->line == 'c'))
update = EINA_TRUE; update = EINA_TRUE;
send_signal_icon_cache_update(update); send_signal_icon_cache_update(update);
} }
return ECORE_CALLBACK_RENEW; return ECORE_CALLBACK_RENEW;
@ -178,12 +183,12 @@ icon_changes_cb(void *data __UNUSED__, Ecore_File_Monitor *em __UNUSED__,
case ECORE_FILE_EVENT_CLOSED: case ECORE_FILE_EVENT_CLOSED:
case ECORE_FILE_EVENT_DELETED_DIRECTORY: case ECORE_FILE_EVENT_DELETED_DIRECTORY:
case ECORE_FILE_EVENT_CREATED_DIRECTORY: case ECORE_FILE_EVENT_CREATED_DIRECTORY:
cache_icon_update(); cache_icon_update(EINA_FALSE);
break; break;
case ECORE_FILE_EVENT_DELETED_SELF: case ECORE_FILE_EVENT_DELETED_SELF:
eina_hash_del_by_key(change_monitors, path); eina_hash_del_by_key(change_monitors, path);
cache_icon_update(); cache_icon_update(EINA_FALSE);
break; break;
} }
} }
@ -193,23 +198,26 @@ icon_changes_monitor_add(const char *path)
{ {
Eina_Iterator *it; Eina_Iterator *it;
Eina_File_Direct_Info *info; Eina_File_Direct_Info *info;
Ecore_File_Monitor *mon;
if (!ecore_file_is_dir(path)) return; if (!ecore_file_is_dir(path)) return;
if (eina_hash_find(change_monitors, path)) return; if (eina_hash_find(change_monitors, path)) return;
eina_hash_add(change_monitors, path, mon = ecore_file_monitor_add(path,
ecore_file_monitor_add(path, icon_changes_cb,
icon_changes_cb, NULL);
NULL)); if (mon)
eina_hash_add(change_monitors, path, mon);
it = eina_file_stat_ls(path); it = eina_file_stat_ls(path);
if (!it) return; if (!it) return;
EINA_ITERATOR_FOREACH(it, info) EINA_ITERATOR_FOREACH(it, info)
{ {
if (info->type != EINA_FILE_DIR) continue; if (info->type != EINA_FILE_DIR) continue;
eina_hash_add(change_monitors, info->path, mon = ecore_file_monitor_add(info->path,
ecore_file_monitor_add(info->path, icon_changes_cb,
icon_changes_cb, NULL);
NULL)); if (mon)
eina_hash_add(change_monitors, info->path, mon);
} }
eina_iterator_free(it); eina_iterator_free(it);
} }
@ -286,11 +294,14 @@ desktop_changes_cb(void *data __UNUSED__, Ecore_File_Monitor *em __UNUSED__,
static void static void
desktop_changes_monitor_add(const char *path) desktop_changes_monitor_add(const char *path)
{ {
Ecore_File_Monitor *mon;
if (eina_hash_find(change_monitors, path)) return; if (eina_hash_find(change_monitors, path)) return;
eina_hash_add(change_monitors, path, mon = ecore_file_monitor_add(path,
ecore_file_monitor_add(path, desktop_changes_cb,
desktop_changes_cb, NULL);
NULL)); if (mon)
eina_hash_add(change_monitors, path, mon);
} }
static void static void
@ -314,17 +325,13 @@ desktop_changes_listen_recursive(const char *path)
static void static void
desktop_changes_listen(void) desktop_changes_listen(void)
{ {
Eina_List *dirs, *l; Eina_List *l;
const char *path; const char *path;
dirs = efreet_default_dirs_get(efreet_data_home_get(), EINA_LIST_FOREACH(desktop_system_dirs, l, path)
efreet_data_dirs_get(), "applications");
EINA_LIST_FREE(dirs, path)
{ {
if (ecore_file_is_dir(path)) if (ecore_file_is_dir(path))
desktop_changes_listen_recursive(path); desktop_changes_listen_recursive(path);
eina_stringshare_del(path);
} }
EINA_LIST_FOREACH(desktop_extra_dirs, l, path) EINA_LIST_FOREACH(desktop_extra_dirs, l, path)
@ -332,7 +339,7 @@ desktop_changes_listen(void)
} }
static void static void
fill_extra(const char *file, Eina_List **l) fill_list(const char *file, Eina_List **l)
{ {
Eina_File *f = NULL; Eina_File *f = NULL;
Eina_Iterator *it = NULL; Eina_Iterator *it = NULL;
@ -349,7 +356,6 @@ fill_extra(const char *file, Eina_List **l)
const char *end; const char *end;
end = line->end - 1; end = line->end - 1;
*l = eina_list_append(*l, eina_stringshare_add_length(line->start, end - line->start)); *l = eina_list_append(*l, eina_stringshare_add_length(line->start, end - line->start));
printf("fill: %s\n", (const char *)(*l)->data);
} }
eina_iterator_free(it); eina_iterator_free(it);
error: error:
@ -357,15 +363,15 @@ error:
} }
static void static void
read_extra(void) read_lists(void)
{ {
fill_extra("extra_desktop.dirs", &desktop_extra_dirs); fill_list("extra_desktop.dirs", &desktop_extra_dirs);
fill_extra("extra_icon.dirs", &icon_extra_dirs); fill_list("extra_icon.dirs", &icon_extra_dirs);
fill_extra("extra_icon.exts", &icon_extra_exts); fill_list("icon.exts", &icon_exts);
} }
static void static void
save_extra(const char *file, Eina_List *l) save_list(const char *file, Eina_List *l)
{ {
FILE *f; FILE *f;
char buf[PATH_MAX]; char buf[PATH_MAX];
@ -373,13 +379,19 @@ save_extra(const char *file, Eina_List *l)
const char *path; const char *path;
snprintf(buf, sizeof(buf), "%s/efreet/%s", efreet_cache_home_get(), file); snprintf(buf, sizeof(buf), "%s/efreet/%s", efreet_cache_home_get(), file);
f = fopen("wb", buf); f = fopen(buf, "wb");
if (!f) return; if (!f) return;
EINA_LIST_FOREACH(l, ll, path) EINA_LIST_FOREACH(l, ll, path)
fprintf(f, "%s\n", path); fprintf(f, "%s\n", path);
fclose(f); fclose(f);
} }
static int
strcmplen(const void *data1, const void *data2)
{
return strncmp(data1, data2, eina_stringshare_strlen(data1));
}
/* external */ /* external */
void void
cache_desktop_dir_add(const char *dir) cache_desktop_dir_add(const char *dir)
@ -388,10 +400,11 @@ cache_desktop_dir_add(const char *dir)
san = eina_file_path_sanitize(dir); san = eina_file_path_sanitize(dir);
if (!san) return; if (!san) return;
if (!eina_list_search_unsorted_list(desktop_extra_dirs, EINA_COMPARE_CB(strcmp), san)) if ((!eina_list_search_unsorted_list(desktop_system_dirs, strcmplen, san)) &&
(!eina_list_search_unsorted_list(desktop_extra_dirs, EINA_COMPARE_CB(strcmp), san)))
{ {
desktop_extra_dirs = eina_list_append(desktop_extra_dirs, eina_stringshare_add(san)); desktop_extra_dirs = eina_list_append(desktop_extra_dirs, eina_stringshare_add(san));
save_extra("extra_desktop.dirs", desktop_extra_dirs); save_list("extra_desktop.dirs", desktop_extra_dirs);
cache_desktop_update(); cache_desktop_update();
} }
free(san); free(san);
@ -407,8 +420,8 @@ cache_icon_dir_add(const char *dir)
if (!eina_list_search_unsorted_list(icon_extra_dirs, EINA_COMPARE_CB(strcmp), san)) if (!eina_list_search_unsorted_list(icon_extra_dirs, EINA_COMPARE_CB(strcmp), san))
{ {
icon_extra_dirs = eina_list_append(icon_extra_dirs, eina_stringshare_add(san)); icon_extra_dirs = eina_list_append(icon_extra_dirs, eina_stringshare_add(san));
save_extra("extra_icon.dirs", icon_extra_dirs); save_list("extra_icon.dirs", icon_extra_dirs);
cache_icon_update(); cache_icon_update(EINA_TRUE);
} }
free(san); free(san);
} }
@ -416,14 +429,22 @@ cache_icon_dir_add(const char *dir)
void void
cache_icon_ext_add(const char *ext) cache_icon_ext_add(const char *ext)
{ {
if (!eina_list_search_unsorted_list(icon_extra_exts, EINA_COMPARE_CB(strcmp), ext)) if (!eina_list_search_unsorted_list(icon_exts, EINA_COMPARE_CB(strcmp), ext))
{ {
icon_extra_exts = eina_list_append(icon_extra_exts, eina_stringshare_add(ext)); icon_exts = eina_list_append(icon_exts, eina_stringshare_add(ext));
save_extra("extra_icon.exts", icon_extra_exts); save_list("icon.exts", icon_exts);
cache_icon_update(); cache_icon_update(EINA_TRUE);
} }
} }
void
cache_desktop_update(void)
{
if (desktop_cache_timer)
ecore_timer_del(desktop_cache_timer);
desktop_cache_timer = ecore_timer_add(0.2, desktop_cache_update_cache_cb, NULL);
}
Eina_Bool Eina_Bool
cache_init(void) cache_init(void)
{ {
@ -437,14 +458,14 @@ cache_init(void)
} }
cache_exe_del_handler = ecore_event_handler_add(ECORE_EXE_EVENT_DEL, cache_exe_del_handler = ecore_event_handler_add(ECORE_EXE_EVENT_DEL,
cache_exe_del_cb, NULL); cache_exe_del_cb, NULL);
if (!cache_exe_del_handler) if (!cache_exe_del_handler)
{ {
ERR("Failed to add exe del handler\n"); ERR("Failed to add exe del handler\n");
goto error; goto error;
} }
cache_exe_data_handler = ecore_event_handler_add(ECORE_EXE_EVENT_DATA, cache_exe_data_handler = ecore_event_handler_add(ECORE_EXE_EVENT_DATA,
cache_exe_data_cb, NULL); cache_exe_data_cb, NULL);
if (!cache_exe_data_handler) if (!cache_exe_data_handler)
{ {
ERR("Failed to add exe del handler\n"); ERR("Failed to add exe del handler\n");
@ -456,10 +477,13 @@ cache_init(void)
efreet_cache_update = 0; efreet_cache_update = 0;
if (!efreet_init()) goto error; if (!efreet_init()) goto error;
read_extra(); read_lists();
/* TODO: Should check if system dirs has changed and handles extra_dirs */
desktop_system_dirs = efreet_default_dirs_get(efreet_data_home_get(),
efreet_data_dirs_get(), "applications");
icon_changes_listen(); icon_changes_listen();
desktop_changes_listen(); desktop_changes_listen();
cache_icon_update(); cache_icon_update(EINA_FALSE);
cache_desktop_update(); cache_desktop_update();
return EINA_TRUE; return EINA_TRUE;
@ -485,11 +509,14 @@ cache_shutdown(void)
if (change_monitors) if (change_monitors)
eina_hash_free(change_monitors); eina_hash_free(change_monitors);
change_monitors = NULL;
EINA_LIST_FREE(desktop_system_dirs, data)
eina_stringshare_del(data);
EINA_LIST_FREE(desktop_extra_dirs, data) EINA_LIST_FREE(desktop_extra_dirs, data)
eina_stringshare_del(data); eina_stringshare_del(data);
EINA_LIST_FREE(icon_extra_dirs, data) EINA_LIST_FREE(icon_extra_dirs, data)
eina_stringshare_del(data); eina_stringshare_del(data);
EINA_LIST_FREE(icon_extra_exts, data) EINA_LIST_FREE(icon_exts, data)
eina_stringshare_del(data); eina_stringshare_del(data);
return EINA_TRUE; return EINA_TRUE;
} }

1
legacy/efreet/src/bin/efreetd_cache.h
View File

@ -4,6 +4,7 @@
void cache_desktop_dir_add(const char *dir); void cache_desktop_dir_add(const char *dir);
void cache_icon_dir_add(const char *dir); void cache_icon_dir_add(const char *dir);
void cache_icon_ext_add(const char *ext); void cache_icon_ext_add(const char *ext);
void cache_desktop_update(void);
Eina_Bool cache_init(void); Eina_Bool cache_init(void);
Eina_Bool cache_shutdown(void); Eina_Bool cache_shutdown(void);

30
legacy/efreet/src/bin/efreetd_dbus.c
View File

@ -7,8 +7,8 @@
#include "efreetd.h" #include "efreetd.h"
#include "efreetd_cache.h" #include "efreetd_cache.h"
#define BUS "org.enlightenment" #define BUS "org.enlightenment.Efreet"
#define PATH "/org/enlightenment" #define PATH "/org/enlightenment/Efreet"
#define INTERFACE "org.enlightenment.Efreet" #define INTERFACE "org.enlightenment.Efreet"
/* internal */ /* internal */
@ -24,17 +24,15 @@ static EDBus_Service_Interface *iface;
static EDBus_Message * static EDBus_Message *
ping(const EDBus_Service_Interface *ifc __UNUSED__, const EDBus_Message *message) ping(const EDBus_Service_Interface *ifc __UNUSED__, const EDBus_Message *message)
{ {
printf("ping\n");
return edbus_message_method_return_new(message); return edbus_message_method_return_new(message);
} }
static EDBus_Message * static EDBus_Message *
add_desktop_dirs(const EDBus_Service_Interface *ifc __UNUSED__, const EDBus_Message *message) add_desktop_dirs(const EDBus_Service_Interface *ifc __UNUSED__, const EDBus_Message *message)
{ {
EDBus_Message_Iter *array = NULL; EDBus_Message_Iter *array = NULL;
const char *dir; const char *dir;
printf("Add desktop dirs\n");
if (!edbus_message_arguments_get(message, "as", &array)) if (!edbus_message_arguments_get(message, "as", &array))
{ {
ERR("Error getting arguments."); ERR("Error getting arguments.");
@ -55,7 +53,6 @@ add_icon_dirs(const EDBus_Service_Interface *ifc __UNUSED__, const EDBus_Message
EDBus_Message_Iter *array = NULL; EDBus_Message_Iter *array = NULL;
const char *dir; const char *dir;
printf("Add icon dirs\n");
if (!edbus_message_arguments_get(message, "as", &array)) if (!edbus_message_arguments_get(message, "as", &array))
{ {
ERR("Error getting arguments."); ERR("Error getting arguments.");
@ -70,13 +67,19 @@ add_icon_dirs(const EDBus_Service_Interface *ifc __UNUSED__, const EDBus_Message
return NULL; return NULL;
} }
static EDBus_Message *
build_desktop_cache(const EDBus_Service_Interface *ifc __UNUSED__, const EDBus_Message *message __UNUSED__)
{
cache_desktop_update();
return NULL;
}
static EDBus_Message * static EDBus_Message *
add_icon_exts(const EDBus_Service_Interface *ifc __UNUSED__, const EDBus_Message *message) add_icon_exts(const EDBus_Service_Interface *ifc __UNUSED__, const EDBus_Message *message)
{ {
EDBus_Message_Iter *array = NULL; EDBus_Message_Iter *array = NULL;
const char *ext; const char *ext;
printf("Add icon exts\n");
if (!edbus_message_arguments_get(message, "as", &array)) if (!edbus_message_arguments_get(message, "as", &array))
{ {
ERR("Error getting arguments."); ERR("Error getting arguments.");
@ -98,26 +101,31 @@ static const EDBus_Signal signals[] = {
}; };
static const EDBus_Method methods[] = { static const EDBus_Method methods[] = {
/* TODO: Register / Unregister */
{ {
"Ping", NULL, NULL, "Ping", NULL, NULL,
ping, 0 ping, 0
}, },
{ {
"AddDesktopDirs", NULL, EDBUS_ARGS({"as", "dirs"}), "AddDesktopDirs", EDBUS_ARGS({"as", "dirs"}), NULL,
add_desktop_dirs, EDBUS_METHOD_FLAG_NOREPLY add_desktop_dirs, EDBUS_METHOD_FLAG_NOREPLY
}, },
{ {
"AddIconDirs", NULL, EDBUS_ARGS({"as", "dirs"}), "BuildDesktopCache", NULL, NULL,
build_desktop_cache, EDBUS_METHOD_FLAG_NOREPLY
},
{
"AddIconDirs", EDBUS_ARGS({"as", "dirs"}), NULL,
add_icon_dirs, EDBUS_METHOD_FLAG_NOREPLY add_icon_dirs, EDBUS_METHOD_FLAG_NOREPLY
}, },
{ {
"AddIconExts", NULL, EDBUS_ARGS({"as", "exts"}), "AddIconExts", EDBUS_ARGS({"as", "exts"}), NULL,
add_icon_exts, EDBUS_METHOD_FLAG_NOREPLY add_icon_exts, EDBUS_METHOD_FLAG_NOREPLY
}, },
{ NULL, NULL, NULL, NULL, 0 } { NULL, NULL, NULL, NULL, 0 }
}; };
const static EDBus_Service_Interface_Desc desc = { static const EDBus_Service_Interface_Desc desc = {
INTERFACE, methods, signals INTERFACE, methods, signals
}; };

2
legacy/efreet/src/lib/efreet.c
View File

@ -187,7 +187,7 @@ efreet_lang_reset(void)
efreet_dirs_reset(); efreet_dirs_reset();
efreet_cache_desktop_close(); efreet_cache_desktop_close();
efreet_cache_desktop_update(); efreet_cache_desktop_build();
} }
/** /**

526
legacy/efreet/src/lib/efreet_cache.c
View File

@ -15,6 +15,7 @@
#include <Eet.h> #include <Eet.h>
#include <Ecore.h> #include <Ecore.h>
#include <Ecore_File.h> #include <Ecore_File.h>
#include <EDBus.h>
/* define macros and variable for using the eina logging system */ /* define macros and variable for using the eina logging system */
#define EFREET_MODULE_LOG_DOM _efreet_cache_log_dom #define EFREET_MODULE_LOG_DOM _efreet_cache_log_dom
@ -34,6 +35,13 @@ struct _Efreet_Old_Cache
Eet_File *ef; Eet_File *ef;
}; };
/* TODO: Common define location with daemon */
#define BUS "org.enlightenment.Efreet"
#define PATH "/org/enlightenment/Efreet"
#define INTERFACE "org.enlightenment.Efreet"
static EDBus_Connection *conn = NULL;
static EDBus_Proxy *proxy = NULL;
/** /**
* Data for cache files * Data for cache files
*/ */
@ -65,20 +73,9 @@ static Eet_Data_Descriptor *array_string_edd = NULL;
static Eet_Data_Descriptor *hash_string_edd = NULL; static Eet_Data_Descriptor *hash_string_edd = NULL;
static Eina_Hash *desktops = NULL; static Eina_Hash *desktops = NULL;
static Eina_List *desktop_dirs_add = NULL;
static Eet_File *desktop_cache = NULL; static Eet_File *desktop_cache = NULL;
static const char *desktop_cache_file = NULL; static const char *desktop_cache_file = NULL;
static Ecore_File_Monitor *cache_monitor = NULL;
static Ecore_Event_Handler *cache_exe_handler = NULL;
static Ecore_Timer *icon_cache_timer = NULL;
static Ecore_Exe *icon_cache_exe = NULL;
static int icon_cache_exe_lock = -1;
static Ecore_Timer *desktop_cache_timer = NULL;
static Ecore_Exe *desktop_cache_exe = NULL;
static int desktop_cache_exe_lock = -1;
static Eina_List *old_desktop_caches = NULL; static Eina_List *old_desktop_caches = NULL;
static const char *util_cache_file = NULL; static const char *util_cache_file = NULL;
@ -96,14 +93,10 @@ static void efreet_cache_icon_theme_free(Efreet_Icon_Theme *theme);
static Eina_Bool efreet_cache_check(Eet_File **ef, const char *path, int major); static Eina_Bool efreet_cache_check(Eet_File **ef, const char *path, int major);
static void *efreet_cache_close(Eet_File *ef); static void *efreet_cache_close(Eet_File *ef);
static Eina_Bool cache_exe_cb(void *data, int type, void *event); static void on_send_ping(void *data, const EDBus_Message *msg, EDBus_Pending *pending);
static Eina_Bool cache_check_change(const char *path); static void desktop_cache_update(void *context, const EDBus_Message *msg);
static void cache_update_cb(void *data, Ecore_File_Monitor *em, static void icon_cache_update(void *context, const EDBus_Message *msg);
Ecore_File_Event event, const char *path);
static Eina_Bool desktop_cache_update_cache_cb(void *data);
static Eina_Bool icon_cache_update_cache_cb(void *data);
static void desktop_cache_update_free(void *data, void *ev);
static void icon_cache_update_free(void *data, void *ev); static void icon_cache_update_free(void *data, void *ev);
static void *hash_array_string_add(void *hash, const char *key, void *data); static void *hash_array_string_add(void *hash, const char *key, void *data);
@ -128,50 +121,26 @@ efreet_cache_init(void)
fallbacks = eina_hash_string_superfast_new(EINA_FREE_CB(efreet_cache_icon_fallback_free)); fallbacks = eina_hash_string_superfast_new(EINA_FREE_CB(efreet_cache_icon_fallback_free));
desktops = eina_hash_string_superfast_new(NULL); desktops = eina_hash_string_superfast_new(NULL);
edbus_init();
if (efreet_cache_update) if (efreet_cache_update)
{ {
char buf[PATH_MAX]; EDBus_Object *obj;
snprintf(buf, sizeof(buf), "%s/efreet", efreet_cache_home_get()); conn = edbus_connection_get(EDBUS_CONNECTION_TYPE_SESSION);
if (!ecore_file_exists(buf)) if (!conn) goto error;
{
if (!ecore_file_mkpath(buf))
{
ERR("Failed to create directory '%s'", buf);
goto error;
}
efreet_setowner(buf);
}
snprintf(buf, sizeof(buf), "%s/efreet/update", efreet_cache_home_get());
if (!ecore_file_exists(buf))
{
if (!ecore_file_mkpath(buf))
{
ERR("Failed to create directory '%s'", buf);
goto error;
}
efreet_setowner(buf);
}
cache_exe_handler = ecore_event_handler_add(ECORE_EXE_EVENT_DEL, obj = edbus_object_get(conn, BUS, PATH);
cache_exe_cb, NULL); proxy = edbus_proxy_get(obj, INTERFACE);
if (!cache_exe_handler) edbus_proxy_signal_handler_add(proxy, "IconCacheUpdate", icon_cache_update, NULL);
{ edbus_proxy_signal_handler_add(proxy, "DesktopCacheUpdate", desktop_cache_update, NULL);
ERR("Failed to add exe del handler");
goto error;
}
cache_monitor = ecore_file_monitor_add(buf, edbus_proxy_call(proxy, "Ping", on_send_ping, NULL, -1, "");
cache_update_cb,
NULL);
if (!cache_monitor)
{
ERR("Failed to set up ecore file monitor for '%s'", buf);
goto error;
}
efreet_cache_icon_update(); /*
efreet_cache_desktop_update(); * TODO: Needed?
edbus_name_owner_changed_callback_add(conn, BUS, on_name_owner_changed,
conn, EINA_TRUE);
*/
} }
return 1; return 1;
@ -185,10 +154,6 @@ error:
if (desktops) eina_hash_free(desktops); if (desktops) eina_hash_free(desktops);
desktops = NULL; desktops = NULL;
if (cache_exe_handler) ecore_event_handler_del(cache_exe_handler);
cache_exe_handler = NULL;
if (cache_monitor) ecore_file_monitor_del(cache_monitor);
cache_monitor = NULL;
efreet_cache_edd_shutdown(); efreet_cache_edd_shutdown();
return 0; return 0;
} }
@ -197,7 +162,6 @@ void
efreet_cache_shutdown(void) efreet_cache_shutdown(void)
{ {
Efreet_Old_Cache *d; Efreet_Old_Cache *d;
void *data;
IF_RELEASE(theme_name); IF_RELEASE(theme_name);
@ -209,34 +173,11 @@ efreet_cache_shutdown(void)
IF_FREE_HASH(fallbacks); IF_FREE_HASH(fallbacks);
IF_FREE_HASH_CB(desktops, EINA_FREE_CB(efreet_cache_desktop_free)); IF_FREE_HASH_CB(desktops, EINA_FREE_CB(efreet_cache_desktop_free));
EINA_LIST_FREE(desktop_dirs_add, data)
eina_stringshare_del(data);
desktop_cache = efreet_cache_close(desktop_cache); desktop_cache = efreet_cache_close(desktop_cache);
IF_RELEASE(desktop_cache_file); IF_RELEASE(desktop_cache_file);
if (cache_exe_handler) ecore_event_handler_del(cache_exe_handler);
cache_exe_handler = NULL;
if (cache_monitor) ecore_file_monitor_del(cache_monitor);
cache_monitor = NULL;
efreet_cache_edd_shutdown(); efreet_cache_edd_shutdown();
if (desktop_cache_timer)
{
ecore_timer_del(desktop_cache_timer);
desktop_cache_timer = NULL;
}
IF_RELEASE(icon_theme_cache_file); IF_RELEASE(icon_theme_cache_file);
if (icon_cache_exe_lock > 0)
{
close(icon_cache_exe_lock);
icon_cache_exe_lock = -1;
}
if (desktop_cache_exe_lock > 0)
{
close(desktop_cache_exe_lock);
desktop_cache_exe_lock = -1;
}
if (old_desktop_caches) if (old_desktop_caches)
ERR("This application has not properly closed all its desktop references!"); ERR("This application has not properly closed all its desktop references!");
@ -264,6 +205,14 @@ efreet_cache_shutdown(void)
eina_log_domain_unregister(_efreet_cache_log_dom); eina_log_domain_unregister(_efreet_cache_log_dom);
_efreet_cache_log_dom = -1; _efreet_cache_log_dom = -1;
/*
* TODO: Needed??
edbus_name_owner_changed_callback_del(conn, BUS, on_name_owner_changed, conn);
*/
if (conn) edbus_connection_unref(conn);
edbus_shutdown();
} }
/* /*
@ -910,52 +859,56 @@ efreet_cache_desktop_free(Efreet_Desktop *desktop)
void void
efreet_cache_desktop_add(Efreet_Desktop *desktop) efreet_cache_desktop_add(Efreet_Desktop *desktop)
{ {
char buf[PATH_MAX]; EDBus_Message *msg;
char *dir; EDBus_Message_Iter *iter, *array_of_string;
Efreet_Cache_Array_String *arr;
/* if (!efreet_cache_update) return;
* Read file from disk, save path in cache so it will be included in next /* TODO: Chunk updates */
* cache update msg = edbus_proxy_method_call_new(proxy, "AddDesktopDirs");
*/ iter = edbus_message_iter_get(msg);
strncpy(buf, desktop->orig_path, PATH_MAX); array_of_string = edbus_message_iter_container_new(iter, 'a',"s");
buf[PATH_MAX - 1] = '\0'; edbus_message_iter_basic_append(array_of_string, 's', desktop->orig_path);
dir = dirname(buf); edbus_message_iter_container_close(iter, array_of_string);
arr = efreet_cache_desktop_dirs(); edbus_proxy_send(proxy, msg, NULL, NULL, -1);
if (arr) edbus_message_unref(msg);
{
unsigned int i;
for (i = 0; i < arr->array_count; i++)
{
/* Check if we already have this dir in cache */
if (!strcmp(dir, arr->array[i]))
return;
}
efreet_cache_array_string_free(arr);
}
if (!eina_list_search_unsorted_list(desktop_dirs_add, EINA_COMPARE_CB(strcmp), dir))
desktop_dirs_add = eina_list_append(desktop_dirs_add, eina_stringshare_add(dir));
efreet_cache_desktop_update();
}
Efreet_Cache_Array_String *
efreet_cache_desktop_dirs(void)
{
if (!efreet_cache_check(&desktop_cache, efreet_desktop_cache_file(), EFREET_DESKTOP_CACHE_MAJOR)) return NULL;
return eet_data_read(desktop_cache, efreet_array_string_edd(), EFREET_CACHE_DESKTOP_DIRS);
} }
void void
efreet_cache_desktop_update(void) efreet_cache_icon_exts_add(Eina_List *exts)
{ {
if (!efreet_cache_update) return; EDBus_Message *msg;
EDBus_Message_Iter *iter, *array_of_string;
Eina_List *l;
const char *ext;
if (desktop_cache_timer) if (!efreet_cache_update) return;
ecore_timer_del(desktop_cache_timer); msg = edbus_proxy_method_call_new(proxy, "AddIconExts");
desktop_cache_timer = ecore_timer_add(0.2, desktop_cache_update_cache_cb, NULL); iter = edbus_message_iter_get(msg);
array_of_string = edbus_message_iter_container_new(iter, 'a',"s");
EINA_LIST_FOREACH(exts, l, ext)
edbus_message_iter_basic_append(array_of_string, 's', ext);
edbus_message_iter_container_close(iter, array_of_string);
edbus_proxy_send(proxy, msg, NULL, NULL, -1);
edbus_message_unref(msg);
}
void
efreet_cache_icon_dirs_add(Eina_List *dirs)
{
EDBus_Message *msg;
EDBus_Message_Iter *iter, *array_of_string;
Eina_List *l;
const char *dir;
if (!efreet_cache_update) return;
msg = edbus_proxy_method_call_new(proxy, "AddIconDirs");
iter = edbus_message_iter_get(msg);
array_of_string = edbus_message_iter_container_new(iter, 'a',"s");
EINA_LIST_FOREACH(dirs, l, dir)
edbus_message_iter_basic_append(array_of_string, 's', dir);
edbus_message_iter_container_close(iter, array_of_string);
edbus_proxy_send(proxy, msg, NULL, NULL, -1);
edbus_message_unref(msg);
} }
void void
@ -995,13 +948,10 @@ efreet_cache_desktop_close(void)
} }
void void
efreet_cache_icon_update(void) efreet_cache_desktop_build(void)
{ {
if (!efreet_cache_update) return; if (!efreet_cache_update) return;
edbus_proxy_call(proxy, "BuildDesktopCache", NULL, NULL, -1, "");
if (icon_cache_timer)
ecore_timer_del(icon_cache_timer);
icon_cache_timer = ecore_timer_add(0.2, icon_cache_update_cache_cb, NULL);
} }
static Eina_Bool static Eina_Bool
@ -1095,285 +1045,93 @@ efreet_cache_util_names(const char *key)
return util_cache_names; return util_cache_names;
} }
static Eina_Bool static void
cache_exe_cb(void *data __UNUSED__, int type __UNUSED__, void *event) on_send_ping(void *data __UNUSED__, const EDBus_Message *msg, EDBus_Pending *pending __UNUSED__)
{ {
Ecore_Exe_Event_Del *ev; const char *errname, *errmsg;
ev = event; if (edbus_message_error_get(msg, &errname, &errmsg))
if (ev->exe == desktop_cache_exe)
{ {
if (desktop_cache_exe_lock > 0) ERR("%s %s", errname, errmsg);
{ return;
close(desktop_cache_exe_lock);
desktop_cache_exe_lock = -1;
}
desktop_cache_exe = NULL;
} }
else if (ev->exe == icon_cache_exe)
{
if (icon_cache_exe_lock > 0)
{
close(icon_cache_exe_lock);
icon_cache_exe_lock = -1;
}
icon_cache_exe = NULL;
}
return ECORE_CALLBACK_RENEW;
}
static Eina_Bool
cache_check_change(const char *path)
{
const char *data;
Eina_Bool changed = EINA_TRUE;
Eina_File *f;
f = eina_file_open(path, EINA_FALSE);
if (!f) return EINA_TRUE;
if (eina_file_size_get(f) < 1) return EINA_TRUE;
data = eina_file_map_all(f, EINA_FILE_SEQUENTIAL);
if (*data == 'n') changed = EINA_FALSE;
eina_file_close(f);
return changed;
} }
static void static void
cache_update_cb(void *data __UNUSED__, Ecore_File_Monitor *em __UNUSED__, desktop_cache_update(void *context __UNUSED__, const EDBus_Message *msg)
Ecore_File_Event event, const char *path)
{ {
const char *file; Eina_Bool update;
Efreet_Event_Cache_Update *ev = NULL;
Efreet_Old_Cache *d = NULL;
Eina_List *l = NULL;
if (event != ECORE_FILE_EVENT_CLOSED) if (edbus_message_arguments_get(msg, "b", &update))
return;
file = ecore_file_file_get(path);
if (!file) return;
if (!strcmp(file, "desktop_data.update"))
{ {
if (cache_check_change(path)) if (update)
{ {
ev = NEW(Efreet_Event_Cache_Update, 1); Efreet_Event_Cache_Update *ev = NULL;
if (!ev) goto error;
efreet_cache_desktop_close(); efreet_cache_desktop_close();
ecore_event_add(EFREET_EVENT_DESKTOP_CACHE_UPDATE, ev, desktop_cache_update_free, d);
}
ecore_event_add(EFREET_EVENT_DESKTOP_CACHE_BUILD, NULL, NULL, NULL);
/* TODO: Check if desktop_dirs_add exists, and rebuild cache if */
}
else if (!strcmp(file, "icon_data.update"))
{
if (cache_check_change(path))
{
ev = NEW(Efreet_Event_Cache_Update, 1); ev = NEW(Efreet_Event_Cache_Update, 1);
if (!ev) goto error; if (ev)
ecore_event_add(EFREET_EVENT_DESKTOP_CACHE_UPDATE, ev, NULL, NULL);
IF_RELEASE(theme_name);
/* Save all old caches */
d = NEW(Efreet_Old_Cache, 1);
if (!d) goto error;
d->hash = themes;
d->ef = icon_theme_cache;
l = eina_list_append(l, d);
d = NEW(Efreet_Old_Cache, 1);
if (!d) goto error;
d->hash = icons;
d->ef = icon_cache;
l = eina_list_append(l, d);
d = NEW(Efreet_Old_Cache, 1);
if (!d) goto error;
d->hash = fallbacks;
d->ef = fallback_cache;
l = eina_list_append(l, d);
/* Create new empty caches */
themes = eina_hash_string_superfast_new(EINA_FREE_CB(efreet_cache_icon_theme_free));
icons = eina_hash_string_superfast_new(EINA_FREE_CB(efreet_cache_icon_free));
fallbacks = eina_hash_string_superfast_new(EINA_FREE_CB(efreet_cache_icon_fallback_free));
icon_theme_cache = NULL;
icon_cache = NULL;
fallback_cache = NULL;
/* Send event */
ecore_event_add(EFREET_EVENT_ICON_CACHE_UPDATE, ev, icon_cache_update_free, l);
} }
/* TODO: Need to send this event always */
ecore_event_add(EFREET_EVENT_DESKTOP_CACHE_BUILD, NULL, NULL, NULL);
}
}
static void
icon_cache_update(void *context __UNUSED__, const EDBus_Message *msg)
{
Efreet_Event_Cache_Update *ev = NULL;
Efreet_Old_Cache *d = NULL;
Eina_List *l = NULL;
Eina_Bool update;
if (edbus_message_arguments_get(msg, "b", &update) && update)
{
ev = NEW(Efreet_Event_Cache_Update, 1);
if (!ev) goto error;
IF_RELEASE(theme_name);
/* Save all old caches */
d = NEW(Efreet_Old_Cache, 1);
if (!d) goto error;
d->hash = themes;
d->ef = icon_theme_cache;
l = eina_list_append(l, d);
d = NEW(Efreet_Old_Cache, 1);
if (!d) goto error;
d->hash = icons;
d->ef = icon_cache;
l = eina_list_append(l, d);
d = NEW(Efreet_Old_Cache, 1);
if (!d) goto error;
d->hash = fallbacks;
d->ef = fallback_cache;
l = eina_list_append(l, d);
/* Create new empty caches */
themes = eina_hash_string_superfast_new(EINA_FREE_CB(efreet_cache_icon_theme_free));
icons = eina_hash_string_superfast_new(EINA_FREE_CB(efreet_cache_icon_free));
fallbacks = eina_hash_string_superfast_new(EINA_FREE_CB(efreet_cache_icon_fallback_free));
icon_theme_cache = NULL;
icon_cache = NULL;
fallback_cache = NULL;
/* Send event */
ecore_event_add(EFREET_EVENT_ICON_CACHE_UPDATE, ev, icon_cache_update_free, l);
} }
return; return;
error: error:
IF_FREE(ev); IF_FREE(ev);
IF_FREE(d);
EINA_LIST_FREE(l, d) EINA_LIST_FREE(l, d)
free(d); free(d);
} }
static Eina_Bool
desktop_cache_update_cache_cb(void *data __UNUSED__)
{
char file[PATH_MAX];
struct flock fl;
int prio;
desktop_cache_timer = NULL;
/* TODO: Retry update cache later */
if (desktop_cache_exe_lock > 0) return ECORE_CALLBACK_CANCEL;
snprintf(file, sizeof(file), "%s/efreet/desktop_exec.lock", efreet_cache_home_get());
desktop_cache_exe_lock = open(file, O_CREAT | O_RDWR, S_IRUSR | S_IWUSR);
if (desktop_cache_exe_lock < 0) goto error;
efreet_fsetowner(desktop_cache_exe_lock);
memset(&fl, 0, sizeof(struct flock));
fl.l_type = F_WRLCK;
fl.l_whence = SEEK_SET;
if (fcntl(desktop_cache_exe_lock, F_SETLK, &fl) < 0) goto error;
prio = ecore_exe_run_priority_get();
ecore_exe_run_priority_set(19);
eina_strlcpy(file, PACKAGE_LIB_DIR "/efreet/efreet_desktop_cache_create", sizeof(file));
if (desktop_dirs_add)
{
const char *str;
eina_strlcat(file, " -d", sizeof(file));
EINA_LIST_FREE(desktop_dirs_add, str)
{
eina_strlcat(file, " ", sizeof(file));
eina_strlcat(file, str, sizeof(file));
eina_stringshare_del(str);
}
}
INF("Run desktop cache creation: %s", file);
desktop_cache_exe = ecore_exe_run(file, NULL);
ecore_exe_run_priority_set(prio);
if (!desktop_cache_exe) goto error;
return ECORE_CALLBACK_CANCEL;
error:
if (desktop_cache_exe_lock > 0)
{
close(desktop_cache_exe_lock);
desktop_cache_exe_lock = -1;
}
return ECORE_CALLBACK_CANCEL;
}
static Eina_Bool
icon_cache_update_cache_cb(void *data __UNUSED__)
{
char file[PATH_MAX];
struct flock fl;
int prio;
Eina_List **l, *l2;
icon_cache_timer = NULL;
/* TODO: Retry update cache later */
if (icon_cache_exe_lock > 0) return ECORE_CALLBACK_CANCEL;
snprintf(file, sizeof(file), "%s/efreet/icon_exec.lock", efreet_cache_home_get());
icon_cache_exe_lock = open(file, O_CREAT | O_RDWR, S_IRUSR | S_IWUSR);
if (icon_cache_exe_lock < 0) goto error;
efreet_fsetowner(icon_cache_exe_lock);
memset(&fl, 0, sizeof(struct flock));
fl.l_type = F_WRLCK;
fl.l_whence = SEEK_SET;
if (fcntl(icon_cache_exe_lock, F_SETLK, &fl) < 0) goto error;
prio = ecore_exe_run_priority_get();
ecore_exe_run_priority_set(19);
eina_strlcpy(file, PACKAGE_LIB_DIR "/efreet/efreet_icon_cache_create", sizeof(file));
l = efreet_icon_extra_list_get();
if (l && eina_list_count(*l) > 0)
{
Eina_List *ll;
char *p;
eina_strlcat(file, " -d", sizeof(file));
EINA_LIST_FOREACH(*l, ll, p)
{
eina_strlcat(file, " ", sizeof(file));
eina_strlcat(file, p, sizeof(file));
}
}
l2 = efreet_icon_extensions_list_get();
if (eina_list_count(l2) > 0)
{
Eina_List *ll;
char *p;
eina_strlcat(file, " -e", sizeof(file));
EINA_LIST_FOREACH(l2, ll, p)
{
eina_strlcat(file, " ", sizeof(file));
eina_strlcat(file, p, sizeof(file));
}
}
icon_cache_exe = ecore_exe_run(file, NULL);
ecore_exe_run_priority_set(prio);
if (!icon_cache_exe) goto error;
return ECORE_CALLBACK_CANCEL;
error:
if (icon_cache_exe_lock > 0)
{
close(icon_cache_exe_lock);
icon_cache_exe_lock = -1;
}
return ECORE_CALLBACK_CANCEL;
}
static void
desktop_cache_update_free(void *data, void *ev)
{
Efreet_Old_Cache *d;
int dangling = 0;
d = data;
if (d && (eina_list_data_find(old_desktop_caches, d) == d))
{
/*
* All users should now had the chance to update their pointers.
* Check whether we still have some dangling and print a warning.
* Programs might close their pointers later.
*/
if (d->hash)
{
Eina_Iterator *it;
Eina_Hash_Tuple *tuple;
it = eina_hash_iterator_tuple_new(d->hash);
EINA_ITERATOR_FOREACH(it, tuple)
{
if (tuple->data == NON_EXISTING) continue;
WRN("%d:%s still in cache after update event!",
((Efreet_Desktop *)tuple->data)->ref, (char *)tuple->key);
dangling++;
}
eina_iterator_free(it);
}
if (dangling != 0)
{
WRN("There are still %i desktop files with old\n"
"dangling references to desktop files. This application\n"
"has not handled the EFREET_EVENT_DESKTOP_CACHE_UPDATE\n"
"fully and released its references. Please fix the application\n"
"so it does this.",
dangling);
}
}
free(ev);
}
static void static void
icon_cache_update_free(void *data, void *ev) icon_cache_update_free(void *data, void *ev)
{ {

3
legacy/efreet/src/lib/efreet_cache_private.h
View File

@ -11,9 +11,6 @@
#define EFREET_CACHE_VERSION "__efreet//version" #define EFREET_CACHE_VERSION "__efreet//version"
#define EFREET_CACHE_ICON_FALLBACK "__efreet_fallback" #define EFREET_CACHE_ICON_FALLBACK "__efreet_fallback"
#define EFREET_CACHE_ICON_EXTENSIONS "__efreet//icon_extensions"
#define EFREET_CACHE_ICON_EXTRA_DIRS "__efreet//icon_extra_dirs"
#define EFREET_CACHE_DESKTOP_DIRS "__efreet//desktop_dirs"
EAPI const char *efreet_desktop_util_cache_file(void); EAPI const char *efreet_desktop_util_cache_file(void);
EAPI const char *efreet_desktop_cache_file(void); EAPI const char *efreet_desktop_cache_file(void);

109
legacy/efreet/src/lib/efreet_desktop.c
View File

@ -45,8 +45,6 @@ static const char *desktop_environment = NULL;
*/ */
static Eina_List *efreet_desktop_types = NULL; static Eina_List *efreet_desktop_types = NULL;
static Eina_Hash *change_monitors = NULL;
EAPI int EFREET_DESKTOP_TYPE_APPLICATION = 0; EAPI int EFREET_DESKTOP_TYPE_APPLICATION = 0;
EAPI int EFREET_DESKTOP_TYPE_LINK = 0; EAPI int EFREET_DESKTOP_TYPE_LINK = 0;
EAPI int EFREET_DESKTOP_TYPE_DIRECTORY = 0; EAPI int EFREET_DESKTOP_TYPE_DIRECTORY = 0;
@ -90,12 +88,6 @@ static Eina_Bool efreet_desktop_x_fields_save(const Eina_Hash *hash,
void *fdata); void *fdata);
static int efreet_desktop_environment_check(Efreet_Desktop *desktop); static int efreet_desktop_environment_check(Efreet_Desktop *desktop);
static void efreet_desktop_changes_listen(void);
static void efreet_desktop_changes_listen_recursive(const char *path);
static void efreet_desktop_changes_monitor_add(const char *path);
static void efreet_desktop_changes_cb(void *data, Ecore_File_Monitor *em,
Ecore_File_Event event, const char *path);
/** /**
* @internal * @internal
* @return Returns > 0 on success or 0 on failure * @return Returns > 0 on success or 0 on failure
@ -132,7 +124,6 @@ efreet_desktop_init(void)
EFREET_DESKTOP_TYPE_DIRECTORY = efreet_desktop_type_add("Directory", NULL, EFREET_DESKTOP_TYPE_DIRECTORY = efreet_desktop_type_add("Directory", NULL,
NULL, NULL); NULL, NULL);
efreet_desktop_changes_listen();
return 1; return 1;
} }
@ -149,7 +140,6 @@ efreet_desktop_shutdown(void)
IF_RELEASE(desktop_environment); IF_RELEASE(desktop_environment);
EINA_LIST_FREE(efreet_desktop_types, info) EINA_LIST_FREE(efreet_desktop_types, info)
efreet_desktop_type_info_free(info); efreet_desktop_type_info_free(info);
IF_FREE_HASH(change_monitors);
#ifdef HAVE_EVIL #ifdef HAVE_EVIL
evil_sockets_shutdown(); evil_sockets_shutdown();
#endif #endif
@ -991,102 +981,3 @@ efreet_desktop_environment_check(Efreet_Desktop *desktop)
return 1; return 1;
} }
static void
efreet_desktop_changes_listen(void)
{
Efreet_Cache_Array_String *arr;
Eina_List *dirs;
const char *path;
if (!efreet_cache_update) return;
change_monitors = eina_hash_string_superfast_new(EINA_FREE_CB(ecore_file_monitor_del));
if (!change_monitors) return;
dirs = efreet_default_dirs_get(efreet_data_home_get(),
efreet_data_dirs_get(), "applications");
EINA_LIST_FREE(dirs, path)
{
if (ecore_file_is_dir(path))
efreet_desktop_changes_listen_recursive(path);
eina_stringshare_del(path);
}
arr = efreet_cache_desktop_dirs();
if (arr)
{
unsigned int i;
for (i = 0; i < arr->array_count; i++)
efreet_desktop_changes_monitor_add(arr->array[i]);
efreet_cache_array_string_free(arr);
}
}
static void
efreet_desktop_changes_listen_recursive(const char *path)
{
Eina_Iterator *it;
Eina_File_Direct_Info *info;
efreet_desktop_changes_monitor_add(path);
it = eina_file_stat_ls(path);
if (!it) return;
EINA_ITERATOR_FOREACH(it, info)
{
if (info->type != EINA_FILE_DIR) continue;
efreet_desktop_changes_listen_recursive(info->path);
}
eina_iterator_free(it);
}
static void
efreet_desktop_changes_monitor_add(const char *path)
{
if (eina_hash_find(change_monitors, path)) return;
eina_hash_add(change_monitors, path,
ecore_file_monitor_add(path,
efreet_desktop_changes_cb,
NULL));
}
static void
efreet_desktop_changes_cb(void *data __UNUSED__, Ecore_File_Monitor *em __UNUSED__,
Ecore_File_Event event, const char *path)
{
const char *ext;
/* TODO: If we get a stale symlink, we need to rerun cache creation */
/* TODO: Check for desktop*.cache, as this will be created when app is installed */
/* TODO: Do efreet_cache_icon_update() when app is installed, as it has the same
* symlink problem */
switch (event)
{
case ECORE_FILE_EVENT_NONE:
/* noop */
break;
case ECORE_FILE_EVENT_CREATED_FILE:
case ECORE_FILE_EVENT_DELETED_FILE:
case ECORE_FILE_EVENT_MODIFIED:
case ECORE_FILE_EVENT_CLOSED:
ext = strrchr(path, '.');
if (ext && (!strcmp(ext, ".desktop") || !strcmp(ext, ".directory")))
efreet_cache_desktop_update();
break;
case ECORE_FILE_EVENT_DELETED_SELF:
case ECORE_FILE_EVENT_DELETED_DIRECTORY:
eina_hash_del_by_key(change_monitors, path);
efreet_cache_desktop_update();
break;
case ECORE_FILE_EVENT_CREATED_DIRECTORY:
efreet_desktop_changes_monitor_add(path);
efreet_cache_desktop_update();
break;
}
}

102
legacy/efreet/src/lib/efreet_icon.c
View File

@ -35,8 +35,6 @@ static const char *efreet_icon_user_dir = NULL;
static Eina_List *efreet_icon_extensions = NULL; static Eina_List *efreet_icon_extensions = NULL;
static Eina_List *efreet_extra_icon_dirs = NULL; static Eina_List *efreet_extra_icon_dirs = NULL;
static Eina_Hash *change_monitors = NULL;
typedef struct Efreet_Icon_Cache Efreet_Icon_Cache; typedef struct Efreet_Icon_Cache Efreet_Icon_Cache;
struct Efreet_Icon_Cache struct Efreet_Icon_Cache
{ {
@ -59,12 +57,7 @@ static const char *efreet_icon_lookup_path_path(Efreet_Cache_Icon_Element *elem,
static const char *efreet_icon_fallback_lookup_path(Efreet_Cache_Fallback_Icon *icon); static const char *efreet_icon_fallback_lookup_path(Efreet_Cache_Fallback_Icon *icon);
static const char *efreet_icon_fallback_lookup_path_path(Efreet_Cache_Fallback_Icon *icon, static const char *efreet_icon_fallback_lookup_path_path(Efreet_Cache_Fallback_Icon *icon,
const char *path); const char *path);
static void efreet_cache_icon_dirs_add_cb(void *data);
static void efreet_icon_changes_listen(void);
static void efreet_icon_changes_monitor_add(const char *path);
static void efreet_icon_changes_cb(void *data, Ecore_File_Monitor *em,
Ecore_File_Event event, const char *path);
/** /**
* @internal * @internal
@ -86,9 +79,8 @@ efreet_icon_init(void)
for (i = 0; default_exts[i]; i++) for (i = 0; default_exts[i]; i++)
efreet_icon_extensions = eina_list_append(efreet_icon_extensions, eina_stringshare_add(default_exts[i])); efreet_icon_extensions = eina_list_append(efreet_icon_extensions, eina_stringshare_add(default_exts[i]));
efreet_icon_changes_listen();
efreet_extra_icon_dirs = NULL; efreet_extra_icon_dirs = NULL;
efreet_cache_icon_exts_add(efreet_icon_extensions);
return 1; return 1;
} }
@ -109,7 +101,6 @@ efreet_icon_shutdown(void)
eina_log_domain_unregister(_efreet_icon_log_dom); eina_log_domain_unregister(_efreet_icon_log_dom);
_efreet_icon_log_dom = -1; _efreet_icon_log_dom = -1;
IF_FREE_HASH(change_monitors);
} }
EAPI const char * EAPI const char *
@ -166,11 +157,13 @@ efreet_icon_extension_add(const char *ext)
} }
else else
efreet_icon_extensions = eina_list_prepend(efreet_icon_extensions, ext); efreet_icon_extensions = eina_list_prepend(efreet_icon_extensions, ext);
efreet_cache_icon_exts_add(efreet_icon_extensions);
} }
EAPI Eina_List ** EAPI Eina_List **
efreet_icon_extra_list_get(void) efreet_icon_extra_list_get(void)
{ {
ecore_job_add(efreet_cache_icon_dirs_add_cb, NULL);
return &efreet_extra_icon_dirs; return &efreet_extra_icon_dirs;
} }
@ -813,90 +806,7 @@ efreet_icon_fallback_lookup_path_path(Efreet_Cache_Fallback_Icon *icon, const ch
} }
static void static void
efreet_icon_changes_listen(void) efreet_cache_icon_dirs_add_cb(void *data __UNUSED__)
{ {
Eina_List *l; efreet_cache_icon_dirs_add(efreet_extra_icon_dirs);
Eina_List *xdg_dirs;
char buf[PATH_MAX];
const char *dir;
if (!efreet_cache_update) return;
change_monitors = eina_hash_string_superfast_new(EINA_FREE_CB(ecore_file_monitor_del));
if (!change_monitors) return;
efreet_icon_changes_monitor_add(efreet_icon_deprecated_user_dir_get());
efreet_icon_changes_monitor_add(efreet_icon_user_dir_get());
EINA_LIST_FOREACH(efreet_extra_icon_dirs, l, dir)
efreet_icon_changes_monitor_add(dir);
xdg_dirs = efreet_data_dirs_get();
EINA_LIST_FOREACH(xdg_dirs, l, dir)
{
snprintf(buf, sizeof(buf), "%s/icons", dir);
efreet_icon_changes_monitor_add(buf);
}
#ifndef STRICT_SPEC
EINA_LIST_FOREACH(xdg_dirs, l, dir)
{
snprintf(buf, sizeof(buf), "%s/pixmaps", dir);
efreet_icon_changes_monitor_add(buf);
}
#endif
efreet_icon_changes_monitor_add("/usr/share/pixmaps");
}
static void
efreet_icon_changes_monitor_add(const char *path)
{
Eina_Iterator *it;
Eina_File_Direct_Info *info;
if (!ecore_file_is_dir(path)) return;
if (eina_hash_find(change_monitors, path)) return;
eina_hash_add(change_monitors, path,
ecore_file_monitor_add(path,
efreet_icon_changes_cb,
NULL));
it = eina_file_stat_ls(path);
if (!it) return;
EINA_ITERATOR_FOREACH(it, info)
{
if (info->type != EINA_FILE_DIR) continue;
eina_hash_add(change_monitors, info->path,
ecore_file_monitor_add(info->path,
efreet_icon_changes_cb,
NULL));
}
eina_iterator_free(it);
}
static void
efreet_icon_changes_cb(void *data __UNUSED__, Ecore_File_Monitor *em __UNUSED__,
Ecore_File_Event event, const char *path)
{
/* TODO: If we get a stale symlink, we need to rerun cache creation */
switch (event)
{
case ECORE_FILE_EVENT_NONE:
/* noop */
break;
case ECORE_FILE_EVENT_CREATED_FILE:
case ECORE_FILE_EVENT_DELETED_FILE:
case ECORE_FILE_EVENT_MODIFIED:
case ECORE_FILE_EVENT_CLOSED:
case ECORE_FILE_EVENT_DELETED_DIRECTORY:
case ECORE_FILE_EVENT_CREATED_DIRECTORY:
efreet_cache_icon_update();
break;
case ECORE_FILE_EVENT_DELETED_SELF:
eina_hash_del_by_key(change_monitors, path);
efreet_cache_icon_update();
break;
}
} }

5
legacy/efreet/src/lib/efreet_private.h
View File

@ -195,13 +195,14 @@ const char *efreet_lang_modifier_get(void);
size_t efreet_array_cat(char *buffer, size_t size, const char *strs[]); size_t efreet_array_cat(char *buffer, size_t size, const char *strs[]);
void efreet_cache_desktop_update(void);
void efreet_cache_desktop_close(void); void efreet_cache_desktop_close(void);
void efreet_cache_icon_update(void); void efreet_cache_desktop_build(void);
Efreet_Desktop *efreet_cache_desktop_find(const char *file); Efreet_Desktop *efreet_cache_desktop_find(const char *file);
void efreet_cache_desktop_free(Efreet_Desktop *desktop); void efreet_cache_desktop_free(Efreet_Desktop *desktop);
void efreet_cache_desktop_add(Efreet_Desktop *desktop); void efreet_cache_desktop_add(Efreet_Desktop *desktop);
void efreet_cache_icon_exts_add(Eina_List *exts);
void efreet_cache_icon_dirs_add(Eina_List *dirs);
Efreet_Cache_Array_String *efreet_cache_desktop_dirs(void); Efreet_Cache_Array_String *efreet_cache_desktop_dirs(void);
Efreet_Cache_Icon *efreet_cache_icon_find(Efreet_Icon_Theme *theme, const char *icon); Efreet_Cache_Icon *efreet_cache_icon_find(Efreet_Icon_Theme *theme, const char *icon);