1
/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 8 -*-
3
* Copyright Ā© 2001 Ximian, Inc.
4
* Copyright (C) 2007 William Jon McCann <mccann@jhu.edu>
5
* Written by Sergey V. Oudaltsov <svu@users.sourceforge.net>
7
* This program is free software; you can redistribute it and/or modify
8
* it under the terms of the GNU General Public License as published by
9
* the Free Software Foundation; either version 2 of the License, or
10
* (at your option) any later version.
12
* This program is distributed in the hope that it will be useful,
13
* but WITHOUT ANY WARRANTY; without even the implied warranty of
14
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15
* GNU General Public License for more details.
17
* You should have received a copy of the GNU General Public License
18
* along with this program; if not, write to the Free Software
19
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
25
#include <sys/types.h>
36
#include <glib/gi18n.h>
41
#include <X11/XKBlib.h>
42
#include <X11/keysym.h>
43
#include <X11/extensions/XKBrules.h>
45
#define GNOME_DESKTOP_USE_UNSTABLE_API
46
#include <libgnome-desktop/gnome-languages.h>
47
#include <libgnome-desktop/gnome-xkb-info.h>
55
#include "gnome-settings-session.h"
56
#include "gnome-settings-profile.h"
57
#include "gsd-keyboard-manager.h"
58
#include "gsd-input-helper.h"
59
#include "gsd-enums.h"
61
#define GSD_KEYBOARD_MANAGER_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), GSD_TYPE_KEYBOARD_MANAGER, GsdKeyboardManagerPrivate))
63
#define GSD_KEYBOARD_DIR "org.gnome.settings-daemon.peripherals.keyboard"
65
#define KEY_REPEAT "repeat"
66
#define KEY_CLICK "click"
67
#define KEY_INTERVAL "repeat-interval"
68
#define KEY_DELAY "delay"
69
#define KEY_CLICK_VOLUME "click-volume"
70
#define KEY_REMEMBER_NUMLOCK_STATE "remember-numlock-state"
71
#define KEY_NUMLOCK_STATE "numlock-state"
73
#define KEY_BELL_VOLUME "bell-volume"
74
#define KEY_BELL_PITCH "bell-pitch"
75
#define KEY_BELL_DURATION "bell-duration"
76
#define KEY_BELL_MODE "bell-mode"
78
#define GNOME_DESKTOP_INTERFACE_DIR "org.gnome.desktop.interface"
80
#define KEY_GTK_IM_MODULE "gtk-im-module"
81
#define GTK_IM_MODULE_SIMPLE "gtk-im-context-simple"
82
#define GTK_IM_MODULE_IBUS "ibus"
84
#define GNOME_DESKTOP_INPUT_SOURCES_DIR "org.gnome.desktop.input-sources"
86
#define KEY_CURRENT_INPUT_SOURCE "current"
87
#define KEY_INPUT_SOURCES "sources"
88
#define KEY_KEYBOARD_OPTIONS "xkb-options"
90
#define INPUT_SOURCE_TYPE_XKB "xkb"
91
#define INPUT_SOURCE_TYPE_IBUS "ibus"
93
#define DEFAULT_LANGUAGE "en_US"
94
#define DEFAULT_LAYOUT "us"
96
#define GSD_KEYBOARD_DBUS_NAME "org.gnome.SettingsDaemon.Keyboard"
97
#define GSD_KEYBOARD_DBUS_PATH "/org/gnome/SettingsDaemon/Keyboard"
99
struct GsdKeyboardManagerPrivate
103
GSettings *input_sources_settings;
104
GSettings *interface_settings;
105
GnomeXkbInfo *xkb_info;
107
GCancellable *cancellable;
110
GHashTable *ibus_engines;
111
GCancellable *ibus_cancellable;
114
GsdNumLockState old_state;
115
GdkDeviceManager *device_manager;
116
guint device_added_id;
117
guint device_removed_id;
119
GDBusConnection *dbus_connection;
120
GDBusNodeInfo *dbus_introspection;
121
guint dbus_own_name_id;
122
guint dbus_register_object_id;
124
GDBusMethodInvocation *invocation;
128
static void gsd_keyboard_manager_class_init (GsdKeyboardManagerClass *klass);
129
static void gsd_keyboard_manager_init (GsdKeyboardManager *keyboard_manager);
130
static void gsd_keyboard_manager_finalize (GObject *object);
131
static gboolean apply_input_sources_settings (GSettings *settings,
134
GsdKeyboardManager *manager);
135
static void set_gtk_im_module (GsdKeyboardManager *manager,
137
static void maybe_return_from_set_input_source (GsdKeyboardManager *manager);
138
static void increment_set_input_source_ops (GsdKeyboardManager *manager);
140
G_DEFINE_TYPE (GsdKeyboardManager, gsd_keyboard_manager, G_TYPE_OBJECT)
142
static const gchar introspection_xml[] =
144
" <interface name='org.gnome.SettingsDaemon.Keyboard'>"
145
" <method name='SetInputSource'>"
146
" <arg type='u' name='idx' direction='in'/>"
151
static gpointer manager_object = NULL;
154
init_builder_with_sources (GVariantBuilder *builder,
162
sources = g_settings_get_value (settings, KEY_INPUT_SOURCES);
164
g_variant_builder_init (builder, G_VARIANT_TYPE ("a(ss)"));
166
g_variant_iter_init (&iter, sources);
167
while (g_variant_iter_next (&iter, "(&s&s)", &type, &id))
168
g_variant_builder_add (builder, "(ss)", type, id);
170
g_variant_unref (sources);
174
schema_is_installed (const gchar *name)
176
const gchar * const *schemas;
177
const gchar * const *s;
179
schemas = g_settings_list_schemas ();
180
for (s = schemas; *s; ++s)
181
if (g_str_equal (*s, name))
189
clear_ibus (GsdKeyboardManager *manager)
191
GsdKeyboardManagerPrivate *priv = manager->priv;
193
g_cancellable_cancel (priv->ibus_cancellable);
194
g_clear_object (&priv->ibus_cancellable);
195
g_clear_pointer (&priv->ibus_engines, g_hash_table_destroy);
196
g_clear_object (&priv->ibus);
200
fetch_ibus_engines_result (GObject *object,
201
GAsyncResult *result,
202
GsdKeyboardManager *manager)
204
GsdKeyboardManagerPrivate *priv = manager->priv;
206
GError *error = NULL;
208
/* engines shouldn't be there yet */
209
g_return_if_fail (priv->ibus_engines == NULL);
211
g_clear_object (&priv->ibus_cancellable);
213
list = ibus_bus_list_engines_async_finish (priv->ibus,
216
if (!list && error) {
217
if (!g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED))
218
g_warning ("Couldn't finish IBus request: %s", error->message);
219
g_error_free (error);
221
clear_ibus (manager);
225
/* Maps IBus engine ids to engine description objects */
226
priv->ibus_engines = g_hash_table_new_full (g_str_hash, g_str_equal, NULL, g_object_unref);
228
for (l = list; l; l = l->next) {
229
IBusEngineDesc *engine = l->data;
230
const gchar *engine_id = ibus_engine_desc_get_name (engine);
232
g_hash_table_replace (priv->ibus_engines, (gpointer)engine_id, engine);
236
apply_input_sources_settings (priv->input_sources_settings, NULL, 0, manager);
240
fetch_ibus_engines (GsdKeyboardManager *manager)
242
GsdKeyboardManagerPrivate *priv = manager->priv;
244
/* engines shouldn't be there yet */
245
g_return_if_fail (priv->ibus_engines == NULL);
246
g_return_if_fail (priv->ibus_cancellable == NULL);
248
priv->ibus_cancellable = g_cancellable_new ();
250
ibus_bus_list_engines_async (priv->ibus,
252
priv->ibus_cancellable,
253
(GAsyncReadyCallback)fetch_ibus_engines_result,
258
maybe_start_ibus (GsdKeyboardManager *manager)
260
if (!manager->priv->ibus) {
262
manager->priv->ibus = ibus_bus_new_async ();
263
g_signal_connect_swapped (manager->priv->ibus, "connected",
264
G_CALLBACK (fetch_ibus_engines), manager);
265
g_signal_connect_swapped (manager->priv->ibus, "disconnected",
266
G_CALLBACK (clear_ibus), manager);
268
/* IBus doesn't export API in the session bus. The only thing
269
* we have there is a well known name which we can use as a
270
* sure-fire way to activate it. */
271
g_bus_unwatch_name (g_bus_watch_name (G_BUS_TYPE_SESSION,
273
G_BUS_NAME_WATCHER_FLAGS_AUTO_START,
281
set_ibus_engine_finish (GObject *object,
283
GsdKeyboardManager *manager)
286
IBusBus *ibus = IBUS_BUS (object);
287
GsdKeyboardManagerPrivate *priv = manager->priv;
288
GError *error = NULL;
290
g_clear_object (&priv->ibus_cancellable);
292
result = ibus_bus_set_global_engine_async_finish (ibus, res, &error);
294
if (!g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED))
295
g_warning ("Couldn't set IBus engine: %s", error->message);
296
g_error_free (error);
300
maybe_return_from_set_input_source (manager);
304
set_ibus_engine (GsdKeyboardManager *manager,
305
const gchar *engine_id)
307
GsdKeyboardManagerPrivate *priv = manager->priv;
309
g_return_if_fail (priv->ibus != NULL);
310
g_return_if_fail (priv->ibus_engines != NULL);
312
g_cancellable_cancel (priv->ibus_cancellable);
313
g_clear_object (&priv->ibus_cancellable);
314
priv->ibus_cancellable = g_cancellable_new ();
316
increment_set_input_source_ops (manager);
318
ibus_bus_set_global_engine_async (priv->ibus,
321
priv->ibus_cancellable,
322
(GAsyncReadyCallback)set_ibus_engine_finish,
327
set_ibus_xkb_engine (GsdKeyboardManager *manager)
329
IBusEngineDesc *engine;
330
GsdKeyboardManagerPrivate *priv = manager->priv;
332
if (!priv->ibus_engines)
335
/* All the "xkb:..." IBus engines simply "echo" back symbols,
336
despite their naming implying differently, so we always set
337
one in order for XIM applications to work given that we set
338
XMODIFIERS=@im=ibus in the first place so that they can
339
work without restarting when/if the user adds an IBus
341
engine = g_hash_table_lookup (priv->ibus_engines, "xkb:us::eng");
345
set_ibus_engine (manager, ibus_engine_desc_get_name (engine));
349
need_ibus (GVariant *sources)
354
g_variant_iter_init (&iter, sources);
355
while (g_variant_iter_next (&iter, "(&s&s)", &type, NULL))
356
if (g_str_equal (type, INPUT_SOURCE_TYPE_IBUS))
364
set_gtk_im_module (GsdKeyboardManager *manager,
367
GsdKeyboardManagerPrivate *priv = manager->priv;
368
const gchar *new_module;
369
gchar *current_module;
371
if (!sources || need_ibus (sources))
372
new_module = GTK_IM_MODULE_IBUS;
374
new_module = GTK_IM_MODULE_SIMPLE;
376
current_module = g_settings_get_string (priv->interface_settings,
378
if (!g_str_equal (current_module, new_module))
379
g_settings_set_string (priv->interface_settings,
382
g_free (current_module);
385
/* XXX: See upstream bug:
386
* https://codereview.appspot.com/6586075/ */
388
layout_from_ibus_layout (const gchar *ibus_layout)
392
/* we get something like "layout(variant)[option1,option2]" */
396
if (*p == '(' || *p == '[')
401
return g_strndup (ibus_layout, p - ibus_layout);
405
variant_from_ibus_layout (const gchar *ibus_layout)
409
/* we get something like "layout(variant)[option1,option2]" */
430
return g_strndup (a, b - a);
434
options_from_ibus_layout (const gchar *ibus_layout)
437
GPtrArray *opt_array;
439
/* we get something like "layout(variant)[option1,option2]" */
450
opt_array = g_ptr_array_new ();
456
if (*b == ',' || *b == ']')
463
g_ptr_array_add (opt_array, g_strndup (a, b - a));
466
} while (*a && *a == ',');
469
g_ptr_array_add (opt_array, NULL);
470
return (gchar **) g_ptr_array_free (opt_array, FALSE);
474
engine_from_locale (void)
477
const gchar *locale_engine[][2] = {
478
{ "as_IN", "m17n:as:phonetic" },
479
{ "bn_IN", "m17n:bn:inscript" },
480
{ "gu_IN", "m17n:gu:inscript" },
481
{ "hi_IN", "m17n:hi:inscript" },
482
{ "ja_JP", "anthy" },
483
{ "kn_IN", "m17n:kn:kgp" },
484
{ "ko_KR", "hangul" },
485
{ "mai_IN", "m17n:mai:inscript" },
486
{ "ml_IN", "m17n:ml:inscript" },
487
{ "mr_IN", "m17n:mr:inscript" },
488
{ "or_IN", "m17n:or:inscript" },
489
{ "pa_IN", "m17n:pa:inscript" },
490
{ "sd_IN", "m17n:sd:inscript" },
491
{ "ta_IN", "m17n:ta:tamil99" },
492
{ "te_IN", "m17n:te:inscript" },
493
{ "zh_CN", "pinyin" },
494
{ "zh_HK", "cangjie3" },
495
{ "zh_TW", "chewing" },
499
locale = setlocale (LC_CTYPE, NULL);
503
for (i = 0; i < G_N_ELEMENTS (locale_engine); ++i)
504
if (g_str_has_prefix (locale, locale_engine[i][0]))
505
return locale_engine[i][1];
511
add_ibus_sources_from_locale (GSettings *settings)
513
const gchar *locale_engine;
514
GVariantBuilder builder;
516
locale_engine = engine_from_locale ();
520
init_builder_with_sources (&builder, settings);
521
g_variant_builder_add (&builder, "(ss)", INPUT_SOURCE_TYPE_IBUS, locale_engine);
522
g_settings_set_value (settings, KEY_INPUT_SOURCES, g_variant_builder_end (&builder));
526
convert_ibus (GSettings *settings)
528
GVariantBuilder builder;
529
GSettings *ibus_settings;
530
gchar **engines, **e;
532
if (!schema_is_installed ("org.freedesktop.ibus.general"))
535
init_builder_with_sources (&builder, settings);
537
ibus_settings = g_settings_new ("org.freedesktop.ibus.general");
538
engines = g_settings_get_strv (ibus_settings, "preload-engines");
539
for (e = engines; *e; ++e) {
540
if (g_str_has_prefix (*e, "xkb:"))
542
g_variant_builder_add (&builder, "(ss)", INPUT_SOURCE_TYPE_IBUS, *e);
545
g_settings_set_value (settings, KEY_INPUT_SOURCES, g_variant_builder_end (&builder));
547
g_strfreev (engines);
548
g_object_unref (ibus_settings);
550
#endif /* HAVE_IBUS */
553
xkb_set_keyboard_autorepeat_rate (guint delay, guint interval)
555
return XkbSetAutoRepeatRate (GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()),
562
check_xkb_extension (GsdKeyboardManager *manager)
564
Display *dpy = GDK_DISPLAY_XDISPLAY (gdk_display_get_default ());
565
int opcode, error_base, major, minor;
568
have_xkb = XkbQueryExtension (dpy,
570
&manager->priv->xkb_event_base,
578
xkb_init (GsdKeyboardManager *manager)
582
dpy = GDK_DISPLAY_XDISPLAY (gdk_display_get_default ());
583
XkbSelectEventDetails (dpy,
587
XkbModifierLockMask);
591
numlock_NumLock_modifier_mask (void)
593
Display *dpy = GDK_DISPLAY_XDISPLAY (gdk_display_get_default ());
594
return XkbKeysymToModifiers (dpy, XK_Num_Lock);
598
numlock_set_xkb_state (GsdNumLockState new_state)
600
unsigned int num_mask;
601
Display *dpy = GDK_DISPLAY_XDISPLAY (gdk_display_get_default ());
602
if (new_state != GSD_NUM_LOCK_STATE_ON && new_state != GSD_NUM_LOCK_STATE_OFF)
604
num_mask = numlock_NumLock_modifier_mask ();
605
XkbLockModifiers (dpy, XkbUseCoreKbd, num_mask, new_state == GSD_NUM_LOCK_STATE_ON ? num_mask : 0);
609
num_lock_state_to_string (GsdNumLockState numlock_state)
611
switch (numlock_state) {
612
case GSD_NUM_LOCK_STATE_UNKNOWN:
613
return "GSD_NUM_LOCK_STATE_UNKNOWN";
614
case GSD_NUM_LOCK_STATE_ON:
615
return "GSD_NUM_LOCK_STATE_ON";
616
case GSD_NUM_LOCK_STATE_OFF:
617
return "GSD_NUM_LOCK_STATE_OFF";
623
static GdkFilterReturn
624
xkb_events_filter (GdkXEvent *xev_,
628
XEvent *xev = (XEvent *) xev_;
629
XkbEvent *xkbev = (XkbEvent *) xev;
630
GsdKeyboardManager *manager = (GsdKeyboardManager *) user_data;
632
if (xev->type != manager->priv->xkb_event_base ||
633
xkbev->any.xkb_type != XkbStateNotify)
634
return GDK_FILTER_CONTINUE;
636
if (xkbev->state.changed & XkbModifierLockMask) {
637
unsigned num_mask = numlock_NumLock_modifier_mask ();
638
unsigned locked_mods = xkbev->state.locked_mods;
639
GsdNumLockState numlock_state;
641
numlock_state = (num_mask & locked_mods) ? GSD_NUM_LOCK_STATE_ON : GSD_NUM_LOCK_STATE_OFF;
643
if (numlock_state != manager->priv->old_state) {
644
g_debug ("New num-lock state '%s' != Old num-lock state '%s'",
645
num_lock_state_to_string (numlock_state),
646
num_lock_state_to_string (manager->priv->old_state));
647
g_settings_set_enum (manager->priv->settings,
650
manager->priv->old_state = numlock_state;
654
return GDK_FILTER_CONTINUE;
658
install_xkb_filter (GsdKeyboardManager *manager)
660
gdk_window_add_filter (NULL,
666
remove_xkb_filter (GsdKeyboardManager *manager)
668
gdk_window_remove_filter (NULL,
674
free_xkb_component_names (XkbComponentNamesRec *p)
676
g_return_if_fail (p != NULL);
689
upload_xkb_description (const gchar *rules_file_path,
690
XkbRF_VarDefsRec *var_defs,
691
XkbComponentNamesRec *comp_names)
693
Display *display = GDK_DISPLAY_XDISPLAY (gdk_display_get_default ());
694
XkbDescRec *xkb_desc;
697
/* The layout we want is always in the first XKB group index
698
* so we should enforce it to make sure we never end up with
700
XkbLockGroup (display, XkbUseCoreKbd, 0);
702
/* Upload it to the X server using the same method as setxkbmap */
703
xkb_desc = XkbGetKeyboardByName (display,
706
XkbGBN_AllComponentsMask,
707
XkbGBN_AllComponentsMask &
708
(~XkbGBN_GeometryMask), True);
710
g_warning ("Couldn't upload new XKB keyboard description");
714
XkbFreeKeyboard (xkb_desc, 0, True);
716
rules_file = g_path_get_basename (rules_file_path);
718
if (!XkbRF_SetNamesProp (display, rules_file, var_defs))
719
g_warning ("Couldn't update the XKB root window property");
725
build_xkb_group_string (const gchar *user,
734
length += strlen (latin);
739
length += strlen (locale);
743
length += strlen (user) + commas + 1;
745
string = malloc (length);
748
sprintf (string, "%s,%s,%s", user, locale, latin);
750
sprintf (string, "%s,%s", user, locale);
752
sprintf (string, "%s,%s", user, latin);
754
sprintf (string, "%s", user);
760
layout_equal (const gchar *layout_a,
761
const gchar *variant_a,
762
const gchar *layout_b,
763
const gchar *variant_b)
765
return !g_strcmp0 (layout_a, layout_b) && !g_strcmp0 (variant_a, variant_b);
769
get_locale_layout (GsdKeyboardManager *manager,
770
const gchar **layout,
771
const gchar **variant)
781
locale = setlocale (LC_MESSAGES, NULL);
782
/* If LANG is empty, default to en_US */
784
locale = DEFAULT_LANGUAGE;
786
got_info = gnome_get_input_source_from_locale (locale, &type, &id);
788
if (!gnome_get_input_source_from_locale (DEFAULT_LANGUAGE, &type, &id))
791
if (!g_str_equal (type, INPUT_SOURCE_TYPE_XKB))
794
gnome_xkb_info_get_layout_info (manager->priv->xkb_info,
803
replace_layout_and_variant (GsdKeyboardManager *manager,
804
XkbRF_VarDefsRec *xkb_var_defs,
806
const gchar *variant)
808
/* Toolkits need to know about both a latin layout to handle
809
* accelerators which are usually defined like Ctrl+C and a
810
* layout with the symbols for the language used in UI strings
811
* to handle mnemonics like Alt+Š¤, so we try to find and add
812
* them in XKB group slots after the layout which the user
813
* actually intends to type with. */
814
const gchar *latin_layout = "us";
815
const gchar *latin_variant = "";
816
const gchar *locale_layout = NULL;
817
const gchar *locale_variant = NULL;
825
get_locale_layout (manager, &locale_layout, &locale_variant);
827
/* We want to minimize the number of XKB groups if we have
828
* duplicated layout+variant pairs.
830
* Also, if a layout doesn't have a variant we still have to
831
* include it in the variants string because the number of
832
* variants must agree with the number of layouts. For
835
* layouts: "us,ru,us"
836
* variants: "dvorak,,"
838
if (layout_equal (latin_layout, latin_variant, locale_layout, locale_variant) ||
839
layout_equal (latin_layout, latin_variant, layout, variant)) {
841
latin_variant = NULL;
844
if (layout_equal (locale_layout, locale_variant, layout, variant)) {
845
locale_layout = NULL;
846
locale_variant = NULL;
849
free (xkb_var_defs->layout);
850
xkb_var_defs->layout = build_xkb_group_string (layout, locale_layout, latin_layout);
852
free (xkb_var_defs->variant);
853
xkb_var_defs->variant = build_xkb_group_string (variant, locale_variant, latin_variant);
857
build_xkb_options_string (gchar **options)
866
/* First part, getting length */
867
len = 1 + strlen (options[0]);
868
for (i = 1; options[i] != NULL; i++)
869
len += strlen (options[i]);
870
len += (i - 1); /* commas */
872
/* Second part, building string */
873
string = malloc (len);
874
ptr = g_stpcpy (string, *options);
875
for (i = 1; options[i] != NULL; i++) {
876
ptr = g_stpcpy (ptr, ",");
877
ptr = g_stpcpy (ptr, options[i]);
888
append_options (gchar **a,
896
return g_strdupv (b);
898
return g_strdupv (a);
900
c = g_new0 (gchar *, g_strv_length (a) + g_strv_length (b) + 1);
918
strip_xkb_option (gchar **options,
928
if (g_str_has_prefix (*p, prefix)) {
929
last = g_strv_length (options) - 1;
932
options[last] = NULL;
939
prepare_xkb_options (GsdKeyboardManager *manager,
941
gchar **extra_options)
944
gchar **settings_options;
947
settings_options = g_settings_get_strv (manager->priv->input_sources_settings,
948
KEY_KEYBOARD_OPTIONS);
949
options = append_options (settings_options, extra_options);
950
g_strfreev (settings_options);
952
/* We might set up different layouts in different groups - see
953
* replace_layout_and_variant(). But we don't want the X
954
* server group switching feature to actually switch
955
* them. Regularly, if we have at least two input sources,
956
* gnome-shell will tell us to switch input source at that
957
* point so we fix that automatically. But when there's only
958
* one source, gnome-shell short circuits as an optimization
959
* and doesn't call us so we can't set the group switching XKB
960
* option in the first place otherwise the X server's switch
961
* will take effect and we get a broken configuration. */
962
if (n_sources < 2 || g_strcmp0 (g_getenv ("XDG_CURRENT_DESKTOP"), "Unity") == 0)
963
strip_xkb_option (options, "grp:");
965
options_str = build_xkb_options_string (options);
966
g_strfreev (options);
972
apply_xkb_settings (GsdKeyboardManager *manager,
974
const gchar *variant,
977
XkbRF_RulesRec *xkb_rules;
978
XkbRF_VarDefsRec *xkb_var_defs;
979
gchar *rules_file_path;
981
gnome_xkb_info_get_var_defs (&rules_file_path, &xkb_var_defs);
983
free (xkb_var_defs->options);
984
xkb_var_defs->options = options;
986
replace_layout_and_variant (manager, xkb_var_defs, layout, variant);
988
gdk_error_trap_push ();
990
xkb_rules = XkbRF_Load (rules_file_path, NULL, True, True);
992
XkbComponentNamesRec *xkb_comp_names;
993
xkb_comp_names = g_new0 (XkbComponentNamesRec, 1);
995
XkbRF_GetComponents (xkb_rules, xkb_var_defs, xkb_comp_names);
996
upload_xkb_description (rules_file_path, xkb_var_defs, xkb_comp_names);
998
free_xkb_component_names (xkb_comp_names);
999
XkbRF_Free (xkb_rules, True);
1001
g_warning ("Couldn't load XKB rules");
1004
if (gdk_error_trap_pop ())
1005
g_warning ("Error loading XKB rules");
1007
gnome_xkb_info_free_var_defs (xkb_var_defs);
1008
g_free (rules_file_path);
1010
XkbLockModifiers (GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()), XkbUseCoreKbd, LockMask, 0);
1014
user_notify_is_loaded_cb (GObject *object,
1018
ActUser *user = ACT_USER (object);
1019
GSettings *settings = user_data;
1021
if (act_user_is_loaded (user)) {
1026
GVariantBuilder builder;
1028
g_signal_handlers_disconnect_by_data (user, user_data);
1030
sources = g_settings_get_value (settings, KEY_INPUT_SOURCES);
1032
g_variant_builder_init (&builder, G_VARIANT_TYPE ("aa{ss}"));
1034
g_variant_iter_init (&iter, sources);
1035
while (g_variant_iter_next (&iter, "(&s&s)", &type, &name)) {
1036
g_variant_builder_open (&builder, G_VARIANT_TYPE ("a{ss}"));
1037
g_variant_builder_add (&builder, "{ss}", type, name);
1038
g_variant_builder_close (&builder);
1041
g_variant_unref (sources);
1043
sources = g_variant_ref_sink (g_variant_builder_end (&builder));
1044
act_user_set_input_sources (user, sources);
1045
g_variant_unref (sources);
1050
manager_notify_is_loaded_cb (GObject *object,
1054
ActUserManager *manager = ACT_USER_MANAGER (object);
1057
g_object_get (manager, "is-loaded", &loaded, NULL);
1062
g_signal_handlers_disconnect_by_data (manager, user_data);
1064
user = act_user_manager_get_user (manager, g_get_user_name ());
1066
if (act_user_is_loaded (user))
1067
user_notify_is_loaded_cb (G_OBJECT (user), NULL, user_data);
1069
g_signal_connect (user, "notify::is-loaded",
1070
user_notify_is_loaded_cb, user_data);
1075
apply_input_sources_settings (GSettings *settings,
1078
GsdKeyboardManager *manager)
1080
GsdKeyboardManagerPrivate *priv = manager->priv;
1084
const gchar *type = NULL;
1085
const gchar *id = NULL;
1086
gchar *layout = NULL;
1087
gchar *variant = NULL;
1088
gchar **options = NULL;
1089
ActUserManager *user_manager;
1090
gboolean user_manager_loaded;
1092
sources = g_settings_get_value (priv->input_sources_settings, KEY_INPUT_SOURCES);
1093
current = g_settings_get_uint (priv->input_sources_settings, KEY_CURRENT_INPUT_SOURCE);
1094
n_sources = g_variant_n_children (sources);
1096
user_manager = act_user_manager_get_default ();
1097
g_object_get (user_manager, "is-loaded", &user_manager_loaded, NULL);
1098
if (user_manager_loaded)
1099
manager_notify_is_loaded_cb (G_OBJECT (user_manager), NULL, settings);
1101
g_signal_connect (user_manager, "notify::is-loaded", G_CALLBACK (manager_notify_is_loaded_cb), settings);
1106
if (current >= n_sources) {
1107
g_settings_set_uint (priv->input_sources_settings,
1108
KEY_CURRENT_INPUT_SOURCE,
1114
maybe_start_ibus (manager);
1117
g_variant_get_child (sources, current, "(&s&s)", &type, &id);
1119
if (g_str_equal (type, INPUT_SOURCE_TYPE_XKB)) {
1121
gnome_xkb_info_get_layout_info (priv->xkb_info, id, NULL, NULL, &l, &v);
1123
layout = g_strdup (l);
1124
variant = g_strdup (v);
1126
if (!layout || !layout[0]) {
1127
g_warning ("Couldn't find XKB input source '%s'", id);
1131
set_gtk_im_module (manager, sources);
1132
set_ibus_xkb_engine (manager);
1134
} else if (g_str_equal (type, INPUT_SOURCE_TYPE_IBUS)) {
1136
IBusEngineDesc *engine_desc = NULL;
1138
if (priv->ibus_engines)
1139
engine_desc = g_hash_table_lookup (priv->ibus_engines, id);
1141
goto exit; /* we'll be called again when ibus is up and running */
1144
const gchar *ibus_layout;
1145
ibus_layout = ibus_engine_desc_get_layout (engine_desc);
1148
layout = layout_from_ibus_layout (ibus_layout);
1149
variant = variant_from_ibus_layout (ibus_layout);
1150
options = options_from_ibus_layout (ibus_layout);
1153
g_warning ("Couldn't find IBus input source '%s'", id);
1157
/* NULL here is a shortcut for "I already know I
1158
need the IBus module". */
1159
set_gtk_im_module (manager, NULL);
1160
set_ibus_engine (manager, id);
1162
g_warning ("IBus input source type specified but IBus support was not compiled");
1165
g_warning ("Unknown input source type '%s'", type);
1169
apply_xkb_settings (manager, layout, variant,
1170
prepare_xkb_options (manager, n_sources, options));
1171
maybe_return_from_set_input_source (manager);
1172
g_variant_unref (sources);
1175
g_strfreev (options);
1176
/* Prevent individual "changed" signal invocations since we
1182
apply_bell (GsdKeyboardManager *manager)
1184
GSettings *settings;
1185
XKeyboardControl kbdcontrol;
1190
GsdBellMode bell_mode;
1193
g_debug ("Applying the bell settings");
1194
settings = manager->priv->settings;
1195
click = g_settings_get_boolean (settings, KEY_CLICK);
1196
click_volume = g_settings_get_int (settings, KEY_CLICK_VOLUME);
1198
bell_pitch = g_settings_get_int (settings, KEY_BELL_PITCH);
1199
bell_duration = g_settings_get_int (settings, KEY_BELL_DURATION);
1201
bell_mode = g_settings_get_enum (settings, KEY_BELL_MODE);
1202
bell_volume = (bell_mode == GSD_BELL_MODE_ON) ? 50 : 0;
1204
/* as percentage from 0..100 inclusive */
1205
if (click_volume < 0) {
1207
} else if (click_volume > 100) {
1210
kbdcontrol.key_click_percent = click ? click_volume : 0;
1211
kbdcontrol.bell_percent = bell_volume;
1212
kbdcontrol.bell_pitch = bell_pitch;
1213
kbdcontrol.bell_duration = bell_duration;
1215
gdk_error_trap_push ();
1216
XChangeKeyboardControl (GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()),
1217
KBKeyClickPercent | KBBellPercent | KBBellPitch | KBBellDuration,
1220
XSync (GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()), FALSE);
1221
gdk_error_trap_pop_ignored ();
1225
apply_numlock (GsdKeyboardManager *manager)
1227
GSettings *settings;
1230
g_debug ("Applying the num-lock settings");
1231
settings = manager->priv->settings;
1232
rnumlock = g_settings_get_boolean (settings, KEY_REMEMBER_NUMLOCK_STATE);
1233
manager->priv->old_state = g_settings_get_enum (manager->priv->settings, KEY_NUMLOCK_STATE);
1235
gdk_error_trap_push ();
1237
g_debug ("Remember num-lock is set, so applying setting '%s'",
1238
num_lock_state_to_string (manager->priv->old_state));
1239
numlock_set_xkb_state (manager->priv->old_state);
1242
XSync (GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()), FALSE);
1243
gdk_error_trap_pop_ignored ();
1247
apply_repeat (GsdKeyboardManager *manager)
1249
GSettings *settings;
1254
g_debug ("Applying the repeat settings");
1255
settings = manager->priv->settings;
1256
repeat = g_settings_get_boolean (settings, KEY_REPEAT);
1257
interval = g_settings_get_uint (settings, KEY_INTERVAL);
1258
delay = g_settings_get_uint (settings, KEY_DELAY);
1260
gdk_error_trap_push ();
1262
gboolean rate_set = FALSE;
1264
XAutoRepeatOn (GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()));
1265
/* Use XKB in preference */
1266
rate_set = xkb_set_keyboard_autorepeat_rate (delay, interval);
1269
g_warning ("Neither XKeyboard not Xfree86's keyboard extensions are available,\n"
1270
"no way to support keyboard autorepeat rate settings");
1272
XAutoRepeatOff (GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()));
1275
XSync (GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()), FALSE);
1276
gdk_error_trap_pop_ignored ();
1280
apply_all_settings (GsdKeyboardManager *manager)
1282
apply_repeat (manager);
1283
apply_bell (manager);
1284
apply_numlock (manager);
1288
settings_changed (GSettings *settings,
1290
GsdKeyboardManager *manager)
1292
if (g_strcmp0 (key, KEY_CLICK) == 0||
1293
g_strcmp0 (key, KEY_CLICK_VOLUME) == 0 ||
1294
g_strcmp0 (key, KEY_BELL_PITCH) == 0 ||
1295
g_strcmp0 (key, KEY_BELL_DURATION) == 0 ||
1296
g_strcmp0 (key, KEY_BELL_MODE) == 0) {
1297
g_debug ("Bell setting '%s' changed, applying bell settings", key);
1298
apply_bell (manager);
1299
} else if (g_strcmp0 (key, KEY_REMEMBER_NUMLOCK_STATE) == 0) {
1300
g_debug ("Remember Num-Lock state '%s' changed, applying num-lock settings", key);
1301
apply_numlock (manager);
1302
} else if (g_strcmp0 (key, KEY_NUMLOCK_STATE) == 0) {
1303
g_debug ("Num-Lock state '%s' changed, will apply at next startup", key);
1304
} else if (g_strcmp0 (key, KEY_REPEAT) == 0 ||
1305
g_strcmp0 (key, KEY_INTERVAL) == 0 ||
1306
g_strcmp0 (key, KEY_DELAY) == 0) {
1307
g_debug ("Key repeat setting '%s' changed, applying key repeat settings", key);
1308
apply_repeat (manager);
1310
g_warning ("Unhandled settings change, key '%s'", key);
1316
device_added_cb (GdkDeviceManager *device_manager,
1318
GsdKeyboardManager *manager)
1320
GdkInputSource source;
1322
source = gdk_device_get_source (device);
1323
if (source == GDK_SOURCE_KEYBOARD) {
1324
g_debug ("New keyboard plugged in, applying all settings");
1325
apply_input_sources_settings (manager->priv->input_sources_settings, NULL, 0, manager);
1326
run_custom_command (device, COMMAND_DEVICE_ADDED);
1331
device_removed_cb (GdkDeviceManager *device_manager,
1333
GsdKeyboardManager *manager)
1335
GdkInputSource source;
1337
source = gdk_device_get_source (device);
1338
if (source == GDK_SOURCE_KEYBOARD) {
1339
run_custom_command (device, COMMAND_DEVICE_REMOVED);
1344
set_devicepresence_handler (GsdKeyboardManager *manager)
1346
GdkDeviceManager *device_manager;
1348
device_manager = gdk_display_get_device_manager (gdk_display_get_default ());
1350
manager->priv->device_added_id = g_signal_connect (G_OBJECT (device_manager), "device-added",
1351
G_CALLBACK (device_added_cb), manager);
1352
manager->priv->device_removed_id = g_signal_connect (G_OBJECT (device_manager), "device-removed",
1353
G_CALLBACK (device_removed_cb), manager);
1354
manager->priv->device_manager = device_manager;
1358
get_sources_from_xkb_config (GsdKeyboardManager *manager)
1360
GsdKeyboardManagerPrivate *priv = manager->priv;
1361
GVariantBuilder builder;
1364
gchar **layouts = NULL;
1365
gchar **variants = NULL;
1366
gboolean have_default_layout = FALSE;
1368
v = g_dbus_proxy_get_cached_property (priv->localed, "X11Layout");
1370
const gchar *s = g_variant_get_string (v, NULL);
1372
layouts = g_strsplit (s, ",", -1);
1373
g_variant_unref (v);
1379
v = g_dbus_proxy_get_cached_property (priv->localed, "X11Variant");
1381
const gchar *s = g_variant_get_string (v, NULL);
1383
variants = g_strsplit (s, ",", -1);
1384
g_variant_unref (v);
1387
if (variants && variants[0])
1388
n = MIN (g_strv_length (layouts), g_strv_length (variants));
1390
n = g_strv_length (layouts);
1392
init_builder_with_sources (&builder, priv->input_sources_settings);
1394
for (i = 0; i < n && layouts[i][0]; ++i) {
1397
if (variants && variants[i] && variants[i][0])
1398
id = g_strdup_printf ("%s+%s", layouts[i], variants[i]);
1400
id = g_strdup (layouts[i]);
1402
if (g_str_equal (id, DEFAULT_LAYOUT))
1403
have_default_layout = TRUE;
1405
g_variant_builder_add (&builder, "(ss)", INPUT_SOURCE_TYPE_XKB, id);
1409
if (!have_default_layout)
1410
g_variant_builder_add (&builder, "(ss)", INPUT_SOURCE_TYPE_XKB, DEFAULT_LAYOUT);
1412
g_settings_set_value (priv->input_sources_settings, KEY_INPUT_SOURCES, g_variant_builder_end (&builder));
1414
g_strfreev (layouts);
1415
g_strfreev (variants);
1419
get_options_from_xkb_config (GsdKeyboardManager *manager)
1421
GsdKeyboardManagerPrivate *priv = manager->priv;
1423
gchar **options = NULL;
1425
v = g_dbus_proxy_get_cached_property (priv->localed, "X11Options");
1427
const gchar *s = g_variant_get_string (v, NULL);
1429
options = g_strsplit (s, ",", -1);
1430
g_variant_unref (v);
1436
g_settings_set_strv (priv->input_sources_settings, KEY_KEYBOARD_OPTIONS, (const gchar * const*) options);
1438
g_strfreev (options);
1442
convert_libgnomekbd_options (GSettings *settings)
1444
GPtrArray *opt_array;
1445
GSettings *libgnomekbd_settings;
1446
gchar **options, **o;
1448
if (!schema_is_installed ("org.gnome.libgnomekbd.keyboard"))
1451
opt_array = g_ptr_array_new_with_free_func (g_free);
1453
libgnomekbd_settings = g_settings_new ("org.gnome.libgnomekbd.keyboard");
1454
options = g_settings_get_strv (libgnomekbd_settings, "options");
1456
for (o = options; *o; ++o) {
1459
strv = g_strsplit (*o, "\t", 2);
1460
if (strv[0] && strv[1])
1461
g_ptr_array_add (opt_array, g_strdup (strv[1]));
1464
g_ptr_array_add (opt_array, NULL);
1466
g_settings_set_strv (settings, KEY_KEYBOARD_OPTIONS, (const gchar * const*) opt_array->pdata);
1468
g_strfreev (options);
1469
g_object_unref (libgnomekbd_settings);
1470
g_ptr_array_free (opt_array, TRUE);
1474
convert_libgnomekbd_layouts (GSettings *settings)
1476
GVariantBuilder builder;
1477
GSettings *libgnomekbd_settings;
1478
gchar **layouts, **l;
1480
if (!schema_is_installed ("org.gnome.libgnomekbd.keyboard"))
1483
init_builder_with_sources (&builder, settings);
1485
libgnomekbd_settings = g_settings_new ("org.gnome.libgnomekbd.keyboard");
1486
layouts = g_settings_get_strv (libgnomekbd_settings, "layouts");
1488
for (l = layouts; *l; ++l) {
1492
strv = g_strsplit (*l, "\t", 2);
1493
if (strv[0] && !strv[1])
1494
id = g_strdup (strv[0]);
1495
else if (strv[0] && strv[1])
1496
id = g_strdup_printf ("%s+%s", strv[0], strv[1]);
1501
g_variant_builder_add (&builder, "(ss)", INPUT_SOURCE_TYPE_XKB, id);
1507
g_settings_set_value (settings, KEY_INPUT_SOURCES, g_variant_builder_end (&builder));
1509
g_strfreev (layouts);
1510
g_object_unref (libgnomekbd_settings);
1514
maybe_convert_old_settings (GSettings *settings)
1518
gchar *stamp_dir_path = NULL;
1519
gchar *stamp_file_path = NULL;
1520
GError *error = NULL;
1522
stamp_dir_path = g_build_filename (g_get_user_data_dir (), PACKAGE_NAME, NULL);
1523
if (g_mkdir_with_parents (stamp_dir_path, 0755)) {
1524
g_warning ("Failed to create directory %s: %s", stamp_dir_path, g_strerror (errno));
1528
stamp_file_path = g_build_filename (stamp_dir_path, "input-sources-converted", NULL);
1529
if (g_file_test (stamp_file_path, G_FILE_TEST_EXISTS))
1532
sources = g_settings_get_value (settings, KEY_INPUT_SOURCES);
1533
if (g_variant_n_children (sources) < 1) {
1534
convert_libgnomekbd_layouts (settings);
1536
convert_ibus (settings);
1539
g_variant_unref (sources);
1541
options = g_settings_get_strv (settings, KEY_KEYBOARD_OPTIONS);
1542
if (g_strv_length (options) < 1)
1543
convert_libgnomekbd_options (settings);
1544
g_strfreev (options);
1546
if (!g_file_set_contents (stamp_file_path, "", 0, &error)) {
1547
g_warning ("%s", error->message);
1548
g_error_free (error);
1551
g_free (stamp_file_path);
1552
g_free (stamp_dir_path);
1556
maybe_create_initial_settings (GsdKeyboardManager *manager)
1558
GSettings *settings;
1562
settings = manager->priv->input_sources_settings;
1564
if (g_getenv ("RUNNING_UNDER_GDM")) {
1565
GVariantBuilder builder;
1566
/* clean the settings and get them from the "system" */
1567
g_variant_builder_init (&builder, G_VARIANT_TYPE ("a(ss)"));
1568
g_settings_set_value (settings, KEY_INPUT_SOURCES, g_variant_builder_end (&builder));
1569
get_sources_from_xkb_config (manager);
1571
g_settings_set_strv (settings, KEY_KEYBOARD_OPTIONS, NULL);
1572
get_options_from_xkb_config (manager);
1576
maybe_convert_old_settings (settings);
1578
/* if we still don't have anything do some educated guesses */
1579
sources = g_settings_get_value (settings, KEY_INPUT_SOURCES);
1580
if (g_variant_n_children (sources) < 1) {
1581
get_sources_from_xkb_config (manager);
1583
add_ibus_sources_from_locale (settings);
1586
g_variant_unref (sources);
1588
options = g_settings_get_strv (settings, KEY_KEYBOARD_OPTIONS);
1589
if (g_strv_length (options) < 1)
1590
get_options_from_xkb_config (manager);
1591
g_strfreev (options);
1595
set_input_source_return (GDBusMethodInvocation *invocation)
1597
g_dbus_method_invocation_return_value (invocation, NULL);
1601
maybe_return_from_set_input_source (GsdKeyboardManager *manager)
1603
GsdKeyboardManagerPrivate *priv = manager->priv;
1605
if (!priv->invocation)
1608
if (priv->pending_ops > 0) {
1609
priv->pending_ops -= 1;
1613
g_clear_pointer (&priv->invocation, set_input_source_return);
1617
increment_set_input_source_ops (GsdKeyboardManager *manager)
1619
GsdKeyboardManagerPrivate *priv = manager->priv;
1621
if (!priv->invocation)
1624
priv->pending_ops += 1;
1628
set_input_source (GsdKeyboardManager *manager)
1630
GsdKeyboardManagerPrivate *priv = manager->priv;
1633
g_variant_get (g_dbus_method_invocation_get_parameters (priv->invocation), "(u)", &idx);
1635
if (idx == g_settings_get_uint (priv->input_sources_settings, KEY_CURRENT_INPUT_SOURCE)) {
1636
maybe_return_from_set_input_source (manager);
1640
g_settings_set_uint (priv->input_sources_settings, KEY_CURRENT_INPUT_SOURCE, idx);
1644
handle_dbus_method_call (GDBusConnection *connection,
1645
const gchar *sender,
1646
const gchar *object_path,
1647
const gchar *interface_name,
1648
const gchar *method_name,
1649
GVariant *parameters,
1650
GDBusMethodInvocation *invocation,
1651
GsdKeyboardManager *manager)
1653
GsdKeyboardManagerPrivate *priv = manager->priv;
1655
if (g_str_equal (method_name, "SetInputSource")) {
1656
if (priv->invocation) {
1658
/* This can only happen if there's an
1659
* ibus_bus_set_global_engine_async() call
1661
g_cancellable_cancel (priv->ibus_cancellable);
1663
g_clear_pointer (&priv->invocation, set_input_source_return);
1664
priv->pending_ops = 0;
1666
priv->invocation = invocation;
1667
set_input_source (manager);
1672
on_bus_name_lost (GDBusConnection *connection,
1676
g_warning ("DBus name %s lost", name);
1680
got_session_bus (GObject *source,
1682
GsdKeyboardManager *manager)
1684
GsdKeyboardManagerPrivate *priv;
1685
GDBusConnection *connection;
1686
GError *error = NULL;
1687
GDBusInterfaceVTable vtable = {
1688
(GDBusInterfaceMethodCallFunc) handle_dbus_method_call,
1693
connection = g_bus_get_finish (res, &error);
1695
if (!g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED))
1696
g_warning ("Couldn't get session bus: %s", error->message);
1697
g_error_free (error);
1701
priv = manager->priv;
1702
priv->dbus_connection = connection;
1704
priv->dbus_register_object_id = g_dbus_connection_register_object (priv->dbus_connection,
1705
GSD_KEYBOARD_DBUS_PATH,
1706
priv->dbus_introspection->interfaces[0],
1711
if (!priv->dbus_register_object_id) {
1712
g_warning ("Error registering object: %s", error->message);
1713
g_error_free (error);
1717
priv->dbus_own_name_id = g_bus_own_name_on_connection (priv->dbus_connection,
1718
GSD_KEYBOARD_DBUS_NAME,
1719
G_BUS_NAME_OWNER_FLAGS_NONE,
1727
register_manager_dbus (GsdKeyboardManager *manager)
1729
GError *error = NULL;
1731
manager->priv->dbus_introspection = g_dbus_node_info_new_for_xml (introspection_xml, &error);
1733
g_warning ("Error creating introspection data: %s", error->message);
1734
g_error_free (error);
1738
g_bus_get (G_BUS_TYPE_SESSION,
1739
manager->priv->cancellable,
1740
(GAsyncReadyCallback) got_session_bus,
1745
localed_proxy_ready (GObject *source,
1749
GsdKeyboardManager *manager = data;
1751
GError *error = NULL;
1753
proxy = g_dbus_proxy_new_finish (res, &error);
1755
if (g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED)) {
1756
g_error_free (error);
1759
g_warning ("Failed to contact localed: %s", error->message);
1760
g_error_free (error);
1764
manager->priv->localed = proxy;
1765
maybe_create_initial_settings (manager);
1767
apply_input_sources_settings (manager->priv->input_sources_settings, NULL, 0, manager);
1768
register_manager_dbus (manager);
1772
start_keyboard_idle_cb (GsdKeyboardManager *manager)
1774
gnome_settings_profile_start (NULL);
1776
g_debug ("Starting keyboard manager");
1778
manager->priv->settings = g_settings_new (GSD_KEYBOARD_DIR);
1782
set_devicepresence_handler (manager);
1784
manager->priv->input_sources_settings = g_settings_new (GNOME_DESKTOP_INPUT_SOURCES_DIR);
1785
manager->priv->interface_settings = g_settings_new (GNOME_DESKTOP_INTERFACE_DIR);
1786
manager->priv->xkb_info = gnome_xkb_info_new ();
1788
manager->priv->cancellable = g_cancellable_new ();
1790
g_dbus_proxy_new_for_bus (G_BUS_TYPE_SYSTEM,
1791
G_DBUS_PROXY_FLAGS_NONE,
1793
"org.freedesktop.locale1",
1794
"/org/freedesktop/locale1",
1795
"org.freedesktop.locale1",
1796
manager->priv->cancellable,
1797
localed_proxy_ready,
1800
/* apply current settings before we install the callback */
1801
g_debug ("Started the keyboard plugin, applying all settings");
1802
apply_all_settings (manager);
1804
g_signal_connect (G_OBJECT (manager->priv->settings), "changed",
1805
G_CALLBACK (settings_changed), manager);
1806
g_signal_connect (G_OBJECT (manager->priv->input_sources_settings), "change-event",
1807
G_CALLBACK (apply_input_sources_settings), manager);
1809
install_xkb_filter (manager);
1811
gnome_settings_profile_end (NULL);
1813
manager->priv->start_idle_id = 0;
1819
gsd_keyboard_manager_start (GsdKeyboardManager *manager,
1822
gnome_settings_profile_start (NULL);
1824
if (check_xkb_extension (manager) == FALSE) {
1825
g_debug ("XKB is not supported, not applying any settings");
1829
manager->priv->start_idle_id = g_idle_add ((GSourceFunc) start_keyboard_idle_cb, manager);
1831
gnome_settings_profile_end (NULL);
1837
gsd_keyboard_manager_stop (GsdKeyboardManager *manager)
1839
GsdKeyboardManagerPrivate *p = manager->priv;
1841
g_debug ("Stopping keyboard manager");
1843
if (p->dbus_own_name_id) {
1844
g_bus_unown_name (p->dbus_own_name_id);
1845
p->dbus_own_name_id = 0;
1848
if (p->dbus_register_object_id) {
1849
g_dbus_connection_unregister_object (p->dbus_connection,
1850
p->dbus_register_object_id);
1851
p->dbus_register_object_id = 0;
1854
g_cancellable_cancel (p->cancellable);
1855
g_clear_object (&p->cancellable);
1857
g_clear_object (&p->settings);
1858
g_clear_object (&p->input_sources_settings);
1859
g_clear_object (&p->interface_settings);
1860
g_clear_object (&p->xkb_info);
1861
g_clear_object (&p->localed);
1864
clear_ibus (manager);
1867
if (p->device_manager != NULL) {
1868
g_signal_handler_disconnect (p->device_manager, p->device_added_id);
1869
g_signal_handler_disconnect (p->device_manager, p->device_removed_id);
1870
p->device_manager = NULL;
1873
remove_xkb_filter (manager);
1875
g_clear_pointer (&p->invocation, set_input_source_return);
1876
g_clear_pointer (&p->dbus_introspection, g_dbus_node_info_unref);
1877
g_clear_object (&p->dbus_connection);
1881
gsd_keyboard_manager_class_init (GsdKeyboardManagerClass *klass)
1883
GObjectClass *object_class = G_OBJECT_CLASS (klass);
1885
object_class->finalize = gsd_keyboard_manager_finalize;
1887
g_type_class_add_private (klass, sizeof (GsdKeyboardManagerPrivate));
1891
gsd_keyboard_manager_init (GsdKeyboardManager *manager)
1893
manager->priv = GSD_KEYBOARD_MANAGER_GET_PRIVATE (manager);
1897
gsd_keyboard_manager_finalize (GObject *object)
1899
GsdKeyboardManager *keyboard_manager;
1901
g_return_if_fail (object != NULL);
1902
g_return_if_fail (GSD_IS_KEYBOARD_MANAGER (object));
1904
keyboard_manager = GSD_KEYBOARD_MANAGER (object);
1906
g_return_if_fail (keyboard_manager->priv != NULL);
1908
if (keyboard_manager->priv->start_idle_id != 0)
1909
g_source_remove (keyboard_manager->priv->start_idle_id);
1911
G_OBJECT_CLASS (gsd_keyboard_manager_parent_class)->finalize (object);
1914
GsdKeyboardManager *
1915
gsd_keyboard_manager_new (void)
1917
if (manager_object != NULL) {
1918
g_object_ref (manager_object);
1920
manager_object = g_object_new (GSD_TYPE_KEYBOARD_MANAGER, NULL);
1921
g_object_add_weak_pointer (manager_object,
1922
(gpointer *) &manager_object);
1925
return GSD_KEYBOARD_MANAGER (manager_object);
added
removed
plugins/keyboard/gsd-keyboard-manager.c
