static int
_evas_gl_common_shader_binary_init(Evas_GL_Shared *shared)
{
Eet_File *ef = NULL;
char bin_dir_path[PATH_MAX];
char bin_file_path[PATH_MAX];
if (!shared || !shared->info.bin_program)
return 1;
if (shared->shaders_cache)
return 1;
if (!evas_gl_common_file_cache_dir_check(bin_dir_path, sizeof(bin_dir_path)))
return 0;
if (!evas_gl_common_file_cache_file_check(bin_dir_path, SHADER_EET_CACHENAME,
bin_file_path, sizeof(bin_dir_path)))
return 0;
if (!eet_init()) return 0;
ef = eet_open(bin_file_path, EET_FILE_MODE_READ);
if (!_evas_gl_common_shader_binary_checksum_check(shared, ef))
goto error;
shared->shaders_cache = ef;
return 1;
error:
if (ef) eet_close(ef);
eet_shutdown();
return 0;
}
void _show_hs(void *data, Evas_Object *obj, void *event_info)
{
elm_genlist_clear(highscores_genlist);
if(!_itc)
{
_itc = elm_genlist_item_class_new();
_itc->item_style = "default";
_itc->func.text_get = _item_label_get;
_itc->func.content_get = NULL;
_itc->func.state_get = NULL;
_itc->func.del = NULL;
}
Eet_File *eef = eet_open(RESULTS_FILE, EET_FILE_MODE_READ);
int game_type = (int)(uintptr_t)(data);
int j = 0;
for(; j < 10; ++j)
{
char buf[50];
int *res;
sprintf(buf, "%d%d", game_type, j);
res = eet_read(eef, buf, NULL);
if(res && res[0] != -1)
{
elm_genlist_item_append(highscores_genlist, _itc, res, NULL, ELM_GENLIST_ITEM_NONE, NULL, NULL);
}
}
//free(res); //MEMORY LEAK?
eet_close(eef);
}
void
on_btn_save_clicked(Etk_Object *object, void *data)
{
Cover_Entry *ce;
Eet_File *ef;
Eina_List *list;
char *cover_file;
list = cover_changed;
asprintf(&cover_file, "%s/.e/apps/emphasis/cover.eet", getenv("HOME"));
ef = eet_open(cover_file, EET_FILE_MODE_READ_WRITE);
if (!ef)
{
fprintf(stderr, "can't open %s\n", cover_file);
free(cover_file);
return;
}
while (cover_changed)
{
ce = eina_list_data_get(cover_changed);
eet_write(ef, ce->key, ce->path, strlen(ce->path)+1, 0);
eet_clearcache();
free(ce->key);
free(ce->path);
free(ce);
cover_changed = eina_list_next(cover_changed);
}
eina_list_free(list);
eet_close(ef);
free(cover_file);
}
static My_Conf_Type *
_my_conf_load(const char *filename)
{
My_Conf_Type *my_conf;
Eet_File *ef = eet_open(filename, EET_FILE_MODE_READ);
if (!ef)
{
fprintf(stderr, "ERROR: could not open '%s' for read\n", filename);
return NULL;
}
my_conf = eet_data_read(ef, _my_conf_descriptor, MY_CONF_FILE_ENTRY);
if (!my_conf)
goto end;
if (my_conf->version < 0x112233)
{
fprintf(stderr,
"WARNING: version %#x was too old, upgrading it to %#x\n",
my_conf->version, 0x112233);
my_conf->version = 0x112233;
my_conf->enabled = EINA_TRUE;
}
end:
eet_close(ef);
return my_conf;
} /* _my_conf_load */
static int
_ephoto_config_load(Ephoto *ephoto)
{
Eet_File *ef;
char buf[4096], buf2[4096];
snprintf(buf2, sizeof(buf2), "%s/.config/ephoto", getenv("HOME"));
ecore_file_mkpath(buf2);
snprintf(buf, sizeof(buf), "%s/ephoto.cfg", buf2);
ef = eet_open(buf, EET_FILE_MODE_READ);
if (!ef)
{
ephoto_config_free(ephoto);
ephoto->config = calloc(1, sizeof(Ephoto_Config));
return 0;
}
ephoto->config = eet_data_read(ef, edd, "config");
eet_close(ef);
if (!ephoto->config || ephoto->config->config_version > CONFIG_VERSION)
{
ephoto_config_free(ephoto);
ephoto->config = calloc(1, sizeof(Ephoto_Config));
return 0;
}
if (ephoto->config->config_version < CONFIG_VERSION)
return -1;
return 1;
}
char *
emphasis_cover_db_search(const char *artist, const char *album)
{
char *config_path;
char *cover_path = NULL;
char *key;
int size;
void *cover = NULL;
Eet_File *ef;
asprintf(&config_path, "%s/.e/apps/emphasis/cover.eet", getenv("HOME"));
ef = eet_open(config_path, EET_FILE_MODE_READ);
asprintf(&key, "/%s/%s", artist, album);
cover_path = eet_read(ef, key, &size);
eet_close(ef);
if (!cover_path)
{
cover = emphasis_cover_file_get_from_amazon(artist, album, &size);
cover_path = emphasis_cover_db_add(artist, album, cover, size);
}
if (cover_path && !strcmp(cover_path, "not found"))
{
free(cover_path);
cover_path = NULL;
}
free(config_path);
free(key);
return cover_path;
}
void Config::saveStateCache()
{
Eet_File *ef;
std::string file = Utils::getCacheFile("iostates.cache");
std::string tmp = file + "_tmp";
ConfigStateCache *cache;
cache = new ConfigStateCache;
cache->version = CONFIG_STATES_CACHE_VERSION;
cache->states = cache_states;
ef = eet_open(tmp.c_str(), EET_FILE_MODE_WRITE);
if (!ef)
{
cWarning() << "Could not open iostates.cache for write !";
delete cache;
return;
}
Eina_Bool ret = eet_data_write(ef, edd_cache, "calaos/states/cache", cache, EINA_TRUE);
eet_close(ef);
delete cache;
if (ret)
{
ecore_file_unlink(file.c_str());
ecore_file_mv(tmp.c_str(), file.c_str());
}
cInfo() << "State cache file written successfully (" << file << ")";
}
/**
* @brief Saves Etk's config to disk
* @return Returns ETK_TRUE on a successful save, ETK_FALSE otherwise.
*/
Etk_Bool etk_config_save(void)
{
Eet_File *ef;
char buf[PATH_MAX];
char *home;
Etk_Bool ret;
home = getenv("HOME");
if (!home)
return 0;
snprintf(buf, sizeof(buf), "%s/.e/etk/config.eet", home);
ef = eet_open(buf, EET_FILE_MODE_WRITE);
if (!ef)
return 0;
ret = eet_data_write(ef, _etk_config_ver_edd, "config/version",
_etk_config->version, 1);
if (!ret)
ETK_WARNING("Problem saving config!");
ret = eet_data_write(ef, _etk_config_gen_edd, "config/general",
_etk_config->general, 1);
if (!ret)
ETK_WARNING("Problem saving config/stickies!");
eet_close(ef);
return ret;
}
/* check if old and new caches contain the same number of entries,
* and are the same version */
static int
check_changed(const char *old_name, Eet_File *new_ef,
unsigned char major, unsigned char minor)
{
Eet_File *old_ef;
Efreet_Cache_Version *old_version = NULL;
old_ef = eet_open(old_name, EET_FILE_MODE_READ);
if (!old_ef) return 1;
if (eet_num_entries(old_ef) != eet_num_entries(new_ef))
goto changed;
old_version = eet_data_read(old_ef, efreet_version_edd(), EFREET_CACHE_VERSION);
if (!old_version)
goto changed;
if ((old_version->major != major) ||
(old_version->minor != minor))
goto changed;
free(old_version);
eet_close(old_ef);
return 0;
changed:
free(old_version);
eet_close(old_ef);
return 1;
}
static Eet_File *
_open_temp_eet(Eina_Tmpstr **path, const char *rel)
{
Eet_File *ef;
int tmpfd;
char buffer[PATH_MAX];
{
char *tmp;
tmp = strdup(rel);
snprintf(buffer, sizeof(buffer), "%s/efreet/%s.XXXXXX.cache",
efreet_cache_home_get(), basename(tmp));
free(tmp);
}
tmpfd = eina_file_mkstemp(buffer, path);
if (tmpfd < 0) return NULL;
close(tmpfd);
ef = eet_open(*path, EET_FILE_MODE_READ_WRITE);
if (!ef) goto on_error;
return ef;
on_error:
eina_tmpstr_del(*path);
*path = NULL;
return NULL;
}
static void
_open_era(const char *era)
{
char my_getcwd[1024];
char my_path2[1024];
char my_path[1024];
if (_export_type == EET)
{
#ifdef HAVE_EET
snprintf(my_path2, sizeof(my_path2),
"%s/tiles/eet", getcwd(my_getcwd, sizeof(my_getcwd)));
ecore_file_mkpath(my_path2);
snprintf(my_path, sizeof(my_path), "%s/%s.eet", my_path2, era);
_ef = eet_open(my_path, EET_FILE_MODE_WRITE);
#endif
}
else if (_export_type == ATLAS)
{
#ifdef HAVE_CAIRO
_cairo.img = cairo_image_surface_create(CAIRO_FORMAT_ARGB32,
0x10 * TILE_H,
14 * 9 * TILE_W + 0xc * TILE_W);
_cairo.cr = cairo_create(_cairo.img);
snprintf(my_path2, sizeof(my_path2),
"%s/tiles/atlas", getcwd(my_getcwd, sizeof(my_getcwd)));
ecore_file_mkpath(my_path2);
snprintf(my_path, sizeof(my_path), "%s/%s.png", my_path2, era);
_cairo.png = strdup(my_path);
#endif
}
}
void
config_flush(void)
{
Eet_File *cf;
char path[PATH_MAX];
if (!config)
return;
snprintf(path, sizeof(path), "%s/%s", efreet_config_home_get(), "jesus.eet");
cf = eet_open(path, EET_FILE_MODE_WRITE);
if (!cf)
{
printf("Failed to open config file");
}
if (!eet_data_write(cf, edd, CONFIG_KEY, config, 0))
{
printf("Failed to write config file");
}
eet_close(cf);
}
/*
* @brief load the list of interfaces from a file
* @param file the configuration file
* @return Returns the list of interfaces
*/
Boot_Process_List *waiting_iface_load(const char* file)
{
Eet_Data_Descriptor*edd;
Eet_File *f;
Boot_Process_List *data;
edd = waiting_iface_edd_new();
f = eet_open(file, EET_FILE_MODE_READ);
EXALT_ASSERT_ADV(f!=NULL,
data = malloc(sizeof(Boot_Process_List));
data->timeout = 30;
data->l=NULL,
"f!=NULL failed");
data = eet_data_read(f, edd, "boot process interface list");
eet_close(f);
eet_data_descriptor_free(edd);
EXALT_ASSERT_ADV(data!=NULL,
data = malloc(sizeof(Boot_Process_List));
data->timeout = 30;
data->l=NULL,
"data!=NULL failed");
return data;
}
void
_config_read()
{
Eet_File *cf;
char path[PATH_MAX];
if (config)
{
_config_free(config);
config = NULL;
}
snprintf(path, sizeof(path), "%s/%s", efreet_config_home_get(), "jesus.eet");
cf = eet_open(path, EET_FILE_MODE_READ);
if (cf)
{
config = eet_data_read(cf, edd, CONFIG_KEY);
eet_close(cf);
}
if (!config)
{
config = _config_standart_new();
config_flush();
}
}
static Eina_Bool
_ephoto_on_config_save(void *data)
{
Ephoto *ephoto = data;
Eet_File *ef;
char buf[4096], buf2[4096];
snprintf(buf, sizeof(buf), "%s/.config/ephoto/ephoto.cfg", getenv("HOME"));
snprintf(buf2, sizeof(buf2), "%s.tmp", buf);
ef = eet_open(buf2, EET_FILE_MODE_WRITE);
if (!ef) goto save_end;
eet_data_write(ef, edd, "config", ephoto->config, 1);
if (eet_close(ef)) goto save_end;
if (!ecore_file_mv(buf2, buf)) goto save_end;
INF("Config saved");
save_end:
ecore_file_unlink(buf2);
if (save_timer)
{
ecore_timer_del(save_timer);
save_timer = NULL;
}
return ECORE_CALLBACK_CANCEL;
}
/**
* @brief Save the connection associated to an essid in the configuration file
* @param file the configuration file
* @param c the connection
* @return Returns 1 if success, else 0
*/
int _exalt_eet_wireless_conn_save(const char*file, Exalt_Connection* c)
{
Eet_Data_Descriptor* edd;
Eet_File* f;
int res;
edd = exalt_conn_edd_new();
f = eet_open(file, EET_FILE_MODE_READ_WRITE);
if(!f)
f = eet_open(file, EET_FILE_MODE_WRITE);
res=eet_data_write(f, edd,exalt_conn_get_essid(c), c, 0);
EXALT_ASSERT(res!=0);
eet_close(f);
eet_data_descriptor_free(edd);
return res;
}
static void
_eio_eet_open_job(void *data, Ecore_Thread *thread)
{
Eio_Eet_Open *eet = data;
eet->result = eet_open(eet->filename, eet->mode);
if (!eet->result) eio_file_thread_error(&eet->common, thread);
}
/**
* @brief Save a Exalt_Eth_Save structure in the configuration file
* @param file the configuration file
* @param s the Exalt_Eth_Save strucuture
* @param udi the hal udi of the interface
* @return Returns 1 if success, else 0
*/
int _exalt_eet_eth_save(const char* file, Exalt_Eth_Save* s, const char* udi)
{
Eet_Data_Descriptor *edd;
Eet_File* f;
int res;
edd = _exalt_eth_save_edd_new();
f = eet_open(file, EET_FILE_MODE_READ_WRITE);
if(!f)
f = eet_open(file, EET_FILE_MODE_WRITE);
res=eet_data_write(f, edd,udi, s, 0);
EXALT_ASSERT(res!=0);
eet_close(f);
eet_data_descriptor_free(edd);
return res;
}
static Eina_Bool
config_save(Eet_Data_Descriptor *descriptor, const char *filename, const char *section, const void *data)
{
Eet_File *ef;
FILE *f;
char buffer[PATH_MAX];
int i;
/* human readable version */
snprintf(buffer, PATH_MAX, "%s.%s", filename, section);
f = fopen(buffer, "w");
if (!f) {
fprintf(stderr, "Not able to open human readable config file.\n");
goto on_error;
}
/* save the configuration */
snprintf(buffer, PATH_MAX, "%s.eet", filename);
ef = eet_open(buffer, EET_FILE_MODE_READ_WRITE);
if (!ef) {
fprintf(stderr, "Not able to open config file for read write mode.\n");
goto on_error;
}
if (!eet_data_write(ef, descriptor, section, data, 1)) {
fprintf(stderr, "Can't write data inside the config file.\n");
goto on_write_error;
}
if (!eet_data_dump(ef, section, invert_fputs, f)) {
fprintf(stderr, "Can't dump section `%s`.\n");
goto on_write_error;
}
eet_close(ef);
sleep(2);
fclose(f);
return EINA_TRUE;
on_write_error:
eet_close(ef);
snprintf(buffer, PATH_MAX, "%s.eet", filename);
unlink(buffer);
on_error:
if (f)
{
fclose(f);
snprintf(buffer, PATH_MAX, "%s.%s", filename, section);
unlink(buffer);
}
return EINA_FALSE;
}
int
ex_config_write(Extrackt *ex)
{
Eet_File *ef;
char buf[PATH_MAX];
char *home;
int ret;
Eina_List *l;
home = getenv("HOME");
if(!home)
return 0;
snprintf(buf, sizeof(buf), "%s/.e/extrackt/config.eet", home);
ef = eet_open(buf, EET_FILE_MODE_WRITE);
if(!ef)
return 0;
ret = eet_data_write(ef, _ex_config_version_edd, "config/version", ex->config.version, 1);
if(!ret)
DEBUG(_("Problem saving config!"));
ret = eet_data_write(ef, _ex_config_cd_edd, "config/cd", ex->config.cd, 1);
if(!ret)
DEBUG(_("Problem saving config!"));
ret = eet_data_write(ef, _ex_config_cddb_edd, "config/cddb", ex->config.cddb, 1);
if(!ret)
DEBUG(_("Problem saving config!"));
for(l = ex->config.rippers; l; l = l->next)
{
Ex_Config_Exe *ripper;
char *buf;
int size;
ripper = l->data;
size = strlen("config/rippers/") + strlen(ripper->name) + 1;
buf = E_NEW(size, char);
snprintf(buf, size, "config/rippers/%s", ripper->name);
ret = eet_data_write(ef, _ex_config_exe_edd, buf, ripper, 1);
if(!ret)
DEBUG(_("Problem saving config!"));
}
ret = eet_data_write(ef, _ex_config_encode_edd, "config/encode", ex->config.encode, 1);
if(!ret)
DEBUG(_("Problem saving config!"));
eet_close(ef);
return ret;
}
/*
* @brief save the list of interfaces
* @param l the list
* @param file the configuration file
*/
void waiting_iface_save(const Boot_Process_List* l, const char* file)
{
Eet_Data_Descriptor* edd;
Eet_File* f;
EXALT_ASSERT_RETURN_VOID(l!=NULL);
EXALT_ASSERT_RETURN_VOID(file!=NULL);
edd = waiting_iface_edd_new();
f = eet_open(file, EET_FILE_MODE_READ_WRITE);
if(!f)
{
f = eet_open(file, EET_FILE_MODE_WRITE);
}
eet_data_write(f, edd,"boot process interface list", l, 0);
eet_close(f);
eet_data_descriptor_free(edd);
}
int
main(int argc, char **argv)
{
Eet_File *theme_ef;
Eina_List *l = NULL;
Efreet_Icon_Theme *theme;
int i;
efreet_cache_update = 0;
if (!efreet_init()) return -1;
theme_ef = eet_open(efreet_icon_theme_cache_file(), EET_FILE_MODE_READ);
if (!theme_ef) return -1;
if (argc > 1)
{
for (i = 1; i < argc; i++)
{
theme = eet_data_read(theme_ef, efreet_icon_theme_edd(EINA_FALSE), argv[i]);
if (theme) l = eina_list_append(l, theme);
}
}
else
{
char **keys;
int num;
keys = eet_list(theme_ef, "*", &num);
if (keys)
{
for (i = 0; i < num; i++)
{
theme = eet_data_read(theme_ef, efreet_icon_theme_edd(EINA_FALSE), keys[i]);
if (theme) l = eina_list_append(l, theme);
}
free(keys);
}
}
EINA_LIST_FREE(l, theme)
{
void *data;
dump(theme);
/* free theme */
eina_list_free(theme->paths);
eina_list_free(theme->inherits);
EINA_LIST_FREE(theme->directories, data)
free(data);
free(theme);
}
static int
_evas_gl_common_shader_binary_save(Evas_GL_Shared *shared)
{
/* check eet */
Eet_File *et = NULL; //check eet file
int tmpfd;
int res = 0;
char bin_dir_path[PATH_MAX];
char bin_file_path[PATH_MAX];
char tmp_file[PATH_MAX];
unsigned int i;
if (!_evas_gl_shader_dir_check(bin_dir_path, sizeof(bin_dir_path)))
{
res = _evas_gl_shader_file_mkpath(bin_dir_path);
if (!res) return 0; /* we can't make directory */
}
_evas_gl_shader_file_check(bin_dir_path, bin_file_path,
sizeof(bin_dir_path));
/* use mkstemp for writing */
snprintf(tmp_file, sizeof(tmp_file), "%s.XXXXXX", bin_file_path);
tmpfd = mkstemp(tmp_file);
if (tmpfd < 0) goto error;
close(tmpfd);
/* use eet */
if (!eet_init()) goto error;
et = eet_open(tmp_file, EET_FILE_MODE_WRITE);
if (!et) goto error;
for (i = 0; i < sizeof (_shaders_source) / sizeof (_shaders_source[0]); ++i)
if (!_evas_gl_common_shader_program_binary_save(&(shared->shader[_shaders_source[i].id]),
_shaders_source[i].name,
et))
goto error;
if (eet_close(et) != EET_ERROR_NONE) goto error;
if (rename(tmp_file,bin_file_path) < 0) goto error;
eet_shutdown();
return 1;
error:
if (et) eet_close(et);
if (_evas_gl_shader_file_exists(tmp_file)) unlink(tmp_file);
eet_shutdown();
return 0;
}
static void _eli_highscore_write(const char * game)
{
Eli_Highscore hiscore;
Eet_File * file;
hiscore.entries = eli_highscore_get(game);
if (!hiscore.entries) return;
if (ecore_file_exists(eet_file_name)) {
file = eet_open(eet_file_name, EET_FILE_MODE_READ_WRITE);
if (!file) fprintf(stderr, "Could not open file %s!\n", eet_file_name);
}
else {
file = eet_open(eet_file_name, EET_FILE_MODE_WRITE);
if (!file) fprintf(stderr, "Could not create file %s\n!",
eet_file_name);
}
if (file) {
eet_data_write(file, edd_hiscore, game, &hiscore, 1);
eet_close(file);
}
}
int
main(void)
{
Eet_File *ef;
char *ret;
int size;
char *entries[] =
{
"Entry 1",
"Big text string here compared to others",
"Eet is cool"
};
eet_init();
// blindly open an file for output and write strings with their NUL char
ef = eet_open("test.eet", EET_FILE_MODE_WRITE);
eet_write(ef, "Entry 1", entries[0], strlen(entries[0]) + 1, 0);
eet_write(ef, "Entry 2", entries[1], strlen(entries[1]) + 1, 1);
eet_write(ef, "Entry 3", entries[2], strlen(entries[2]) + 1, 0);
eet_close(ef);
// open the file again and blindly get the entries we wrote
ef = eet_open("test.eet", EET_FILE_MODE_READ);
ret = eet_read(ef, "Entry 1", &size);
printf("%s\n", ret);
free(ret);
ret = eet_read(ef, "Entry 2", &size);
printf("%s\n", ret);
free(ret);
ret = eet_read(ef, "Entry 3", &size);
printf("%s\n", ret);
free(ret);
eet_close(ef);
eet_shutdown();
}
static void storage_rewrite_all_items(StorageData *sd)
{
CALLED();
if (sd->ef)
eet_close(sd->ef);
ecore_file_remove(STORAGE_FILEPATH);
sd->ef = eet_open(STORAGE_FILEPATH, EET_FILE_MODE_READ_WRITE);
int i;
for (i = 0; i < STORAGE_ITEM_CNT; i++)
{
if ((sd->indexTable[i] != STORAGE_INDEX_ITEM_NONE) && (sd->itemTable[i]))
item_write(sd->ef, i, sd->itemTable[i]);
}
storage_index_write(sd);
}
void
fill_tree_with_db(Etk_Tree *tree)
{
int num, i;
char **entries;
char *cover_path;
Etk_Tree_Col *col;
Etk_Tree_Row *row;
Eet_File *ef;
char *cover_db_path;
asprintf(&cover_db_path, "%s/.e/apps/emphasis/cover.eet", getenv("HOME"));
ef = eet_open(cover_db_path, EET_FILE_MODE_READ);
if (!ef)
{
fprintf(stderr, "Can't open %s\n", cover_db_path);
free(cover_db_path);
exit(-1);
}
col = etk_tree_col_new(tree, "/artist/album", 0, 0.0);
etk_tree_col_model_add(col, etk_tree_model_text_new());
etk_tree_build(tree);
etk_tree_freeze(tree);
entries = eet_list(ef, "*", &num);
for (i=0; i<num; i++)
{
cover_path = eet_read(ef, entries[i], NULL);
row = etk_tree_row_append(tree, NULL, col, entries[i], NULL);
if (strcmp("not found", cover_path))
{
etk_tree_row_data_set(row, cover_path);
}
else
{
etk_tree_row_data_set(row, NULL);
}
}
eet_close(ef);
free(cover_db_path);
etk_tree_col_sort_set(etk_tree_nth_col_get(tree, 0), tree_sort, NULL);
etk_tree_thaw(tree);
}
/**
* @brief Load the information about an interface from the configuration file
* The information are saved in a Exalt_Eth_Save structure
* @param file the configuration file
* @param udi the hal udi of the interface
* @return Returns the information
*/
Exalt_Eth_Save* _exalt_eet_eth_load(const char* file, const char* udi)
{
Exalt_Eth_Save *data = NULL;
Eet_Data_Descriptor *edd;
Eet_File *f;
edd = _exalt_eth_save_edd_new();
f = eet_open(file, EET_FILE_MODE_READ);
EXALT_ASSERT_RETURN(f!=NULL);
data = eet_data_read(f, edd, udi);
eet_close(f);
eet_data_descriptor_free(edd);
return data;
}
/**
* @brief Load the connection associated to an essid from the configuration file
* @param file the configuration file
* @param essid the essid
* @return Returns the connection if success, else NULL
*/
Exalt_Connection* _exalt_eet_wireless_conn_load(const char*file, const char* essid)
{
Exalt_Connection *data = NULL;
Eet_Data_Descriptor *edd;
Eet_File *f;
edd = exalt_conn_edd_new();
f = eet_open(file, EET_FILE_MODE_READ);
EXALT_ASSERT_RETURN(f!=NULL);
data = eet_data_read(f, edd, essid);
eet_close(f);
eet_data_descriptor_free(edd);
return data;
}
void Config::loadStateCache()
{
ConfigStateCache *cache;
std::string file = Utils::getCacheFile("iostates.cache");
Eet_File *ef = eet_open(file.c_str(), EET_FILE_MODE_READ);
if (!ef)
{
cWarning() << "Could not open iostates.cache for read !";
return;
}
cache = (ConfigStateCache *)eet_data_read(ef, edd_cache, "calaos/states/cache");
if (!cache)
{
eet_close(ef);
cWarning() << "Could not read iostates.cache, corrupted file?";
return;
}
if (cache->version < CONFIG_STATES_CACHE_VERSION)
{
cWarning() << "File version too old, upgrading to new format";
cache->version = CONFIG_STATES_CACHE_VERSION;
}
//read all states and put it in cache_states
Eina_Iterator *it = eina_hash_iterator_tuple_new(cache->states);
void *data;
while (eina_iterator_next(it, &data))
{
Eina_Hash_Tuple *t = (Eina_Hash_Tuple *)data;
ConfigStateValue *state = (ConfigStateValue *)t->data;
std::string skey = state->id;
std::string svalue = state->value;
SaveValueIO(skey, svalue, false);
}
eina_iterator_free(it);
eina_hash_free(cache->states);
free(cache);
eet_close(ef);
cInfo() << "States cache read successfully.";
}
