diff --git a/js/ui/Makefile.am b/js/ui/Makefile.am
index 22f027e..4215a8b 100644
--- a/js/ui/Makefile.am
+++ b/js/ui/Makefile.am
@@ -16,6 +16,8 @@ dist_jsui_DATA =		\
 	link.js			\
 	lookingGlass.js		\
 	main.js			\
+	magnifier.js		\
+	magnifierDBus.js	\
 	messageTray.js          \
 	notificationDaemon.js   \
 	overview.js		\
diff --git a/js/ui/altTab.js b/js/ui/altTab.js
index 46e723d..328a856 100644
--- a/js/ui/altTab.js
+++ b/js/ui/altTab.js
@@ -59,7 +59,7 @@ AltTabPopup.prototype = {
         // the switcher appears underneath the current pointer location
         this._disableHover();
 
-        global.stage.add_actor(this.actor);
+        Main.uiGroup.add_actor(this.actor);
     },
 
     show : function(backward) {
diff --git a/js/ui/appDisplay.js b/js/ui/appDisplay.js
index 1af7994..177d907 100644
--- a/js/ui/appDisplay.js
+++ b/js/ui/appDisplay.js
@@ -579,7 +579,7 @@ AppIconMenu.prototype = {
         }));
         source.actor.connect('destroy', Lang.bind(this, function () { this.actor.destroy(); }));
 
-        global.stage.add_actor(this.actor);
+        Main.uiGroup.add_actor(this.actor);
     },
 
     _getPreferredWidth: function(actor, forHeight, alloc) {
diff --git a/js/ui/chrome.js b/js/ui/chrome.js
index 50e0e79..3d85360 100644
--- a/js/ui/chrome.js
+++ b/js/ui/chrome.js
@@ -21,7 +21,7 @@ Chrome.prototype = {
     _init: function() {
         // The group itself has zero size so it doesn't interfere with DND
         this.actor = new Clutter.Group({ width: 0, height: 0 });
-        global.stage.add_actor(this.actor);
+        Main.uiGroup.add_actor(this.actor);
         this.nonOverviewActor = new Clutter.Group();
         this.actor.add_actor(this.nonOverviewActor);
 
diff --git a/js/ui/dnd.js b/js/ui/dnd.js
index 9188cad..8e4b60e 100644
--- a/js/ui/dnd.js
+++ b/js/ui/dnd.js
@@ -5,6 +5,7 @@ const Gtk = imports.gi.Gtk;
 const Lang = imports.lang;
 const Signals = imports.signals;
 const Tweener = imports.ui.tweener;
+const Main = imports.ui.main;
 
 const SNAP_BACK_ANIMATION_TIME = 0.25;
 
@@ -16,7 +17,7 @@ function _getEventHandlerActor() {
         eventHandlerActor = new Clutter.Rectangle();
         eventHandlerActor.width = 0;
         eventHandlerActor.height = 0;
-        global.stage.add_actor(eventHandlerActor);
+        Main.uiGroup.add_actor(eventHandlerActor);
         // We connect to 'event' rather than 'captured-event' because the capturing phase doesn't happen
         // when you've grabbed the pointer.
         eventHandlerActor.connect('event',
diff --git a/js/ui/lookingGlass.js b/js/ui/lookingGlass.js
index 783d3ef..0157a64 100644
--- a/js/ui/lookingGlass.js
+++ b/js/ui/lookingGlass.js
@@ -266,7 +266,7 @@ Inspector.prototype = {
         eventHandler.connect('notify::allocation', Lang.bind(this, function () {
             eventHandler.x = primary.x + Math.floor((primary.width - eventHandler.width) / 2);
         }));
-        global.stage.add_actor(eventHandler);
+        Main.uiGroup.add_actor(eventHandler);
         let displayText = new St.Label();
         eventHandler.add(displayText, { expand: true });
 
@@ -473,7 +473,7 @@ LookingGlass.prototype = {
                       Lang.bind(this, this._updateFont));
         this._updateFont();
 
-        global.stage.add_actor(this.actor);
+        Main.uiGroup.add_actor(this.actor);
 
         let toolbar = new St.BoxLayout({ name: "Toolbar" });
         this.actor.add_actor(toolbar);
diff --git a/js/ui/magnifier.js b/js/ui/magnifier.js
new file mode 100755
index 0000000..4376b11
--- /dev/null
+++ b/js/ui/magnifier.js
@@ -0,0 +1,930 @@
+/* -*- mode: js2; js2-basic-offset: 4; indent-tabs-mode: nil -*- */
+
+const DBus = imports.dbus;
+const Gtk = imports.gi.Gtk;
+const Gdk = imports.gi.Gdk;
+const Clutter = imports.gi.Clutter;
+const Shell = imports.gi.Shell;
+const Big = imports.gi.Big;
+const Lang = imports.lang;
+const Mainloop = imports.mainloop;
+const Main = imports.ui.main;
+const MagnifierDBus = imports.ui.magnifierDBus;
+
+const MouseTrackingMode = {
+    NONE: 0,
+    CENTERED: 1,
+    PUSH: 2,
+    PROPORTIONAL: 3
+};
+
+const ScreenPosition = {
+    NONE: 0,
+    FULL_SCREEN: 1,
+    TOP_HALF: 2,
+    BOTTOM_HALF: 3,
+    LEFT_HALF: 4,
+    RIGHT_HALF: 5
+};
+
+// Default settings
+const DEFAULT_X_MAGFACTOR = 2;
+const DEFAULT_Y_MAGFACTOR = 2;
+const DEFAULT_MOUSE_POLL_FREQUENCY = 50;
+const DEFAULT_LENS_MODE = false;
+const DEFAULT_SCREEN_POSITION = ScreenPosition.BOTTOM_HALF;
+const DEFAULT_MOUSE_TRACKING_MODE = MouseTrackingMode.CENTERED;
+const DEFAULT_CLAMP_SCROLLING_AT_EDGES = true;
+
+// GConf settings
+const A11Y_MAG_PREFS_DIR    = "/desktop/gnome/accessibility/magnifier";
+const SHOW_KEY              = A11Y_MAG_PREFS_DIR + "/show_magnifier";
+const SCREEN_POSITION_KEY   = A11Y_MAG_PREFS_DIR + "/screen_position";
+const MAG_FACTOR_KEY        = A11Y_MAG_PREFS_DIR + "/mag_factor";
+const LENS_MODE_KEY         = A11Y_MAG_PREFS_DIR + "/lens_mode";
+const CLAMP_MODE_KEY        = A11Y_MAG_PREFS_DIR + "/scroll_at_edges";
+const MOUSE_TRACKING_KEY    = A11Y_MAG_PREFS_DIR + "/mouse_tracking";
+
+const BORDER_WIDTH = 2;
+const BORDER_COLOR = new Clutter.Color();
+BORDER_COLOR.from_pixel(0x800000ff);
+
+let magDBusService = null;
+
+function Magnifier() {
+    this._init();
+}
+
+Magnifier.prototype = {
+    _init: function() {
+        // Magnifier is a manager of ZoomRegions.
+        this._zoomRegions = [];
+
+        // Create small clutter tree for the magnified mouse.
+        let xfixesCursor = new Shell.XFixesCursor({stage: global.stage});
+        let pixbuf = xfixesCursor.get_gdkpixbuf();
+        this._mouseSprite = new Clutter.Texture();
+        if (pixbuf)
+            Shell.clutter_texture_set_from_pixbuf(this._mouseSprite, pixbuf);
+        this._cursorRoot = new Big.Box();
+        this._cursorRoot.append(this._mouseSprite, Big.BoxPackFlags.EXPAND);
+
+        // Create the first ZoomRegion and initialize it according to the
+        // magnification GConf settings.
+        let [objUnder, xMouse, yMouse, mask] =
+            Gdk.Screen.get_default().get_root_window().get_pointer();
+        let aZoomRegion = new ZoomRegion(this, this._cursorRoot);
+        let showAtLaunch = this._gConfInit(aZoomRegion);
+        aZoomRegion.scrollContentsTo(xMouse, yMouse);
+        this._zoomRegions.push(aZoomRegion);
+
+        xfixesCursor.connect('cursor-change', Lang.bind(this, this._updateMouseSprite));
+        this._xfixesCursor = xfixesCursor;
+        this.startTrackingMouse();
+
+        // Export to dbus.
+        magDBusService = new MagnifierDBus.ShellMagnifier();
+        this.setActive(showAtLaunch);
+    },
+
+    /**
+     * showSystemCursor:
+     * Show the system mouse pointer.
+     */
+    showSystemCursor: function() {
+        this._xfixesCursor.show();
+    },
+
+    /**
+     * hideSystemCursor:
+     * Hide the system mouse pointer.
+     */
+    hideSystemCursor: function() {
+        this._xfixesCursor.hide();
+    },
+
+    /**
+     * setActive:
+     * Show/hide all the zoom regions.
+     * @activate:   Boolean to activate or de-activate the magnifier.
+     */
+    setActive: function(activate) {
+        this._zoomRegions.forEach (function(zoomRegion, index, array) {
+            zoomRegion.setActive(activate);
+        });
+
+        // Make sure system mouse pointer is shown when all zoom regions are
+        // invisible.
+        if (!activate)
+            this._xfixesCursor.show();
+    },
+
+    /**
+     * isActive:
+     * @return  Whether the magnifier is active (boolean).
+     */
+    isActive: function() {
+        // 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: function() {
+        // initialize previous mouse coord to undefined.
+        let prevCoord = { x: NaN, y: NaN };
+        if (!this._mouseTrackingId)
+            this._mouseTrackingId = Mainloop.timeout_add(
+                DEFAULT_MOUSE_POLL_FREQUENCY,
+                Lang.bind(this, this.scrollToMousePos, prevCoord)
+            );
+    },
+
+    /**
+     * stopTrackingMouse:
+     * Turn off mouse tracking, if not already doing so.
+     */
+    stopTrackingMouse: function() {
+        if (this._mouseTrackingId)
+            Mainloop.source_remove(this._mouseTrackingId);
+
+        this._mouseTrackingId = null;
+    },
+
+    /**
+     * isTrackingMouse:
+     * Is the magnifier tracking the mouse currently?
+     */
+    isTrackingMouse: function() {
+        return !!this._mouseTrackingId;
+    },
+
+    /**
+     * scrollToMousePos:
+     * Position all zoom regions' ROI relative to the current location of the
+     * system pointer.
+     * @prevCoord:  The previous mouse coordinates.  Used to stop scrolling if
+     *              the new position is the same as the last one (optional).
+     * @return      true.
+     */
+    scrollToMousePos: function(prevCoord) {
+        let [objUnder, xMouse, yMouse, mask] =
+            Gdk.Screen.get_default().get_root_window().get_pointer();
+
+        if (!prevCoord || prevCoord.x != xMouse || prevCoord.y != yMouse) {
+            let sysMouseOverAny = false;
+            this._zoomRegions.forEach(function(zoomRegion, index, array) {
+                if (zoomRegion.scrollToMousePos())
+                    sysMouseOverAny = true;
+            });
+            if (sysMouseOverAny)
+                this.hideSystemCursor();
+            else
+                this.showSystemCursor();
+
+            if (prevCoord) {
+                prevCoord.x = xMouse;
+                prevCoord.y = yMouse;
+            }
+        }
+        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: function(xMagFactor, yMagFactor, roi, viewPort) {
+        let zoomRegion = new ZoomRegion(this, this._cursorRoot);
+        zoomRegion.setMagFactor(xMagFactor, yMagFactor);
+        zoomRegion.setViewPort(viewPort);
+        zoomRegion.setROI(roi);
+        return zoomRegion;
+    },
+
+    /**
+     * addZoomRegion:
+     * Append the given ZoomRegion to the list of currently defined ZoomRegions
+     * for this Magnifier instance.
+     * @zoomRegion:     The zoomRegion to add.
+     */
+    addZoomRegion: function(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: function() {
+        return this._zoomRegions;
+    },
+
+    /**
+     * clearAllZoomRegions:
+     * Remove all the zoom regions from this Magnfier's ZoomRegion list.
+     */
+    clearAllZoomRegions: function() {
+        for (let i = 1; i < this._zoomRegions.length; i++) {
+            this._zoomRegions[i].setActive(false);
+            this._zoomRegions[i].removeFromStage();
+        }
+        this._zoomRegions[0].setActive(false);
+        this._cursorRoot.get_parent().remove_actor(this._cursorRoot);
+        this._zoomRegions[0].removeFromStage();
+        this._zoomRegions.length = 0;
+        this.stopTrackingMouse();
+        this.showSystemCursor();
+    },
+
+    //// Private methods ////
+
+    _updateMouseSprite: function() {
+        let pixbuf = this._xfixesCursor.get_gdkpixbuf();
+        if (pixbuf) {
+            Shell.clutter_texture_set_from_pixbuf(this._mouseSprite, pixbuf);
+            let xHot = this._xfixesCursor.get_hot_x();
+            let yHot = this._xfixesCursor.get_hot_y();
+            this._mouseSprite.set_anchor_point(xHot - 2, yHot - 2);
+        }
+    },
+
+    _gConfInit: function(zoomRegion) {
+        let gConf = Shell.GConf.get_default();
+        if (zoomRegion) {
+            // Mag factor is accurate to two decimal places.
+            let aPref = gConf.get_float(MAG_FACTOR_KEY).toFixed(2);
+            if (aPref != 0.0)
+                zoomRegion.setMagFactor(aPref, aPref);
+
+            aPref = gConf.get_int(SCREEN_POSITION_KEY);
+            if (aPref)
+                zoomRegion.setScreenPosition(aPref);
+
+            zoomRegion.setLensMode(gConf.get_boolean(LENS_MODE_KEY));
+            zoomRegion.setClampScrollingAtEdges(!gConf.get_boolean(CLAMP_MODE_KEY));
+
+            aPref = gConf.get_int(MOUSE_TRACKING_KEY);
+            if (aPref)
+                zoomRegion.setMouseTrackingMode(aPref);
+        }
+        gConf.watch_directory(A11Y_MAG_PREFS_DIR);
+        gConf.connect('changed::' + SHOW_KEY, Lang.bind(this, this._updateShowHide));
+        gConf.connect('changed::' + SCREEN_POSITION_KEY, Lang.bind(this, this._updateScreenPosition));
+        gConf.connect('changed::' + MAG_FACTOR_KEY, Lang.bind(this, this._updateMagFactor));
+        gConf.connect('changed::' + LENS_MODE_KEY, Lang.bind(this, this._updateLensMode));
+        gConf.connect('changed::' + CLAMP_MODE_KEY, Lang.bind(this, this._updateClampMode));
+        gConf.connect('changed::' + MOUSE_TRACKING_KEY, Lang.bind(this, this._updateMouseTrackingMode));
+
+        return gConf.get_boolean(SHOW_KEY);
+   },
+
+    _updateShowHide: function() {
+        let gConf = Shell.GConf.get_default();
+        this.setActive(gConf.get_boolean(SHOW_KEY));
+    },
+
+    _updateScreenPosition: function() {
+        // Applies only to the first zoom region.
+        if (this._zoomRegions.length) {
+            let gConf = Shell.GConf.get_default();
+            let position = gConf.get_int(SCREEN_POSITION_KEY);
+            this._zoomRegions[0].setScreenPosition(position);
+            if (position != ScreenPosition.FULL_SCREEN)
+                this._updateLensMode();
+        }
+    },
+
+    _updateMagFactor: function() {
+        // Applies only to the first zoom region.
+        if (this._zoomRegions.length) {
+            let gConf = Shell.GConf.get_default();
+            // Mag factor is accurate to two decimal places.
+            let magFactor = gConf.get_float(MAG_FACTOR_KEY).toFixed(2);
+            this._zoomRegions[0].setMagFactor(magFactor, magFactor);
+        }
+    },
+
+    _updateLensMode: function() {
+        // Applies only to the first zoom region.
+        if (this._zoomRegions.length) {
+            let gConf = Shell.GConf.get_default();
+            this._zoomRegions[0].setLensMode(gConf.get_boolean(LENS_MODE_KEY));
+        }
+    },
+
+    _updateClampMode: function() {
+        // Applies only to the first zoom region.
+        if (this._zoomRegions.length) {
+            let gConf = Shell.GConf.get_default();
+            this._zoomRegions[0].setClampScrollingAtEdges(
+                !gConf.get_boolean(CLAMP_MODE_KEY)
+            );
+        }
+    },
+
+    _updateMouseTrackingMode: function() {
+        // Applies only to the first zoom region.
+        if (this._zoomRegions.length) {
+            let gConf = Shell.GConf.get_default();
+            this._zoomRegions[0].setMouseTrackingMode(
+                gConf.get_int(MOUSE_TRACKING_KEY)
+            );
+        }
+    }
+}
+
+function ZoomRegion(magnifier, mouseRoot) {
+    this._init(magnifier, mouseRoot);
+}
+
+ZoomRegion.prototype = {
+    _init: function(magnifier, mouseRoot) {
+        this._magnifier = magnifier;
+
+        // The root actor for a zoom region is a Big.Box with a frame around it.
+        this._magView = new Big.Box({
+            border: BORDER_WIDTH,
+            border_color: BORDER_COLOR
+        });
+
+        // Append a Clutter.Group to clip the contents of the magnified vew.
+        // Note:  if the size is not initialized to something, the height is
+        // not properly clipped when added to _magView.  Setting width and
+        // height temporarily to anything fixes this.
+        let aGroup = new Clutter.Group({
+            clip_to_allocation: true,
+            width: 0,
+            height: 0
+        });
+        this._magView.append(aGroup, Big.BoxPackFlags.EXPAND);
+
+        // Add a background for when the magnified uiGroup is scrolled
+        // out of view (don't want to see desktop showing through).
+        let background = new Clutter.Rectangle({ color: Main.DEFAULT_BACKGROUND_COLOR });
+        aGroup.add_actor(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 });
+        aGroup.add_actor(this._uiGroupClone);
+        Main.uiGroup.set_size(global.screen_width, global.screen_height);
+        background.set_size(global.screen_width, global.screen_height);
+        this._uiGroupClone.set_size(global.screen_width, global.screen_height);
+
+        // Add either the given mouseRoot to the ZoomRegion, or a clone of
+        // it.
+        if (mouseRoot.get_parent() != null)
+            this._mouseRoot = new Clutter.Clone({ source: mouseRoot });
+        else
+            this._mouseRoot = mouseRoot;
+        aGroup.add_actor(this._mouseRoot);
+
+        this.setMagFactor(DEFAULT_X_MAGFACTOR, DEFAULT_Y_MAGFACTOR);
+        this.setScreenPosition(DEFAULT_SCREEN_POSITION);
+        this.setLensMode(DEFAULT_LENS_MODE);
+        this.setClampScrollingAtEdges(DEFAULT_CLAMP_SCROLLING_AT_EDGES);
+        this.setMouseTrackingMode(DEFAULT_MOUSE_TRACKING_MODE);
+
+        this._magView.hide();
+        global.stage.add_actor(this._magView);
+    },
+
+    /**
+     * setActive:
+     * @activate:   Boolean to show/hide the ZoomRegion.
+     */
+    setActive: function(activate) {
+        if (activate) {
+            this._magView.show();
+            if (this.isMouseOverRegion())
+                this._magnifier.hideSystemCursor();
+        }
+        else
+            this._magView.hide();
+    },
+
+    /**
+     * isActive:
+     * @return  Whether this ZoomRegion is active (boolean).
+     */
+    isActive: function() {
+        return this._magView.visible;
+    },
+
+    /**
+     * removeFromStage:
+     * Remove the magnified view from the stage.
+     */
+    removeFromStage: function() {
+        global.stage.remove_actor(this._magView);
+        this._mouseRoot = null;
+        this._uiGroupClone = null;
+        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: function(xMagFactor, yMagFactor) {
+        if (xMagFactor > 0 && yMagFactor > 0) {
+            // Changing the mag factor moves the pixels along the axes of
+            // magnification.  Set the view back to the point that was at the centre
+            // of the region of interest.
+            let [x, y, width, height] = this.getROI();
+            let xCentre = x + width / 2;
+            let yCentre = y + height / 2;
+            this._uiGroupClone.set_scale(xMagFactor, yMagFactor);
+            this._mouseRoot.set_scale(xMagFactor, yMagFactor);
+            this._calcRightBottomStops();
+            this._scrollToPosition(xCentre, yCentre);
+            this._updateMousePosition(false /* mouse didn't move */);
+        }
+    },
+
+    /**
+     * 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: function() {
+        return this._uiGroupClone.get_scale();
+    },
+
+    /**
+     * setMouseTrackingMode
+     * @mode:     One of the enum MouseTrackingMode values.
+     */
+    setMouseTrackingMode: function(mode) {
+        if (mode >= MouseTrackingMode.NONE && mode <= MouseTrackingMode.PROPORTIONAL)
+            this._mouseTrackingMode = mode;
+    },
+
+    /**
+     * getMouseTrackingMode
+     * @return:     One of the enum MouseTrackingMode values.
+     */
+    getMouseTrackingMode: function() {
+        return this._mouseTrackingMode;
+    },
+
+    /**
+     * setViewPort
+     * Sets the position and size of the ZoomRegion on screen.
+     * @viewPort:   Object defining the position and size of the view port.  It
+     *              has the form { x, y, width, height }.  The values are in
+     *              stage coordinate space.
+     */
+    setViewPort: function(viewPort) {
+        this.setSize(viewPort.width, viewPort.height);
+        this.setPosition(viewPort.x, viewPort.y);
+        this._updateMousePosition(false /* mouse didn't move */);
+        this._screenPosition = ScreenPosition.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 the form { x, y, width, height }.  The values are in
+     *          screen (unmagnified) coordinate space.
+     */
+    setROI: function(roi) {
+        let xRoiCenter = roi.x + (roi.width - roi.x) / 2;
+        let yRoiCenter = roi.y + (roi.height - roi.y) / 2;
+        this.scrollContentsTo(xRoiCenter, yRoiCenter);
+    },
+
+    /**
+     * setSize:
+     * @width:    The width to set the magnified view to.
+     * @height:   The height to set the magnified view to.
+     */
+    setSize: function(width, height) {
+        this._magView.set_size(width, height);
+        this._calcRightBottomStops();
+    },
+
+    /**
+     * getSize:
+     * @return  an array, [width, height], that specifies the size of the
+     *          magnified view.
+     */
+    getSize: function() {
+        return this._magView.get_size();
+    },
+
+    /**
+     * setPosition:
+     * Position the magnified view at the given coordinates.
+     * @x:    The x-coord of the new position.
+     * @y:    The y-coord of the new position.
+     */
+    setPosition: function(x, y) {
+        let [width, height] = this._magView.get_size();
+        if (this._clampScrollingAtEdges) {
+            // Restrict positioning so view doesn't go beyond any edge of the
+            // screen.
+            if (x < 0)
+                x = 0;
+            if (x + width > global.screen_width)
+                x = global.screen_width - width;
+            if (y < 0)
+                y = 0;
+            if (y + height > global.screen_height)
+                y = global.screen_height - height;
+        }
+        this._magView.set_position(x, y);
+    },
+
+    /**
+     * getPosition:
+     * @return  an array, [x, y], that gives the position of the
+     *          magnified view on screen.
+     */
+    getPosition: function() {
+        return this._magView.get_position();
+    },
+
+    /**
+     * getCenter:
+     * @return  an array, [x, y], that is half the width and height of the
+     *          magnified view (the center of the magnified view).
+     */
+    getCenter: function() {
+        let [width, height] = this._magView.get_size();
+        return [width / 2, height / 2];
+    },
+
+    /**
+     * isFullScreenMode:
+     * Does the magnified view occupy the whole screen?
+     */
+    isFullScreenMode: function() {
+        let [x, y] = this._magView.get_position();
+        if (x != 0 || y != 0)
+            return false;
+        [width, height] = this._magView.get_size();
+        if (width != global.screen_width || height != global.screen_height)
+            return false;
+        return true;
+    },
+
+    /**
+     * 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: function() {
+        let [xMagnified, yMagnified] = this._uiGroupClone.get_position();
+        let [xMagFactor, yMagFactor] = this.getMagFactor();
+        let [width, height] = this.getSize();
+        let x = (0 - xMagnified) / xMagFactor;
+        let y = (0 - yMagnified) / yMagFactor;
+        return [x, y, width / xMagFactor, height / yMagFactor];
+    },
+
+    /**
+     * setLensMode:
+     * Turn lens mode on/off.  In full screen mode, lens mode is alway off since
+     * a lens the size of the screen is pointless.
+     * @lensMode:   A boolean to set the sense of lens mode.
+     */
+    setLensMode: function(lensMode) {
+        let fullScreen = this.isFullScreenMode();
+        this._lensMode = (lensMode && !fullScreen);
+        if (!this._lensMode && !fullScreen)
+            this.setScreenPosition (this._screenPosition);
+    },
+
+    /**
+     * isLensMode:
+     * Is lens mode on or off?
+     * @return  The lens mode state as a boolean.
+     */
+    isLensMode: function() {
+        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: function(clamp) {
+        this._clampScrollingAtEdges = clamp;
+    },
+
+    /**
+     * setTopHalf:
+     * Magnifier view occupies the top half of the screen.
+     */
+    setTopHalf: function() {
+        this.setPosition(0, 0);
+        this.setSize(global.screen_width, global.screen_height/2);
+        this.scrollToMousePos();
+        this._magView.set_border_width(BORDER_WIDTH);
+        this._screenPosition = ScreenPosition.TOP_HALF;
+    },
+
+    /**
+     * setBottomHalf:
+     * Magnifier view occupies the bottom half of the screen.
+     */
+    setBottomHalf: function() {
+        this.setPosition(0, global.screen_height/2);
+        this.setSize(global.screen_width, global.screen_height/2);
+        this._magView.set_border_width(BORDER_WIDTH);
+        this.scrollToMousePos();
+        this._screenPosition = ScreenPosition.BOTTOM_HALF;
+    },
+
+    /**
+     * setLeftHalf:
+     * Magnifier view occupies the left half of the screen.
+     */
+    setLeftHalf: function() {
+        this.setPosition(0, 0);
+        this.setSize(global.screen_width/2, global.screen_height);
+        this.scrollToMousePos();
+        this._magView.set_border_width(BORDER_WIDTH);
+        this._screenPosition = ScreenPosition.LEFT_HALF;
+    },
+
+    /**
+     * setRightHalf:
+     * Magnifier view occupies the right half of the screen.
+     */
+    setRightHalf: function() {
+        this.setPosition(global.screen_width/2, 0);
+        this.setSize(global.screen_width/2, global.screen_height);
+        this.scrollToMousePos();
+        this._magView.set_border_width(BORDER_WIDTH);
+        this._screenPosition = ScreenPosition.RIGHT_HALF;
+    },
+
+    /**
+     * getScreenPosition:
+     * Tell the outside world what the current mode is -- magnifiying the
+     * top half, bottom half, etc.
+     * @return:  the current mode.
+     */
+    getScreenPosition: function() {
+        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: function() {
+        let [objUnder, xMouse, yMouse, mask] =
+            Gdk.Screen.get_default().get_root_window().get_pointer();
+
+        if (this._mouseTrackingMode == MouseTrackingMode.PROPORTIONAL) {
+            this._setROIProportional(xMouse, yMouse);
+        }
+        else if (this._mouseTrackingMode == MouseTrackingMode.PUSH) {
+            this._setROIPush(xMouse, yMouse);
+        }
+        else if (this._mouseTrackingMode == MouseTrackingMode.CENTERED) {
+            this._setROICentered(xMouse, yMouse);
+        }
+        this._updateMousePosition(true);
+
+        // Determine whether the system mouse pointer is over this zoom region.
+        return this.isMouseOverRegion(xMouse, yMouse);
+    },
+
+    /**
+     * setFullScreenMode:
+     * Set the Magnifier to full-screen mode.
+     * Note:  disallows lens mode.
+     */
+    setFullScreenMode: function() {
+        if (!this.isFullScreenMode()) {
+            this.setPosition(0, 0);
+            this.setSize(global.screen_width, global.screen_height);
+            this.scrollToMousePos();
+            this._magView.set_border_width(0);
+            this.setLensMode(false);
+            if (this.isActive())
+                this._magnifier.hideSystemCursor();
+        }
+    },
+
+    /**
+     * setScreenPosition:
+     * Positions the magnifier 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: function(inPosition) {
+        switch (inPosition) {
+            case ScreenPosition.FULL_SCREEN:
+                this.setFullScreenMode();
+                break;
+            case ScreenPosition.TOP_HALF:
+                this.setTopHalf();
+                break;
+            case ScreenPosition.BOTTOM_HALF:
+                this.setBottomHalf();
+                break;
+            case ScreenPosition.LEFT_HALF:
+                this.setLeftHalf();
+                break;
+            case ScreenPosition.RIGHT_HALF:
+                this.setRightHalf();
+                break;
+        }
+    },
+
+    /**
+     * scrollContentsTo:
+     * Shift the contents of the magnified view such it is centered on the given
+     * coordinate.  Also, update the position of the magnified mouse image after
+     * the shift.
+     * @x:      The x-coord of the point to center on.
+     * @y:      The y-coord of the point to center on.
+     */
+    scrollContentsTo: function(x, y) {
+        this._scrollToPosition(x, y);
+        this._updateMousePosition(false /* mouse didn't move */);
+    },
+
+    /**
+     * isMouseOverRegion:
+     * Return whether the system mouse sprite is over this ZoomRegion.  If the
+     * mouse's position is not given, then it is fetched.
+     * @xMouse:     The system mouse's x-coord.  Optional.
+     * @yMouse:     The system mouse's y-coord.  Optional.
+     * @return:     Boolean:  true if the mouse is over the zoom region; false
+     *              otherwise.
+     */
+    isMouseOverRegion: function(xMouse, yMouse) {
+        let mouseIsOver = false;
+        if (this.isActive()) {
+            if (!xMouse || !yMouse) {
+                let [objUnder, x, y, mask] =
+                    Gdk.Screen.get_default().get_root_window().get_pointer();
+                xMouse = x;
+                yMouse = y;
+            }
+            let [x, y] = this.getPosition();
+            let [width, height] = this.getSize();
+            mouseIsOver = (
+                xMouse >= x && xMouse < (x + width) &&
+                yMouse >= y && yMouse < (y + height)
+            );
+        }
+        return mouseIsOver;
+    },
+
+    //// Private methods ////
+
+    _scrollToPosition: function(x, y) {
+        // Given the point (x, y) in non-magnified coordinates, scroll the
+        // magnified contenst such that the point is at the centre of the
+        // magnified view.
+        let [xMagFactor, yMagFactor] = this.getMagFactor();
+        let xMagnified = x * xMagFactor;
+        let yMagnified = y * yMagFactor;
+
+        let [xCenterMagView, yCenterMagView] = this.getCenter();
+        let newX = xCenterMagView - xMagnified;
+        let newY = yCenterMagView - yMagnified;
+
+        if (this._clampScrollingAtEdges) {
+            if (newX > 0)
+                newX = 0;
+            else if (newX < this._rightStop)
+                newX = this._rightStop;
+            if (newY > 0)
+                newY = 0;
+            else if (newY < this._bottomStop)
+                newY = this._bottomStop;
+            this._uiGroupClone.set_position(newX, newY);
+        }
+        else
+            this._uiGroupClone.set_position(newX, newY);
+
+        // 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.isFullScreenMode())
+            this.setPosition(x - xCenterMagView, y - yCenterMagView);
+    },
+
+    _calcRightBottomStops: function() {
+        // Calculate the location of the top-left corner of _uiGroupClone
+        // when its right and bottom edges are coincident with the right and
+        // bottom edges of the _magView.
+        let [contentWidth, contentHeight] = this._uiGroupClone.get_size();
+        let [viewWidth, viewHeight] = this.getSize();
+        let [xMagFactor, yMagFactor] = this.getMagFactor();
+        this._rightStop = viewWidth - (contentWidth * xMagFactor);
+        this._bottomStop = viewHeight - (contentHeight * yMagFactor);
+    },
+
+    _setROIPush: function(xMouse, yMouse) {
+        let [xRoi, yRoi, widthRoi, heightRoi] = this.getROI();
+        let [cursorWidth, cursorHeight] = this._mouseRoot.get_size();
+        xPos = xRoi + widthRoi / 2;
+        yPos = yRoi + heightRoi / 2;
+        let xRoiRight = xRoi + widthRoi - cursorWidth;
+        let yRoiBottom = yRoi + heightRoi - cursorHeight;
+
+        let xPos;
+        let yPos;
+        if (xMouse < xRoi)
+            xPos -= (xRoi - xMouse);
+        else if (xMouse > xRoiRight)
+            xPos += (xMouse - xRoiRight);
+
+        if (yMouse < yRoi)
+            yPos -= (yRoi - yMouse);
+        else if (yMouse > yRoiBottom)
+            yPos += (yMouse - yRoiBottom);
+
+        this._scrollToPosition(xPos, yPos);
+    },
+
+    _setROIProportional: function(xMouse, yMouse) {
+        let [xRoi, yRoi, widthRoi, heightRoi] = this.getROI();
+        let halfScreenWidth = global.screen_width / 2;
+        let halfScreenHeight = global.screen_height / 2;
+        let xProportion = (halfScreenWidth - xMouse) / halfScreenWidth;
+        let yProportion = (halfScreenHeight - yMouse) / halfScreenHeight;
+        let xPos = xMouse + xProportion * widthRoi / 2;
+        let yPos = yMouse + yProportion * heightRoi / 2;
+
+        this._scrollToPosition(xPos, yPos);
+    },
+
+    _setROICentered: function(xMouse, yMouse) {
+        this._scrollToPosition(xMouse, yMouse);
+    },
+
+    _updateMousePosition: function(mouseMoved) {
+        let [x, y] = this._uiGroupClone.get_position();
+        let [xCenterMagView, yCenterMagView] = this.getCenter();
+        let [objUnder, xMouse, yMouse, mask] =
+            Gdk.Screen.get_default().get_root_window().get_pointer();
+        let [xMagFactor, yMagFactor] = this.getMagFactor();
+
+        let xMagMouse = xMouse * xMagFactor + x;
+        let yMagMouse = yMouse * yMagFactor + y;
+        if (mouseMoved) {
+            if (x == 0)
+                xMagMouse = xMouse * xMagFactor;
+            else if (x == this._rightStop)
+                xMagMouse = (xMouse * xMagFactor) + this._rightStop;
+            else if (this._mouseTrackingMode == MouseTrackingMode.CENTERED)
+                xMagMouse = xCenterMagView;
+
+            if (y == 0)
+                yMagMouse = yMouse * yMagFactor;
+            else if (y == this._bottomStop)
+                yMagMouse = (yMouse * yMagFactor) + this._bottomStop;
+            else if (this._mouseTrackingMode == MouseTrackingMode.CENTERED)
+                yMagMouse = yCenterMagView;
+        }
+        this._mouseRoot.set_position(xMagMouse, yMagMouse);
+    }
+}
diff --git a/js/ui/magnifierDBus.js b/js/ui/magnifierDBus.js
new file mode 100755
index 0000000..b00f8a9
--- /dev/null
+++ b/js/ui/magnifierDBus.js
@@ -0,0 +1,282 @@
+/* -*- mode: js2; js2-basic-offset: 4; indent-tabs-mode: nil -*- */
+
+const DBus = imports.dbus;
+const Main = imports.ui.main;
+
+const MAG_SERVICE_NAME = 'org.freedesktop.Magnifier';
+const MAG_SERVICE_PATH = '/org/freedesktop/Magnifier';
+const ZOOM_SERVICE_NAME = 'org.freedesktop.Magnifier.ZoomRegion';
+const ZOOM_SERVICE_PATH = '/org/freedesktop/Magnifier/ZoomRegion';
+
+// Subset of gnome-mag's Magnifier dbus interface -- to be expanded.  See:
+// http://git.gnome.org/browse/gnome-mag/tree/xml/org.freedesktop.gnome.Magnifier.xml
+const MagnifierIface = {
+    name: MAG_SERVICE_NAME,
+    methods: [
+                { name: 'setActive', inSignature: 'b', outSignature: '' },
+                { name: 'isActive', inSignature: '', outSignature: 'b' },
+                { name: 'showCursor', inSignature: '', outSignature: '' },
+                { name: 'hideCursor', inSignature: '', outSignature: ''  },
+                { name: 'createZoomRegion', inSignature: 'ddaiai', outSignature: 'o' },
+                { name: 'addZoomRegion', inSignature: 'o', outSignature: 'b' },
+                { name: 'getZoomRegions', inSignature: '', outSignature: 'ao' },
+                { name: 'clearAllZoomRegions', inSignature: '', outSignature: '' },
+                { name: 'fullScreenCapable', inSignature: '', outSignature: 'b' },
+             ],
+    signals: [],
+    properties: []
+};
+
+// Subset of gnome-mag's ZoomRegion dbus interface -- to be expanded.  See:
+// http://git.gnome.org/browse/gnome-mag/tree/xml/org.freedesktop.gnome.ZoomRegion.xml
+const ZoomRegionIface = {
+    name: ZOOM_SERVICE_NAME,
+    methods: [
+                { name: 'setMagFactor', inSignature: 'dd', outSignature: ''},
+                { name: 'getMagFactor', inSignature: '', outSignature: 'dd' },
+                { name: 'setRoi', inSignature: 'ai', outSignature: '' },
+                { name: 'getRoi', inSignature: '', outSignature: 'ai' },
+                { name: 'moveResize', inSignature: 'ai', outSignature: '' },
+             ],
+    signals: [],
+    properties: []
+};
+
+// For making unique ZoomRegion DBus proxy object paths of the form:
+// "/org/freedesktop/Magnifier/ZoomRegion/zoomer0",
+// "/org/freedesktop/Magnifier/ZoomRegion/zoomer1", etc.
+let _zoomRegionInstanceCount = 0;
+
+function ShellMagnifier() {
+    this._init();
+}
+
+ShellMagnifier.prototype = {
+    _init: function() {
+        this._zoomers = {};
+        DBus.session.exportObject(MAG_SERVICE_PATH, this);
+    },
+
+    /**
+     * setActive:
+     * @activate:   Boolean to activate or de-activate the magnifier.
+     */
+    setActive: function(activate) {
+        Main.magnifier.setActive(activate);
+    },
+
+    /**
+     * isActive:
+     * @return  Whether the magnifier is active (boolean).
+     */
+    isActive: function() {
+        return Main.magnifier.isActive();
+    },
+
+    /**
+     * showCursor:
+     * Show the system mouse pointer.
+     */
+    showCursor: function() {
+        Main.magnifier.showSystemCursor();
+    },
+
+    /**
+     * hideCursor:
+     * Hide the system mouse pointer.
+     */
+    hideCursor: function() {
+        Main.magnifier.hideSystemCursor();
+    },
+
+    /**
+     * createZoomRegion:
+     * Allocate a ZoomRegion instance and return that as a
+     * /org/freedesktop/Magnifier/ZoomRegion.
+     * @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             Array of integers defining the region of the
+     *                  screen/desktop to magnify.  The array has the form
+     *                  [x, y, width, height].
+     * @viewPort        Array of integers, [ x, y, width, height ] that defines
+     *                  the position of the ZoomRegion on screen.
+     * @return          The newly created ZoomRegion.
+     */
+    createZoomRegion: function(xMagFactor, yMagFactor, roi, viewPort) {
+        let ROI = { x: roi[0], y: roi[1], width: roi[2], height: roi[3] };
+        let viewBox = { x: viewPort[0], y: viewPort[1], width: viewPort[2], height: viewPort[3] };
+        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.
+     * @zoomerObjectPath:   The object path for the zoom region proxy.
+     */
+    addZoomRegion: function(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.
+     * @return:     The Magnifier's zoom region list as an array of DBus object
+     *              paths.
+     */
+    getZoomRegions: function() {
+        // 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 (function(aZoomRegion, index, array) {
+            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: function() {
+        Main.magnifier.clearAllZoomRegions();
+        let i = 0;
+        for (let objectPath in this._zoomers) {
+            let proxyAndZoomer = this._zoomers[objectPath];
+            proxyAndZoomer.zoomRegionProxy = null;
+            proxyAndZoomer.zoomRegion = null;
+            delete this._zoomers[objectPath];
+        }
+        for (let objectPath in this._zoomers) {
+            log ("SHOULDN'T GET HERE (" + objectPath + ")");
+        }
+        this._zoomers = {};
+    },
+
+    /**
+     * fullScreenCapable:
+     * Consult if the Magnifier can magnify in full-screen mode.
+     * @return  Always return true.
+     */
+    fullScreenCapable: function() {
+        return true;
+    }
+}
+
+/**
+ * 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.
+ */
+function ShellMagnifierZoomRegion(zoomerObjectPath, zoomRegion) {
+    this._init(zoomerObjectPath, zoomRegion);
+}
+
+ShellMagnifierZoomRegion.prototype = {
+    _init: function(zoomerObjectPath, zoomRegion) {
+        this._zoomRegion = zoomRegion;
+        DBus.session.proxifyObject(this, ZOOM_SERVICE_NAME, zoomerObjectPath);
+        DBus.session.exportObject(zoomerObjectPath, this);
+    },
+
+    /**
+     * 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: function(xMagFactor, yMagFactor) {
+        this._zoomRegion.setMagFactor(xMagFactor, yMagFactor);
+    },
+
+    /**
+     * 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: function() {
+        return this._zoomRegion.getMagFactor();
+    },
+
+    /**
+     * setRoi:
+     * Sets the "region of interest" that the ZoomRegion is magnifying.
+     * @roi     Array, [x, y, width, height], defining the region of the screen to
+     *          magnify. The values are in screen (unmagnified) coordinate
+     *          space.
+     */
+    setRoi: function(roi) {
+        let roiObject = { x: roi[0], y: roi[1], width: roi[2], height: roi[3] };
+        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.
+     * @return  an array, [x, y, width, height], representing the bounding
+     *          rectangle of what is shown in the magnified view.
+     */
+    getRoi: function() {
+        return this._zoomRegion.getROI();
+    },
+
+    /**
+     * moveResize
+     * Sets the position and size of the ZoomRegion on screen.
+     * @viewPort    Array, [x, y, width, height], defining the position and size
+     *              on screen to place the zoom region.
+     */
+    moveResize: function(viewPort) {
+        let viewRect = { x: viewPort[0], y: viewPort[1], width: viewPort[2], height: viewPort[3] };
+        this._zoomRegion.setViewPort(viewRect);
+    }
+}
+
+DBus.conformExport(ShellMagnifier.prototype, MagnifierIface);
+DBus.conformExport(ShellMagnifierZoomRegion.prototype, ZoomRegionIface);
diff --git a/js/ui/main.js b/js/ui/main.js
index aced139..adf109d 100644
--- a/js/ui/main.js
+++ b/js/ui/main.js
@@ -25,6 +25,7 @@ const NotificationDaemon = imports.ui.notificationDaemon;
 const ShellDBus = imports.ui.shellDBus;
 const Sidebar = imports.ui.sidebar;
 const WindowManager = imports.ui.windowManager;
+const Magnifier = imports.ui.magnifier;
 
 const DEFAULT_BACKGROUND_COLOR = new Clutter.Color();
 DEFAULT_BACKGROUND_COLOR.from_pixel(0x2266bbff);
@@ -43,6 +44,8 @@ let recorder = null;
 let shellDBusService = null;
 let modalCount = 0;
 let modalActorFocusStack = [];
+let uiGroup = null;
+let magnifier = null;
 let _errorLogStack = [];
 let _startDate;
 
@@ -109,6 +112,12 @@ function start() {
        getRunDialog().open();
     });
 
+    // Set up stage hierarchy to group all UI actors under one container.
+    uiGroup = new Clutter.Group();
+    global.window_group.reparent(uiGroup);
+    global.overlay_group.reparent(uiGroup);
+    global.stage.add_actor(uiGroup);
+
     placesManager = new PlaceDisplay.PlacesManager();
     overview = new Overview.Overview();
     chrome = new Chrome.Chrome();
@@ -158,6 +167,9 @@ function start() {
 
     global.stage.connect('captured-event', _globalKeyPressHandler);
 
+    // Install magnifier.
+    magnifier = new Magnifier.Magnifier();
+
     _log('info', 'loaded at ' + _startDate);
     log('GNOME Shell started at ' + _startDate);
 
diff --git a/js/ui/panel.js b/js/ui/panel.js
index 1a989fe..a8d52dd 100644
--- a/js/ui/panel.js
+++ b/js/ui/panel.js
@@ -600,7 +600,7 @@ Panel.prototype = {
                                    transition: 'linear',
                                    onUpdate: function() { ripple.opacity = 255 * Math.sqrt(ripple._opacity); },
                                    onComplete: function() { ripple.destroy(); } });
-        global.stage.add_actor(ripple);
+        Main.uiGroup.add_actor(ripple);
     },
 
     _onHotCornerEntered : function() {
diff --git a/js/ui/runDialog.js b/js/ui/runDialog.js
index de8d081..e6080f1 100644
--- a/js/ui/runDialog.js
+++ b/js/ui/runDialog.js
@@ -214,7 +214,7 @@ RunDialog.prototype = {
                                           y: 0,
                                           width: global.screen_width,
                                           height: global.screen_height });
-        global.stage.add_actor(this._group);
+        Main.uiGroup.add_actor(this._group);
 
         let lightbox = new Lightbox.Lightbox(this._group, true);
 
diff --git a/js/ui/workspaceSwitcherPopup.js b/js/ui/workspaceSwitcherPopup.js
index 655779c..0724088 100644
--- a/js/ui/workspaceSwitcherPopup.js
+++ b/js/ui/workspaceSwitcherPopup.js
@@ -5,6 +5,7 @@ const Lang = imports.lang;
 const Mainloop = imports.mainloop;
 const Shell = imports.gi.Shell;
 const St = imports.gi.St;
+const Main = imports.ui.main;
 
 const Tweener = imports.ui.tweener;
 
@@ -25,7 +26,7 @@ WorkspaceSwitcherPopup.prototype = {
                                          y: 0,
                                          width: global.screen_width,
                                          height: global.screen_height });
-        global.stage.add_actor(this.actor);
+        Main.uiGroup.add_actor(this.actor);
 
         this._container = new St.BoxLayout({ style_class: "workspace-switcher-container" });
         this._list = new St.BoxLayout({ style_class: "workspace-switcher" });
diff --git a/src/Makefile.am b/src/Makefile.am
index 0f6457f..74d564a 100644
--- a/src/Makefile.am
+++ b/src/Makefile.am
@@ -77,6 +77,8 @@ libgnome_shell_la_SOURCES =			\
 	shell-gtk-embed.h			\
 	shell-menu.c       \
 	shell-menu.h       \
+	shell-xfixes-cursor.c \
+	shell-xfixes-cursor.h \
 	shell-overflow-list.c		\
 	shell-overflow-list.h		\
 	shell-process.c				\
diff --git a/src/shell-global.c b/src/shell-global.c
old mode 100644
new mode 100755
index 4cf1e38..3cdff2f
--- a/src/shell-global.c
+++ b/src/shell-global.c
@@ -26,6 +26,7 @@
 #endif
 
 #define SHELL_DBUS_SERVICE "org.gnome.Shell"
+#define MAGNIFIER_DBUS_SERVICE "org.freedesktop.Magnifier"
 
 static void grab_notify (GtkWidget *widget, gboolean is_grab, gpointer user_data);
 static void update_root_window_pixmap (ShellGlobal *global);
@@ -845,6 +846,20 @@ shell_global_grab_dbus_service (ShellGlobal *global)
           exit (1);
         }
     }
+
+  /* ...and the org.freedesktop.Magnifier service.
+   */
+  if (!dbus_g_proxy_call (bus, "RequestName", &error,
+                          G_TYPE_STRING, MAGNIFIER_DBUS_SERVICE,
+                          G_TYPE_UINT, 0,
+                          G_TYPE_INVALID,
+                          G_TYPE_UINT, &request_name_result,
+                          G_TYPE_INVALID))
+    {
+      g_print ("failed to acquire %s: %s\n", MAGNIFIER_DBUS_SERVICE, error->message);
+      /* Failing to acquire the magnifer service is not fatal.  Log the error,
+       * but keep going. */
+    }
   g_object_unref (bus);
 }
 
diff --git a/src/shell-xfixes-cursor.c b/src/shell-xfixes-cursor.c
new file mode 100755
index 0000000..3372e58
--- /dev/null
+++ b/src/shell-xfixes-cursor.c
@@ -0,0 +1,392 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+
+
+#include "config.h"
+#include <stdio.h>
+#include <stdlib.h>
+
+#include "shell-xfixes-cursor.h"
+
+#include <clutter/x11/clutter-x11.h>
+#include <X11/extensions/Xfixes.h>
+
+struct _ShellXFixesCursorClass
+{
+  GObjectClass parent_class;
+};
+
+struct _ShellXFixesCursor {
+  GObject parent;
+
+  ClutterStage *stage;
+
+  gboolean have_xfixes;
+  int xfixes_event_base;
+
+  gboolean is_showing;
+
+  GdkPixbuf *cursor_pixbuf;
+  int cursor_hot_x;
+  int cursor_hot_y;
+};
+
+static void xfixes_cursor_show        (ShellXFixesCursor *xfixes_cursor);
+static void xfixes_cursor_hide        (ShellXFixesCursor *xfixes_cursor);
+
+static void xfixes_cursor_set_stage   (ShellXFixesCursor *xfixes_cursor,
+                                       ClutterStage  *stage);
+
+static void      xfixes_cursor_reset_image        (ShellXFixesCursor *xfixes_cursor);
+static void      xfixes_cursor_free_cursor_pixels (guchar *pixels, gpointer data);
+static GdkPixbuf *xfixes_cursor_make_gdkpixbuf    (XFixesCursorImage *cursor_image);
+
+enum {
+  PROP_0,
+  PROP_STAGE,
+};
+
+G_DEFINE_TYPE(ShellXFixesCursor, shell_xfixes_cursor, G_TYPE_OBJECT);
+
+static guint cursor_change_signal = 0;
+
+static void
+shell_xfixes_cursor_init (ShellXFixesCursor *xfixes_cursor)
+{
+  // (JS) Best (?) that can be assumed since XFixes doesn't provide a way of
+  // detecting if the system mouse cursor is showing or not.
+  xfixes_cursor->is_showing = TRUE;
+}
+
+static void
+shell_xfixes_cursor_finalize (GObject  *object)
+{
+  ShellXFixesCursor *xfixes_cursor = SHELL_XFIXES_CURSOR (object);
+
+  // Make sure the system cursor is showing before leaving the stage.
+  xfixes_cursor_show(xfixes_cursor);
+  xfixes_cursor_set_stage (xfixes_cursor, NULL);
+  if (xfixes_cursor->cursor_pixbuf)
+    g_object_unref (xfixes_cursor->cursor_pixbuf);
+
+  G_OBJECT_CLASS (shell_xfixes_cursor_parent_class)->finalize (object);
+}
+
+static void
+xfixes_cursor_on_stage_destroy (ClutterActor  *actor,
+                                ShellXFixesCursor *xfixes_cursor)
+{
+  xfixes_cursor_set_stage (xfixes_cursor, NULL);
+}
+
+static ClutterX11FilterReturn
+xfixes_cursor_event_filter (XEvent        *xev,
+                            ClutterEvent  *cev,
+                            gpointer       data)
+{
+  ShellXFixesCursor *xfixes_cursor = data;
+
+  if (xev->xany.window != clutter_x11_get_stage_window (xfixes_cursor->stage))
+    return CLUTTER_X11_FILTER_CONTINUE;
+
+  if (xev->xany.type == xfixes_cursor->xfixes_event_base + XFixesCursorNotify)
+    {
+      XFixesCursorNotifyEvent *notify_event = (XFixesCursorNotifyEvent *)xev;
+      if (notify_event->subtype == XFixesDisplayCursorNotify)
+        xfixes_cursor_reset_image (xfixes_cursor);
+    }
+    return CLUTTER_X11_FILTER_CONTINUE;
+}
+
+static void
+xfixes_cursor_set_stage (ShellXFixesCursor *xfixes_cursor,
+                         ClutterStage  *stage)
+{
+  if (xfixes_cursor->stage == stage)
+    return;
+
+  if (xfixes_cursor->stage)
+    {
+      g_signal_handlers_disconnect_by_func (xfixes_cursor->stage,
+                                            (void *)xfixes_cursor_on_stage_destroy,
+                                            xfixes_cursor);
+
+      clutter_x11_remove_filter (xfixes_cursor_event_filter, xfixes_cursor);
+    }
+  xfixes_cursor->stage = stage;
+  if (xfixes_cursor->stage)
+    {
+      int error_base;
+
+      xfixes_cursor->stage = stage;
+      g_signal_connect (xfixes_cursor->stage, "destroy",
+                        G_CALLBACK (xfixes_cursor_on_stage_destroy), xfixes_cursor);
+
+      clutter_x11_add_filter (xfixes_cursor_event_filter, xfixes_cursor);
+
+      xfixes_cursor->have_xfixes = XFixesQueryExtension (clutter_x11_get_default_display (),
+                                                         &xfixes_cursor->xfixes_event_base,
+                                                         &error_base);
+      if (xfixes_cursor->have_xfixes)
+        XFixesSelectCursorInput (clutter_x11_get_default_display (),
+                                 clutter_x11_get_stage_window (stage),
+                                 XFixesDisplayCursorNotifyMask);
+
+      xfixes_cursor_reset_image (xfixes_cursor);
+    }
+}
+
+static void
+xfixes_cursor_show (ShellXFixesCursor *xfixes_cursor)
+{
+  int minor, major;
+  Display *xdisplay;
+  Window xwindow;
+
+  if (xfixes_cursor->is_showing == TRUE)
+      return;
+
+  if (!xfixes_cursor->have_xfixes)
+      return;
+
+  xdisplay = clutter_x11_get_default_display ();
+  xwindow = clutter_x11_get_stage_window (xfixes_cursor->stage);
+  XFixesQueryVersion (xdisplay, &major, &minor);
+  if (major >= 4)
+    {
+      XFixesShowCursor (xdisplay, xwindow);
+      xfixes_cursor->is_showing = TRUE;
+    }
+}
+
+static void
+xfixes_cursor_hide (ShellXFixesCursor *xfixes_cursor)
+{
+  int minor, major;
+  Display *xdisplay;
+  Window xwindow;
+
+  if (xfixes_cursor->is_showing == FALSE)
+      return;
+
+  if (!xfixes_cursor->have_xfixes)
+      return;
+
+  xdisplay = clutter_x11_get_default_display ();
+  xwindow = clutter_x11_get_stage_window (xfixes_cursor->stage);
+  XFixesQueryVersion (xdisplay, &major, &minor);
+  if (major >= 4)
+    {
+      XFixesHideCursor (xdisplay, xwindow);
+      xfixes_cursor->is_showing = FALSE;
+    }
+}
+
+static void
+xfixes_cursor_free_cursor_pixels (guchar *pixels, gpointer data)
+{
+  XFree (data);
+}
+
+static GdkPixbuf *
+xfixes_cursor_make_gdkpixbuf (XFixesCursorImage *cursor_image)
+{
+  GdkPixbuf *cursor_pixbuf = NULL;
+  int i, count;
+  guint32 pixval;
+
+  if (cursor_image)
+    {
+      // Convert to rgba.
+      count = cursor_image->width * cursor_image->height;
+      for (i = 0; i < count; ++i) {
+          pixval = GUINT_TO_LE (cursor_image->pixels[i]);
+          cursor_image->pixels[i] = pixval;
+      }
+      cursor_pixbuf = gdk_pixbuf_new_from_data (
+        (guchar *) cursor_image->pixels, GDK_COLORSPACE_RGB,
+        TRUE, 8, cursor_image->width, cursor_image->height,
+        cursor_image->width * 4,
+        xfixes_cursor_free_cursor_pixels, cursor_image);
+    }
+  return cursor_pixbuf;
+}
+
+static void
+xfixes_cursor_reset_image (ShellXFixesCursor *xfixes_cursor)
+{
+  XFixesCursorImage *cursor_image;
+  GdkPixbuf *pixbuf = NULL;
+
+  if (!xfixes_cursor->have_xfixes)
+    return;
+
+  cursor_image = XFixesGetCursorImage (clutter_x11_get_default_display ());
+
+  // NOTE (JS):  always destroying the current image and replacing with the
+  // latest, but it would be more efficient to cache the images and just swap.
+  // Not sure how much more efficient that is, though.
+  pixbuf = xfixes_cursor_make_gdkpixbuf (cursor_image);
+  if (pixbuf != NULL)
+  {
+    if (xfixes_cursor->cursor_pixbuf != NULL)
+       g_object_unref (xfixes_cursor->cursor_pixbuf);
+
+    xfixes_cursor->cursor_pixbuf = pixbuf;
+    xfixes_cursor->cursor_hot_x = cursor_image->xhot;
+    xfixes_cursor->cursor_hot_y = cursor_image->yhot;
+
+    g_signal_emit (xfixes_cursor, cursor_change_signal, 0);
+  }
+}
+
+static void
+shell_xfixes_cursor_set_property (GObject      *object,
+                                 guint         prop_id,
+                                 const GValue *value,
+                                 GParamSpec   *pspec)
+{
+  ShellXFixesCursor *xfixes_cursor = SHELL_XFIXES_CURSOR (object);
+
+  switch (prop_id)
+    {
+    case PROP_STAGE:
+      xfixes_cursor_set_stage (xfixes_cursor, g_value_get_object (value));
+      break;
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+      break;
+    }
+}
+
+static void
+shell_xfixes_cursor_get_property (GObject         *object,
+                             guint            prop_id,
+                             GValue          *value,
+                             GParamSpec      *pspec)
+{
+  ShellXFixesCursor *xfixes_cursor = SHELL_XFIXES_CURSOR (object);
+
+  switch (prop_id)
+    {
+    case PROP_STAGE:
+      g_value_set_object (value, G_OBJECT (xfixes_cursor->stage));
+      break;
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+      break;
+    }
+}
+
+static void
+shell_xfixes_cursor_class_init (ShellXFixesCursorClass *klass)
+{
+  GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
+
+  gobject_class->finalize = shell_xfixes_cursor_finalize;
+
+  cursor_change_signal = g_signal_new ("cursor-change",
+                                       G_TYPE_FROM_CLASS (klass),
+                                       G_SIGNAL_RUN_LAST,
+                                       0,
+                                       NULL, NULL,
+                                       g_cclosure_marshal_VOID__VOID,
+                                       G_TYPE_NONE, 0);
+
+  gobject_class->get_property = shell_xfixes_cursor_get_property;
+  gobject_class->set_property = shell_xfixes_cursor_set_property;
+
+  g_object_class_install_property (gobject_class,
+                                   PROP_STAGE,
+                                   g_param_spec_object ("stage",
+                                                        "Stage",
+                                                        "Stage for mouse cursor",
+                                                        CLUTTER_TYPE_STAGE,
+                                                        G_PARAM_READWRITE));
+}
+
+/**
+ * shell_xfixes_cursor_new:
+ * @stage: The #ClutterStage
+ *
+ * Create a new #ShellXFixesCursor for manipulating the system mouse cursor.
+ *
+ * Return value: The newly created #ShellXFixesCursor object
+ */
+ShellXFixesCursor     *
+shell_xfixes_cursor_new (ClutterStage  *stage)
+{
+  return g_object_new (SHELL_TYPE_XFIXES_CURSOR,
+                       "stage",    stage,
+                       NULL);
+}
+
+/**
+ * shell_xfixes_cursor_hide:
+ * @xfixes_cursor: the #ShellXFixesCursor
+ *
+ * Hide the system mouse cursor.
+ */
+void
+shell_xfixes_cursor_hide (ShellXFixesCursor *xfixes_cursor)
+{
+  g_return_if_fail (SHELL_IS_XFIXES_CURSOR (xfixes_cursor));
+
+  xfixes_cursor_hide (xfixes_cursor);
+}
+
+/**
+ * shell_xfixes_cursor_show:
+ * @xfixes_cursor: the #ShellXFixesCursor
+ *
+ * Show the system mouse cursor to show
+ */
+void
+shell_xfixes_cursor_show (ShellXFixesCursor *xfixes_cursor)
+{
+  g_return_if_fail (SHELL_IS_XFIXES_CURSOR (xfixes_cursor));
+
+  xfixes_cursor_show (xfixes_cursor);
+}
+
+/**
+ * shell_xfixes_cursor_get_gdkpixbuf:
+ * @xfixes_cursor: the #ShellXFixesCursor
+ *
+ * Return the current mouse cursor image.
+ */
+GdkPixbuf *
+shell_xfixes_cursor_get_gdkpixbuf (ShellXFixesCursor *xfixes_cursor)
+{
+  g_return_val_if_fail (SHELL_IS_XFIXES_CURSOR (xfixes_cursor), NULL);
+
+  return xfixes_cursor->cursor_pixbuf;
+}
+
+/**
+ * shell_xfixes_cursor_get_hot_x:
+ * @xfixes_cursor: the #ShellXFixesCursor
+ *
+ * Return the current mouse cursor's hot x-coordinate.
+ */
+int
+shell_xfixes_cursor_get_hot_x (ShellXFixesCursor *xfixes_cursor)
+{
+  g_return_val_if_fail (SHELL_IS_XFIXES_CURSOR (xfixes_cursor), 0);
+
+  return xfixes_cursor->cursor_hot_x;
+}
+
+/**
+ * shell_xfixes_cursor_get_hot_y:
+ * @xfixes_cursor: the #ShellXFixesCursor
+ *
+ * Return the current mouse cursor's hot y-coordinate.
+ */
+int
+shell_xfixes_cursor_get_hot_y (ShellXFixesCursor *xfixes_cursor)
+{
+  g_return_val_if_fail (SHELL_IS_XFIXES_CURSOR (xfixes_cursor), 0);
+
+  return xfixes_cursor->cursor_hot_y;
+}
+
diff --git a/src/shell-xfixes-cursor.h b/src/shell-xfixes-cursor.h
new file mode 100755
index 0000000..81d6d80
--- /dev/null
+++ b/src/shell-xfixes-cursor.h
@@ -0,0 +1,42 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+#ifndef __SHELL_XFIXES_CURSOR_H__
+#define __SHELL_XFIXES_CURSOR_H__
+
+#include <clutter/clutter.h>
+#include <gdk-pixbuf/gdk-pixbuf.h>
+
+G_BEGIN_DECLS
+
+/**
+ * SECTION:ShellXFixesCursor
+ * short_description: Capture/manipulate system mouse cursor.
+ *
+ * The #ShellXFixesCursor object uses the XFixes extension to show/hide the
+ * the system mouse pointer, to grab its image as it changes, and emit a
+ * notification when its image changes.
+ */
+typedef struct _ShellXFixesCursor        ShellXFixesCursor;
+typedef struct _ShellXFixesCursorClass   ShellXFixesCursorClass;
+
+#define SHELL_TYPE_XFIXES_CURSOR             (shell_xfixes_cursor_get_type ())
+#define SHELL_XFIXES_CURSOR(object)          (G_TYPE_CHECK_INSTANCE_CAST ((object), SHELL_TYPE_XFIXES_CURSOR, ShellXFixesCursor))
+#define SHELL_XFIXES_CURSOR_CLASS(klass)     (G_TYPE_CHECK_CLASS_CAST ((klass), SHELL_TYPE_XFIXES_CURSOR, ShellXFixesCursorClass))
+#define SHELL_IS_XFIXES_CURSOR(object)       (G_TYPE_CHECK_INSTANCE_TYPE ((object), SHELL_TYPE_XFIXES_CURSOR))
+#define SHELL_IS_XFIXES_CURSOR_CLASS(klass)  (G_TYPE_CHECK_CLASS_TYPE ((klass), SHELL_TYPE_XFIXES_CURSOR))
+#define SHELL_XFIXES_CURSOR_GET_CLASS(obj)   (G_TYPE_INSTANCE_GET_CLASS ((obj), SHELL_TYPE_XFIXES_CURSOR, ShellXFixesCursorClass))
+
+GType               shell_xfixes_cursor_get_type     (void) G_GNUC_CONST;
+
+ShellXFixesCursor   *shell_xfixes_cursor_new (ClutterStage *stage);
+
+void                shell_xfixes_cursor_show (ShellXFixesCursor *xfixes_cursor);
+void                shell_xfixes_cursor_hide (ShellXFixesCursor *xfixes_cursor);
+
+GdkPixbuf 	    *shell_xfixes_cursor_get_gdkpixbuf (ShellXFixesCursor *xfixes_cursor);
+int                 shell_xfixes_cursor_get_hot_x (ShellXFixesCursor *xfixes_cursor);
+int                 shell_xfixes_cursor_get_hot_y (ShellXFixesCursor *xfixes_cursor);
+
+G_END_DECLS
+
+#endif /* __SHELL_XFIXES_CURSOR_H__ */
+
