202 lines
5.1 KiB
C
202 lines
5.1 KiB
C
#ifndef E_CONFIG_H
|
|
#define E_CONFIG_H
|
|
|
|
#include "e.h"
|
|
|
|
typedef struct _E_Config_File E_Config_File;
|
|
typedef struct _E_Config_Element E_Config_Element;
|
|
|
|
/* something to check validity of config files where we get data from */
|
|
/* for now its just a 5 second timout so it will only invalidate */
|
|
/* if we havent looked for 5 seconds... BUT later when efsd is more solid */
|
|
/* we should use that to tell us when its invalid */
|
|
struct _E_Config_File
|
|
{
|
|
char *src;
|
|
double last_fetch;
|
|
};
|
|
|
|
struct _E_Config_Element
|
|
{
|
|
char *src;
|
|
char *key;
|
|
double last_fetch;
|
|
int type;
|
|
int def_int_val;
|
|
float def_float_val;
|
|
char *def_str_val;
|
|
void *def_data_val;
|
|
int def_data_val_size;
|
|
int cur_int_val;
|
|
float cur_float_val;
|
|
char *cur_str_val;
|
|
void *cur_data_val;
|
|
int cur_data_val_size;
|
|
};
|
|
|
|
#define E_CFG_FILE(_var, _src) \
|
|
static E_Config_File _var = {_src, 0.0}
|
|
#define E_CONFIG_CHECK_VALIDITY(_var, _src) \
|
|
{ \
|
|
double __time; \
|
|
__time = e_get_time(); \
|
|
if (_var.last_fetch < (__time - 5.0)) { \
|
|
_var.last_fetch = __time;
|
|
#define E_CONFIG_CHECK_VALIDITY_END \
|
|
} \
|
|
}
|
|
|
|
typedef enum e_config_type
|
|
{
|
|
E_CFG_INT_T,
|
|
E_CFG_FLOAT_T,
|
|
E_CFG_STR_T,
|
|
E_CFG_DATA_T,
|
|
}
|
|
E_Config_Type;
|
|
|
|
#define E_CFG_INT(_var, _src, _key, _default) \
|
|
static E_Config_Element _var = { _src, _key, 0.0, E_CFG_INT_T, \
|
|
_default, 0.0, NULL, NULL, 0, \
|
|
0, 0.0, NULL, NULL, 0, \
|
|
}
|
|
|
|
#define E_CFG_FLOAT(_var, _src, _key, _default) \
|
|
static E_Config_Element _var = { _src, _key, 0.0, E_CFG_FLOAT_T, \
|
|
0, _default, NULL, NULL, 0, \
|
|
0, 0.0, NULL, NULL, 0, \
|
|
}
|
|
|
|
#define E_CFG_STR(_var, _src, _key, _default) \
|
|
static E_Config_Element _var = { _src, _key, 0.0, E_CFG_STR_T, \
|
|
0, 0.0, _default, NULL, 0, \
|
|
0, 0.0, NULL, NULL, 0, \
|
|
}
|
|
|
|
#define E_CFG_DATA(_var, _src, _key, _default, _default_size) \
|
|
static E_Config_Element _var = { _src, _key, 0.0, E_CFG_DATAT_T, \
|
|
0, 0.0, NULL, _default, _default_size, \
|
|
0, 0.0, NULL, NULL, 0, \
|
|
}
|
|
|
|
/* yes for now it only fetches them every 5 seconds - in the end i need a */
|
|
/* validity flag for the database file to know if it changed and only then */
|
|
/* get the value again. this is waiting for efsd to become more solid */
|
|
#define E_CFG_VALIDITY_CHECK(_var) \
|
|
{ \
|
|
double __time; \
|
|
__time = e_get_time(); \
|
|
if (_var.last_fetch < (__time - 5.0)) { \
|
|
int __cfg_ok = 0; \
|
|
_var.last_fetch = __time;
|
|
|
|
#define E_CFG_END_VALIDITY_CHECK \
|
|
} \
|
|
}
|
|
|
|
#define E_CONFIG_INT_GET(_var, _val) \
|
|
{{ \
|
|
E_CFG_VALIDITY_CHECK(_var) \
|
|
E_DB_INT_GET(e_config_get(_var.src), _var.key, _var.cur_int_val, __cfg_ok); \
|
|
if (!__cfg_ok) _var.cur_int_val = _var.def_int_val; \
|
|
E_CFG_END_VALIDITY_CHECK \
|
|
} \
|
|
_val = _var.cur_int_val;}
|
|
|
|
#define E_CONFIG_FLOAT_GET(_var, _val) \
|
|
{{ \
|
|
E_CFG_VALIDITY_CHECK(_var) \
|
|
E_DB_FLOAT_GET(e_config_get(_var.src), _var.key, _var.cur_float_val, __cfg_ok); \
|
|
if (!__cfg_ok) _var.cur_float_val = _var.def_float_val; \
|
|
E_CFG_END_VALIDITY_CHECK \
|
|
} \
|
|
_val = _var.cur_float_val;}
|
|
|
|
#define E_CONFIG_STR_GET(_var, _val) \
|
|
{{ \
|
|
E_CFG_VALIDITY_CHECK(_var) \
|
|
if (_var.cur_str_val) free(_var.cur_str_val); \
|
|
_var.cur_str_val = NULL; \
|
|
E_DB_STR_GET(e_config_get(_var.src), _var.key, _var.cur_str_val, __cfg_ok); \
|
|
if (!__cfg_ok) _var.cur_str_val = _var.def_str_val \
|
|
E_CFG_END_VALIDITY_CHECK \
|
|
} \
|
|
_val = _var.cur_str_val;}
|
|
|
|
#define E_CONFIG_DATA_GET(_var, _val, _size) \
|
|
{{ \
|
|
E_CFG_VALIDITY_CHECK(_var) \
|
|
if (_var.cur_data_val) free(_var.cur_data_val); \
|
|
_var.cur_data_val = NULL; \
|
|
_var.cur_data_size = 0; \
|
|
{ E_DB_File *__db; \
|
|
__db = e_db_open_read(e_config_get(_var.src)); \
|
|
if (__db) { \
|
|
_var.cur_data_val = e_db_data_get(__db, _var.key, &(_var.cur_data_size)); \
|
|
if (_var.cur_data_val) __cfg_ok = 1; \
|
|
e_db_close(__db); \
|
|
} \
|
|
} \
|
|
if (!__cfg_ok) { \
|
|
_var.cur_data_val = e_memdup(_var.def_data_val, _var.def_data_size); \
|
|
_var.cur_data_size = _var.def_data_size; \
|
|
} \
|
|
E_CFG_END_VALIDITY_CHECK \
|
|
} \
|
|
_val = _var.cur_data_val; \
|
|
_size = _var.cur_data_size;}
|
|
|
|
|
|
char *e_config_get(char *type);
|
|
void e_config_init(void);
|
|
void e_config_set_user_dir(char *dir);
|
|
char *e_config_user_dir(void);
|
|
|
|
typedef struct _e_config_base_type E_Config_Base_Type;
|
|
typedef struct _e_config_node E_Config_Node;
|
|
typedef enum _e_config_datatype E_Config_Datatype;
|
|
|
|
enum _e_config_datatype
|
|
{
|
|
E_CFG_TYPE_INT,
|
|
E_CFG_TYPE_STR,
|
|
E_CFG_TYPE_FLOAT,
|
|
E_CFG_TYPE_LIST
|
|
};
|
|
|
|
struct _e_config_base_type
|
|
{
|
|
int size;
|
|
Evas_List nodes;
|
|
};
|
|
|
|
struct _e_config_node
|
|
{
|
|
char *prefix;
|
|
E_Config_Datatype type;
|
|
int offset;
|
|
E_Config_Base_Type *sub_type;
|
|
};
|
|
|
|
#define E_CONFIG_NODE(var, prefix, type, sub, struct_type, struct_member) \
|
|
{ \
|
|
struct_type _cfg_dummy; \
|
|
char *_cfg_p1, *_cfg_p2; \
|
|
int _cfg_offset; \
|
|
\
|
|
_cfg_p1 = (char *)(&(_cfg_dummy)); \
|
|
_cfg_p2 = (char *)(&(_cfg_dummy.struct_member)); \
|
|
_cfg_offset = (int)(_cfg_p2 - _cfg_p1); \
|
|
\
|
|
e_config_type_add_node(var, prefix, type, sub, _cfg_offset); \
|
|
var->size = sizeof(struct_type); \
|
|
}
|
|
|
|
E_Config_Base_Type *e_config_type_new(void);
|
|
void e_config_type_add_node(E_Config_Base_Type *base, char *prefix,
|
|
E_Config_Datatype type, E_Config_Base_Type *list_type,
|
|
int offset);
|
|
void *e_config_load(char *file, char *prefix, E_Config_Base_Type *type);
|
|
|
|
#endif
|