diff --git a/js/ui/Makefile.am b/js/ui/Makefile.am
index 4eb3883..5052b6c 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 f211a8b..6ec0ddd 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 26e43c1..1a00239 100644
--- a/js/ui/appDisplay.js
+++ b/js/ui/appDisplay.js
@@ -564,7 +564,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 2e57456..9257104 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..72e3b10
--- /dev/null
+++ b/js/ui/magnifier.js
@@ -0,0 +1,570 @@
+/* -*- 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 ScreenPosition =
+    { NONE: 0, FULL_SCREEN: 1, TOP_HALF: 2, BOTTOM_HALF: 3, LEFT_HALF: 4, RIGHT_HALF: 5, DOCKED: 6 };
+
+// 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 BORDER_WIDTH = 8;
+
+let magDBusService = null;
+
+function Magnifier(options) {
+    this._init(options);
+}
+
+Magnifier.prototype = {
+    _init: function() {
+        // The root actor for the magnifier is a Big.Box with a frame around it.
+        const BORDER_COLOR = new Clutter.Color();
+        BORDER_COLOR.from_pixel(0x800000ff);
+        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);
+
+        this._xfixesCursor = new Shell.XFixesCursor({stage: global.stage});
+        this._cursorActor = new Big.Box();
+        this._cursorImg = new Clutter.Texture();
+        this._cursorActor.append(this._cursorImg, Big.BoxPackFlags.EXPAND);
+        this._magView.add_actor(this._cursorActor);
+        this._setMouseCursor();
+        this._xfixesCursor.connect('cursor-change', Lang.bind(this, this._setMouseCursor));
+
+        this.setMagFactor(DEFAULT_X_MAGFACTOR, DEFAULT_Y_MAGFACTOR);
+        this.setScreenPosition(DEFAULT_SCREEN_POSITION);
+        this.setLensMode(DEFAULT_LENS_MODE);
+        this._clampScrollingAtEdges = true;
+        this.startTrackingMouse();
+        this._magView.hide();
+        global.stage.add_actor(this._magView);
+
+        // Export to dbus.
+        magDBusService = new MagnifierDBus.ShellMagnifier();
+    },
+
+    /**
+     * setActive:
+     * @activate:   Boolean to activate or de-activate the magnifier.
+     */
+    setActive: function(activate) {
+        if (activate)
+            this._magView.show();
+        else {
+            this._magView.hide();
+            this._xfixesCursor.show();
+        }
+    },
+
+    /**
+     * isActive:
+     * @return  Whether the magnifier is active (boolean).
+     */
+    isActive: function() {
+        return this._magView.visible;
+    },
+
+    /**
+     * 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) {
+        xMagFactor = xMagFactor < 1 ? 1 : xMagFactor;
+        yMagFactor = yMagFactor < 1 ? 1 : yMagFactor;
+
+        // 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._cursorActor.set_scale(xMagFactor, yMagFactor);
+        this.scrollToPosition(xCentre, yCentre);
+    },
+
+    /**
+     * 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();
+    },
+
+    /**
+     * 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);
+
+        // Reposition the mouse to the centre.
+        let [xCenter, yCenter] = this.getCenter();
+        this._cursorActor.set_position(xCenter, yCenter);
+    },
+
+    /**
+     * 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;
+    },
+
+    /**
+     * scrollToPosition:
+     * Center the contents of the magnified view to the given screen
+     * (non-magnifed) coordinates.
+     * @x:          The x-coord of the position to scroll to.
+     * @y:          The y-coord of the position to scroll to.
+     * @hideMouse:  Option: Hide the magnified mouse cursor after the move.  The
+     *              default is to show the mouse.
+     */
+    scrollToPosition: function(x, y, hideMouse) {
+        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) {
+            let [contentWidth, contentHeight] = this._uiGroupClone.get_size();
+            let [viewWidth, viewHeight] = this.getSize();
+
+            // The point (rightStop, bottomStop) is the top left point of
+            // _uiGroupClone when its right and bottom edges are coincident
+            // with the right and bottom edges of _magView.
+            let rightStop = viewWidth - (contentWidth * xMagFactor);
+            let bottomStop = viewHeight - (contentHeight * yMagFactor);
+
+            if (newX > 0)
+                newX = 0;
+            else if (newX < rightStop)
+                newX = rightStop;
+            if (newY > 0)
+                newY = 0;
+            else if (newY < bottomStop)
+                newY = bottomStop;
+            this._uiGroupClone.set_position(newX, newY);
+            this._updateMousePosition(rightStop, bottomStop);
+        }
+        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);
+
+        if (hideMouse)
+            this._cursorActor.hide();
+        else
+            this._cursorActor.show();
+    },
+
+    /**
+     * 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 or allow scrolling of the magnified contents when they scroll beyond
+     * the edges of the screen.  Also, insure that the magnified mouse cursor is
+     * recentered within the magnified view when clamping is removed, as it may
+     * be off-center if near a screen edge with clamping on.
+     * @clamp:   Boolean to turn on/off clamping.
+     */
+    setClampScrollingAtEdges: function(clamp) {
+        this._clampScrollingAtEdges = clamp;
+        if (!clamp) {
+            let [xCenter, yCenter] = this.getCenter();
+            this._cursorActor.set_position(xCenter, yCenter);
+        }
+    },
+
+    /**
+     * 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;
+    },
+
+    /**
+     * setDocked:
+     * Magnifier view occupies a certain percentage of the screen.
+     */
+    setDocked: function() {
+        this.setSize(global.screen_width / 2, global.screen_height / 3);
+        this.setPosition(0, global.screen_height * 2 / 3);
+        this.scrollToMousePos();
+        this._magView.set_border_width(BORDER_WIDTH);
+        this._screenPosition = ScreenPosition.DOCKED;
+    },
+
+    /**
+     * 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;
+    },
+
+    /**
+     * 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 == null;
+    },
+
+    /**
+     * scrollToMousePos:
+     * Centre the magnified view to the position of the mouse.
+     * @prevCoord:  The previous mouse coordinates.  Used for stop scrolling if
+     *              the new position is the same as the last one (optional).
+     * @return      true.
+     */
+    scrollToMousePos: function(prevCoord) {
+        let [objUnder, mouseX, mouseY, mask] =
+            Gdk.Screen.get_default().get_root_window().get_pointer();
+        if (!prevCoord)
+            this.scrollToPosition(mouseX, mouseY);
+        else if (prevCoord.x != mouseX || prevCoord.y != mouseY) {
+            prevCoord.x = mouseX;
+            prevCoord.y = mouseY;
+            this.scrollToPosition(mouseX, mouseY);
+        }
+
+        // show/hide system cursor depending on if it is within the magnified
+        // view.
+        if (this.isActive()) {
+            let [x, y] = this.getPosition();
+            let [width, height] = this.getSize();
+            if (mouseX >= x && mouseX < (x + width) && mouseY >= y && mouseY < (y + height))
+                this._xfixesCursor.hide();
+            else
+                this._xfixesCursor.show();
+        }
+        return true;
+    },
+
+    /**
+     * 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);
+            this._xfixesCursor.hide();
+        }
+    },
+
+    /**
+     * 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,
+     *              Magnifier.RIGHT_HALF, or Magnifier.DOCKED.
+     */
+    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;
+            case ScreenPosition.DOCKED:
+                this.setDocked();
+                break;
+        }
+    },
+
+    /**
+     * scrollContentsTo:
+     * Shift the contents of the magnified view such it is centered on the given
+     * coordinate.  Also, hide the magnified mouse image in the process.
+     * @x:      The x-coord of the point to center on.
+     * @y:      The y-coord of the point to center on.
+     * @return  The new position of the UI group clone.
+     */
+    scrollContentsTo: function(x, y) {
+        return this.scrollToPosition(x, y, true);
+    },
+
+    //// Private methods ////
+
+    /**
+     * _updateMousePosition:
+     * If the actual mouse is near one of the top, left, bottom, or right edges,
+     * move the magnified mouse cursor image away from the center of the
+     * magnfied view to the position corresponding to the actual mouse.
+     * @rightStop:  The x-coord of the left edge of the magnified contents such
+     *              its right edge is coincident with the magnified view's right
+     *              edge.
+     * @bottomStop: The y-ccord of the top edge of the magnified contents such
+     *              its bottom edge is the same as the mangnified view's bottom
+     *              edge.
+     */
+     _updateMousePosition: function(rightStop, bottomStop) {
+        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 = xCenterMagView;
+        let yMagMouse = yCenterMagView;
+        if (x == 0)
+            xMagMouse = xMouse * xMagFactor;
+        else if (x == rightStop)
+            xMagMouse = (xMouse * xMagFactor) + rightStop;
+
+        if (y == 0)
+            yMagMouse = yMouse * yMagFactor;
+        else if (y == bottomStop)
+            yMagMouse = (yMouse * yMagFactor) + bottomStop;
+
+        this._cursorActor.set_position(xMagMouse, yMagMouse);
+    },
+
+    _setMouseCursor: function() {
+        let pixbuf = this._xfixesCursor.get_gdkpixbuf();
+        if (pixbuf) {
+            this._cursorActor.hide();
+            let xHot = this._xfixesCursor.get_hot_x();
+            let yHot = this._xfixesCursor.get_hot_y();
+            Shell.clutter_texture_set_from_pixbuf(this._cursorImg, pixbuf);
+            this._cursorImg.set_anchor_point(xHot - 2, yHot - 2);
+            let [xMagFactor, yMagFactor] = this.getMagFactor();
+            this._cursorActor.set_scale (xMagFactor, yMagFactor);
+            this._cursorActor.show();
+        }
+    }
+}
+
diff --git a/js/ui/magnifierDBus.js b/js/ui/magnifierDBus.js
new file mode 100755
index 0000000..c61605d
--- /dev/null
+++ b/js/ui/magnifierDBus.js
@@ -0,0 +1,160 @@
+/* -*- 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 MagnifierIface = {
+    name: MAG_SERVICE_NAME,
+    methods: [{ name: "setActive",
+                inSignature: "b",
+                outSignature: ""
+              },
+              { name: "isActive",
+                inSignature: "",
+                outSignature: "b"
+              },
+              { name: "setScreenPosition",
+                inSignature: "i",
+                outSignature: ""
+              },
+              { name: "getMagFactor",
+                inSignature: "",
+                outSignature: "dd"
+              },
+              { name: "setMagFactor",
+                inSignature: "dd",
+                outSignature: ""
+              },
+              { name: "shiftContentsTo",
+                inSignature: "ii",
+                outSignature: ""
+              },
+              { name: "getROI",
+                inSignature: "",
+                outSignature: "(iiii)"
+              },
+              { name: "setClampScrollingAtEdges",
+                inSignature: "b",
+                outSignature: ""
+              },
+              {
+                name: "fullScreenCapable",
+                inSignature: "",
+                outSignature: "b"
+              }
+             ],
+    signals: [],
+    properties: []
+};
+
+function ShellMagnifier() {
+    this._init();
+}
+
+ShellMagnifier.prototype = {
+    _init: function() {
+        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();
+    },
+
+    /**
+     * 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,
+     *              Magnifier.RIGHT_HALF, or Magnifier.DOCKED.
+     */
+    setScreenPosition: function(position) {
+        Main.magnifier.setScreenPosition(position)
+    },
+
+    /**
+     * 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 Main.magnifier.getMagFactor();
+    },
+
+    /**
+     * 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) {
+        Main.magnifier.setMagFactor(xMagFactor, yMagFactor)
+    },
+
+    /**
+     * 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 Main.magnifier.getROI();
+    },
+
+    /**
+     * shiftContentsTo:
+     * Shift the contents of the magnified view such it is centered on the given
+     * non-magnified coordinate.
+     * @x:      x-coordinate to scroll to.
+     * @y:      y-coordinate to scroll to.
+     */
+    shiftContentsTo: function(x, y) {
+        Main.magnifier.scrollContentsTo(x,y);
+    },
+
+    /**
+     * setClampScrollingAtEdges:
+     * Stop or allow scrolling of the magnified contents when they scroll beyond
+     * the edges of the screen.  Also, insure that the magnified mouse cursor is
+     * recentered within the magnified view when clamping is removed, as it may
+     * be off-center if near a screen edge with clamping on.
+     * @clamp:   Boolean to turn on/off clamping.
+     */
+    setClampScrollingAtEdges: function(clamp) {
+        Main.magnifier.setClampScrollingAtEdges(clamp);
+    },
+
+    /**
+     * fullScreenCapable:
+     * Consult if the Magnifier can apply colorblind image filters.  This is
+     * here to match the old Corba and future DBus interface for gnome-mag
+     * (http://live.gnome.org/GnomeMag).
+     * @return  Always return true.
+     */
+    fullScreenCapable: function() {
+        return true;
+    }
+};
+
+DBus.conformExport(ShellMagnifier.prototype, MagnifierIface);
diff --git a/js/ui/main.js b/js/ui/main.js
index f8c95b3..919f016 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;
 
@@ -111,6 +114,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();
@@ -147,6 +156,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/runDialog.js b/js/ui/runDialog.js
index 6465a6e..d4a2480 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);
 
diff --git a/src/Makefile.am b/src/Makefile.am
index 2c81a23..a8b3de0 100644
--- a/src/Makefile.am
+++ b/src/Makefile.am
@@ -78,6 +78,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 3e422b1..5b1af09
--- 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);
 
@@ -763,6 +764,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..bbe556d
--- /dev/null
+++ b/src/shell-xfixes-cursor.c
@@ -0,0 +1,390 @@
+/* -*- 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);
+
+  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..3bfde8c
--- /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__ */
+
