[gnome-shell/osk] Add keyboard to GNOME shell
- From: Dan Winship <danw src gnome org>
- To: commits-list gnome org
- Cc:
- Subject: [gnome-shell/osk] Add keyboard to GNOME shell
- Date: Tue, 12 Jul 2011 12:54:02 +0000 (UTC)
commit 6e4d05bb58e026df1f5e9917471e6fa4cce9bc86
Author: Nohemi Fernandez <nf68 cornell edu>
Date: Mon Jul 11 15:20:37 2011 -0400
Add keyboard to GNOME shell
data/org.gnome.shell.gschema.xml.in | 33 ++
data/theme/gnome-shell.css | 50 +++
js/Makefile.am | 1 +
js/ui/keyboard.js | 570 +++++++++++++++++++++++++++++++++++
js/ui/main.js | 3 +
js/ui/status/accessibility.js | 8 +-
tools/build/gnome-shell.modules | 3 +-
7 files changed, 664 insertions(+), 4 deletions(-)
---
diff --git a/data/org.gnome.shell.gschema.xml.in b/data/org.gnome.shell.gschema.xml.in
index 050c413..1f353a1 100644
--- a/data/org.gnome.shell.gschema.xml.in
+++ b/data/org.gnome.shell.gschema.xml.in
@@ -62,6 +62,7 @@
<child name="clock" schema="org.gnome.shell.clock"/>
<child name="calendar" schema="org.gnome.shell.calendar"/>
<child name="recorder" schema="org.gnome.shell.recorder"/>
+ <child name="keyboard" schema="org.gnome.shell.keyboard"/>
</schema>
<schema id="org.gnome.shell.calendar" path="/org/gnome/shell/calendar/"
@@ -75,6 +76,38 @@
</key>
</schema>
+ <schema id="org.gnome.shell.keyboard" path="/org/gnome/shell/keyboard/"
+ gettext-domain="@GETTEXT_PACKAGE@">
+ <key name="show-keyboard" type="b">
+ <default>true</default>
+ <_summary>Show the onscreen keyboard</_summary>
+ <_description>
+ If true, display onscreen keyboard.
+ </_description>
+ </key>
+ <key name="keyboard-type" type="s">
+ <default>'touch'</default>
+ <_summary>Which keyboard to use</_summary>
+ <_description>
+ The type of keyboard to use.
+ </_description>
+ </key>
+ <key name="enable-drag" type="b">
+ <default>true</default>
+ <_summary>Enable keyboard dragging</_summary>
+ <_description>
+ If true, enable keyboard dragging.
+ </_description>
+ </key>
+ <key name="enable-float" type="b">
+ <default>true</default>
+ <_summary>Enable floating keyboard</_summary>
+ <_description>
+ If true, enable floating keyboard.
+ </_description>
+ </key>
+ </schema>
+
<schema id="org.gnome.shell.clock" path="/org/gnome/shell/clock/"
gettext-domain="@GETTEXT_PACKAGE@">
<key name="show-seconds" type="b">
diff --git a/data/theme/gnome-shell.css b/data/theme/gnome-shell.css
index 1d9c72f..e714513 100644
--- a/data/theme/gnome-shell.css
+++ b/data/theme/gnome-shell.css
@@ -1671,3 +1671,53 @@ StTooltip StLabel {
.magnifier-zoom-region.full-screen {
border-width: 0px;
}
+
+/* On-screen Keyboard */
+
+#keyboard {
+ border: 1px solid white;
+ background: rgba(0,0,0,0.8);
+}
+
+.keyboard-layout {
+ spacing: 10px;
+ padding: 10px;
+}
+
+.keyboard-row {
+ spacing: 15px;
+}
+
+.keyboard-key {
+ min-height: 30px;
+ min-width: 30px;
+ background-gradient-start: rgba(255,245,245,0.4);
+ background-gradient-end: rgba(105,105,105,0.1);
+ background-gradient-direction: vertical;
+ font-size: 14pt;
+ font-weight: bold;
+ border-radius: 5px;
+ border: 1px solid white;
+ color: white;
+}
+
+.keyboard-key:checked,
+.keyboard-key:hover {
+ background: #303030;
+ border: 3px solid white;
+}
+
+.keyboard-key:active {
+ background: #808080;
+}
+
+.keyboard-subkeys {
+ color: white;
+ padding: 5px;
+ -arrow-border-radius: 10px;
+ -arrow-background-color: #090909;
+ -arrow-border-width: 2px;
+ -arrow-border-color: white;
+ -arrow-base: 20px;
+ -arrow-rise: 10px;
+}
diff --git a/js/Makefile.am b/js/Makefile.am
index 758b4c0..6fe1b5b 100644
--- a/js/Makefile.am
+++ b/js/Makefile.am
@@ -27,6 +27,7 @@ nobase_dist_js_DATA = \
ui/environment.js \
ui/extensionSystem.js \
ui/iconGrid.js \
+ ui/keyboard.js \
ui/layout.js \
ui/lightbox.js \
ui/link.js \
diff --git a/js/ui/keyboard.js b/js/ui/keyboard.js
new file mode 100644
index 0000000..b6ef05b
--- /dev/null
+++ b/js/ui/keyboard.js
@@ -0,0 +1,570 @@
+/* -*- mode: js2; js2-basic-offset: 4; indent-tabs-mode: nil -*- */
+
+const Caribou = imports.gi.Caribou;
+const Clutter = imports.gi.Clutter;
+const DBus = imports.dbus;
+const Gdk = imports.gi.Gdk;
+const Gio = imports.gi.Gio;
+const GLib = imports.gi.GLib;
+const Lang = imports.lang;
+const Meta = imports.gi.Meta;
+const Shell = imports.gi.Shell;
+const St = imports.gi.St;
+
+const BoxPointer = imports.ui.boxpointer;
+const Main = imports.ui.main;
+const MessageTray = imports.ui.messageTray;
+const PopupMenu = imports.ui.popupMenu;
+
+const KEYBOARD_SCHEMA = 'org.gnome.shell.keyboard';
+const SHOW_KEYBOARD = 'show-keyboard';
+const KEYBOARD_TYPE = 'keyboard-type';
+const ENABLE_DRAGGABLE = 'enable-drag';
+const ENABLE_FLOAT = 'enable-float';
+
+// Key constants taken from Antler
+const PRETTY_KEYS = {
+ 'BackSpace': '\u232b',
+ 'space': ' ',
+ 'Return': '\u23ce',
+ 'Caribou_Prefs': '\u2328',
+ 'Caribou_ShiftUp': '\u2b06',
+ 'Caribou_ShiftDown': '\u2b07',
+ 'Caribou_Emoticons': '\u263a',
+ 'Caribou_Symbols': '123',
+ 'Caribou_Symbols_More': '{#*',
+ 'Caribou_Alpha': 'Abc',
+ 'Tab': 'Tab',
+ 'Escape': 'Esc',
+ 'Control_L': 'Ctrl',
+ 'Alt_L': 'Alt'
+};
+
+const CaribouKeyboardIface = {
+ name: 'org.gnome.Caribou.Keyboard',
+ methods: [ { name: 'Show',
+ inSignature: '',
+ outSignature: ''
+ },
+ { name: 'Hide',
+ inSignature: '',
+ outSignature: ''
+ },
+ { name: 'SetCursorLocation',
+ inSignature: 'iiii',
+ outSignature: ''
+ },
+ { name: 'SetEntryLocation',
+ inSignature: 'iiii',
+ outSignature: ''
+ } ],
+ properties: [ { name: 'Name',
+ signature: 's',
+ access: 'read' } ]
+};
+
+function Key() {
+ this._init.apply(this, arguments);
+}
+
+Key.prototype = {
+ _init : function(key, key_width, key_height) {
+ this._key = key;
+
+ this._width = key_width;
+ this._height = key_height;
+
+ this.actor = this._getKey();
+
+ this._extended_keys = this._key.get_extended_keys();
+ this._extended_keyboard = {};
+
+ if (this._key.name == "Control_L" || this._key.name == "Alt_L")
+ this._key.latch = true;
+
+ this._key.connect('key-pressed', Lang.bind(this, function ()
+ { this.actor.checked = true }));
+ this._key.connect('key-released', Lang.bind(this, function ()
+ { this.actor.checked = false; }));
+
+ if (this._extended_keys.length > 0) {
+ this._grabbed = false;
+ this._eventCaptureId = 0;
+ this._key.connect('notify::show-subkeys', Lang.bind(this, this._onShowSubkeysChanged));
+ this._boxPointer = new BoxPointer.BoxPointer(St.Side.BOTTOM,
+ { x_fill: true,
+ y_fill: true,
+ x_align: St.Align.START });
+ // Adds style to existing keyboard style to avoid repetition
+ this._boxPointer.actor.add_style_class_name('keyboard-subkeys');
+ this._getExtendedKeys();
+ this.actor._extended_keys = this._extended_keyboard;
+ this._boxPointer.actor.hide();
+ Main.chrome.addActor(this._boxPointer.actor, { visibleInFullscreen: true,
+ affectsStruts: false });
+ }
+ },
+
+ _getKey: function () {
+ let label = this._key.name;
+
+ if (label.length > 1) {
+ let pretty = PRETTY_KEYS[label];
+ if (pretty)
+ label = pretty;
+ else
+ label = this._getUnichar(this._key);
+ }
+
+ label = GLib.markup_escape_text(label, -1);
+ let button = new St.Button ({ label: label, style_class: 'keyboard-key' });
+
+ button.width = this._width;
+ button.key_width = this._key.width;
+ button.height = this._height;
+ button.draggable = false;
+ button.connect('button-press-event', Lang.bind(this, function () { this._key.press(); }));
+ button.connect('button-release-event', Lang.bind(this, function () { this._key.release(); }));
+
+ return button;
+ },
+
+ _getUnichar: function(key) {
+ let keyval = key.keyval;
+ let unichar = Gdk.keyval_to_unicode(keyval);
+ if (unichar) {
+ return String.fromCharCode(unichar);
+ } else {
+ return key.name;
+ }
+ },
+
+ _getExtendedKeys: function () {
+ this._extended_keyboard = new St.BoxLayout({ style_class: 'keyboard-layout',
+ vertical: false });
+ for (let i = 0; i < this._extended_keys.length; ++i) {
+ let extended_key = this._extended_keys[i];
+ let label = this._getUnichar(extended_key);
+ let key = new St.Button({ label: label, style_class: 'keyboard-key' });
+ key.extended_key = extended_key;
+ key.width = this._width;
+ key.height = this._height;
+ key.draggable = false;
+ key.connect('button-press-event', Lang.bind(this, function () { extended_key.press(); }));
+ key.connect('button-release-event', Lang.bind(this, function () { extended_key.release(); }));
+ this._extended_keyboard.add(key);
+ }
+ this._boxPointer.bin.add_actor(this._extended_keyboard);
+ },
+
+ _onEventCapture: function (actor, event) {
+ let source = event.get_source();
+ if (event.type() == Clutter.EventType.BUTTON_PRESS ||
+ (event.type() == Clutter.EventType.BUTTON_RELEASE && source.draggable)) {
+ if (this._extended_keyboard.contains(source)) {
+ if (source.draggable) {
+ source.extended_key.press();
+ source.extended_key.release();
+ }
+ this._ungrab();
+ return false;
+ }
+ this._boxPointer.actor.hide();
+ this._ungrab();
+ return true;
+ }
+ return false;
+ },
+
+ _ungrab: function () {
+ global.stage.disconnect(this._eventCaptureId);
+ this._eventCaptureId = 0;
+ this._grabbed = false;
+ Main.popModal(this.actor);
+ },
+
+ _onShowSubkeysChanged: function () {
+ if (this._key.show_subkeys) {
+ this.actor.fake_release();
+ this._boxPointer.actor.raise_top();
+ this._boxPointer.setPosition(this.actor, 5, 0.5);
+ this._boxPointer.show(true);
+ this.actor.set_hover(false);
+ if (!this._grabbed) {
+ Main.pushModal(this.actor);
+ this._eventCaptureId = global.stage.connect('captured-event', Lang.bind(this, this._onEventCapture));
+ this._grabbed = true;
+ }
+ this._key.release();
+ } else {
+ if (this._grabbed)
+ this._ungrab();
+ this._boxPointer.hide(true);
+ }
+ }
+};
+
+function Keyboard() {
+ this._init.apply(this, arguments);
+}
+
+Keyboard.prototype = {
+ _init: function () {
+ DBus.session.exportObject('/org/gnome/Caribou/Keyboard', this);
+ DBus.session.acquire_name('org.gnome.Caribou.Keyboard', 0, null, null);
+
+ if (GLib.getenv("GTK_IM_MODULE") != 'caribou')
+ log('GTK_IM_MODULE not set to "caribou"; automatic showing/hiding of the keyboard may not work');
+
+ this.actor = new St.BoxLayout({ name: 'keyboard', vertical: false, reactive: true });
+
+ this._keyboardSettings = new Gio.Settings({ schema: KEYBOARD_SCHEMA });
+ this._keyboardSettings.connect('changed', Lang.bind(this, this._display));
+
+ this._setupKeyboard();
+
+ Main.layoutManager.connect('monitors-changed', Lang.bind(this, this._reposition));
+ this.actor.connect('allocation-changed', Lang.bind(this, this._queueReposition));
+
+ Main.chrome.addActor(this.actor, { visibleInFullscreen: true,
+ affectsStruts: false });
+ this.showTray = true;
+ this._reposition();
+ this._display();
+ },
+
+ _setupKeyboard: function() {
+ if (this._keyboardNotifyId)
+ this._keyboard.disconnect(this._keyboardNotifyId);
+ let children = this.actor.get_children();
+ for (let i = 0; i < children.length; i++)
+ children[i].destroy();
+
+ this._keyboard = new Caribou.KeyboardModel({ keyboard_type: this._keyboardSettings.get_string(KEYBOARD_TYPE) });
+ this._groups = {};
+ this._current_page = null;
+
+ // Initialize keyboard key measurements
+ this._numOfHorizKeys = 0;
+ this._numOfVertKeys = 0;
+
+ this._floatId = 0;
+
+ this._addKeys();
+
+ this._keyboardNotifyId = this._keyboard.connect('notify::active-group', Lang.bind(this, this._onGroupChanged));
+ },
+
+ _display: function () {
+ if (this._keyboard.keyboard_type != this._keyboardSettings.get_string(KEYBOARD_TYPE))
+ this._setupKeyboard();
+
+ this._showKeyboard = this._keyboardSettings.get_boolean(SHOW_KEYBOARD);
+ this._draggable = this._keyboardSettings.get_boolean(ENABLE_DRAGGABLE);
+ this.floating = this._keyboardSettings.get_boolean(ENABLE_FLOAT);
+ if (this.floating) {
+ this._floatId = this.actor.connect('button-press-event', Lang.bind(this, this._startDragging));
+ this._dragging = false;
+ }
+ else
+ this.actor.disconnect(this._floatId);
+ if (this._showKeyboard) {
+ this.show();
+ this._reposition();
+ } else {
+ if (this._source)
+ this._source.destroy();
+ this.hide();
+ }
+ },
+
+ _startDragging: function (actor, event) {
+ if (this._dragging) // don't allow two drags at the same time
+ return;
+ this._dragging = true;
+ this._preDragStageMode = global.stage_input_mode;
+
+ Clutter.grab_pointer(this.actor);
+ global.set_stage_input_mode(Shell.StageInputMode.FULLSCREEN);
+
+ this._releaseId = this.actor.connect('button-release-event', Lang.bind(this, this._endDragging));
+ this._motionId = this.actor.connect('motion-event', Lang.bind(this, this._motionEvent));
+ [this._dragStartX, this._dragStartY] = event.get_coords();
+ [this._currentX, this._currentY] = this.actor.get_position();
+ },
+
+ _endDragging: function () {
+ if (this._dragging) {
+ this.actor.disconnect(this._releaseId);
+ this.actor.disconnect(this._motionId);
+
+ Clutter.ungrab_pointer();
+ global.set_stage_input_mode(this._preDragStageMode);
+ global.unset_cursor();
+ this._dragging = false;
+ }
+ return true;
+ },
+
+ _motionEvent: function(actor, event) {
+ let absX, absY;
+ [absX, absY] = event.get_coords();
+ global.set_cursor(Shell.Cursor.DND_IN_DRAG);
+ this._moveHandle(absX, absY);
+ return true;
+ },
+
+ _moveHandle: function (stageX, stageY) {
+ let x, y;
+ x = stageX - this._dragStartX + this._currentX;
+ y = stageY - this._dragStartY + this._currentY;
+ this.actor.set_position(x,y);
+
+ },
+
+ _onStyleChanged: function (actor) {
+ if (actor.style_class == 'keyboard-row')
+ this._horizontalSpacing = actor.get_theme_node().get_length('spacing');
+ if (actor.style_class == 'keyboard-layout') {
+ this._verticalSpacing = actor.get_theme_node().get_length('spacing');
+ this._padding = actor.get_theme_node().get_length('padding');
+ }
+ },
+
+ _reposition: function () {
+ let primary = Main.layoutManager.primaryMonitor;
+ this.actor.x = primary.x;
+ this.actor.y = primary.y + primary.height - this.actor.height;
+ this.actor.height = primary.height / 3;
+ },
+
+ _queueReposition: function () {
+ // Meta.later_add(Meta.LaterType.BEFORE_REDRAW, Lang.bind(this, function () { this._reposition(); }));
+ },
+
+ _addKeys: function () {
+ let groups = this._keyboard.get_groups();
+ for (let i = 0; i < groups.length; ++i) {
+ let gname = groups[i];
+ let group = this._keyboard.get_group(gname);
+ group.connect('notify::active-level', Lang.bind(this, this._onLevelChanged));
+ let layers = {};
+ let levels = group.get_levels();
+ for (let j = 0; j < levels.length; ++j) {
+ let lname = levels[j];
+ let level = group.get_level(lname);
+ let layout = new St.BoxLayout({ style_class: 'keyboard-layout',
+ vertical: true });
+ this._loadRows(level, layout);
+ layers[lname] = layout;
+ this.actor.add(layout);
+
+ layout.hide();
+ }
+ this._groups[gname] = layers;
+ }
+ this._setActiveLayer();
+ },
+
+ _addRows : function (keys, layout) {
+ let keyboard_row = new St.BoxLayout ({ style_class: 'keyboard-row' });
+ for (let i = 0; i < keys.length; ++i) {
+ let children = keys[i].get_children();
+ let right_box = new St.BoxLayout({ style_class: 'keyboard-row' });
+ let left_box = new St.BoxLayout({ style_class: 'keyboard-row' });
+ for (let j = 0; j < children.length; ++j) {
+ if (this._numOfHorizKeys == 0)
+ this._numOfHorizKeys = children.length;
+ let key = children[j];
+ let button = new Key(key, 0, 0);
+
+ if (key.align == 'right')
+ right_box.add(button.actor);
+ else
+ left_box.add(button.actor);
+ if (key.name == "Caribou_Prefs")
+ key.connect('key-released', Lang.bind(this, this._onPrefsClick));
+ }
+ keyboard_row.add(left_box, { expand: true, x_fill: true});
+ keyboard_row.add(right_box, { expand: true, x_fill: true});
+ }
+ layout.add(keyboard_row);
+ },
+
+ _onPrefsClick: function () {
+ this._source = new KeyboardSource(this);
+ Main.messageTray.add(this._source);
+ this.hide();
+ },
+
+ _loadRows : function (level, layout) {
+ let rows = level.get_rows();
+ for (let i = 0; i < rows.length; ++i) {
+ let row = rows[i];
+ if (this._numOfVertKeys == 0)
+ this._numOfVertKeys = rows.length;
+ this._addRows(row.get_columns(),layout);
+ }
+
+ },
+
+ _redraw: function () {
+ if (this._verticalSpacing == 0)
+ this._current_page.connect('style-changed', Lang.bind(this, this._onStyleChanged));
+
+ let primary_monitor = Main.layoutManager.primaryMonitor;
+ let rows = this._current_page.get_children();
+ for (let i = 0; i < rows.length; ++i) {
+ let keyboard_row = rows[i];
+ if (this._horizontalSpacing == 0)
+ keyboard_row.connect('style-changed', Lang.bind(this, this._onStyleChanged));
+
+ this._onStyleChanged(keyboard_row);
+ this._onStyleChanged(this._current_page);
+ let boxes = keyboard_row.get_children();
+ for (let j = 0; j < boxes.length; ++j) {
+ let keys = boxes[j].get_children();
+ for (let k = 0; k < keys.length; ++k) {
+ let child = keys[k];
+ child.width = (primary_monitor.width - (this._numOfHorizKeys - 1) * this._horizontalSpacing
+ - 2 * this._padding)/ this._numOfHorizKeys * child.key_width;
+ child.height = (primary_monitor.height / 3 - (this._numOfVertKeys - 1) * this._verticalSpacing
+ - 2 * this._padding) / this._numOfVertKeys;
+ if (this.floating) {
+ child.height = Math.min(child.width, child.height);
+ child.width = child.height * child.key_width;
+ }
+ child.draggable = this._draggable;
+ if (child._extended_keys) {
+ let extended_keys = child._extended_keys.get_children();
+ for (let n = 0; n < extended_keys.length; ++n) {
+ let extended_key = extended_keys[n];
+ extended_key.width = child.width;
+ extended_key.height = child.height;
+ extended_key.draggable = this._draggable;
+ }
+ }
+ }
+ }
+ }
+ },
+
+ _onLevelChanged: function () {
+ this._setActiveLayer();
+ this._redraw();
+ },
+
+ _onGroupChanged: function () {
+ this._setActiveLayer();
+ this._redraw();
+ },
+
+ _setActiveLayer: function () {
+ let active_group_name = this._keyboard.active_group;
+ let active_group = this._keyboard.get_group(active_group_name);
+ let active_level = active_group.active_level;
+ let layers = this._groups[active_group_name];
+
+ if (this._current_page != null) {
+ this._current_page.hide();
+ }
+
+ this._current_page = layers[active_level];
+ this._current_page.show();
+ },
+
+ show: function () {
+ this._redraw();
+ this.actor.show();
+ this._current_page.show();
+ },
+
+ hide: function () {
+ this.actor.hide();
+ this._current_page.hide();
+ this.showTray = true;
+ },
+
+ // Window placement method
+ _updatePosition: function (x, y) {
+ let primary = Main.layoutManager.primaryMonitor;
+ x -= this.actor.width / 2;
+ // Determines bottom/top centered
+ if (y <= primary.height / 2)
+ y += this.actor.height / 2;
+ else
+ y -= 3 * this.actor.height / 2;
+
+ // Accounting for monitor boundaries
+ if (x < primary.x)
+ x = primary.x;
+ if (x + this.actor.width > primary.width)
+ x = primary.width - this.actor.width;
+
+ this.actor.set_position(x, y);
+ },
+
+ // D-Bus methods
+ Show: function() {
+ this.show();
+ },
+
+ Hide: function() {
+ this._source = new KeyboardSource(this);
+ Main.messageTray.add(this._source);
+ this.hide();
+ },
+
+ SetCursorLocation: function(x, y, w, h) {
+ if (this.floating)
+ this._updatePosition(x, y);
+ },
+
+ SetEntryLocation: function(x, y, w, h) {
+ if (this.floating)
+ this._updatePosition(x, y);
+ },
+
+ get Name() {
+ return 'gnome-shell';
+ }
+};
+DBus.conformExport(Keyboard.prototype, CaribouKeyboardIface);
+
+function KeyboardSource() {
+ this._init.apply(this, arguments);
+}
+
+KeyboardSource.prototype = {
+ __proto__: MessageTray.Source.prototype,
+
+ _init: function(keyboard) {
+ this._keyboard = keyboard;
+ MessageTray.Source.prototype._init.call(this, _("Keyboard"));
+
+ this._setSummaryIcon(this.createNotificationIcon());
+ },
+
+ createNotificationIcon: function() {
+ return new St.Icon({ icon_name: 'input-keyboard',
+ icon_type: St.IconType.SYMBOLIC,
+ icon_size: this.ICON_SIZE });
+ },
+
+ handleSummaryClick: function() {
+ let event = Clutter.get_current_event();
+ if (event.type() != Clutter.EventType.BUTTON_RELEASE)
+ return false;
+
+ if (event.get_button() != 1)
+ return false;
+
+ this.open();
+ return true;
+ },
+
+ open: function() {
+ this._keyboard.show();
+ this.destroy();
+ }
+};
diff --git a/js/ui/main.js b/js/ui/main.js
index 8ca9da9..3e953c3 100644
--- a/js/ui/main.js
+++ b/js/ui/main.js
@@ -18,6 +18,7 @@ const EndSessionDialog = imports.ui.endSessionDialog;
const PolkitAuthenticationAgent = imports.ui.polkitAuthenticationAgent;
const Environment = imports.ui.environment;
const ExtensionSystem = imports.ui.extensionSystem;
+const Keyboard = imports.ui.keyboard;
const MessageTray = imports.ui.messageTray;
const Overview = imports.ui.overview;
const Panel = imports.ui.panel;
@@ -60,6 +61,7 @@ let uiGroup = null;
let magnifier = null;
let xdndHandler = null;
let statusIconDispatcher = null;
+let keyboard = null;
let layoutManager = null;
let _errorLogStack = [];
let _startDate;
@@ -142,6 +144,7 @@ function start() {
notificationDaemon = new NotificationDaemon.NotificationDaemon();
windowAttentionHandler = new WindowAttentionHandler.WindowAttentionHandler();
telepathyClient = new TelepathyClient.Client();
+ keyboard = new Keyboard.Keyboard();
layoutManager.init();
overview.init();
diff --git a/js/ui/status/accessibility.js b/js/ui/status/accessibility.js
index 560042c..fb2a2d1 100644
--- a/js/ui/status/accessibility.js
+++ b/js/ui/status/accessibility.js
@@ -40,6 +40,8 @@ const KEY_TEXT_SCALING_FACTOR = 'text-scaling-factor';
const HIGH_CONTRAST_THEME = 'HighContrast';
+const KEYBOARD_SCHEMA = 'org.gnome.shell.keyboard'
+
function ATIndicator() {
this._init.apply(this, arguments);
}
@@ -68,9 +70,9 @@ ATIndicator.prototype = {
// 'screen-reader-enabled');
// this.menu.addMenuItem(screenReader);
-// let screenKeyboard = this._buildItem(_("Screen Keyboard"), APPLICATIONS_SCHEMA,
-// 'screen-keyboard-enabled');
-// this.menu.addMenuItem(screenKeyboard);
+ let screenKeyboard = this._buildItem(_("Screen Keyboard"), KEYBOARD_SCHEMA,
+ 'show-keyboard');
+ this.menu.addMenuItem(screenKeyboard);
let visualBell = this._buildItemGConf(_("Visual Alerts"), client, KEY_VISUAL_BELL);
this.menu.addMenuItem(visualBell);
diff --git a/tools/build/gnome-shell.modules b/tools/build/gnome-shell.modules
index 52867f3..7544fa9 100644
--- a/tools/build/gnome-shell.modules
+++ b/tools/build/gnome-shell.modules
@@ -330,6 +330,7 @@
<dep package="gobject-introspection"/>
<dep package="mutter"/>
<dep package="gjs"/>
+ <dep package="caribou"/>
<dep package="dconf"/>
<dep package="gconf"/>
<dep package="glib"/>
@@ -438,7 +439,7 @@
</dependencies>
</tarball>
- <autotools id="caribou">
+ <autotools id="caribou" autogenargs="--enable-gtk3-im">
<branch repo="git.gnome.org" module="caribou"/>
</autotools>
[
Date Prev][
Date Next] [
Thread Prev][
Thread Next]
[
Thread Index]
[
Date Index]
[
Author Index]
