applications/gnome-control-center
4
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Big libgswitchit API change (to GNOME naming conventions)

Browse source
This commit is contained in:
Sergey V. Udaltsov 2006-06-25 02:23:08 +00:00
parent 73b8ac314b
commit ebfb8c66b0
7 changed files with 365 additions and 358 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

5
capplets/keyboard/ChangeLog
View file

@ -1,3 +1,8 @@
2006-06-25 Sergey Udaltsov <svu@gnome.org>
*.c: massive libgswitchit API change
(following standard GNOME naming conventions)
2006-04-22 Sergey Udaltsov <svu@gnome.org>
gnome-keyboard-properties-xkblt.c:

56
capplets/keyboard/gnome-keyboard-properties-xkb.c
View file

@ -41,14 +41,14 @@
#include "gnome-keyboard-properties-xkb.h"
XklEngine *engine;
XklConfigRegistry *configRegistry;
XklConfigRegistry *config_registry;
GSwitchItKbdConfig initialConfig;
GSwitchItKbdConfig initial_config;
GConfClient *xkbGConfClient;
GConfClient *xkb_gconf_client;
char *
xci_desc_to_utf8 (const XklConfigItem * ci)
xci_desc_to_utf8 (XklConfigItem * ci)
{
char *sd = g_strstrip (ci->description);
return sd[0] == 0 ? g_strdup (ci->name) :
@ -70,11 +70,11 @@ set_model_text (GtkWidget * entry,
}
if (model == NULL)
model = initialConfig.model;
model = initial_config.model;
g_snprintf (ci.name, sizeof (ci.name), "%s", model);
if (xkl_config_registry_find_model (configRegistry, &ci))
if (xkl_config_registry_find_model (config_registry, &ci))
{
char * d;
@ -105,14 +105,14 @@ setup_model_entry (GladeXML * dialog)
{
GConfValue * value;
value = gconf_client_get (xkbGConfClient,
value = gconf_client_get (xkb_gconf_client,
GSWITCHIT_KBD_CONFIG_KEY_MODEL,
NULL);
set_model_text (WID ("xkb_model"), value);
if (value != NULL)
gconf_value_free (value);
gconf_client_notify_add (xkbGConfClient,
gconf_client_notify_add (xkb_gconf_client,
GSWITCHIT_KBD_CONFIG_KEY_MODEL,
(GConfClientNotifyFunc) model_key_changed,
dialog, NULL, NULL);
@ -121,24 +121,24 @@ setup_model_entry (GladeXML * dialog)
static void
cleanup_xkb_tabs (GladeXML * dialog)
{
GSwitchItKbdConfigTerm (&initialConfig);
g_object_unref (G_OBJECT (configRegistry));
configRegistry = NULL;
gswitchit_kbd_config_term (&initial_config);
g_object_unref (G_OBJECT (config_registry));
config_registry = NULL;
g_object_unref (G_OBJECT (engine));
engine = NULL;
g_object_unref (G_OBJECT (xkbGConfClient));
xkbGConfClient = NULL;
g_object_unref (G_OBJECT (xkb_gconf_client));
xkb_gconf_client = NULL;
}
static void
reset_to_defaults (GtkWidget * button, GladeXML * dialog)
{
GSwitchItKbdConfig emptyKbdConfig;
GSwitchItKbdConfig empty_kbd_config;
GSwitchItKbdConfigInit (&emptyKbdConfig, xkbGConfClient, engine);
GSwitchItKbdConfigSaveToGConfBackup (&emptyKbdConfig);
GSwitchItKbdConfigSaveToGConf (&emptyKbdConfig);
GSwitchItKbdConfigTerm (&emptyKbdConfig);
gswitchit_kbd_config_init (&empty_kbd_config, xkb_gconf_client, engine);
gswitchit_kbd_config_save_to_gconf_backup (&empty_kbd_config);
gswitchit_kbd_config_save_to_gconf (&empty_kbd_config);
gswitchit_kbd_config_term (&empty_kbd_config);
/* all the rest is g-s-d's business */
}
@ -156,14 +156,14 @@ void
setup_xkb_tabs (GladeXML * dialog, GConfChangeSet * changeset)
{
GObject * peditor;
xkbGConfClient = gconf_client_get_default ();
xkb_gconf_client = gconf_client_get_default ();
engine = xkl_engine_get_instance (GDK_DISPLAY ());
configRegistry = xkl_config_registry_get_instance (engine);
xkl_config_registry_load (configRegistry);
config_registry = xkl_config_registry_get_instance (engine);
xkl_config_registry_load (config_registry);
GSwitchItKbdConfigInit (&initialConfig, xkbGConfClient, engine);
GSwitchItKbdConfigLoadFromXInitial (&initialConfig);
gswitchit_kbd_config_init (&initial_config, xkb_gconf_client, engine);
gswitchit_kbd_config_load_from_x_initial (&initial_config);
setup_model_entry (dialog);
@ -196,7 +196,7 @@ setup_xkb_tabs (GladeXML * dialog, GConfChangeSet * changeset)
enable_disable_restoring (dialog);
xkb_layouts_enable_disable_default (dialog,
gconf_client_get_bool (xkbGConfClient,
gconf_client_get_bool (xkb_gconf_client,
GSWITCHIT_CONFIG_KEY_GROUP_PER_WINDOW,
NULL));
}
@ -207,11 +207,11 @@ enable_disable_restoring (GladeXML * dialog)
GSwitchItKbdConfig gswic;
gboolean enable;
GSwitchItKbdConfigInit (&gswic, xkbGConfClient, engine);
GSwitchItKbdConfigLoadFromGConf (&gswic, NULL);
gswitchit_kbd_config_init (&gswic, xkb_gconf_client, engine);
gswitchit_kbd_config_load_from_gconf (&gswic, NULL);
enable = !GSwitchItKbdConfigEquals (&gswic, &initialConfig);
enable = !gswitchit_kbd_config_equals (&gswic, &initial_config);
GSwitchItKbdConfigTerm (&gswic);
gswitchit_kbd_config_term (&gswic);
gtk_widget_set_sensitive (WID ("xkb_reset_to_defaults"), enable);
}

16
capplets/keyboard/gnome-keyboard-properties-xkb.h
View file

@ -38,12 +38,12 @@ G_BEGIN_DECLS
#define AVAIL_LAYOUT_TREE_COL_DESCRIPTION 0
#define AVAIL_LAYOUT_TREE_COL_ID 1
#define CWID(s) glade_xml_get_widget (chooserDialog, s)
#define CWID(s) glade_xml_get_widget (chooser_dialog, s)
extern XklEngine *engine;
extern XklConfigRegistry *configRegistry;
extern GConfClient *xkbGConfClient;
extern GSwitchItKbdConfig initialConfig;
extern XklConfigRegistry *config_registry;
extern GConfClient *xkb_gconf_client;
extern GSwitchItKbdConfig initial_config;
extern void setup_xkb_tabs (GladeXML * dialog,
GConfChangeSet * changeset);
@ -73,9 +73,9 @@ extern void xkb_options_load_options (GladeXML * dialog);
extern void clear_xkb_elements_list (GSList * list);
extern char *xci_desc_to_utf8 (const XklConfigItem * ci);
extern char *xci_desc_to_utf8 (XklConfigItem * ci);
extern void sort_tree_content (GtkWidget * treeView);
extern void sort_tree_content (GtkWidget * tree_view);
extern void enable_disable_restoring (GladeXML * dialog);
@ -101,9 +101,9 @@ extern GSList *xkb_options_get_selected_list (void);
GSWITCHIT_KBD_CONFIG_KEY_OPTIONS, \
GCONF_VALUE_STRING, (list), NULL)
extern GtkWidget * xkb_layout_preview_create_widget (GladeXML * chooserDialog);
extern GtkWidget * xkb_layout_preview_create_widget (GladeXML * chooser_dialog);
extern void xkb_layout_preview_update (GladeXML * chooserDialog);
extern void xkb_layout_preview_update (GladeXML * chooser_dialog);
G_END_DECLS
#endif /* __GNOME_KEYBOARD_PROPERTY_XKB_H */

398
capplets/keyboard/gnome-keyboard-properties-xkblt.c
View file

@ -43,17 +43,17 @@
#define GROUP_SWITCHERS_GROUP "grp"
#define DEFAULT_GROUP_SWITCH "grp:alts_toggle"
static GtkTreeIter current1stLevelIter;
static const char *current1stLevelId;
static GtkTreeIter current1st_level_iter;
static const char *current1st_level_id;
static int idx2Select = -1;
static int maxSelectedLayouts = -1;
static int defaultGroup = -1;
static int idx2select = -1;
static int max_selected_layouts = -1;
static int default_group = -1;
static GtkCellRenderer *textRenderer;
static GtkCellRenderer *toggleRenderer;
static GtkCellRenderer *text_renderer;
static GtkCellRenderer *toggle_renderer;
static gboolean disableButtonsSensibilityUpdate = FALSE;
static gboolean disable_buttons_sensibility_update = FALSE;
void
clear_xkb_elements_list (GSList * list)
@ -72,16 +72,16 @@ xkb_layouts_get_selected_list (void)
{
GSList *retval;
retval = gconf_client_get_list (xkbGConfClient,
retval = gconf_client_get_list (xkb_gconf_client,
GSWITCHIT_KBD_CONFIG_KEY_LAYOUTS,
GCONF_VALUE_STRING,
NULL);
if (retval == NULL)
{
GSList *curLayout;
GSList *cur_layout;
for (curLayout = initialConfig.layouts; curLayout != NULL; curLayout = curLayout->next)
retval = g_slist_prepend (retval, g_strdup (curLayout->data));
for (cur_layout = initial_config.layouts; cur_layout != NULL; cur_layout = cur_layout->next)
retval = g_slist_prepend (retval, g_strdup (cur_layout->data));
retval = g_slist_reverse (retval);
}
@ -90,14 +90,14 @@ xkb_layouts_get_selected_list (void)
}
static void
save_default_group (int aDefaultGroup)
save_default_group (int default_group)
{
if (aDefaultGroup != gconf_client_get_int (xkbGConfClient,
if (default_group != gconf_client_get_int (xkb_gconf_client,
GSWITCHIT_CONFIG_KEY_DEFAULT_GROUP,
NULL))
gconf_client_set_int (xkbGConfClient,
gconf_client_set_int (xkb_gconf_client,
GSWITCHIT_CONFIG_KEY_DEFAULT_GROUP,
aDefaultGroup,
default_group,
NULL);
}
@ -107,16 +107,16 @@ def_group_in_ui_changed (GtkCellRendererToggle *cell_renderer,
GladeXML * dialog)
{
GtkTreePath *chpath = gtk_tree_path_new_from_string (path);
int newDefaultGroup = -1;
gboolean previouslySelected = gtk_cell_renderer_toggle_get_active (cell_renderer);
int new_default_group = -1;
gboolean previously_selected = gtk_cell_renderer_toggle_get_active (cell_renderer);
if (!previouslySelected) /* prev state - non-selected! */
if (!previously_selected) /* prev state - non-selected! */
{
int *indices = gtk_tree_path_get_indices (chpath);
newDefaultGroup = indices[0];
new_default_group = indices[0];
}
save_default_group (newDefaultGroup);
save_default_group (new_default_group);
gtk_tree_path_free (chpath);
}
@ -129,22 +129,22 @@ def_group_in_gconf_changed (GConfClient * client,
if (value->type == GCONF_VALUE_INT)
{
GtkWidget* treeView = WID ("xkb_layouts_selected");
GtkTreeModel *model = GTK_TREE_MODEL (gtk_tree_view_get_model (GTK_TREE_VIEW (treeView)));
GtkWidget* tree_view = WID ("xkb_layouts_selected");
GtkTreeModel *model = GTK_TREE_MODEL (gtk_tree_view_get_model (GTK_TREE_VIEW (tree_view)));
GtkTreeIter iter;
int counter = 0;
defaultGroup = gconf_value_get_int (value);
default_group = gconf_value_get_int (value);
if (gtk_tree_model_get_iter_first (model, &iter))
{
do
{
gboolean curVal;
gboolean cur_val;
gtk_tree_model_get (model, &iter,
SEL_LAYOUT_TREE_COL_DEFAULT, &curVal,
SEL_LAYOUT_TREE_COL_DEFAULT, &cur_val,
-1);
if (curVal != ( counter == defaultGroup))
if (cur_val != ( counter == default_group))
gtk_list_store_set (GTK_LIST_STORE (model), &iter,
SEL_LAYOUT_TREE_COL_DEFAULT, counter == defaultGroup,
SEL_LAYOUT_TREE_COL_DEFAULT, counter == default_group,
-1);
counter++;
}
@ -154,107 +154,107 @@ def_group_in_gconf_changed (GConfClient * client,
}
static void
add_variant_to_available_layouts_tree (XklConfigRegistry * configRegistry,
const XklConfigItem * configItem,
GladeXML * chooserDialog)
add_variant_to_available_layouts_tree (XklConfigRegistry * config_registry,
XklConfigItem * config_item,
GladeXML * chooser_dialog)
{
GtkWidget *layoutsTree = CWID ("xkb_layouts_available");
GtkWidget *layouts_tree = CWID ("xkb_layouts_available");
GtkTreeIter iter;
GtkTreeStore *treeStore =
GTK_TREE_STORE (gtk_tree_view_get_model (GTK_TREE_VIEW (layoutsTree)));
const gchar *fullLayoutName = GSwitchItKbdConfigMergeItems (current1stLevelId,
configItem->name);
char *utfVariantName = xci_desc_to_utf8 (configItem);
GtkTreeStore *tree_store =
GTK_TREE_STORE (gtk_tree_view_get_model (GTK_TREE_VIEW (layouts_tree)));
const gchar *full_layout_name = gswitchit_kbd_config_merge_items (current1st_level_id,
config_item->name);
char *utf_variant_name = xci_desc_to_utf8 (config_item);
gtk_tree_store_append (treeStore, &iter, &current1stLevelIter);
gtk_tree_store_set (treeStore, &iter,
AVAIL_LAYOUT_TREE_COL_DESCRIPTION, utfVariantName,
AVAIL_LAYOUT_TREE_COL_ID, fullLayoutName, -1);
g_free (utfVariantName);
gtk_tree_store_append (tree_store, &iter, &current1st_level_iter);
gtk_tree_store_set (tree_store, &iter,
AVAIL_LAYOUT_TREE_COL_DESCRIPTION, utf_variant_name,
AVAIL_LAYOUT_TREE_COL_ID, full_layout_name, -1);
g_free (utf_variant_name);
}
static void
add_layout_to_available_layouts_tree (XklConfigRegistry * configRegistry,
const XklConfigItem * configItem,
GladeXML * chooserDialog)
add_layout_to_available_layouts_tree (XklConfigRegistry * config_registry,
XklConfigItem * config_item,
GladeXML * chooser_dialog)
{
GtkWidget *layoutsTree = CWID ("xkb_layouts_available");
GtkTreeStore *treeStore =
GTK_TREE_STORE (gtk_tree_view_get_model (GTK_TREE_VIEW (layoutsTree)));
char *utfLayoutName = xci_desc_to_utf8 (configItem);
GtkWidget *layouts_tree = CWID ("xkb_layouts_available");
GtkTreeStore *tree_store =
GTK_TREE_STORE (gtk_tree_view_get_model (GTK_TREE_VIEW (layouts_tree)));
char *utf_layout_name = xci_desc_to_utf8 (config_item);
gtk_tree_store_append (treeStore, &current1stLevelIter, NULL);
gtk_tree_store_set (treeStore, &current1stLevelIter,
AVAIL_LAYOUT_TREE_COL_DESCRIPTION, utfLayoutName,
AVAIL_LAYOUT_TREE_COL_ID, configItem->name, -1);
g_free (utfLayoutName);
gtk_tree_store_append (tree_store, &current1st_level_iter, NULL);
gtk_tree_store_set (tree_store, &current1st_level_iter,
AVAIL_LAYOUT_TREE_COL_DESCRIPTION, utf_layout_name,
AVAIL_LAYOUT_TREE_COL_ID, config_item->name, -1);
g_free (utf_layout_name);
current1stLevelId = configItem->name;
current1st_level_id = config_item->name;
xkl_config_registry_foreach_layout_variant (configRegistry, configItem->name,
xkl_config_registry_foreach_layout_variant (config_registry, config_item->name,
(ConfigItemProcessFunc)add_variant_to_available_layouts_tree,
chooserDialog);
chooser_dialog);
}
static void
xkb_layouts_enable_disable_buttons (GladeXML * dialog)
{
GtkWidget *addLayoutBtn = WID ("xkb_layouts_add");
GtkWidget *delLayoutBtn = WID ("xkb_layouts_remove");
GtkWidget *upLayoutBtn = WID ("xkb_layouts_up");
GtkWidget *dnLayoutBtn = WID ("xkb_layouts_down");
GtkWidget *selectedLayoutsTree = WID ("xkb_layouts_selected");
GtkWidget *add_layout_btn = WID ("xkb_layouts_add");
GtkWidget *del_layout_btn = WID ("xkb_layouts_remove");
GtkWidget *up_layout_btn = WID ("xkb_layouts_up");
GtkWidget *dn_layout_btn = WID ("xkb_layouts_down");
GtkWidget *selected_layouts_tree = WID ("xkb_layouts_selected");
GtkTreeSelection *sSelection =
gtk_tree_view_get_selection (GTK_TREE_VIEW (selectedLayoutsTree));
const int nSelectedSelectedLayouts =
gtk_tree_selection_count_selected_rows (sSelection);
gboolean canMoveUp = FALSE;
gboolean canMoveDn = FALSE;
GtkTreeSelection *s_selection =
gtk_tree_view_get_selection (GTK_TREE_VIEW (selected_layouts_tree));
const int n_selected_selected_layouts =
gtk_tree_selection_count_selected_rows (s_selection);
gboolean can_move_up = FALSE;
gboolean can_move_dn = FALSE;
GtkTreeIter iter;
GtkTreeModel *selectedLayoutsModel = gtk_tree_view_get_model
(GTK_TREE_VIEW (selectedLayoutsTree));
const int nSelectedLayouts =
gtk_tree_model_iter_n_children (selectedLayoutsModel,
GtkTreeModel *selected_layouts_model = gtk_tree_view_get_model
(GTK_TREE_VIEW (selected_layouts_tree));
const int n_selected_layouts =
gtk_tree_model_iter_n_children (selected_layouts_model,
NULL);
if (disableButtonsSensibilityUpdate)
if (disable_buttons_sensibility_update)
return;
gtk_widget_set_sensitive (addLayoutBtn,
(nSelectedLayouts < maxSelectedLayouts ||
maxSelectedLayouts == 0));
gtk_widget_set_sensitive (delLayoutBtn, nSelectedSelectedLayouts > 0);
gtk_widget_set_sensitive (add_layout_btn,
(n_selected_layouts < max_selected_layouts ||
max_selected_layouts == 0));
gtk_widget_set_sensitive (del_layout_btn, n_selected_selected_layouts > 0);
if (gtk_tree_selection_get_selected (sSelection, NULL, &iter))
if (gtk_tree_selection_get_selected (s_selection, NULL, &iter))
{
GtkTreePath *path = gtk_tree_model_get_path (selectedLayoutsModel,
GtkTreePath *path = gtk_tree_model_get_path (selected_layouts_model,
&iter);
if (path != NULL)
{
int *indices = gtk_tree_path_get_indices (path);
int idx = indices[0];
canMoveUp = idx > 0;
canMoveDn = idx < (nSelectedLayouts - 1);
can_move_up = idx > 0;
can_move_dn = idx < (n_selected_layouts - 1);
gtk_tree_path_free (path);
}
}
gtk_widget_set_sensitive (upLayoutBtn, canMoveUp);
gtk_widget_set_sensitive (dnLayoutBtn, canMoveDn);
gtk_widget_set_sensitive (up_layout_btn, can_move_up);
gtk_widget_set_sensitive (dn_layout_btn, can_move_dn);
}
static void
xkb_layout_chooser_enable_disable_buttons (GladeXML * chooserDialog)
xkb_layout_chooser_enable_disable_buttons (GladeXML * chooser_dialog)
{
GtkWidget *availableLayoutsTree = CWID ("xkb_layouts_available");
GtkTreeSelection *aSelection =
gtk_tree_view_get_selection (GTK_TREE_VIEW (availableLayoutsTree));
const int nSelectedAvailableLayouts =
gtk_tree_selection_count_selected_rows (aSelection);
GtkWidget *available_layouts_tree = CWID ("xkb_layouts_available");
GtkTreeSelection *selection =
gtk_tree_view_get_selection (GTK_TREE_VIEW (available_layouts_tree));
const int n_selected_available_layouts =
gtk_tree_selection_count_selected_rows (selection);
gtk_dialog_set_response_sensitive (GTK_DIALOG (CWID ("xkb_layout_chooser")),
GTK_RESPONSE_OK, nSelectedAvailableLayouts > 0);
GTK_RESPONSE_OK, n_selected_available_layouts > 0);
}
void xkb_layouts_enable_disable_default (GladeXML * dialog,
@ -263,62 +263,62 @@ void xkb_layouts_enable_disable_default (GladeXML * dialog,
GValue val = {0};
g_value_init (&val, G_TYPE_BOOLEAN);
g_value_set_boolean (&val, enable);
g_object_set_property (G_OBJECT (toggleRenderer), "activatable", &val);
g_object_set_property (G_OBJECT (toggle_renderer), "activatable", &val);
}
void
xkb_layouts_prepare_selected_tree (GladeXML * dialog, GConfChangeSet * changeset)
{
GtkListStore *listStore =
GtkListStore *list_store =
gtk_list_store_new (3, G_TYPE_STRING, G_TYPE_BOOLEAN, G_TYPE_STRING);
GtkWidget *treeView = WID ("xkb_layouts_selected");
GtkTreeViewColumn * descColumn, * defColumn;
GtkWidget *tree_view = WID ("xkb_layouts_selected");
GtkTreeViewColumn * desc_column, * def_column;
GtkTreeSelection *selection;
textRenderer = GTK_CELL_RENDERER (gtk_cell_renderer_text_new ());
toggleRenderer = GTK_CELL_RENDERER (gtk_cell_renderer_toggle_new ());
text_renderer = GTK_CELL_RENDERER (gtk_cell_renderer_text_new ());
toggle_renderer = GTK_CELL_RENDERER (gtk_cell_renderer_toggle_new ());
descColumn = gtk_tree_view_column_new_with_attributes (_("Layout"),
textRenderer,
desc_column = gtk_tree_view_column_new_with_attributes (_("Layout"),
text_renderer,
"text", SEL_LAYOUT_TREE_COL_DESCRIPTION,
NULL);
defColumn = gtk_tree_view_column_new_with_attributes (_("Default"),
toggleRenderer,
def_column = gtk_tree_view_column_new_with_attributes (_("Default"),
toggle_renderer,
"active", SEL_LAYOUT_TREE_COL_DEFAULT,
NULL);
selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (treeView));
selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (tree_view));
gtk_tree_view_set_model (GTK_TREE_VIEW (treeView),
GTK_TREE_MODEL (listStore));
gtk_tree_view_set_model (GTK_TREE_VIEW (tree_view),
GTK_TREE_MODEL (list_store));
gtk_tree_view_column_set_sizing (descColumn, GTK_TREE_VIEW_COLUMN_AUTOSIZE);
gtk_tree_view_column_set_sizing (defColumn, GTK_TREE_VIEW_COLUMN_AUTOSIZE);
gtk_tree_view_column_set_resizable (descColumn, TRUE);
gtk_tree_view_column_set_resizable (defColumn, TRUE);
gtk_tree_view_column_set_sizing (desc_column, GTK_TREE_VIEW_COLUMN_AUTOSIZE);
gtk_tree_view_column_set_sizing (def_column, GTK_TREE_VIEW_COLUMN_AUTOSIZE);
gtk_tree_view_column_set_resizable (desc_column, TRUE);
gtk_tree_view_column_set_resizable (def_column, TRUE);
gtk_tree_view_append_column (GTK_TREE_VIEW (treeView), descColumn);
gtk_tree_view_append_column (GTK_TREE_VIEW (treeView), defColumn);
gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view), desc_column);
gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view), def_column);
g_signal_connect_swapped (G_OBJECT (selection), "changed",
G_CALLBACK
(xkb_layouts_enable_disable_buttons), dialog);
maxSelectedLayouts = xkl_engine_get_max_num_groups (engine);
max_selected_layouts = xkl_engine_get_max_num_groups (engine);
gconf_client_notify_add (xkbGConfClient,
gconf_client_notify_add (xkb_gconf_client,
GSWITCHIT_CONFIG_KEY_DEFAULT_GROUP,
(GConfClientNotifyFunc)def_group_in_gconf_changed,
dialog,
NULL,
NULL);
g_signal_connect (G_OBJECT (toggleRenderer), "toggled",
g_signal_connect (G_OBJECT (toggle_renderer), "toggled",
G_CALLBACK (def_group_in_ui_changed), dialog);
}
static void
xkb_layout_chooser_selection_changed (GladeXML * chooserDialog)
xkb_layout_chooser_selection_changed (GladeXML * chooser_dialog)
{
xkb_layout_preview_update (chooserDialog);
xkb_layout_chooser_enable_disable_buttons (chooserDialog);
xkb_layout_preview_update (chooser_dialog);
xkb_layout_chooser_enable_disable_buttons (chooser_dialog);
}
void
@ -326,49 +326,49 @@ xkb_layouts_fill_selected_tree (GladeXML * dialog)
{
GConfEntry *gce;
GSList *layouts = xkb_layouts_get_selected_list ();
GSList *curLayout;
GtkListStore *listStore =
GSList *cur_layout;
GtkListStore *list_store =
GTK_LIST_STORE (gtk_tree_view_get_model
(GTK_TREE_VIEW (WID ("xkb_layouts_selected"))));
/* temporarily disable the buttons' status update */
disableButtonsSensibilityUpdate = TRUE;
disable_buttons_sensibility_update = TRUE;
gtk_list_store_clear (listStore);
gtk_list_store_clear (list_store);
for (curLayout = layouts; curLayout != NULL; curLayout = curLayout->next)
for (cur_layout = layouts; cur_layout != NULL; cur_layout = cur_layout->next)
{
GtkTreeIter iter;
char *l, *sl, *v, *sv;
char *v1, *utfVisible;
const char *visible = (char *) curLayout->data;
gtk_list_store_append (listStore, &iter);
if (GSwitchItKbdConfigGetDescriptions (configRegistry, visible, &sl, &l, &sv, &v))
visible = GSwitchItKbdConfigFormatFullLayout (l, v);
char *v1, *utf_visible;
const char *visible = (char *) cur_layout->data;
gtk_list_store_append (list_store, &iter);
if (gswitchit_kbd_config_get_descriptions (config_registry, visible, &sl, &l, &sv, &v))
visible = gswitchit_kbd_config_format_full_layout (l, v);
v1 = g_strdup (visible);
utfVisible = g_locale_to_utf8 (g_strstrip (v1), -1, NULL, NULL, NULL);
gtk_list_store_set (listStore, &iter,
SEL_LAYOUT_TREE_COL_DESCRIPTION, utfVisible,
utf_visible = g_locale_to_utf8 (g_strstrip (v1), -1, NULL, NULL, NULL);
gtk_list_store_set (list_store, &iter,
SEL_LAYOUT_TREE_COL_DESCRIPTION, utf_visible,
SEL_LAYOUT_TREE_COL_DEFAULT, FALSE,
SEL_LAYOUT_TREE_COL_ID, curLayout->data, -1);
g_free (utfVisible);
SEL_LAYOUT_TREE_COL_ID, cur_layout->data, -1);
g_free (utf_visible);
g_free (v1);
}
clear_xkb_elements_list (layouts);
/* enable the buttons' status update */
disableButtonsSensibilityUpdate = FALSE;
disable_buttons_sensibility_update = FALSE;
if (idx2Select != -1)
if (idx2select != -1)
{
GtkTreeSelection *selection =
gtk_tree_view_get_selection ((GTK_TREE_VIEW
(WID ("xkb_layouts_selected"))));
GtkTreePath *path = gtk_tree_path_new_from_indices (idx2Select, -1);
GtkTreePath *path = gtk_tree_path_new_from_indices (idx2select, -1);
gtk_tree_selection_select_path (selection, path);
gtk_tree_path_free (path);
idx2Select = -1;
idx2select = -1;
}
else
{
@ -377,34 +377,34 @@ xkb_layouts_fill_selected_tree (GladeXML * dialog)
xkb_layouts_enable_disable_buttons (dialog);
}
gce = gconf_client_get_entry (xkbGConfClient,
gce = gconf_client_get_entry (xkb_gconf_client,
GSWITCHIT_CONFIG_KEY_DEFAULT_GROUP,
NULL,
TRUE,
NULL);
def_group_in_gconf_changed (xkbGConfClient, -1, gce, dialog);
def_group_in_gconf_changed (xkb_gconf_client, -1, gce, dialog);
}
void
sort_tree_content (GtkWidget * treeView)
sort_tree_content (GtkWidget * tree_view)
{
GtkTreeModel *treeModel =
gtk_tree_view_get_model (GTK_TREE_VIEW (treeView));
GtkTreeModel *sortedTreeModel;
GtkTreeModel *tree_model =
gtk_tree_view_get_model (GTK_TREE_VIEW (tree_view));
GtkTreeModel *sorted_tree_model;
/* replace the store with the sorted version */
sortedTreeModel = gtk_tree_model_sort_new_with_model (treeModel);
sorted_tree_model = gtk_tree_model_sort_new_with_model (tree_model);
gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE
(sortedTreeModel), 0,
(sorted_tree_model), 0,
GTK_SORT_ASCENDING);
gtk_tree_view_set_model (GTK_TREE_VIEW (treeView), sortedTreeModel);
gtk_tree_view_set_model (GTK_TREE_VIEW (tree_view), sorted_tree_model);
}
void
xkb_layouts_fill_available_tree (GladeXML * chooserDialog)
xkb_layouts_fill_available_tree (GladeXML * chooser_dialog)
{
GtkTreeStore *treeStore =
GtkTreeStore *tree_store =
gtk_tree_store_new (2, G_TYPE_STRING, G_TYPE_STRING);
GtkWidget *treeView = CWID ("xkb_layouts_available");
GtkWidget *tree_view = CWID ("xkb_layouts_available");
GtkCellRenderer *renderer =
GTK_CELL_RENDERER (gtk_cell_renderer_text_new ());
GtkTreeViewColumn *column = gtk_tree_view_column_new_with_attributes (NULL,
@ -413,19 +413,19 @@ xkb_layouts_fill_available_tree (GladeXML * chooserDialog)
AVAIL_LAYOUT_TREE_COL_DESCRIPTION,
NULL);
GtkTreeSelection *selection =
gtk_tree_view_get_selection (GTK_TREE_VIEW (treeView));
gtk_tree_view_get_selection (GTK_TREE_VIEW (tree_view));
gtk_tree_view_set_model (GTK_TREE_VIEW (treeView),
GTK_TREE_MODEL (treeStore));
gtk_tree_view_append_column (GTK_TREE_VIEW (treeView), column);
gtk_tree_view_set_model (GTK_TREE_VIEW (tree_view),
GTK_TREE_MODEL (tree_store));
gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view), column);
xkl_config_registry_foreach_layout (configRegistry, (ConfigItemProcessFunc)
add_layout_to_available_layouts_tree, chooserDialog);
xkl_config_registry_foreach_layout (config_registry, (ConfigItemProcessFunc)
add_layout_to_available_layouts_tree, chooser_dialog);
sort_tree_content (treeView);
sort_tree_content (tree_view);
g_signal_connect_swapped (G_OBJECT (selection), "changed",
G_CALLBACK
(xkb_layout_chooser_selection_changed), chooserDialog);
(xkb_layout_chooser_selection_changed), chooser_dialog);
}
static void
@ -440,21 +440,21 @@ move_selected_layout (GladeXML * dialog, int offset)
GtkTreeSelection *selection =
gtk_tree_view_get_selection (GTK_TREE_VIEW
(WID ("xkb_layouts_selected")));
GtkTreeIter selectedIter;
GtkTreeIter selected_iter;
GtkTreeModel *model;
if (gtk_tree_selection_get_selected (selection, &model, &selectedIter))
if (gtk_tree_selection_get_selected (selection, &model, &selected_iter))
{
GSList *layoutsList = xkb_layouts_get_selected_list ();
GSList *layouts_list = xkb_layouts_get_selected_list ();
GtkTreePath *path = gtk_tree_model_get_path (model,
&selectedIter);
&selected_iter);
if (path != NULL)
{
int *indices = gtk_tree_path_get_indices (path);
int idx = indices[0];
char *id = NULL;
GSList *node2Remove = g_slist_nth (layoutsList, idx);
GSList *node2Remove = g_slist_nth (layouts_list, idx);
layoutsList = g_slist_remove_link (layoutsList, node2Remove);
layouts_list = g_slist_remove_link (layouts_list, node2Remove);
id = (char *) node2Remove->data;
g_slist_free_1 (node2Remove);
@ -462,26 +462,26 @@ move_selected_layout (GladeXML * dialog, int offset)
if (offset == 0)
{
g_free (id);
if (defaultGroup > idx)
save_default_group (defaultGroup - 1);
else if (defaultGroup == idx)
if (default_group > idx)
save_default_group (default_group - 1);
else if (default_group == idx)
save_default_group (-1);
}
else
{
layoutsList =
g_slist_insert (layoutsList, id, idx + offset);
idx2Select = idx + offset;
if (idx == defaultGroup)
save_default_group (idx2Select);
else if (idx2Select == defaultGroup)
layouts_list =
g_slist_insert (layouts_list, id, idx + offset);
idx2select = idx + offset;
if (idx == default_group)
save_default_group (idx2select);
else if (idx2select == default_group)
save_default_group (idx);
}
xkb_layouts_set_selected_list (layoutsList);
xkb_layouts_set_selected_list (layouts_list);
gtk_tree_path_free (path);
}
clear_xkb_elements_list (layoutsList);
clear_xkb_elements_list (layouts_list);
}
}
@ -519,7 +519,7 @@ xkb_layouts_register_buttons_handlers (GladeXML * dialog)
static void
xkb_layout_chooser_response(GtkDialog *dialog,
gint response,
GladeXML *chooserDialog)
GladeXML *chooser_dialog)
{
GdkRectangle rect;
@ -528,57 +528,57 @@ xkb_layout_chooser_response(GtkDialog *dialog,
GtkTreeSelection *selection =
gtk_tree_view_get_selection (GTK_TREE_VIEW
(CWID ("xkb_layouts_available")));
GtkTreeIter selectedIter;
GtkTreeIter selected_iter;
GtkTreeModel *model;
if (gtk_tree_selection_get_selected (selection, &model, &selectedIter))
if (gtk_tree_selection_get_selected (selection, &model, &selected_iter))
{
gchar *id;
GSList *layoutsList = xkb_layouts_get_selected_list ();
gtk_tree_model_get (model, &selectedIter,
GSList *layouts_list = xkb_layouts_get_selected_list ();
gtk_tree_model_get (model, &selected_iter,
AVAIL_LAYOUT_TREE_COL_ID, &id, -1);
layoutsList = g_slist_append (layoutsList, id);
xkb_layouts_set_selected_list (layoutsList);
layouts_list = g_slist_append (layouts_list, id);
xkb_layouts_set_selected_list (layouts_list);
/* process default switcher */
if (g_slist_length(layoutsList) >= 2)
if (g_slist_length(layouts_list) >= 2)
{
GSList *optionsList = xkb_options_get_selected_list ();
gboolean anySwitcher = False;
GSList *option = optionsList;
GSList *options_list = xkb_options_get_selected_list ();
gboolean any_switcher = False;
GSList *option = options_list;
while (option != NULL)
{
char *g, *o;
if (GSwitchItKbdConfigSplitItems (option->data, &g, &o))
if (gswitchit_kbd_config_split_items (option->data, &g, &o))
{
if (!g_ascii_strcasecmp (g, GROUP_SWITCHERS_GROUP))
{
anySwitcher = True;
any_switcher = True;
break;
}
}
option = option->next;
}
if (!anySwitcher)
if (!any_switcher)
{
XklConfigItem ci;
g_snprintf(ci.name, XKL_MAX_CI_NAME_LENGTH, DEFAULT_GROUP_SWITCH );
if (xkl_config_registry_find_option (configRegistry,
if (xkl_config_registry_find_option (config_registry,
GROUP_SWITCHERS_GROUP,
&ci))
{
const gchar* id = GSwitchItKbdConfigMergeItems (GROUP_SWITCHERS_GROUP, DEFAULT_GROUP_SWITCH);
optionsList = g_slist_append (optionsList, g_strdup (id));
xkb_options_set_selected_list (optionsList);
const gchar* id = gswitchit_kbd_config_merge_items (GROUP_SWITCHERS_GROUP, DEFAULT_GROUP_SWITCH);
options_list = g_slist_append (options_list, g_strdup (id));
xkb_options_set_selected_list (options_list);
}
}
clear_xkb_elements_list (optionsList);
clear_xkb_elements_list (options_list);
}
clear_xkb_elements_list (layoutsList);
clear_xkb_elements_list (layouts_list);
}
}
gtk_window_get_position (GTK_WINDOW (dialog), &rect.x, &rect.y);
gtk_window_get_size (GTK_WINDOW (dialog), &rect.width, &rect.height);
GSwitchItPreviewSave (&rect);
gswitchit_preview_save (&rect);
}
static void
@ -592,7 +592,7 @@ xkb_layouts_update_list (GConfClient * client,
void
xkb_layouts_register_gconf_listener (GladeXML * dialog)
{
gconf_client_notify_add (xkbGConfClient,
gconf_client_notify_add (xkb_gconf_client,
GSWITCHIT_KBD_CONFIG_KEY_LAYOUTS,
(GConfClientNotifyFunc)
xkb_layouts_update_list, dialog, NULL, NULL);
@ -601,20 +601,20 @@ xkb_layouts_register_gconf_listener (GladeXML * dialog)
void
xkb_layout_choose (GladeXML * dialog)
{
GladeXML* chooserDialog = glade_xml_new (GNOMECC_DATA_DIR "/interfaces/gnome-keyboard-properties.glade", "xkb_layout_chooser", NULL);
GladeXML* chooser_dialog = glade_xml_new (GNOMECC_DATA_DIR "/interfaces/gnome-keyboard-properties.glade", "xkb_layout_chooser", NULL);
GtkWidget* chooser = CWID ( "xkb_layout_chooser");
GtkWidget* kbdraw = NULL;
GtkWidget* toplevel = NULL;
gtk_window_set_transient_for (GTK_WINDOW (chooser), GTK_WINDOW (WID ("keyboard_dialog")));
xkb_layouts_fill_available_tree (chooserDialog);
xkb_layout_chooser_selection_changed (chooserDialog);
xkb_layouts_fill_available_tree (chooser_dialog);
xkb_layout_chooser_selection_changed (chooser_dialog);
#ifdef HAVE_X11_EXTENSIONS_XKB_H
if (!strcmp (xkl_engine_get_backend_name (engine), "XKB"))
{
kbdraw = xkb_layout_preview_create_widget (chooserDialog);
kbdraw = xkb_layout_preview_create_widget (chooser_dialog);
g_object_set_data (G_OBJECT (chooser), "kbdraw", kbdraw);
gtk_container_add (GTK_CONTAINER (CWID ("vboxPreview")), kbdraw);
gtk_widget_show_all (kbdraw);
@ -625,12 +625,12 @@ xkb_layout_choose (GladeXML * dialog)
}
g_signal_connect (G_OBJECT (chooser),
"response", G_CALLBACK (xkb_layout_chooser_response), chooserDialog);
"response", G_CALLBACK (xkb_layout_chooser_response), chooser_dialog);
toplevel = gtk_widget_get_toplevel (chooser);
if (GTK_WIDGET_TOPLEVEL (toplevel))
{
GdkRectangle *rect = GSwitchItPreviewLoad ();
GdkRectangle *rect = gswitchit_preview_load ();
if (rect != NULL)
{
gtk_window_move (GTK_WINDOW (toplevel), rect->x, rect->y);

102
capplets/keyboard/gnome-keyboard-properties-xkbmc.c
View file

@ -40,27 +40,27 @@
#include "gnome-keyboard-properties-xkb.h"
static gchar* currentModelName = NULL;
static gchar* current_model_name = NULL;
static void
add_model_to_list (XklConfigRegistry * configRegistry,
const XklConfigItem * configItem,
GtkTreeView * modelsList)
add_model_to_list (XklConfigRegistry * config_registry,
XklConfigItem * config_item,
GtkTreeView * models_list)
{
GtkTreeIter iter;
GtkListStore * listStore = GTK_LIST_STORE (gtk_tree_view_get_model (modelsList));
char *utfModelName = xci_desc_to_utf8 (configItem);
gtk_list_store_append( listStore, &iter );
gtk_list_store_set( listStore, &iter,
0, utfModelName,
1, configItem->name, -1 );
GtkListStore * list_store = GTK_LIST_STORE (gtk_tree_view_get_model (models_list));
char *utf_model_name = xci_desc_to_utf8 (config_item);
gtk_list_store_append( list_store, &iter );
gtk_list_store_set( list_store, &iter,
0, utf_model_name,
1, config_item->name, -1 );
g_free (utfModelName);
g_free (utf_model_name);
}
static void
xkb_model_chooser_change_sel (GtkTreeSelection* selection,
GladeXML* chooserDialog)
GladeXML* chooser_dialog)
{
gboolean anysel = gtk_tree_selection_get_selected (selection, NULL, NULL);
gtk_dialog_set_response_sensitive (GTK_DIALOG (CWID ("xkb_model_chooser")),
@ -68,79 +68,79 @@ xkb_model_chooser_change_sel (GtkTreeSelection* selection,
}
static void
fill_models_list (GladeXML * chooserDialog)
fill_models_list (GladeXML * chooser_dialog)
{
GtkWidget* modelsList = CWID( "models_list" );
GtkWidget* models_list = CWID( "models_list" );
GtkTreeIter iter;
GtkTreePath *path;
GtkCellRenderer* renderer = gtk_cell_renderer_text_new ();
GtkTreeViewColumn* descriptionCol = gtk_tree_view_column_new_with_attributes ( _("Models"),
GtkTreeViewColumn* description_col = gtk_tree_view_column_new_with_attributes ( _("Models"),
renderer,
"text", 0,
NULL);
GtkListStore *listStore = gtk_list_store_new (2, G_TYPE_STRING, G_TYPE_STRING);
char *modelName;
GtkListStore *list_store = gtk_list_store_new (2, G_TYPE_STRING, G_TYPE_STRING);
char *model_name;
gtk_tree_view_column_set_visible (descriptionCol, TRUE);
gtk_tree_view_append_column (GTK_TREE_VIEW (modelsList), descriptionCol);
gtk_tree_view_column_set_visible (description_col, TRUE);
gtk_tree_view_append_column (GTK_TREE_VIEW (models_list), description_col);
gtk_tree_view_set_model (GTK_TREE_VIEW (modelsList), GTK_TREE_MODEL (listStore) );
gtk_tree_view_set_model (GTK_TREE_VIEW (models_list), GTK_TREE_MODEL (list_store) );
gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (listStore),
gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (list_store),
0, GTK_SORT_ASCENDING);
xkl_config_registry_foreach_model (configRegistry,
xkl_config_registry_foreach_model (config_registry,
(ConfigItemProcessFunc) add_model_to_list,
modelsList);
models_list);
if (currentModelName != NULL)
if (current_model_name != NULL)
{
if (gtk_tree_model_get_iter_first (GTK_TREE_MODEL (listStore), &iter))
if (gtk_tree_model_get_iter_first (GTK_TREE_MODEL (list_store), &iter))
{
do
{
gtk_tree_model_get (GTK_TREE_MODEL (listStore), &iter,
1, &modelName, -1);
if (!g_ascii_strcasecmp(modelName, currentModelName))
gtk_tree_model_get (GTK_TREE_MODEL (list_store), &iter,
1, &model_name, -1);
if (!g_ascii_strcasecmp(model_name, current_model_name))
{
gtk_tree_selection_select_iter (gtk_tree_view_get_selection (GTK_TREE_VIEW (modelsList)), &iter);
path = gtk_tree_model_get_path (GTK_TREE_MODEL (listStore), &iter);
gtk_tree_view_scroll_to_cell (GTK_TREE_VIEW (modelsList),
gtk_tree_selection_select_iter (gtk_tree_view_get_selection (GTK_TREE_VIEW (models_list)), &iter);
path = gtk_tree_model_get_path (GTK_TREE_MODEL (list_store), &iter);
gtk_tree_view_scroll_to_cell (GTK_TREE_VIEW (models_list),
path, NULL, TRUE, 0.5, 0);
gtk_tree_path_free (path);
}
g_free (modelName);
} while (gtk_tree_model_iter_next (GTK_TREE_MODEL (listStore), &iter));
g_free (model_name);
} while (gtk_tree_model_iter_next (GTK_TREE_MODEL (list_store), &iter));
}
}
g_signal_connect (G_OBJECT (gtk_tree_view_get_selection (GTK_TREE_VIEW (modelsList))),
g_signal_connect (G_OBJECT (gtk_tree_view_get_selection (GTK_TREE_VIEW (models_list))),
"changed",
G_CALLBACK (xkb_model_chooser_change_sel),
chooserDialog);
chooser_dialog);
}
static void
xkb_model_chooser_response (GtkDialog *dialog,
gint response,
GladeXML *chooserDialog)
GladeXML *chooser_dialog)
{
if (response == GTK_RESPONSE_OK)
{
GtkWidget* modelsList = CWID( "models_list" );
GtkTreeSelection* selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (modelsList));
GtkWidget* models_list = CWID( "models_list" );
GtkTreeSelection* selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (models_list));
GtkTreeIter iter;
GtkTreeModel* listStore = NULL;
if (gtk_tree_selection_get_selected (selection, &listStore, &iter))
GtkTreeModel* list_store = NULL;
if (gtk_tree_selection_get_selected (selection, &list_store, &iter))
{
gchar* modelName = NULL;
gtk_tree_model_get (listStore, &iter,
1, &modelName, -1);
gchar* model_name = NULL;
gtk_tree_model_get (list_store, &iter,
1, &model_name, -1);
gconf_client_set_string (xkbGConfClient,
gconf_client_set_string (xkb_gconf_client,
GSWITCHIT_KBD_CONFIG_KEY_MODEL,
modelName, NULL);
g_free(modelName);
model_name, NULL);
g_free(model_name);
}
}
}
@ -148,15 +148,15 @@ xkb_model_chooser_response (GtkDialog *dialog,
void
choose_model(GladeXML * dialog)
{
GladeXML* chooserDialog = glade_xml_new (GNOMECC_DATA_DIR "/interfaces/gnome-keyboard-properties.glade", "xkb_model_chooser", NULL);
GladeXML* chooser_dialog = glade_xml_new (GNOMECC_DATA_DIR "/interfaces/gnome-keyboard-properties.glade", "xkb_model_chooser", NULL);
GtkWidget* chooser = CWID ( "xkb_model_chooser");
gtk_window_set_transient_for (GTK_WINDOW (chooser), GTK_WINDOW (WID ("keyboard_dialog")));
currentModelName = gconf_client_get_string (xkbGConfClient,
current_model_name = gconf_client_get_string (xkb_gconf_client,
GSWITCHIT_KBD_CONFIG_KEY_MODEL, NULL);
fill_models_list (chooserDialog);
fill_models_list (chooser_dialog);
g_signal_connect (G_OBJECT (chooser),
"response", G_CALLBACK (xkb_model_chooser_response), chooserDialog);
"response", G_CALLBACK (xkb_model_chooser_response), chooser_dialog);
gtk_dialog_run (GTK_DIALOG (chooser));
gtk_widget_destroy (chooser);
g_free (currentModelName);
g_free (current_model_name);
}

118
capplets/keyboard/gnome-keyboard-properties-xkbot.c
View file

@ -40,11 +40,11 @@
#include "gnome-keyboard-properties-xkb.h"
static const char *current1stLevelId = NULL;
static GtkWidget *currentVbox = NULL;
static GtkWidget *currentNoneRadio = NULL;
static gboolean currentMultiSelect = FALSE;
static GSList *currentRadioGroup = NULL;
static const char *current1st_level_id = NULL;
static GtkWidget *current_vbox = NULL;
static GtkWidget *current_none_radio = NULL;
static gboolean current_multi_select = FALSE;
static GSList *current_radio_group = NULL;
#define OPTION_ID_PROP "optionID"
#define SELCOUNTER_PROP "selectionCounter"
@ -56,16 +56,16 @@ xkb_options_get_selected_list (void)
{
GSList *retval;
retval = gconf_client_get_list (xkbGConfClient,
retval = gconf_client_get_list (xkb_gconf_client,
GSWITCHIT_KBD_CONFIG_KEY_OPTIONS,
GCONF_VALUE_STRING,
NULL);
if (retval == NULL)
{
GSList *curOption;
GSList *cur_option;
for (curOption = initialConfig.options; curOption != NULL; curOption = curOption->next)
retval = g_slist_prepend (retval, g_strdup (curOption->data));
for (cur_option = initial_config.options; cur_option != NULL; cur_option = cur_option->next)
retval = g_slist_prepend (retval, g_strdup (cur_option->data));
retval = g_slist_reverse (retval);
}
@ -97,12 +97,14 @@ xkb_options_expander_selcounter_add (GtkWidget * expander, int value)
static void
xkb_options_expander_highlight (GtkWidget * expander)
{
char * utfGroupName = g_object_get_data (G_OBJECT (expander), "utfGroupName");
char * utf_group_name = g_object_get_data (G_OBJECT (expander), "utfGroupName");
int counter = xkb_options_expander_selcounter_get (expander);
if (utf_group_name != NULL) {
gchar *titlemarkup = g_strconcat (counter > 0 ? "<span weight=\"bold\">" : "<span>",
utfGroupName, "</span>", NULL);
utf_group_name, "</span>", NULL);
gtk_expander_set_label (GTK_EXPANDER (expander), titlemarkup);
g_free (titlemarkup);
}
}
/* Add optionname from the backend's selection list if it's not
@ -111,26 +113,26 @@ static void
xkb_options_select (gchar *optionname)
{
gboolean already_selected = FALSE;
GSList *optionsList = xkb_options_get_selected_list ();
GSList *options_list = xkb_options_get_selected_list ();
GSList *option;
for (option = optionsList ; option != NULL ; option = option->next)
for (option = options_list ; option != NULL ; option = option->next)
if (!strcmp ((gchar*)option->data, optionname))
already_selected = TRUE;
if (!already_selected)
optionsList = g_slist_append (optionsList, g_strdup (optionname));
xkb_options_set_selected_list (optionsList);
options_list = g_slist_append (options_list, g_strdup (optionname));
xkb_options_set_selected_list (options_list);
clear_xkb_elements_list (optionsList);
clear_xkb_elements_list (options_list);
}
/* Remove all occurences of optionname from the backend's selection list */
static void
xkb_options_deselect (gchar *optionname)
{
GSList *optionsList = xkb_options_get_selected_list ();
GSList *options_list = xkb_options_get_selected_list ();
GSList *nodetmp;
GSList *option = optionsList;
GSList *option = options_list;
while (option != NULL)
{
gchar *id = (char *) option->data;
@ -138,15 +140,15 @@ xkb_options_deselect (gchar *optionname)
{
nodetmp = option->next;
g_free (id);
optionsList = g_slist_remove_link (optionsList, option);
options_list = g_slist_remove_link (options_list, option);
g_slist_free_1 (option);
option=nodetmp;
}
else
option = option->next;
}
xkb_options_set_selected_list (optionsList);
clear_xkb_elements_list (optionsList);
xkb_options_set_selected_list (options_list);
clear_xkb_elements_list (options_list);
}
/* Return true if optionname describes a string already in the backend's
@ -155,14 +157,14 @@ static gboolean
xkb_options_is_selected (gchar *optionname)
{
gboolean retval = FALSE;
GSList *optionsList = xkb_options_get_selected_list ();
GSList *options_list = xkb_options_get_selected_list ();
GSList *option;
for (option = optionsList ; option != NULL ; option = option->next)
for (option = options_list ; option != NULL ; option = option->next)
{
if (!strcmp ((gchar*)option->data, optionname))
retval = TRUE;
}
clear_xkb_elements_list (optionsList);
clear_xkb_elements_list (options_list);
return retval;
}
@ -205,53 +207,53 @@ option_update_cb (GConfClient * client,
This function makes particular use of the current... variables at
the top of this file. */
static void
xkb_options_add_option (XklConfigRegistry * configRegistry,
const XklConfigItem * configItem,
xkb_options_add_option (XklConfigRegistry * config_registry,
XklConfigItem * config_item,
GladeXML * dialog)
{
GtkWidget *option_check;
gchar *utfOptionName = xci_desc_to_utf8 (configItem);
gchar *utf_option_name = xci_desc_to_utf8 (config_item);
/* Copy this out because we'll load it into the widget with set_data */
gchar *fullOptionName = g_strdup(
GSwitchItKbdConfigMergeItems (current1stLevelId, configItem->name));
gchar *full_option_name = g_strdup(
gswitchit_kbd_config_merge_items (current1st_level_id, config_item->name));
gboolean initial_state;
if (currentMultiSelect)
option_check = gtk_check_button_new_with_label (utfOptionName);
if (current_multi_select)
option_check = gtk_check_button_new_with_label (utf_option_name);
else
{
if (currentRadioGroup == NULL)
if (current_radio_group == NULL)
{
/* The first radio in a group is to be "Default", meaning none of
the below options are to be included in the selected list.
This is a HIG-compliant alternative to allowing no
selection in the group. */
option_check = gtk_radio_button_new_with_label (currentRadioGroup, _("Default"));
option_check = gtk_radio_button_new_with_label (current_radio_group, _("Default"));
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (option_check), TRUE);
gtk_box_pack_start_defaults (GTK_BOX (currentVbox), option_check);
currentRadioGroup = gtk_radio_button_get_group (GTK_RADIO_BUTTON (option_check));
currentNoneRadio = option_check;
gtk_box_pack_start_defaults (GTK_BOX (current_vbox), option_check);
current_radio_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (option_check));
current_none_radio = option_check;
}
option_check = gtk_radio_button_new_with_label (currentRadioGroup, utfOptionName);
currentRadioGroup = gtk_radio_button_get_group (GTK_RADIO_BUTTON (option_check));
g_object_set_data (G_OBJECT (option_check), "NoneRadio", currentNoneRadio);
option_check = gtk_radio_button_new_with_label (current_radio_group, utf_option_name);
current_radio_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (option_check));
g_object_set_data (G_OBJECT (option_check), "NoneRadio", current_none_radio);
}
g_free (utfOptionName);
g_free (utf_option_name);
initial_state = xkb_options_is_selected (fullOptionName);
initial_state = xkb_options_is_selected (full_option_name);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (option_check), initial_state);
g_object_set_data_full (G_OBJECT (option_check), OPTION_ID_PROP, fullOptionName, g_free);
g_object_set_data_full (G_OBJECT (option_check), OPTION_ID_PROP, full_option_name, g_free);
g_signal_connect (G_OBJECT (option_check), "toggled", G_CALLBACK (option_toggled_cb), NULL);
gconf_client_notify_add (xkbGConfClient,
gconf_client_notify_add (xkb_gconf_client,
GSWITCHIT_KBD_CONFIG_KEY_OPTIONS,
(GConfClientNotifyFunc)
option_update_cb, option_check, NULL, NULL);
gtk_box_pack_start_defaults (GTK_BOX (currentVbox), option_check);
gtk_box_pack_start_defaults (GTK_BOX (current_vbox), option_check);
xkb_options_expander_selcounter_add (xkb_options_get_expander (option_check), initial_state);
g_object_set_data (G_OBJECT (option_check), GCONFSTATE_PROP, GINT_TO_POINTER (initial_state));
@ -260,36 +262,36 @@ xkb_options_add_option (XklConfigRegistry * configRegistry,
/* Add a group of options: create title and layout widgets and then
add widgets for all the options in the group. */
static void
xkb_options_add_group (XklConfigRegistry * configRegistry,
const XklConfigItem * configItem,
xkb_options_add_group (XklConfigRegistry * config_registry,
XklConfigItem * config_item,
GladeXML * dialog)
{
GtkWidget *expander, *align, *vbox;
gboolean allowMultipleSelection = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (configItem),
gboolean allow_multiple_selection = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (config_item),
XCI_PROP_ALLOW_MULTIPLE_SELECTION));
GSList * expanders_list = g_object_get_data (G_OBJECT (dialog), EXPANDERS_PROP);
gchar *utfGroupName = xci_desc_to_utf8 (configItem);
gchar *titlemarkup = g_strconcat ("<span>", utfGroupName, "</span>", NULL);
gchar *utf_group_name = xci_desc_to_utf8 (config_item);
gchar *titlemarkup = g_strconcat ("<span>", utf_group_name, "</span>", NULL);
expander = gtk_expander_new (titlemarkup);
g_object_set_data_full (G_OBJECT (expander), "utfGroupName", utfGroupName, g_free);
gtk_expander_set_use_markup (GTK_EXPANDER (expander), TRUE);
g_object_set_data_full (G_OBJECT (expander), "utfGroupName", utf_group_name, g_free);
g_free (titlemarkup);
gtk_expander_set_use_markup (GTK_EXPANDER (expander), TRUE);
align = gtk_alignment_new (0, 0, 1, 1);
gtk_alignment_set_padding (GTK_ALIGNMENT (align), 6, 12, 12, 0);
vbox = gtk_vbox_new (TRUE, 6);
gtk_container_add (GTK_CONTAINER (align), vbox);
gtk_container_add (GTK_CONTAINER (expander), align);
currentVbox = vbox;
current_vbox = vbox;
currentMultiSelect = (gboolean) allowMultipleSelection;
currentRadioGroup = NULL;
current_multi_select = (gboolean) allow_multiple_selection;
current_radio_group = NULL;
current1stLevelId = configItem->name;
xkl_config_registry_foreach_option (configRegistry, configItem->name,
current1st_level_id = config_item->name;
xkl_config_registry_foreach_option (config_registry, config_item->name,
(ConfigItemProcessFunc)xkb_options_add_option,
dialog);
@ -316,7 +318,7 @@ xkb_options_load_options (GladeXML * dialog)
GtkWidget * expander;
/* fill the list */
xkl_config_registry_foreach_option_group (configRegistry,
xkl_config_registry_foreach_option_group (config_registry,
(ConfigItemProcessFunc)xkb_options_add_group,
dialog);
/* sort it */
@ -351,7 +353,7 @@ xkb_options_update (GConfClient * client,
void
xkb_options_register_gconf_listener (GladeXML * dialog)
{
gconf_client_notify_add (xkbGConfClient,
gconf_client_notify_add (xkb_gconf_client,
GSWITCHIT_KBD_CONFIG_KEY_OPTIONS,
(GConfClientNotifyFunc)
xkb_options_update, dialog, NULL, NULL);

22
capplets/keyboard/gnome-keyboard-properties-xkbpv.c
View file

@ -65,25 +65,25 @@ xkb_layout_preview_create_widget (GladeXML * chooserDialog)
}
void
xkb_layout_preview_update (GladeXML * chooserDialog)
xkb_layout_preview_update (GladeXML * chooser_dialog)
{
#ifdef HAVE_X11_EXTENSIONS_XKB_H
GtkWidget *chooser = CWID ( "xkb_layout_chooser");
GtkWidget *availableLayoutsTree = CWID ("xkb_layouts_available");
GtkWidget *available_layouts_tree = CWID ("xkb_layouts_available");
GtkTreeSelection *selection =
gtk_tree_view_get_selection (GTK_TREE_VIEW (availableLayoutsTree));
GtkTreeIter selectedIter;
gtk_tree_view_get_selection (GTK_TREE_VIEW (available_layouts_tree));
GtkTreeIter selected_iter;
GtkTreeModel *model;
GtkWidget *kbdraw = GTK_WIDGET (g_object_get_data (G_OBJECT (chooser), "kbdraw"));
if (kbdraw != NULL &&
gtk_tree_selection_get_selected (selection, &model, &selectedIter))
gtk_tree_selection_get_selected (selection, &model, &selected_iter))
{
gchar *id;
XklConfigRec *data;
char **p, *layout, *variant;
XkbComponentNamesRec componentNames;
XkbComponentNamesRec component_names;
gtk_tree_model_get (model, &selectedIter, AVAIL_LAYOUT_TREE_COL_ID, &id, -1);
gtk_tree_model_get (model, &selected_iter, AVAIL_LAYOUT_TREE_COL_ID, &id, -1);
data = xkl_config_rec_new ();
if (xkl_config_rec_get_from_server (data, engine))
{
@ -95,7 +95,7 @@ xkb_layout_preview_update (GladeXML * chooserDialog)
data->layouts = g_new0 (char*, 2);
data->variants = g_new0 (char*, 2);
if (GSwitchItKbdConfigSplitItems (id, &layout, &variant)
if (gswitchit_kbd_config_split_items (id, &layout, &variant)
&& variant != NULL)
{
data->layouts[0] = (layout == NULL) ? NULL : g_strdup (layout);
@ -106,11 +106,11 @@ xkb_layout_preview_update (GladeXML * chooserDialog)
data->variants[0] = NULL;
}
if (xkl_xkb_config_native_prepare (engine, data, &componentNames))
if (xkl_xkb_config_native_prepare (engine, data, &component_names))
{
keyboard_drawing_set_keyboard (KEYBOARD_DRAWING (kbdraw), &componentNames);
keyboard_drawing_set_keyboard (KEYBOARD_DRAWING (kbdraw), &component_names);
xkl_xkb_config_native_cleanup (engine, &componentNames);
xkl_xkb_config_native_cleanup (engine, &component_names);
}
}
g_object_unref (G_OBJECT (data));