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> 2006-04-22 Sergey Udaltsov <svu@gnome.org>
gnome-keyboard-properties-xkblt.c: 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" #include "gnome-keyboard-properties-xkb.h"
XklEngine *engine; XklEngine *engine;
XklConfigRegistry *configRegistry; XklConfigRegistry *config_registry;
GSwitchItKbdConfig initialConfig; GSwitchItKbdConfig initial_config;
GConfClient *xkbGConfClient; GConfClient *xkb_gconf_client;
char * char *
xci_desc_to_utf8 (const XklConfigItem * ci) xci_desc_to_utf8 (XklConfigItem * ci)
{ {
char *sd = g_strstrip (ci->description); char *sd = g_strstrip (ci->description);
return sd[0] == 0 ? g_strdup (ci->name) : return sd[0] == 0 ? g_strdup (ci->name) :
@ -70,11 +70,11 @@ set_model_text (GtkWidget * entry,
} }
if (model == NULL) if (model == NULL)
model = initialConfig.model; model = initial_config.model;
g_snprintf (ci.name, sizeof (ci.name), "%s", 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; char * d;
@ -105,14 +105,14 @@ setup_model_entry (GladeXML * dialog)
{ {
GConfValue * value; GConfValue * value;
value = gconf_client_get (xkbGConfClient, value = gconf_client_get (xkb_gconf_client,
GSWITCHIT_KBD_CONFIG_KEY_MODEL, GSWITCHIT_KBD_CONFIG_KEY_MODEL,
NULL); NULL);
set_model_text (WID ("xkb_model"), value); set_model_text (WID ("xkb_model"), value);
if (value != NULL) if (value != NULL)
gconf_value_free (value); gconf_value_free (value);
gconf_client_notify_add (xkbGConfClient, gconf_client_notify_add (xkb_gconf_client,
GSWITCHIT_KBD_CONFIG_KEY_MODEL, GSWITCHIT_KBD_CONFIG_KEY_MODEL,
(GConfClientNotifyFunc) model_key_changed, (GConfClientNotifyFunc) model_key_changed,
dialog, NULL, NULL); dialog, NULL, NULL);
@ -121,24 +121,24 @@ setup_model_entry (GladeXML * dialog)
static void static void
cleanup_xkb_tabs (GladeXML * dialog) cleanup_xkb_tabs (GladeXML * dialog)
{ {
GSwitchItKbdConfigTerm (&initialConfig); gswitchit_kbd_config_term (&initial_config);
g_object_unref (G_OBJECT (configRegistry)); g_object_unref (G_OBJECT (config_registry));
configRegistry = NULL; config_registry = NULL;
g_object_unref (G_OBJECT (engine)); g_object_unref (G_OBJECT (engine));
engine = NULL; engine = NULL;
g_object_unref (G_OBJECT (xkbGConfClient)); g_object_unref (G_OBJECT (xkb_gconf_client));
xkbGConfClient = NULL; xkb_gconf_client = NULL;
} }
static void static void
reset_to_defaults (GtkWidget * button, GladeXML * dialog) reset_to_defaults (GtkWidget * button, GladeXML * dialog)
{ {
GSwitchItKbdConfig emptyKbdConfig; GSwitchItKbdConfig empty_kbd_config;
GSwitchItKbdConfigInit (&emptyKbdConfig, xkbGConfClient, engine); gswitchit_kbd_config_init (&empty_kbd_config, xkb_gconf_client, engine);
GSwitchItKbdConfigSaveToGConfBackup (&emptyKbdConfig); gswitchit_kbd_config_save_to_gconf_backup (&empty_kbd_config);
GSwitchItKbdConfigSaveToGConf (&emptyKbdConfig); gswitchit_kbd_config_save_to_gconf (&empty_kbd_config);
GSwitchItKbdConfigTerm (&emptyKbdConfig); gswitchit_kbd_config_term (&empty_kbd_config);
/* all the rest is g-s-d's business */ /* all the rest is g-s-d's business */
} }
@ -156,14 +156,14 @@ void
setup_xkb_tabs (GladeXML * dialog, GConfChangeSet * changeset) setup_xkb_tabs (GladeXML * dialog, GConfChangeSet * changeset)
{ {
GObject * peditor; GObject * peditor;
xkbGConfClient = gconf_client_get_default (); xkb_gconf_client = gconf_client_get_default ();
engine = xkl_engine_get_instance (GDK_DISPLAY ()); engine = xkl_engine_get_instance (GDK_DISPLAY ());
configRegistry = xkl_config_registry_get_instance (engine); config_registry = xkl_config_registry_get_instance (engine);
xkl_config_registry_load (configRegistry); xkl_config_registry_load (config_registry);
GSwitchItKbdConfigInit (&initialConfig, xkbGConfClient, engine); gswitchit_kbd_config_init (&initial_config, xkb_gconf_client, engine);
GSwitchItKbdConfigLoadFromXInitial (&initialConfig); gswitchit_kbd_config_load_from_x_initial (&initial_config);
setup_model_entry (dialog); setup_model_entry (dialog);
@ -196,7 +196,7 @@ setup_xkb_tabs (GladeXML * dialog, GConfChangeSet * changeset)
enable_disable_restoring (dialog); enable_disable_restoring (dialog);
xkb_layouts_enable_disable_default (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, GSWITCHIT_CONFIG_KEY_GROUP_PER_WINDOW,
NULL)); NULL));
} }
@ -207,11 +207,11 @@ enable_disable_restoring (GladeXML * dialog)
GSwitchItKbdConfig gswic; GSwitchItKbdConfig gswic;
gboolean enable; gboolean enable;
GSwitchItKbdConfigInit (&gswic, xkbGConfClient, engine); gswitchit_kbd_config_init (&gswic, xkb_gconf_client, engine);
GSwitchItKbdConfigLoadFromGConf (&gswic, NULL); 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); 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_DESCRIPTION 0
#define AVAIL_LAYOUT_TREE_COL_ID 1 #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 XklEngine *engine;
extern XklConfigRegistry *configRegistry; extern XklConfigRegistry *config_registry;
extern GConfClient *xkbGConfClient; extern GConfClient *xkb_gconf_client;
extern GSwitchItKbdConfig initialConfig; extern GSwitchItKbdConfig initial_config;
extern void setup_xkb_tabs (GladeXML * dialog, extern void setup_xkb_tabs (GladeXML * dialog,
GConfChangeSet * changeset); GConfChangeSet * changeset);
@ -73,9 +73,9 @@ extern void xkb_options_load_options (GladeXML * dialog);
extern void clear_xkb_elements_list (GSList * list); 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); extern void enable_disable_restoring (GladeXML * dialog);
@ -101,9 +101,9 @@ extern GSList *xkb_options_get_selected_list (void);
GSWITCHIT_KBD_CONFIG_KEY_OPTIONS, \ GSWITCHIT_KBD_CONFIG_KEY_OPTIONS, \
GCONF_VALUE_STRING, (list), NULL) 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 G_END_DECLS
#endif /* __GNOME_KEYBOARD_PROPERTY_XKB_H */ #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 GROUP_SWITCHERS_GROUP "grp"
#define DEFAULT_GROUP_SWITCH "grp:alts_toggle" #define DEFAULT_GROUP_SWITCH "grp:alts_toggle"
static GtkTreeIter current1stLevelIter; static GtkTreeIter current1st_level_iter;
static const char *current1stLevelId; static const char *current1st_level_id;
static int idx2Select = -1; static int idx2select = -1;
static int maxSelectedLayouts = -1; static int max_selected_layouts = -1;
static int defaultGroup = -1; static int default_group = -1;
static GtkCellRenderer *textRenderer; static GtkCellRenderer *text_renderer;
static GtkCellRenderer *toggleRenderer; static GtkCellRenderer *toggle_renderer;
static gboolean disableButtonsSensibilityUpdate = FALSE; static gboolean disable_buttons_sensibility_update = FALSE;
void void
clear_xkb_elements_list (GSList * list) clear_xkb_elements_list (GSList * list)
@ -72,16 +72,16 @@ xkb_layouts_get_selected_list (void)
{ {
GSList *retval; GSList *retval;
retval = gconf_client_get_list (xkbGConfClient, retval = gconf_client_get_list (xkb_gconf_client,
GSWITCHIT_KBD_CONFIG_KEY_LAYOUTS, GSWITCHIT_KBD_CONFIG_KEY_LAYOUTS,
GCONF_VALUE_STRING, GCONF_VALUE_STRING,
NULL); NULL);
if (retval == NULL) if (retval == NULL)
{ {
GSList *curLayout; GSList *cur_layout;
for (curLayout = initialConfig.layouts; curLayout != NULL; curLayout = curLayout->next) for (cur_layout = initial_config.layouts; cur_layout != NULL; cur_layout = cur_layout->next)
retval = g_slist_prepend (retval, g_strdup (curLayout->data)); retval = g_slist_prepend (retval, g_strdup (cur_layout->data));
retval = g_slist_reverse (retval); retval = g_slist_reverse (retval);
} }
@ -90,14 +90,14 @@ xkb_layouts_get_selected_list (void)
} }
static 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, GSWITCHIT_CONFIG_KEY_DEFAULT_GROUP,
NULL)) NULL))
gconf_client_set_int (xkbGConfClient, gconf_client_set_int (xkb_gconf_client,
GSWITCHIT_CONFIG_KEY_DEFAULT_GROUP, GSWITCHIT_CONFIG_KEY_DEFAULT_GROUP,
aDefaultGroup, default_group,
NULL); NULL);
} }
@ -107,16 +107,16 @@ def_group_in_ui_changed (GtkCellRendererToggle *cell_renderer,
GladeXML * dialog) GladeXML * dialog)
{ {
GtkTreePath *chpath = gtk_tree_path_new_from_string (path); GtkTreePath *chpath = gtk_tree_path_new_from_string (path);
int newDefaultGroup = -1; int new_default_group = -1;
gboolean previouslySelected = gtk_cell_renderer_toggle_get_active (cell_renderer); 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); 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); gtk_tree_path_free (chpath);
} }
@ -129,22 +129,22 @@ def_group_in_gconf_changed (GConfClient * client,
if (value->type == GCONF_VALUE_INT) if (value->type == GCONF_VALUE_INT)
{ {
GtkWidget* treeView = WID ("xkb_layouts_selected"); GtkWidget* tree_view = WID ("xkb_layouts_selected");
GtkTreeModel *model = GTK_TREE_MODEL (gtk_tree_view_get_model (GTK_TREE_VIEW (treeView))); GtkTreeModel *model = GTK_TREE_MODEL (gtk_tree_view_get_model (GTK_TREE_VIEW (tree_view)));
GtkTreeIter iter; GtkTreeIter iter;
int counter = 0; 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)) if (gtk_tree_model_get_iter_first (model, &iter))
{ {
do do
{ {
gboolean curVal; gboolean cur_val;
gtk_tree_model_get (model, &iter, gtk_tree_model_get (model, &iter,
SEL_LAYOUT_TREE_COL_DEFAULT, &curVal, SEL_LAYOUT_TREE_COL_DEFAULT, &cur_val,
-1); -1);
if (curVal != ( counter == defaultGroup)) if (cur_val != ( counter == default_group))
gtk_list_store_set (GTK_LIST_STORE (model), &iter, 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); -1);
counter++; counter++;
} }
@ -154,107 +154,107 @@ def_group_in_gconf_changed (GConfClient * client,
} }
static void static void
add_variant_to_available_layouts_tree (XklConfigRegistry * configRegistry, add_variant_to_available_layouts_tree (XklConfigRegistry * config_registry,
const XklConfigItem * configItem, XklConfigItem * config_item,
GladeXML * chooserDialog) GladeXML * chooser_dialog)
{ {
GtkWidget *layoutsTree = CWID ("xkb_layouts_available"); GtkWidget *layouts_tree = CWID ("xkb_layouts_available");
GtkTreeIter iter; GtkTreeIter iter;
GtkTreeStore *treeStore = GtkTreeStore *tree_store =
GTK_TREE_STORE (gtk_tree_view_get_model (GTK_TREE_VIEW (layoutsTree))); GTK_TREE_STORE (gtk_tree_view_get_model (GTK_TREE_VIEW (layouts_tree)));
const gchar *fullLayoutName = GSwitchItKbdConfigMergeItems (current1stLevelId, const gchar *full_layout_name = gswitchit_kbd_config_merge_items (current1st_level_id,
configItem->name); config_item->name);
char *utfVariantName = xci_desc_to_utf8 (configItem); char *utf_variant_name = xci_desc_to_utf8 (config_item);
gtk_tree_store_append (treeStore, &iter, &current1stLevelIter); gtk_tree_store_append (tree_store, &iter, &current1st_level_iter);
gtk_tree_store_set (treeStore, &iter, gtk_tree_store_set (tree_store, &iter,
AVAIL_LAYOUT_TREE_COL_DESCRIPTION, utfVariantName, AVAIL_LAYOUT_TREE_COL_DESCRIPTION, utf_variant_name,
AVAIL_LAYOUT_TREE_COL_ID, fullLayoutName, -1); AVAIL_LAYOUT_TREE_COL_ID, full_layout_name, -1);
g_free (utfVariantName); g_free (utf_variant_name);
} }
static void static void
add_layout_to_available_layouts_tree (XklConfigRegistry * configRegistry, add_layout_to_available_layouts_tree (XklConfigRegistry * config_registry,
const XklConfigItem * configItem, XklConfigItem * config_item,
GladeXML * chooserDialog) GladeXML * chooser_dialog)
{ {
GtkWidget *layoutsTree = CWID ("xkb_layouts_available"); GtkWidget *layouts_tree = CWID ("xkb_layouts_available");
GtkTreeStore *treeStore = GtkTreeStore *tree_store =
GTK_TREE_STORE (gtk_tree_view_get_model (GTK_TREE_VIEW (layoutsTree))); GTK_TREE_STORE (gtk_tree_view_get_model (GTK_TREE_VIEW (layouts_tree)));
char *utfLayoutName = xci_desc_to_utf8 (configItem); char *utf_layout_name = xci_desc_to_utf8 (config_item);
gtk_tree_store_append (treeStore, &current1stLevelIter, NULL); gtk_tree_store_append (tree_store, &current1st_level_iter, NULL);
gtk_tree_store_set (treeStore, &current1stLevelIter, gtk_tree_store_set (tree_store, &current1st_level_iter,
AVAIL_LAYOUT_TREE_COL_DESCRIPTION, utfLayoutName, AVAIL_LAYOUT_TREE_COL_DESCRIPTION, utf_layout_name,
AVAIL_LAYOUT_TREE_COL_ID, configItem->name, -1); AVAIL_LAYOUT_TREE_COL_ID, config_item->name, -1);
g_free (utfLayoutName); 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, (ConfigItemProcessFunc)add_variant_to_available_layouts_tree,
chooserDialog); chooser_dialog);
} }
static void static void
xkb_layouts_enable_disable_buttons (GladeXML * dialog) xkb_layouts_enable_disable_buttons (GladeXML * dialog)
{ {
GtkWidget *addLayoutBtn = WID ("xkb_layouts_add"); GtkWidget *add_layout_btn = WID ("xkb_layouts_add");
GtkWidget *delLayoutBtn = WID ("xkb_layouts_remove"); GtkWidget *del_layout_btn = WID ("xkb_layouts_remove");
GtkWidget *upLayoutBtn = WID ("xkb_layouts_up"); GtkWidget *up_layout_btn = WID ("xkb_layouts_up");
GtkWidget *dnLayoutBtn = WID ("xkb_layouts_down"); GtkWidget *dn_layout_btn = WID ("xkb_layouts_down");
GtkWidget *selectedLayoutsTree = WID ("xkb_layouts_selected"); GtkWidget *selected_layouts_tree = WID ("xkb_layouts_selected");
GtkTreeSelection *sSelection = GtkTreeSelection *s_selection =
gtk_tree_view_get_selection (GTK_TREE_VIEW (selectedLayoutsTree)); gtk_tree_view_get_selection (GTK_TREE_VIEW (selected_layouts_tree));
const int nSelectedSelectedLayouts = const int n_selected_selected_layouts =
gtk_tree_selection_count_selected_rows (sSelection); gtk_tree_selection_count_selected_rows (s_selection);
gboolean canMoveUp = FALSE; gboolean can_move_up = FALSE;
gboolean canMoveDn = FALSE; gboolean can_move_dn = FALSE;
GtkTreeIter iter; GtkTreeIter iter;
GtkTreeModel *selectedLayoutsModel = gtk_tree_view_get_model GtkTreeModel *selected_layouts_model = gtk_tree_view_get_model
(GTK_TREE_VIEW (selectedLayoutsTree)); (GTK_TREE_VIEW (selected_layouts_tree));
const int nSelectedLayouts = const int n_selected_layouts =
gtk_tree_model_iter_n_children (selectedLayoutsModel, gtk_tree_model_iter_n_children (selected_layouts_model,
NULL); NULL);
if (disableButtonsSensibilityUpdate) if (disable_buttons_sensibility_update)
return; return;
gtk_widget_set_sensitive (addLayoutBtn, gtk_widget_set_sensitive (add_layout_btn,
(nSelectedLayouts < maxSelectedLayouts || (n_selected_layouts < max_selected_layouts ||
maxSelectedLayouts == 0)); max_selected_layouts == 0));
gtk_widget_set_sensitive (delLayoutBtn, nSelectedSelectedLayouts > 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); &iter);
if (path != NULL) if (path != NULL)
{ {
int *indices = gtk_tree_path_get_indices (path); int *indices = gtk_tree_path_get_indices (path);
int idx = indices[0]; int idx = indices[0];
canMoveUp = idx > 0; can_move_up = idx > 0;
canMoveDn = idx < (nSelectedLayouts - 1); can_move_dn = idx < (n_selected_layouts - 1);
gtk_tree_path_free (path); gtk_tree_path_free (path);
} }
} }
gtk_widget_set_sensitive (upLayoutBtn, canMoveUp); gtk_widget_set_sensitive (up_layout_btn, can_move_up);
gtk_widget_set_sensitive (dnLayoutBtn, canMoveDn); gtk_widget_set_sensitive (dn_layout_btn, can_move_dn);
} }
static void 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"); GtkWidget *available_layouts_tree = CWID ("xkb_layouts_available");
GtkTreeSelection *aSelection = GtkTreeSelection *selection =
gtk_tree_view_get_selection (GTK_TREE_VIEW (availableLayoutsTree)); gtk_tree_view_get_selection (GTK_TREE_VIEW (available_layouts_tree));
const int nSelectedAvailableLayouts = const int n_selected_available_layouts =
gtk_tree_selection_count_selected_rows (aSelection); gtk_tree_selection_count_selected_rows (selection);
gtk_dialog_set_response_sensitive (GTK_DIALOG (CWID ("xkb_layout_chooser")), 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, void xkb_layouts_enable_disable_default (GladeXML * dialog,
@ -263,62 +263,62 @@ void xkb_layouts_enable_disable_default (GladeXML * dialog,
GValue val = {0}; GValue val = {0};
g_value_init (&val, G_TYPE_BOOLEAN); g_value_init (&val, G_TYPE_BOOLEAN);
g_value_set_boolean (&val, enable); 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 void
xkb_layouts_prepare_selected_tree (GladeXML * dialog, GConfChangeSet * changeset) 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); gtk_list_store_new (3, G_TYPE_STRING, G_TYPE_BOOLEAN, G_TYPE_STRING);
GtkWidget *treeView = WID ("xkb_layouts_selected"); GtkWidget *tree_view = WID ("xkb_layouts_selected");
GtkTreeViewColumn * descColumn, * defColumn; GtkTreeViewColumn * desc_column, * def_column;
GtkTreeSelection *selection; GtkTreeSelection *selection;
textRenderer = GTK_CELL_RENDERER (gtk_cell_renderer_text_new ()); text_renderer = GTK_CELL_RENDERER (gtk_cell_renderer_text_new ());
toggleRenderer = GTK_CELL_RENDERER (gtk_cell_renderer_toggle_new ()); toggle_renderer = GTK_CELL_RENDERER (gtk_cell_renderer_toggle_new ());
descColumn = gtk_tree_view_column_new_with_attributes (_("Layout"), desc_column = gtk_tree_view_column_new_with_attributes (_("Layout"),
textRenderer, text_renderer,
"text", SEL_LAYOUT_TREE_COL_DESCRIPTION, "text", SEL_LAYOUT_TREE_COL_DESCRIPTION,
NULL); NULL);
defColumn = gtk_tree_view_column_new_with_attributes (_("Default"), def_column = gtk_tree_view_column_new_with_attributes (_("Default"),
toggleRenderer, toggle_renderer,
"active", SEL_LAYOUT_TREE_COL_DEFAULT, "active", SEL_LAYOUT_TREE_COL_DEFAULT,
NULL); 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_view_set_model (GTK_TREE_VIEW (tree_view),
GTK_TREE_MODEL (listStore)); GTK_TREE_MODEL (list_store));
gtk_tree_view_column_set_sizing (descColumn, GTK_TREE_VIEW_COLUMN_AUTOSIZE); gtk_tree_view_column_set_sizing (desc_column, GTK_TREE_VIEW_COLUMN_AUTOSIZE);
gtk_tree_view_column_set_sizing (defColumn, GTK_TREE_VIEW_COLUMN_AUTOSIZE); gtk_tree_view_column_set_sizing (def_column, GTK_TREE_VIEW_COLUMN_AUTOSIZE);
gtk_tree_view_column_set_resizable (descColumn, TRUE); gtk_tree_view_column_set_resizable (desc_column, TRUE);
gtk_tree_view_column_set_resizable (defColumn, 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 (tree_view), desc_column);
gtk_tree_view_append_column (GTK_TREE_VIEW (treeView), defColumn); gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view), def_column);
g_signal_connect_swapped (G_OBJECT (selection), "changed", g_signal_connect_swapped (G_OBJECT (selection), "changed",
G_CALLBACK G_CALLBACK
(xkb_layouts_enable_disable_buttons), dialog); (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, GSWITCHIT_CONFIG_KEY_DEFAULT_GROUP,
(GConfClientNotifyFunc)def_group_in_gconf_changed, (GConfClientNotifyFunc)def_group_in_gconf_changed,
dialog, dialog,
NULL, NULL,
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); G_CALLBACK (def_group_in_ui_changed), dialog);
} }
static void static void
xkb_layout_chooser_selection_changed (GladeXML * chooserDialog) xkb_layout_chooser_selection_changed (GladeXML * chooser_dialog)
{ {
xkb_layout_preview_update (chooserDialog); xkb_layout_preview_update (chooser_dialog);
xkb_layout_chooser_enable_disable_buttons (chooserDialog); xkb_layout_chooser_enable_disable_buttons (chooser_dialog);
} }
void void
@ -326,49 +326,49 @@ xkb_layouts_fill_selected_tree (GladeXML * dialog)
{ {
GConfEntry *gce; GConfEntry *gce;
GSList *layouts = xkb_layouts_get_selected_list (); GSList *layouts = xkb_layouts_get_selected_list ();
GSList *curLayout; GSList *cur_layout;
GtkListStore *listStore = GtkListStore *list_store =
GTK_LIST_STORE (gtk_tree_view_get_model GTK_LIST_STORE (gtk_tree_view_get_model
(GTK_TREE_VIEW (WID ("xkb_layouts_selected")))); (GTK_TREE_VIEW (WID ("xkb_layouts_selected"))));
/* temporarily disable the buttons' status update */ /* 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; GtkTreeIter iter;
char *l, *sl, *v, *sv; char *l, *sl, *v, *sv;
char *v1, *utfVisible; char *v1, *utf_visible;
const char *visible = (char *) curLayout->data; const char *visible = (char *) cur_layout->data;
gtk_list_store_append (listStore, &iter); gtk_list_store_append (list_store, &iter);
if (GSwitchItKbdConfigGetDescriptions (configRegistry, visible, &sl, &l, &sv, &v)) if (gswitchit_kbd_config_get_descriptions (config_registry, visible, &sl, &l, &sv, &v))
visible = GSwitchItKbdConfigFormatFullLayout (l, v); visible = gswitchit_kbd_config_format_full_layout (l, v);
v1 = g_strdup (visible); v1 = g_strdup (visible);
utfVisible = g_locale_to_utf8 (g_strstrip (v1), -1, NULL, NULL, NULL); utf_visible = g_locale_to_utf8 (g_strstrip (v1), -1, NULL, NULL, NULL);
gtk_list_store_set (listStore, &iter, gtk_list_store_set (list_store, &iter,
SEL_LAYOUT_TREE_COL_DESCRIPTION, utfVisible, SEL_LAYOUT_TREE_COL_DESCRIPTION, utf_visible,
SEL_LAYOUT_TREE_COL_DEFAULT, FALSE, SEL_LAYOUT_TREE_COL_DEFAULT, FALSE,
SEL_LAYOUT_TREE_COL_ID, curLayout->data, -1); SEL_LAYOUT_TREE_COL_ID, cur_layout->data, -1);
g_free (utfVisible); g_free (utf_visible);
g_free (v1); g_free (v1);
} }
clear_xkb_elements_list (layouts); clear_xkb_elements_list (layouts);
/* enable the buttons' status update */ /* enable the buttons' status update */
disableButtonsSensibilityUpdate = FALSE; disable_buttons_sensibility_update = FALSE;
if (idx2Select != -1) if (idx2select != -1)
{ {
GtkTreeSelection *selection = GtkTreeSelection *selection =
gtk_tree_view_get_selection ((GTK_TREE_VIEW gtk_tree_view_get_selection ((GTK_TREE_VIEW
(WID ("xkb_layouts_selected")))); (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_selection_select_path (selection, path);
gtk_tree_path_free (path); gtk_tree_path_free (path);
idx2Select = -1; idx2select = -1;
} }
else else
{ {
@ -377,34 +377,34 @@ xkb_layouts_fill_selected_tree (GladeXML * dialog)
xkb_layouts_enable_disable_buttons (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, GSWITCHIT_CONFIG_KEY_DEFAULT_GROUP,
NULL, NULL,
TRUE, TRUE,
NULL); NULL);
def_group_in_gconf_changed (xkbGConfClient, -1, gce, dialog); def_group_in_gconf_changed (xkb_gconf_client, -1, gce, dialog);
} }
void void
sort_tree_content (GtkWidget * treeView) sort_tree_content (GtkWidget * tree_view)
{ {
GtkTreeModel *treeModel = GtkTreeModel *tree_model =
gtk_tree_view_get_model (GTK_TREE_VIEW (treeView)); gtk_tree_view_get_model (GTK_TREE_VIEW (tree_view));
GtkTreeModel *sortedTreeModel; GtkTreeModel *sorted_tree_model;
/* replace the store with the sorted version */ /* 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 gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE
(sortedTreeModel), 0, (sorted_tree_model), 0,
GTK_SORT_ASCENDING); 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 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); 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 = GtkCellRenderer *renderer =
GTK_CELL_RENDERER (gtk_cell_renderer_text_new ()); GTK_CELL_RENDERER (gtk_cell_renderer_text_new ());
GtkTreeViewColumn *column = gtk_tree_view_column_new_with_attributes (NULL, 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, AVAIL_LAYOUT_TREE_COL_DESCRIPTION,
NULL); NULL);
GtkTreeSelection *selection = 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_view_set_model (GTK_TREE_VIEW (tree_view),
GTK_TREE_MODEL (treeStore)); GTK_TREE_MODEL (tree_store));
gtk_tree_view_append_column (GTK_TREE_VIEW (treeView), column); gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view), column);
xkl_config_registry_foreach_layout (configRegistry, (ConfigItemProcessFunc) xkl_config_registry_foreach_layout (config_registry, (ConfigItemProcessFunc)
add_layout_to_available_layouts_tree, chooserDialog); 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_signal_connect_swapped (G_OBJECT (selection), "changed",
G_CALLBACK G_CALLBACK
(xkb_layout_chooser_selection_changed), chooserDialog); (xkb_layout_chooser_selection_changed), chooser_dialog);
} }
static void static void
@ -440,21 +440,21 @@ move_selected_layout (GladeXML * dialog, int offset)
GtkTreeSelection *selection = GtkTreeSelection *selection =
gtk_tree_view_get_selection (GTK_TREE_VIEW gtk_tree_view_get_selection (GTK_TREE_VIEW
(WID ("xkb_layouts_selected"))); (WID ("xkb_layouts_selected")));
GtkTreeIter selectedIter; GtkTreeIter selected_iter;
GtkTreeModel *model; 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, GtkTreePath *path = gtk_tree_model_get_path (model,
&selectedIter); &selected_iter);
if (path != NULL) if (path != NULL)
{ {
int *indices = gtk_tree_path_get_indices (path); int *indices = gtk_tree_path_get_indices (path);
int idx = indices[0]; int idx = indices[0];
char *id = NULL; 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; id = (char *) node2Remove->data;
g_slist_free_1 (node2Remove); g_slist_free_1 (node2Remove);
@ -462,26 +462,26 @@ move_selected_layout (GladeXML * dialog, int offset)
if (offset == 0) if (offset == 0)
{ {
g_free (id); g_free (id);
if (defaultGroup > idx) if (default_group > idx)
save_default_group (defaultGroup - 1); save_default_group (default_group - 1);
else if (defaultGroup == idx) else if (default_group == idx)
save_default_group (-1); save_default_group (-1);
} }
else else
{ {
layoutsList = layouts_list =
g_slist_insert (layoutsList, id, idx + offset); g_slist_insert (layouts_list, id, idx + offset);
idx2Select = idx + offset; idx2select = idx + offset;
if (idx == defaultGroup) if (idx == default_group)
save_default_group (idx2Select); save_default_group (idx2select);
else if (idx2Select == defaultGroup) else if (idx2select == default_group)
save_default_group (idx); save_default_group (idx);
} }
xkb_layouts_set_selected_list (layoutsList); xkb_layouts_set_selected_list (layouts_list);
gtk_tree_path_free (path); 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 static void
xkb_layout_chooser_response(GtkDialog *dialog, xkb_layout_chooser_response(GtkDialog *dialog,
gint response, gint response,
GladeXML *chooserDialog) GladeXML *chooser_dialog)
{ {
GdkRectangle rect; GdkRectangle rect;
@ -528,57 +528,57 @@ xkb_layout_chooser_response(GtkDialog *dialog,
GtkTreeSelection *selection = GtkTreeSelection *selection =
gtk_tree_view_get_selection (GTK_TREE_VIEW gtk_tree_view_get_selection (GTK_TREE_VIEW
(CWID ("xkb_layouts_available"))); (CWID ("xkb_layouts_available")));
GtkTreeIter selectedIter; GtkTreeIter selected_iter;
GtkTreeModel *model; GtkTreeModel *model;
if (gtk_tree_selection_get_selected (selection, &model, &selectedIter)) if (gtk_tree_selection_get_selected (selection, &model, &selected_iter))
{ {
gchar *id; gchar *id;
GSList *layoutsList = xkb_layouts_get_selected_list (); GSList *layouts_list = xkb_layouts_get_selected_list ();
gtk_tree_model_get (model, &selectedIter, gtk_tree_model_get (model, &selected_iter,
AVAIL_LAYOUT_TREE_COL_ID, &id, -1); AVAIL_LAYOUT_TREE_COL_ID, &id, -1);
layoutsList = g_slist_append (layoutsList, id); layouts_list = g_slist_append (layouts_list, id);
xkb_layouts_set_selected_list (layoutsList); xkb_layouts_set_selected_list (layouts_list);
/* process default switcher */ /* process default switcher */
if (g_slist_length(layoutsList) >= 2) if (g_slist_length(layouts_list) >= 2)
{ {
GSList *optionsList = xkb_options_get_selected_list (); GSList *options_list = xkb_options_get_selected_list ();
gboolean anySwitcher = False; gboolean any_switcher = False;
GSList *option = optionsList; GSList *option = options_list;
while (option != NULL) while (option != NULL)
{ {
char *g, *o; 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)) if (!g_ascii_strcasecmp (g, GROUP_SWITCHERS_GROUP))
{ {
anySwitcher = True; any_switcher = True;
break; break;
} }
} }
option = option->next; option = option->next;
} }
if (!anySwitcher) if (!any_switcher)
{ {
XklConfigItem ci; XklConfigItem ci;
g_snprintf(ci.name, XKL_MAX_CI_NAME_LENGTH, DEFAULT_GROUP_SWITCH ); 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, GROUP_SWITCHERS_GROUP,
&ci)) &ci))
{ {
const gchar* id = GSwitchItKbdConfigMergeItems (GROUP_SWITCHERS_GROUP, DEFAULT_GROUP_SWITCH); const gchar* id = gswitchit_kbd_config_merge_items (GROUP_SWITCHERS_GROUP, DEFAULT_GROUP_SWITCH);
optionsList = g_slist_append (optionsList, g_strdup (id)); options_list = g_slist_append (options_list, g_strdup (id));
xkb_options_set_selected_list (optionsList); 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_position (GTK_WINDOW (dialog), &rect.x, &rect.y);
gtk_window_get_size (GTK_WINDOW (dialog), &rect.width, &rect.height); gtk_window_get_size (GTK_WINDOW (dialog), &rect.width, &rect.height);
GSwitchItPreviewSave (&rect); gswitchit_preview_save (&rect);
} }
static void static void
@ -592,7 +592,7 @@ xkb_layouts_update_list (GConfClient * client,
void void
xkb_layouts_register_gconf_listener (GladeXML * dialog) xkb_layouts_register_gconf_listener (GladeXML * dialog)
{ {
gconf_client_notify_add (xkbGConfClient, gconf_client_notify_add (xkb_gconf_client,
GSWITCHIT_KBD_CONFIG_KEY_LAYOUTS, GSWITCHIT_KBD_CONFIG_KEY_LAYOUTS,
(GConfClientNotifyFunc) (GConfClientNotifyFunc)
xkb_layouts_update_list, dialog, NULL, NULL); xkb_layouts_update_list, dialog, NULL, NULL);
@ -601,20 +601,20 @@ xkb_layouts_register_gconf_listener (GladeXML * dialog)
void void
xkb_layout_choose (GladeXML * dialog) 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* chooser = CWID ( "xkb_layout_chooser");
GtkWidget* kbdraw = NULL; GtkWidget* kbdraw = NULL;
GtkWidget* toplevel = NULL; GtkWidget* toplevel = NULL;
gtk_window_set_transient_for (GTK_WINDOW (chooser), GTK_WINDOW (WID ("keyboard_dialog"))); gtk_window_set_transient_for (GTK_WINDOW (chooser), GTK_WINDOW (WID ("keyboard_dialog")));
xkb_layouts_fill_available_tree (chooserDialog); xkb_layouts_fill_available_tree (chooser_dialog);
xkb_layout_chooser_selection_changed (chooserDialog); xkb_layout_chooser_selection_changed (chooser_dialog);
#ifdef HAVE_X11_EXTENSIONS_XKB_H #ifdef HAVE_X11_EXTENSIONS_XKB_H
if (!strcmp (xkl_engine_get_backend_name (engine), "XKB")) 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); g_object_set_data (G_OBJECT (chooser), "kbdraw", kbdraw);
gtk_container_add (GTK_CONTAINER (CWID ("vboxPreview")), kbdraw); gtk_container_add (GTK_CONTAINER (CWID ("vboxPreview")), kbdraw);
gtk_widget_show_all (kbdraw); gtk_widget_show_all (kbdraw);
@ -625,12 +625,12 @@ xkb_layout_choose (GladeXML * dialog)
} }
g_signal_connect (G_OBJECT (chooser), 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); toplevel = gtk_widget_get_toplevel (chooser);
if (GTK_WIDGET_TOPLEVEL (toplevel)) if (GTK_WIDGET_TOPLEVEL (toplevel))
{ {
GdkRectangle *rect = GSwitchItPreviewLoad (); GdkRectangle *rect = gswitchit_preview_load ();
if (rect != NULL) if (rect != NULL)
{ {
gtk_window_move (GTK_WINDOW (toplevel), rect->x, rect->y); 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" #include "gnome-keyboard-properties-xkb.h"
static gchar* currentModelName = NULL; static gchar* current_model_name = NULL;
static void static void
add_model_to_list (XklConfigRegistry * configRegistry, add_model_to_list (XklConfigRegistry * config_registry,
const XklConfigItem * configItem, XklConfigItem * config_item,
GtkTreeView * modelsList) GtkTreeView * models_list)
{ {
GtkTreeIter iter; GtkTreeIter iter;
GtkListStore * listStore = GTK_LIST_STORE (gtk_tree_view_get_model (modelsList)); GtkListStore * list_store = GTK_LIST_STORE (gtk_tree_view_get_model (models_list));
char *utfModelName = xci_desc_to_utf8 (configItem); char *utf_model_name = xci_desc_to_utf8 (config_item);
gtk_list_store_append( listStore, &iter ); gtk_list_store_append( list_store, &iter );
gtk_list_store_set( listStore, &iter, gtk_list_store_set( list_store, &iter,
0, utfModelName, 0, utf_model_name,
1, configItem->name, -1 ); 1, config_item->name, -1 );
g_free (utfModelName); g_free (utf_model_name);
} }
static void static void
xkb_model_chooser_change_sel (GtkTreeSelection* selection, xkb_model_chooser_change_sel (GtkTreeSelection* selection,
GladeXML* chooserDialog) GladeXML* chooser_dialog)
{ {
gboolean anysel = gtk_tree_selection_get_selected (selection, NULL, NULL); gboolean anysel = gtk_tree_selection_get_selected (selection, NULL, NULL);
gtk_dialog_set_response_sensitive (GTK_DIALOG (CWID ("xkb_model_chooser")), gtk_dialog_set_response_sensitive (GTK_DIALOG (CWID ("xkb_model_chooser")),
@ -68,79 +68,79 @@ xkb_model_chooser_change_sel (GtkTreeSelection* selection,
} }
static void 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; GtkTreeIter iter;
GtkTreePath *path; GtkTreePath *path;
GtkCellRenderer* renderer = gtk_cell_renderer_text_new (); 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, renderer,
"text", 0, "text", 0,
NULL); NULL);
GtkListStore *listStore = gtk_list_store_new (2, G_TYPE_STRING, G_TYPE_STRING); GtkListStore *list_store = gtk_list_store_new (2, G_TYPE_STRING, G_TYPE_STRING);
char *modelName; char *model_name;
gtk_tree_view_column_set_visible (descriptionCol, TRUE); gtk_tree_view_column_set_visible (description_col, TRUE);
gtk_tree_view_append_column (GTK_TREE_VIEW (modelsList), descriptionCol); 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); 0, GTK_SORT_ASCENDING);
xkl_config_registry_foreach_model (configRegistry, xkl_config_registry_foreach_model (config_registry,
(ConfigItemProcessFunc) add_model_to_list, (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 do
{ {
gtk_tree_model_get (GTK_TREE_MODEL (listStore), &iter, gtk_tree_model_get (GTK_TREE_MODEL (list_store), &iter,
1, &modelName, -1); 1, &model_name, -1);
if (!g_ascii_strcasecmp(modelName, currentModelName)) if (!g_ascii_strcasecmp(model_name, current_model_name))
{ {
gtk_tree_selection_select_iter (gtk_tree_view_get_selection (GTK_TREE_VIEW (modelsList)), &iter); 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 (listStore), &iter); path = gtk_tree_model_get_path (GTK_TREE_MODEL (list_store), &iter);
gtk_tree_view_scroll_to_cell (GTK_TREE_VIEW (modelsList), gtk_tree_view_scroll_to_cell (GTK_TREE_VIEW (models_list),
path, NULL, TRUE, 0.5, 0); path, NULL, TRUE, 0.5, 0);
gtk_tree_path_free (path); gtk_tree_path_free (path);
} }
g_free (modelName); g_free (model_name);
} while (gtk_tree_model_iter_next (GTK_TREE_MODEL (listStore), &iter)); } 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", "changed",
G_CALLBACK (xkb_model_chooser_change_sel), G_CALLBACK (xkb_model_chooser_change_sel),
chooserDialog); chooser_dialog);
} }
static void static void
xkb_model_chooser_response (GtkDialog *dialog, xkb_model_chooser_response (GtkDialog *dialog,
gint response, gint response,
GladeXML *chooserDialog) GladeXML *chooser_dialog)
{ {
if (response == GTK_RESPONSE_OK) if (response == GTK_RESPONSE_OK)
{ {
GtkWidget* modelsList = CWID( "models_list" ); GtkWidget* models_list = CWID( "models_list" );
GtkTreeSelection* selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (modelsList)); GtkTreeSelection* selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (models_list));
GtkTreeIter iter; GtkTreeIter iter;
GtkTreeModel* listStore = NULL; GtkTreeModel* list_store = NULL;
if (gtk_tree_selection_get_selected (selection, &listStore, &iter)) if (gtk_tree_selection_get_selected (selection, &list_store, &iter))
{ {
gchar* modelName = NULL; gchar* model_name = NULL;
gtk_tree_model_get (listStore, &iter, gtk_tree_model_get (list_store, &iter,
1, &modelName, -1); 1, &model_name, -1);
gconf_client_set_string (xkbGConfClient, gconf_client_set_string (xkb_gconf_client,
GSWITCHIT_KBD_CONFIG_KEY_MODEL, GSWITCHIT_KBD_CONFIG_KEY_MODEL,
modelName, NULL); model_name, NULL);
g_free(modelName); g_free(model_name);
} }
} }
} }
@ -148,15 +148,15 @@ xkb_model_chooser_response (GtkDialog *dialog,
void void
choose_model(GladeXML * dialog) 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"); GtkWidget* chooser = CWID ( "xkb_model_chooser");
gtk_window_set_transient_for (GTK_WINDOW (chooser), GTK_WINDOW (WID ("keyboard_dialog"))); 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); GSWITCHIT_KBD_CONFIG_KEY_MODEL, NULL);
fill_models_list (chooserDialog); fill_models_list (chooser_dialog);
g_signal_connect (G_OBJECT (chooser), 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_dialog_run (GTK_DIALOG (chooser));
gtk_widget_destroy (chooser); gtk_widget_destroy (chooser);
g_free (currentModelName); g_free (current_model_name);
} }

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

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