conf.c

Go to the documentation of this file.

/*
 * File Name: conf.c
 */

/*
 * This file is part of sysd.
 *
 * sysd is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 2 of the License, or
 * (at your option) any later version.
 *
 * sysd 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 General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <http://www.gnu.org/licenses/>.
 */

/**
 * Copyright (C) 2008 iRex Technologies B.V.
 * All rights reserved.
 */

//----------------------------------------------------------------------------
// Include Files
//----------------------------------------------------------------------------

#include "config.h"

// system include files, between < >
#include <glib.h>
#include <gconf/gconf-client.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

// ereader include files, between < >
#include <liberipc/eripc.h>

// local include files, between " "
#include "log.h"
#include "conf.h"
#include "connections.h"
#include "locales.h"
#include "i18n.h"
#include "ipc.h"
#include "wacom.h"

#define UNUSED(x) (void)(x)


//----------------------------------------------------------------------------
// Type Declarations
//----------------------------------------------------------------------------


//----------------------------------------------------------------------------
// Global Constants
//----------------------------------------------------------------------------

#define KEYS_SYSTEM                    KEYS_EREADER "/sys"
#define KEY_GLOBAL_LOCALE              KEYS_SYSTEM "/global/locale"
#define KEY_GLOBAL_TZ_OFFSET           KEYS_SYSTEM "/global/timezone_offset"
#define KEY_GLOBAL_LIST_LOCALES        KEYS_SYSTEM "/global/list_locales"
#define KEY_GLOBAL_LIST_LANGUAGES      KEYS_SYSTEM "/global/list_languages"
#define KEY_GLOBAL_FIRST_BOOT          KEYS_SYSTEM "/global/is_first_boot"
#define KEY_DISPLAY_ROTATION           KEYS_SYSTEM "/display/rotation"
#define KEY_SENSOR_USE_SOUND           KEYS_SYSTEM "/sensor/use_sound"
#define KEY_SENSOR_USE_LIGHT           KEYS_SYSTEM "/sensor/use_light"
#define KEY_SENSOR_USE_LOCK_LEFT       KEYS_SYSTEM "/sensor/use_lock_left"
#define KEY_SENSOR_USE_LOCK_RIGHT      KEYS_SYSTEM "/sensor/use_lock_right"
#define KEY_SENSOR_USE_LOCK_MIDDLE     KEYS_SYSTEM "/sensor/use_lock_middle"
#define KEY_POWER_IDLE_MODE             KEYS_SYSTEM "/power/idle_mode"
#define KEY_POWER_MIN_STANDBY          KEYS_SYSTEM "/power/min_standby"
#define KEY_POWER_USE_STYLUS           KEYS_SYSTEM "/power/use_stylus"
#define KEY_POWER_STANDBY_IF_PLUGGED    KEYS_SYSTEM "/power/standby_if_plugged"
#define KEY_FLIGHTMODE_MODE             KEYS_SYSTEM "/flightmode/flightmode_mode"
#define KEY_PAGETURN_INVERTED           KEYS_SYSTEM "/flipbar/pageturn_inverted"
#define KEY_INDEX_WITH_METADATA         KEYS_SYSTEM "/index/add_with_metadata"
 
#define KEY_UP_DOWN_FOCUS_BEHAVIOR      "/desktop/poky/interface/gtk-up-down-focus-behavior"

#define MINIMUM_STANDBY_MIN         1
 
 
//----------------------------------------------------------------------------
// Static Variables
//----------------------------------------------------------------------------

static GConfClient                  *g_gconfclient  = NULL;
static gboolean                      g_number_of_langages = FALSE;


//============================================================================
// Local Function Definition
//============================================================================

static void event_gconf_value_changed(GConfClient *client,
                                      guint cnxn_id,
                                      GConfEntry *entry,
                                      gpointer user_data);
static void set_startup_defaults(void);
static void update_installed_locales(void);

//============================================================================
// Functions Implementation
//============================================================================

void conf_set_services(void)
{
    LOGPRINTF("entry");

    g_type_init();
    g_gconfclient = gconf_client_get_default();
    if (g_gconfclient==NULL) 
    {
        ERRORPRINTF("Failed to connect to GConf");
        exit(1);
    }   
    
    gconf_client_add_dir(g_gconfclient,
                         KEYS_SYSTEM,
                         GCONF_CLIENT_PRELOAD_NONE,
                         NULL);

    gconf_client_notify_add(g_gconfclient,
                            KEYS_SYSTEM,
                            event_gconf_value_changed,
                            NULL,
                            NULL,
                            NULL);
    
    // check locales/languages available on system
    update_installed_locales();
    
    // initialize system settings from startup configuration
    set_startup_defaults();
}


gboolean conf_get_first_boot(void)
{
    LOGPRINTF("entry");

    gboolean     first_boot = FALSE;
    GError       *error     = NULL;
    
    first_boot = gconf_client_get_bool(g_gconfclient, KEY_GLOBAL_FIRST_BOOT, &error);
    if (error)
    {
        WARNPRINTF("error fetching GConf key %s: %s", KEY_GLOBAL_FIRST_BOOT, error->message);
        g_error_free(error);
    }   
    LOGPRINTF("return: %d", first_boot);
    
    return first_boot;
}


void conf_set_first_boot(gboolean first_boot)
{
    LOGPRINTF("entry");

    GError       *error     = NULL;
    
    gconf_client_set_bool(g_gconfclient, KEY_GLOBAL_FIRST_BOOT, first_boot, &error);
    if (error)
    {
        WARNPRINTF("error writing GConf key %s: %s", KEY_GLOBAL_FIRST_BOOT, error->message);
        g_error_free(error);
    }   
}


void conf_disabled_sensor_lock(void)
{
    LOGPRINTF("entry");
    
    gboolean locked;
    GError   *error = NULL;

    locked = gconf_client_get_bool(g_gconfclient, KEY_SENSOR_USE_LOCK_LEFT, &error);
    if (!error && !locked)
    {
        locked = gconf_client_get_bool(g_gconfclient, KEY_SENSOR_USE_LOCK_RIGHT, &error);
        if (!error && !locked)
        {
            locked = gconf_client_get_bool(g_gconfclient, KEY_SENSOR_USE_LOCK_MIDDLE, &error);
        }
    }
    
    if (error) 
    {
        g_error_free(error);
    }
    else if (locked)
    {
        ipc_menu_set_item_state("lock", "general", "normal");
    }
    else
    {
        ipc_menu_set_item_state("lock", "general", "disabled");
    }
}


gboolean conf_set_flightmode(gboolean is_enabled)
{
    gboolean ret = TRUE;  // return value, TRUE = ok
    GError   *error = NULL;

    LOGPRINTF("entry");

    ret = gconf_client_set_bool(g_gconfclient, KEY_FLIGHTMODE_MODE, is_enabled, &error);
    if (error)
    {
        WARNPRINTF("error saving GConf key %s: %s", KEY_FLIGHTMODE_MODE, error->message);
        g_error_free(error);
    }

    return ret;
}


gboolean conf_is_multi_language()
{
    return (g_number_of_langages > 1);
}


//============================================================================
// Local Functions Implementation
//============================================================================

static gboolean set_locale(const gchar *locale)
{
    gboolean retval = FALSE;
    GSList *locale_list;
    GSList *code_list;
    GSList *found;
    locale_list = locales_list_create();
    code_list = locales_list_codes(locale_list);
    
    found = g_slist_find_custom(code_list, locale, (GCompareFunc)strcmp);
    if (!found) 
    {
        WARNPRINTF("Locale [%s] not found, try en_US", locale);
        found = g_slist_find_custom(code_list, "en_US", (GCompareFunc)strcmp);
    }
    if (!found) 
    {
        WARNPRINTF("Locale en_US not found, try en_GB");
        found = g_slist_find_custom(code_list, "en_GB", (GCompareFunc)strcmp);
    }
    
    if (found)
    {
        LOGPRINTF("Found and set locale [%s]", (gchar *) found->data);
        
        // set locale in environment 
        g_setenv("LANG", found->data, TRUE);
        setlocale(LC_ALL, "");
        
        // report to applications
        ipc_send_changed_locale(found->data);
        
        retval = TRUE;
    }
    
    // free memory
    locales_list_free(locale_list);
    g_slist_free(code_list);
    
    return retval;
}


static void event_gconf_value_changed(GConfClient *client,
                                      guint cnxn_id,
                                      GConfEntry *entry,
                                      gpointer user_data)
{
    UNUSED(cnxn_id);
    UNUSED(user_data);

    LOGPRINTF("entry");

    const gchar* key = gconf_entry_get_key(entry);
    if (key == NULL)
    {
        WARNPRINTF("Failed to get key name");
        return;
    }
    
    const GConfValue* value = gconf_entry_get_value(entry);
    if (value == NULL)
    {
        // value not set, possibly empty folder
        return;
    }

    LOGPRINTF("key [%s] type [%d] value [%s]", key, value->type, gconf_value_to_string(value));
    
    if (strcmp(key, KEY_GLOBAL_LOCALE) == 0)
    {
        if (value->type == GCONF_VALUE_STRING)
        {   
            const char *locale = gconf_value_get_string(value);
            if (locale != NULL)
            {
                if (!set_locale(locale))
                {
                    WARNPRINTF("Locale not found");
                }
            }
        }
        else
        {
            WARNPRINTF("Cannot parse value of key %s", key);
        }
    }
    else if (strcmp(key, KEY_INDEX_WITH_METADATA) == 0)
    {
        if (value->type == GCONF_VALUE_BOOL)
        {
            sys_set_index_with_metadata(gconf_value_get_bool(value));
        }
        else
        {
            WARNPRINTF("Cannot parse value of key %s", key);
        }
    }
    else if (strcmp(key, KEY_PAGETURN_INVERTED) == 0)
    {
        if (value->type == GCONF_VALUE_BOOL)
        {
            sys_set_pageturn_inverted(gconf_value_get_bool(value));
        }
        else
        {
            WARNPRINTF("Cannot parse value of key %s", key);
        }
    }
    else if (strcmp(key, KEY_DISPLAY_ROTATION) == 0)
    {
        if (value->type == GCONF_VALUE_STRING)
        {   
            const char *rotation = gconf_value_get_string(value);
            if (rotation != NULL)
            {
                sys_set_rotate_direction(rotation);
            }
        }
        else
        {
            WARNPRINTF("Cannot parse value of key %s", key);
        }
    }
    else if (strcmp(key, KEY_SENSOR_USE_SOUND) == 0)
    {
        if (value->type == GCONF_VALUE_BOOL)
        {   
            gboolean use_light     = gconf_client_get_bool(g_gconfclient, KEY_SENSOR_USE_LIGHT, NULL);
            gboolean use_sound     = gconf_value_get_bool(value);

            sys_set_sensor_feedback(use_light, use_sound);
        }
        else
        {
            WARNPRINTF("Cannot parse value of key %s", key);
        }
    }
    else if (strcmp(key, KEY_SENSOR_USE_LIGHT) == 0)
    {
        if (value->type == GCONF_VALUE_BOOL)
        {   
            gboolean use_sound     = gconf_client_get_bool(g_gconfclient, KEY_SENSOR_USE_SOUND, NULL);
            gboolean use_light     = gconf_value_get_bool(value);
            
            sys_set_sensor_feedback(use_light, use_sound);
        }
        else
        {
            WARNPRINTF("Cannot parse value of key %s", key);
        }
    }
    else if (strcmp(key, KEY_SENSOR_USE_LOCK_LEFT) == 0)
    {
        if (value->type == GCONF_VALUE_BOOL)
        {   
            gboolean use_lock_left = gconf_value_get_bool(value);
            gboolean use_lock_right = gconf_client_get_bool(g_gconfclient, KEY_SENSOR_USE_LOCK_RIGHT, NULL);
            gboolean use_lock_middle = gconf_client_get_bool(g_gconfclient, KEY_SENSOR_USE_LOCK_MIDDLE, NULL);
            
            conf_disabled_sensor_lock();
            
            sys_set_sensor_lock_config(use_lock_left, use_lock_right, use_lock_middle);
        }
        else
        {
            WARNPRINTF("Cannot parse value of key %s", key);
        }
    }
    else if (strcmp(key, KEY_SENSOR_USE_LOCK_RIGHT) == 0)
    {
        if (value->type == GCONF_VALUE_BOOL)
        {   
            gboolean use_lock_left = gconf_client_get_bool(g_gconfclient, KEY_SENSOR_USE_LOCK_LEFT, NULL);
            gboolean use_lock_right = gconf_value_get_bool(value);
            gboolean use_lock_middle = gconf_client_get_bool(g_gconfclient, KEY_SENSOR_USE_LOCK_MIDDLE, NULL);
            
            conf_disabled_sensor_lock();
            
            sys_set_sensor_lock_config(use_lock_left, use_lock_right, use_lock_middle);
        }
        else
        {
            WARNPRINTF("Cannot parse value of key %s", key);
        }
    }
    else if (strcmp(key, KEY_SENSOR_USE_LOCK_MIDDLE) == 0)
    {
        if (value->type == GCONF_VALUE_BOOL)
        {   
            gboolean use_lock_left = gconf_client_get_bool(g_gconfclient, KEY_SENSOR_USE_LOCK_LEFT, NULL);
            gboolean use_lock_right = gconf_client_get_bool(g_gconfclient, KEY_SENSOR_USE_LOCK_RIGHT, NULL);
            gboolean use_lock_middle = gconf_value_get_bool(value);
            
            conf_disabled_sensor_lock();
            
            sys_set_sensor_lock_config(use_lock_left, use_lock_right, use_lock_middle);
        }
        else
        {
            WARNPRINTF("Cannot parse value of key %s", key);
        }
    }
/*    
    else if (strcmp(key, KEY_GLOBAL_TZ_OFFSET) == 0)
    {
        if (value->type == GCONF_VALUE_INT)
        {   
            sys_set_timezone_offset(gconf_value_get_int(value));
        }
        else
        {
            WARNPRINTF("Cannot parse value of key %s", key);
        }
    }
*/
    else if (strcmp(key, KEY_POWER_USE_STYLUS) == 0)
    {
        if (value->type == GCONF_VALUE_BOOL)
        {   
            if (gconf_value_get_bool(value))
            {
                wacom_enable();
            }
            else
            {
                wacom_disable();
            }
        }
        else
        {
            WARNPRINTF("Cannot parse value of key %s", key);
        }
    }
    else if (strcmp(key, KEY_POWER_IDLE_MODE) == 0)
    {
        if (value->type == GCONF_VALUE_BOOL)
        {   
            sys_set_idle_mode(gconf_value_get_bool(value));
        }
        else
        {
            WARNPRINTF("Cannot parse value of key %s", key);
        }
    }
    else if (strcmp(key, KEY_POWER_MIN_STANDBY) == 0)
    {
        if (value->type == GCONF_VALUE_INT)
        {   
            gint standby = gconf_value_get_int(value);
            if (standby > 0)
            {
                if (standby < MINIMUM_STANDBY_MIN)
                {
                    standby = MINIMUM_STANDBY_MIN;
                }
                sys_set_standby_time(standby * 60);
            }
            else if (standby == -1)
            {
                sys_set_standby_time(0);
            }
        }
        else
        {
            WARNPRINTF("Cannot parse value of key %s", key);
        }
    }
    else if (strcmp(key, KEY_POWER_STANDBY_IF_PLUGGED) == 0)
    {
        if (value->type == GCONF_VALUE_BOOL)
        {   
            sys_set_standby_mode(gconf_value_get_bool(value));
        }
        else
        {
            WARNPRINTF("Cannot parse value of key %s", key);
        }
    }
    else if (strcmp(key, KEY_FLIGHTMODE_MODE) == 0)
    {
        if (value->type == GCONF_VALUE_BOOL)
        {   
            conn_set_flightmode(gconf_value_get_bool(value));
        }
        else
        {
            WARNPRINTF("Cannot parse value of key %s", key);
        }
    }
    else if (strcmp(key, KEY_GLOBAL_FIRST_BOOT) == 0)
    {
        if (value->type == GCONF_VALUE_BOOL)
        {   
            if (gconf_value_get_bool(value))
            {
                // device is reset to factory defaults;
                // check locales/languages available on system
                update_installed_locales();
            }
        }
    }    
    
/*
    LOGPRINTF("GConf key changed");
    g_print("Key: %s\t", key);

    if (value) 
    {
        switch (value->type) 
        {
        case GCONF_VALUE_STRING: 
            g_print(" STRING\t`%s`", gconf_value_get_string(value));
            break;
        
        case GCONF_VALUE_INT:
            g_print(" INT\t %d", gconf_value_get_int(value));
            break;      
        
        case GCONF_VALUE_FLOAT:
            g_print(" FLOAT\t %f", gconf_value_get_float(value));
            break;            
        
        case GCONF_VALUE_BOOL:
            g_print(" BOOL\t %s", (gconf_value_get_bool(value) ? "true" : "false"));
            break;            
        
        case GCONF_VALUE_SCHEMA:
            g_print(" SCHEMA");
            break;            
        
        case GCONF_VALUE_LIST:
            g_print(" LIST");
            break;            
        
        case GCONF_VALUE_PAIR:
            g_print(" PAIR");
            break;            
        
        case GCONF_VALUE_INVALID:
        default:
            g_print(" has invalid type");
            break;
        }
    }
    else
    {
      g_print(" has invalid type");
    } 
    g_print("\n");
*/
}


static void set_startup_defaults(void)
{
    LOGPRINTF("entry");

    GError *error = NULL;
    
    // set alternate navigation of GTK+ for DR800 with up/down buttons only
#if MACHINE_IS_DR800SG || MACHINE_IS_DR800S || MACHINE_IS_DR800SW
    gconf_client_set_int(g_gconfclient, KEY_UP_DOWN_FOCUS_BEHAVIOR, 1, &error);
#elif MACHINE_IS_DR1000S || MACHINE_IS_DR1000SW
    gconf_client_set_int(g_gconfclient, KEY_UP_DOWN_FOCUS_BEHAVIOR, 0, &error);
#endif    
    if (error)
    {
        WARNPRINTF("error writing GConf key %s: %s", KEY_UP_DOWN_FOCUS_BEHAVIOR, error->message);
        g_error_free(error);
        error = NULL;
    }
    
    char *locale = gconf_client_get_string(g_gconfclient, KEY_GLOBAL_LOCALE, &error);
    if (error)
    {
        WARNPRINTF("error fetching GConf key %s: %s", KEY_GLOBAL_LOCALE, error->message);
        g_error_free(error);
        error = NULL;
    }
    else
    {
        if (!set_locale(locale))
        {
            WARNPRINTF("Locale not found");
        }
    }
  
/*    
    gint tz_offset = gconf_client_get_int(g_gconfclient, KEY_GLOBAL_TZ_OFFSET, &error);
    if (error)
    {
        WARNPRINTF("error fetching GConf key %s: %s", KEY_GLOBAL_TZ_OFFSET, error->message);
        g_error_free(error);
        error = NULL;
    }
    else
    {
        sys_set_timezone_offset(tz_offset);
    }
*/

    gboolean index_with_metadata = gconf_client_get_bool(g_gconfclient, KEY_INDEX_WITH_METADATA, &error);
    if (error)
    {
        WARNPRINTF("error fetching GConf key %s: %s", KEY_INDEX_WITH_METADATA, error->message);
        g_error_free(error);
        error = NULL;
    }
    else
    {
        sys_set_index_with_metadata(index_with_metadata);
    }

    char *rotation = gconf_client_get_string(g_gconfclient, KEY_DISPLAY_ROTATION, &error);
    if (error)
    {
        WARNPRINTF("error fetching GConf key %s: %s", KEY_DISPLAY_ROTATION, error->message);
        g_error_free(error);
        error = NULL;
    }
    if (rotation != NULL )
    {
        sys_set_rotate_direction(rotation);
    }
    
    gboolean is_pageturn_inverted = gconf_client_get_bool(g_gconfclient, KEY_PAGETURN_INVERTED, &error);
    if (error)
    {
        WARNPRINTF("error fetching GConf key %s: %s", KEY_PAGETURN_INVERTED, error->message);
        g_error_free(error);
        error = NULL;
    }
    else
    {
        sys_set_pageturn_inverted(is_pageturn_inverted);
    }

    gboolean use_light = gconf_client_get_bool(g_gconfclient, KEY_SENSOR_USE_LIGHT, &error);
    if (error)
    {
        WARNPRINTF("error fetching GConf key %s: %s", KEY_SENSOR_USE_LIGHT, error->message);
        g_error_free(error);
        error = NULL;
    }
    else
    {
        gboolean use_sound = gconf_client_get_bool(g_gconfclient, KEY_SENSOR_USE_SOUND, &error);
        if (error)
        {
            WARNPRINTF("error fetching GConf key %s: %s", KEY_SENSOR_USE_SOUND, error->message);
            g_error_free(error);
            error = NULL;
        }
        else
        {
            sys_set_sensor_feedback(use_light, use_sound);    
        }
    }
    
    gboolean use_lock_left = gconf_client_get_bool(g_gconfclient, KEY_SENSOR_USE_LOCK_LEFT, &error);
    if (error)
    {
        WARNPRINTF("error fetching GConf key %s: %s", KEY_SENSOR_USE_LOCK_LEFT, error->message);
        g_error_free(error);
        error = NULL;
    }
    else
    {
        gboolean use_lock_right  = gconf_client_get_bool(g_gconfclient, KEY_SENSOR_USE_LOCK_RIGHT, &error);
        if (error)
        {
            WARNPRINTF("error fetching GConf key %s: %s", KEY_SENSOR_USE_LOCK_RIGHT, error->message);
            g_error_free(error);
            error = NULL;
        }
        else
        {
            gboolean use_lock_middle = gconf_client_get_bool(g_gconfclient, KEY_SENSOR_USE_LOCK_MIDDLE, &error);
            if (error)
            {
                WARNPRINTF("error fetching GConf key %s: %s", KEY_SENSOR_USE_LOCK_MIDDLE, error->message);
                g_error_free(error);
                error = NULL;
            }
            else
            {
                sys_set_sensor_lock_config(use_lock_left, use_lock_right, use_lock_middle);    
            }
        }
    }

    gboolean use_stylus = gconf_client_get_bool(g_gconfclient, KEY_POWER_USE_STYLUS, &error);
    if (error)
    {
        WARNPRINTF("error fetching GConf key %s: %s", KEY_POWER_USE_STYLUS, error->message);
        g_error_free(error);
        error = NULL;
    }
    else
    {
        if (use_stylus)
        {
            wacom_enable();
        }
        else
        {
            wacom_disable();
        }
    }
 
    gboolean idle_mode = gconf_client_get_bool(g_gconfclient, KEY_POWER_IDLE_MODE, &error);
    if (error)
    {
        WARNPRINTF("error fetching GConf key %s: %s", KEY_POWER_IDLE_MODE, error->message);
        g_error_free(error);
        error = NULL;
    }
    else
    {
        sys_set_idle_mode(idle_mode);
    }

    gint standby = gconf_client_get_int(g_gconfclient, KEY_POWER_MIN_STANDBY, &error);
    if (error)
    {
        WARNPRINTF("error fetching GConf key %s: %s", KEY_POWER_MIN_STANDBY, error->message);
        g_error_free(error);
        error = NULL;
    }
    else
    {
        if (standby > 0)
        {
            if (standby < MINIMUM_STANDBY_MIN)
            {
                standby = MINIMUM_STANDBY_MIN;
            }
            sys_set_standby_time(standby * 60);
        }
        else if (standby == -1)
        {
            sys_set_standby_time(0);
        }
    }
    
    gboolean standby_if_plugged = gconf_client_get_bool(g_gconfclient, KEY_POWER_STANDBY_IF_PLUGGED, &error);
    if (error)
    {
        WARNPRINTF("error fetching GConf key %s: %s", KEY_POWER_STANDBY_IF_PLUGGED, error->message);
        g_error_free(error);
        error = NULL;
    }
    else
    {
        sys_set_standby_mode(standby_if_plugged);
    }
    
    gboolean is_flightmode_enabled = gconf_client_get_bool(g_gconfclient, KEY_FLIGHTMODE_MODE, &error);
    if (error)
    {
        WARNPRINTF("error fetching GConf key %s: %s", KEY_FLIGHTMODE_MODE, error->message);
        g_error_free(error);
        error = NULL;
    }
    else
    {
        conn_set_flightmode(is_flightmode_enabled);
    }
}


static void update_installed_locales()
{
    GSList *locale_list;
    GSList *code_list;
    GSList *lang_list;
    
    // get list of installed locales on system
    locale_list = locales_list_create();

    // create lists of only codes and languages
    code_list = locales_list_codes(locale_list);
    lang_list = locales_list_languages(locale_list);

    // update gconf entries
    gconf_client_set_list(g_gconfclient, KEY_GLOBAL_LIST_LOCALES, GCONF_VALUE_STRING, code_list, NULL);
    gconf_client_set_list(g_gconfclient, KEY_GLOBAL_LIST_LANGUAGES, GCONF_VALUE_STRING, lang_list, NULL);

    if (g_slist_length(code_list) != g_slist_length(lang_list))
    {
        WARNPRINTF("Locale code and language lists are not of equal length");
    }
    
    g_number_of_langages = g_slist_length(code_list);
        
    if (g_number_of_langages == 1)
    {
        // auto set locale to the only available langage
        //
        char *new_locale = code_list->data;
        char *old_locale = gconf_client_get_string(g_gconfclient, KEY_GLOBAL_LOCALE, NULL);
        if ( ((old_locale == NULL) || (strcmp(old_locale, new_locale) != 0)) )
        {
            LOGPRINTF("Auto set locale to %s (was: %s)", new_locale, old_locale);
            gconf_client_set_string(g_gconfclient, KEY_GLOBAL_LOCALE, new_locale, NULL);
        }
        else
        {
            LOGPRINTF("Locale already set to %s", new_locale);
        }
    }

    // free memory
    locales_list_free(locale_list);
    g_slist_free(code_list);
    g_slist_free(lang_list);
}


/*
static void print_environment(void)
{
    char **envp;
    int i;
    envp = g_listenv();
    for (i = 0; envp[i]; i++) 
    {
        char *name = envp[i];
        LOGPRINTF("%s=%s", name, g_getenv(name));
        g_free name);
    }                
}
*/