summaryrefslogtreecommitdiffstats
path: root/js/ui/magnifierDBus.js
diff options
context:
space:
mode:
Diffstat (limited to 'js/ui/magnifierDBus.js')
-rw-r--r--js/ui/magnifierDBus.js351
1 files changed, 351 insertions, 0 deletions
diff --git a/js/ui/magnifierDBus.js b/js/ui/magnifierDBus.js
new file mode 100644
index 0000000..6f962d1
--- /dev/null
+++ b/js/ui/magnifierDBus.js
@@ -0,0 +1,351 @@
+// -*- mode: js; js-indent-level: 4; indent-tabs-mode: nil -*-
+/* exported ShellMagnifier */
+
+const Gio = imports.gi.Gio;
+const Main = imports.ui.main;
+
+const { loadInterfaceXML } = imports.misc.fileUtils;
+
+const MAG_SERVICE_PATH = '/org/gnome/Magnifier';
+const ZOOM_SERVICE_PATH = '/org/gnome/Magnifier/ZoomRegion';
+
+// Subset of gnome-mag's Magnifier dbus interface -- to be expanded. See:
+// http://git.gnome.org/browse/gnome-mag/tree/xml/...Magnifier.xml
+const MagnifierIface = loadInterfaceXML('org.gnome.Magnifier');
+
+// Subset of gnome-mag's ZoomRegion dbus interface -- to be expanded. See:
+// http://git.gnome.org/browse/gnome-mag/tree/xml/...ZoomRegion.xml
+const ZoomRegionIface = loadInterfaceXML('org.gnome.Magnifier.ZoomRegion');
+
+// For making unique ZoomRegion DBus proxy object paths of the form:
+// '/org/gnome/Magnifier/ZoomRegion/zoomer0',
+// '/org/gnome/Magnifier/ZoomRegion/zoomer1', etc.
+let _zoomRegionInstanceCount = 0;
+
+var ShellMagnifier = class ShellMagnifier {
+ constructor() {
+ this._zoomers = {};
+
+ this._dbusImpl = Gio.DBusExportedObject.wrapJSObject(MagnifierIface, this);
+ this._dbusImpl.export(Gio.DBus.session, MAG_SERVICE_PATH);
+ }
+
+ /**
+ * setActive:
+ * @param {bool} activate: activate or de-activate the magnifier.
+ */
+ setActive(activate) {
+ Main.magnifier.setActive(activate);
+ }
+
+ /**
+ * isActive:
+ * @returns {bool} Whether the magnifier is active.
+ */
+ isActive() {
+ return Main.magnifier.isActive();
+ }
+
+ /**
+ * showCursor:
+ * Show the system mouse pointer.
+ */
+ showCursor() {
+ Main.magnifier.showSystemCursor();
+ }
+
+ /**
+ * hideCursor:
+ * Hide the system mouse pointer.
+ */
+ hideCursor() {
+ Main.magnifier.hideSystemCursor();
+ }
+
+ /**
+ * createZoomRegion:
+ * Create a new ZoomRegion and return its object path.
+ * @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 {number[]} roi
+ * Array of integers defining the region of the screen/desktop
+ * to magnify. The array has the form [left, top, right, bottom].
+ * @param {number[]} viewPort
+ * Array of integers, [left, top, right, bottom] that defines
+ * the position of the ZoomRegion on screen.
+ *
+ * FIXME: The arguments here are redundant, since the width and height of
+ * the ROI are determined by the viewport and magnification factors.
+ * We ignore the passed in width and height.
+ *
+ * @returns {ZoomRegion} The newly created ZoomRegion.
+ */
+ createZoomRegion(xMagFactor, yMagFactor, roi, viewPort) {
+ let ROI = { x: roi[0], y: roi[1], width: roi[2] - roi[0], height: roi[3] - roi[1] };
+ let viewBox = { x: viewPort[0], y: viewPort[1], width: viewPort[2] - viewPort[0], height: viewPort[3] - viewPort[1] };
+ let realZoomRegion = Main.magnifier.createZoomRegion(xMagFactor, yMagFactor, ROI, viewBox);
+ let objectPath = `${ZOOM_SERVICE_PATH}/zoomer${_zoomRegionInstanceCount}`;
+ _zoomRegionInstanceCount++;
+
+ let zoomRegionProxy = new ShellMagnifierZoomRegion(objectPath, realZoomRegion);
+ let proxyAndZoomRegion = {};
+ proxyAndZoomRegion.proxy = zoomRegionProxy;
+ proxyAndZoomRegion.zoomRegion = realZoomRegion;
+ this._zoomers[objectPath] = proxyAndZoomRegion;
+ return objectPath;
+ }
+
+ /**
+ * addZoomRegion:
+ * Append the given ZoomRegion to the magnifier's list of ZoomRegions.
+ * @param {string} zoomerObjectPath: The object path for the zoom
+ * region proxy.
+ * @returns {bool} whether the region was added successfully
+ */
+ addZoomRegion(zoomerObjectPath) {
+ let proxyAndZoomRegion = this._zoomers[zoomerObjectPath];
+ if (proxyAndZoomRegion && proxyAndZoomRegion.zoomRegion) {
+ Main.magnifier.addZoomRegion(proxyAndZoomRegion.zoomRegion);
+ return true;
+ } else {
+ return false;
+ }
+ }
+
+ /**
+ * getZoomRegions:
+ * Return a list of ZoomRegion object paths for this Magnifier.
+ * @returns {string[]}: The Magnifier's zoom region list as an array
+ * of DBus object paths.
+ */
+ getZoomRegions() {
+ // There may be more ZoomRegions in the magnifier itself than have
+ // been added through dbus. Make sure all of them are associated with
+ // an object path and proxy.
+ let zoomRegions = Main.magnifier.getZoomRegions();
+ let objectPaths = [];
+ let thoseZoomers = this._zoomers;
+ zoomRegions.forEach(aZoomRegion => {
+ let found = false;
+ for (let objectPath in thoseZoomers) {
+ let proxyAndZoomRegion = thoseZoomers[objectPath];
+ if (proxyAndZoomRegion.zoomRegion === aZoomRegion) {
+ objectPaths.push(objectPath);
+ found = true;
+ break;
+ }
+ }
+ if (!found) {
+ // Got a ZoomRegion with no DBus proxy, make one.
+ let newPath = `${ZOOM_SERVICE_PATH}/zoomer${_zoomRegionInstanceCount}`;
+ _zoomRegionInstanceCount++;
+ let zoomRegionProxy = new ShellMagnifierZoomRegion(newPath, aZoomRegion);
+ let proxyAndZoomer = {};
+ proxyAndZoomer.proxy = zoomRegionProxy;
+ proxyAndZoomer.zoomRegion = aZoomRegion;
+ thoseZoomers[newPath] = proxyAndZoomer;
+ objectPaths.push(newPath);
+ }
+ });
+ return objectPaths;
+ }
+
+ /**
+ * clearAllZoomRegions:
+ * Remove all the zoom regions from this Magnfier's ZoomRegion list.
+ */
+ clearAllZoomRegions() {
+ Main.magnifier.clearAllZoomRegions();
+ for (let objectPath in this._zoomers) {
+ let proxyAndZoomer = this._zoomers[objectPath];
+ proxyAndZoomer.proxy.destroy();
+ proxyAndZoomer.proxy = null;
+ proxyAndZoomer.zoomRegion = null;
+ delete this._zoomers[objectPath];
+ }
+ this._zoomers = {};
+ }
+
+ /**
+ * fullScreenCapable:
+ * Consult if the Magnifier can magnify in full-screen mode.
+ * @returns {bool} Always return true.
+ */
+ fullScreenCapable() {
+ return true;
+ }
+
+ /**
+ * setCrosswireSize:
+ * Set the crosswire size of all ZoomRegions.
+ * @param {number} size: The thickness of each line in the cross wire.
+ */
+ setCrosswireSize(size) {
+ Main.magnifier.setCrosshairsThickness(size);
+ }
+
+ /**
+ * getCrosswireSize:
+ * Get the crosswire size of all ZoomRegions.
+ * @returns {number}: The thickness of each line in the cross wire.
+ */
+ getCrosswireSize() {
+ return Main.magnifier.getCrosshairsThickness();
+ }
+
+ /**
+ * setCrosswireLength:
+ * Set the crosswire length of all zoom-regions..
+ * @param {number} length: The length of each line in the cross wire.
+ */
+ setCrosswireLength(length) {
+ Main.magnifier.setCrosshairsLength(length);
+ }
+
+ /**
+ * getCrosswireSize:
+ * Get the crosswire length of all zoom-regions.
+ * @returns {number} size: The length of each line in the cross wire.
+ */
+ getCrosswireLength() {
+ return Main.magnifier.getCrosshairsLength();
+ }
+
+ /**
+ * setCrosswireClip:
+ * Set if the crosswire will be clipped by the cursor image..
+ * @param {bool} clip: Flag to indicate whether to clip the crosswire.
+ */
+ setCrosswireClip(clip) {
+ Main.magnifier.setCrosshairsClip(clip);
+ }
+
+ /**
+ * getCrosswireClip:
+ * Get the crosswire clip value.
+ * @returns {bool}: Whether the crosswire is clipped by the cursor image.
+ */
+ getCrosswireClip() {
+ return Main.magnifier.getCrosshairsClip();
+ }
+
+ /**
+ * setCrosswireColor:
+ * Set the crosswire color of all ZoomRegions.
+ * @param {number} color: Unsigned int of the form rrggbbaa.
+ */
+ setCrosswireColor(color) {
+ Main.magnifier.setCrosshairsColor('#%08x'.format(color));
+ }
+
+ /**
+ * getCrosswireClip:
+ * Get the crosswire color of all ZoomRegions.
+ * @returns {number}: The crosswire color as an unsigned int in
+ * the form rrggbbaa.
+ */
+ getCrosswireColor() {
+ let colorString = Main.magnifier.getCrosshairsColor();
+ // Drop the leading '#'.
+ return parseInt(colorString.slice(1), 16);
+ }
+};
+
+/**
+ * ShellMagnifierZoomRegion:
+ * Object that implements the DBus ZoomRegion interface.
+ * @zoomerObjectPath: String that is the path to a DBus ZoomRegion.
+ * @zoomRegion: The actual zoom region associated with the object path.
+ */
+var ShellMagnifierZoomRegion = class ShellMagnifierZoomRegion {
+ constructor(zoomerObjectPath, zoomRegion) {
+ this._zoomRegion = zoomRegion;
+
+ this._dbusImpl = Gio.DBusExportedObject.wrapJSObject(ZoomRegionIface, this);
+ this._dbusImpl.export(Gio.DBus.session, zoomerObjectPath);
+ }
+
+ /**
+ * 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._zoomRegion.setMagFactor(xMagFactor, yMagFactor);
+ }
+
+ /**
+ * getMagFactor:
+ * @returns {number[]}: [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._zoomRegion.getMagFactor();
+ }
+
+ /**
+ * setRoi:
+ * Sets the "region of interest" that the ZoomRegion is magnifying.
+ * @param {number[]} roi: [left, top, right, bottom], defining the
+ * region of the screen to magnify.
+ * The values are in screen (unmagnified) coordinate space.
+ */
+ setRoi(roi) {
+ let roiObject = { x: roi[0], y: roi[1], width: roi[2] - roi[0], height: roi[3] - roi[1] };
+ this._zoomRegion.setROI(roiObject);
+ }
+
+ /**
+ * 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 {Array}: [left, top, right, bottom], representing the bounding
+ * rectangle of what is shown in the magnified view.
+ */
+ getRoi() {
+ let roi = this._zoomRegion.getROI();
+ roi[2] += roi[0];
+ roi[3] += roi[1];
+ return roi;
+ }
+
+ /**
+ * Set the "region of interest" by centering the given screen coordinate
+ * within the zoom region.
+ * @param {number} x: The x-coord of the point to place at the
+ * center of the zoom region.
+ * @param {number} y: The y-coord.
+ * @returns {bool} Whether the shift was successful (for GS-mag, this
+ * is always true).
+ */
+ shiftContentsTo(x, y) {
+ this._zoomRegion.scrollContentsTo(x, y);
+ return true;
+ }
+
+ /**
+ * moveResize
+ * Sets the position and size of the ZoomRegion on screen.
+ * @param {number[]} viewPort: [left, top, right, bottom], defining
+ * the position and size on screen to place the zoom region.
+ */
+ moveResize(viewPort) {
+ let viewRect = { x: viewPort[0], y: viewPort[1], width: viewPort[2] - viewPort[0], height: viewPort[3] - viewPort[1] };
+ this._zoomRegion.setViewPort(viewRect);
+ }
+
+ destroy() {
+ this._dbusImpl.unexport();
+ }
+};