6ed5bc2f6c
We are currently inconsistent on whether case labels share the same indentation level as the corresponding switch statement or not. gjs goes with the default of no additional indentation, so go along with that. https://gitlab.gnome.org/GNOME/gnome-shell/merge_requests/608
1926 lines
66 KiB
JavaScript
1926 lines
66 KiB
JavaScript
// -*- mode: js; js-indent-level: 4; indent-tabs-mode: nil -*-
|
|
|
|
const { Atspi, Clutter, GDesktopEnums,
|
|
Gio, GLib, GObject, Meta, Shell, St } = imports.gi;
|
|
const Mainloop = imports.mainloop;
|
|
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) {
|
|
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();
|
|
|
|
this._cursorRoot = new Clutter.Actor();
|
|
this._cursorRoot.add_actor(this._mouseSprite);
|
|
|
|
// Create the first ZoomRegion and initialize it according to the
|
|
// magnification settings.
|
|
|
|
let mask;
|
|
[this.xMouse, this.yMouse, mask] = global.get_pointer();
|
|
|
|
let aZoomRegion = new ZoomRegion(this, this._cursorRoot);
|
|
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() {
|
|
this._cursorTracker.set_pointer_visible(true);
|
|
}
|
|
|
|
/**
|
|
* hideSystemCursor:
|
|
* Hide the system mouse pointer.
|
|
*/
|
|
hideSystemCursor() {
|
|
this._cursorTracker.set_pointer_visible(false);
|
|
}
|
|
|
|
/**
|
|
* setActive:
|
|
* Show/hide all the zoom regions.
|
|
* @activate: Boolean to activate or de-activate the magnifier.
|
|
*/
|
|
setActive(activate) {
|
|
let isActive = this.isActive();
|
|
|
|
this._zoomRegions.forEach((zoomRegion, index, array) => {
|
|
zoomRegion.setActive(activate);
|
|
});
|
|
|
|
if (isActive != activate) {
|
|
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();
|
|
}
|
|
}
|
|
|
|
// Make sure system mouse pointer is shown when all zoom regions are
|
|
// invisible.
|
|
if (!activate)
|
|
this._cursorTracker.set_pointer_visible(true);
|
|
|
|
// Notify interested parties of this change
|
|
this.emit('active-changed', activate);
|
|
}
|
|
|
|
/**
|
|
* isActive:
|
|
* @return Whether the magnifier is active (boolean).
|
|
*/
|
|
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:
|
|
* Is the magnifier tracking the mouse currently?
|
|
*/
|
|
isTrackingMouse() {
|
|
return !!this._mouseTrackingId;
|
|
}
|
|
|
|
/**
|
|
* scrollToMousePos:
|
|
* Position all zoom regions' ROI relative to the current location of the
|
|
* system pointer.
|
|
* @return true.
|
|
*/
|
|
scrollToMousePos() {
|
|
let [xMouse, yMouse, mask] = global.get_pointer();
|
|
|
|
if (xMouse != this.xMouse || yMouse != this.yMouse) {
|
|
this.xMouse = xMouse;
|
|
this.yMouse = yMouse;
|
|
|
|
let sysMouseOverAny = false;
|
|
this._zoomRegions.forEach((zoomRegion, index, array) => {
|
|
if (zoomRegion.scrollToMousePos())
|
|
sysMouseOverAny = true;
|
|
});
|
|
if (sysMouseOverAny)
|
|
this.hideSystemCursor();
|
|
else
|
|
this.showSystemCursor();
|
|
}
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* createZoomRegion:
|
|
* Create a ZoomRegion instance with the given properties.
|
|
* @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.
|
|
* @yMagFactor: The power to set the vertical magnification of the
|
|
* ZoomRegion.
|
|
* @roi Object in the form { x, y, width, height } that
|
|
* defines the region to magnify. Given in unmagnified
|
|
* coordinates.
|
|
* @viewPort Object in the form { x, y, width, height } that defines
|
|
* the position of the ZoomRegion on screen.
|
|
* @return The newly created ZoomRegion.
|
|
*/
|
|
createZoomRegion(xMagFactor, yMagFactor, roi, viewPort) {
|
|
let zoomRegion = new ZoomRegion(this, this._cursorRoot);
|
|
zoomRegion.setViewPort(viewPort);
|
|
|
|
// We ignore the redundant width/height on the ROI
|
|
let fixedROI = new Object(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.
|
|
* @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.
|
|
* @return: The Magnifier's zoom region list (array).
|
|
*/
|
|
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, index, array) => {
|
|
zoomRegion.addCrosshairs(theCrossHairs);
|
|
});
|
|
}
|
|
|
|
/**
|
|
* setCrosshairsVisible:
|
|
* Show or hide the cross hair.
|
|
* @visible Flag that indicates show (true) or hide (false).
|
|
*/
|
|
setCrosshairsVisible(visible) {
|
|
if (visible) {
|
|
if (!this._crossHairs)
|
|
this.addCrosshairs();
|
|
this._crossHairs.show();
|
|
} else {
|
|
if (this._crossHairs)
|
|
this._crossHairs.hide();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* setCrosshairsColor:
|
|
* Set the color of the crosshairs for all ZoomRegions.
|
|
* @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.
|
|
* @return: 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.
|
|
* @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.
|
|
* @return: The width of the vertical and horizontal lines of the
|
|
* crosshairs.
|
|
*/
|
|
getCrosshairsThickness() {
|
|
if (this._crossHairs)
|
|
return this._crossHairs.getThickness();
|
|
else
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* setCrosshairsOpacity:
|
|
* @opacity: Value between 0.0 (transparent) and 1.0 (fully opaque).
|
|
*/
|
|
setCrosshairsOpacity(opacity) {
|
|
if (this._crossHairs)
|
|
this._crossHairs.setOpacity(opacity * 255);
|
|
}
|
|
|
|
/**
|
|
* getCrosshairsOpacity:
|
|
* @return: 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.
|
|
* @length: The length of the vertical and horizontal lines making up the
|
|
* crosshairs.
|
|
*/
|
|
setCrosshairsLength(length) {
|
|
if (this._crossHairs)
|
|
this._crossHairs.setLength(length);
|
|
}
|
|
|
|
/**
|
|
* getCrosshairsLength:
|
|
* Get the crosshairs length.
|
|
* @return: 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.
|
|
* @clip: Flag to indicate whether to clip the crosshairs.
|
|
*/
|
|
setCrosshairsClip(clip) {
|
|
if (clip) {
|
|
if (this._crossHairs)
|
|
this._crossHairs.setClip(CROSSHAIRS_CLIP_SIZE);
|
|
} else {
|
|
// Setting no clipping on crosshairs means a zero sized clip
|
|
// rectangle.
|
|
if (this._crossHairs)
|
|
this._crossHairs.setClip([0, 0]);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* getCrosshairsClip:
|
|
* Get whether the crosshairs are clipped by the mouse image.
|
|
* @return: 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_anchor_point(xHot, 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_for_device(Meta.VIRTUAL_CORE_POINTER_ID);
|
|
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;
|
|
}
|
|
|
|
[this._xFocus, this._yFocus] = [extents.x + (extents.width / 2),
|
|
extents.y + (extents.height / 2)];
|
|
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;
|
|
}
|
|
|
|
[this._xCaret, this._yCaret] = [extents.x, extents.y];
|
|
this._centerFromCaretPosition();
|
|
}
|
|
|
|
/**
|
|
* setActive:
|
|
* @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:
|
|
* @return Whether this ZoomRegion is active (boolean).
|
|
*/
|
|
isActive() {
|
|
return this._magView != null;
|
|
}
|
|
|
|
/**
|
|
* setMagFactor:
|
|
* @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.
|
|
* @yMagFactor: The power to set the vertical magnification factor to
|
|
* of the magnified view.
|
|
*/
|
|
setMagFactor(xMagFactor, yMagFactor) {
|
|
this._changeROI({ xMagFactor: xMagFactor,
|
|
yMagFactor: yMagFactor,
|
|
redoCursorTracking: this._followingCursor });
|
|
}
|
|
|
|
/**
|
|
* getMagFactor:
|
|
* @return 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
|
|
* @mode: One of the enum MouseTrackingMode values.
|
|
*/
|
|
setMouseTrackingMode(mode) {
|
|
if (mode >= GDesktopEnums.MagnifierMouseTrackingMode.NONE &&
|
|
mode <= GDesktopEnums.MagnifierMouseTrackingMode.PUSH)
|
|
this._mouseTrackingMode = mode;
|
|
}
|
|
|
|
/**
|
|
* getMouseTrackingMode
|
|
* @return: One of the enum MouseTrackingMode values.
|
|
*/
|
|
getMouseTrackingMode() {
|
|
return this._mouseTrackingMode;
|
|
}
|
|
|
|
/**
|
|
* setFocusTrackingMode
|
|
* @mode: One of the enum FocusTrackingMode values.
|
|
*/
|
|
setFocusTrackingMode(mode) {
|
|
this._focusTrackingMode = mode;
|
|
this._syncFocusTracking();
|
|
}
|
|
|
|
/**
|
|
* setCaretTrackingMode
|
|
* @mode: One of the enum CaretTrackingMode values.
|
|
*/
|
|
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.
|
|
* @viewPort: Object defining the position and size of the view port.
|
|
* It has members x, y, width, height. 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.
|
|
* @roi: Object that defines the region of the screen to magnify. It
|
|
* has members x, y, width, height. 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.
|
|
* @return 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.
|
|
* @lensMode: A boolean to set the sense of lens mode.
|
|
*/
|
|
setLensMode(lensMode) {
|
|
this._lensMode = lensMode;
|
|
if (!this._lensMode)
|
|
this.setScreenPosition (this._screenPosition);
|
|
}
|
|
|
|
/**
|
|
* isLensMode:
|
|
* Is lens mode on or off?
|
|
* @return The lens mode state as a boolean.
|
|
*/
|
|
isLensMode() {
|
|
return this._lensMode;
|
|
}
|
|
|
|
/**
|
|
* setClampScrollingAtEdges:
|
|
* Stop vs. allow scrolling of the magnified contents when it scroll beyond
|
|
* the edges of the screen.
|
|
* @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.
|
|
* @position: one of Magnifier.FULL_SCREEN, Magnifier.TOP_HALF,
|
|
* Magnifier.BOTTOM_HALF,Magnifier.LEFT_HALF, or
|
|
* Magnifier.RIGHT_HALF.
|
|
*/
|
|
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.
|
|
* @return: the current mode.
|
|
*/
|
|
getScreenPosition() {
|
|
return this._screenPosition;
|
|
}
|
|
|
|
/**
|
|
* scrollToMousePos:
|
|
* Set the region of interest based on the position of the system pointer.
|
|
* @return: 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();
|
|
|
|
// Determine whether the system mouse pointer is over this zoom region.
|
|
return this._isMouseOverRegion();
|
|
}
|
|
|
|
_clearScrollContentsTimer() {
|
|
if (this._scrollContentsTimerId != 0) {
|
|
Mainloop.source_remove(this._scrollContentsTimerId);
|
|
this._scrollContentsTimerId = 0;
|
|
}
|
|
}
|
|
|
|
_scrollContentsToDelayed(x, y) {
|
|
if (this._pointerIdleMonitor.get_idletime() >= POINTER_REST_TIME) {
|
|
this.scrollContentsTo(x, y);
|
|
return;
|
|
}
|
|
|
|
this._clearScrollContentsTimer();
|
|
this._scrollContentsTimerId = Mainloop.timeout_add(POINTER_REST_TIME, () => {
|
|
this._scrollContentsToDelayed(x, y);
|
|
return GLib.SOURCE_REMOVE;
|
|
});
|
|
}
|
|
|
|
/**
|
|
* scrollContentsTo:
|
|
* Shift the contents of the magnified view such it is centered on the given
|
|
* coordinate.
|
|
* @x: The x-coord of the point to center on.
|
|
* @y: The y-coord of the point to center on.
|
|
*/
|
|
scrollContentsTo(x, y) {
|
|
this._clearScrollContentsTimer();
|
|
|
|
this._followingCursor = false;
|
|
this._changeROI({ xCenter: x,
|
|
yCenter: y });
|
|
}
|
|
|
|
/**
|
|
* addCrosshairs:
|
|
* Add crosshairs centered on the magnified mouse.
|
|
* @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.
|
|
* @flag Boolean to either invert brightness (true), or not (false).
|
|
*/
|
|
setInvertLightness(flag) {
|
|
this._invertLightness = flag;
|
|
if (this._magShaderEffects)
|
|
this._magShaderEffects.setInvertLightness(this._invertLightness);
|
|
}
|
|
|
|
/**
|
|
* getInvertLightness:
|
|
* Retrieve whether the lightness is inverted.
|
|
* @return Boolean indicating inversion (true), or not (false).
|
|
*/
|
|
getInvertLightness() {
|
|
return this._invertLightness;
|
|
}
|
|
|
|
/**
|
|
* setColorSaturation:
|
|
* Set the color saturation of the magnified view.
|
|
* @sauration 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.
|
|
*/
|
|
getColorSaturation() {
|
|
return this._colorSaturation;
|
|
}
|
|
|
|
/**
|
|
* setBrightness:
|
|
* Alter the brightness of the magnified view.
|
|
* @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.
|
|
*/
|
|
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.
|
|
* @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.
|
|
*/
|
|
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.
|
|
* @return 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', x_fill: true, y_fill: true });
|
|
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()).actor;
|
|
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(this._uiGroupClone);
|
|
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 });
|
|
|
|
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();
|
|
this._updateMousePosition();
|
|
}
|
|
|
|
_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() {
|
|
if (!this.isActive())
|
|
return;
|
|
|
|
this._uiGroupClone.set_scale(this._xMagFactor, this._yMagFactor);
|
|
this._mouseActor.set_scale(this._xMagFactor, this._yMagFactor);
|
|
|
|
let [x, y] = this._screenToViewPort(0, 0);
|
|
this._uiGroupClone.set_position(Math.round(x), Math.round(y));
|
|
|
|
this._updateMousePosition();
|
|
}
|
|
|
|
_updateMousePosition() {
|
|
if (!this.isActive())
|
|
return;
|
|
|
|
let [xMagMouse, yMagMouse] = this._screenToViewPort(this._magnifier.xMouse,
|
|
this._magnifier.yMouse);
|
|
|
|
xMagMouse = Math.round(xMagMouse);
|
|
yMagMouse = Math.round(yMagMouse);
|
|
|
|
this._mouseActor.set_position(xMagMouse, yMagMouse);
|
|
|
|
if (this._crossHairsActor) {
|
|
let [groupWidth, groupHeight] = this._crossHairsActor.get_size();
|
|
this._crossHairsActor.set_position(xMagMouse - groupWidth / 2,
|
|
yMagMouse - groupHeight / 2);
|
|
}
|
|
}
|
|
|
|
_monitorsChanged() {
|
|
this._background.set_size(global.screen_width, global.screen_height);
|
|
this._updateScreenPosition();
|
|
}
|
|
};
|
|
|
|
var Crosshairs = class Crosshairs {
|
|
constructor() {
|
|
|
|
// 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;
|
|
|
|
this._actor = new Clutter.Actor({
|
|
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._actor.add_actor(this._horizLeftHair);
|
|
this._actor.add_actor(this._horizRightHair);
|
|
this._actor.add_actor(this._vertTopHair);
|
|
this._actor.add_actor(this._vertBottomHair);
|
|
this._clipSize = [0, 0];
|
|
this._clones = [];
|
|
this.reCenter();
|
|
|
|
Main.layoutManager.connect('monitors-changed',
|
|
this._monitorsChanged.bind(this));
|
|
}
|
|
|
|
_monitorsChanged() {
|
|
this._actor.set_size(global.screen_width * 3, global.screen_height * 3);
|
|
this.reCenter();
|
|
}
|
|
|
|
/**
|
|
* 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.
|
|
* @zoomRegion: The container to add the crosshairs group to.
|
|
* @magnifiedMouse: The mouse actor for the zoom region -- used to
|
|
* position the crosshairs and properly layer them below
|
|
* the mouse.
|
|
* @return The crosshairs actor, or its clone.
|
|
*/
|
|
addToZoomRegion(zoomRegion, magnifiedMouse) {
|
|
let crosshairsActor = null;
|
|
if (zoomRegion && magnifiedMouse) {
|
|
let container = magnifiedMouse.get_parent();
|
|
if (container) {
|
|
crosshairsActor = this._actor;
|
|
if (this._actor.get_parent() != null) {
|
|
crosshairsActor = new Clutter.Clone({ source: this._actor });
|
|
this._clones.push(crosshairsActor);
|
|
}
|
|
crosshairsActor.visible = this._actor.visible;
|
|
|
|
container.add_actor(crosshairsActor);
|
|
container.raise_child(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:
|
|
* @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._actor)
|
|
childActor.get_parent().remove_actor(childActor);
|
|
else
|
|
childActor.destroy();
|
|
}
|
|
|
|
/**
|
|
* setColor:
|
|
* Set the color of the crosshairs.
|
|
* @clutterColor: The color as a Clutter.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.
|
|
* @color: The color as a Clutter.Color.
|
|
*/
|
|
getColor() {
|
|
return this._horizLeftHair.get_color();
|
|
}
|
|
|
|
/**
|
|
* setThickness:
|
|
* Set the width of the vertical and horizontal lines of the crosshairs.
|
|
* @thickness
|
|
*/
|
|
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.
|
|
* @return: The thickness of the crosshairs.
|
|
*/
|
|
getThickness() {
|
|
return this._horizLeftHair.get_height();
|
|
}
|
|
|
|
/**
|
|
* setOpacity:
|
|
* Set how opaque the crosshairs are.
|
|
* @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.
|
|
* @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.
|
|
* @return: 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
|
|
* @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();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* show:
|
|
* Show the crosshairs.
|
|
*/
|
|
show() {
|
|
this._actor.show();
|
|
// Clones don't share visibility.
|
|
for (let i = 0; i < this._clones.length; i++)
|
|
this._clones[i].show();
|
|
}
|
|
|
|
/**
|
|
* hide:
|
|
* Hide the crosshairs.
|
|
*/
|
|
hide() {
|
|
this._actor.hide();
|
|
// Clones don't share visibility.
|
|
for (let i = 0; i < this._clones.length; i++)
|
|
this._clones[i].hide();
|
|
}
|
|
|
|
/**
|
|
* 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.
|
|
* @clipSize: Optional. If present, an array of the form [width, height].
|
|
*/
|
|
reCenter(clipSize) {
|
|
let [groupWidth, groupHeight] = this._actor.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];
|
|
|
|
// Note that clip, if present, is not centred on the cross hair
|
|
// intersection, but biased towards the top left.
|
|
let left = groupWidth / 2 - clipWidth * 0.25 - leftLength;
|
|
let right = groupWidth / 2 + clipWidth * 0.75;
|
|
let top = groupHeight / 2 - clipHeight * 0.25 - topLength - thickness / 2;
|
|
let bottom = groupHeight / 2 + clipHeight * 0.75 + 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.
|
|
* @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.
|
|
* @brightness: Object containing the brightness 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.
|
|
*/
|
|
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.
|
|
* @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.
|
|
*/
|
|
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
|
|
);
|
|
}
|
|
};
|