Skip to content
Snippets Groups Projects
Select Git revision
  • master default protected
  • release/202005
  • release/202001
  • release/201912
  • release/201911
  • release/releaseWindowsTestOne
  • release/windowsReleaseTest
  • release/releaseTest
  • release/releaseWindowsTest
  • release/201910
  • release/qt/201910
  • release/windows-test/201910
  • release/201908
  • release/201906
  • release/201905
  • release/201904
  • release/201903
  • release/201902
  • release/201901
  • release/201812
  • 4.0.0
  • 2.2.0
  • 2.1.0
  • 2.0.1
  • 2.0.0
  • 1.4.1
  • 1.4.0
  • 1.3.0
  • 1.2.0
  • 1.1.0
30 results

eel-gconf-extensions.c

Blame
  • Code owners
    Assign users and groups as approvers for specific file changes. Learn more.
    eel-gconf-extensions.c 13.88 KiB
    /* -*- Mode: C; indent-tabs-mode: t; c-basic-offset: 8; tab-width: 8 -*- */
    
    /* eel-gconf-extensions.c - Stuff to make GConf easier to use.
    
       Copyright (C) 2000, 2001 Eazel, Inc.
    
       The Gnome Library is free software; you can redistribute it and/or
       modify it under the terms of the GNU Library General Public License as
       published by the Free Software Foundation; either version 2 of the
       License, or (at your option) any later version.
    
       The Gnome Library is distributed in the hope that it will be useful,
       but WITHOUT ANY WARRANTY; without even the implied warranty of
       MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
       Library General Public License for more details.
    
       You should have received a copy of the GNU Library General Public
       License along with the Gnome Library; see the file COPYING.LIB.  If not,
       write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
       Boston, MA 02111-1307, USA.
    
       Authors: Ramiro Estrugo <ramiro@eazel.com>
    */
    
    #include "config.h"
    #include <glib/gi18n.h>
    #include <stdlib.h>
    #include "eel-gconf-extensions.h"
    
    #include <gconf/gconf-client.h>
    #include <gconf/gconf.h>
    #include <gtk/gtk.h>
    #include <glib.h>
    
    static GConfClient *global_gconf_client = NULL;
    
    void eel_gconf_global_client_free(void)
    {
        if (global_gconf_client == NULL)
            return;
    
        g_object_unref(G_OBJECT(global_gconf_client));
        global_gconf_client = NULL;
    }
    
    /* Public */
    GConfClient *
    eel_gconf_client_get_global(void)
    {
        /* Initialize gconf if needed */
        if (!gconf_is_initialized()) {
            char *argv[] = { "eel-preferences", NULL };
            GError *error = NULL;
            char *teststr;
    
            if (!gconf_init(1, argv, &error)) {
                if (eel_gconf_handle_error(&error)) {
                    return NULL;
                }
            }
    
            /* check if gconf schemas are working */
            teststr = gconf_client_get_string(eel_gconf_client_get_global(),
                                              "/apps/gpdf/gconf_test", NULL);
    
            if (!teststr) {
                GtkWidget *dialog;
                dialog = gtk_message_dialog_new(NULL,
                                                GTK_DIALOG_MODAL,
                                                GTK_MESSAGE_ERROR,
                                                GTK_BUTTONS_OK,
                                                _("Cannot find a schema for gpdf preferences. \n"
                                                  "Check your gconf setup, look at gpdf FAQ for \n"
                                                  "more info"));
                gtk_dialog_run(GTK_DIALOG(dialog));
                exit(EXIT_SUCCESS);
            } else
                g_free(teststr);
        }
    
        if (global_gconf_client == NULL)
            global_gconf_client = gconf_client_get_default();
    
        return global_gconf_client;
    }
    
    gboolean
    eel_gconf_handle_error(GError **error)
    {
        g_return_val_if_fail(error != NULL, FALSE);
    
        if (*error != NULL) {
            g_warning("GConf error: %s\n", (*error)->message);
            g_error_free(*error);
            *error = NULL;
    
            return TRUE;
        }
    
        return FALSE;
    }
    
    void
    eel_gconf_set_boolean(const char *key,
                          gboolean boolean_value)
    {
        GConfClient *client;
        GError *error = NULL;
    
        g_return_if_fail(key != NULL);
    
        client = eel_gconf_client_get_global();
        g_return_if_fail(client != NULL);
    
        gconf_client_set_bool(client, key, boolean_value, &error);
        eel_gconf_handle_error(&error);
    }
    
    gboolean
    eel_gconf_get_boolean(const char *key)
    {
        gboolean result;
        GConfClient *client;
        GError *error = NULL;
    
        g_return_val_if_fail(key != NULL, FALSE);
    
        client = eel_gconf_client_get_global();
        g_return_val_if_fail(client != NULL, FALSE);
    
        result = gconf_client_get_bool(client, key, &error);
    
        if (eel_gconf_handle_error(&error)) {
            result = FALSE;
        }
    
        return result;
    }
    
    void
    eel_gconf_set_integer(const char *key,
                          int int_value)
    {
        GConfClient *client;
        GError *error = NULL;
    
        g_return_if_fail(key != NULL);
    
        client = eel_gconf_client_get_global();
        g_return_if_fail(client != NULL);
    
        gconf_client_set_int(client, key, int_value, &error);
        eel_gconf_handle_error(&error);
    }
    
    int
    eel_gconf_get_integer(const char *key)
    {
        int result;
        GConfClient *client;
        GError *error = NULL;
    
        g_return_val_if_fail(key != NULL, 0);
    
        client = eel_gconf_client_get_global();
        g_return_val_if_fail(client != NULL, 0);
    
        result = gconf_client_get_int(client, key, &error);
    
        if (eel_gconf_handle_error(&error)) {
            result = 0;
        }
    
        return result;
    }
    
    void
    eel_gconf_set_float(const char *key,
                        gfloat float_value)
    {
        GConfClient *client;
        GError *error = NULL;
    
        g_return_if_fail(key != NULL);
    
        client = eel_gconf_client_get_global();
        g_return_if_fail(client != NULL);
    
        gconf_client_set_float(client, key, float_value, &error);
        eel_gconf_handle_error(&error);
    }
    
    gfloat
    eel_gconf_get_float(const char *key)
    {
        gfloat result;
        GConfClient *client;
        GError *error = NULL;
    
        g_return_val_if_fail(key != NULL, 0);
    
        client = eel_gconf_client_get_global();
        g_return_val_if_fail(client != NULL, 0);
    
        result = gconf_client_get_float(client, key, &error);
    
        if (eel_gconf_handle_error(&error)) {
            result = 0;
        }
    
        return result;
    }
    
    void
    eel_gconf_set_string(const char *key,
                         const char *string_value)
    {
        GConfClient *client;
        GError *error = NULL;
    
        g_return_if_fail(key != NULL);
        g_return_if_fail(string_value != NULL);
    
        client = eel_gconf_client_get_global();
        g_return_if_fail(client != NULL);
    
        gconf_client_set_string(client, key, string_value, &error);
        eel_gconf_handle_error(&error);
    }
    
    void
    eel_gconf_unset(const char *key)
    {
        GConfClient *client;
        GError *error = NULL;
    
        g_return_if_fail(key != NULL);
    
        client = eel_gconf_client_get_global();
        g_return_if_fail(client != NULL);
    
        gconf_client_unset(client, key, &error);
        eel_gconf_handle_error(&error);
    }
    
    char *
    eel_gconf_get_string(const char *key)
    {
        char *result;
        GConfClient *client;
        GError *error = NULL;
    
        g_return_val_if_fail(key != NULL, NULL);
    
        client = eel_gconf_client_get_global();
        g_return_val_if_fail(client != NULL, NULL);
    
        result = gconf_client_get_string(client, key, &error);
    
        if (eel_gconf_handle_error(&error)) {
            result = g_strdup("");
        }
    
        return result;
    }
    
    void
    eel_gconf_set_string_list(const char *key,
                              const GSList *slist)
    {
        GConfClient *client;
        GError *error;
    
        g_return_if_fail(key != NULL);
    
        client = eel_gconf_client_get_global();
        g_return_if_fail(client != NULL);
    
        error = NULL;
        gconf_client_set_list(client, key, GCONF_VALUE_STRING,
                              /* Need cast cause of GConf api bug */
                              (GSList *) slist,
                              &error);
        eel_gconf_handle_error(&error);
    }
    
    GSList *
    eel_gconf_get_string_list(const char *key)
    {
        GSList *slist;
        GConfClient *client;
        GError *error;
    
        g_return_val_if_fail(key != NULL, NULL);
    
        client = eel_gconf_client_get_global();
        g_return_val_if_fail(client != NULL, NULL);
    
        error = NULL;
        slist = gconf_client_get_list(client, key, GCONF_VALUE_STRING, &error);
    
        if (eel_gconf_handle_error(&error)) {
            slist = NULL;
        }
    
        return slist;
    }
    
    /* This code wasn't part of the original eel-gconf-extensions.c */
    void
    eel_gconf_set_integer_list(const char *key,
                               const GSList *slist)
    {
        GConfClient *client;
        GError *error;
    
        g_return_if_fail(key != NULL);
    
        client = eel_gconf_client_get_global();
        g_return_if_fail(client != NULL);
    
        error = NULL;
        gconf_client_set_list(client, key, GCONF_VALUE_INT,
                              /* Need cast cause of GConf api bug */
                              (GSList *) slist,
                              &error);
        eel_gconf_handle_error(&error);
    }
    
    GSList *
    eel_gconf_get_integer_list(const char *key)
    {
        GSList *slist;
        GConfClient *client;
        GError *error;
    
        g_return_val_if_fail(key != NULL, NULL);
    
        client = eel_gconf_client_get_global();
        g_return_val_if_fail(client != NULL, NULL);
    
        error = NULL;
        slist = gconf_client_get_list(client, key, GCONF_VALUE_INT, &error);
    
        if (eel_gconf_handle_error(&error)) {
            slist = NULL;
        }
    
        return slist;
    }
    /* End of added code */
    
    gboolean
    eel_gconf_is_default(const char *key)
    {
        gboolean result;
        GConfValue *value;
        GError *error = NULL;
    
        g_return_val_if_fail(key != NULL, FALSE);
    
        value = gconf_client_get_without_default(eel_gconf_client_get_global(), key, &error);
    
        if (eel_gconf_handle_error(&error)) {
            if (value != NULL) {
                gconf_value_free(value);
            }
    
            return FALSE;
        }
    
        result = (value == NULL);
    
        if (value != NULL) {
            gconf_value_free(value);
        }
    
    
        return result;
    }
    
    gboolean
    eel_gconf_monitor_add(const char *directory)
    {
        GError *error = NULL;
        GConfClient *client;
    
        g_return_val_if_fail(directory != NULL, FALSE);
    
        client = eel_gconf_client_get_global();
        g_return_val_if_fail(client != NULL, FALSE);
    
        gconf_client_add_dir(client,
                             directory,
                             GCONF_CLIENT_PRELOAD_NONE,
                             &error);
    
        if (eel_gconf_handle_error(&error)) {
            return FALSE;
        }
    
        return TRUE;
    }
    
    gboolean
    eel_gconf_monitor_remove(const char *directory)
    {
        GError *error = NULL;
        GConfClient *client;
    
        if (directory == NULL) {
            return FALSE;
        }
    
        client = eel_gconf_client_get_global();
        g_return_val_if_fail(client != NULL, FALSE);
    
        gconf_client_remove_dir(client,
                                directory,
                                &error);
    
        if (eel_gconf_handle_error(&error)) {
            return FALSE;
        }
    
        return TRUE;
    }
    
    void
    eel_gconf_suggest_sync(void)
    {
        GConfClient *client;
        GError *error = NULL;
    
        client = eel_gconf_client_get_global();
        g_return_if_fail(client != NULL);
    
        gconf_client_suggest_sync(client, &error);
        eel_gconf_handle_error(&error);
    }
    
    GConfValue*
    eel_gconf_get_value(const char *key)
    {
        GConfValue *value = NULL;
        GConfClient *client;
        GError *error = NULL;
    
        g_return_val_if_fail(key != NULL, NULL);
    
        client = eel_gconf_client_get_global();
        g_return_val_if_fail(client != NULL, NULL);
    
        value = gconf_client_get(client, key, &error);
    
        if (eel_gconf_handle_error(&error)) {
            if (value != NULL) {
                gconf_value_free(value);
                value = NULL;
            }
        }
    
        return value;
    }
    
    void
    eel_gconf_set_value(const char *key, const GConfValue *value)
    {
        GConfClient *client;
        GError *error = NULL;
    
        g_return_if_fail(key != NULL);
    
        client = eel_gconf_client_get_global();
        g_return_if_fail(client != NULL);
    
        gconf_client_set(client, key, value, &error);
    
        if (eel_gconf_handle_error(&error)) {
            return;
        }
    }
    
    gboolean
    eel_gconf_key_exists(const char *key)
    {
        GConfValue *value = NULL;
        GConfClient *client;
        GError *error = NULL;
        gboolean error_occurred;
        gboolean value_found;
    
        g_return_val_if_fail(key != NULL, FALSE);
    
        client = eel_gconf_client_get_global();
        g_return_val_if_fail(client != NULL, FALSE);
    
        value = gconf_client_get(client, key, &error);
    
        value_found = (value != NULL);
        error_occurred = (error != NULL);
    
        eel_gconf_value_free(value);
    
        if (error != NULL) {
            g_error_free(error);
        }
    
        return (!error_occurred && value_found);
    }
    
    void
    eel_gconf_value_free(GConfValue *value)
    {
        if (value == NULL) {
            return;
        }
    
        gconf_value_free(value);
    }
    
    guint
    eel_gconf_notification_add(const char *key,
                               GConfClientNotifyFunc notification_callback,
                               gpointer callback_data)
    {
        guint notification_id;
        GConfClient *client;
        GError *error = NULL;
    
        g_return_val_if_fail(key != NULL, EEL_GCONF_UNDEFINED_CONNECTION);
        g_return_val_if_fail(notification_callback != NULL, EEL_GCONF_UNDEFINED_CONNECTION);
    
        client = eel_gconf_client_get_global();
        g_return_val_if_fail(client != NULL, EEL_GCONF_UNDEFINED_CONNECTION);
    
        notification_id = gconf_client_notify_add(client,
                          key,
                          notification_callback,
                          callback_data,
                          NULL,
                          &error);
    
        if (eel_gconf_handle_error(&error)) {
            if (notification_id != EEL_GCONF_UNDEFINED_CONNECTION) {
                gconf_client_notify_remove(client, notification_id);
                notification_id = EEL_GCONF_UNDEFINED_CONNECTION;
            }
        }
    
        return notification_id;
    }
    
    void
    eel_gconf_notification_remove(guint notification_id)
    {
        GConfClient *client;
    
        if (notification_id == EEL_GCONF_UNDEFINED_CONNECTION) {
            return;
        }
    
        client = eel_gconf_client_get_global();
        g_return_if_fail(client != NULL);
    
        gconf_client_notify_remove(client, notification_id);
    }
    
    /* Simple wrapper for eel_gconf_notifier_add which
     * adds the notifier id to the GList given as argument
     * so that a call to gpdf_notification_free can remove the notifiers
     */
    void
    gpdf_notification_add(const char *key,
                          GConfClientNotifyFunc notification_callback,
                          gpointer callback_data,
                          GList **notifiers)
    {
        guint id = 0;
    
        id = eel_gconf_notification_add(key,
                                        notification_callback,
                                        callback_data);
    
        if (notifiers != NULL) {
            *notifiers = g_list_append(*notifiers,
                                       GINT_TO_POINTER(id));
        }
    }
    
    /* Removes all the notifiers listed in notifiers */
    /* Frees the notifiers list */
    void
    gpdf_notification_remove(GList **notifiers)
    {
        g_list_foreach(*notifiers,
                       (GFunc) eel_gconf_notification_remove,
                       NULL);
        g_list_free(*notifiers);
        *notifiers = NULL;
    }