From f9d480cfe50ca1d7a0f0b5a2b8bb9932962bfbe7 Mon Sep 17 00:00:00 2001 From: Daniel Baumann Date: Sat, 27 Apr 2024 17:07:22 +0200 Subject: Adding upstream version 3.38.6. Signed-off-by: Daniel Baumann --- js/ui/padOsd.js | 993 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 993 insertions(+) create mode 100644 js/ui/padOsd.js (limited to 'js/ui/padOsd.js') diff --git a/js/ui/padOsd.js b/js/ui/padOsd.js new file mode 100644 index 0000000..9ab1cbb --- /dev/null +++ b/js/ui/padOsd.js @@ -0,0 +1,993 @@ +// -*- mode: js; js-indent-level: 4; indent-tabs-mode: nil -*- +/* exported PadOsd, PadOsdService */ + +const { Atk, Clutter, GDesktopEnums, Gio, + GLib, GObject, Gtk, Meta, Pango, Rsvg, St } = imports.gi; +const ByteArray = imports.byteArray; +const Signals = imports.signals; + +const Main = imports.ui.main; +const PopupMenu = imports.ui.popupMenu; +const Layout = imports.ui.layout; + +const { loadInterfaceXML } = imports.misc.fileUtils; + +const ACTIVE_COLOR = "#729fcf"; + +const LTR = 0; +const RTL = 1; + +const CW = 0; +const CCW = 1; + +const UP = 0; +const DOWN = 1; + +var PadChooser = GObject.registerClass({ + Signals: { 'pad-selected': { param_types: [Clutter.InputDevice.$gtype] } }, +}, class PadChooser extends St.Button { + _init(device, groupDevices) { + super._init({ + style_class: 'pad-chooser-button', + toggle_mode: true, + }); + this.currentDevice = device; + this._padChooserMenu = null; + + let arrow = new St.Icon({ + style_class: 'popup-menu-arrow', + icon_name: 'pan-down-symbolic', + accessible_role: Atk.Role.ARROW, + x_align: Clutter.ActorAlign.CENTER, + y_align: Clutter.ActorAlign.CENTER, + }); + this.set_child(arrow); + this._ensureMenu(groupDevices); + + this.connect('destroy', this._onDestroy.bind(this)); + } + + vfunc_clicked() { + if (this.get_checked()) { + if (this._padChooserMenu != null) + this._padChooserMenu.open(true); + else + this.set_checked(false); + } else { + this._padChooserMenu.close(true); + } + } + + _ensureMenu(devices) { + this._padChooserMenu = new PopupMenu.PopupMenu(this, 0.5, St.Side.TOP); + this._padChooserMenu.connect('menu-closed', () => { + this.set_checked(false); + }); + this._padChooserMenu.actor.hide(); + Main.uiGroup.add_actor(this._padChooserMenu.actor); + + for (let i = 0; i < devices.length; i++) { + let device = devices[i]; + if (device == this.currentDevice) + continue; + + this._padChooserMenu.addAction(device.get_device_name(), () => { + this.emit('pad-selected', device); + }); + } + } + + _onDestroy() { + this._padChooserMenu.destroy(); + } + + update(devices) { + if (this._padChooserMenu) + this._padChooserMenu.actor.destroy(); + this.set_checked(false); + this._ensureMenu(devices); + } +}); + +var KeybindingEntry = GObject.registerClass({ + Signals: { 'keybinding-edited': { param_types: [GObject.TYPE_STRING] } }, +}, class KeybindingEntry extends St.Entry { + _init() { + super._init({ hint_text: _("New shortcut…"), style: 'width: 10em' }); + } + + vfunc_captured_event(event) { + if (event.type() != Clutter.EventType.KEY_PRESS) + return Clutter.EVENT_PROPAGATE; + + let str = Gtk.accelerator_name_with_keycode(null, + event.get_key_symbol(), + event.get_key_code(), + event.get_state()); + this.set_text(str); + this.emit('keybinding-edited', str); + return Clutter.EVENT_STOP; + } +}); + +var ActionComboBox = GObject.registerClass({ + Signals: { 'action-selected': { param_types: [GObject.TYPE_INT] } }, +}, class ActionComboBox extends St.Button { + _init() { + super._init({ style_class: 'button' }); + this.set_toggle_mode(true); + + let boxLayout = new Clutter.BoxLayout({ orientation: Clutter.Orientation.HORIZONTAL, + spacing: 6 }); + let box = new St.Widget({ layout_manager: boxLayout }); + this.set_child(box); + + this._label = new St.Label({ style_class: 'combo-box-label' }); + box.add_child(this._label); + + let arrow = new St.Icon({ style_class: 'popup-menu-arrow', + icon_name: 'pan-down-symbolic', + accessible_role: Atk.Role.ARROW, + y_expand: true, + y_align: Clutter.ActorAlign.CENTER }); + box.add_child(arrow); + + this._editMenu = new PopupMenu.PopupMenu(this, 0, St.Side.TOP); + this._editMenu.connect('menu-closed', () => { + this.set_checked(false); + }); + this._editMenu.actor.hide(); + Main.uiGroup.add_actor(this._editMenu.actor); + + this._actionLabels = new Map(); + this._actionLabels.set(GDesktopEnums.PadButtonAction.NONE, _("Application defined")); + this._actionLabels.set(GDesktopEnums.PadButtonAction.HELP, _("Show on-screen help")); + this._actionLabels.set(GDesktopEnums.PadButtonAction.SWITCH_MONITOR, _("Switch monitor")); + this._actionLabels.set(GDesktopEnums.PadButtonAction.KEYBINDING, _("Assign keystroke")); + + this._buttonItems = []; + + for (let [action, label] of this._actionLabels.entries()) { + let selectedAction = action; + let item = this._editMenu.addAction(label, () => { + this._onActionSelected(selectedAction); + }); + + /* These actions only apply to pad buttons */ + if (selectedAction == GDesktopEnums.PadButtonAction.HELP || + selectedAction == GDesktopEnums.PadButtonAction.SWITCH_MONITOR) + this._buttonItems.push(item); + } + + this.setAction(GDesktopEnums.PadButtonAction.NONE); + } + + _onActionSelected(action) { + this.setAction(action); + this.popdown(); + this.emit('action-selected', action); + } + + setAction(action) { + this._label.set_text(this._actionLabels.get(action)); + } + + popup() { + this._editMenu.open(true); + } + + popdown() { + this._editMenu.close(true); + } + + vfunc_clicked() { + if (this.get_checked()) + this.popup(); + else + this.popdown(); + } + + setButtonActionsActive(active) { + this._buttonItems.forEach(item => item.setSensitive(active)); + } +}); + +var ActionEditor = GObject.registerClass({ + Signals: { 'done': {} }, +}, class ActionEditor extends St.Widget { + _init() { + let boxLayout = new Clutter.BoxLayout({ orientation: Clutter.Orientation.HORIZONTAL, + spacing: 12 }); + + super._init({ layout_manager: boxLayout }); + + this._actionComboBox = new ActionComboBox(); + this._actionComboBox.connect('action-selected', this._onActionSelected.bind(this)); + this.add_actor(this._actionComboBox); + + this._keybindingEdit = new KeybindingEntry(); + this._keybindingEdit.connect('keybinding-edited', this._onKeybindingEdited.bind(this)); + this.add_actor(this._keybindingEdit); + + this._doneButton = new St.Button({ label: _("Done"), + style_class: 'button', + x_expand: false }); + this._doneButton.connect('clicked', this._onEditingDone.bind(this)); + this.add_actor(this._doneButton); + } + + _updateKeybindingEntryState() { + if (this._currentAction == GDesktopEnums.PadButtonAction.KEYBINDING) { + this._keybindingEdit.set_text(this._currentKeybinding); + this._keybindingEdit.show(); + this._keybindingEdit.grab_key_focus(); + } else { + this._keybindingEdit.hide(); + } + } + + setSettings(settings, action) { + this._buttonSettings = settings; + + this._currentAction = this._buttonSettings.get_enum('action'); + this._currentKeybinding = this._buttonSettings.get_string('keybinding'); + this._actionComboBox.setAction(this._currentAction); + this._updateKeybindingEntryState(); + + let isButton = action == Meta.PadActionType.BUTTON; + this._actionComboBox.setButtonActionsActive(isButton); + } + + close() { + this._actionComboBox.popdown(); + this.hide(); + } + + _onKeybindingEdited(entry, keybinding) { + this._currentKeybinding = keybinding; + } + + _onActionSelected(menu, action) { + this._currentAction = action; + this._updateKeybindingEntryState(); + } + + _storeSettings() { + if (!this._buttonSettings) + return; + + let keybinding = null; + + if (this._currentAction == GDesktopEnums.PadButtonAction.KEYBINDING) + keybinding = this._currentKeybinding; + + this._buttonSettings.set_enum('action', this._currentAction); + + if (keybinding) + this._buttonSettings.set_string('keybinding', keybinding); + else + this._buttonSettings.reset('keybinding'); + } + + _onEditingDone() { + this._storeSettings(); + this.close(); + this.emit('done'); + } +}); + +var PadDiagram = GObject.registerClass({ + Properties: { + 'left-handed': GObject.ParamSpec.boolean('left-handed', + 'left-handed', 'Left handed', + GObject.ParamFlags.READWRITE | + GObject.ParamFlags.CONSTRUCT_ONLY, + false), + 'image': GObject.ParamSpec.string('image', 'image', 'Image', + GObject.ParamFlags.READWRITE | + GObject.ParamFlags.CONSTRUCT_ONLY, + null), + 'editor-actor': GObject.ParamSpec.object('editor-actor', + 'editor-actor', + 'Editor actor', + GObject.ParamFlags.READWRITE | + GObject.ParamFlags.CONSTRUCT_ONLY, + Clutter.Actor.$gtype), + }, +}, class PadDiagram extends St.DrawingArea { + _init(params) { + let file = Gio.File.new_for_uri('resource:///org/gnome/shell/theme/pad-osd.css'); + let [success_, css] = file.load_contents(null); + css = ByteArray.toString(css); + this._curEdited = null; + this._prevEdited = null; + this._css = css; + this._labels = []; + this._activeButtons = []; + super._init(params); + } + + // eslint-disable-next-line camelcase + get left_handed() { + return this._leftHanded; + } + + // eslint-disable-next-line camelcase + set left_handed(leftHanded) { + this._leftHanded = leftHanded; + } + + get image() { + return this._imagePath; + } + + set image(imagePath) { + let originalHandle = Rsvg.Handle.new_from_file(imagePath); + let dimensions = originalHandle.get_dimensions(); + this._imageWidth = dimensions.width; + this._imageHeight = dimensions.height; + + this._imagePath = imagePath; + this._handle = this._composeStyledDiagram(); + this._initLabels(); + } + + // eslint-disable-next-line camelcase + get editor_actor() { + return this._editorActor; + } + + // eslint-disable-next-line camelcase + set editor_actor(actor) { + actor.hide(); + this._editorActor = actor; + this.add_actor(actor); + } + + _initLabels() { + let i = 0; + for (i = 0; ; i++) { + if (!this._addLabel(Meta.PadActionType.BUTTON, i)) + break; + } + + for (i = 0; ; i++) { + if (!this._addLabel(Meta.PadActionType.RING, i, CW) || + !this._addLabel(Meta.PadActionType.RING, i, CCW)) + break; + } + + for (i = 0; ; i++) { + if (!this._addLabel(Meta.PadActionType.STRIP, i, UP) || + !this._addLabel(Meta.PadActionType.STRIP, i, DOWN)) + break; + } + } + + _wrappingSvgHeader() { + return '' + + ''.format(this._imageWidth, this._imageHeight) + + '' + + '' + + ''; + } + + _cssString() { + let css = this._css; + + for (let i = 0; i < this._activeButtons.length; i++) { + let ch = String.fromCharCode('A'.charCodeAt() + this._activeButtons[i]); + css += '.%s.Leader { stroke: %s !important; }'.format(ch, ACTIVE_COLOR); + css += '.%s.Button { stroke: %s !important; fill: %s !important; }'.format(ch, ACTIVE_COLOR, ACTIVE_COLOR); + } + + return css; + } + + _composeStyledDiagram() { + let svgData = ''; + + if (!GLib.file_test(this._imagePath, GLib.FileTest.EXISTS)) + return null; + + svgData += this._wrappingSvgHeader(); + svgData += this._cssString(); + svgData += this._wrappingSvgFooter(); + + let istream = new Gio.MemoryInputStream(); + istream.add_bytes(new GLib.Bytes(svgData)); + + return Rsvg.Handle.new_from_stream_sync(istream, + Gio.File.new_for_path(this._imagePath), + 0, null); + } + + _updateDiagramScale() { + [this._actorWidth, this._actorHeight] = this.get_size(); + let dimensions = this._handle.get_dimensions(); + let scaleX = this._actorWidth / dimensions.width; + let scaleY = this._actorHeight / dimensions.height; + this._scale = Math.min(scaleX, scaleY); + } + + _allocateChild(child, x, y, direction) { + let [, natHeight] = child.get_preferred_height(-1); + let [, natWidth] = child.get_preferred_width(natHeight); + let childBox = new Clutter.ActorBox(); + + // I miss Cairo.Matrix + let dimensions = this._handle.get_dimensions(); + x = x * this._scale + this._actorWidth / 2 - dimensions.width / 2 * this._scale; + y = y * this._scale + this._actorHeight / 2 - dimensions.height / 2 * this._scale; + + if (direction == LTR) { + childBox.x1 = x; + childBox.x2 = x + natWidth; + } else { + childBox.x1 = x - natWidth; + childBox.x2 = x; + } + + childBox.y1 = y - natHeight / 2; + childBox.y2 = y + natHeight / 2; + child.allocate(childBox); + } + + vfunc_allocate(box) { + super.vfunc_allocate(box); + if (this._handle === null) + return; + + this._updateDiagramScale(); + + for (let i = 0; i < this._labels.length; i++) { + const { label, x, y, arrangement } = this._labels[i]; + this._allocateChild(label, x, y, arrangement); + } + + if (this._editorActor && this._curEdited) { + const { x, y, arrangement } = this._curEdited; + this._allocateChild(this._editorActor, x, y, arrangement); + } + } + + vfunc_repaint() { + if (this._handle == null) + return; + + if (this._scale == null) + this._updateDiagramScale(); + + let [width, height] = this.get_surface_size(); + let dimensions = this._handle.get_dimensions(); + let cr = this.get_context(); + + cr.save(); + cr.translate(width / 2, height / 2); + cr.scale(this._scale, this._scale); + if (this._leftHanded) + cr.rotate(Math.PI); + cr.translate(-dimensions.width / 2, -dimensions.height / 2); + this._handle.render_cairo(cr); + cr.restore(); + cr.$dispose(); + } + + _getItemLabelCoords(labelName, leaderName) { + if (this._handle == null) + return [false]; + + let leaderPos, leaderSize, pos; + let found, direction; + + [found, pos] = this._handle.get_position_sub('#%s'.format(labelName)); + if (!found) + return [false]; + + [found, leaderPos] = this._handle.get_position_sub('#%s'.format(leaderName)); + [found, leaderSize] = this._handle.get_dimensions_sub('#%s'.format(leaderName)); + if (!found) + return [false]; + + if (pos.x > leaderPos.x + leaderSize.width) + direction = LTR; + else + direction = RTL; + + if (this._leftHanded) { + direction = 1 - direction; + pos.x = this._imageWidth - pos.x; + pos.y = this._imageHeight - pos.y; + } + + return [true, pos.x, pos.y, direction]; + } + + _getButtonLabels(button) { + let ch = String.fromCharCode('A'.charCodeAt() + button); + let labelName = 'Label%s'.format(ch); + let leaderName = 'Leader%s'.format(ch); + return [labelName, leaderName]; + } + + _getRingLabels(number, dir) { + let numStr = number > 0 ? (number + 1).toString() : ''; + let dirStr = dir == CW ? 'CW' : 'CCW'; + let labelName = 'LabelRing%s%s'.format(numStr, dirStr); + let leaderName = 'LeaderRing%s%s'.format(numStr, dirStr); + return [labelName, leaderName]; + } + + _getStripLabels(number, dir) { + let numStr = number > 0 ? (number + 1).toString() : ''; + let dirStr = dir == UP ? 'Up' : 'Down'; + let labelName = 'LabelStrip%s%s'.format(numStr, dirStr); + let leaderName = 'LeaderStrip%s%s'.format(numStr, dirStr); + return [labelName, leaderName]; + } + + _getLabelCoords(action, idx, dir) { + if (action == Meta.PadActionType.BUTTON) + return this._getItemLabelCoords(...this._getButtonLabels(idx)); + else if (action == Meta.PadActionType.RING) + return this._getItemLabelCoords(...this._getRingLabels(idx, dir)); + else if (action == Meta.PadActionType.STRIP) + return this._getItemLabelCoords(...this._getStripLabels(idx, dir)); + + return [false]; + } + + _invalidateSvg() { + if (this._handle == null) + return; + this._handle = this._composeStyledDiagram(); + this.queue_repaint(); + } + + activateButton(button) { + this._activeButtons.push(button); + this._invalidateSvg(); + } + + deactivateButton(button) { + for (let i = 0; i < this._activeButtons.length; i++) { + if (this._activeButtons[i] == button) + this._activeButtons.splice(i, 1); + } + this._invalidateSvg(); + } + + _addLabel(action, idx, dir) { + let [found, x, y, arrangement] = this._getLabelCoords(action, idx, dir); + if (!found) + return false; + + let label = new St.Label(); + this._labels.push({ label, action, idx, dir, x, y, arrangement }); + this.add_actor(label); + return true; + } + + updateLabels(getText) { + for (let i = 0; i < this._labels.length; i++) { + const { label, action, idx, dir } = this._labels[i]; + let str = getText(action, idx, dir); + label.set_text(str); + } + + this.queue_relayout(); + } + + _applyLabel(label, action, idx, dir, str) { + if (str !== null) + label.set_text(str); + label.show(); + } + + stopEdition(continues, str) { + this._editorActor.hide(); + + if (this._prevEdited) { + const { label, action, idx, dir } = this._prevEdited; + this._applyLabel(label, action, idx, dir, str); + this._prevEdited = null; + } + + if (this._curEdited) { + const { label, action, idx, dir } = this._curEdited; + this._applyLabel(label, action, idx, dir, str); + if (continues) + this._prevEdited = this._curEdited; + this._curEdited = null; + } + + this.queue_relayout(); + } + + startEdition(action, idx, dir) { + let editedLabel; + + if (this._curEdited) + return; + + for (let i = 0; i < this._labels.length; i++) { + if (action == this._labels[i].action && + idx == this._labels[i].idx && dir == this._labels[i].dir) { + this._curEdited = this._labels[i]; + editedLabel = this._curEdited.label; + break; + } + } + + if (this._curEdited == null) + return; + this._editorActor.show(); + editedLabel.hide(); + this.queue_relayout(); + } +}); + +var PadOsd = GObject.registerClass({ + Signals: { + 'pad-selected': { param_types: [Clutter.InputDevice.$gtype] }, + 'closed': {}, + }, +}, class PadOsd extends St.BoxLayout { + _init(padDevice, settings, imagePath, editionMode, monitorIndex) { + super._init({ + style_class: 'pad-osd-window', + vertical: true, + x_expand: true, + y_expand: true, + reactive: true, + }); + + this.padDevice = padDevice; + this._groupPads = [padDevice]; + this._settings = settings; + this._imagePath = imagePath; + this._editionMode = editionMode; + this._capturedEventId = global.stage.connect('captured-event', this._onCapturedEvent.bind(this)); + this._padChooser = null; + + let seat = Clutter.get_default_backend().get_default_seat(); + this._deviceAddedId = seat.connect('device-added', (_seat, device) => { + if (device.get_device_type() == Clutter.InputDeviceType.PAD_DEVICE && + this.padDevice.is_grouped(device)) { + this._groupPads.push(device); + this._updatePadChooser(); + } + }); + this._deviceRemovedId = seat.connect('device-removed', (_seat, device) => { + // If the device is being removed, destroy the padOsd. + if (device == this.padDevice) { + this.destroy(); + } else if (this._groupPads.includes(device)) { + // Or update the pad chooser if the device belongs to + // the same group. + this._groupPads.splice(this._groupPads.indexOf(device), 1); + this._updatePadChooser(); + + } + }); + + seat.list_devices().forEach(device => { + if (device != this.padDevice && + device.get_device_type() == Clutter.InputDeviceType.PAD_DEVICE && + this.padDevice.is_grouped(device)) + this._groupPads.push(device); + }); + + this.connect('destroy', this._onDestroy.bind(this)); + Main.uiGroup.add_actor(this); + + this._monitorIndex = monitorIndex; + let constraint = new Layout.MonitorConstraint({ index: monitorIndex }); + this.add_constraint(constraint); + + this._titleBox = new St.BoxLayout({ style_class: 'pad-osd-title-box', + vertical: false, + x_expand: false, + x_align: Clutter.ActorAlign.CENTER }); + this.add_actor(this._titleBox); + + let labelBox = new St.BoxLayout({ style_class: 'pad-osd-title-menu-box', + vertical: true }); + this._titleBox.add_actor(labelBox); + + this._titleLabel = new St.Label({ style: 'font-side: larger; font-weight: bold;', + x_align: Clutter.ActorAlign.CENTER }); + this._titleLabel.clutter_text.set_ellipsize(Pango.EllipsizeMode.NONE); + this._titleLabel.clutter_text.set_text(padDevice.get_device_name()); + labelBox.add_actor(this._titleLabel); + + this._tipLabel = new St.Label({ x_align: Clutter.ActorAlign.CENTER }); + labelBox.add_actor(this._tipLabel); + + this._updatePadChooser(); + + this._actionEditor = new ActionEditor(); + this._actionEditor.connect('done', this._endActionEdition.bind(this)); + + this._padDiagram = new PadDiagram({ image: this._imagePath, + left_handed: settings.get_boolean('left-handed'), + editor_actor: this._actionEditor, + x_expand: true, + y_expand: true }); + this.add_actor(this._padDiagram); + this._updateActionLabels(); + + let buttonBox = new St.Widget({ layout_manager: new Clutter.BinLayout(), + x_expand: true, + x_align: Clutter.ActorAlign.CENTER, + y_align: Clutter.ActorAlign.CENTER }); + this.add_actor(buttonBox); + this._editButton = new St.Button({ + label: _('Edit…'), + style_class: 'button', + can_focus: true, + x_align: Clutter.ActorAlign.CENTER, + }); + this._editButton.connect('clicked', () => { + this.setEditionMode(true); + }); + buttonBox.add_actor(this._editButton); + + this._syncEditionMode(); + Main.pushModal(this); + } + + _updatePadChooser() { + if (this._groupPads.length > 1) { + if (this._padChooser == null) { + this._padChooser = new PadChooser(this.padDevice, this._groupPads); + this._padChooser.connect('pad-selected', (chooser, pad) => { + this._requestForOtherPad(pad); + }); + this._titleBox.add_child(this._padChooser); + } else { + this._padChooser.update(this._groupPads); + } + } else if (this._padChooser != null) { + this._padChooser.destroy(); + this._padChooser = null; + } + } + + _requestForOtherPad(pad) { + if (pad == this.padDevice || !this._groupPads.includes(pad)) + return; + + let editionMode = this._editionMode; + this.destroy(); + global.display.request_pad_osd(pad, editionMode); + } + + _getActionText(type, number) { + let str = global.display.get_pad_action_label(this.padDevice, type, number); + return str ? str : _("None"); + } + + _updateActionLabels() { + this._padDiagram.updateLabels(this._getActionText.bind(this)); + } + + _onCapturedEvent(actor, event) { + let isModeSwitch = + (event.type() == Clutter.EventType.PAD_BUTTON_PRESS || + event.type() == Clutter.EventType.PAD_BUTTON_RELEASE) && + this.padDevice.get_mode_switch_button_group(event.get_button()) >= 0; + + if (event.type() == Clutter.EventType.PAD_BUTTON_PRESS && + event.get_source_device() == this.padDevice) { + this._padDiagram.activateButton(event.get_button()); + + /* Buttons that switch between modes cannot be edited */ + if (this._editionMode && !isModeSwitch) + this._startButtonActionEdition(event.get_button()); + return Clutter.EVENT_STOP; + } else if (event.type() == Clutter.EventType.PAD_BUTTON_RELEASE && + event.get_source_device() == this.padDevice) { + this._padDiagram.deactivateButton(event.get_button()); + + if (isModeSwitch) { + this._endActionEdition(); + this._updateActionLabels(); + } + return Clutter.EVENT_STOP; + } else if (event.type() == Clutter.EventType.KEY_PRESS && + (!this._editionMode || event.get_key_symbol() === Clutter.KEY_Escape)) { + if (this._editedAction != null) + this._endActionEdition(); + else + this.destroy(); + return Clutter.EVENT_STOP; + } else if (event.get_source_device() == this.padDevice && + event.type() == Clutter.EventType.PAD_STRIP) { + if (this._editionMode) { + let [retval_, number, mode] = event.get_pad_event_details(); + this._startStripActionEdition(number, UP, mode); + } + } else if (event.get_source_device() == this.padDevice && + event.type() == Clutter.EventType.PAD_RING) { + if (this._editionMode) { + let [retval_, number, mode] = event.get_pad_event_details(); + this._startRingActionEdition(number, CCW, mode); + } + } + + // If the event comes from another pad in the same group, + // show the OSD for it. + if (this._groupPads.includes(event.get_source_device())) { + this._requestForOtherPad(event.get_source_device()); + return Clutter.EVENT_STOP; + } + + return Clutter.EVENT_PROPAGATE; + } + + _syncEditionMode() { + this._editButton.set_reactive(!this._editionMode); + this._editButton.save_easing_state(); + this._editButton.set_easing_duration(200); + this._editButton.set_opacity(this._editionMode ? 128 : 255); + this._editButton.restore_easing_state(); + + let title; + + if (this._editionMode) { + title = _("Press a button to configure"); + this._tipLabel.set_text(_("Press Esc to exit")); + } else { + title = this.padDevice.get_device_name(); + this._tipLabel.set_text(_("Press any key to exit")); + } + + this._titleLabel.set_text(title); + } + + _isEditedAction(type, number, dir) { + if (!this._editedAction) + return false; + + return this._editedAction.type == type && + this._editedAction.number == number && + this._editedAction.dir == dir; + } + + _followUpActionEdition(str) { + let { type, dir, number, mode } = this._editedAction; + let hasNextAction = type == Meta.PadActionType.RING && dir == CCW || + type == Meta.PadActionType.STRIP && dir == UP; + if (!hasNextAction) + return false; + + this._padDiagram.stopEdition(true, str); + this._editedAction = null; + if (type == Meta.PadActionType.RING) + this._startRingActionEdition(number, CW, mode); + else + this._startStripActionEdition(number, DOWN, mode); + + return true; + } + + _endActionEdition() { + this._actionEditor.close(); + + if (this._editedAction != null) { + let str = global.display.get_pad_action_label(this.padDevice, + this._editedAction.type, + this._editedAction.number); + if (this._followUpActionEdition(str)) + return; + + this._padDiagram.stopEdition(false, str ? str : _("None")); + this._editedAction = null; + } + + this._editedActionSettings = null; + } + + _startActionEdition(key, type, number, dir, mode) { + if (this._isEditedAction(type, number, dir)) + return; + + this._endActionEdition(); + this._editedAction = { type, number, dir, mode }; + + let settingsPath = this._settings.path + key + '/'; + this._editedActionSettings = Gio.Settings.new_with_path('org.gnome.desktop.peripherals.tablet.pad-button', + settingsPath); + this._actionEditor.setSettings(this._editedActionSettings, type); + this._padDiagram.startEdition(type, number, dir); + } + + _startButtonActionEdition(button) { + let ch = String.fromCharCode('A'.charCodeAt() + button); + let key = 'button%s'.format(ch); + this._startActionEdition(key, Meta.PadActionType.BUTTON, button); + } + + _startRingActionEdition(ring, dir, mode) { + let ch = String.fromCharCode('A'.charCodeAt() + ring); + let key = 'ring%s-%s-mode-%d'.format(ch, dir == CCW ? 'ccw' : 'cw', mode); + this._startActionEdition(key, Meta.PadActionType.RING, ring, dir, mode); + } + + _startStripActionEdition(strip, dir, mode) { + let ch = String.fromCharCode('A'.charCodeAt() + strip); + let key = 'strip%s-%s-mode-%d'.format(ch, dir == UP ? 'up' : 'down', mode); + this._startActionEdition(key, Meta.PadActionType.STRIP, strip, dir, mode); + } + + setEditionMode(editionMode) { + if (this._editionMode == editionMode) + return; + + this._editionMode = editionMode; + this._syncEditionMode(); + } + + _onDestroy() { + Main.popModal(this); + this._actionEditor.close(); + + let seat = Clutter.get_default_backend().get_default_seat(); + if (this._deviceRemovedId != 0) { + seat.disconnect(this._deviceRemovedId); + this._deviceRemovedId = 0; + } + if (this._deviceAddedId != 0) { + seat.disconnect(this._deviceAddedId); + this._deviceAddedId = 0; + } + + if (this._capturedEventId != 0) { + global.stage.disconnect(this._capturedEventId); + this._capturedEventId = 0; + } + + this.emit('closed'); + } +}); + +const PadOsdIface = loadInterfaceXML('org.gnome.Shell.Wacom.PadOsd'); + +var PadOsdService = class { + constructor() { + this._dbusImpl = Gio.DBusExportedObject.wrapJSObject(PadOsdIface, this); + this._dbusImpl.export(Gio.DBus.session, '/org/gnome/Shell/Wacom'); + Gio.DBus.session.own_name('org.gnome.Shell.Wacom.PadOsd', Gio.BusNameOwnerFlags.REPLACE, null, null); + } + + ShowAsync(params, invocation) { + let [deviceNode, editionMode] = params; + let seat = Clutter.get_default_backend().get_default_seat(); + let devices = seat.list_devices(); + let padDevice = null; + + devices.forEach(device => { + if (deviceNode == device.get_device_node() && + device.get_device_type() == Clutter.InputDeviceType.PAD_DEVICE) + padDevice = device; + }); + + if (padDevice == null) { + invocation.return_error_literal(Gio.IOErrorEnum, + Gio.IOErrorEnum.CANCELLED, + "Invalid params"); + return; + } + + global.display.request_pad_osd(padDevice, editionMode); + invocation.return_value(null); + } +}; +Signals.addSignalMethods(PadOsdService.prototype); -- cgit v1.2.3