← Back to branch summary

~kroq-gar78/ubuntu/precise/gnome-control-center/fix-885947

« back to all changes in this revision

Viewing changes to capplets/keyboard/gnome-keyboard-properties-xkbmc.c

  • Committer: Bazaar Package Importer
  • Author(s): Rodrigo Moya
  • Date: 2011-05-17 10:47:27 UTC
  • mfrom: (0.1.11 experimental) (1.1.45 upstream)
  • Revision ID: james.westby@ubuntu.com-20110517104727-lqel6m8vhfw5jby1
Tags: 1:3.0.1.1-1ubuntu1
* Rebase on Debian, remaining Ubuntu changes:
* debian/control:
  - Build-Depend on hardening-wrapper, dpkg-dev and dh-autoreconf
  - Add dependency on ubuntu-system-service
  - Remove dependency on gnome-icon-theme-symbolic
  - Move dependency on apg, gnome-icon-theme-symbolic and accountsservice to
    be a Recommends: until we get them in main
* debian/rules:
  - Use autoreconf
  - Add binary-post-install rule for gnome-control-center-data
  - Run dh-autoreconf
* debian/gnome-control-center.dirs:
* debian/gnome-control-center.links:
  - Add a link to the control center shell for indicators
* debian/patches/00_disable-nm.patch:
  - Temporary patch to disable building with NetworkManager until we get
    the new one in the archive
* debian/patches/01_git_remove_gettext_calls.patch:
  - Remove calls to AM_GNU_GETTEXT, IT_PROG_INTLTOOL should be enough
* debian/patches/01_git_kill_warning.patch:
  - Kill warning
* debian/patches/50_ubuntu_systemwide_prefs.patch:
  - Ubuntu specific proxy preferences
* debian/patches/51_ubuntu_system_keyboard.patch:
  - Implement the global keyboard spec at https://wiki.ubuntu.com/DefaultKeyboardSettings

Show diffs side-by-side

added added

removed removed

Lines of Context:
capplets/keyboard/gnome-keyboard-properties-xkbmc.c
1
 
/* -*- mode: c; style: linux -*- */
2
 
 
3
 
/* gnome-keyboard-properties-xkbmc.c
4
 
 * Copyright (C) 2003-2007 Sergey V. Udaltsov
5
 
 *
6
 
 * Written by: Sergey V. Udaltsov <svu@gnome.org>
7
 
 *
8
 
 * This program is free software; you can redistribute it and/or modify
9
 
 * it under the terms of the GNU General Public License as published by
10
 
 * the Free Software Foundation; either version 2, or (at your option)
11
 
 * any later version.
12
 
 *
13
 
 * This program is distributed in the hope that it will be useful,
14
 
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15
 
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16
 
 * GNU General Public License for more details.
17
 
 *
18
 
 * You should have received a copy of the GNU General Public License
19
 
 * along with this program; if not, write to the Free Software
20
 
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
21
 
 * 02111-1307, USA.
22
 
 */
23
 
 
24
 
#ifdef HAVE_CONFIG_H
25
 
#  include <config.h>
26
 
#endif
27
 
 
28
 
#include <gdk/gdkx.h>
29
 
#include <gconf/gconf-client.h>
30
 
#include <glib/gi18n.h>
31
 
 
32
 
#include "capplet-util.h"
33
 
 
34
 
#include "gnome-keyboard-properties-xkb.h"
35
 
 
36
 
static gchar *current_model_name = NULL;
37
 
static gchar *current_vendor_name = NULL;
38
 
 
39
 
static void fill_models_list (GtkBuilder * chooser_dialog);
40
 
 
41
 
static gboolean fill_vendors_list (GtkBuilder * chooser_dialog);
42
 
 
43
 
static GtkTreePath *
44
 
gtk_list_store_find_entry (GtkListStore * list_store,
45
 
                           GtkTreeIter * iter, gchar * name, int column_id)
46
 
{
47
 
        GtkTreePath *path;
48
 
        char *current_name = NULL;
49
 
        if (gtk_tree_model_get_iter_first
50
 
            (GTK_TREE_MODEL (list_store), iter)) {
51
 
                do {
52
 
                        gtk_tree_model_get (GTK_TREE_MODEL
53
 
                                            (list_store), iter, column_id,
54
 
                                            &current_name, -1);
55
 
                        if (!g_ascii_strcasecmp (name, current_name)) {
56
 
                                path =
57
 
                                    gtk_tree_model_get_path
58
 
                                    (GTK_TREE_MODEL (list_store), iter);
59
 
                                return path;
60
 
                        }
61
 
                        g_free (current_name);
62
 
                } while (gtk_tree_model_iter_next
63
 
                         (GTK_TREE_MODEL (list_store), iter));
64
 
        }
65
 
        return NULL;
66
 
}
67
 
 
68
 
static void
69
 
add_vendor_to_list (XklConfigRegistry * config_registry,
70
 
                    XklConfigItem * config_item,
71
 
                    GtkTreeView * vendors_list)
72
 
{
73
 
        GtkTreeIter iter;
74
 
        GtkTreePath *found_existing;
75
 
        GtkListStore *list_store;
76
 
 
77
 
        gchar *vendor_name =
78
 
            (gchar *) g_object_get_data (G_OBJECT (config_item),
79
 
                                         XCI_PROP_VENDOR);
80
 
 
81
 
        if (vendor_name == NULL)
82
 
                return;
83
 
 
84
 
        list_store =
85
 
            GTK_LIST_STORE (gtk_tree_view_get_model (vendors_list));
86
 
 
87
 
        if (!g_ascii_strcasecmp (config_item->name, current_model_name)) {
88
 
                current_vendor_name = g_strdup (vendor_name);
89
 
        }
90
 
 
91
 
        found_existing =
92
 
            gtk_list_store_find_entry (list_store, &iter, vendor_name, 0);
93
 
        /* This vendor is already there */
94
 
        if (found_existing != NULL) {
95
 
                gtk_tree_path_free (found_existing);
96
 
                return;
97
 
        }
98
 
 
99
 
        gtk_list_store_append (list_store, &iter);
100
 
        gtk_list_store_set (list_store, &iter, 0, vendor_name, -1);
101
 
}
102
 
 
103
 
static void
104
 
add_model_to_list (XklConfigRegistry * config_registry,
105
 
                   XklConfigItem * config_item, GtkTreeView * models_list)
106
 
{
107
 
        GtkTreeIter iter;
108
 
        GtkListStore *list_store =
109
 
            GTK_LIST_STORE (gtk_tree_view_get_model (models_list));
110
 
        char *utf_model_name;
111
 
        if (current_vendor_name != NULL) {
112
 
                gchar *vendor_name =
113
 
                    (gchar *) g_object_get_data (G_OBJECT (config_item),
114
 
                                                 XCI_PROP_VENDOR);
115
 
                if (vendor_name == NULL)
116
 
                        return;
117
 
 
118
 
                if (g_ascii_strcasecmp (vendor_name, current_vendor_name))
119
 
                        return;
120
 
        }
121
 
        utf_model_name = xci_desc_to_utf8 (config_item);
122
 
        gtk_list_store_append (list_store, &iter);
123
 
        gtk_list_store_set (list_store, &iter,
124
 
                            0, utf_model_name, 1, config_item->name, -1);
125
 
 
126
 
        g_free (utf_model_name);
127
 
}
128
 
 
129
 
static void
130
 
xkb_model_chooser_change_vendor_sel (GtkTreeSelection * selection,
131
 
                                     GtkBuilder * chooser_dialog)
132
 
{
133
 
        GtkTreeIter iter;
134
 
        GtkTreeModel *list_store = NULL;
135
 
        if (gtk_tree_selection_get_selected
136
 
            (selection, &list_store, &iter)) {
137
 
                gchar *vendor_name = NULL;
138
 
                gtk_tree_model_get (list_store, &iter,
139
 
                                    0, &vendor_name, -1);
140
 
 
141
 
                current_vendor_name = vendor_name;
142
 
                fill_models_list (chooser_dialog);
143
 
                g_free (vendor_name);
144
 
        } else {
145
 
                current_vendor_name = NULL;
146
 
                fill_models_list (chooser_dialog);
147
 
        }
148
 
 
149
 
}
150
 
 
151
 
static void
152
 
xkb_model_chooser_change_model_sel (GtkTreeSelection * selection,
153
 
                                    GtkBuilder * chooser_dialog)
154
 
{
155
 
        gboolean anysel =
156
 
            gtk_tree_selection_get_selected (selection, NULL, NULL);
157
 
        gtk_dialog_set_response_sensitive (GTK_DIALOG
158
 
                                           (CWID ("xkb_model_chooser")),
159
 
                                           GTK_RESPONSE_OK, anysel);
160
 
}
161
 
 
162
 
static void
163
 
prepare_vendors_list (GtkBuilder * chooser_dialog)
164
 
{
165
 
        GtkWidget *vendors_list = CWID ("vendors_list");
166
 
        GtkCellRenderer *renderer = gtk_cell_renderer_text_new ();
167
 
        GtkTreeViewColumn *vendor_col =
168
 
            gtk_tree_view_column_new_with_attributes (_("Vendors"),
169
 
                                                      renderer,
170
 
                                                      "text", 0,
171
 
                                                      NULL);
172
 
        gtk_tree_view_column_set_visible (vendor_col, TRUE);
173
 
        gtk_tree_view_append_column (GTK_TREE_VIEW (vendors_list),
174
 
                                     vendor_col);
175
 
}
176
 
 
177
 
static gboolean
178
 
fill_vendors_list (GtkBuilder * chooser_dialog)
179
 
{
180
 
        GtkWidget *vendors_list = CWID ("vendors_list");
181
 
        GtkListStore *list_store = gtk_list_store_new (1, G_TYPE_STRING);
182
 
        GtkTreeIter iter;
183
 
        GtkTreePath *path;
184
 
 
185
 
        gtk_tree_view_set_model (GTK_TREE_VIEW (vendors_list),
186
 
                                 GTK_TREE_MODEL (list_store));
187
 
 
188
 
        gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE
189
 
                                              (list_store), 0,
190
 
                                              GTK_SORT_ASCENDING);
191
 
 
192
 
        current_vendor_name = NULL;
193
 
 
194
 
        xkl_config_registry_foreach_model (config_registry,
195
 
                                           (ConfigItemProcessFunc)
196
 
                                           add_vendor_to_list,
197
 
                                           vendors_list);
198
 
 
199
 
        if (current_vendor_name != NULL) {
200
 
                path = gtk_list_store_find_entry (list_store,
201
 
                                                  &iter,
202
 
                                                  current_vendor_name, 0);
203
 
                if (path != NULL) {
204
 
                        gtk_tree_selection_select_iter
205
 
                            (gtk_tree_view_get_selection
206
 
                             (GTK_TREE_VIEW (vendors_list)), &iter);
207
 
                        gtk_tree_view_scroll_to_cell
208
 
                            (GTK_TREE_VIEW (vendors_list),
209
 
                             path, NULL, TRUE, 0.5, 0);
210
 
                        gtk_tree_path_free (path);
211
 
                }
212
 
                fill_models_list (chooser_dialog);
213
 
                g_free (current_vendor_name);
214
 
        } else {
215
 
                fill_models_list (chooser_dialog);
216
 
        }
217
 
 
218
 
        g_signal_connect (G_OBJECT
219
 
                          (gtk_tree_view_get_selection
220
 
                           (GTK_TREE_VIEW (vendors_list))), "changed",
221
 
                          G_CALLBACK (xkb_model_chooser_change_vendor_sel),
222
 
                          chooser_dialog);
223
 
 
224
 
        return gtk_tree_model_get_iter_first (GTK_TREE_MODEL (list_store),
225
 
                                              &iter);
226
 
}
227
 
 
228
 
static void
229
 
prepare_models_list (GtkBuilder * chooser_dialog)
230
 
{
231
 
        GtkWidget *models_list = CWID ("models_list");
232
 
        GtkCellRenderer *renderer = gtk_cell_renderer_text_new ();
233
 
        GtkTreeViewColumn *description_col =
234
 
            gtk_tree_view_column_new_with_attributes (_("Models"),
235
 
                                                      renderer,
236
 
                                                      "text", 0,
237
 
                                                      NULL);
238
 
        gtk_tree_view_column_set_visible (description_col, TRUE);
239
 
        gtk_tree_view_append_column (GTK_TREE_VIEW (models_list),
240
 
                                     description_col);
241
 
}
242
 
 
243
 
static void
244
 
fill_models_list (GtkBuilder * chooser_dialog)
245
 
{
246
 
        GtkWidget *models_list = CWID ("models_list");
247
 
        GtkTreeIter iter;
248
 
        GtkTreePath *path;
249
 
 
250
 
        GtkListStore *list_store =
251
 
            gtk_list_store_new (2, G_TYPE_STRING, G_TYPE_STRING);
252
 
 
253
 
        gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE
254
 
                                              (list_store), 0,
255
 
                                              GTK_SORT_ASCENDING);
256
 
 
257
 
        gtk_tree_view_set_model (GTK_TREE_VIEW (models_list),
258
 
                                 GTK_TREE_MODEL (list_store));
259
 
 
260
 
        xkl_config_registry_foreach_model (config_registry,
261
 
                                           (ConfigItemProcessFunc)
262
 
                                           add_model_to_list, models_list);
263
 
 
264
 
        if (current_model_name != NULL) {
265
 
                path = gtk_list_store_find_entry (list_store,
266
 
                                                  &iter,
267
 
                                                  current_model_name, 1);
268
 
                if (path != NULL) {
269
 
                        gtk_tree_selection_select_iter
270
 
                            (gtk_tree_view_get_selection
271
 
                             (GTK_TREE_VIEW (models_list)), &iter);
272
 
                        gtk_tree_view_scroll_to_cell
273
 
                            (GTK_TREE_VIEW (models_list),
274
 
                             path, NULL, TRUE, 0.5, 0);
275
 
                        gtk_tree_path_free (path);
276
 
                }
277
 
        }
278
 
 
279
 
        g_signal_connect (G_OBJECT
280
 
                          (gtk_tree_view_get_selection
281
 
                           (GTK_TREE_VIEW (models_list))), "changed",
282
 
                          G_CALLBACK (xkb_model_chooser_change_model_sel),
283
 
                          chooser_dialog);
284
 
}
285
 
 
286
 
static void
287
 
xkb_model_chooser_response (GtkDialog * dialog,
288
 
                            gint response, GtkBuilder * chooser_dialog)
289
 
{
290
 
        if (response == GTK_RESPONSE_OK) {
291
 
                GtkWidget *models_list = CWID ("models_list");
292
 
                GtkTreeSelection *selection =
293
 
                    gtk_tree_view_get_selection (GTK_TREE_VIEW
294
 
                                                 (models_list));
295
 
                GtkTreeIter iter;
296
 
                GtkTreeModel *list_store = NULL;
297
 
                if (gtk_tree_selection_get_selected
298
 
                    (selection, &list_store, &iter)) {
299
 
                        gchar *model_name = NULL;
300
 
                        gtk_tree_model_get (list_store, &iter,
301
 
                                            1, &model_name, -1);
302
 
 
303
 
                        gconf_client_set_string (xkb_gconf_client,
304
 
                                                 GKBD_KEYBOARD_CONFIG_KEY_MODEL,
305
 
                                                 model_name, NULL);
306
 
                        g_free (model_name);
307
 
                }
308
 
        }
309
 
}
310
 
 
311
 
void
312
 
choose_model (GtkBuilder * dialog)
313
 
{
314
 
        GtkBuilder *chooser_dialog;
315
 
    GtkWidget *chooser;
316
 
    
317
 
    chooser_dialog = gtk_builder_new ();
318
 
    gtk_builder_add_from_file (chooser_dialog, GNOMECC_UI_DIR
319
 
                               "/gnome-keyboard-properties-model-chooser.ui",
320
 
                               NULL);
321
 
        chooser = CWID ("xkb_model_chooser");
322
 
        gtk_window_set_transient_for (GTK_WINDOW (chooser),
323
 
                                      GTK_WINDOW (WID
324
 
                                                  ("keyboard_dialog")));
325
 
        current_model_name =
326
 
            gconf_client_get_string (xkb_gconf_client,
327
 
                                     GKBD_KEYBOARD_CONFIG_KEY_MODEL, NULL);
328
 
 
329
 
 
330
 
        prepare_vendors_list (chooser_dialog);
331
 
        prepare_models_list (chooser_dialog);
332
 
 
333
 
        if (!fill_vendors_list (chooser_dialog)) {
334
 
                gtk_widget_hide_all (CWID ("vendors_label"));
335
 
                gtk_widget_hide_all (CWID ("vendors_scrolledwindow"));
336
 
                current_vendor_name = NULL;
337
 
                fill_models_list (chooser_dialog);
338
 
        }
339
 
 
340
 
        g_signal_connect (G_OBJECT (chooser),
341
 
                          "response",
342
 
                          G_CALLBACK (xkb_model_chooser_response),
343
 
                          chooser_dialog);
344
 
        gtk_dialog_run (GTK_DIALOG (chooser));
345
 
        gtk_widget_destroy (chooser);
346
 
        g_free (current_model_name);
347
 
}