diff options
Diffstat (limited to 'js/ui/magnifier.js')
| -rw-r--r-- | js/ui/magnifier.js | 1989 |
1 files changed, 1989 insertions, 0 deletions
diff --git a/js/ui/magnifier.js b/js/ui/magnifier.js new file mode 100644 index 0000000..3a778b6 --- /dev/null +++ b/js/ui/magnifier.js @@ -0,0 +1,1989 @@ +// -*- mode: js; js-indent-level: 4; indent-tabs-mode: nil -*- + +const { Atspi, Clutter, GDesktopEnums, + Gio, GLib, GObject, Meta, Shell, St } = imports.gi; +const Signals = imports.signals; + +const Background = imports.ui.background; +const FocusCaretTracker = imports.ui.focusCaretTracker; +const Main = imports.ui.main; +const MagnifierDBus = imports.ui.magnifierDBus; +const Params = imports.misc.params; +const PointerWatcher = imports.ui.pointerWatcher; + +var CROSSHAIRS_CLIP_SIZE = [100, 100]; +var NO_CHANGE = 0.0; + +var POINTER_REST_TIME = 1000; // milliseconds + +// Settings +const MAGNIFIER_SCHEMA = 'org.gnome.desktop.a11y.magnifier'; +const SCREEN_POSITION_KEY = 'screen-position'; +const MAG_FACTOR_KEY = 'mag-factor'; +const INVERT_LIGHTNESS_KEY = 'invert-lightness'; +const COLOR_SATURATION_KEY = 'color-saturation'; +const BRIGHT_RED_KEY = 'brightness-red'; +const BRIGHT_GREEN_KEY = 'brightness-green'; +const BRIGHT_BLUE_KEY = 'brightness-blue'; +const CONTRAST_RED_KEY = 'contrast-red'; +const CONTRAST_GREEN_KEY = 'contrast-green'; +const CONTRAST_BLUE_KEY = 'contrast-blue'; +const LENS_MODE_KEY = 'lens-mode'; +const CLAMP_MODE_KEY = 'scroll-at-edges'; +const MOUSE_TRACKING_KEY = 'mouse-tracking'; +const FOCUS_TRACKING_KEY = 'focus-tracking'; +const CARET_TRACKING_KEY = 'caret-tracking'; +const SHOW_CROSS_HAIRS_KEY = 'show-cross-hairs'; +const CROSS_HAIRS_THICKNESS_KEY = 'cross-hairs-thickness'; +const CROSS_HAIRS_COLOR_KEY = 'cross-hairs-color'; +const CROSS_HAIRS_OPACITY_KEY = 'cross-hairs-opacity'; +const CROSS_HAIRS_LENGTH_KEY = 'cross-hairs-length'; +const CROSS_HAIRS_CLIP_KEY = 'cross-hairs-clip'; + +var MouseSpriteContent = GObject.registerClass({ + Implements: [Clutter.Content], +}, class MouseSpriteContent extends GObject.Object { + _init() { + super._init(); + this._texture = null; + } + + vfunc_get_preferred_size() { + if (!this._texture) + return [false, 0, 0]; + + return [true, this._texture.get_width(), this._texture.get_height()]; + } + + vfunc_paint_content(actor, node, _paintContext) { + if (!this._texture) + return; + + let color = Clutter.Color.get_static(Clutter.StaticColor.WHITE); + let [minFilter, magFilter] = actor.get_content_scaling_filters(); + let textureNode = new Clutter.TextureNode(this._texture, + color, minFilter, magFilter); + textureNode.set_name('MouseSpriteContent'); + node.add_child(textureNode); + + textureNode.add_rectangle(actor.get_content_box()); + } + + get texture() { + return this._texture; + } + + set texture(coglTexture) { + if (this._texture == coglTexture) + return; + + let oldTexture = this._texture; + this._texture = coglTexture; + this.invalidate(); + + if (!oldTexture || !coglTexture || + oldTexture.get_width() != coglTexture.get_width() || + oldTexture.get_height() != coglTexture.get_height()) + this.invalidate_size(); + } +}); + +var Magnifier = class Magnifier { + constructor() { + // Magnifier is a manager of ZoomRegions. + this._zoomRegions = []; + + // Create small clutter tree for the magnified mouse. + let cursorTracker = Meta.CursorTracker.get_for_display(global.display); + this._cursorTracker = cursorTracker; + + this._mouseSprite = new Clutter.Actor({ request_mode: Clutter.RequestMode.CONTENT_SIZE }); + this._mouseSprite.content = new MouseSpriteContent(); + + // Create the first ZoomRegion and initialize it according to the + // magnification settings. + + [this.xMouse, this.yMouse] = global.get_pointer(); + + let aZoomRegion = new ZoomRegion(this, this._mouseSprite); + this._zoomRegions.push(aZoomRegion); + this._settingsInit(aZoomRegion); + aZoomRegion.scrollContentsTo(this.xMouse, this.yMouse); + + St.Settings.get().connect('notify::magnifier-active', () => { + this.setActive(St.Settings.get().magnifier_active); + }); + + // Export to dbus. + new MagnifierDBus.ShellMagnifier(); + this.setActive(St.Settings.get().magnifier_active); + } + + /** + * showSystemCursor: + * Show the system mouse pointer. + */ + showSystemCursor() { + const seat = Clutter.get_default_backend().get_default_seat(); + + if (seat.is_unfocus_inhibited()) + seat.uninhibit_unfocus(); + this._cursorTracker.set_pointer_visible(true); + } + + /** + * hideSystemCursor: + * Hide the system mouse pointer. + */ + hideSystemCursor() { + const seat = Clutter.get_default_backend().get_default_seat(); + + if (!seat.is_unfocus_inhibited()) + seat.inhibit_unfocus(); + this._cursorTracker.set_pointer_visible(false); + } + + /** + * setActive: + * Show/hide all the zoom regions. + * @param {bool} activate: Boolean to activate or de-activate the magnifier. + */ + setActive(activate) { + let isActive = this.isActive(); + + this._zoomRegions.forEach(zoomRegion => { + zoomRegion.setActive(activate); + }); + + if (isActive === activate) + return; + + if (activate) { + this._updateMouseSprite(); + this._cursorSpriteChangedId = + this._cursorTracker.connect('cursor-changed', + this._updateMouseSprite.bind(this)); + Meta.disable_unredirect_for_display(global.display); + this.startTrackingMouse(); + } else { + this._cursorTracker.disconnect(this._cursorSpriteChangedId); + this._mouseSprite.content.texture = null; + Meta.enable_unredirect_for_display(global.display); + this.stopTrackingMouse(); + } + + if (this._crossHairs) + this._crossHairs.setEnabled(activate); + + // Make sure system mouse pointer is shown when all zoom regions are + // invisible. + if (!activate) + this.showSystemCursor(); + + // Notify interested parties of this change + this.emit('active-changed', activate); + } + + /** + * isActive: + * @returns {bool} Whether the magnifier is active. + */ + isActive() { + // Sufficient to check one ZoomRegion since Magnifier's active + // state applies to all of them. + if (this._zoomRegions.length == 0) + return false; + else + return this._zoomRegions[0].isActive(); + } + + /** + * startTrackingMouse: + * Turn on mouse tracking, if not already doing so. + */ + startTrackingMouse() { + if (!this._pointerWatch) { + let interval = 1000 / Clutter.get_default_frame_rate(); + this._pointerWatch = PointerWatcher.getPointerWatcher().addWatch(interval, this.scrollToMousePos.bind(this)); + } + } + + /** + * stopTrackingMouse: + * Turn off mouse tracking, if not already doing so. + */ + stopTrackingMouse() { + if (this._pointerWatch) + this._pointerWatch.remove(); + + this._pointerWatch = null; + } + + /** + * isTrackingMouse: + * @returns {bool} whether the magnifier is currently tracking the mouse + */ + isTrackingMouse() { + return !!this._mouseTrackingId; + } + + /** + * scrollToMousePos: + * Position all zoom regions' ROI relative to the current location of the + * system pointer. + * @returns {bool} true. + */ + scrollToMousePos() { + let [xMouse, yMouse] = global.get_pointer(); + + if (xMouse != this.xMouse || yMouse != this.yMouse) { + this.xMouse = xMouse; + this.yMouse = yMouse; + + let sysMouseOverAny = false; + this._zoomRegions.forEach(zoomRegion => { + if (zoomRegion.scrollToMousePos()) + sysMouseOverAny = true; + }); + if (sysMouseOverAny) + this.hideSystemCursor(); + else + this.showSystemCursor(); + } + return true; + } + + /** + * createZoomRegion: + * Create a ZoomRegion instance with the given properties. + * @param {number} xMagFactor: + * The power to set horizontal magnification of the ZoomRegion. A value + * of 1.0 means no magnification, a value of 2.0 doubles the size. + * @param {number} yMagFactor: + * The power to set the vertical magnification of the ZoomRegion. + * @param {{x: number, y: number, width: number, height: number}} roi: + * The reg Object that defines the region to magnify, given in + * unmagnified coordinates. + * @param {{x: number, y: number, width: number, height: number}} viewPort: + * Object that defines the position of the ZoomRegion on screen. + * @returns {ZoomRegion} the newly created ZoomRegion. + */ + createZoomRegion(xMagFactor, yMagFactor, roi, viewPort) { + let zoomRegion = new ZoomRegion(this, this._mouseSprite); + zoomRegion.setViewPort(viewPort); + + // We ignore the redundant width/height on the ROI + let fixedROI = Object.create(roi); + fixedROI.width = viewPort.width / xMagFactor; + fixedROI.height = viewPort.height / yMagFactor; + zoomRegion.setROI(fixedROI); + + zoomRegion.addCrosshairs(this._crossHairs); + return zoomRegion; + } + + /** + * addZoomRegion: + * Append the given ZoomRegion to the list of currently defined ZoomRegions + * for this Magnifier instance. + * @param {ZoomRegion} zoomRegion: The zoomRegion to add. + */ + addZoomRegion(zoomRegion) { + if (zoomRegion) { + this._zoomRegions.push(zoomRegion); + if (!this.isTrackingMouse()) + this.startTrackingMouse(); + } + } + + /** + * getZoomRegions: + * Return a list of ZoomRegion's for this Magnifier. + * @returns {number[]} The Magnifier's zoom region list. + */ + getZoomRegions() { + return this._zoomRegions; + } + + /** + * clearAllZoomRegions: + * Remove all the zoom regions from this Magnfier's ZoomRegion list. + */ + clearAllZoomRegions() { + for (let i = 0; i < this._zoomRegions.length; i++) + this._zoomRegions[i].setActive(false); + + this._zoomRegions.length = 0; + this.stopTrackingMouse(); + this.showSystemCursor(); + } + + /** + * addCrosshairs: + * Add and show a cross hair centered on the magnified mouse. + */ + addCrosshairs() { + if (!this._crossHairs) + this._crossHairs = new Crosshairs(); + + let thickness = this._settings.get_int(CROSS_HAIRS_THICKNESS_KEY); + let color = this._settings.get_string(CROSS_HAIRS_COLOR_KEY); + let opacity = this._settings.get_double(CROSS_HAIRS_OPACITY_KEY); + let length = this._settings.get_int(CROSS_HAIRS_LENGTH_KEY); + let clip = this._settings.get_boolean(CROSS_HAIRS_CLIP_KEY); + + this.setCrosshairsThickness(thickness); + this.setCrosshairsColor(color); + this.setCrosshairsOpacity(opacity); + this.setCrosshairsLength(length); + this.setCrosshairsClip(clip); + + let theCrossHairs = this._crossHairs; + this._zoomRegions.forEach(zoomRegion => { + zoomRegion.addCrosshairs(theCrossHairs); + }); + } + + /** + * setCrosshairsVisible: + * Show or hide the cross hair. + * @param {bool} visible: Flag that indicates show (true) or hide (false). + */ + setCrosshairsVisible(visible) { + if (visible) { + if (!this._crossHairs) + this.addCrosshairs(); + this._crossHairs.show(); + } else { + // eslint-disable-next-line no-lonely-if + if (this._crossHairs) + this._crossHairs.hide(); + } + } + + /** + * setCrosshairsColor: + * Set the color of the crosshairs for all ZoomRegions. + * @param {string} color: The color as a string, e.g. '#ff0000ff' or 'red'. + */ + setCrosshairsColor(color) { + if (this._crossHairs) { + let [res_, clutterColor] = Clutter.Color.from_string(color); + this._crossHairs.setColor(clutterColor); + } + } + + /** + * getCrosshairsColor: + * Get the color of the crosshairs. + * @returns {string} The color as a string, e.g. '#0000ffff' or 'blue'. + */ + getCrosshairsColor() { + if (this._crossHairs) { + let clutterColor = this._crossHairs.getColor(); + return clutterColor.to_string(); + } else { + return '#00000000'; + } + } + + /** + * setCrosshairsThickness: + * Set the crosshairs thickness for all ZoomRegions. + * @param {number} thickness: The width of the vertical and + * horizontal lines of the crosshairs. + */ + setCrosshairsThickness(thickness) { + if (this._crossHairs) + this._crossHairs.setThickness(thickness); + } + + /** + * getCrosshairsThickness: + * Get the crosshairs thickness. + * @returns {number} The width of the vertical and horizontal + * lines of the crosshairs. + */ + getCrosshairsThickness() { + if (this._crossHairs) + return this._crossHairs.getThickness(); + else + return 0; + } + + /** + * setCrosshairsOpacity: + * @param {number} opacity: Value between 0.0 (transparent) + * and 1.0 (fully opaque). + */ + setCrosshairsOpacity(opacity) { + if (this._crossHairs) + this._crossHairs.setOpacity(opacity * 255); + } + + /** + * getCrosshairsOpacity: + * @returns {number} Value between 0.0 (transparent) and 1.0 (fully opaque). + */ + getCrosshairsOpacity() { + if (this._crossHairs) + return this._crossHairs.getOpacity() / 255.0; + else + return 0.0; + } + + /** + * setCrosshairsLength: + * Set the crosshairs length for all ZoomRegions. + * @param {number} length: The length of the vertical and horizontal + * lines making up the crosshairs. + */ + setCrosshairsLength(length) { + if (this._crossHairs) { + let scaleFactor = St.ThemeContext.get_for_stage(global.stage).scale_factor; + this._crossHairs.setLength(length / scaleFactor); + } + } + + /** + * getCrosshairsLength: + * Get the crosshairs length. + * @returns {number} The length of the vertical and horizontal + * lines making up the crosshairs. + */ + getCrosshairsLength() { + if (this._crossHairs) + return this._crossHairs.getLength(); + else + return 0; + } + + /** + * setCrosshairsClip: + * Set whether the crosshairs are clipped at their intersection. + * @param {bool} clip: Flag to indicate whether to clip the crosshairs. + */ + setCrosshairsClip(clip) { + if (!this._crossHairs) + return; + + // Setting no clipping on crosshairs means a zero sized clip rectangle. + this._crossHairs.setClip(clip ? CROSSHAIRS_CLIP_SIZE : [0, 0]); + } + + /** + * getCrosshairsClip: + * Get whether the crosshairs are clipped by the mouse image. + * @returns {bool} Whether the crosshairs are clipped. + */ + getCrosshairsClip() { + if (this._crossHairs) { + let [clipWidth, clipHeight] = this._crossHairs.getClip(); + return clipWidth > 0 && clipHeight > 0; + } else { + return false; + } + } + + // Private methods // + + _updateMouseSprite() { + this._updateSpriteTexture(); + let [xHot, yHot] = this._cursorTracker.get_hot(); + this._mouseSprite.set({ + translation_x: -xHot, + translation_y: -yHot, + }); + } + + _updateSpriteTexture() { + let sprite = this._cursorTracker.get_sprite(); + + if (sprite) { + this._mouseSprite.content.texture = sprite; + this._mouseSprite.show(); + } else { + this._mouseSprite.hide(); + } + } + + _settingsInit(zoomRegion) { + this._settings = new Gio.Settings({ schema_id: MAGNIFIER_SCHEMA }); + + this._settings.connect(`changed::${SCREEN_POSITION_KEY}`, + this._updateScreenPosition.bind(this)); + this._settings.connect(`changed::${MAG_FACTOR_KEY}`, + this._updateMagFactor.bind(this)); + this._settings.connect(`changed::${LENS_MODE_KEY}`, + this._updateLensMode.bind(this)); + this._settings.connect(`changed::${CLAMP_MODE_KEY}`, + this._updateClampMode.bind(this)); + this._settings.connect(`changed::${MOUSE_TRACKING_KEY}`, + this._updateMouseTrackingMode.bind(this)); + this._settings.connect(`changed::${FOCUS_TRACKING_KEY}`, + this._updateFocusTrackingMode.bind(this)); + this._settings.connect(`changed::${CARET_TRACKING_KEY}`, + this._updateCaretTrackingMode.bind(this)); + + this._settings.connect(`changed::${INVERT_LIGHTNESS_KEY}`, + this._updateInvertLightness.bind(this)); + this._settings.connect(`changed::${COLOR_SATURATION_KEY}`, + this._updateColorSaturation.bind(this)); + + this._settings.connect(`changed::${BRIGHT_RED_KEY}`, + this._updateBrightness.bind(this)); + this._settings.connect(`changed::${BRIGHT_GREEN_KEY}`, + this._updateBrightness.bind(this)); + this._settings.connect(`changed::${BRIGHT_BLUE_KEY}`, + this._updateBrightness.bind(this)); + + this._settings.connect(`changed::${CONTRAST_RED_KEY}`, + this._updateContrast.bind(this)); + this._settings.connect(`changed::${CONTRAST_GREEN_KEY}`, + this._updateContrast.bind(this)); + this._settings.connect(`changed::${CONTRAST_BLUE_KEY}`, + this._updateContrast.bind(this)); + + this._settings.connect(`changed::${SHOW_CROSS_HAIRS_KEY}`, () => { + this.setCrosshairsVisible(this._settings.get_boolean(SHOW_CROSS_HAIRS_KEY)); + }); + + this._settings.connect(`changed::${CROSS_HAIRS_THICKNESS_KEY}`, () => { + this.setCrosshairsThickness(this._settings.get_int(CROSS_HAIRS_THICKNESS_KEY)); + }); + + this._settings.connect(`changed::${CROSS_HAIRS_COLOR_KEY}`, () => { + this.setCrosshairsColor(this._settings.get_string(CROSS_HAIRS_COLOR_KEY)); + }); + + this._settings.connect(`changed::${CROSS_HAIRS_OPACITY_KEY}`, () => { + this.setCrosshairsOpacity(this._settings.get_double(CROSS_HAIRS_OPACITY_KEY)); + }); + + this._settings.connect(`changed::${CROSS_HAIRS_LENGTH_KEY}`, () => { + this.setCrosshairsLength(this._settings.get_int(CROSS_HAIRS_LENGTH_KEY)); + }); + + this._settings.connect(`changed::${CROSS_HAIRS_CLIP_KEY}`, () => { + this.setCrosshairsClip(this._settings.get_boolean(CROSS_HAIRS_CLIP_KEY)); + }); + + if (zoomRegion) { + // Mag factor is accurate to two decimal places. + let aPref = parseFloat(this._settings.get_double(MAG_FACTOR_KEY).toFixed(2)); + if (aPref != 0.0) + zoomRegion.setMagFactor(aPref, aPref); + + aPref = this._settings.get_enum(SCREEN_POSITION_KEY); + if (aPref) + zoomRegion.setScreenPosition(aPref); + + zoomRegion.setLensMode(this._settings.get_boolean(LENS_MODE_KEY)); + zoomRegion.setClampScrollingAtEdges(!this._settings.get_boolean(CLAMP_MODE_KEY)); + + aPref = this._settings.get_enum(MOUSE_TRACKING_KEY); + if (aPref) + zoomRegion.setMouseTrackingMode(aPref); + + aPref = this._settings.get_enum(FOCUS_TRACKING_KEY); + if (aPref) + zoomRegion.setFocusTrackingMode(aPref); + + aPref = this._settings.get_enum(CARET_TRACKING_KEY); + if (aPref) + zoomRegion.setCaretTrackingMode(aPref); + + aPref = this._settings.get_boolean(INVERT_LIGHTNESS_KEY); + if (aPref) + zoomRegion.setInvertLightness(aPref); + + aPref = this._settings.get_double(COLOR_SATURATION_KEY); + if (aPref) + zoomRegion.setColorSaturation(aPref); + + let bc = {}; + bc.r = this._settings.get_double(BRIGHT_RED_KEY); + bc.g = this._settings.get_double(BRIGHT_GREEN_KEY); + bc.b = this._settings.get_double(BRIGHT_BLUE_KEY); + zoomRegion.setBrightness(bc); + + bc.r = this._settings.get_double(CONTRAST_RED_KEY); + bc.g = this._settings.get_double(CONTRAST_GREEN_KEY); + bc.b = this._settings.get_double(CONTRAST_BLUE_KEY); + zoomRegion.setContrast(bc); + } + + let showCrosshairs = this._settings.get_boolean(SHOW_CROSS_HAIRS_KEY); + this.addCrosshairs(); + this.setCrosshairsVisible(showCrosshairs); + } + + _updateScreenPosition() { + // Applies only to the first zoom region. + if (this._zoomRegions.length) { + let position = this._settings.get_enum(SCREEN_POSITION_KEY); + this._zoomRegions[0].setScreenPosition(position); + if (position != GDesktopEnums.MagnifierScreenPosition.FULL_SCREEN) + this._updateLensMode(); + } + } + + _updateMagFactor() { + // Applies only to the first zoom region. + if (this._zoomRegions.length) { + // Mag factor is accurate to two decimal places. + let magFactor = parseFloat(this._settings.get_double(MAG_FACTOR_KEY).toFixed(2)); + this._zoomRegions[0].setMagFactor(magFactor, magFactor); + } + } + + _updateLensMode() { + // Applies only to the first zoom region. + if (this._zoomRegions.length) + this._zoomRegions[0].setLensMode(this._settings.get_boolean(LENS_MODE_KEY)); + } + + _updateClampMode() { + // Applies only to the first zoom region. + if (this._zoomRegions.length) { + this._zoomRegions[0].setClampScrollingAtEdges( + !this._settings.get_boolean(CLAMP_MODE_KEY)); + } + } + + _updateMouseTrackingMode() { + // Applies only to the first zoom region. + if (this._zoomRegions.length) { + this._zoomRegions[0].setMouseTrackingMode( + this._settings.get_enum(MOUSE_TRACKING_KEY)); + } + } + + _updateFocusTrackingMode() { + // Applies only to the first zoom region. + if (this._zoomRegions.length) { + this._zoomRegions[0].setFocusTrackingMode( + this._settings.get_enum(FOCUS_TRACKING_KEY)); + } + } + + _updateCaretTrackingMode() { + // Applies only to the first zoom region. + if (this._zoomRegions.length) { + this._zoomRegions[0].setCaretTrackingMode( + this._settings.get_enum(CARET_TRACKING_KEY)); + } + } + + _updateInvertLightness() { + // Applies only to the first zoom region. + if (this._zoomRegions.length) { + this._zoomRegions[0].setInvertLightness( + this._settings.get_boolean(INVERT_LIGHTNESS_KEY)); + } + } + + _updateColorSaturation() { + // Applies only to the first zoom region. + if (this._zoomRegions.length) { + this._zoomRegions[0].setColorSaturation( + this._settings.get_double(COLOR_SATURATION_KEY)); + } + } + + _updateBrightness() { + // Applies only to the first zoom region. + if (this._zoomRegions.length) { + let brightness = {}; + brightness.r = this._settings.get_double(BRIGHT_RED_KEY); + brightness.g = this._settings.get_double(BRIGHT_GREEN_KEY); + brightness.b = this._settings.get_double(BRIGHT_BLUE_KEY); + this._zoomRegions[0].setBrightness(brightness); + } + } + + _updateContrast() { + // Applies only to the first zoom region. + if (this._zoomRegions.length) { + let contrast = {}; + contrast.r = this._settings.get_double(CONTRAST_RED_KEY); + contrast.g = this._settings.get_double(CONTRAST_GREEN_KEY); + contrast.b = this._settings.get_double(CONTRAST_BLUE_KEY); + this._zoomRegions[0].setContrast(contrast); + } + } +}; +Signals.addSignalMethods(Magnifier.prototype); + +var ZoomRegion = class ZoomRegion { + constructor(magnifier, mouseSourceActor) { + this._magnifier = magnifier; + this._focusCaretTracker = new FocusCaretTracker.FocusCaretTracker(); + + this._mouseTrackingMode = GDesktopEnums.MagnifierMouseTrackingMode.NONE; + this._focusTrackingMode = GDesktopEnums.MagnifierFocusTrackingMode.NONE; + this._caretTrackingMode = GDesktopEnums.MagnifierCaretTrackingMode.NONE; + this._clampScrollingAtEdges = false; + this._lensMode = false; + this._screenPosition = GDesktopEnums.MagnifierScreenPosition.FULL_SCREEN; + this._invertLightness = false; + this._colorSaturation = 1.0; + this._brightness = { r: NO_CHANGE, g: NO_CHANGE, b: NO_CHANGE }; + this._contrast = { r: NO_CHANGE, g: NO_CHANGE, b: NO_CHANGE }; + + this._magView = null; + this._background = null; + this._uiGroupClone = null; + this._mouseSourceActor = mouseSourceActor; + this._mouseActor = null; + this._crossHairs = null; + this._crossHairsActor = null; + + this._viewPortX = 0; + this._viewPortY = 0; + this._viewPortWidth = global.screen_width; + this._viewPortHeight = global.screen_height; + this._xCenter = this._viewPortWidth / 2; + this._yCenter = this._viewPortHeight / 2; + this._xMagFactor = 1; + this._yMagFactor = 1; + this._followingCursor = false; + this._xFocus = 0; + this._yFocus = 0; + this._xCaret = 0; + this._yCaret = 0; + + this._pointerIdleMonitor = Meta.IdleMonitor.get_core(); + this._scrollContentsTimerId = 0; + } + + _connectSignals() { + if (this._signalConnections) + return; + + this._signalConnections = []; + let id = Main.layoutManager.connect('monitors-changed', + this._monitorsChanged.bind(this)); + this._signalConnections.push([Main.layoutManager, id]); + + id = this._focusCaretTracker.connect('caret-moved', this._updateCaret.bind(this)); + this._signalConnections.push([this._focusCaretTracker, id]); + + id = this._focusCaretTracker.connect('focus-changed', this._updateFocus.bind(this)); + this._signalConnections.push([this._focusCaretTracker, id]); + } + + _disconnectSignals() { + for (let [obj, id] of this._signalConnections) + obj.disconnect(id); + + delete this._signalConnections; + } + + _updateScreenPosition() { + if (this._screenPosition == GDesktopEnums.MagnifierScreenPosition.NONE) { + this._setViewPort({ + x: this._viewPortX, + y: this._viewPortY, + width: this._viewPortWidth, + height: this._viewPortHeight, + }); + } else { + this.setScreenPosition(this._screenPosition); + } + } + + _updateFocus(caller, event) { + let component = event.source.get_component_iface(); + if (!component || event.detail1 != 1) + return; + let extents; + try { + extents = component.get_extents(Atspi.CoordType.SCREEN); + } catch (e) { + log(`Failed to read extents of focused component: ${e.message}`); + return; + } + + let scaleFactor = St.ThemeContext.get_for_stage(global.stage).scale_factor; + let [xFocus, yFocus] = [(extents.x + (extents.width / 2)) * scaleFactor, + (extents.y + (extents.height / 2)) * scaleFactor]; + + if (this._xFocus !== xFocus || this._yFocus !== yFocus) { + [this._xFocus, this._yFocus] = [xFocus, yFocus]; + this._centerFromFocusPosition(); + } + } + + _updateCaret(caller, event) { + let text = event.source.get_text_iface(); + if (!text) + return; + let extents; + try { + extents = text.get_character_extents(text.get_caret_offset(), 0); + } catch (e) { + log(`Failed to read extents of text caret: ${e.message}`); + return; + } + + let scaleFactor = St.ThemeContext.get_for_stage(global.stage).scale_factor; + let [xCaret, yCaret] = [extents.x * scaleFactor, extents.y * scaleFactor]; + + // Ignore event(s) if the caret size is none (0x0). This happens a lot if + // the cursor offset can't be translated into a location. This is a work + // around. + if (extents.width === 0 && extents.height === 0) + return; + + if (this._xCaret !== xCaret || this._yCaret !== yCaret) { + [this._xCaret, this._yCaret] = [xCaret, yCaret]; + this._centerFromCaretPosition(); + } + } + + /** + * setActive: + * @param {bool} activate: Boolean to show/hide the ZoomRegion. + */ + setActive(activate) { + if (activate == this.isActive()) + return; + + if (activate) { + this._createActors(); + if (this._isMouseOverRegion()) + this._magnifier.hideSystemCursor(); + this._updateScreenPosition(); + this._updateMagViewGeometry(); + this._updateCloneGeometry(); + this._updateMousePosition(); + this._connectSignals(); + } else { + this._disconnectSignals(); + this._destroyActors(); + } + + this._syncCaretTracking(); + this._syncFocusTracking(); + } + + /** + * isActive: + * @returns {bool} Whether this ZoomRegion is active + */ + isActive() { + return this._magView != null; + } + + /** + * setMagFactor: + * @param {number} xMagFactor: The power to set the horizontal + * magnification factor to of the magnified view. A value of 1.0 + * means no magnification. A value of 2.0 doubles the size. + * @param {number} yMagFactor: The power to set the vertical + * magnification factor to of the magnified view. + */ + setMagFactor(xMagFactor, yMagFactor) { + this._changeROI({ xMagFactor, + yMagFactor, + redoCursorTracking: this._followingCursor, + animate: true }); + } + + /** + * getMagFactor: + * @returns {number[]} an array, [xMagFactor, yMagFactor], containing + * the horizontal and vertical magnification powers. A value of + * 1.0 means no magnification. A value of 2.0 means the contents + * are doubled in size, and so on. + */ + getMagFactor() { + return [this._xMagFactor, this._yMagFactor]; + } + + /** + * setMouseTrackingMode + * @param {GDesktopEnums.MagnifierMouseTrackingMode} mode: the new mode + */ + setMouseTrackingMode(mode) { + if (mode >= GDesktopEnums.MagnifierMouseTrackingMode.NONE && + mode <= GDesktopEnums.MagnifierMouseTrackingMode.PUSH) + this._mouseTrackingMode = mode; + } + + /** + * getMouseTrackingMode + * @returns {GDesktopEnums.MagnifierMouseTrackingMode} the current mode + */ + getMouseTrackingMode() { + return this._mouseTrackingMode; + } + + /** + * setFocusTrackingMode + * @param {GDesktopEnums.MagnifierFocusTrackingMode} mode: the new mode + */ + setFocusTrackingMode(mode) { + this._focusTrackingMode = mode; + this._syncFocusTracking(); + } + + /** + * setCaretTrackingMode + * @param {GDesktopEnums.MagnifierCaretTrackingMode} mode: the new mode + */ + setCaretTrackingMode(mode) { + this._caretTrackingMode = mode; + this._syncCaretTracking(); + } + + _syncFocusTracking() { + let enabled = this._focusTrackingMode != GDesktopEnums.MagnifierFocusTrackingMode.NONE && + this.isActive(); + + if (enabled) + this._focusCaretTracker.registerFocusListener(); + else + this._focusCaretTracker.deregisterFocusListener(); + } + + _syncCaretTracking() { + let enabled = this._caretTrackingMode != GDesktopEnums.MagnifierCaretTrackingMode.NONE && + this.isActive(); + + if (enabled) + this._focusCaretTracker.registerCaretListener(); + else + this._focusCaretTracker.deregisterCaretListener(); + } + + /** + * setViewPort + * Sets the position and size of the ZoomRegion on screen. + * @param {{x: number, y: number, width: number, height: number}} viewPort: + * Object defining the position and size of the view port. + * The values are in stage coordinate space. + */ + setViewPort(viewPort) { + this._setViewPort(viewPort); + this._screenPosition = GDesktopEnums.MagnifierScreenPosition.NONE; + } + + /** + * setROI + * Sets the "region of interest" that the ZoomRegion is magnifying. + * @param {{x: number, y: number, width: number, height: number}} roi: + * Object that defines the region of the screen to magnify. + * The values are in screen (unmagnified) coordinate space. + */ + setROI(roi) { + if (roi.width <= 0 || roi.height <= 0) + return; + + this._followingCursor = false; + this._changeROI({ xMagFactor: this._viewPortWidth / roi.width, + yMagFactor: this._viewPortHeight / roi.height, + xCenter: roi.x + roi.width / 2, + yCenter: roi.y + roi.height / 2 }); + } + + /** + * getROI: + * Retrieves the "region of interest" -- the rectangular bounds of that part + * of the desktop that the magnified view is showing (x, y, width, height). + * The bounds are given in non-magnified coordinates. + * @returns {number[]} an array, [x, y, width, height], representing + * the bounding rectangle of what is shown in the magnified view. + */ + getROI() { + let roiWidth = this._viewPortWidth / this._xMagFactor; + let roiHeight = this._viewPortHeight / this._yMagFactor; + + return [this._xCenter - roiWidth / 2, + this._yCenter - roiHeight / 2, + roiWidth, roiHeight]; + } + + /** + * setLensMode: + * Turn lens mode on/off. In full screen mode, lens mode does nothing since + * a lens the size of the screen is pointless. + * @param {bool} lensMode: Whether lensMode should be active + */ + setLensMode(lensMode) { + this._lensMode = lensMode; + if (!this._lensMode) + this.setScreenPosition(this._screenPosition); + } + + /** + * isLensMode: + * Is lens mode on or off? + * @returns {bool} The lens mode state. + */ + isLensMode() { + return this._lensMode; + } + + /** + * setClampScrollingAtEdges: + * Stop vs. allow scrolling of the magnified contents when it scroll beyond + * the edges of the screen. + * @param {bool} clamp: Boolean to turn on/off clamping. + */ + setClampScrollingAtEdges(clamp) { + this._clampScrollingAtEdges = clamp; + if (clamp) + this._changeROI(); + } + + /** + * setTopHalf: + * Magnifier view occupies the top half of the screen. + */ + setTopHalf() { + let viewPort = {}; + viewPort.x = 0; + viewPort.y = 0; + viewPort.width = global.screen_width; + viewPort.height = global.screen_height / 2; + this._setViewPort(viewPort); + this._screenPosition = GDesktopEnums.MagnifierScreenPosition.TOP_HALF; + } + + /** + * setBottomHalf: + * Magnifier view occupies the bottom half of the screen. + */ + setBottomHalf() { + let viewPort = {}; + viewPort.x = 0; + viewPort.y = global.screen_height / 2; + viewPort.width = global.screen_width; + viewPort.height = global.screen_height / 2; + this._setViewPort(viewPort); + this._screenPosition = GDesktopEnums.MagnifierScreenPosition.BOTTOM_HALF; + } + + /** + * setLeftHalf: + * Magnifier view occupies the left half of the screen. + */ + setLeftHalf() { + let viewPort = {}; + viewPort.x = 0; + viewPort.y = 0; + viewPort.width = global.screen_width / 2; + viewPort.height = global.screen_height; + this._setViewPort(viewPort); + this._screenPosition = GDesktopEnums.MagnifierScreenPosition.LEFT_HALF; + } + + /** + * setRightHalf: + * Magnifier view occupies the right half of the screen. + */ + setRightHalf() { + let viewPort = {}; + viewPort.x = global.screen_width / 2; + viewPort.y = 0; + viewPort.width = global.screen_width / 2; + viewPort.height = global.screen_height; + this._setViewPort(viewPort); + this._screenPosition = GDesktopEnums.MagnifierScreenPosition.RIGHT_HALF; + } + + /** + * setFullScreenMode: + * Set the ZoomRegion to full-screen mode. + * Note: disallows lens mode. + */ + setFullScreenMode() { + let viewPort = {}; + viewPort.x = 0; + viewPort.y = 0; + viewPort.width = global.screen_width; + viewPort.height = global.screen_height; + this.setViewPort(viewPort); + + this._screenPosition = GDesktopEnums.MagnifierScreenPosition.FULL_SCREEN; + } + + /** + * setScreenPosition: + * Positions the zoom region to one of the enumerated positions on the + * screen. + * @param {GDesktopEnums.MagnifierScreenPosition} inPosition: the position + */ + setScreenPosition(inPosition) { + switch (inPosition) { + case GDesktopEnums.MagnifierScreenPosition.FULL_SCREEN: + this.setFullScreenMode(); + break; + case GDesktopEnums.MagnifierScreenPosition.TOP_HALF: + this.setTopHalf(); + break; + case GDesktopEnums.MagnifierScreenPosition.BOTTOM_HALF: + this.setBottomHalf(); + break; + case GDesktopEnums.MagnifierScreenPosition.LEFT_HALF: + this.setLeftHalf(); + break; + case GDesktopEnums.MagnifierScreenPosition.RIGHT_HALF: + this.setRightHalf(); + break; + } + } + + /** + * getScreenPosition: + * Tell the outside world what the current mode is -- magnifiying the + * top half, bottom half, etc. + * @returns {GDesktopEnums.MagnifierScreenPosition}: the current position. + */ + getScreenPosition() { + return this._screenPosition; + } + + _clearScrollContentsTimer() { + if (this._scrollContentsTimerId !== 0) { + GLib.source_remove(this._scrollContentsTimerId); + this._scrollContentsTimerId = 0; + } + } + + /** + * scrollToMousePos: + * Set the region of interest based on the position of the system pointer. + * @returns {bool}: Whether the system mouse pointer is over the + * magnified view. + */ + scrollToMousePos() { + this._followingCursor = true; + if (this._mouseTrackingMode != GDesktopEnums.MagnifierMouseTrackingMode.NONE) + this._changeROI({ redoCursorTracking: true }); + else + this._updateMousePosition(); + + this._clearScrollContentsTimer(); + this._scrollContentsTimerId = GLib.timeout_add(GLib.PRIORITY_DEFAULT, POINTER_REST_TIME, () => { + this._followingCursor = false; + if (this._xDelayed !== null && this._yDelayed !== null) { + this._scrollContentsToDelayed(this._xDelayed, this._yDelayed); + this._xDelayed = null; + this._yDelayed = null; + } + + this._scrollContentsTimerId = 0; + + return GLib.SOURCE_REMOVE; + }); + + // Determine whether the system mouse pointer is over this zoom region. + return this._isMouseOverRegion(); + } + + _scrollContentsToDelayed(x, y) { + if (this._followingCursor) { + this._xDelayed = x; + this._yDelayed = y; + } else { + this.scrollContentsTo(x, y); + } + } + + /** + * scrollContentsTo: + * Shift the contents of the magnified view such it is centered on the given + * coordinate. + * @param {number} x: The x-coord of the point to center on. + * @param {number} y: The y-coord of the point to center on. + */ + scrollContentsTo(x, y) { + if (x < 0 || x > global.screen_width || + y < 0 || y > global.screen_height) + return; + + this._clearScrollContentsTimer(); + + this._followingCursor = false; + this._changeROI({ xCenter: x, + yCenter: y, + animate: true }); + } + + /** + * addCrosshairs: + * Add crosshairs centered on the magnified mouse. + * @param {Crosshairs} crossHairs: Crosshairs instance + */ + addCrosshairs(crossHairs) { + this._crossHairs = crossHairs; + + // If the crossHairs is not already within a larger container, add it + // to this zoom region. Otherwise, add a clone. + if (crossHairs && this.isActive()) + this._crossHairsActor = crossHairs.addToZoomRegion(this, this._mouseActor); + } + + /** + * setInvertLightness: + * Set whether to invert the lightness of the magnified view. + * @param {bool} flag: whether brightness should be inverted + */ + setInvertLightness(flag) { + this._invertLightness = flag; + if (this._magShaderEffects) + this._magShaderEffects.setInvertLightness(this._invertLightness); + } + + /** + * getInvertLightness: + * Retrieve whether the lightness is inverted. + * @returns {bool} whether brightness should be inverted + */ + getInvertLightness() { + return this._invertLightness; + } + + /** + * setColorSaturation: + * Set the color saturation of the magnified view. + * @param {number} saturation: A value from 0.0 to 1.0 that defines + * the color saturation, with 0.0 defining no color (grayscale), + * and 1.0 defining full color. + */ + setColorSaturation(saturation) { + this._colorSaturation = saturation; + if (this._magShaderEffects) + this._magShaderEffects.setColorSaturation(this._colorSaturation); + } + + /** + * getColorSaturation: + * Retrieve the color saturation of the magnified view. + * @returns {number} the color saturation + */ + getColorSaturation() { + return this._colorSaturation; + } + + /** + * setBrightness: + * Alter the brightness of the magnified view. + * @param {Object} brightness: Object containing the contrast for the + * red, green, and blue channels. Values of 0.0 represent "standard" + * brightness (no change), whereas values less or greater than + * 0.0 indicate decreased or incresaed brightness, respectively. + * + * {number} brightness.r - the red component + * {number} brightness.g - the green component + * {number} brightness.b - the blue component + */ + setBrightness(brightness) { + this._brightness.r = brightness.r; + this._brightness.g = brightness.g; + this._brightness.b = brightness.b; + if (this._magShaderEffects) + this._magShaderEffects.setBrightness(this._brightness); + } + + /** + * setContrast: + * Alter the contrast of the magnified view. + * @param {Object} contrast: Object containing the contrast for the + * red, green, and blue channels. Values of 0.0 represent "standard" + * contrast (no change), whereas values less or greater than + * 0.0 indicate decreased or incresaed contrast, respectively. + * + * {number} contrast.r - the red component + * {number} contrast.g - the green component + * {number} contrast.b - the blue component + */ + setContrast(contrast) { + this._contrast.r = contrast.r; + this._contrast.g = contrast.g; + this._contrast.b = contrast.b; + if (this._magShaderEffects) + this._magShaderEffects.setContrast(this._contrast); + } + + /** + * getContrast: + * Retrieve the contrast of the magnified view. + * @returns {{r: number, g: number, b: number}}: Object containing + * the contrast for the red, green, and blue channels. + */ + getContrast() { + let contrast = {}; + contrast.r = this._contrast.r; + contrast.g = this._contrast.g; + contrast.b = this._contrast.b; + return contrast; + } + + // Private methods // + + _createActors() { + // The root actor for the zoom region + this._magView = new St.Bin({ style_class: 'magnifier-zoom-region' }); + global.stage.add_actor(this._magView); + + // hide the magnified region from CLUTTER_PICK_ALL + Shell.util_set_hidden_from_pick(this._magView, true); + + // Add a group to clip the contents of the magnified view. + let mainGroup = new Clutter.Actor({ clip_to_allocation: true }); + this._magView.set_child(mainGroup); + + // Add a background for when the magnified uiGroup is scrolled + // out of view (don't want to see desktop showing through). + this._background = new Background.SystemBackground(); + mainGroup.add_actor(this._background); + + // Clone the group that contains all of UI on the screen. This is the + // chrome, the windows, etc. + this._uiGroupClone = new Clutter.Clone({ source: Main.uiGroup, + clip_to_allocation: true }); + mainGroup.add_actor(this._uiGroupClone); + + // Add either the given mouseSourceActor to the ZoomRegion, or a clone of + // it. + if (this._mouseSourceActor.get_parent() != null) + this._mouseActor = new Clutter.Clone({ source: this._mouseSourceActor }); + else + this._mouseActor = this._mouseSourceActor; + mainGroup.add_actor(this._mouseActor); + + if (this._crossHairs) + this._crossHairsActor = this._crossHairs.addToZoomRegion(this, this._mouseActor); + else + this._crossHairsActor = null; + + // Contrast and brightness effects. + this._magShaderEffects = new MagShaderEffects(mainGroup); + this._magShaderEffects.setColorSaturation(this._colorSaturation); + this._magShaderEffects.setInvertLightness(this._invertLightness); + this._magShaderEffects.setBrightness(this._brightness); + this._magShaderEffects.setContrast(this._contrast); + } + + _destroyActors() { + if (this._mouseActor == this._mouseSourceActor) + this._mouseActor.get_parent().remove_actor(this._mouseActor); + if (this._crossHairs) + this._crossHairs.removeFromParent(this._crossHairsActor); + + this._magShaderEffects.destroyEffects(); + this._magShaderEffects = null; + this._magView.destroy(); + this._magView = null; + this._background = null; + this._uiGroupClone = null; + this._mouseActor = null; + this._crossHairsActor = null; + } + + _setViewPort(viewPort, fromROIUpdate) { + // Sets the position of the zoom region on the screen + + let width = Math.round(Math.min(viewPort.width, global.screen_width)); + let height = Math.round(Math.min(viewPort.height, global.screen_height)); + let x = Math.max(viewPort.x, 0); + let y = Math.max(viewPort.y, 0); + + x = Math.round(Math.min(x, global.screen_width - width)); + y = Math.round(Math.min(y, global.screen_height - height)); + + this._viewPortX = x; + this._viewPortY = y; + this._viewPortWidth = width; + this._viewPortHeight = height; + + this._updateMagViewGeometry(); + + if (!fromROIUpdate) + this._changeROI({ redoCursorTracking: this._followingCursor }); // will update mouse + + if (this.isActive() && this._isMouseOverRegion()) + this._magnifier.hideSystemCursor(); + } + + _changeROI(params) { + // Updates the area we are viewing; the magnification factors + // and center can be set explicitly, or we can recompute + // the position based on the mouse cursor position + + params = Params.parse(params, { xMagFactor: this._xMagFactor, + yMagFactor: this._yMagFactor, + xCenter: this._xCenter, + yCenter: this._yCenter, + redoCursorTracking: false, + animate: false }); + + if (params.xMagFactor <= 0) + params.xMagFactor = this._xMagFactor; + if (params.yMagFactor <= 0) + params.yMagFactor = this._yMagFactor; + + this._xMagFactor = params.xMagFactor; + this._yMagFactor = params.yMagFactor; + + if (params.redoCursorTracking && + this._mouseTrackingMode != GDesktopEnums.MagnifierMouseTrackingMode.NONE) { + // This depends on this.xMagFactor/yMagFactor already being updated + [params.xCenter, params.yCenter] = this._centerFromMousePosition(); + } + + if (this._clampScrollingAtEdges) { + let roiWidth = this._viewPortWidth / this._xMagFactor; + let roiHeight = this._viewPortHeight / this._yMagFactor; + + params.xCenter = Math.min(params.xCenter, global.screen_width - roiWidth / 2); + params.xCenter = Math.max(params.xCenter, roiWidth / 2); + params.yCenter = Math.min(params.yCenter, global.screen_height - roiHeight / 2); + params.yCenter = Math.max(params.yCenter, roiHeight / 2); + } + + this._xCenter = params.xCenter; + this._yCenter = params.yCenter; + + // If in lens mode, move the magnified view such that it is centered + // over the actual mouse. However, in full screen mode, the "lens" is + // the size of the screen -- pointless to move such a large lens around. + if (this._lensMode && !this._isFullScreen()) { + this._setViewPort({ x: this._xCenter - this._viewPortWidth / 2, + y: this._yCenter - this._viewPortHeight / 2, + width: this._viewPortWidth, + height: this._viewPortHeight }, true); + } + + this._updateCloneGeometry(params.animate); + } + + _isMouseOverRegion() { + // Return whether the system mouse sprite is over this ZoomRegion. If the + // mouse's position is not given, then it is fetched. + let mouseIsOver = false; + if (this.isActive()) { + let xMouse = this._magnifier.xMouse; + let yMouse = this._magnifier.yMouse; + + mouseIsOver = + xMouse >= this._viewPortX && xMouse < (this._viewPortX + this._viewPortWidth) && + yMouse >= this._viewPortY && yMouse < (this._viewPortY + this._viewPortHeight); + } + return mouseIsOver; + } + + _isFullScreen() { + // Does the magnified view occupy the whole screen? Note that this + // doesn't necessarily imply + // this._screenPosition = GDesktopEnums.MagnifierScreenPosition.FULL_SCREEN; + + if (this._viewPortX != 0 || this._viewPortY != 0) + return false; + if (this._viewPortWidth != global.screen_width || + this._viewPortHeight != global.screen_height) + return false; + return true; + } + + _centerFromMousePosition() { + // Determines where the center should be given the current cursor + // position and mouse tracking mode + + let xMouse = this._magnifier.xMouse; + let yMouse = this._magnifier.yMouse; + + if (this._mouseTrackingMode == GDesktopEnums.MagnifierMouseTrackingMode.PROPORTIONAL) + return this._centerFromPointProportional(xMouse, yMouse); + else if (this._mouseTrackingMode == GDesktopEnums.MagnifierMouseTrackingMode.PUSH) + return this._centerFromPointPush(xMouse, yMouse); + else if (this._mouseTrackingMode == GDesktopEnums.MagnifierMouseTrackingMode.CENTERED) + return this._centerFromPointCentered(xMouse, yMouse); + + return null; // Should never be hit + } + + _centerFromCaretPosition() { + let xCaret = this._xCaret; + let yCaret = this._yCaret; + + if (this._caretTrackingMode == GDesktopEnums.MagnifierCaretTrackingMode.PROPORTIONAL) + [xCaret, yCaret] = this._centerFromPointProportional(xCaret, yCaret); + else if (this._caretTrackingMode == GDesktopEnums.MagnifierCaretTrackingMode.PUSH) + [xCaret, yCaret] = this._centerFromPointPush(xCaret, yCaret); + else if (this._caretTrackingMode == GDesktopEnums.MagnifierCaretTrackingMode.CENTERED) + [xCaret, yCaret] = this._centerFromPointCentered(xCaret, yCaret); + + this._scrollContentsToDelayed(xCaret, yCaret); + } + + _centerFromFocusPosition() { + let xFocus = this._xFocus; + let yFocus = this._yFocus; + + if (this._focusTrackingMode == GDesktopEnums.MagnifierFocusTrackingMode.PROPORTIONAL) + [xFocus, yFocus] = this._centerFromPointProportional(xFocus, yFocus); + else if (this._focusTrackingMode == GDesktopEnums.MagnifierFocusTrackingMode.PUSH) + [xFocus, yFocus] = this._centerFromPointPush(xFocus, yFocus); + else if (this._focusTrackingMode == GDesktopEnums.MagnifierFocusTrackingMode.CENTERED) + [xFocus, yFocus] = this._centerFromPointCentered(xFocus, yFocus); + + this._scrollContentsToDelayed(xFocus, yFocus); + } + + _centerFromPointPush(xPoint, yPoint) { + let [xRoi, yRoi, widthRoi, heightRoi] = this.getROI(); + let [cursorWidth, cursorHeight] = this._mouseSourceActor.get_size(); + let xPos = xRoi + widthRoi / 2; + let yPos = yRoi + heightRoi / 2; + let xRoiRight = xRoi + widthRoi - cursorWidth; + let yRoiBottom = yRoi + heightRoi - cursorHeight; + + if (xPoint < xRoi) + xPos -= xRoi - xPoint; + else if (xPoint > xRoiRight) + xPos += xPoint - xRoiRight; + + if (yPoint < yRoi) + yPos -= yRoi - yPoint; + else if (yPoint > yRoiBottom) + yPos += yPoint - yRoiBottom; + + return [xPos, yPos]; + } + + _centerFromPointProportional(xPoint, yPoint) { + let [xRoi_, yRoi_, widthRoi, heightRoi] = this.getROI(); + let halfScreenWidth = global.screen_width / 2; + let halfScreenHeight = global.screen_height / 2; + // We want to pad with a constant distance after zooming, so divide + // by the magnification factor. + let unscaledPadding = Math.min(this._viewPortWidth, this._viewPortHeight) / 5; + let xPadding = unscaledPadding / this._xMagFactor; + let yPadding = unscaledPadding / this._yMagFactor; + let xProportion = (xPoint - halfScreenWidth) / halfScreenWidth; // -1 ... 1 + let yProportion = (yPoint - halfScreenHeight) / halfScreenHeight; // -1 ... 1 + let xPos = xPoint - xProportion * (widthRoi / 2 - xPadding); + let yPos = yPoint - yProportion * (heightRoi / 2 - yPadding); + + return [xPos, yPos]; + } + + _centerFromPointCentered(xPoint, yPoint) { + return [xPoint, yPoint]; + } + + _screenToViewPort(screenX, screenY) { + // Converts coordinates relative to the (unmagnified) screen to coordinates + // relative to the origin of this._magView + return [this._viewPortWidth / 2 + (screenX - this._xCenter) * this._xMagFactor, + this._viewPortHeight / 2 + (screenY - this._yCenter) * this._yMagFactor]; + } + + _updateMagViewGeometry() { + if (!this.isActive()) + return; + + if (this._isFullScreen()) + this._magView.add_style_class_name('full-screen'); + else + this._magView.remove_style_class_name('full-screen'); + + this._magView.set_size(this._viewPortWidth, this._viewPortHeight); + this._magView.set_position(this._viewPortX, this._viewPortY); + } + + _updateCloneGeometry(animate = false) { + if (!this.isActive()) + return; + + let [x, y] = this._screenToViewPort(0, 0); + this._uiGroupClone.ease({ + x: Math.round(x), + y: Math.round(y), + scale_x: this._xMagFactor, + scale_y: this._yMagFactor, + mode: Clutter.AnimationMode.EASE_OUT_QUAD, + duration: animate ? 100 : 0, + }); + + let [mouseX, mouseY] = this._getMousePosition(); + this._mouseActor.ease({ + x: mouseX, + y: mouseY, + scale_x: this._xMagFactor, + scale_y: this._yMagFactor, + mode: Clutter.AnimationMode.EASE_OUT_QUAD, + duration: animate ? 100 : 0, + }); + + if (this._crossHairsActor) { + let [crossX, crossY] = this._getCrossHairsPosition(); + this._crossHairsActor.ease({ + x: crossX, + y: crossY, + mode: Clutter.AnimationMode.EASE_OUT_QUAD, + duration: animate ? 100 : 0, + }); + } + } + + _updateMousePosition() { + let [xMagMouse, yMagMouse] = this._getMousePosition(); + this._mouseActor.set_position(xMagMouse, yMagMouse); + + if (this._crossHairsActor) { + let [crossX, crossY] = this._getCrossHairsPosition(); + this._crossHairsActor.set_position(crossX, crossY); + } + } + + _getMousePosition() { + let [xMagMouse, yMagMouse] = this._screenToViewPort( + this._magnifier.xMouse, this._magnifier.yMouse); + return [Math.round(xMagMouse), Math.round(yMagMouse)]; + } + + _getCrossHairsPosition() { + let [xMagMouse, yMagMouse] = this._getMousePosition(); + let [groupWidth, groupHeight] = this._crossHairsActor.get_size(); + + return [xMagMouse - groupWidth / 2, yMagMouse - groupHeight / 2]; + } + + _monitorsChanged() { + this._background.set_size(global.screen_width, global.screen_height); + this._updateScreenPosition(); + } +}; + +var Crosshairs = GObject.registerClass( +class Crosshairs extends Clutter.Actor { + _init() { + + // Set the group containing the crosshairs to three times the desktop + // size in case the crosshairs need to appear to be infinite in + // length (i.e., extend beyond the edges of the view they appear in). + let groupWidth = global.screen_width * 3; + let groupHeight = global.screen_height * 3; + + super._init({ + clip_to_allocation: false, + width: groupWidth, + height: groupHeight, + }); + this._horizLeftHair = new Clutter.Actor(); + this._horizRightHair = new Clutter.Actor(); + this._vertTopHair = new Clutter.Actor(); + this._vertBottomHair = new Clutter.Actor(); + this.add_actor(this._horizLeftHair); + this.add_actor(this._horizRightHair); + this.add_actor(this._vertTopHair); + this.add_actor(this._vertBottomHair); + this._clipSize = [0, 0]; + this._clones = []; + this.reCenter(); + this._monitorsChangedId = 0; + } + + _monitorsChanged() { + this.set_size(global.screen_width * 3, global.screen_height * 3); + this.reCenter(); + } + + setEnabled(enabled) { + if (enabled && this._monitorsChangedId === 0) { + this._monitorsChangedId = Main.layoutManager.connect( + 'monitors-changed', this._monitorsChanged.bind(this)); + } else if (!enabled && this._monitorsChangedId !== 0) { + Main.layoutManager.disconnect(this._monitorsChangedId); + this._monitorsChangedId = 0; + } + } + + /** + * addToZoomRegion + * Either add the crosshairs actor to the given ZoomRegion, or, if it is + * already part of some other ZoomRegion, create a clone of the crosshairs + * actor, and add the clone instead. Returns either the original or the + * clone. + * @param {ZoomRegion} zoomRegion: The container to add the crosshairs + * group to. + * @param {Clutter.Actor} magnifiedMouse: The mouse actor for the + * zoom region -- used to position the crosshairs and properly + * layer them below the mouse. + * @returns {Clutter.Actor} The crosshairs actor, or its clone. + */ + addToZoomRegion(zoomRegion, magnifiedMouse) { + let crosshairsActor = null; + if (zoomRegion && magnifiedMouse) { + let container = magnifiedMouse.get_parent(); + if (container) { + crosshairsActor = this; + if (this.get_parent() != null) { + crosshairsActor = new Clutter.Clone({ source: this }); + this._clones.push(crosshairsActor); + + // Clones don't share visibility. + this.bind_property('visible', crosshairsActor, 'visible', + GObject.BindingFlags.SYNC_CREATE); + } + + container.add_actor(crosshairsActor); + container.set_child_above_sibling(magnifiedMouse, crosshairsActor); + let [xMouse, yMouse] = magnifiedMouse.get_position(); + let [crosshairsWidth, crosshairsHeight] = crosshairsActor.get_size(); + crosshairsActor.set_position(xMouse - crosshairsWidth / 2, yMouse - crosshairsHeight / 2); + } + } + return crosshairsActor; + } + + /** + * removeFromParent: + * @param {Clutter.Actor} childActor: the actor returned from + * addToZoomRegion + * Remove the crosshairs actor from its parent container, or destroy the + * child actor if it was just a clone of the crosshairs actor. + */ + removeFromParent(childActor) { + if (childActor == this) + childActor.get_parent().remove_actor(childActor); + else + childActor.destroy(); + } + + /** + * setColor: + * Set the color of the crosshairs. + * @param {Clutter.Color} clutterColor: The color + */ + setColor(clutterColor) { + this._horizLeftHair.background_color = clutterColor; + this._horizRightHair.background_color = clutterColor; + this._vertTopHair.background_color = clutterColor; + this._vertBottomHair.background_color = clutterColor; + } + + /** + * getColor: + * Get the color of the crosshairs. + * @returns {ClutterColor} the crosshairs color + */ + getColor() { + return this._horizLeftHair.get_color(); + } + + /** + * setThickness: + * Set the width of the vertical and horizontal lines of the crosshairs. + * @param {number} thickness: the new thickness value + */ + setThickness(thickness) { + this._horizLeftHair.set_height(thickness); + this._horizRightHair.set_height(thickness); + this._vertTopHair.set_width(thickness); + this._vertBottomHair.set_width(thickness); + this.reCenter(); + } + + /** + * getThickness: + * Get the width of the vertical and horizontal lines of the crosshairs. + * @returns {number} The thickness of the crosshairs. + */ + getThickness() { + return this._horizLeftHair.get_height(); + } + + /** + * setOpacity: + * Set how opaque the crosshairs are. + * @param {number} opacity: Value between 0 (fully transparent) + * and 255 (full opaque). + */ + setOpacity(opacity) { + // set_opacity() throws an exception for values outside the range + // [0, 255]. + if (opacity < 0) + opacity = 0; + else if (opacity > 255) + opacity = 255; + + this._horizLeftHair.set_opacity(opacity); + this._horizRightHair.set_opacity(opacity); + this._vertTopHair.set_opacity(opacity); + this._vertBottomHair.set_opacity(opacity); + } + + /** + * setLength: + * Set the length of the vertical and horizontal lines in the crosshairs. + * @param {number} length: The length of the crosshairs. + */ + setLength(length) { + this._horizLeftHair.set_width(length); + this._horizRightHair.set_width(length); + this._vertTopHair.set_height(length); + this._vertBottomHair.set_height(length); + this.reCenter(); + } + + /** + * getLength: + * Get the length of the vertical and horizontal lines in the crosshairs. + * @returns {number} The length of the crosshairs. + */ + getLength() { + return this._horizLeftHair.get_width(); + } + + /** + * setClip: + * Set the width and height of the rectangle that clips the crosshairs at + * their intersection + * @param {number[]} size: Array of [width, height] defining the size + * of the clip rectangle. + */ + setClip(size) { + if (size) { + // Take a chunk out of the crosshairs where it intersects the + // mouse. + this._clipSize = size; + this.reCenter(); + } else { + // Restore the missing chunk. + this._clipSize = [0, 0]; + this.reCenter(); + } + } + + /** + * reCenter: + * Reposition the horizontal and vertical hairs such that they cross at + * the center of crosshairs group. If called with the dimensions of + * the clip rectangle, these are used to update the size of the clip. + * @param {number[]=} clipSize: If present, the clip's [width, height]. + */ + reCenter(clipSize) { + let [groupWidth, groupHeight] = this.get_size(); + let leftLength = this._horizLeftHair.get_width(); + let topLength = this._vertTopHair.get_height(); + let thickness = this._horizLeftHair.get_height(); + + // Deal with clip rectangle. + if (clipSize) + this._clipSize = clipSize; + let clipWidth = this._clipSize[0]; + let clipHeight = this._clipSize[1]; + + let left = groupWidth / 2 - clipWidth / 2 - leftLength - thickness / 2; + let right = groupWidth / 2 + clipWidth / 2 + thickness / 2; + let top = groupHeight / 2 - clipHeight / 2 - topLength - thickness / 2; + let bottom = groupHeight / 2 + clipHeight / 2 + thickness / 2; + this._horizLeftHair.set_position(left, (groupHeight - thickness) / 2); + this._horizRightHair.set_position(right, (groupHeight - thickness) / 2); + this._vertTopHair.set_position((groupWidth - thickness) / 2, top); + this._vertBottomHair.set_position((groupWidth - thickness) / 2, bottom); + } +}); + +var MagShaderEffects = class MagShaderEffects { + constructor(uiGroupClone) { + this._inverse = new Shell.InvertLightnessEffect(); + this._brightnessContrast = new Clutter.BrightnessContrastEffect(); + this._colorDesaturation = new Clutter.DesaturateEffect(); + this._inverse.set_enabled(false); + this._brightnessContrast.set_enabled(false); + + this._magView = uiGroupClone; + this._magView.add_effect(this._inverse); + this._magView.add_effect(this._brightnessContrast); + this._magView.add_effect(this._colorDesaturation); + } + + /** + * destroyEffects: + * Remove contrast and brightness effects from the magnified view, and + * lose the reference to the actor they were applied to. Don't use this + * object after calling this. + */ + destroyEffects() { + this._magView.clear_effects(); + this._colorDesaturation = null; + this._brightnessContrast = null; + this._inverse = null; + this._magView = null; + } + + /** + * setInvertLightness: + * Enable/disable invert lightness effect. + * @param {bool} invertFlag: Enabled flag. + */ + setInvertLightness(invertFlag) { + this._inverse.set_enabled(invertFlag); + } + + setColorSaturation(factor) { + this._colorDesaturation.set_factor(1.0 - factor); + } + + /** + * setBrightness: + * Set the brightness of the magnified view. + * @param {Object} brightness: Object containing the contrast for the + * red, green, and blue channels. Values of 0.0 represent "standard" + * brightness (no change), whereas values less or greater than + * 0.0 indicate decreased or incresaed brightness, respectively. + * + * {number} brightness.r - the red component + * {number} brightness.g - the green component + * {number} brightness.b - the blue component + */ + setBrightness(brightness) { + let bRed = brightness.r; + let bGreen = brightness.g; + let bBlue = brightness.b; + this._brightnessContrast.set_brightness_full(bRed, bGreen, bBlue); + + // Enable the effect if the brightness OR contrast change are such that + // it modifies the brightness and/or contrast. + let [cRed, cGreen, cBlue] = this._brightnessContrast.get_contrast(); + this._brightnessContrast.set_enabled( + bRed !== NO_CHANGE || bGreen !== NO_CHANGE || bBlue !== NO_CHANGE || + cRed !== NO_CHANGE || cGreen !== NO_CHANGE || cBlue !== NO_CHANGE); + } + + /** + * Set the contrast of the magnified view. + * @param {Object} contrast: Object containing the contrast for the + * red, green, and blue channels. Values of 0.0 represent "standard" + * contrast (no change), whereas values less or greater than + * 0.0 indicate decreased or incresaed contrast, respectively. + * + * {number} contrast.r - the red component + * {number} contrast.g - the green component + * {number} contrast.b - the blue component + */ + setContrast(contrast) { + let cRed = contrast.r; + let cGreen = contrast.g; + let cBlue = contrast.b; + + this._brightnessContrast.set_contrast_full(cRed, cGreen, cBlue); + + // Enable the effect if the contrast OR brightness change are such that + // it modifies the brightness and/or contrast. + // should be able to use Clutter.color_equal(), but that complains of + // a null first argument. + let [bRed, bGreen, bBlue] = this._brightnessContrast.get_brightness(); + this._brightnessContrast.set_enabled( + cRed !== NO_CHANGE || cGreen !== NO_CHANGE || cBlue !== NO_CHANGE || + bRed !== NO_CHANGE || bGreen !== NO_CHANGE || bBlue !== NO_CHANGE); + } +}; |