double moloch_config_double(GKeyFile *keyfile, char *key, double d, double min, double max)
{
double value = d;
if (!keyfile)
keyfile = molochKeyFile;
if (g_key_file_has_key(keyfile, config.nodeName, key, NULL)) {
value = g_key_file_get_double(keyfile, config.nodeName, key, NULL);
} else if (config.nodeClass && g_key_file_has_key(keyfile, config.nodeClass, key, NULL)) {
value = g_key_file_get_double(keyfile, config.nodeClass, key, NULL);
} else if (g_key_file_has_key(keyfile, "default", key, NULL)) {
value = g_key_file_get_double(keyfile, "default", key, NULL);
}
if (value < min)
value = min;
if (value > max)
value = max;
if (config.debug) {
LOG("%s=%lf", key, value);
}
return value;
}
static EqualizerPreset * equalizer_read_mlp_preset (const char * filename)
{
int i;
EqualizerPreset *preset;
GKeyFile *rcfile;
GError *error = NULL;
preset = g_new0(EqualizerPreset, 1);
preset->name = g_strdup("");
rcfile = g_key_file_new();
if (!g_key_file_load_from_file(rcfile, filename, G_KEY_FILE_NONE, &error))
{
g_key_file_free(rcfile);
g_free(preset->name);
g_free(preset);
return NULL;
}
preset->preamp = g_key_file_get_double(rcfile, "Equalizer preset", "Preamp", &error);
for (i = 0; i < 10; i++)
{
char tmp[7];
g_snprintf(tmp, sizeof(tmp), "Band%d", i);
preset->bands[i] = g_key_file_get_double(rcfile, "Equalizer preset", tmp, &error);
}
g_key_file_free(rcfile);
return preset;
}
Index * equalizer_read_presets (const char * basename)
{
char *filename, *name;
GKeyFile *rcfile;
int i, p = 0;
EqualizerPreset *preset;
filename = g_build_filename (get_path (AUD_PATH_USER_DIR), basename, NULL);
rcfile = g_key_file_new();
if (!g_key_file_load_from_file(rcfile, filename, G_KEY_FILE_NONE, NULL))
{
g_free(filename);
filename = g_build_filename (get_path (AUD_PATH_DATA_DIR), basename,
NULL);
if (!g_key_file_load_from_file(rcfile, filename, G_KEY_FILE_NONE, NULL))
{
g_free(filename);
return NULL;
}
}
g_free(filename);
Index * list = index_new ();
for (;;)
{
char section[32];
g_snprintf(section, sizeof(section), "Preset%d", p++);
if ((name = g_key_file_get_string(rcfile, "Presets", section, NULL)) != NULL)
{
preset = g_new0(EqualizerPreset, 1);
preset->name = name;
preset->preamp = g_key_file_get_double(rcfile, name, "Preamp", NULL);
for (i = 0; i < AUD_EQUALIZER_NBANDS; i++)
{
char band[16];
g_snprintf(band, sizeof(band), "Band%d", i);
preset->bands[i] = g_key_file_get_double(rcfile, name, band, NULL);
}
index_append (list, preset);
}
else
break;
}
g_key_file_free(rcfile);
return list;
}
/**
* facq_source_nidaq_key_constructor:
* @group_name: The group name to use in the #GKeyFile.
* @key_file: A #GKeyFile object to read parameters from.
* @err: (allow-none): A #GError, it will be set in case of error if not %NULL.
*
* It's purpose it's to create a #FacqSourceNidaq object from a #GKeyFile and a
* group name. This function is used by #FacqCatalog. See #CIKeyConstructor
* for more details.
*
* Returns: A new #FacqSourceNidaq if successful or %NULL in other case.
*/
gpointer facq_source_nidaq_key_constructor(const gchar *group_name,GKeyFile *key_file,GError **err)
{
GError *local_err = NULL;
gchar *dev = NULL;
guint nibufsize = 0;
gdouble period = 0, max = 5, min = 0;
gulong sleep_us = 0;
FacqChanlist *chanlist = NULL;
dev = g_key_file_get_string(key_file,group_name,"dev",&local_err);
if(local_err)
goto error;
nibufsize = (guint) g_key_file_get_double(key_file,group_name,"ni-bufsize",&local_err);
if(local_err)
goto error;
max = g_key_file_get_double(key_file,group_name,"max",&local_err);
if(local_err)
goto error;
min = g_key_file_get_double(key_file,group_name,"min",&local_err);
if(local_err)
goto error;
period = g_key_file_get_double(key_file,group_name,"period",&local_err);
if(local_err)
goto error;
sleep_us = (gulong) g_key_file_get_double(key_file,group_name,"sleep-us",&local_err);
if(local_err)
goto error;
chanlist = facq_chanlist_from_key_file(key_file,group_name,&local_err);
if(local_err)
goto error;
return facq_source_nidaq_new(dev,chanlist,nibufsize,period,max,min,sleep_us,err);
error:
if(dev)
g_free(dev);
if(local_err){
if(err)
g_propagate_error(err,local_err);
}
return NULL;
}
gfloat gm_pref_store_get_float(GmPrefStore * store, const gchar * key)
{
gfloat value = 0.0;
if (store == NULL)
return value;
#if HAVE_GSETTINGS
value = g_settings_get_double(store->settings, key);
#else
#ifdef HAVE_GCONF
gchar *full_key;
full_key = g_strdup_printf("/apps/%s/preferences/%s", store->context, key);
value = gconf_client_get_float(store->gconf, full_key, NULL);
g_free(full_key);
#else
if (g_key_file_has_key(store->keyfile, store->context, key, NULL))
value = g_key_file_get_double(store->keyfile, store->context, key, NULL);
#endif
#endif
return value;
}
XUL_APIEXPORT gdouble
xul_prefs_gdouble_get(xul_t * xul, const gchar * group, const gchar * key)
{
g_assert(XUL_IS_VALID(xul));
return g_key_file_get_double(xul->prefs->keyfile, group, key, NULL);
}
gdouble
libbalsa_conf_get_double_with_default_(const char *path,
gboolean * def, gboolean priv)
{
gchar *key;
const gchar *defval;
gdouble retval;
GError *error = NULL;
key = lbc_get_key(path, &defval);
retval =
g_key_file_get_double(LBC_KEY_FILE(priv), lbc_groups->data, key,
&error);
g_free(key);
if (error) {
g_error_free(error);
if (defval)
retval = g_ascii_strtod(defval, NULL);
}
if (def)
*def = error != NULL;
return retval;
}
static void
load_records (OfficeRunner *run)
{
GKeyFile *keyfile;
char *path;
guint i;
path = get_records_path ();
keyfile = g_key_file_new ();
if (g_key_file_load_from_file (keyfile, path, G_KEY_FILE_NONE, NULL) == FALSE) {
g_key_file_free (keyfile);
g_free (path);
load_default_records (run);
return;
}
g_free (path);
run->records = NULL;
for (i = GOLD; i <= BRONZE; i++) {
gdouble time;
time = g_key_file_get_double (keyfile, cups[i], "time", NULL);
run->records = g_list_prepend (run->records,
new_orecord (time ? time : cup_times[i]));
}
run->records = g_list_reverse (run->records);
g_key_file_free (keyfile);
}
double
egg_desktop_file_get_numeric (EggDesktopFile * desktop_file, const char *key,
GError ** error)
{
return g_key_file_get_double (desktop_file->key_file,
EGG_DESKTOP_FILE_GROUP, key, error);
}
static void read_double_config(gdouble *item, GKeyFile *gkey, const char *key)
{
gdouble tmp;
GError *err = NULL;
tmp = g_key_file_get_double(gkey, pref_group, key, &err);
if (err)
return; /* key not found, exit */
*item = tmp;
}
static VikLayerParamData get_default_data_answer ( const gchar *group, const gchar *name, VikLayerParamType ptype, gpointer success )
{
VikLayerParamData data = VIK_LPD_BOOLEAN ( FALSE );
GError *error = NULL;
switch ( ptype ) {
case VIK_LAYER_PARAM_DOUBLE: {
gdouble dd = g_key_file_get_double ( keyfile, group, name, &error );
if ( !error ) data.d = dd;
break;
}
case VIK_LAYER_PARAM_UINT: {
guint32 uu = g_key_file_get_integer ( keyfile, group, name, &error );
if ( !error ) data.u = uu;
break;
}
case VIK_LAYER_PARAM_INT: {
gint32 ii = g_key_file_get_integer ( keyfile, group, name, &error );
if ( !error ) data.i = ii;
break;
}
case VIK_LAYER_PARAM_BOOLEAN: {
gboolean bb = g_key_file_get_boolean ( keyfile, group, name, &error );
if ( !error ) data.b = bb;
break;
}
case VIK_LAYER_PARAM_STRING: {
gchar *str = g_key_file_get_string ( keyfile, group, name, &error );
if ( !error ) data.s = str;
break;
}
//case VIK_LAYER_PARAM_STRING_LIST: {
// gchar **str = g_key_file_get_string_list ( keyfile, group, name, &error );
// data.sl = str_to_glist (str); //TODO convert
// break;
//}
case VIK_LAYER_PARAM_COLOR: {
gchar *str = g_key_file_get_string ( keyfile, group, name, &error );
if ( !error ) {
memset(&(data.c), 0, sizeof(data.c));
gdk_color_parse ( str, &(data.c) );
}
g_free ( str );
break;
}
default: break;
}
success = GINT_TO_POINTER (TRUE);
if ( error ) {
g_warning ( error->message );
g_error_free ( error );
success = GINT_TO_POINTER (FALSE);
}
return data;
}
static gboolean settings_read_double(GKeyFile *file, const gchar *group_name, const gchar *key, gdouble *value, GError **err) {
GError *tmp_error = NULL;
gdouble tmp_value = g_key_file_get_double(file, group_name, key, &tmp_error);
if (tmp_error != NULL) {
return settings_handle_error(err, tmp_error);
}
// Overwrite the previous value
*value = tmp_value;
return TRUE;
}
double
ol_config_get_double (OlConfig *config, const char *group, const char *name)
{
ol_assert_ret (config != NULL, 0.0);
ol_assert_ret (name != NULL, 0.0);
double value = g_key_file_get_double (OL_CONFIG_GET_PRIVATE (config)->config,
group,
name,
NULL);
ol_debugf ("[%s]%s:%lf\n", group, name, value);
return value;
}
/**
* fm_folder_config_get_double
* @fc: a configuration descriptor
* @key: a key to search
* @val: (out): location to save the value
*
* Returns the value associated with @key as a double.
*
* Returns: %TRUE if key was found and value can be parsed as double.
*
* Since: 1.2.0
*/
gboolean fm_folder_config_get_double(FmFolderConfig *fc, const char *key,
gdouble *val)
{
GError *error = NULL;
gdouble ret = g_key_file_get_double(fc->kf, fc->group, key, &error);
if (error)
{
g_error_free(error);
return FALSE;
}
*val = ret;
return TRUE;
}
/**
* anjuta_session_get_float:
* @session: an #AnjutaSession object
* @section: Section.
* @key: Key name.
*
* Get a float @value of @key in given @section.
*
* Returns: Key value
*/
gfloat
anjuta_session_get_float (AnjutaSession *session, const gchar *section,
const gchar *key)
{
gfloat value;
g_return_val_if_fail (ANJUTA_IS_SESSION (session), 0);
g_return_val_if_fail (section != NULL, 0);
g_return_val_if_fail (key != NULL, 0);
value = (float)g_key_file_get_double (session->priv->key_file, section, key, NULL);
return value;
}
/**
* Gets a double value from preferences.
* On error, returns def as default value.
*
* @param key the specific settings key
* @param def the default value to return on error
* @return the preference value or def on error
*/
gdouble
prefs_get_double(const gchar *key, gdouble def)
{
gdouble ret;
GError *error = NULL;
ret = g_key_file_get_double(keyFile, "PNMixer", key, &error);
if (error) {
g_error_free(error);
return def;
}
return ret;
}
static gboolean settings_get_double ( const gchar *group, const gchar *name, gdouble *val )
{
GError *error = NULL;
gboolean success = TRUE;
gdouble dd = g_key_file_get_double ( keyfile, group, name, &error );
if ( error ) {
// Only print on debug - as often may have requests for keys not in the file
g_debug ( "%s", error->message );
g_error_free ( error );
success = FALSE;
}
*val = dd;
return success;
}
static void
check_double_value (GKeyFile *keyfile,
const gchar *group,
const gchar *key,
gdouble expected)
{
GError *error = NULL;
gdouble value;
value = g_key_file_get_double (keyfile, group, key, &error);
check_no_error (error);
cut_assert_equal_double (expected, 0.0, value,
cut_message ("Group %s key %s: "
"expected integer value %e, "
"actual value %e",
group, key, expected, value));
}
static gboolean yui_gl_hide_cursor(GtkWidget * widget, GdkEventMotion * event, gpointer user_data) {
if (PerGetId(padbits) == PERMOUSE) {
int x = event->x;
int y = event->y;
double speed = g_key_file_get_double(keyfile, "General", "MouseSpeed", NULL);
PerMouseMove(padbits, speed * (x - oldx), -speed * (y - oldy));
oldx = x;
oldy = y;
}
if (beforehiding == 0) {
gdk_window_set_cursor(widget->window, NULL);
g_timeout_add(1000, gonna_hide, widget);
}
beforehiding = 2;
return FALSE;
}
bool MetadataManager::getDouble(String uri, const char* name, double& value)
{
XOJ_CHECK_TYPE(MetadataManager);
if (uri.isEmpty())
{
return false;
}
loadConfigFile();
GError* error = NULL;
double v = g_key_file_get_double(this->config, uri.c_str(), name, &error);
if (error)
{
g_error_free(error);
return false;
}
value = v;
return true;
}
static gboolean
lr_fastestmirrorcache_lookup(LrFastestMirrorCache *cache,
gchar *url,
gint64 *ts,
double *connecttime)
{
if (!cache || !cache->keyfile || !url)
return FALSE;
GKeyFile *keyfile = cache->keyfile;
if (!g_key_file_has_group(keyfile, url))
return FALSE;
gint64 l_ts;
double l_connecttime;
GError *tmp_err = NULL;
// Get timestamp
l_ts = g_key_file_get_int64(keyfile, url, CACHE_KEY_TS, &tmp_err);
if (tmp_err) {
g_error_free(tmp_err);
return FALSE;
}
// Get connect time
l_connecttime = (double) g_key_file_get_double(keyfile,
url,
CACHE_KEY_CONNECTTIME,
&tmp_err);
if (tmp_err) {
g_error_free(tmp_err);
return FALSE;
}
*ts = l_ts;
*connecttime = l_connecttime;
return TRUE;
}
void
cid_read_key_file (CidMainContainer **pCid, const gchar *f)
{
CidMainContainer *cid = *pCid;
if (!cid_load_key_file(pCid, f))
cid_exit(CID_ERROR_READING_FILE,"Key File error");
bChangedDesktop = cid->config->bAllDesktop;
iPlayerChanged = cid->config->iPlayer;
iSymbolChanged = cid->config->iSymbolColor;
iOldWidth = cid->config->iWidth;
iOldHeight = cid->config->iHeight;
gint *pSize;
gsize iReadSize;
GError *error = NULL;
bUnvalidKey = FALSE;
// [System] configuration
cid->config->iPlayer = CID_CONFIG_GET_INTEGER ("System", "PLAYER");
cid->config->iInter = CID_CONFIG_GET_INTEGER_WITH_DEFAULT ("System", "INTER", DEFAULT_TIMERS) SECONDES;
cid->config->bMonitorPlayer = CID_CONFIG_GET_BOOLEAN_WITH_DEFAULT ("System", "MONITOR", TRUE);
cid->config->bPlayerState = CID_CONFIG_GET_BOOLEAN_WITH_DEFAULT ("System", "STATE", TRUE);
cid->config->bDisplayTitle = CID_CONFIG_GET_BOOLEAN_WITH_DEFAULT ("System", "TITLE", TRUE);
cid->config->iSymbolColor = CID_CONFIG_GET_INTEGER ("System", "SYMBOL_COLOR");
cid->config->bDisplayControl = CID_CONFIG_GET_BOOLEAN_WITH_DEFAULT ("System", "CONTROLS", TRUE);
cid->config->dPoliceSize = g_key_file_get_double (cid->pKeyFile, "System", "POLICE_SIZE", &error);
cid_free_and_debug_error(&error);
cid->config->dPoliceColor = g_key_file_get_double_list (cid->pKeyFile, "System", "POLICE_COLOR", &cid->config->gPlainTextSize, &error);
cid_free_and_debug_error(&error);
cid->config->dOutlineTextColor = g_key_file_get_double_list (cid->pKeyFile, "System", "OUTLINE_COLOR", &cid->config->gOutlineTextSize, &error);
cid_free_and_debug_error(&error);
// [Options] configuration
cid->config->bHide = CID_CONFIG_GET_BOOLEAN ("Options", "HIDE");
cid->config->cDefaultImage = CID_CONFIG_GET_FILE_PATH ("Options", "IMAGE", cid->config->bDevMode ? TESTING_DIR"/"TESTING_COVER : CID_DEFAULT_IMAGE);
cid->config->bRunAnimation = CID_CONFIG_GET_BOOLEAN_WITH_DEFAULT ("Options", "ANIMATION", TRUE);
cid->config->iAnimationType = CID_CONFIG_GET_INTEGER ("Options", "ANIMATION_TYPE");
cid->config->iAnimationSpeed = CID_CONFIG_GET_INTEGER ("Options", "ANIMATION_SPEED");
cid->config->bThreaded = CID_CONFIG_GET_BOOLEAN ("Options", "THREAD");
cid->config->bDownload = CID_CONFIG_GET_BOOLEAN ("Options", "DOWNLOAD");
cid->config->cDLPath = CID_CONFIG_GET_STRING_WITH_DEFAULT ("Options", "DL_PATH", cid->defaut->cDLPath);
cid->config->iImageSize = CID_CONFIG_GET_INTEGER ("Options", "D_SIZE");
cid->config->iTimeToWait = CID_CONFIG_GET_INTEGER_WITH_DEFAULT ("Options", "DELAY", DEFAULT_TIMERS);
cid->config->bUnstable = cid->config->bTesting && CID_CONFIG_GET_BOOLEAN_WITH_DEFAULT ("Options", "B_UNSTABLE", TRUE);
// [Behaviour] configuration
cid->config->iPosX = CID_CONFIG_GET_INTEGER ("Behaviour", "GAP_X");
cid->config->iPosY = CID_CONFIG_GET_INTEGER ("Behaviour", "GAP_Y");
pSize = g_key_file_get_integer_list (cid->pKeyFile, "Behaviour", "SIZE", &iReadSize, &error);
if (cid_free_and_debug_error(&error) || iReadSize != 2)
{
pSize = g_realloc (pSize, 2 * sizeof(int));
if (pSize != NULL)
{
pSize[0] = DEFAULT_SIZE;
pSize[1] = DEFAULT_SIZE;
}
else
{
cid_exit (CID_ERROR_READING_FILE, "cannot allocate memory");
}
}
cid->config->dRotate = g_key_file_get_double (cid->pKeyFile, "Behaviour", "ROTATION", &error);
cid_free_and_debug_error(&error);
cid->config->dColor = g_key_file_get_double_list (cid->pKeyFile, "Behaviour", "COLOR", &cid->config->gColorSize, &error);
cid_free_and_debug_error(&error);
cid->config->dFlyingColor = g_key_file_get_double_list (cid->pKeyFile, "Behaviour", "FLYING_COLOR", &cid->config->gFlyingColorSize, &error);
cid_free_and_debug_error(&error);
cid->config->bKeepCorners = CID_CONFIG_GET_BOOLEAN ("Behaviour", "KEEP_CORNERS");
cid->config->bAllDesktop = CID_CONFIG_GET_BOOLEAN_WITH_DEFAULT ("Behaviour", "ALL_DESKTOP", TRUE);
cid->config->bLockPosition = CID_CONFIG_GET_BOOLEAN_WITH_DEFAULT ("Behaviour", "LOCK", TRUE);
cid->config->bMask = CID_CONFIG_GET_BOOLEAN_WITH_DEFAULT ("Behaviour", "MASK", TRUE);
cid->config->bShowAbove = CID_CONFIG_GET_BOOLEAN_WITH_DEFAULT ("Behaviour", "SWITCH_ABOVE", TRUE);
// MPD configurations
cid->mpd_dir = CID_CONFIG_GET_DIR_PATH ("MPD", "MPD_DIR", g_strdup_printf ("%s/Music",g_getenv ("HOME")));
cid->mpd_host = CID_CONFIG_GET_STRING ("MPD", "MPD_HOST");
if (cid->mpd_host != NULL && strcmp (cid->mpd_host, "") == 0)
{
g_free (cid->mpd_host);
cid->mpd_host = g_strdup ("localhost");
}
gchar *cEncrypted = NULL;
cEncrypted = CID_CONFIG_GET_STRING ("MPD", "MPD_PASS");
//cid_decrypt_string (cEncrypted, &cid->mpd_pass);
cid->mpd_pass = g_strdup (cEncrypted);
g_free (cEncrypted);
cid->mpd_port = CID_CONFIG_GET_INTEGER_WITH_DEFAULT ("MPD", "MPD_PORT", 6600);
cid->config->iWidth = pSize[0] <= MAX_SIZE ? pSize[0] : MAX_SIZE;
cid->config->iHeight = pSize[1] <= MAX_SIZE ? pSize[1] : MAX_SIZE;
if (!bUnvalidKey)
{
cid->config->dRed = cid->config->dColor[0];
cid->config->dGreen = cid->config->dColor[1];
cid->config->dBlue = cid->config->dColor[2];
cid->config->dAlpha = cid->config->dColor[3];
cid->runtime->dFocusVariation = cid->config->dFlyingColor[3]>cid->config->dAlpha ? +1 : -1;
cid->config->iExtraSize = (cid->config->iHeight + cid->config->iWidth)/20;
cid->config->iPrevNextSize = cid->config->iExtraSize * 2;
cid->config->iPlayPauseSize = cid->config->iExtraSize * 3;
}
cid_key_file_free(pCid);
if (bUnvalidKey && !bReloaded)
{
cid_save_data (pCid);
cid_read_key_file (pCid, f);
bReloaded = TRUE;
}
}
void
_clutter_settings_read_from_key_file (ClutterSettings *settings,
GKeyFile *keyfile)
{
GObjectClass *settings_class;
GObject *settings_obj;
GParamSpec **pspecs;
guint n_pspecs, i;
if (!g_key_file_has_group (keyfile, SETTINGS_GROUP))
return;
settings_obj = G_OBJECT (settings);
settings_class = G_OBJECT_GET_CLASS (settings);
pspecs = g_object_class_list_properties (settings_class, &n_pspecs);
for (i = 0; i < n_pspecs; i++)
{
GParamSpec *pspec = pspecs[i];
const gchar *p_name = pspec->name;
GType p_type = G_TYPE_FUNDAMENTAL (pspec->value_type);
GValue value = G_VALUE_INIT;
GError *key_error = NULL;
g_value_init (&value, p_type);
switch (p_type)
{
case G_TYPE_INT:
case G_TYPE_UINT:
{
gint val;
val = g_key_file_get_integer (keyfile,
SETTINGS_GROUP, p_name,
&key_error);
if (p_type == G_TYPE_INT)
g_value_set_int (&value, val);
else
g_value_set_uint (&value, val);
}
break;
case G_TYPE_BOOLEAN:
{
gboolean val;
val = g_key_file_get_boolean (keyfile,
SETTINGS_GROUP, p_name,
&key_error);
g_value_set_boolean (&value, val);
}
break;
case G_TYPE_FLOAT:
case G_TYPE_DOUBLE:
{
gdouble val;
val = g_key_file_get_double (keyfile,
SETTINGS_GROUP, p_name,
&key_error);
if (p_type == G_TYPE_FLOAT)
g_value_set_float (&value, val);
else
g_value_set_double (&value, val);
}
break;
case G_TYPE_STRING:
{
gchar *val;
val = g_key_file_get_string (keyfile,
SETTINGS_GROUP, p_name,
&key_error);
g_value_take_string (&value, val);
}
break;
}
if (key_error != NULL &&
key_error->domain != G_KEY_FILE_ERROR &&
key_error->code != G_KEY_FILE_ERROR_KEY_NOT_FOUND)
{
g_critical ("Unable to read the value for setting '%s': %s",
p_name,
key_error->message);
}
if (key_error == NULL)
g_object_set_property (settings_obj, p_name, &value);
else
g_error_free (key_error);
g_value_unset (&value);
}
g_free (pspecs);
}
/* check parsing of integer and double values */
void
test_number (void)
{
GError *error = NULL;
const gchar *data =
"[valid]\n"
"key1=0\n"
"key2=1\n"
"key3=-1\n"
"key4=2324431\n"
"key5=-2324431\n"
"key6=000111\n"
"dkey1=000111\n"
"dkey2=145.45\n"
"dkey3=-3453.7\n"
"[invalid]\n"
"key1=0xffff\n"
"key2=0.5\n"
"key3=1e37\n"
"key4=ten\n"
"key5=\n"
"key6=1.0.0\n"
"key7=2x2\n"
"key8=abc\n";
cut_assert (g_key_file_load_from_data (keyfile, data, -1, 0, NULL));
check_integer_value (keyfile, "valid", "key1", 0);
check_integer_value (keyfile, "valid", "key2", 1);
check_integer_value (keyfile, "valid", "key3", -1);
check_integer_value (keyfile, "valid", "key4", 2324431);
check_integer_value (keyfile, "valid", "key5", -2324431);
check_integer_value (keyfile, "valid", "key6", 111);
check_double_value (keyfile, "valid", "dkey1", 111.0);
check_double_value (keyfile, "valid", "dkey2", 145.45);
check_double_value (keyfile, "valid", "dkey3", -3453.7);
g_key_file_get_integer (keyfile, "invalid", "key1", &error);
check_error (&error, G_KEY_FILE_ERROR, G_KEY_FILE_ERROR_INVALID_VALUE);
g_key_file_get_integer (keyfile, "invalid", "key2", &error);
check_error (&error, G_KEY_FILE_ERROR, G_KEY_FILE_ERROR_INVALID_VALUE);
g_key_file_get_integer (keyfile, "invalid", "key3", &error);
check_error (&error, G_KEY_FILE_ERROR, G_KEY_FILE_ERROR_INVALID_VALUE);
g_key_file_get_integer (keyfile, "invalid", "key4", &error);
check_error (&error, G_KEY_FILE_ERROR, G_KEY_FILE_ERROR_INVALID_VALUE);
g_key_file_get_double (keyfile, "invalid", "key5", &error);
check_error (&error, G_KEY_FILE_ERROR, G_KEY_FILE_ERROR_INVALID_VALUE);
g_key_file_get_double (keyfile, "invalid", "key6", &error);
check_error (&error, G_KEY_FILE_ERROR, G_KEY_FILE_ERROR_INVALID_VALUE);
g_key_file_get_double (keyfile, "invalid", "key7", &error);
check_error (&error, G_KEY_FILE_ERROR, G_KEY_FILE_ERROR_INVALID_VALUE);
g_key_file_get_double (keyfile, "invalid", "key8", &error);
check_error (&error, G_KEY_FILE_ERROR, G_KEY_FILE_ERROR_INVALID_VALUE);
}
int chassis_keyfile_to_options(GKeyFile *keyfile, const gchar *ini_group_name, GOptionEntry *config_entries) {
GError *gerr = NULL;
int ret = 0;
int i, j;
/* all the options are in the group for "mysql-proxy" */
if (!keyfile) return -1;
if (!g_key_file_has_group(keyfile, ini_group_name)) return 0;
/* set the defaults */
for (i = 0; config_entries[i].long_name; i++) {
GOptionEntry *entry = &(config_entries[i]);
gchar *arg_string;
gchar **arg_string_array;
gboolean arg_bool = 0;
gint arg_int = 0;
gdouble arg_double = 0;
gsize len = 0;
switch (entry->arg) {
case G_OPTION_ARG_FILENAME:
case G_OPTION_ARG_STRING:
/* is this option set already */
if (NULL == entry->arg_data || NULL != *(gchar **)(entry->arg_data)) break;
arg_string = g_key_file_get_string(keyfile, ini_group_name, entry->long_name, &gerr);
if (!gerr) {
/* strip trailing spaces */
*(gchar **)(entry->arg_data) = g_strchomp(arg_string);
}
break;
case G_OPTION_ARG_FILENAME_ARRAY:
case G_OPTION_ARG_STRING_ARRAY:
/* is this option set already */
if (NULL == entry->arg_data || NULL != *(gchar ***)(entry->arg_data)) break;
arg_string_array = g_key_file_get_string_list(keyfile, ini_group_name, entry->long_name, &len, &gerr);
if (!gerr) {
for (j = 0; arg_string_array[j]; j++) {
arg_string_array[j] = g_strstrip(arg_string_array[j]);
}
*(gchar ***)(entry->arg_data) = arg_string_array;
}
break;
case G_OPTION_ARG_NONE:
arg_bool = g_key_file_get_boolean(keyfile, ini_group_name, entry->long_name, &gerr);
if (!gerr) {
*(int *)(entry->arg_data) = arg_bool;
}
break;
case G_OPTION_ARG_INT:
arg_int = g_key_file_get_integer(keyfile, ini_group_name, entry->long_name, &gerr);
if (!gerr) {
*(gint *)(entry->arg_data) = arg_int;
}
break;
#if GLIB_MAJOR_VERSION >= 2 && GLIB_MINOR_VERSION >= 12
case G_OPTION_ARG_DOUBLE:
arg_double = g_key_file_get_double(keyfile, ini_group_name, entry->long_name, &gerr);
if (!gerr) {
*(gint *)(entry->arg_data) = arg_double;
}
break;
#endif
default:
g_error("%s: (keyfile) the option %d can't be handled", G_STRLOC, entry->arg);
break;
}
if (gerr) {
if (gerr->code != G_KEY_FILE_ERROR_KEY_NOT_FOUND) {
g_message("%s", gerr->message);
ret = -1;
}
g_error_free(gerr);
gerr = NULL;
}
}
return ret;
}
static void
load_placemarks (PlacemarksPlugin *plugin)
{
gchar *filename = NULL;
GKeyFile *file;
GError *error = NULL;
gchar **groups = NULL;
guint i;
gsize group_count;
PlacemarksPluginPrivate *priv;
priv = PLACEMARKS_PLUGIN (plugin)->priv;
filename = g_build_filename (g_get_user_data_dir (),
"emerillon",
"placemarks.ini",
NULL);
file = g_key_file_new ();
if (!g_key_file_load_from_file (file,
filename,
G_KEY_FILE_KEEP_COMMENTS | G_KEY_FILE_KEEP_TRANSLATIONS,
&error))
{
g_warning ("Error loading %s: %s", filename, error->message);
g_error_free (error);
//g_key_file_free (file);
return;
}
g_free (filename);
groups = g_key_file_get_groups (file, &group_count);
priv->placemark_count = group_count;
for (i = 0; i < group_count; i++)
{
gchar *name;
gfloat lat, lon;
gint zoom;
name = g_key_file_get_string (file, groups[i], "name", &error);
if (error)
{
g_warning ("Error loading name key of group %s: %s", groups[i], error->message);
g_error_free (error);
error = NULL;
name = g_strdup ("A placemark");
}
lat = g_key_file_get_double (file, groups[i], "latitude", &error);
if (error)
{
g_warning ("Error loading latitude key of group %s: %s", groups[i], error->message);
g_error_free (error);
error = NULL;
lat = 0.0;
}
lon = g_key_file_get_double (file, groups[i], "longitude", &error);
if (error)
{
g_warning ("Error loading longitude key of group %s: %s", groups[i], error->message);
g_error_free (error);
error = NULL;
lon = 0.0;
}
zoom = g_key_file_get_integer (file, groups[i], "zoom", &error);
if (error)
{
g_warning ("Error loading longitude key of group %s: %s", groups[i], error->message);
g_error_free (error);
error = NULL;
zoom = 0;
}
add_placemark (plugin, groups[i], name, lat, lon, zoom);
g_free (name);
}
g_strfreev (groups);
}
void cd_clock_load_theme (CairoDockModuleInstance *myApplet)
{
cd_message ("%s (%s)", __func__, myConfig.cThemePath);
//\_______________ On charge le theme choisi (on n'a pas besoin de connaitre les dimmensions de l'icone).
if (myConfig.cThemePath != NULL)
{
GString *sElementPath = g_string_new ("");
int i;
for (i = 0; i < CLOCK_ELEMENTS; i ++)
{
g_string_printf (sElementPath, "%s/%s", myConfig.cThemePath, s_cFileNames[i]);
myData.pSvgHandles[i] = rsvg_handle_new_from_file (sElementPath->str, NULL);
}
i = 0;
while (i < CLOCK_FRAME && myData.pSvgHandles[i] == NULL)
{
i ++;
if (i == CLOCK_HOUR_HAND_SHADOW)
i = CLOCK_FACE_SHADOW;
}
if (i != CLOCK_FRAME)
rsvg_handle_get_dimensions (myData.pSvgHandles[i], &myData.DimensionData);
if (myData.pSvgHandles[CLOCK_HOUR_HAND] != NULL)
rsvg_handle_get_dimensions (myData.pSvgHandles[CLOCK_HOUR_HAND], &myData.needleDimension);
cd_debug ("clock bg dimension : %dx%d", (int) myData.DimensionData.width, (int) myData.DimensionData.height);
cd_debug ("clock needle dimension : %dx%d", (int) myData.needleDimension.width, (int) myData.needleDimension.height);
// recuperation des parametres des aiguilles.
g_string_printf (sElementPath, "%s/%s", myConfig.cThemePath, "theme.conf");
GKeyFile *pKeyFile = cairo_dock_open_key_file (sElementPath->str);
if (pKeyFile != NULL)
{
GError *erreur = NULL;
myData.iNeedleRealHeight = g_key_file_get_integer (pKeyFile, "Needle", "height", &erreur);
if (erreur != NULL)
{
cd_warning (erreur->message);
g_error_free (erreur);
erreur = NULL;
}
myData.iNeedleOffsetX = g_key_file_get_double (pKeyFile, "Needle", "offset x", &erreur);
if (erreur != NULL)
{
cd_warning (erreur->message);
g_error_free (erreur);
erreur = NULL;
}
g_key_file_free (pKeyFile);
}
else // on prend des valeurs par defaut assez larges.
{
g_print ("clock : default needle size\n");
myData.iNeedleRealHeight = .5 * myData.needleDimension.height;
myData.iNeedleOffsetX = .5 * myData.needleDimension.width;
}
myData.iNeedleRealWidth = myData.needleDimension.width/2 + myData.iNeedleOffsetX;
myData.iNeedleOffsetY = .5 * myData.iNeedleRealHeight;
cd_debug ("clock needle : H=%d; dx=%d\n", myData.iNeedleRealHeight, myData.iNeedleOffsetX);
g_string_free (sElementPath, TRUE);
}
else
{
myData.DimensionData.width = 48; // valeurs par defaut si aucun theme trouve.
myData.DimensionData.height = 48;
myData.needleDimension.width = 48;
myData.needleDimension.height = 48;
}
}
void *proc_emu_ctx_cfg_new(gchar *group_name)
{
g_debug("%s node", __PRETTY_FUNCTION__);
struct emu_config *conf = g_malloc0(sizeof(struct emu_config));
GError *error = NULL;
conf->limits.files = g_key_file_get_integer(g_dionaea->config, group_name, "config.limits.files", &error);
if (error != NULL)
goto err;
conf->limits.filesize = g_key_file_get_integer(g_dionaea->config, group_name, "config.limits.filesize", &error);
if (error != NULL)
goto err;
conf->limits.sockets = g_key_file_get_integer(g_dionaea->config, group_name, "config.limits.sockets", &error);
if (error != NULL)
goto err;
conf->limits.steps = g_key_file_get_integer(g_dionaea->config, group_name, "config.limits.steps", &error);
if (error != NULL)
goto err;
conf->limits.idle = g_key_file_get_integer(g_dionaea->config, group_name, "config.limits.idle", &error);
if (error != NULL)
goto err;
conf->limits.listen = g_key_file_get_double(g_dionaea->config, group_name, "config.limits.listen", &error);
if (error != NULL)
goto err;
conf->limits.sustain = g_key_file_get_double(g_dionaea->config, group_name, "config.limits.sustain", &error);
if (error != NULL)
goto err;
conf->limits.cpu = g_key_file_get_double(g_dionaea->config, group_name, "config.limits.cpu", &error);
if (error != NULL)
goto err;
g_debug(
" files %i filesize %i sockets %i steps %i idle %f listen %f sustain %f cpu %f ",
conf->limits.files,
conf->limits.filesize,
conf->limits.sockets,
conf->limits.steps,
conf->limits.idle,
conf->limits.listen,
conf->limits.sustain,
conf->limits.cpu
);
// g_error("STOP");
return conf;
err:
g_warning("configuration for emulation is incomplete");
if (error != NULL)
g_warning("%s", error->message);
g_clear_error(&error);
g_free(conf);
return NULL;
}
/** \brief Read rotator configuration.
* \param conf Pointer to a rotor_conf_t structure where the data will be
* stored.
*
* This function reads a rotoator configuration from a .rot file into conf.
* conf->name must contain the file name of the configuration (no path, just
* file name and without the .rot extension).
*/
gboolean rotor_conf_read (rotor_conf_t *conf)
{
GKeyFile *cfg = NULL;
gchar *confdir;
gchar *fname;
GError *error = NULL;
if (conf->name == NULL) {
sat_log_log (SAT_LOG_LEVEL_ERROR,
_("%s: NULL configuration name!"),
__func__);
return FALSE;
}
confdir = get_hwconf_dir();
fname = g_strconcat (confdir, G_DIR_SEPARATOR_S,
conf->name, ".rot", NULL);
g_free (confdir);
/* open .grc file */
cfg = g_key_file_new ();
g_key_file_load_from_file(cfg, fname, 0, NULL);
if (cfg == NULL) {
sat_log_log (SAT_LOG_LEVEL_ERROR,
_("%s: Could not load file %s\n"),
__func__, fname);
g_free (fname);
return FALSE;
}
g_free (fname);
/* read parameters */
conf->host = g_key_file_get_string (cfg, GROUP, KEY_HOST, &error);
if (error != NULL) {
sat_log_log (SAT_LOG_LEVEL_ERROR,
_("%s: Error reading rotor conf from %s (%s)."),
__func__, conf->name, error->message);
g_clear_error (&error);
g_key_file_free (cfg);
return FALSE;
}
conf->port = g_key_file_get_integer (cfg, GROUP, KEY_PORT, &error);
if (error != NULL) {
sat_log_log (SAT_LOG_LEVEL_ERROR,
_("%s: Error reading rotor conf from %s (%s)."),
__func__, conf->name, error->message);
g_clear_error (&error);
g_key_file_free (cfg);
return FALSE;
}
conf->aztype = g_key_file_get_integer (cfg, GROUP, KEY_AZTYPE, &error);
if (error != NULL) {
sat_log_log (SAT_LOG_LEVEL_WARN,
_("%s: Az type not defined for %s. Assuming 0..360\302\260"),
__func__, conf->name);
g_clear_error (&error);
conf->aztype = ROT_AZ_TYPE_360;
}
conf->minaz = g_key_file_get_double (cfg, GROUP, KEY_MINAZ, &error);
if (error != NULL) {
sat_log_log (SAT_LOG_LEVEL_WARN,
_("%s: MinAz not defined for %s. Assuming 0\302\260."),
__func__, conf->name);
g_clear_error (&error);
conf->minaz = 0.0;
}
conf->maxaz = g_key_file_get_double (cfg, GROUP, KEY_MAXAZ, &error);
if (error != NULL) {
sat_log_log (SAT_LOG_LEVEL_WARN,
_("%s: MaxAz not defined for %s. Assuming 360\302\260."),
__func__, conf->name);
g_clear_error (&error);
conf->maxaz = 360.0;
}
conf->minel = g_key_file_get_double (cfg, GROUP, KEY_MINEL, &error);
if (error != NULL) {
sat_log_log (SAT_LOG_LEVEL_WARN,
_("%s: MinEl not defined for %s. Assuming 0\302\260."),
__func__, conf->name);
g_clear_error (&error);
conf->minel = 0.0;
}
conf->maxel = g_key_file_get_double (cfg, GROUP, KEY_MAXEL, &error);
if (error != NULL) {
sat_log_log (SAT_LOG_LEVEL_WARN,
_("%s: MaxEl not defined for %s. Assuming 90\302\260."),
__func__, conf->name);
g_clear_error (&error);
conf->maxel = 90.0;
}
g_key_file_free (cfg);
return TRUE;
}
// load preferences from file
void load_preferences (char *filepad) {
char txt[100];
GString *label = g_string_new_len("", 20);
int i, p, choice = -1;
GdkDevice *device, *nodevice;
GList *list;
TS keus;
if (settings == NULL) settings = g_key_file_new();
if (g_key_file_load_from_file(settings, filepad, G_KEY_FILE_NONE, NULL) == FALSE) { // set defaults
gchar *data;
gsize len;
// default settings when xpen.cfg not found
g_key_file_set_integer (settings, "display", "x", -1);
g_key_file_set_integer (settings, "display", "y", -1);
g_key_file_set_integer (settings, "display", "lx", -1);
g_key_file_set_integer (settings, "display", "ly", -1);
g_key_file_set_integer (settings, "display", "dx", 300);
g_key_file_set_integer (settings, "display", "dy", 400);
g_key_file_set_double (settings, "display", "opacity", 0.7);
g_key_file_set_string (settings, "display", "font", gtk_font_button_get_font_name(GTK_FONT_BUTTON(fontbutton)));
g_key_file_set_boolean (settings, "display", "tooltips", TRUE);
g_key_file_set_string (settings, "reader", "device", "stylus");
g_key_file_set_integer (settings, "reader", "speed", 6);
g_key_file_set_uint64 (settings, "reader", "lijnkleur", 0x514942);
g_key_file_set_uint64 (settings, "reader", "rasterkleur", 0xAB8C6D);
g_key_file_set_boolean (settings, "reader", "raster", TRUE);
g_key_file_set_boolean (settings, "reader", "speech", FALSE);
g_key_file_set_string (settings, "reader", "command", "aplay -q");
g_key_file_set_integer (settings, "reader", "voice", 0);
g_key_file_set_integer (settings, "keys", "paste0", 37);
g_key_file_set_integer (settings, "keys", "paste1", 55);
g_key_file_set_integer (settings, "keys", "backspace0", 0);
g_key_file_set_integer (settings, "keys", "backspace1", 22);
g_key_file_set_integer (settings, "GB1", "key", 0);
g_key_file_set_integer (settings, "GB1", "mode", 0);
g_key_file_set_integer (settings, "BIG5", "key", CTRL_R);
g_key_file_set_integer (settings, "BIG5", "mode", BIG5);
g_key_file_set_integer (settings, "DIGITS", "key", ALT_L);
g_key_file_set_integer (settings, "DIGITS", "mode", DIGITS);
g_key_file_set_integer (settings, "LOWERCASE", "key", ALT_L);
g_key_file_set_integer (settings, "LOWERCASE", "mode", LOWERCASE);
g_key_file_set_integer (settings, "UPPERCASE", "key", 0);
g_key_file_set_integer (settings, "UPPERCASE", "mode", 0);
g_key_file_set_integer (settings, "PUNC", "key", 0);
g_key_file_set_integer (settings, "PUNC", "mode", 0);
g_key_file_set_integer (settings, "DEFAULT", "key", ESC);
g_key_file_set_integer (settings, "DEFAULT", "mode", (GB1|GB2|DIGITS));
g_key_file_set_string (settings, "keydefs", "label1", "Control-Left");
g_key_file_set_integer (settings, "keydefs", "key1", CTRL_L);
g_key_file_set_string (settings, "keydefs", "label2", "Control-Right");
g_key_file_set_integer (settings, "keydefs", "key2", CTRL_R);
g_key_file_set_string (settings, "keydefs", "label3", "Shift-Left");
g_key_file_set_integer (settings, "keydefs", "key3", SHIFT_L);
g_key_file_set_string (settings, "keydefs", "label4", "Shift-Right");
g_key_file_set_integer (settings, "keydefs", "key4", SHIFT_R);
g_key_file_set_string (settings, "keydefs", "label5", "Alt-Left");
g_key_file_set_integer (settings, "keydefs", "key5", ALT_L);
g_key_file_set_string (settings, "keydefs", "label6", "Alt-Right");
g_key_file_set_integer (settings, "keydefs", "key6", ALT_R);
g_key_file_set_string (settings, "keydefs", "label7", "Escape");
g_key_file_set_integer (settings, "keydefs", "key7", ESC);
g_key_file_set_string (settings, "keydefs", "label8", "Caps-Lock");
g_key_file_set_integer (settings, "keydefs", "key8", CAPS);
g_key_file_set_string (settings, "keydefs", "label9", "Num-Lock");
g_key_file_set_integer (settings, "keydefs", "key9", NUMS);
g_key_file_set_string (settings, "keydefs", "label10", "Scroll-Lock");
g_key_file_set_integer (settings, "keydefs", "key10", SCROLLS);
g_key_file_set_string (settings, "keydefs", "label11", "Pause/Break");
g_key_file_set_integer (settings, "keydefs", "key11", PAUSE);
g_key_file_set_string (settings, "keydefs", "label12", "not set");
g_key_file_set_integer (settings, "keydefs", "key12", 0);
g_key_file_set_string (settings, "keydefs", "label13", "not set");
g_key_file_set_integer (settings, "keydefs", "key13", 0);
data = g_key_file_to_data (settings, &len, NULL); // save defaults
g_file_set_contents (filepad, data, len, NULL);
g_free(data);
}
// fill the preferences structure
conf.x = g_key_file_get_integer (settings, "display", "x", NULL);
conf.y = g_key_file_get_integer (settings, "display", "y", NULL);
conf.lx = g_key_file_get_integer (settings, "display", "lx", NULL);
conf.ly = g_key_file_get_integer (settings, "display", "ly", NULL);
conf.dx = g_key_file_get_integer (settings, "display", "dx", NULL);
conf.dy = g_key_file_get_integer (settings, "display", "dy", NULL);
conf.opacity = g_key_file_get_double (settings, "display", "opacity", NULL);
conf.tips = g_key_file_get_boolean (settings, "display", "tooltips", NULL);
conf.font = g_key_file_get_string (settings, "display", "font", NULL);
conf.device = g_key_file_get_string (settings, "reader", "device", NULL);
conf.speed = g_key_file_get_integer (settings, "reader", "speed", NULL);
conf.lijnkleur = g_key_file_get_uint64 (settings, "reader", "lijnkleur", NULL);
conf.rasterkleur = g_key_file_get_uint64 (settings, "reader", "rasterkleur", NULL);
conf.raster = g_key_file_get_boolean (settings, "reader", "raster", NULL);
conf.speech = g_key_file_get_boolean (settings, "reader", "speech", NULL);
conf.voice = g_key_file_get_integer (settings, "reader", "voice", NULL);
conf.paste[0] = g_key_file_get_integer (settings, "keys", "paste0", NULL);
conf.paste[1] = g_key_file_get_integer (settings, "keys", "paste1", NULL);
conf.backspace[0] = g_key_file_get_integer (settings, "keys", "backspace0", NULL);
conf.backspace[1] = g_key_file_get_integer (settings, "keys", "backspace1", NULL);
conf.keymode[0].key = g_key_file_get_integer (settings, "GB1", "key", NULL);
conf.keymode[0].mode = g_key_file_get_integer (settings, "GB1", "mode", NULL);
conf.keymode[1].key = g_key_file_get_integer (settings, "BIG5", "key", NULL);
conf.keymode[1].mode = g_key_file_get_integer (settings, "BIG5", "mode", NULL);
conf.keymode[2].key = g_key_file_get_integer (settings, "DIGITS", "key", NULL);
conf.keymode[2].mode = g_key_file_get_integer (settings, "DIGITS", "mode", NULL);
conf.keymode[3].key = g_key_file_get_integer (settings, "LOWERCASE", "key", NULL);
conf.keymode[3].mode = g_key_file_get_integer (settings, "LOWERCASE", "mode", NULL);
conf.keymode[4].key = g_key_file_get_integer (settings, "UPPERCASE", "key", NULL);
conf.keymode[4].mode = g_key_file_get_integer (settings, "UPPERCASE", "mode", NULL);
conf.keymode[5].key = g_key_file_get_integer (settings, "PUNC", "key", NULL);
conf.keymode[5].mode = g_key_file_get_integer (settings, "PUNC", "mode", NULL);
conf.keymode[6].key = g_key_file_get_integer (settings, "DEFAULT", "key", NULL);
conf.keymode[6].mode = g_key_file_get_integer (settings, "DEFAULT", "mode", NULL);
// set speech + command
GTK_TOGGLE_BUTTON(checkbutton9)->active = conf.speech;
gtk_combo_box_set_active(GTK_COMBO_BOX(combobox1), conf.voice);
for (i=0; i<13; i++) {
g_string_sprintf(label, "key%d", i+1);
conf.defkey[i].key = g_key_file_get_integer (settings, "keydefs", label->str, NULL);
g_string_sprintf(label, "label%d", i+1);
conf.defkey[i].label = g_key_file_get_string (settings, "keydefs", label->str, NULL);
}
// start setting all widgets with the values from the configuration (conf)
// set tooltips
GTK_TOGGLE_BUTTON(checkbutton8)->active = conf.tips;
// set the 13 buttons/entries in preferences
for (i=0; i<13; i++) {
if (conf.defkey[i].key > 0) {
g_string_sprintf(label, "key = %d", conf.defkey[i].key);
gtk_button_set_label(GTK_BUTTON(conf.defkey[i].button), label->str);
gtk_entry_set_text(GTK_ENTRY(conf.defkey[i].entry), conf.defkey[i].label);
} else {
gtk_button_set_label(GTK_BUTTON(conf.defkey[i].button), "not set");
gtk_entry_set_text(GTK_ENTRY(conf.defkey[i].entry), "");
}
}
g_string_free(label, TRUE);
// set the default recognition mode
mode = conf.keymode[6].mode;
keus = (mode & BIG5) ? Traditional : Simplified;
selecteer(keus);
// set the labels of the hotkeys (preferences)
for (i=0; i<7; i++) {
bool found;
hotkey[conf.keymode[i].key] |= conf.keymode[i].mode; // set the hotkeys
found = FALSE;
for (p=0; p<13; p++) {
if (conf.defkey[p].key > 0) {
if (conf.keymode[i].key == conf.defkey[p].key) {
strcpy(txt, conf.defkey[p].label);
found = TRUE;
break;
}
}
}
if (found == FALSE) {
if (conf.keymode[i].key > 0)
sprintf(txt, "key = %d", conf.keymode[i].key);
else
strcpy(txt, "not set");
}
gtk_button_set_label(GTK_BUTTON(modebits[i].button), txt);
// set the default checkboxes (preferences)
if (conf.keymode[6].mode & GB1)
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(modebits[0].check), TRUE);
if (conf.keymode[6].mode & BIG5)
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(modebits[1].check), TRUE);
if (conf.keymode[6].mode & DIGITS)
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(modebits[2].check), TRUE);
if (conf.keymode[6].mode & LOWERCASE)
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(modebits[3].check), TRUE);
if (conf.keymode[6].mode & UPPERCASE)
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(modebits[4].check), TRUE);
if (conf.keymode[6].mode & PUNC)
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(modebits[5].check), TRUE);
}
// fill combobox with input-devices
list = gdk_devices_list();
device = (GdkDevice *) list->data; // default device
nodevice = NULL;
for (p=0; list->next; p++) {
strcpy(txt, gdk_device_get_name((GdkDevice *)list->data));
gtk_combo_box_append_text(GTK_COMBO_BOX(combo), txt);
if (strstr(txt, conf.device)) {
device = (GdkDevice *) list->data;
choice = p;
}
nodevice = (GdkDevice *) list->data;
list = list->next;
}
if (choice == -1) { // prefered device not found
choice = p-1;
device = nodevice;
}
//g_list_free(list);
gtk_combo_box_set_active(GTK_COMBO_BOX(combo), choice);
gdk_device_set_source (device, GDK_SOURCE_PEN);
gdk_device_set_mode(device, GDK_MODE_SCREEN);
// set line color
lijnkleur.pixel = conf.lijnkleur;
sprintf(txt, "#%.6X", lijnkleur.pixel);
gdk_color_parse(txt, &lijnkleur);
gtk_color_button_set_color(GTK_COLOR_BUTTON(colorbutton1), &lijnkleur);
// set raster color
rasterkleur.pixel = conf.rasterkleur;
sprintf(txt, "#%.6X", rasterkleur.pixel);
gdk_color_parse(txt, &rasterkleur);
gtk_color_button_set_color(GTK_COLOR_BUTTON(colorbutton2), &rasterkleur);
// set raster on/off check button
GTK_TOGGLE_BUTTON(checkbutton1)->active = conf.raster;
// set main window opacity slider
gtk_adjustment_set_value(opacity, conf.opacity);
// set the 9 candidate buttons with a default font
for (i=0; i< 9; i++) {
PangoFontDescription *pfont;
pfont = pango_font_description_from_string(conf.font);
gtk_widget_modify_font (GTK_WIDGET(knop[i]), pfont );
pango_font_description_free(pfont);
}
// set the font selection button with the font title
gtk_font_button_set_font_name(GTK_FONT_BUTTON(fontbutton), conf.font);
// set the recognize speed slider
gtk_adjustment_set_value(speed, conf.speed);
WTSetSpeed(conf.speed);
// set the default paste and backspace entry fields
gtk_entry_set_text(GTK_ENTRY(entry1), key2string(conf.paste[1], conf.paste[0]));
gtk_entry_set_text(GTK_ENTRY(entry2), key2string(conf.backspace[1], conf.backspace[0]));
}
