/* Notification callback for our label widgets that
* monitor the current value of a mateconf key. i.e.
* we are conceptually "configuring" the label widgets
*/
static void
configurable_widget_config_notify (MateConfClient *client,
guint cnxn_id,
MateConfEntry *entry,
gpointer user_data)
{
GtkWidget *label = user_data;
g_return_if_fail (GTK_IS_LABEL (label));
/* Note that value can be NULL (unset) or it can have
* the wrong type! Need to check that to survive
* mateconftool --break-key
*/
if (mateconf_entry_get_value (entry) == NULL)
{
gtk_label_set_text (GTK_LABEL (label), "");
}
else if (mateconf_entry_get_value (entry)->type == MATECONF_VALUE_STRING)
{
gtk_label_set_text (GTK_LABEL (label),
mateconf_value_get_string (mateconf_entry_get_value (entry)));
}
else
{
/* A real app would probably fall back to a reasonable default
* in this case, instead of putting funky stuff in the GUI.
*/
gtk_label_set_text (GTK_LABEL (label), "!type error!");
}
}
static void
model_key_changed (MateConfClient * client,
guint cnxn_id, MateConfEntry * entry, GtkBuilder * dialog)
{
set_model_text (WID ("xkb_model_pick"),
mateconf_entry_get_value (entry));
enable_disable_restoring (dialog);
}
static void
timeout_changed_cb (MateConfClient * client, guint id, MateConfEntry * entry, gpointer user_data)
{
HardDriveStatusTile *tile = HARD_DRIVE_STATUS_TILE (user_data);
HardDriveStatusTilePrivate *priv = HARD_DRIVE_STATUS_TILE_GET_PRIVATE (tile);
int timeout;
if (priv->update_timeout)
g_source_remove (priv->update_timeout);
timeout = mateconf_value_get_int (mateconf_entry_get_value (entry));
timeout = MAX (timeout, 1000);
priv->update_timeout = g_timeout_add (timeout, timeout_cb, tile);
}
static void
hash_lookup_defaults_func(gpointer key, gpointer value, gpointer user_data)
{
MateConfEntry *entry = value;
struct DefaultsLookupData* dld = user_data;
MateConfSources *sources = dld->sources;
const gchar** locales = dld->locales;
if (mateconf_entry_get_value(entry) == NULL)
{
if (mateconf_entry_get_schema_name(entry) != NULL)
{
MateConfValue *val;
val = mateconf_sources_query_value(sources,
mateconf_entry_get_schema_name(entry),
locales,
TRUE,
NULL,
NULL,
NULL,
NULL);
if (val != NULL &&
val->type == MATECONF_VALUE_SCHEMA)
{
MateConfValue* defval;
defval = mateconf_schema_steal_default_value (mateconf_value_get_schema(val));
mateconf_entry_set_value_nocopy (entry, defval);
mateconf_entry_set_is_default (entry, TRUE);
}
if (val)
mateconf_value_free(val);
}
}
}
static void
mate_panel_applet_locked_change_notify (MateConfClient *client,
guint cnxn_id,
MateConfEntry *entry,
GtkWidget *applet)
{
MateConfValue *value;
gboolean locked;
gboolean applet_locked;
AppletInfo *info;
PanelWidget *panel_widget;
g_assert (applet != NULL);
info = (AppletInfo *) g_object_get_data (G_OBJECT (applet),
"applet_info");
if (info == NULL)
return;
value = mateconf_entry_get_value (entry);
if (value == NULL || value->type != MATECONF_VALUE_BOOL)
return;
locked = mateconf_value_get_bool (value);
panel_widget = mate_panel_applet_get_panel_widget (info);
applet_locked = panel_widget_get_applet_locked (panel_widget,
info->widget);
if ((locked && applet_locked) || !(locked || applet_locked))
return;
mate_panel_applet_toggle_locked (info);
if (info->type == PANEL_OBJECT_APPLET)
mate_panel_applet_frame_sync_menu_state (MATE_PANEL_APPLET_FRAME (info->widget));
else
mate_panel_applet_recreate_menu (info);
}
static void
panel_addto_name_notify (MateConfClient *client,
guint cnxn_id,
MateConfEntry *entry,
PanelAddtoDialog *dialog)
{
MateConfValue *value;
const char *key;
const char *text = NULL;
key = panel_mateconf_basename (mateconf_entry_get_key (entry));
if (strcmp (key, "name"))
return;
value = mateconf_entry_get_value (entry);
if (value && value->type == MATECONF_VALUE_STRING)
text = mateconf_value_get_string (value);
if (text)
panel_addto_name_change (dialog, text);
}
static
gboolean
mateconf_tree_model_search_iter_foreach (GtkTreeModel *model, GtkTreePath *path,
GtkTreeIter *iter, gpointer data)
{
Node *node;
SearchIter *st;
gchar *found;
GSList *values, *list;
st = (SearchIter *) data;
if (st->searching == NULL) {
return TRUE;
}
if (st->res >= 1) {
gtk_widget_show (GTK_WIDGET (st->output_window));
}
while (gtk_events_pending ())
gtk_main_iteration ();
node = iter->user_data;
found = g_strrstr ((char*) node->path, (char*) st->pattern);
if (found != NULL) {
/* We found the pattern in the tree */
gchar *key = mateconf_tree_model_get_mateconf_path (MATECONF_TREE_MODEL (model), iter);
gedit_output_window_append_line (st->output_window, key, FALSE);
g_free (key);
st->res++;
return FALSE;
}
if (!st->search_keys && !st->search_values) {
return FALSE;
}
values = mateconf_client_all_entries (MATECONF_TREE_MODEL (model)->client, (const char*) node->path , NULL);
for (list = values; list; list = list->next) {
const gchar *key;
MateConfEntry *entry = list->data;
key = mateconf_entry_get_key (entry);
/* Search in the key names */
if (st->search_keys) {
found = g_strrstr (key, (char*) st->pattern);
if (found != NULL) {
/* We found the pattern in the final key name */
gedit_output_window_append_line (st->output_window, key, FALSE);
st->res++;
mateconf_entry_unref (entry);
/* After finding an entry continue the list to find other matches */
continue;
}
}
/* Search in the values */
if (st->search_values) {
const char *mateconf_string;
MateConfValue *mateconf_value = mateconf_entry_get_value (entry);
/* FIXME: We are only looking into strings... should we do in
* int's? */
if (mateconf_value != NULL && mateconf_value->type == MATECONF_VALUE_STRING)
mateconf_string = mateconf_value_get_string (mateconf_value);
else {
mateconf_entry_unref (entry);
continue;
}
found = g_strrstr (mateconf_string, (char*) st->pattern);
if (found != NULL) {
/* We found the pattern in the key value */
gedit_output_window_append_line (st->output_window, key, FALSE);
st->res++;
mateconf_entry_unref (entry);
continue;
}
}
mateconf_entry_unref (entry);
}
return FALSE;
}
GSList*
mateconf_sources_all_entries (MateConfSources* sources,
const gchar* dir,
const gchar** locales,
GError** err)
{
GList* tmp;
GHashTable* hash;
GSList* flattened;
gboolean first_pass = TRUE; /* as an optimization, don't bother
doing hash lookups on first source
*/
struct DefaultsLookupData dld = { NULL, NULL };
dld.sources = sources;
dld.locales = locales;
/* Empty MateConfSources, skip it */
if (sources->sources == NULL)
return NULL;
hash = g_hash_table_new(g_str_hash, g_str_equal);
tmp = sources->sources;
while (tmp != NULL)
{
MateConfSource* src;
GSList* pairs;
GSList* iter;
GError* error = NULL;
src = tmp->data;
pairs = mateconf_source_all_entries(src, dir, locales, &error);
iter = pairs;
/* On error, set error and bail */
if (error != NULL)
{
g_hash_table_foreach(hash, hash_destroy_entries_func, NULL);
g_hash_table_destroy(hash);
if (err)
{
g_return_val_if_fail(*err == NULL, NULL);
*err = error;
return NULL;
}
else
{
g_error_free(error);
return NULL;
}
}
/* Iterate over the list of entries, stuffing them in the hash
and setting their writability flag if they're new
*/
while (iter != NULL)
{
MateConfEntry* pair = iter->data;
MateConfEntry* previous;
gchar *full;
if (first_pass)
previous = NULL; /* Can't possibly be there. */
else
previous = g_hash_table_lookup(hash, pair->key);
if (previous != NULL)
{
if (mateconf_entry_get_value (previous) != NULL)
/* Discard this latest one */
;
else
{
/* Save the new value, previously we had an entry but no value */
mateconf_entry_set_value_nocopy (previous,
mateconf_entry_steal_value(pair));
/* As an efficiency hack, remember that
* entry->key is relative not absolute on the
* mateconfd side
*/
full = mateconf_concat_dir_and_key (dir, previous->key);
mateconf_entry_set_is_writable (previous,
key_is_writable (sources,
src,
full,
NULL));
g_free (full);
}
if (mateconf_entry_get_schema_name (previous) != NULL)
/* Discard this latest one */
;
else
{
/* Save the new schema name, previously we had an entry but no schema name*/
if (mateconf_entry_get_schema_name (pair) != NULL)
{
mateconf_entry_set_schema_name (previous,
mateconf_entry_get_schema_name (pair));
}
}
mateconf_entry_free(pair);
}
else
{
/* Save */
g_hash_table_insert(hash, pair->key, pair);
/* As an efficiency hack, remember that
* entry->key is relative not absolute on the
* mateconfd side
*/
full = mateconf_concat_dir_and_key (dir, pair->key);
mateconf_entry_set_is_writable (pair,
key_is_writable (sources,
src,
full,
NULL));
g_free (full);
}
iter = g_slist_next(iter);
}
/* All pairs are either stored or destroyed. */
g_slist_free(pairs);
first_pass = FALSE;
tmp = g_list_next(tmp);
}
flattened = NULL;
g_hash_table_foreach(hash, hash_lookup_defaults_func, &dld);
g_hash_table_foreach(hash, hash_listify_func, &flattened);
g_hash_table_destroy(hash);
return flattened;
}
