summaryrefslogtreecommitdiffstats
path: root/js/ui/keyboard.js
diff options
context:
space:
mode:
Diffstat (limited to 'js/ui/keyboard.js')
-rw-r--r--js/ui/keyboard.js1967
1 files changed, 1967 insertions, 0 deletions
diff --git a/js/ui/keyboard.js b/js/ui/keyboard.js
new file mode 100644
index 0000000..e2574f0
--- /dev/null
+++ b/js/ui/keyboard.js
@@ -0,0 +1,1967 @@
+// -*- mode: js; js-indent-level: 4; indent-tabs-mode: nil -*-
+/* exported KeyboardManager */
+
+const { Clutter, Gio, GLib, GObject, Meta, St } = imports.gi;
+const ByteArray = imports.byteArray;
+const Signals = imports.signals;
+
+const InputSourceManager = imports.ui.status.keyboard;
+const IBusManager = imports.misc.ibusManager;
+const BoxPointer = imports.ui.boxpointer;
+const Layout = imports.ui.layout;
+const Main = imports.ui.main;
+const PageIndicators = imports.ui.pageIndicators;
+const PopupMenu = imports.ui.popupMenu;
+
+var KEYBOARD_REST_TIME = Layout.KEYBOARD_ANIMATION_TIME * 2;
+var KEY_LONG_PRESS_TIME = 250;
+var PANEL_SWITCH_ANIMATION_TIME = 500;
+var PANEL_SWITCH_RELATIVE_DISTANCE = 1 / 3; /* A third of the actor width */
+
+const A11Y_APPLICATIONS_SCHEMA = 'org.gnome.desktop.a11y.applications';
+const SHOW_KEYBOARD = 'screen-keyboard-enabled';
+
+/* KeyContainer puts keys in a grid where a 1:1 key takes this size */
+const KEY_SIZE = 2;
+
+const defaultKeysPre = [
+ [[], [], [{ width: 1.5, level: 1, extraClassName: 'shift-key-lowercase', icon: 'keyboard-shift-filled-symbolic' }], [{ label: '?123', width: 1.5, level: 2 }]],
+ [[], [], [{ width: 1.5, level: 0, extraClassName: 'shift-key-uppercase', icon: 'keyboard-shift-filled-symbolic' }], [{ label: '?123', width: 1.5, level: 2 }]],
+ [[], [], [{ label: '=/<', width: 1.5, level: 3 }], [{ label: 'ABC', width: 1.5, level: 0 }]],
+ [[], [], [{ label: '?123', width: 1.5, level: 2 }], [{ label: 'ABC', width: 1.5, level: 0 }]],
+];
+
+const defaultKeysPost = [
+ [[{ width: 1.5, keyval: Clutter.KEY_BackSpace, icon: 'edit-clear-symbolic' }],
+ [{ width: 2, keyval: Clutter.KEY_Return, extraClassName: 'enter-key', icon: 'keyboard-enter-symbolic' }],
+ [{ width: 3, level: 1, right: true, extraClassName: 'shift-key-lowercase', icon: 'keyboard-shift-filled-symbolic' }],
+ [{ action: 'emoji', icon: 'face-smile-symbolic' }, { action: 'languageMenu', extraClassName: 'layout-key', icon: 'keyboard-layout-filled-symbolic' }, { action: 'hide', extraClassName: 'hide-key', icon: 'go-down-symbolic' }]],
+ [[{ width: 1.5, keyval: Clutter.KEY_BackSpace, icon: 'edit-clear-symbolic' }],
+ [{ width: 2, keyval: Clutter.KEY_Return, extraClassName: 'enter-key', icon: 'keyboard-enter-symbolic' }],
+ [{ width: 3, level: 0, right: true, extraClassName: 'shift-key-uppercase', icon: 'keyboard-shift-filled-symbolic' }],
+ [{ action: 'emoji', icon: 'face-smile-symbolic' }, { action: 'languageMenu', extraClassName: 'layout-key', icon: 'keyboard-layout-filled-symbolic' }, { action: 'hide', extraClassName: 'hide-key', icon: 'go-down-symbolic' }]],
+ [[{ width: 1.5, keyval: Clutter.KEY_BackSpace, icon: 'edit-clear-symbolic' }],
+ [{ width: 2, keyval: Clutter.KEY_Return, extraClassName: 'enter-key', icon: 'keyboard-enter-symbolic' }],
+ [{ label: '=/<', width: 3, level: 3, right: true }],
+ [{ action: 'emoji', icon: 'face-smile-symbolic' }, { action: 'languageMenu', extraClassName: 'layout-key', icon: 'keyboard-layout-filled-symbolic' }, { action: 'hide', extraClassName: 'hide-key', icon: 'go-down-symbolic' }]],
+ [[{ width: 1.5, keyval: Clutter.KEY_BackSpace, icon: 'edit-clear-symbolic' }],
+ [{ width: 2, keyval: Clutter.KEY_Return, extraClassName: 'enter-key', icon: 'keyboard-enter-symbolic' }],
+ [{ label: '?123', width: 3, level: 2, right: true }],
+ [{ action: 'emoji', icon: 'face-smile-symbolic' }, { action: 'languageMenu', extraClassName: 'layout-key', icon: 'keyboard-layout-filled-symbolic' }, { action: 'hide', extraClassName: 'hide-key', icon: 'go-down-symbolic' }]],
+];
+
+var AspectContainer = GObject.registerClass(
+class AspectContainer extends St.Widget {
+ _init(params) {
+ super._init(params);
+ this._ratio = 1;
+ }
+
+ setRatio(relWidth, relHeight) {
+ this._ratio = relWidth / relHeight;
+ this.queue_relayout();
+ }
+
+ vfunc_get_preferred_width(forHeight) {
+ let [min, nat] = super.vfunc_get_preferred_width(forHeight);
+
+ if (forHeight > 0)
+ nat = forHeight * this._ratio;
+
+ return [min, nat];
+ }
+
+ vfunc_get_preferred_height(forWidth) {
+ let [min, nat] = super.vfunc_get_preferred_height(forWidth);
+
+ if (forWidth > 0)
+ nat = forWidth / this._ratio;
+
+ return [min, nat];
+ }
+
+ vfunc_allocate(box) {
+ if (box.get_width() > 0 && box.get_height() > 0) {
+ let sizeRatio = box.get_width() / box.get_height();
+
+ if (sizeRatio >= this._ratio) {
+ /* Restrict horizontally */
+ let width = box.get_height() * this._ratio;
+ let diff = box.get_width() - width;
+
+ box.x1 += Math.floor(diff / 2);
+ box.x2 -= Math.ceil(diff / 2);
+ } else {
+ /* Restrict vertically, align to bottom */
+ let height = box.get_width() / this._ratio;
+ box.y1 = box.y2 - Math.floor(height);
+ }
+ }
+
+ super.vfunc_allocate(box);
+ }
+});
+
+var KeyContainer = GObject.registerClass(
+class KeyContainer extends St.Widget {
+ _init() {
+ let gridLayout = new Clutter.GridLayout({ orientation: Clutter.Orientation.HORIZONTAL,
+ column_homogeneous: true,
+ row_homogeneous: true });
+ super._init({
+ layout_manager: gridLayout,
+ x_expand: true,
+ y_expand: true,
+ });
+ this._gridLayout = gridLayout;
+ this._currentRow = 0;
+ this._currentCol = 0;
+ this._maxCols = 0;
+
+ this._currentRow = null;
+ this._rows = [];
+ }
+
+ appendRow() {
+ this._currentRow++;
+ this._currentCol = 0;
+
+ let row = {
+ keys: [],
+ width: 0,
+ };
+ this._rows.push(row);
+ }
+
+ appendKey(key, width = 1, height = 1) {
+ let keyInfo = {
+ key,
+ left: this._currentCol,
+ top: this._currentRow,
+ width,
+ height,
+ };
+
+ let row = this._rows[this._rows.length - 1];
+ row.keys.push(keyInfo);
+ row.width += width;
+
+ this._currentCol += width;
+ this._maxCols = Math.max(this._currentCol, this._maxCols);
+ }
+
+ layoutButtons(container) {
+ let nCol = 0, nRow = 0;
+
+ for (let i = 0; i < this._rows.length; i++) {
+ let row = this._rows[i];
+
+ /* When starting a new row, see if we need some padding */
+ if (nCol == 0) {
+ let diff = this._maxCols - row.width;
+ if (diff >= 1)
+ nCol = diff * KEY_SIZE / 2;
+ else
+ nCol = diff * KEY_SIZE;
+ }
+
+ for (let j = 0; j < row.keys.length; j++) {
+ let keyInfo = row.keys[j];
+ let width = keyInfo.width * KEY_SIZE;
+ let height = keyInfo.height * KEY_SIZE;
+
+ this._gridLayout.attach(keyInfo.key, nCol, nRow, width, height);
+ nCol += width;
+ }
+
+ nRow += KEY_SIZE;
+ nCol = 0;
+ }
+
+ if (container)
+ container.setRatio(this._maxCols, this._rows.length);
+ }
+});
+
+var Suggestions = GObject.registerClass(
+class Suggestions extends St.BoxLayout {
+ _init() {
+ super._init({
+ style_class: 'word-suggestions',
+ vertical: false,
+ x_align: Clutter.ActorAlign.CENTER,
+ });
+ this.show();
+ }
+
+ add(word, callback) {
+ let button = new St.Button({ label: word });
+ button.connect('clicked', callback);
+ this.add_child(button);
+ }
+
+ clear() {
+ this.remove_all_children();
+ }
+});
+
+var LanguageSelectionPopup = class extends PopupMenu.PopupMenu {
+ constructor(actor) {
+ super(actor, 0.5, St.Side.BOTTOM);
+
+ let inputSourceManager = InputSourceManager.getInputSourceManager();
+ let inputSources = inputSourceManager.inputSources;
+
+ let item;
+ for (let i in inputSources) {
+ let is = inputSources[i];
+
+ item = this.addAction(is.displayName, () => {
+ inputSourceManager.activateInputSource(is, true);
+ });
+ item.can_focus = false;
+ }
+
+ this.addMenuItem(new PopupMenu.PopupSeparatorMenuItem());
+ item = this.addSettingsAction(_("Region & Language Settings"), 'gnome-region-panel.desktop');
+ item.can_focus = false;
+
+ this._capturedEventId = 0;
+
+ this._unmapId = actor.connect('notify::mapped', () => {
+ if (!actor.is_mapped())
+ this.close(true);
+ });
+ }
+
+ _onCapturedEvent(actor, event) {
+ if (event.get_source() == this.actor ||
+ this.actor.contains(event.get_source()))
+ return Clutter.EVENT_PROPAGATE;
+
+ if (event.type() == Clutter.EventType.BUTTON_RELEASE || event.type() == Clutter.EventType.TOUCH_END)
+ this.close(true);
+
+ return Clutter.EVENT_STOP;
+ }
+
+ open(animate) {
+ super.open(animate);
+ this._capturedEventId = global.stage.connect('captured-event',
+ this._onCapturedEvent.bind(this));
+ }
+
+ close(animate) {
+ super.close(animate);
+ if (this._capturedEventId != 0) {
+ global.stage.disconnect(this._capturedEventId);
+ this._capturedEventId = 0;
+ }
+ }
+
+ destroy() {
+ if (this._capturedEventId != 0)
+ global.stage.disconnect(this._capturedEventId);
+ if (this._unmapId != 0)
+ this.sourceActor.disconnect(this._unmapId);
+ super.destroy();
+ }
+};
+
+var Key = GObject.registerClass({
+ Signals: {
+ 'activated': {},
+ 'long-press': {},
+ 'pressed': { param_types: [GObject.TYPE_UINT, GObject.TYPE_STRING] },
+ 'released': { param_types: [GObject.TYPE_UINT, GObject.TYPE_STRING] },
+ },
+}, class Key extends St.BoxLayout {
+ _init(key, extendedKeys, icon = null) {
+ super._init({ style_class: 'key-container' });
+
+ this.key = key || "";
+ this.keyButton = this._makeKey(this.key, icon);
+
+ /* Add the key in a container, so keys can be padded without losing
+ * logical proportions between those.
+ */
+ this.add_child(this.keyButton);
+ this.connect('destroy', this._onDestroy.bind(this));
+
+ this._extendedKeys = extendedKeys;
+ this._extendedKeyboard = null;
+ this._pressTimeoutId = 0;
+ this._capturedPress = false;
+
+ this._capturedEventId = 0;
+ this._unmapId = 0;
+ this._longPress = false;
+ }
+
+ _onDestroy() {
+ if (this._boxPointer) {
+ this._boxPointer.destroy();
+ this._boxPointer = null;
+ }
+
+ this.cancel();
+ }
+
+ _ensureExtendedKeysPopup() {
+ if (this._extendedKeys.length === 0)
+ return;
+
+ if (this._boxPointer)
+ return;
+
+ this._boxPointer = new BoxPointer.BoxPointer(St.Side.BOTTOM);
+ this._boxPointer.hide();
+ Main.layoutManager.addTopChrome(this._boxPointer);
+ this._boxPointer.setPosition(this.keyButton, 0.5);
+
+ // Adds style to existing keyboard style to avoid repetition
+ this._boxPointer.add_style_class_name('keyboard-subkeys');
+ this._getExtendedKeys();
+ this.keyButton._extendedKeys = this._extendedKeyboard;
+ }
+
+ _getKeyval(key) {
+ let unicode = key.length ? key.charCodeAt(0) : undefined;
+ return Clutter.unicode_to_keysym(unicode);
+ }
+
+ _press(key) {
+ this.emit('activated');
+
+ if (key !== this.key || this._extendedKeys.length === 0)
+ this.emit('pressed', this._getKeyval(key), key);
+
+ if (key == this.key) {
+ this._pressTimeoutId = GLib.timeout_add(GLib.PRIORITY_DEFAULT,
+ KEY_LONG_PRESS_TIME,
+ () => {
+ this._longPress = true;
+ this._pressTimeoutId = 0;
+
+ this.emit('long-press');
+
+ if (this._extendedKeys.length > 0) {
+ this._touchPressed = false;
+ this._ensureExtendedKeysPopup();
+ this.keyButton.set_hover(false);
+ this.keyButton.fake_release();
+ this._showSubkeys();
+ }
+
+ return GLib.SOURCE_REMOVE;
+ });
+ }
+ }
+
+ _release(key) {
+ if (this._pressTimeoutId != 0) {
+ GLib.source_remove(this._pressTimeoutId);
+ this._pressTimeoutId = 0;
+ }
+
+ if (!this._longPress && key === this.key && this._extendedKeys.length > 0)
+ this.emit('pressed', this._getKeyval(key), key);
+
+ this.emit('released', this._getKeyval(key), key);
+ this._hideSubkeys();
+ this._longPress = false;
+ }
+
+ cancel() {
+ if (this._pressTimeoutId != 0) {
+ GLib.source_remove(this._pressTimeoutId);
+ this._pressTimeoutId = 0;
+ }
+ this._touchPressed = false;
+ this.keyButton.set_hover(false);
+ this.keyButton.fake_release();
+ }
+
+ _onCapturedEvent(actor, event) {
+ let type = event.type();
+ let press = type == Clutter.EventType.BUTTON_PRESS || type == Clutter.EventType.TOUCH_BEGIN;
+ let release = type == Clutter.EventType.BUTTON_RELEASE || type == Clutter.EventType.TOUCH_END;
+
+ if (event.get_source() == this._boxPointer.bin ||
+ this._boxPointer.bin.contains(event.get_source()))
+ return Clutter.EVENT_PROPAGATE;
+
+ if (press)
+ this._capturedPress = true;
+ else if (release && this._capturedPress)
+ this._hideSubkeys();
+
+ return Clutter.EVENT_STOP;
+ }
+
+ _showSubkeys() {
+ this._boxPointer.open(BoxPointer.PopupAnimation.FULL);
+ this._capturedEventId = global.stage.connect('captured-event',
+ this._onCapturedEvent.bind(this));
+ this._unmapId = this.keyButton.connect('notify::mapped', () => {
+ if (!this.keyButton.is_mapped())
+ this._hideSubkeys();
+ });
+ }
+
+ _hideSubkeys() {
+ if (this._boxPointer)
+ this._boxPointer.close(BoxPointer.PopupAnimation.FULL);
+ if (this._capturedEventId) {
+ global.stage.disconnect(this._capturedEventId);
+ this._capturedEventId = 0;
+ }
+ if (this._unmapId) {
+ this.keyButton.disconnect(this._unmapId);
+ this._unmapId = 0;
+ }
+ this._capturedPress = false;
+ }
+
+ _makeKey(key, icon) {
+ let button = new St.Button({
+ style_class: 'keyboard-key',
+ x_expand: true,
+ });
+
+ if (icon) {
+ let child = new St.Icon({ icon_name: icon });
+ button.set_child(child);
+ this._icon = child;
+ } else {
+ let label = GLib.markup_escape_text(key, -1);
+ button.set_label(label);
+ }
+
+ button.keyWidth = 1;
+ button.connect('button-press-event', () => {
+ this._press(key);
+ return Clutter.EVENT_PROPAGATE;
+ });
+ button.connect('button-release-event', () => {
+ this._release(key);
+ return Clutter.EVENT_PROPAGATE;
+ });
+ button.connect('touch-event', (actor, event) => {
+ // We only handle touch events here on wayland. On X11
+ // we do get emulated pointer events, which already works
+ // for single-touch cases. Besides, the X11 passive touch grab
+ // set up by Mutter will make us see first the touch events
+ // and later the pointer events, so it will look like two
+ // unrelated series of events, we want to avoid double handling
+ // in these cases.
+ if (!Meta.is_wayland_compositor())
+ return Clutter.EVENT_PROPAGATE;
+
+ if (!this._touchPressed &&
+ event.type() == Clutter.EventType.TOUCH_BEGIN) {
+ this._touchPressed = true;
+ this._press(key);
+ } else if (this._touchPressed &&
+ event.type() == Clutter.EventType.TOUCH_END) {
+ this._touchPressed = false;
+ this._release(key);
+ }
+ return Clutter.EVENT_PROPAGATE;
+ });
+
+ return button;
+ }
+
+ _getExtendedKeys() {
+ this._extendedKeyboard = new St.BoxLayout({
+ style_class: 'key-container',
+ vertical: false,
+ });
+ for (let i = 0; i < this._extendedKeys.length; ++i) {
+ let extendedKey = this._extendedKeys[i];
+ let key = this._makeKey(extendedKey);
+
+ key.extendedKey = extendedKey;
+ this._extendedKeyboard.add(key);
+
+ key.set_size(...this.keyButton.allocation.get_size());
+ this.keyButton.connect('notify::allocation',
+ () => key.set_size(...this.keyButton.allocation.get_size()));
+ }
+ this._boxPointer.bin.add_actor(this._extendedKeyboard);
+ }
+
+ get subkeys() {
+ return this._boxPointer;
+ }
+
+ setWidth(width) {
+ this.keyButton.keyWidth = width;
+ }
+
+ setLatched(latched) {
+ if (!this._icon)
+ return;
+
+ if (latched) {
+ this.keyButton.add_style_pseudo_class('latched');
+ this._icon.icon_name = 'keyboard-caps-lock-filled-symbolic';
+ } else {
+ this.keyButton.remove_style_pseudo_class('latched');
+ this._icon.icon_name = 'keyboard-shift-filled-symbolic';
+ }
+ }
+});
+
+var KeyboardModel = class {
+ constructor(groupName) {
+ let names = [groupName];
+ if (groupName.includes('+'))
+ names.push(groupName.replace(/\+.*/, ''));
+ names.push('us');
+
+ for (let i = 0; i < names.length; i++) {
+ try {
+ this._model = this._loadModel(names[i]);
+ break;
+ } catch (e) {
+ }
+ }
+ }
+
+ _loadModel(groupName) {
+ let file = Gio.File.new_for_uri('resource:///org/gnome/shell/osk-layouts/%s.json'.format(groupName));
+ let [success_, contents] = file.load_contents(null);
+ contents = ByteArray.toString(contents);
+
+ return JSON.parse(contents);
+ }
+
+ getLevels() {
+ return this._model.levels;
+ }
+
+ getKeysForLevel(levelName) {
+ return this._model.levels.find(level => level == levelName);
+ }
+};
+
+var FocusTracker = class {
+ constructor() {
+ this._currentWindow = null;
+ this._rect = null;
+
+ global.display.connect('notify::focus-window', () => {
+ this._setCurrentWindow(global.display.focus_window);
+ this.emit('window-changed', this._currentWindow);
+ });
+
+ global.display.connect('grab-op-begin', (display, window, op) => {
+ if (window == this._currentWindow &&
+ (op == Meta.GrabOp.MOVING || op == Meta.GrabOp.KEYBOARD_MOVING))
+ this.emit('reset');
+ });
+
+ /* Valid for wayland clients */
+ Main.inputMethod.connect('cursor-location-changed', (o, rect) => {
+ let newRect = { x: rect.get_x(), y: rect.get_y(), width: rect.get_width(), height: rect.get_height() };
+ this._setCurrentRect(newRect);
+ });
+
+ this._ibusManager = IBusManager.getIBusManager();
+ this._ibusManager.connect('set-cursor-location', (manager, rect) => {
+ /* Valid for X11 clients only */
+ if (Main.inputMethod.currentFocus)
+ return;
+
+ this._setCurrentRect(rect);
+ });
+ this._ibusManager.connect('focus-in', () => {
+ this.emit('focus-changed', true);
+ });
+ this._ibusManager.connect('focus-out', () => {
+ this.emit('focus-changed', false);
+ });
+ }
+
+ get currentWindow() {
+ return this._currentWindow;
+ }
+
+ _setCurrentWindow(window) {
+ this._currentWindow = window;
+ }
+
+ _setCurrentRect(rect) {
+ if (this._currentWindow) {
+ let frameRect = this._currentWindow.get_frame_rect();
+ rect.x -= frameRect.x;
+ rect.y -= frameRect.y;
+ }
+
+ if (this._rect &&
+ this._rect.x == rect.x &&
+ this._rect.y == rect.y &&
+ this._rect.width == rect.width &&
+ this._rect.height == rect.height)
+ return;
+
+ this._rect = rect;
+ this.emit('position-changed');
+ }
+
+ getCurrentRect() {
+ let rect = { x: this._rect.x, y: this._rect.y,
+ width: this._rect.width, height: this._rect.height };
+
+ if (this._currentWindow) {
+ let frameRect = this._currentWindow.get_frame_rect();
+ rect.x += frameRect.x;
+ rect.y += frameRect.y;
+ }
+
+ return rect;
+ }
+};
+Signals.addSignalMethods(FocusTracker.prototype);
+
+var EmojiPager = GObject.registerClass({
+ Properties: {
+ 'delta': GObject.ParamSpec.int(
+ 'delta', 'delta', 'delta',
+ GObject.ParamFlags.READWRITE,
+ GLib.MININT32, GLib.MAXINT32, 0),
+ },
+ Signals: {
+ 'emoji': { param_types: [GObject.TYPE_STRING] },
+ 'page-changed': {
+ param_types: [GObject.TYPE_INT, GObject.TYPE_INT, GObject.TYPE_INT],
+ },
+ },
+}, class EmojiPager extends St.Widget {
+ _init(sections, nCols, nRows) {
+ super._init({
+ layout_manager: new Clutter.BinLayout(),
+ reactive: true,
+ clip_to_allocation: true,
+ y_expand: true,
+ });
+ this._sections = sections;
+ this._nCols = nCols;
+ this._nRows = nRows;
+
+ this._pages = [];
+ this._panel = null;
+ this._curPage = null;
+ this._followingPage = null;
+ this._followingPanel = null;
+ this._currentKey = null;
+ this._delta = 0;
+ this._width = null;
+
+ this._initPagingInfo();
+
+ let panAction = new Clutter.PanAction({ interpolate: false });
+ panAction.connect('pan', this._onPan.bind(this));
+ panAction.connect('gesture-begin', this._onPanBegin.bind(this));
+ panAction.connect('gesture-cancel', this._onPanCancel.bind(this));
+ panAction.connect('gesture-end', this._onPanEnd.bind(this));
+ this._panAction = panAction;
+ this.add_action(panAction);
+ }
+
+ get delta() {
+ return this._delta;
+ }
+
+ set delta(value) {
+ if (value > this._width)
+ value = this._width;
+ else if (value < -this._width)
+ value = -this._width;
+
+ if (this._delta == value)
+ return;
+
+ this._delta = value;
+ this.notify('delta');
+
+ if (value == 0)
+ return;
+
+ let relValue = Math.abs(value / this._width);
+ let followingPage = this.getFollowingPage();
+
+ if (this._followingPage != followingPage) {
+ if (this._followingPanel) {
+ this._followingPanel.destroy();
+ this._followingPanel = null;
+ }
+
+ if (followingPage != null) {
+ this._followingPanel = this._generatePanel(followingPage);
+ this._followingPanel.set_pivot_point(0.5, 0.5);
+ this.add_child(this._followingPanel);
+ this.set_child_below_sibling(this._followingPanel, this._panel);
+ }
+
+ this._followingPage = followingPage;
+ }
+
+ this._panel.translation_x = value;
+ this._panel.opacity = 255 * (1 - Math.pow(relValue, 3));
+
+ if (this._followingPanel) {
+ this._followingPanel.scale_x = 0.8 + (0.2 * relValue);
+ this._followingPanel.scale_y = 0.8 + (0.2 * relValue);
+ this._followingPanel.opacity = 255 * relValue;
+ }
+ }
+
+ _prevPage(nPage) {
+ return (nPage + this._pages.length - 1) % this._pages.length;
+ }
+
+ _nextPage(nPage) {
+ return (nPage + 1) % this._pages.length;
+ }
+
+ getFollowingPage() {
+ if (this.delta == 0)
+ return null;
+
+ if ((this.delta < 0 && global.stage.text_direction == Clutter.TextDirection.LTR) ||
+ (this.delta > 0 && global.stage.text_direction == Clutter.TextDirection.RTL))
+ return this._nextPage(this._curPage);
+ else
+ return this._prevPage(this._curPage);
+ }
+
+ _onPan(action) {
+ let [dist_, dx, dy_] = action.get_motion_delta(0);
+ this.delta += dx;
+
+ if (this._currentKey != null) {
+ this._currentKey.cancel();
+ this._currentKey = null;
+ }
+
+ return false;
+ }
+
+ _onPanBegin() {
+ this._width = this.width;
+ return true;
+ }
+
+ _onPanEnd() {
+ if (Math.abs(this._delta) < this.width * PANEL_SWITCH_RELATIVE_DISTANCE) {
+ this._onPanCancel();
+ } else {
+ let value;
+ if (this._delta > 0)
+ value = this._width;
+ else if (this._delta < 0)
+ value = -this._width;
+
+ let relDelta = Math.abs(this._delta - value) / this._width;
+ let time = PANEL_SWITCH_ANIMATION_TIME * Math.abs(relDelta);
+
+ this.remove_all_transitions();
+ this.ease_property('delta', value, {
+ duration: time,
+ onComplete: () => {
+ this.setCurrentPage(this.getFollowingPage());
+ },
+ });
+ }
+ }
+
+ _onPanCancel() {
+ let relDelta = Math.abs(this._delta) / this.width;
+ let time = PANEL_SWITCH_ANIMATION_TIME * Math.abs(relDelta);
+
+ this.remove_all_transitions();
+ this.ease_property('delta', 0, {
+ duration: time,
+ });
+ }
+
+ _initPagingInfo() {
+ for (let i = 0; i < this._sections.length; i++) {
+ let section = this._sections[i];
+ let itemsPerPage = this._nCols * this._nRows;
+ let nPages = Math.ceil(section.keys.length / itemsPerPage);
+ let page = -1;
+ let pageKeys;
+
+ for (let j = 0; j < section.keys.length; j++) {
+ if (j % itemsPerPage == 0) {
+ page++;
+ pageKeys = [];
+ this._pages.push({ pageKeys, nPages, page, section: this._sections[i] });
+ }
+
+ pageKeys.push(section.keys[j]);
+ }
+ }
+ }
+
+ _lookupSection(section, nPage) {
+ for (let i = 0; i < this._pages.length; i++) {
+ let page = this._pages[i];
+
+ if (page.section == section && page.page == nPage)
+ return i;
+ }
+
+ return -1;
+ }
+
+ _generatePanel(nPage) {
+ let gridLayout = new Clutter.GridLayout({ orientation: Clutter.Orientation.HORIZONTAL,
+ column_homogeneous: true,
+ row_homogeneous: true });
+ let panel = new St.Widget({ layout_manager: gridLayout,
+ style_class: 'emoji-page',
+ x_expand: true,
+ y_expand: true });
+
+ /* Set an expander actor so all proportions are right despite the panel
+ * not having all rows/cols filled in.
+ */
+ let expander = new Clutter.Actor();
+ gridLayout.attach(expander, 0, 0, this._nCols, this._nRows);
+
+ let page = this._pages[nPage];
+ let col = 0;
+ let row = 0;
+
+ for (let i = 0; i < page.pageKeys.length; i++) {
+ let modelKey = page.pageKeys[i];
+ let key = new Key(modelKey.label, modelKey.variants);
+
+ key.keyButton.set_button_mask(0);
+
+ key.connect('activated', () => {
+ this._currentKey = key;
+ });
+ key.connect('long-press', () => {
+ this._panAction.cancel();
+ });
+ key.connect('released', (actor, keyval, str) => {
+ if (this._currentKey != key)
+ return;
+ this._currentKey = null;
+ this.emit('emoji', str);
+ });
+
+ gridLayout.attach(key, col, row, 1, 1);
+
+ col++;
+ if (col >= this._nCols) {
+ col = 0;
+ row++;
+ }
+ }
+
+ return panel;
+ }
+
+ setCurrentPage(nPage) {
+ if (this._curPage == nPage)
+ return;
+
+ this._curPage = nPage;
+
+ if (this._panel) {
+ this._panel.destroy();
+ this._panel = null;
+ }
+
+ /* Reuse followingPage if possible */
+ if (nPage == this._followingPage) {
+ this._panel = this._followingPanel;
+ this._followingPanel = null;
+ }
+
+ if (this._followingPanel)
+ this._followingPanel.destroy();
+
+ this._followingPanel = null;
+ this._followingPage = null;
+ this._delta = 0;
+
+ if (!this._panel) {
+ this._panel = this._generatePanel(nPage);
+ this.add_child(this._panel);
+ }
+
+ let page = this._pages[nPage];
+ this.emit('page-changed', page.section.label, page.page, page.nPages);
+ }
+
+ setCurrentSection(section, nPage) {
+ for (let i = 0; i < this._pages.length; i++) {
+ let page = this._pages[i];
+
+ if (page.section == section && page.page == nPage) {
+ this.setCurrentPage(i);
+ break;
+ }
+ }
+ }
+});
+
+var EmojiSelection = GObject.registerClass({
+ Signals: {
+ 'emoji-selected': { param_types: [GObject.TYPE_STRING] },
+ 'close-request': {},
+ 'toggle': {},
+ },
+}, class EmojiSelection extends St.BoxLayout {
+ _init() {
+ super._init({
+ style_class: 'emoji-panel',
+ x_expand: true,
+ y_expand: true,
+ vertical: true,
+ });
+
+ this._sections = [
+ { first: 'grinning face', label: '🙂ī¸' },
+ { first: 'selfie', label: '👍ī¸' },
+ { first: 'monkey face', label: '🌷ī¸' },
+ { first: 'grapes', label: '🍴ī¸' },
+ { first: 'globe showing Europe-Africa', label: '✈ī¸' },
+ { first: 'jack-o-lantern', label: '🏃ī¸' },
+ { first: 'muted speaker', label: '🔔ī¸' },
+ { first: 'ATM sign', label: '❤ī¸' },
+ { first: 'chequered flag', label: '🚩ī¸' },
+ ];
+
+ this._populateSections();
+
+ this._emojiPager = new EmojiPager(this._sections, 11, 3);
+ this._emojiPager.connect('page-changed', (pager, sectionLabel, page, nPages) => {
+ this._onPageChanged(sectionLabel, page, nPages);
+ });
+ this._emojiPager.connect('emoji', (pager, str) => {
+ this.emit('emoji-selected', str);
+ });
+ this.add_child(this._emojiPager);
+
+ this._pageIndicator = new PageIndicators.PageIndicators(
+ Clutter.Orientation.HORIZONTAL);
+ this.add_child(this._pageIndicator);
+ this._pageIndicator.setReactive(false);
+
+ this._emojiPager.connect('notify::delta', () => {
+ this._updateIndicatorPosition();
+ });
+
+ let bottomRow = this._createBottomRow();
+ this.add_child(bottomRow);
+
+ this._curPage = 0;
+ }
+
+ vfunc_map() {
+ this._emojiPager.setCurrentPage(0);
+ super.vfunc_map();
+ }
+
+ _onPageChanged(sectionLabel, page, nPages) {
+ this._curPage = page;
+ this._pageIndicator.setNPages(nPages);
+ this._updateIndicatorPosition();
+
+ for (let i = 0; i < this._sections.length; i++) {
+ let sect = this._sections[i];
+ sect.button.setLatched(sectionLabel == sect.label);
+ }
+ }
+
+ _updateIndicatorPosition() {
+ this._pageIndicator.setCurrentPosition(this._curPage -
+ this._emojiPager.delta / this._emojiPager.width);
+ }
+
+ _findSection(emoji) {
+ for (let i = 0; i < this._sections.length; i++) {
+ if (this._sections[i].first == emoji)
+ return this._sections[i];
+ }
+
+ return null;
+ }
+
+ _populateSections() {
+ let file = Gio.File.new_for_uri('resource:///org/gnome/shell/osk-layouts/emoji.json');
+ let [success_, contents] = file.load_contents(null);
+
+ if (contents instanceof Uint8Array)
+ contents = imports.byteArray.toString(contents);
+ let emoji = JSON.parse(contents);
+
+ let variants = [];
+ let currentKey = 0;
+ let currentSection = null;
+
+ for (let i = 0; i < emoji.length; i++) {
+ /* Group variants of a same emoji so they appear on the key popover */
+ if (emoji[i].name.startsWith(emoji[currentKey].name)) {
+ variants.push(emoji[i].char);
+ if (i < emoji.length - 1)
+ continue;
+ }
+
+ let newSection = this._findSection(emoji[currentKey].name);
+ if (newSection != null) {
+ currentSection = newSection;
+ currentSection.keys = [];
+ }
+
+ /* Create the key */
+ let label = emoji[currentKey].char + String.fromCharCode(0xFE0F);
+ currentSection.keys.push({ label, variants });
+ currentKey = i;
+ variants = [];
+ }
+ }
+
+ _createBottomRow() {
+ let row = new KeyContainer();
+ let key;
+
+ row.appendRow();
+
+ key = new Key('ABC', []);
+ key.keyButton.add_style_class_name('default-key');
+ key.connect('released', () => this.emit('toggle'));
+ row.appendKey(key, 1.5);
+
+ for (let i = 0; i < this._sections.length; i++) {
+ let section = this._sections[i];
+
+ key = new Key(section.label, []);
+ key.connect('released', () => this._emojiPager.setCurrentSection(section, 0));
+ row.appendKey(key);
+
+ section.button = key;
+ }
+
+ key = new Key(null, [], 'go-down-symbolic');
+ key.keyButton.add_style_class_name('default-key');
+ key.keyButton.add_style_class_name('hide-key');
+ key.connect('released', () => {
+ this.emit('close-request');
+ });
+ row.appendKey(key);
+ row.layoutButtons();
+
+ let actor = new AspectContainer({ layout_manager: new Clutter.BinLayout(),
+ x_expand: true, y_expand: true });
+ actor.add_child(row);
+ /* Regular keyboard layouts are 11.5×4 grids, optimize for that
+ * at the moment. Ideally this should be as wide as the current
+ * keymap.
+ */
+ actor.setRatio(11.5, 1);
+
+ return actor;
+ }
+});
+
+var Keypad = GObject.registerClass({
+ Signals: {
+ 'keyval': { param_types: [GObject.TYPE_UINT] },
+ },
+}, class Keypad extends AspectContainer {
+ _init() {
+ let keys = [
+ { label: '1', keyval: Clutter.KEY_1, left: 0, top: 0 },
+ { label: '2', keyval: Clutter.KEY_2, left: 1, top: 0 },
+ { label: '3', keyval: Clutter.KEY_3, left: 2, top: 0 },
+ { label: '4', keyval: Clutter.KEY_4, left: 0, top: 1 },
+ { label: '5', keyval: Clutter.KEY_5, left: 1, top: 1 },
+ { label: '6', keyval: Clutter.KEY_6, left: 2, top: 1 },
+ { label: '7', keyval: Clutter.KEY_7, left: 0, top: 2 },
+ { label: '8', keyval: Clutter.KEY_8, left: 1, top: 2 },
+ { label: '9', keyval: Clutter.KEY_9, left: 2, top: 2 },
+ { label: '0', keyval: Clutter.KEY_0, left: 1, top: 3 },
+ { keyval: Clutter.KEY_BackSpace, icon: 'edit-clear-symbolic', left: 3, top: 0 },
+ { keyval: Clutter.KEY_Return, extraClassName: 'enter-key', icon: 'keyboard-enter-symbolic', left: 3, top: 1, height: 2 },
+ ];
+
+ super._init({
+ layout_manager: new Clutter.BinLayout(),
+ x_expand: true,
+ y_expand: true,
+ });
+
+ let gridLayout = new Clutter.GridLayout({ orientation: Clutter.Orientation.HORIZONTAL,
+ column_homogeneous: true,
+ row_homogeneous: true });
+ this._box = new St.Widget({ layout_manager: gridLayout, x_expand: true, y_expand: true });
+ this.add_child(this._box);
+
+ for (let i = 0; i < keys.length; i++) {
+ let cur = keys[i];
+ let key = new Key(cur.label || "", [], cur.icon);
+
+ if (keys[i].extraClassName)
+ key.keyButton.add_style_class_name(cur.extraClassName);
+
+ let w, h;
+ w = cur.width || 1;
+ h = cur.height || 1;
+ gridLayout.attach(key, cur.left, cur.top, w, h);
+
+ key.connect('released', () => {
+ this.emit('keyval', cur.keyval);
+ });
+ }
+ }
+});
+
+var KeyboardManager = class KeyBoardManager {
+ constructor() {
+ this._keyboard = null;
+ this._a11yApplicationsSettings = new Gio.Settings({ schema_id: A11Y_APPLICATIONS_SCHEMA });
+ this._a11yApplicationsSettings.connect('changed', this._syncEnabled.bind(this));
+
+ this._seat = Clutter.get_default_backend().get_default_seat();
+ this._seat.connect('notify::touch-mode', this._syncEnabled.bind(this));
+
+ this._lastDevice = null;
+ global.backend.connect('last-device-changed', (backend, device) => {
+ if (device.device_type === Clutter.InputDeviceType.KEYBOARD_DEVICE)
+ return;
+
+ this._lastDevice = device;
+ this._syncEnabled();
+ });
+ this._syncEnabled();
+ }
+
+ _lastDeviceIsTouchscreen() {
+ if (!this._lastDevice)
+ return false;
+
+ let deviceType = this._lastDevice.get_device_type();
+ return deviceType == Clutter.InputDeviceType.TOUCHSCREEN_DEVICE;
+ }
+
+ _syncEnabled() {
+ let enableKeyboard = this._a11yApplicationsSettings.get_boolean(SHOW_KEYBOARD);
+ let autoEnabled = this._seat.get_touch_mode() && this._lastDeviceIsTouchscreen();
+ let enabled = enableKeyboard || autoEnabled;
+
+ if (!enabled && !this._keyboard)
+ return;
+
+ if (enabled && !this._keyboard) {
+ this._keyboard = new Keyboard();
+ } else if (!enabled && this._keyboard) {
+ this._keyboard.setCursorLocation(null);
+ this._keyboard.destroy();
+ this._keyboard = null;
+ Main.layoutManager.hideKeyboard(true);
+ }
+ }
+
+ get keyboardActor() {
+ return this._keyboard;
+ }
+
+ get visible() {
+ return this._keyboard && this._keyboard.visible;
+ }
+
+ open(monitor) {
+ if (this._keyboard)
+ this._keyboard.open(monitor);
+ }
+
+ close() {
+ if (this._keyboard)
+ this._keyboard.close();
+ }
+
+ addSuggestion(text, callback) {
+ if (this._keyboard)
+ this._keyboard.addSuggestion(text, callback);
+ }
+
+ resetSuggestions() {
+ if (this._keyboard)
+ this._keyboard.resetSuggestions();
+ }
+
+ shouldTakeEvent(event) {
+ if (!this._keyboard)
+ return false;
+
+ let actor = event.get_source();
+ return Main.layoutManager.keyboardBox.contains(actor) ||
+ !!actor._extendedKeys || !!actor.extendedKey;
+ }
+};
+
+var Keyboard = GObject.registerClass(
+class Keyboard extends St.BoxLayout {
+ _init() {
+ super._init({ name: 'keyboard', vertical: true });
+ this._focusInExtendedKeys = false;
+ this._emojiActive = false;
+
+ this._languagePopup = null;
+ this._currentFocusWindow = null;
+ this._animFocusedWindow = null;
+ this._delayedAnimFocusWindow = null;
+
+ this._latched = false; // current level is latched
+
+ this._suggestions = null;
+ this._emojiKeyVisible = Meta.is_wayland_compositor();
+
+ this._focusTracker = new FocusTracker();
+ this._connectSignal(this._focusTracker, 'position-changed',
+ this._onFocusPositionChanged.bind(this));
+ this._connectSignal(this._focusTracker, 'reset', () => {
+ this._delayedAnimFocusWindow = null;
+ this._animFocusedWindow = null;
+ this._oskFocusWindow = null;
+ });
+ // Valid only for X11
+ if (!Meta.is_wayland_compositor()) {
+ this._connectSignal(this._focusTracker, 'focus-changed', (_tracker, focused) => {
+ if (focused)
+ this.open(Main.layoutManager.focusIndex);
+ else
+ this.close();
+ });
+ }
+
+ this._showIdleId = 0;
+
+ this._keyboardVisible = false;
+ this._connectSignal(Main.layoutManager, 'keyboard-visible-changed', (_lm, visible) => {
+ this._keyboardVisible = visible;
+ });
+ this._keyboardRequested = false;
+ this._keyboardRestingId = 0;
+
+ this._connectSignal(Main.layoutManager, 'monitors-changed', this._relayout.bind(this));
+
+ this._setupKeyboard();
+
+ this.connect('destroy', this._onDestroy.bind(this));
+ }
+
+ _connectSignal(obj, signal, callback) {
+ if (!this._connectionsIDs)
+ this._connectionsIDs = [];
+
+ let id = obj.connect(signal, callback);
+ this._connectionsIDs.push([obj, id]);
+ return id;
+ }
+
+ get visible() {
+ return this._keyboardVisible && super.visible;
+ }
+
+ set visible(visible) {
+ super.visible = visible;
+ }
+
+ _onFocusPositionChanged(focusTracker) {
+ let rect = focusTracker.getCurrentRect();
+ this.setCursorLocation(focusTracker.currentWindow, rect.x, rect.y, rect.width, rect.height);
+ }
+
+ _onDestroy() {
+ for (let [obj, id] of this._connectionsIDs)
+ obj.disconnect(id);
+ delete this._connectionsIDs;
+
+ this._clearShowIdle();
+
+ this._keyboardController.destroy();
+
+ Main.layoutManager.untrackChrome(this);
+ Main.layoutManager.keyboardBox.remove_actor(this);
+
+ if (this._languagePopup) {
+ this._languagePopup.destroy();
+ this._languagePopup = null;
+ }
+ }
+
+ _setupKeyboard() {
+ Main.layoutManager.keyboardBox.add_actor(this);
+ Main.layoutManager.trackChrome(this);
+
+ this._keyboardController = new KeyboardController();
+
+ this._groups = {};
+ this._currentPage = null;
+
+ this._suggestions = new Suggestions();
+ this.add_child(this._suggestions);
+
+ this._aspectContainer = new AspectContainer({
+ layout_manager: new Clutter.BinLayout(),
+ y_expand: true,
+ });
+ this.add_child(this._aspectContainer);
+
+ this._emojiSelection = new EmojiSelection();
+ this._emojiSelection.connect('toggle', this._toggleEmoji.bind(this));
+ this._emojiSelection.connect('close-request', () => this.close());
+ this._emojiSelection.connect('emoji-selected', (selection, emoji) => {
+ this._keyboardController.commitString(emoji);
+ });
+
+ this._aspectContainer.add_child(this._emojiSelection);
+ this._emojiSelection.hide();
+
+ this._keypad = new Keypad();
+ this._connectSignal(this._keypad, 'keyval', (_keypad, keyval) => {
+ this._keyboardController.keyvalPress(keyval);
+ this._keyboardController.keyvalRelease(keyval);
+ });
+ this._aspectContainer.add_child(this._keypad);
+ this._keypad.hide();
+ this._keypadVisible = false;
+
+ this._ensureKeysForGroup(this._keyboardController.getCurrentGroup());
+ this._setActiveLayer(0);
+
+ // Keyboard models are defined in LTR, we must override
+ // the locale setting in order to avoid flipping the
+ // keyboard on RTL locales.
+ this.text_direction = Clutter.TextDirection.LTR;
+
+ this._connectSignal(this._keyboardController, 'active-group',
+ this._onGroupChanged.bind(this));
+ this._connectSignal(this._keyboardController, 'groups-changed',
+ this._onKeyboardGroupsChanged.bind(this));
+ this._connectSignal(this._keyboardController, 'panel-state',
+ this._onKeyboardStateChanged.bind(this));
+ this._connectSignal(this._keyboardController, 'keypad-visible',
+ this._onKeypadVisible.bind(this));
+ this._connectSignal(global.stage, 'notify::key-focus',
+ this._onKeyFocusChanged.bind(this));
+
+ if (Meta.is_wayland_compositor()) {
+ this._connectSignal(this._keyboardController, 'emoji-visible',
+ this._onEmojiKeyVisible.bind(this));
+ }
+
+ this._relayout();
+ }
+
+ _onKeyFocusChanged() {
+ let focus = global.stage.key_focus;
+
+ // Showing an extended key popup and clicking a key from the extended keys
+ // will grab focus, but ignore that
+ let extendedKeysWereFocused = this._focusInExtendedKeys;
+ this._focusInExtendedKeys = focus && (focus._extendedKeys || focus.extendedKey);
+ if (this._focusInExtendedKeys || extendedKeysWereFocused)
+ return;
+
+ if (!(focus instanceof Clutter.Text)) {
+ this.close();
+ return;
+ }
+
+ if (!this._showIdleId) {
+ this._showIdleId = GLib.idle_add(GLib.PRIORITY_DEFAULT_IDLE, () => {
+ this.open(Main.layoutManager.focusIndex);
+ this._showIdleId = 0;
+ return GLib.SOURCE_REMOVE;
+ });
+ GLib.Source.set_name_by_id(this._showIdleId, '[gnome-shell] this.open');
+ }
+ }
+
+ _createLayersForGroup(groupName) {
+ let keyboardModel = new KeyboardModel(groupName);
+ let layers = {};
+ let levels = keyboardModel.getLevels();
+ for (let i = 0; i < levels.length; i++) {
+ let currentLevel = levels[i];
+ /* There are keyboard maps which consist of 3 levels (no uppercase,
+ * basically). We however make things consistent by skipping that
+ * second level.
+ */
+ let level = i >= 1 && levels.length == 3 ? i + 1 : i;
+
+ let layout = new KeyContainer();
+ layout.shiftKeys = [];
+
+ this._loadRows(currentLevel, level, levels.length, layout);
+ layers[level] = layout;
+ this._aspectContainer.add_child(layout);
+ layout.layoutButtons(this._aspectContainer);
+
+ layout.hide();
+ }
+
+ return layers;
+ }
+
+ _ensureKeysForGroup(group) {
+ if (!this._groups[group])
+ this._groups[group] = this._createLayersForGroup(group);
+ }
+
+ _addRowKeys(keys, layout) {
+ for (let i = 0; i < keys.length; ++i) {
+ let key = keys[i];
+ let button = new Key(key.shift(), key);
+
+ /* Space key gets special width, dependent on the number of surrounding keys */
+ if (button.key == ' ')
+ button.setWidth(keys.length <= 3 ? 5 : 3);
+
+ button.connect('pressed', (actor, keyval, str) => {
+ if (!Main.inputMethod.currentFocus ||
+ !this._keyboardController.commitString(str, true)) {
+ if (keyval != 0) {
+ this._keyboardController.keyvalPress(keyval);
+ button._keyvalPress = true;
+ }
+ }
+ });
+ button.connect('released', (actor, keyval, _str) => {
+ if (keyval != 0) {
+ if (button._keyvalPress)
+ this._keyboardController.keyvalRelease(keyval);
+ button._keyvalPress = false;
+ }
+
+ if (!this._latched)
+ this._setActiveLayer(0);
+ });
+
+ layout.appendKey(button, button.keyButton.keyWidth);
+ }
+ }
+
+ _popupLanguageMenu(keyActor) {
+ if (this._languagePopup)
+ this._languagePopup.destroy();
+
+ this._languagePopup = new LanguageSelectionPopup(keyActor);
+ Main.layoutManager.addTopChrome(this._languagePopup.actor);
+ this._languagePopup.open(true);
+ }
+
+ _loadDefaultKeys(keys, layout, numLevels, numKeys) {
+ let extraButton;
+ for (let i = 0; i < keys.length; i++) {
+ let key = keys[i];
+ let keyval = key.keyval;
+ let switchToLevel = key.level;
+ let action = key.action;
+ let icon = key.icon;
+
+ /* Skip emoji button if necessary */
+ if (!this._emojiKeyVisible && action == 'emoji')
+ continue;
+
+ extraButton = new Key(key.label || '', [], icon);
+
+ extraButton.keyButton.add_style_class_name('default-key');
+ if (key.extraClassName != null)
+ extraButton.keyButton.add_style_class_name(key.extraClassName);
+ if (key.width != null)
+ extraButton.setWidth(key.width);
+
+ let actor = extraButton.keyButton;
+
+ extraButton.connect('pressed', () => {
+ if (switchToLevel != null) {
+ this._setActiveLayer(switchToLevel);
+ // Shift only gets latched on long press
+ this._latched = switchToLevel != 1;
+ } else if (keyval != null) {
+ this._keyboardController.keyvalPress(keyval);
+ }
+ });
+ extraButton.connect('released', () => {
+ if (keyval != null)
+ this._keyboardController.keyvalRelease(keyval);
+ else if (action == 'hide')
+ this.close();
+ else if (action == 'languageMenu')
+ this._popupLanguageMenu(actor);
+ else if (action == 'emoji')
+ this._toggleEmoji();
+ });
+
+ if (switchToLevel == 0) {
+ layout.shiftKeys.push(extraButton);
+ } else if (switchToLevel == 1) {
+ extraButton.connect('long-press', () => {
+ this._latched = true;
+ this._setCurrentLevelLatched(this._currentPage, this._latched);
+ });
+ }
+
+ /* Fixup default keys based on the number of levels/keys */
+ if (switchToLevel == 1 && numLevels == 3) {
+ // Hide shift key if the keymap has no uppercase level
+ if (key.right) {
+ /* Only hide the key actor, so the container still takes space */
+ extraButton.keyButton.hide();
+ } else {
+ extraButton.hide();
+ }
+ extraButton.setWidth(1.5);
+ } else if (key.right && numKeys > 8) {
+ extraButton.setWidth(2);
+ } else if (keyval == Clutter.KEY_Return && numKeys > 9) {
+ extraButton.setWidth(1.5);
+ } else if (!this._emojiKeyVisible && (action == 'hide' || action == 'languageMenu')) {
+ extraButton.setWidth(1.5);
+ }
+
+ layout.appendKey(extraButton, extraButton.keyButton.keyWidth);
+ }
+ }
+
+ _updateCurrentPageVisible() {
+ if (this._currentPage)
+ this._currentPage.visible = !this._emojiActive && !this._keypadVisible;
+ }
+
+ _setEmojiActive(active) {
+ this._emojiActive = active;
+ this._emojiSelection.visible = this._emojiActive;
+ this._updateCurrentPageVisible();
+ }
+
+ _toggleEmoji() {
+ this._setEmojiActive(!this._emojiActive);
+ }
+
+ _setCurrentLevelLatched(layout, latched) {
+ for (let i = 0; i < layout.shiftKeys.length; i++) {
+ let key = layout.shiftKeys[i];
+ key.setLatched(latched);
+ }
+ }
+
+ _getDefaultKeysForRow(row, numRows, level) {
+ /* The first 2 rows in defaultKeysPre/Post belong together with
+ * the first 2 rows on each keymap. On keymaps that have more than
+ * 4 rows, the last 2 default key rows must be respectively
+ * assigned to the 2 last keymap ones.
+ */
+ if (row < 2) {
+ return [defaultKeysPre[level][row], defaultKeysPost[level][row]];
+ } else if (row >= numRows - 2) {
+ let defaultRow = row - (numRows - 2) + 2;
+ return [defaultKeysPre[level][defaultRow], defaultKeysPost[level][defaultRow]];
+ } else {
+ return [null, null];
+ }
+ }
+
+ _mergeRowKeys(layout, pre, row, post, numLevels) {
+ if (pre != null)
+ this._loadDefaultKeys(pre, layout, numLevels, row.length);
+
+ this._addRowKeys(row, layout);
+
+ if (post != null)
+ this._loadDefaultKeys(post, layout, numLevels, row.length);
+ }
+
+ _loadRows(model, level, numLevels, layout) {
+ let rows = model.rows;
+ for (let i = 0; i < rows.length; ++i) {
+ layout.appendRow();
+ let [pre, post] = this._getDefaultKeysForRow(i, rows.length, level);
+ this._mergeRowKeys(layout, pre, rows[i], post, numLevels);
+ }
+ }
+
+ _getGridSlots() {
+ let numOfHorizSlots = 0, numOfVertSlots;
+ let rows = this._currentPage.get_children();
+ numOfVertSlots = rows.length;
+
+ for (let i = 0; i < rows.length; ++i) {
+ let keyboardRow = rows[i];
+ let keys = keyboardRow.get_children();
+
+ numOfHorizSlots = Math.max(numOfHorizSlots, keys.length);
+ }
+
+ return [numOfHorizSlots, numOfVertSlots];
+ }
+
+ _relayout() {
+ let monitor = Main.layoutManager.keyboardMonitor;
+
+ if (!monitor)
+ return;
+
+ let maxHeight = monitor.height / 3;
+ this.width = monitor.width;
+
+ if (monitor.width > monitor.height) {
+ this.height = maxHeight;
+ } else {
+ /* In portrait mode, lack of horizontal space means we won't be
+ * able to make the OSK that big while keeping size ratio, so
+ * we allow the OSK being smaller than 1/3rd of the monitor height
+ * there.
+ */
+ const forWidth = this.get_theme_node().adjust_for_width(monitor.width);
+ const [, natHeight] = this.get_preferred_height(forWidth);
+ this.height = Math.min(maxHeight, natHeight);
+ }
+ }
+
+ _onGroupChanged() {
+ this._ensureKeysForGroup(this._keyboardController.getCurrentGroup());
+ this._setActiveLayer(0);
+ }
+
+ _onKeyboardGroupsChanged() {
+ let nonGroupActors = [this._emojiSelection, this._keypad];
+ this._aspectContainer.get_children().filter(c => !nonGroupActors.includes(c)).forEach(c => {
+ c.destroy();
+ });
+
+ this._groups = {};
+ this._onGroupChanged();
+ }
+
+ _onKeypadVisible(controller, visible) {
+ if (visible == this._keypadVisible)
+ return;
+
+ this._keypadVisible = visible;
+ this._keypad.visible = this._keypadVisible;
+ this._updateCurrentPageVisible();
+ }
+
+ _onEmojiKeyVisible(controller, visible) {
+ if (visible == this._emojiKeyVisible)
+ return;
+
+ this._emojiKeyVisible = visible;
+ /* Rebuild keyboard widgetry to include emoji button */
+ this._onKeyboardGroupsChanged();
+ }
+
+ _onKeyboardStateChanged(controller, state) {
+ let enabled;
+ if (state == Clutter.InputPanelState.OFF)
+ enabled = false;
+ else if (state == Clutter.InputPanelState.ON)
+ enabled = true;
+ else if (state == Clutter.InputPanelState.TOGGLE)
+ enabled = this._keyboardVisible == false;
+ else
+ return;
+
+ if (enabled)
+ this.open(Main.layoutManager.focusIndex);
+ else
+ this.close();
+ }
+
+ _setActiveLayer(activeLevel) {
+ let activeGroupName = this._keyboardController.getCurrentGroup();
+ let layers = this._groups[activeGroupName];
+ let currentPage = layers[activeLevel];
+
+ if (this._currentPage == currentPage) {
+ this._updateCurrentPageVisible();
+ return;
+ }
+
+ if (this._currentPage != null) {
+ this._setCurrentLevelLatched(this._currentPage, false);
+ this._currentPage.disconnect(this._currentPage._destroyID);
+ this._currentPage.hide();
+ delete this._currentPage._destroyID;
+ }
+
+ this._currentPage = currentPage;
+ this._currentPage._destroyID = this._currentPage.connect('destroy', () => {
+ this._currentPage = null;
+ });
+ this._updateCurrentPageVisible();
+ }
+
+ _clearKeyboardRestTimer() {
+ if (!this._keyboardRestingId)
+ return;
+ GLib.source_remove(this._keyboardRestingId);
+ this._keyboardRestingId = 0;
+ }
+
+ open(monitor) {
+ this._clearShowIdle();
+ this._keyboardRequested = true;
+
+ if (this._keyboardVisible) {
+ if (monitor != Main.layoutManager.keyboardIndex) {
+ Main.layoutManager.keyboardIndex = monitor;
+ this._relayout();
+ }
+ return;
+ }
+
+ this._clearKeyboardRestTimer();
+ this._keyboardRestingId = GLib.timeout_add(GLib.PRIORITY_DEFAULT,
+ KEYBOARD_REST_TIME,
+ () => {
+ this._clearKeyboardRestTimer();
+ this._open(monitor);
+ return GLib.SOURCE_REMOVE;
+ });
+ GLib.Source.set_name_by_id(this._keyboardRestingId, '[gnome-shell] this._clearKeyboardRestTimer');
+ }
+
+ _open(monitor) {
+ if (!this._keyboardRequested)
+ return;
+
+ Main.layoutManager.keyboardIndex = monitor;
+ this._relayout();
+ Main.layoutManager.showKeyboard();
+
+ this._setEmojiActive(false);
+
+ if (this._delayedAnimFocusWindow) {
+ this._setAnimationWindow(this._delayedAnimFocusWindow);
+ this._delayedAnimFocusWindow = null;
+ }
+ }
+
+ close() {
+ this._clearShowIdle();
+ this._keyboardRequested = false;
+
+ if (!this._keyboardVisible)
+ return;
+
+ this._clearKeyboardRestTimer();
+ this._keyboardRestingId = GLib.timeout_add(GLib.PRIORITY_DEFAULT,
+ KEYBOARD_REST_TIME,
+ () => {
+ this._clearKeyboardRestTimer();
+ this._close();
+ return GLib.SOURCE_REMOVE;
+ });
+ GLib.Source.set_name_by_id(this._keyboardRestingId, '[gnome-shell] this._clearKeyboardRestTimer');
+ }
+
+ _close() {
+ if (this._keyboardRequested)
+ return;
+
+ Main.layoutManager.hideKeyboard();
+ this.setCursorLocation(null);
+ }
+
+ resetSuggestions() {
+ if (this._suggestions)
+ this._suggestions.clear();
+ }
+
+ addSuggestion(text, callback) {
+ if (!this._suggestions)
+ return;
+ this._suggestions.add(text, callback);
+ this._suggestions.show();
+ }
+
+ _clearShowIdle() {
+ if (!this._showIdleId)
+ return;
+ GLib.source_remove(this._showIdleId);
+ this._showIdleId = 0;
+ }
+
+ _windowSlideAnimationComplete(window, delta) {
+ // Synchronize window positions again.
+ let frameRect = window.get_frame_rect();
+ frameRect.y += delta;
+ window.move_frame(true, frameRect.x, frameRect.y);
+ }
+
+ _animateWindow(window, show) {
+ let windowActor = window.get_compositor_private();
+ let deltaY = Main.layoutManager.keyboardBox.height;
+ if (!windowActor)
+ return;
+
+ if (show) {
+ windowActor.ease({
+ y: windowActor.y - deltaY,
+ duration: Layout.KEYBOARD_ANIMATION_TIME,
+ mode: Clutter.AnimationMode.EASE_OUT_QUAD,
+ onComplete: () => {
+ this._windowSlideAnimationComplete(window, -deltaY);
+ },
+ });
+ } else {
+ windowActor.ease({
+ y: windowActor.y + deltaY,
+ duration: Layout.KEYBOARD_ANIMATION_TIME,
+ mode: Clutter.AnimationMode.EASE_IN_QUAD,
+ onComplete: () => {
+ this._windowSlideAnimationComplete(window, deltaY);
+ },
+ });
+ }
+ }
+
+ _setAnimationWindow(window) {
+ if (this._animFocusedWindow == window)
+ return;
+
+ if (this._animFocusedWindow)
+ this._animateWindow(this._animFocusedWindow, false);
+ if (window)
+ this._animateWindow(window, true);
+
+ this._animFocusedWindow = window;
+ }
+
+ setCursorLocation(window, x, y, w, h) {
+ let monitor = Main.layoutManager.keyboardMonitor;
+
+ if (window && monitor) {
+ let keyboardHeight = Main.layoutManager.keyboardBox.height;
+
+ if (y + h >= monitor.y + monitor.height - keyboardHeight) {
+ if (this._keyboardVisible)
+ this._setAnimationWindow(window);
+ else
+ this._delayedAnimFocusWindow = window;
+ } else if (y < keyboardHeight) {
+ this._delayedAnimFocusWindow = null;
+ this._setAnimationWindow(null);
+ }
+ } else {
+ this._setAnimationWindow(null);
+ }
+
+ this._oskFocusWindow = window;
+ }
+});
+
+var KeyboardController = class {
+ constructor() {
+ let seat = Clutter.get_default_backend().get_default_seat();
+ this._virtualDevice = seat.create_virtual_device(Clutter.InputDeviceType.KEYBOARD_DEVICE);
+
+ this._inputSourceManager = InputSourceManager.getInputSourceManager();
+ this._sourceChangedId = this._inputSourceManager.connect('current-source-changed',
+ this._onSourceChanged.bind(this));
+ this._sourcesModifiedId = this._inputSourceManager.connect('sources-changed',
+ this._onSourcesModified.bind(this));
+ this._currentSource = this._inputSourceManager.currentSource;
+
+ this._notifyContentPurposeId = Main.inputMethod.connect(
+ 'notify::content-purpose', this._onContentPurposeHintsChanged.bind(this));
+ this._notifyContentHintsId = Main.inputMethod.connect(
+ 'notify::content-hints', this._onContentPurposeHintsChanged.bind(this));
+ this._notifyInputPanelStateId = Main.inputMethod.connect(
+ 'input-panel-state', (o, state) => this.emit('panel-state', state));
+ }
+
+ destroy() {
+ this._inputSourceManager.disconnect(this._sourceChangedId);
+ this._inputSourceManager.disconnect(this._sourcesModifiedId);
+ Main.inputMethod.disconnect(this._notifyContentPurposeId);
+ Main.inputMethod.disconnect(this._notifyContentHintsId);
+ Main.inputMethod.disconnect(this._notifyInputPanelStateId);
+
+ // Make sure any buttons pressed by the virtual device are released
+ // immediately instead of waiting for the next GC cycle
+ this._virtualDevice.run_dispose();
+ }
+
+ _onSourcesModified() {
+ this.emit('groups-changed');
+ }
+
+ _onSourceChanged(inputSourceManager, _oldSource) {
+ let source = inputSourceManager.currentSource;
+ this._currentSource = source;
+ this.emit('active-group', source.id);
+ }
+
+ _onContentPurposeHintsChanged(method) {
+ let purpose = method.content_purpose;
+ let emojiVisible = false;
+ let keypadVisible = false;
+
+ if (purpose == Clutter.InputContentPurpose.NORMAL ||
+ purpose == Clutter.InputContentPurpose.ALPHA ||
+ purpose == Clutter.InputContentPurpose.PASSWORD ||
+ purpose == Clutter.InputContentPurpose.TERMINAL)
+ emojiVisible = true;
+ if (purpose == Clutter.InputContentPurpose.DIGITS ||
+ purpose == Clutter.InputContentPurpose.NUMBER ||
+ purpose == Clutter.InputContentPurpose.PHONE)
+ keypadVisible = true;
+
+ this.emit('emoji-visible', emojiVisible);
+ this.emit('keypad-visible', keypadVisible);
+ }
+
+ getGroups() {
+ let inputSources = this._inputSourceManager.inputSources;
+ let groups = [];
+
+ for (let i in inputSources) {
+ let is = inputSources[i];
+ groups[is.index] = is.xkbId;
+ }
+
+ return groups;
+ }
+
+ getCurrentGroup() {
+ return this._currentSource.xkbId;
+ }
+
+ commitString(string, fromKey) {
+ if (string == null)
+ return false;
+ /* Let ibus methods fall through keyval emission */
+ if (fromKey && this._currentSource.type == InputSourceManager.INPUT_SOURCE_TYPE_IBUS)
+ return false;
+
+ Main.inputMethod.commit(string);
+ return true;
+ }
+
+ keyvalPress(keyval) {
+ this._virtualDevice.notify_keyval(Clutter.get_current_event_time(),
+ keyval, Clutter.KeyState.PRESSED);
+ }
+
+ keyvalRelease(keyval) {
+ this._virtualDevice.notify_keyval(Clutter.get_current_event_time(),
+ keyval, Clutter.KeyState.RELEASED);
+ }
+};
+Signals.addSignalMethods(KeyboardController.prototype);