GKeyFile* load_session_config( const char* config_filename )
{
const gchar* const *dirs = g_get_system_config_dirs();
const gchar* const *dir;
GKeyFile* kf = g_key_file_new();
char* filename;
gboolean ret;
/* load user-specific session config */
filename = g_build_filename( g_get_user_config_dir(), prog_name, session_name, config_filename, NULL );
ret = g_key_file_load_from_file(kf, filename, 0, NULL);
g_free( filename );
if( ! ret ) /* user specific file is not found */
{
/* load system-wide session config files */
for( dir = dirs; *dir; ++dir )
{
filename = g_build_filename( *dir, prog_name, session_name, config_filename, NULL );
ret = g_key_file_load_from_file(kf, filename, 0, NULL);
g_free( filename );
if(ret)
break;
}
}
if( G_UNLIKELY(!ret) )
{
g_key_file_free(kf);
return NULL;
}
return kf;
}
gchar*
get_xdg_config_file (const char *name)
{
const gchar *user_dir = g_get_user_config_dir();
const gchar* const *system_dirs;
const gchar* const *dir;
gchar *file;
system_dirs = g_get_system_config_dirs();
file = g_build_filename(user_dir, name, NULL);
if (g_file_test(file, G_FILE_TEST_EXISTS) == TRUE)
{
return file;
}
free(file);
for (dir = system_dirs; *dir; ++dir )
{
file = g_build_filename(*dir, name, NULL);
if (g_file_test(file, G_FILE_TEST_EXISTS) == TRUE)
return file;
free(file);
}
return NULL;
}
static int
init_config(void) {
GKeyFile *cfg;
const char *path;
char *file;
gboolean loaded = FALSE;
cfg = g_key_file_new();
path = g_get_user_config_dir();
file = g_build_filename(path, "lightpad/lightpad.cfg", NULL);
g_free((gpointer)path);
loaded = g_key_file_load_from_file(cfg, file, G_KEY_FILE_NONE, NULL);
for(const char *const *dir = g_get_system_config_dirs(); !loaded && *dir; dir++) {
file = g_build_filename(*dir, "/lightpad/lightpad.cfg", NULL);
loaded = g_key_file_load_from_file(cfg, file, G_KEY_FILE_NONE, NULL);
}
if(loaded)
set_config(cfg);
else {
g_fprintf(stderr,
"Error: cannot find a configuration file!\nPlease make sure Lightpad is installed correctly.\n");
return -1;
}
g_free(file);
g_key_file_free(cfg);
return 0;
}
QString Settings::profileDir(QString profile, bool useFallback) {
// NOTE: it's a shame that QDesktopServices does not handle XDG_CONFIG_HOME
// try user-specific config file first
QString dirName;
// WARNING: Don't use XDG_CONFIG_HOME with root because it might
// give the user config directory if gksu-properties is set to su.
if(geteuid())
dirName = QLatin1String(qgetenv("XDG_CONFIG_HOME"));
if (dirName.isEmpty())
dirName = QDir::homePath() % QLatin1String("/.config");
dirName = dirName % "/pcmanfm-qt/" % profile;
QDir dir(dirName);
// if user config dir does not exist, try system-wide config dirs instead
if(!dir.exists() && useFallback) {
QString fallbackDir;
for(const char* const* configDir = g_get_system_config_dirs(); *configDir; ++configDir) {
fallbackDir = QString(*configDir) % "/pcmanfm-qt/" % profile;
dir.setPath(fallbackDir);
if(dir.exists()) {
dirName = fallbackDir;
break;
}
}
}
return dirName;
}
static gboolean start_all_panels( )
{
char *panel_dir;
const gchar * const * dir;
/* try user panels */
panel_dir = _user_config_file_name("panels", NULL);
_start_panels_from_dir(panel_dir);
g_free(panel_dir);
if (all_panels != NULL)
return TRUE;
/* else try XDG fallbacks */
dir = g_get_system_config_dirs();
if (dir) while (dir[0])
{
panel_dir = _system_config_file_name(dir[0], "panels");
_start_panels_from_dir(panel_dir);
g_free(panel_dir);
if (all_panels != NULL)
return TRUE;
dir++;
}
/* last try at old fallback for compatibility reasons */
panel_dir = _old_system_config_file_name("panels");
_start_panels_from_dir(panel_dir);
g_free(panel_dir);
return all_panels != NULL;
}
static gchar *
tumbler_util_get_settings_filename (void)
{
gchar *path;
const gchar filename[] = "tumbler" G_DIR_SEPARATOR_S "tumbler.rc";
const gchar * const *dirs;
guint n;
/* check user directory */
path = g_build_filename (g_get_user_config_dir (), filename, NULL);
if (g_file_test (path, G_FILE_TEST_IS_REGULAR))
return path;
g_free (path);
dirs = g_get_system_config_dirs ();
if (G_UNLIKELY (dirs == NULL))
return FALSE;
/* look in system config dirs */
for (n = 0; dirs[n] != NULL; n++)
{
path = g_build_filename (dirs[n], filename, NULL);
if (g_file_test (path, G_FILE_TEST_IS_REGULAR))
return path;
g_free (path);
}
return NULL;
}
static void options_file_init_paths(void)
{
if (options_pathv)
return;
/* Add in reverse order of priority because we prepend */
/* XDG system conf dirs */
options_pathv = options_file_join_strvs(g_get_system_config_dirs(), NULL);
if (options_pathv)
options_file_append_leaf_to_pathv(options_pathv, ROXTERM_LEAF_DIR);
/* AppDir or datadir */
if (global_options_appdir)
{
options_file_prepend_str_to_v(g_build_filename(global_options_appdir,
"Config", NULL));
}
else
{
options_file_prepend_str_to_v(g_build_filename(PKG_DATA_DIR,
"Config", NULL));
}
/* XDG home conf dir (highest priority) */
options_file_prepend_str_to_v(g_build_filename(g_get_user_config_dir(),
ROXTERM_LEAF_DIR, NULL));
}
/*
* system wide default config is /etc/xdg/lxsession/SESSION_NAME/desktop.conf
* system wide default apps are listed in /etc/xdg/lxsession/SESSION_NAME/autostart
*/
void start_session()
{
const gchar* const *dirs = g_get_system_config_dirs();
const gchar* const *dir;
char* filename;
/* run window manager first */
if( G_LIKELY( window_manager ) )
run_app( window_manager, TRUE );
if( G_UNLIKELY( !no_autostart ) )
{
/* load system-wide default apps */
for( dir = dirs; *dir; ++dir )
{
filename = g_build_filename( *dir, prog_name, session_name, autostart_filename, NULL );
load_default_apps( filename );
g_free( filename );
}
/* load user-specific default apps */
filename = g_build_filename( g_get_user_config_dir(), prog_name, session_name, autostart_filename, NULL );
load_default_apps( filename );
g_free( filename );
/* Support autostart spec of freedesktop.org if not disable*/
xdg_autostart( session_name );
}
}
/**
* fm_config_load_from_file
* @cfg: pointer to configuration
* @name: (allow-none): file name to load configuration
*
* Fills configuration @cfg with data from configuration file. The file
* @name may be %NULL to load default configuration file. If @name is
* full path then that file will be loaded. Otherwise @name will be
* searched in system config directories and after that in ~/.config/
* directory and all found files will be loaded, overwriting existing
* data in @cfg.
*
* See also: fm_config_load_from_key_file()
*
* Since: 0.1.0
*/
void fm_config_load_from_file(FmConfig* cfg, const char* name)
{
const gchar * const *dirs, * const *dir;
char *path;
GKeyFile* kf = g_key_file_new();
g_strfreev(cfg->modules_blacklist);
g_strfreev(cfg->system_modules_blacklist);
cfg->modules_blacklist = NULL;
cfg->system_modules_blacklist = NULL;
_cfg_monitor_free(cfg);
g_free(cfg->_cfg_name);
if(G_LIKELY(!name))
name = "libfm/libfm.conf";
else
{
if(G_UNLIKELY(g_path_is_absolute(name)))
{
cfg->_cfg_name = g_strdup(name);
if(g_key_file_load_from_file(kf, name, 0, NULL))
{
fm_config_load_from_key_file(cfg, kf);
_cfg_monitor_add(cfg, name);
}
goto _out;
}
}
cfg->_cfg_name = g_strdup(name);
dirs = g_get_system_config_dirs();
/* bug SF #887: first dir in XDG_CONFIG_DIRS is the most relevant
so we shoult process the list in reverse order */
dir = dirs;
while (*dir)
++dir;
while (dir-- != dirs)
{
path = g_build_filename(*dir, name, NULL);
if(g_key_file_load_from_file(kf, path, 0, NULL))
fm_config_load_from_key_file(cfg, kf);
g_free(path);
}
/* we got all system blacklists, save them and get user's one */
cfg->system_modules_blacklist = cfg->modules_blacklist;
cfg->modules_blacklist = NULL;
path = g_build_filename(g_get_user_config_dir(), name, NULL);
if(g_key_file_load_from_file(kf, path, 0, NULL))
{
fm_config_load_from_key_file(cfg, kf);
_cfg_monitor_add(cfg, path);
}
g_free(path);
_out:
g_key_file_free(kf);
g_signal_emit(cfg, signals[CHANGED], 0);
/* FIXME: compare and send individual changes instead */
}
static gboolean
infinoted_startup_load_options(InfinotedStartup* startup,
int* argc,
char*** argv,
GError** error)
{
const gchar* const* system_config_dirs;
guint n_system_config_dirs;
const gchar* user_config_dir;
const gchar* const* dir;
guint i;
gchar** config_files;
system_config_dirs = g_get_system_config_dirs();
user_config_dir = g_get_user_config_dir();
n_system_config_dirs = 0;
if(system_config_dirs != NULL)
{
for(dir = system_config_dirs; *dir != NULL; ++ dir)
++ n_system_config_dirs;
}
config_files = g_malloc( (n_system_config_dirs + 2) * sizeof(gchar*));
config_files[n_system_config_dirs + 1] = NULL;
config_files[0] =
g_build_filename(user_config_dir, "infinoted.conf", NULL);
for(i = 0; i < n_system_config_dirs; ++ i)
{
config_files[i + 1] =
g_build_filename(system_config_dirs[i], "infinoted.conf", NULL);
}
startup->options =
infinoted_options_new(
(gchar const* const*) config_files, argc, argv, error);
for(i = 0; i < n_system_config_dirs + 1; ++ i)
g_free(config_files[i]);
g_free(config_files);
if(startup->options == NULL)
return FALSE;
return TRUE;
}
/* {{{ proto array Glib::systemConfigDirs()
Returns an ordered list of base directories in which to access system-wide configuration information.
*/
PHP_METHOD(Glib, systemConfigDirs)
{
if (zend_parse_parameters_none() == FAILURE) {
return;
}
const gchar* const *dir = g_get_system_config_dirs();
array_init(return_value);
while (*dir != NULL) {
add_next_index_string(return_value, *dir, 1);
dir++;
}
}
/**
* fm_config_load_from_file
* @cfg: pointer to configuration
* @name: (allow-none): file name to load configuration
*
* Fills configuration @cfg with data from configuration file. The file
* @name may be %NULL to load default configuration file. If @name is
* full path then that file will be loaded. Otherwise @name will be
* searched in system config directories and after that in ~/.config/
* directory and all found files will be loaded, overwriting existing
* data in @cfg.
*
* See also: fm_config_load_from_key_file()
*
* Since: 0.1.0
*/
void fm_config_load_from_file(FmConfig* cfg, const char* name)
{
const gchar * const *dirs, * const *dir;
char *path;
GKeyFile* kf = g_key_file_new();
g_strfreev(cfg->modules_blacklist);
g_strfreev(cfg->system_modules_blacklist);
cfg->modules_blacklist = NULL;
cfg->system_modules_blacklist = NULL;
if(G_LIKELY(!name))
name = "libfm/libfm.conf";
else
{
if(G_UNLIKELY(g_path_is_absolute(name)))
{
cfg->_cfg_name = g_strdup(name);
if(g_key_file_load_from_file(kf, name, 0, NULL))
fm_config_load_from_key_file(cfg, kf);
goto _out;
}
}
cfg->_cfg_name = g_strdup(name);
dirs = g_get_system_config_dirs();
for(dir=dirs;*dir;++dir)
{
path = g_build_filename(*dir, name, NULL);
if(g_key_file_load_from_file(kf, path, 0, NULL))
fm_config_load_from_key_file(cfg, kf);
g_free(path);
}
path = g_build_filename(SYSCONF_DIR, name, NULL);
if(g_key_file_load_from_file(kf, path, 0, NULL))
fm_config_load_from_key_file(cfg, kf);
g_free(path);
/* we got all system blacklists, save them and get user's one */
cfg->system_modules_blacklist = cfg->modules_blacklist;
cfg->modules_blacklist = NULL;
path = g_build_filename(g_get_user_config_dir(), name, NULL);
if(g_key_file_load_from_file(kf, path, 0, NULL))
fm_config_load_from_key_file(cfg, kf);
g_free(path);
_out:
g_key_file_free(kf);
g_signal_emit(cfg, signals[CHANGED], 0);
}
static void utils_conf_load(void)
{
if(conf_global)
return;
conf_global=g_key_file_new();
conf_user=g_key_file_new();
// Load system wide configuration
g_key_file_load_from_dirs(conf_global,"sphone/sphone.conf",g_get_system_config_dirs(),NULL,G_KEY_FILE_NONE,NULL);
// load local configuration
gchar *localpath=g_build_filename(g_get_user_config_dir(),"sphone","sphone.conf",NULL);
g_key_file_load_from_file(conf_user,localpath,G_KEY_FILE_NONE,NULL);
g_free(localpath);
}
/* Load a configuration file. */
gboolean
luaH_parserc(const gchar *confpath, gboolean run)
{
const gchar* const *config_dirs = NULL;
gboolean ret = FALSE;
GPtrArray *paths = NULL;
/* try to load, return if it's ok */
if(confpath) {
if(luaH_loadrc(confpath, run))
ret = TRUE;
goto bailout;
}
/* compile list of config search paths */
paths = g_ptr_array_new_with_free_func(g_free);
#if DEVELOPMENT_PATHS
/* allows for testing luakit in the project directory */
g_ptr_array_add(paths, g_strdup("./config/rc.lua"));
#endif
/* search users config dir (see: XDG_CONFIG_HOME) */
g_ptr_array_add(paths, g_build_filename(globalconf.config_dir, "rc.lua", NULL));
/* search system config dirs (see: XDG_CONFIG_DIRS) */
config_dirs = g_get_system_config_dirs();
for(; *config_dirs; config_dirs++)
g_ptr_array_add(paths, g_build_filename(*config_dirs, "luakit", "rc.lua", NULL));
for (gpointer *path = paths->pdata; *path; path++) {
if (file_exists(*path)) {
if(luaH_loadrc(*path, run)) {
globalconf.confpath = g_strdup(*path);
ret = TRUE;
goto bailout;
} else if(!run)
goto bailout;
}
}
bailout:
if (paths) g_ptr_array_free(paths, TRUE);
return ret;
}
static void load_settings()
{
const char* session_name = g_getenv("DESKTOP_SESSION");
/* load settings from current session config files */
if(!session_name)
session_name = "LXDE";
char* rel_path = g_strconcat("lxsession/", session_name, "/desktop.conf", NULL);
char* user_config_file = g_build_filename(g_get_user_config_dir(), rel_path, NULL);
GKeyFile* kf = g_key_file_new();
if(!g_key_file_load_from_file(kf, user_config_file, G_KEY_FILE_KEEP_COMMENTS|G_KEY_FILE_KEEP_TRANSLATIONS, NULL))
{
g_key_file_load_from_dirs(kf, rel_path, (const char**)g_get_system_config_dirs(), NULL,
G_KEY_FILE_KEEP_COMMENTS|G_KEY_FILE_KEEP_TRANSLATIONS, NULL);
}
g_free(rel_path);
int val;
val = g_key_file_get_integer(kf, "Mouse", "AccFactor", NULL);
if( val > 0)
old_accel = accel = val;
val = g_key_file_get_integer(kf, "Mouse", "AccThreshold", NULL);
if( val > 0)
old_threshold = threshold = val;
old_left_handed = left_handed = g_key_file_get_boolean(kf, "Mouse", "LeftHanded", NULL);
val = g_key_file_get_integer(kf, "Keyboard", "Delay", NULL);
if(val > 0)
old_delay = delay = val;
val = g_key_file_get_integer(kf, "Keyboard", "Interval", NULL);
if(val > 0)
old_interval = interval = val;
if( g_key_file_has_key(kf, "Keyboard", "Beep", NULL ) )
old_beep = beep = g_key_file_get_boolean(kf, "Keyboard", "Beep", NULL);
g_key_file_free(kf);
g_free(user_config_file);
old_dclick = dclick = get_dclick_time ();
}
int config_read ()
{
const gchar * const * system_dirs;
char *path1;
gint i;
// follow XDG specification
// check tint2rc in user directory
path1 = g_build_filename (g_get_user_config_dir(), "tint2", "tint2rc", NULL);
if (g_file_test (path1, G_FILE_TEST_EXISTS)) {
i = config_read_file (path1);
config_path = strdup(path1);
g_free(path1);
return i;
}
g_free(path1);
// copy tint2rc from system directory to user directory
char *path2 = 0;
system_dirs = g_get_system_config_dirs();
for (i = 0; system_dirs[i]; i++) {
path2 = g_build_filename(system_dirs[i], "tint2", "tint2rc", NULL);
if (g_file_test(path2, G_FILE_TEST_EXISTS)) break;
g_free (path2);
path2 = 0;
}
if (path2) {
// copy file in user directory (path1)
char *dir = g_build_filename (g_get_user_config_dir(), "tint2", NULL);
if (!g_file_test (dir, G_FILE_TEST_IS_DIR)) g_mkdir(dir, 0777);
g_free(dir);
path1 = g_build_filename (g_get_user_config_dir(), "tint2", "tint2rc", NULL);
copy_file(path2, path1);
g_free(path2);
i = config_read_file (path1);
config_path = strdup(path1);
g_free(path1);
return i;
}
return 0;
}
/**
* find_valid_session_keyfile:
* @session: name of session
*
* We look for the session file in XDG_CONFIG_HOME, XDG_CONFIG_DIRS and
* XDG_DATA_DIRS. This enables users and sysadmins to override a specific
* session that is shipped in XDG_DATA_DIRS.
*/
static GKeyFile *
find_valid_session_keyfile (const char *session)
{
GPtrArray *dirs;
const char * const *system_config_dirs;
const char * const *system_data_dirs;
int i;
GKeyFile *keyfile;
char *basename;
char *path;
dirs = g_ptr_array_new ();
g_ptr_array_add (dirs, (gpointer) g_get_user_config_dir ());
system_config_dirs = g_get_system_config_dirs ();
for (i = 0; system_config_dirs[i]; i++)
g_ptr_array_add (dirs, (gpointer) system_config_dirs[i]);
system_data_dirs = g_get_system_data_dirs ();
for (i = 0; system_data_dirs[i]; i++)
g_ptr_array_add (dirs, (gpointer) system_data_dirs[i]);
keyfile = NULL;
basename = g_strdup_printf ("%s.session", session);
path = NULL;
for (i = 0; i < dirs->len; i++) {
path = g_build_filename (dirs->pdata[i], "gnome-session", "sessions", basename, NULL);
keyfile = get_session_keyfile_if_valid (path);
if (keyfile != NULL)
break;
}
if (dirs)
g_ptr_array_free (dirs, TRUE);
if (basename)
g_free (basename);
if (path)
g_free (path);
return keyfile;
}
JNIEXPORT jobjectArray JNICALL
Java_org_gnome_glib_GlibMisc_g_1get_1system_1config_1dirs
(
JNIEnv* env,
jclass cls
)
{
const gchar** result;
jobjectArray _result;
// call function
result = g_get_system_config_dirs();
// translate return value to JNI type
_result = (jobjectArray) bindings_java_convert_gchararray_to_jarray(env, (const gchar**)result);
// and finally
return _result;
}
/****f* openbox-menu/check_application_menu
* FUNCTION
* Test if menu file exists.
*
* PARAMETERS
* * menu, a string containing the filename of the menu
*
* RETURN VALUE
* FALSE if menu file is not found. TRUE otherwise.
*
* NOTES
* User custom menu file can be used if XDG_CONFIG_DIRS is set, i.g
* 'export XDG_CONFIG_DIRS="$HOME/.config/:/etc/xdg/" to use
* menu file located in $HOME/menus or /etc/xdg/ directories.
****/
gboolean
check_application_menu (gchar *menu)
{
const gchar * const *dir;
gchar *menu_path;
for (dir = g_get_system_config_dirs(); *dir ; dir++)
{
menu_path = g_build_filename (*dir, "menus", menu, NULL);
if (g_file_test (menu_path, G_FILE_TEST_EXISTS))
{
g_free (menu_path);
return TRUE;
}
g_free (menu_path);
}
return FALSE;
}
void load_autostart(const char* session_name)
{
const char* const *dirs = g_get_system_config_dirs();
const char* const *dir;
GHashTable* hash = g_hash_table_new_full( g_str_hash, g_str_equal, g_free, g_free );
/* get system-wide autostart files */
for( dir = dirs; *dir; ++dir )
get_autostart_files_in_dir( hash, session_name, *dir );
/* get user-specific autostart files */
get_autostart_files_in_dir( hash, session_name, g_get_user_config_dir() );
if( g_hash_table_size( hash ) > 0 )
{
GKeyFile* kf = g_key_file_new();
g_hash_table_foreach( hash, (GHFunc)add_autostart_file, kf );
g_key_file_free( kf );
}
g_hash_table_destroy( hash );
}
static void
perform_reboot (GrubChooseDefaultWindow *win)
{
//GrubChooseDefaultWindowPrivate *priv = GET_PRIVATE (win);
gboolean r;
const gchar * const * config_dirs;
const gchar * config_dir;
gchar * script;
GError *error = NULL;
script = g_build_filename (CONFIG_DIR, "reboot", NULL);
config_dir = g_get_user_config_dir ();
r = grub_choose_default_exec (config_dir, script, FALSE, NULL);
if (!r)
{
for (config_dirs = g_get_system_config_dirs (); *config_dirs != NULL && !r; config_dirs++)
{
r = grub_choose_default_exec (*config_dirs, script, FALSE, NULL);
}
/* we found no script */
if (!r)
{
g_set_error (&error,
GCHD_ERROR, GCHD_ERROR_NO_REBOOT_SCRIPT,
"Could not find any reboot scripts.\nYou can install one in %s/%s .",
config_dir, script);
grub_choose_default_error (GTK_WIDGET (win), error);
g_error_free (error);
}
}
g_free (script);
}
inline static void loadconf()
{
const gchar* const *config_dirs = g_get_system_config_dirs();
GPtrArray *ptr_paths = g_ptr_array_new();
g_ptr_array_add(ptr_paths, g_build_filename(g_get_user_config_dir(), APPNAME, "/", NULL));
for(; *config_dirs; config_dirs++)
g_ptr_array_add(ptr_paths, g_build_filename(*config_dirs, APPNAME, "/", NULL));
gchar** paths = (gchar**)g_ptr_array_free(ptr_paths, FALSE);
GError* error = NULL;
GKeyFile* key_file = g_key_file_new();
gchar* fullpath = NULL;
gboolean can_be_loaded = g_key_file_load_from_dirs(key_file, "config", (const gchar**)paths, &fullpath, G_KEY_FILE_NONE, &error);
if (!can_be_loaded)
{
warn("%s\n", error->message);
g_error_free(error);
}
else
{
assign_boolean(key_file, &conf.onecolumn, "onecolumn" );
assign_boolean(key_file, &conf.checkbox, "checkbox" );
assign_boolean(key_file, &conf.numbers, "numbers" );
assign_boolean(key_file, &conf.underline, "underline" );
assign_boolean(key_file, &conf.color, "color" );
assign_boolean(key_file, &conf.radiobox, "radiobox" );
assign_boolean(key_file, &conf.initial, "initial" );
assign_boolean(key_file, &conf.whitelines, "whitelines");
assign_boolean(key_file, &conf.fullattr, "fullattr" );
assign_string (key_file, &conf.foreground, "foreground");
assign_string (key_file, &conf.background, "background");
}
g_key_file_free(key_file);
g_strfreev(paths);
g_free(fullpath);
}
static gchar *
get_config_path (void)
{
gchar *path;
const gchar *const *dirs;
int i;
path = g_strdup (g_getenv ("OMX_CONFIG"));
if (path)
return path;
dirs = g_get_system_config_dirs ();
for (i = 0; dirs[i]; i++) {
path =
g_build_filename (dirs[i], "gstreamer-0.10", "gst-openmax.conf", NULL);
if (g_file_test (path, G_FILE_TEST_IS_REGULAR))
return path;
g_free (path);
}
return g_build_filename (g_get_user_config_dir (), "gst-openmax.conf", NULL);
}
int main(int argc, char** argv)
{
GtkBuilder* builder;
char* str = NULL;
GKeyFile* kf = g_key_file_new();
const char* session_name = g_getenv("DESKTOP_SESSION");
/* load settings from current session config files */
if(!session_name)
session_name = "LXDE";
char* rel_path = g_strconcat("lxsession/", session_name, "/desktop.conf", NULL);
char* user_config_file = g_build_filename(g_get_user_config_dir(), rel_path, NULL);
#ifdef ENABLE_NLS
bindtextdomain ( GETTEXT_PACKAGE, PACKAGE_LOCALE_DIR );
bind_textdomain_codeset ( GETTEXT_PACKAGE, "UTF-8" );
textdomain ( GETTEXT_PACKAGE );
#endif
gtk_init(&argc, &argv);
gtk_icon_theme_prepend_search_path(gtk_icon_theme_get_default(), PACKAGE_DATA_DIR);
/* build the UI */
builder = gtk_builder_new();
gtk_builder_add_from_file( builder, PACKAGE_DATA_DIR "/lxinput.ui", NULL );
dlg = (GtkWidget*)gtk_builder_get_object( builder, "dlg" );
gtk_dialog_set_alternative_button_order( (GtkDialog*)dlg, GTK_RESPONSE_OK, GTK_RESPONSE_CANCEL, -1 );
mouse_accel = (GtkRange*)gtk_builder_get_object(builder,"mouse_accel");
mouse_threshold = (GtkRange*)gtk_builder_get_object(builder,"mouse_threshold");
mouse_left_handed = (GtkToggleButton*)gtk_builder_get_object(builder,"left_handed");
mouse_dclick = (GtkRange*)gtk_builder_get_object(builder, "mouse_dclick");
kb_delay = (GtkRange*)gtk_builder_get_object(builder,"kb_delay");
kb_interval = (GtkRange*)gtk_builder_get_object(builder,"kb_interval");
kb_beep = (GtkToggleButton*)gtk_builder_get_object(builder,"beep");
kb_layout = (GtkButton*)gtk_builder_get_object(builder,"keyboard_layout");
const gchar *program = detect_keymap_program();
if (program == NULL)
{
/* Hide the button if there is no program to set keymap */
kb_layout_label = (GtkLabel*)gtk_builder_get_object(builder,"keyboard_layout_label");
gtk_widget_set_visible(GTK_WIDGET(kb_layout_label), FALSE);
gtk_widget_set_visible(GTK_WIDGET(kb_layout), FALSE);
}
else
{
gtk_button_set_label(kb_layout, _("Keyboard Layout..."));
}
g_object_unref( builder );
/* read the config flie */
load_settings();
/* init the UI */
gtk_range_set_value(mouse_accel, (gdouble)accel / 10.0);
gtk_range_set_value(mouse_threshold, threshold);
gtk_range_set_value(mouse_dclick, dclick);
gtk_toggle_button_set_active(mouse_left_handed, left_handed);
gtk_range_set_value(kb_delay, delay);
gtk_range_set_value(kb_interval, interval);
gtk_toggle_button_set_active(kb_beep, beep);
set_range_stops(mouse_accel, 10);
g_signal_connect(mouse_accel, "value-changed", G_CALLBACK(on_mouse_accel_changed), NULL);
set_range_stops(mouse_threshold, 10);
g_signal_connect(mouse_threshold, "value-changed", G_CALLBACK(on_mouse_threshold_changed), NULL);
g_signal_connect(mouse_left_handed, "toggled", G_CALLBACK(on_left_handed_toggle), NULL);
g_signal_connect(mouse_dclick, "value-changed", G_CALLBACK(on_mouse_dclick_changed), NULL);
set_range_stops(kb_delay, 10);
g_signal_connect(kb_delay, "value-changed", G_CALLBACK(on_kb_range_changed), &delay);
set_range_stops(kb_interval, 10);
g_signal_connect(kb_interval, "value-changed", G_CALLBACK(on_kb_range_changed), &interval);
g_signal_connect(kb_beep, "toggled", G_CALLBACK(on_kb_beep_toggle), NULL);
g_signal_connect(kb_layout, "clicked", G_CALLBACK(on_kb_layout_clicked), NULL);
if( gtk_dialog_run( (GtkDialog*)dlg ) == GTK_RESPONSE_OK )
{
gsize len;
if(!g_key_file_load_from_file(kf, user_config_file, G_KEY_FILE_KEEP_COMMENTS|G_KEY_FILE_KEEP_TRANSLATIONS, NULL))
{
/* the user config file doesn't exist, create its parent dir */
len = strlen(user_config_file) - strlen("/desktop.conf");
user_config_file[len] = '\0';
g_debug("user_config_file = %s", user_config_file);
g_mkdir_with_parents(user_config_file, 0700);
user_config_file[len] = '/';
g_key_file_load_from_dirs(kf, rel_path, (const char**)g_get_system_config_dirs(), NULL,
G_KEY_FILE_KEEP_COMMENTS|G_KEY_FILE_KEEP_TRANSLATIONS, NULL);
}
g_free(rel_path);
g_key_file_set_integer(kf, "Mouse", "AccFactor", accel);
g_key_file_set_integer(kf, "Mouse", "AccThreshold", threshold);
g_key_file_set_integer(kf, "Mouse", "LeftHanded", !!left_handed);
g_key_file_set_integer(kf, "Keyboard", "Delay", delay);
g_key_file_set_integer(kf, "Keyboard", "Interval", interval);
g_key_file_set_integer(kf, "Keyboard", "Beep", !!beep);
str = g_key_file_to_data(kf, &len, NULL);
g_file_set_contents(user_config_file, str, len, NULL);
g_free(str);
/* ask the settigns daemon to reload */
/* FIXME: is this needed? */
/* g_spawn_command_line_sync("lxde-settings-daemon reload", NULL, NULL, NULL, NULL); */
/* also save settings into autostart file for non-lxsession sessions */
g_free(user_config_file);
rel_path = g_build_filename(g_get_user_config_dir(), "autostart", NULL);
user_config_file = g_build_filename(rel_path, "LXinput-setup.desktop", NULL);
if (g_mkdir_with_parents(rel_path, 0755) == 0)
{
str = g_strdup_printf("[Desktop Entry]\n"
"Type=Application\n"
"Name=%s\n"
"Comment=%s\n"
"NoDisplay=true\n"
"Exec=sh -c 'xset m %d/10 %d r rate %d %d b %s'\n"
"NotShowIn=GNOME;KDE;XFCE;\n",
_("LXInput autostart"),
_("Setup keyboard and mouse using settings done in LXInput"),
/* FIXME: how to setup left-handed mouse? */
accel, threshold, delay, interval,
beep ? "on" : "off");
g_file_set_contents(user_config_file, str, -1, NULL);
g_free(str);
}
}
else
{
/* restore to original settings */
/* keyboard */
delay = old_delay;
interval = old_interval;
beep = old_beep;
XkbSetAutoRepeatRate(GDK_DISPLAY_XDISPLAY(gdk_display_get_default()), XkbUseCoreKbd, delay, interval);
/* FIXME: beep? */
/* mouse */
accel = old_accel;
threshold = old_threshold;
left_handed = old_left_handed;
XChangePointerControl(GDK_DISPLAY_XDISPLAY(gdk_display_get_default()), True, True,
accel, 10, threshold);
set_left_handed_mouse();
set_dclick_time (old_dclick);
}
gtk_widget_destroy( dlg );
g_free( file );
g_key_file_free( kf );
g_free(user_config_file);
return 0;
}
void
luaH_add_paths(lua_State *L, const gchar *config_dir)
{
lua_getglobal(L, "package");
if(LUA_TTABLE != lua_type(L, 1)) {
warn("package is not a table");
return;
}
lua_getfield(L, 1, "path");
if(LUA_TSTRING != lua_type(L, 2)) {
warn("package.path is not a string");
lua_pop(L, 1);
return;
}
/* compile list of package search paths */
GPtrArray *paths = g_ptr_array_new_with_free_func(g_free);
#if DEVELOPMENT_PATHS
/* allows for testing luakit in the project directory */
g_ptr_array_add(paths, g_strdup("./lib"));
g_ptr_array_add(paths, g_strdup("./config"));
#endif
/* add luakit install path */
g_ptr_array_add(paths, g_build_filename(LUAKIT_INSTALL_PATH, "lib", NULL));
/* add users config dir (see: XDG_CONFIG_DIR) */
if (config_dir)
g_ptr_array_add(paths, g_strdup(config_dir));
/* add system config dirs (see: XDG_CONFIG_DIRS) */
const gchar* const *config_dirs = g_get_system_config_dirs();
for (; *config_dirs; config_dirs++)
g_ptr_array_add(paths, g_build_filename(*config_dirs, "luakit", NULL));
const gchar *path;
for (guint i = 0; i < paths->len; i++) {
path = paths->pdata[i];
/* Search for file */
lua_pushliteral(L, ";");
lua_pushstring(L, path);
lua_pushliteral(L, "/?.lua");
lua_concat(L, 3);
/* Search for lib */
lua_pushliteral(L, ";");
lua_pushstring(L, path);
lua_pushliteral(L, "/?/init.lua");
lua_concat(L, 3);
/* concat with package.path */
lua_concat(L, 3);
}
g_ptr_array_free(paths, TRUE);
/* package.path = "concatenated string" */
lua_setfield(L, 1, "path");
/* remove package module from stack */
lua_pop(L, 1);
}
VCardEmulError
vcard_emul_init(const VCardEmulOptions *options)
{
SECStatus rv;
PRBool ret, has_readers = PR_FALSE;
VReader *vreader;
VReaderEmul *vreader_emul;
SECMODListLock *module_lock;
SECMODModuleList *module_list;
SECMODModuleList *mlp;
int i;
if (vcard_emul_init_called) {
return VCARD_EMUL_INIT_ALREADY_INITED;
}
vcard_emul_init_called = 1;
vreader_init();
vevent_queue_init();
if (options == NULL) {
options = &default_options;
}
/* first initialize NSS */
if (options->nss_db) {
rv = NSS_Init(options->nss_db);
} else {
gchar *path;
#ifndef _WIN32
path = g_strdup("/etc/pki/nssdb");
#else
if (g_get_system_config_dirs() == NULL ||
g_get_system_config_dirs()[0] == NULL) {
return VCARD_EMUL_FAIL;
}
path = g_build_filename(
g_get_system_config_dirs()[0], "pki", "nssdb", NULL);
#endif
rv = NSS_Init(path);
g_free(path);
}
if (rv != SECSuccess) {
return VCARD_EMUL_FAIL;
}
/* Set password callback function */
PK11_SetPasswordFunc(vcard_emul_get_password);
/* set up soft cards emulated by software certs rather than physical cards
* */
for (i = 0; i < options->vreader_count; i++) {
int j;
int cert_count;
unsigned char **certs;
int *cert_len;
VCardKey **keys;
PK11SlotInfo *slot;
slot = PK11_FindSlotByName(options->vreader[i].name);
if (slot == NULL) {
continue;
}
vreader_emul = vreader_emul_new(slot, options->vreader[i].card_type,
options->vreader[i].type_params);
vreader = vreader_new(options->vreader[i].vname, vreader_emul,
vreader_emul_delete);
vreader_add_reader(vreader);
cert_count = options->vreader[i].cert_count;
ret = vcard_emul_alloc_arrays(&certs, &cert_len, &keys,
options->vreader[i].cert_count);
if (ret == PR_FALSE) {
continue;
}
cert_count = 0;
for (j = 0; j < options->vreader[i].cert_count; j++) {
/* we should have a better way of identifying certs than by
* nickname here */
CERTCertificate *cert = PK11_FindCertFromNickname(
options->vreader[i].cert_name[j],
NULL);
if (cert == NULL) {
continue;
}
certs[cert_count] = cert->derCert.data;
cert_len[cert_count] = cert->derCert.len;
keys[cert_count] = vcard_emul_make_key(slot, cert);
/* this is safe because the key is still holding a cert reference */
CERT_DestroyCertificate(cert);
cert_count++;
}
if (cert_count) {
VCard *vcard = vcard_emul_make_card(vreader, certs, cert_len,
keys, cert_count);
vreader_insert_card(vreader, vcard);
vcard_emul_init_series(vreader, vcard);
/* allow insertion and removal of soft cards */
vreader_emul->saved_vcard = vcard_reference(vcard);
vcard_free(vcard);
vreader_free(vreader);
has_readers = PR_TRUE;
}
g_free(certs);
g_free(cert_len);
g_free(keys);
}
/* if we aren't suppose to use hw, skip looking up hardware tokens */
if (!options->use_hw) {
nss_emul_init = has_readers;
return has_readers ? VCARD_EMUL_OK : VCARD_EMUL_FAIL;
}
/* make sure we have some PKCS #11 module loaded */
module_lock = SECMOD_GetDefaultModuleListLock();
module_list = SECMOD_GetDefaultModuleList();
SECMOD_GetReadLock(module_lock);
for (mlp = module_list; mlp; mlp = mlp->next) {
SECMODModule *module = mlp->module;
if (module_has_removable_hw_slots(module)) {
break;
}
}
SECMOD_ReleaseReadLock(module_lock);
/* now examine all the slots, finding which should be readers */
/* We should control this with options. For now we mirror out any
* removable hardware slot */
default_card_type = options->hw_card_type;
default_type_params = g_strdup(options->hw_type_params);
SECMOD_GetReadLock(module_lock);
for (mlp = module_list; mlp; mlp = mlp->next) {
SECMODModule *module = mlp->module;
/* Ignore the internal module */
if (module == NULL || module == SECMOD_GetInternalModule()) {
continue;
}
for (i = 0; i < module->slotCount; i++) {
PK11SlotInfo *slot = module->slots[i];
/* only map removable HW slots */
if (slot == NULL || !PK11_IsRemovable(slot) || !PK11_IsHW(slot)) {
continue;
}
if (strcmp("E-Gate 0 0", PK11_GetSlotName(slot)) == 0) {
/*
* coolkey <= 1.1.0-20 emulates this reader if it can't find
* any hardware readers. This causes problems, warn user of
* problems.
*/
fprintf(stderr, "known bad coolkey version - see "
"https://bugzilla.redhat.com/show_bug.cgi?id=802435\n");
continue;
}
vreader_emul = vreader_emul_new(slot, options->hw_card_type,
options->hw_type_params);
vreader = vreader_new(PK11_GetSlotName(slot), vreader_emul,
vreader_emul_delete);
vreader_add_reader(vreader);
if (PK11_IsPresent(slot)) {
VCard *vcard;
vcard = vcard_emul_mirror_card(vreader);
vreader_insert_card(vreader, vcard);
vcard_emul_init_series(vreader, vcard);
vcard_free(vcard);
}
}
vcard_emul_new_event_thread(module);
}
SECMOD_ReleaseReadLock(module_lock);
nss_emul_init = PR_TRUE;
return VCARD_EMUL_OK;
}
void
luaH_init(void)
{
lua_State *L;
static const struct luaL_reg luakit_lib[] = {
{ "quit", luaH_quit },
{ "add_signal", luaH_luakit_add_signal },
{ "remove_signal", luaH_luakit_remove_signal },
{ "emit_signal", luaH_luakit_emit_signal },
{ "__index", luaH_luakit_index },
{ "__newindex", luaH_luakit_newindex },
{ NULL, NULL }
};
/* Lua VM init */
L = globalconf.L = luaL_newstate();
/* Set panic fuction */
lua_atpanic(L, luaH_panic);
/* Set error handling function */
lualib_dofunction_on_error = luaH_dofunction_on_error;
luaL_openlibs(L);
luaH_fixups(L);
luaH_object_setup(L);
/* Export luakit lib */
luaH_openlib(L, "luakit", luakit_lib, luakit_lib);
/* Export widget */
widget_class_setup(L);
/* add Lua search paths */
lua_getglobal(L, "package");
if(LUA_TTABLE != lua_type(L, 1)) {
warn("package is not a table");
return;
}
lua_getfield(L, 1, "path");
if(LUA_TSTRING != lua_type(L, 2)) {
warn("package.path is not a string");
lua_pop(L, 1);
return;
}
/* compile list of package search paths */
GPtrArray *paths = g_ptr_array_new_with_free_func(g_free);
#if DEVELOPMENT_PATHS
/* allows for testing luakit in the project directory */
g_ptr_array_add(paths, g_strdup("./lib"));
g_ptr_array_add(paths, g_strdup("./config"));
#endif
/* add users config dir (see: XDG_CONFIG_DIR) */
g_ptr_array_add(paths, g_strdup(globalconf.config_dir));
/* add system config dirs (see: XDG_CONFIG_DIRS) */
const gchar* const *config_dirs = g_get_system_config_dirs();
for (; *config_dirs; config_dirs++)
g_ptr_array_add(paths, g_build_filename(*config_dirs, "luakit", NULL));
/* add luakit install path */
g_ptr_array_add(paths, g_build_filename(LUAKIT_INSTALL_PATH, "lib", NULL));
for (gpointer *path = paths->pdata; *path; path++) {
lua_pushliteral(L, ";");
lua_pushstring(L, *path);
lua_pushliteral(L, "/?.lua");
lua_concat(L, 3);
lua_pushliteral(L, ";");
lua_pushstring(L, *path);
lua_pushliteral(L, "/?/init.lua");
lua_concat(L, 3);
/* concat with package.path */
lua_concat(L, 3);
}
g_ptr_array_free(paths, TRUE);
/* package.path = "concatenated string" */
lua_setfield(L, 1, "path");
}
gethostname(hostname,256);
g_assert(!strcmp(string,hostname));
s = g_get_home_dir ();
g_assert(!strcmp(s,"C:\\Private\\e000002c") && "Wrong value for g_get_home_dir()");
s = g_get_user_data_dir ();
g_assert(!strcmp(s,"C:\\Private\\e000002c"));
s = g_get_user_config_dir ();
g_assert(!strcmp(s,"C:\\Private\\e000002c"));
s = g_get_user_cache_dir ();
g_assert(!strcmp(s,"C:\\Private\\e000002c"));
sv = (gchar **) g_get_system_data_dirs ();
g_assert(!strcmp(sv[0],"C:\\Private\\e000002c"));
g_assert(sv[1] == NULL);
sv = (gchar **) g_get_system_config_dirs ();
g_assert(!strcmp(sv[0],"C:\\Private\\e000002c"));
g_assert(sv[1] == NULL);
string = (char *)g_get_tmp_dir ();
g_assert(!strcmp(string,"C:\\Private\\e000002c\\tmp") && "Wrong value for g_get_tmp_dir()");
sv = (gchar **) g_get_language_names ();
g_assert(!strcmp(sv[0],"C"));
g_assert(!strcmp(sv[1],"C"));
g_assert(sv[2] == NULL);
/* type sizes */
TEST (NULL, sizeof (gint8) == 1);
TEST (NULL, sizeof (gint16) == 2);
static VALUE
rg_s_system_config_dirs(G_GNUC_UNUSED VALUE self)
{
return STRV2RVAL((const gchar **)g_get_system_config_dirs());
}
static DeskmenuObject
*check_file_cache (Deskmenu *deskmenu, gchar *filename)
{
DeskmenuObject *dm_object;
gchar *user_default = g_build_path (G_DIR_SEPARATOR_S,
g_get_user_config_dir (),
"compiz", "boxmenu", "menu.xml", NULL);
//TODO: add a size column to cache for possible autorefresh
g_print("Checking cache...\n");
if (strlen(filename) == 0) {
filename = g_strdup(user_default);
}
if (strcmp(filename, user_default) == 0)
{
g_print("Looking up default menu...\n");
/*
set default filename to be [configdir]/compiz/boxmenu/menu.xml
*/
gboolean success = FALSE;
if (!g_file_test(filename, G_FILE_TEST_EXISTS))
{
g_print("Getting default system menu...\n");
const gchar* const *cursor = g_get_system_config_dirs ();
gchar *path = NULL;
while (*cursor)
{
g_free (path);
path = g_strdup (*cursor);
filename = g_build_path (G_DIR_SEPARATOR_S, path,
"compiz", "boxmenu", "menu.xml", NULL);
if (g_file_test(filename, G_FILE_TEST_EXISTS))
{
if (g_hash_table_lookup(deskmenu->file_cache, filename) == NULL)
{
g_hash_table_insert (deskmenu->file_cache, g_strdup(filename), deskmenu_parse_file(filename));
g_print("Prepared default system menu!\n");
}
else
{
g_print("Retrieving default system menu!\n");
}
g_free (path);
success = TRUE;
break;
}
cursor++;
}
}
else
{
if (g_hash_table_lookup(deskmenu->file_cache, user_default) == NULL)
{
if (g_file_test(filename, G_FILE_TEST_EXISTS))
{
g_print("Preparing default menu!\n");
g_hash_table_insert (deskmenu->file_cache, g_strdup(filename), deskmenu_parse_file(filename));
success = TRUE;
}
}
else
{
g_print("Retrieving cached default user menu...\n");
success = TRUE;
}
}
if (!success)
{
g_printerr ("Couldn't find a menu file...\n");
exit (1);
}
}
else {
if (g_hash_table_lookup(deskmenu->file_cache, filename) == NULL)
{
if (g_file_test(filename, G_FILE_TEST_EXISTS))
{
g_print("Preparing new non-default menu...\n");
g_hash_table_insert (deskmenu->file_cache, g_strdup(filename), deskmenu_parse_file(filename));
}
else
{
if (g_hash_table_lookup(deskmenu->file_cache, user_default) != NULL)
{
g_print("Couldn't find specified file, loading default...\n");
filename = user_default;
}
else
{
g_printerr ("Couldn't find a menu file...\n");
exit (1);
}
}
}
}
dm_object = g_hash_table_lookup (deskmenu->file_cache, filename);
g_printf("Done loading %s!\n", filename);
return dm_object;
}
