Merge lp:~veebers/unity/merge_updated_autopilot_tests_for_1.3 into lp:~unity-team/unity/libunity-7.0-breakage

[Christopher Lee]

Resolve conflicts in merging updated autopilot tests.

As requested by Michal (mhr3), merging in the conflicted parts of the autopilot tests update autopilot ver. 1.3.

[Christopher Lee (veebers)]

I have built this branch in a VM and run the Unity Autopilot tests to make sure I didn't miss anything.
(pass rate wasn't 100% but I expected that (in a VM) and none of the errors are due to this update).

[Paweł Stołowski (stolowski)]

Looks good.

review: Approve

[PS Jenkins bot (ps-jenkins)]

FAILED: Autolanding.
More details in the following jenkins job:
http://jenkins.qa.ubuntu.com/job/unity-team-unity-libunity-7.0-breakage-autolanding/71/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-team-unity-libunity-7.0-breakage-raring-amd64-autolanding/71/console

review: Needs Fixing (continuous-integration)

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:3140
http://jenkins.qa.ubuntu.com/job/unity-team-unity-libunity-7.0-breakage-ci/84/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-team-unity-libunity-7.0-breakage-raring-amd64-ci/84/console

Click here to trigger a rebuild:
http://s-jenkins:8080/job/unity-team-unity-libunity-7.0-breakage-ci/84/rebuild

review: Needs Fixing (continuous-integration)

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:3141
http://jenkins.qa.ubuntu.com/job/unity-team-unity-libunity-7.0-breakage-ci/85/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-team-unity-libunity-7.0-breakage-raring-amd64-ci/85

Click here to trigger a rebuild:
http://s-jenkins:8080/job/unity-team-unity-libunity-7.0-breakage-ci/85/rebuild

review: Approve (continuous-integration)

[Christopher Lee (veebers)]

2nd test suite ran through fine as expected (again there were failures, but none were obviously due to the merge/conflict resolution).

[Paweł Stołowski (stolowski)]

review: Approve

=== modified file 'plugins/unityshell/src/unityshell.cpp'
--- plugins/unityshell/src/unityshell.cpp	2013-05-09 16:26:04 +0000
+++ plugins/unityshell/src/unityshell.cpp	2013-05-15 16:01:29 +0000
@@ -2505,7 +2505,7 @@
         uScreen->windows_for_monitor_[monitor] = 1;
 
       if (!(mask & nonOcclusionBits) &&
-          (window->state() & CompWindowStateFullscreenMask) &&
+          (window->state() & CompWindowStateFullscreenMask && !window->minimized()) &&
           uScreen->windows_for_monitor_[monitor] == 1)
           // And I've been advised to test other things, but they don't work:
           // && (attrib.opacity == OPAQUE)) <-- Doesn't work; Only set in glDraw
 
=== added file 'tests/autopilot/unity/emulators/X11.py'
--- tests/autopilot/unity/emulators/X11.py	1970-01-01 00:00:00 +0000
+++ tests/autopilot/unity/emulators/X11.py	2013-05-15 16:01:29 +0000
@@ -0,0 +1,115 @@
+from __future__ import absolute_import
+
+from autopilot.utilities import Silence
+from autopilot.display import Display
+from autopilot.input import Mouse, Keyboard
+from autopilot.process import Window
+
+import logging
+import subprocess
+from Xlib import X, display, protocol
+
+
+logger = logging.getLogger(__name__)
+
+_display = None
+
+_blacklisted_drivers = ["NVIDIA"]
+
+def _get_display():
+    """Get a Xlib display object. Creating the display prints garbage to stdout."""
+    global _display
+    if _display is None:
+        with Silence():
+            _display = display.Display()
+    return _display
+
+def _getProperty(_type, win=None):
+    if not win:
+        win = _get_display().screen().root
+    atom = win.get_full_property(_get_display().get_atom(_type), X.AnyPropertyType)
+    if atom: return atom.value
+
+def get_desktop_viewport():
+    """Get the x,y coordinates for the current desktop viewport top-left corner."""
+    return _getProperty('_NET_DESKTOP_VIEWPORT')
+
+
+# Note: this use to exist within autopilot, moved here due to Autopilot 1.3
+# upgrade.
+def drag_window_to_screen(window, screen):
+    """Drags *window* to *screen*
+
+    :param autopilot.process.Window window: The window to drag
+    :param integer screen: The screen to drag the *window* to
+    :raises: **TypeError** if *window* is not a autopilot.process.Window
+
+    """
+    if not isinstance(window, Window):
+        raise TypeError("Window must be a autopilot.process.Window")
+
+    if window.monitor == screen:
+        logger.debug("Window %r is already on screen %d." % (window.x_id, screen))
+        return
+
+    assert(not window.is_maximized)
+    (win_x, win_y, win_w, win_h) = window.geometry
+    (mx, my, mw, mh) = Display.create().get_screen_geometry(screen)
+
+    logger.debug("Dragging window %r to screen %d." % (window.x_id, screen))
+
+    mouse = Mouse.create()
+    keyboard = Keyboard.create()
+    mouse.move(win_x + win_w/2, win_y + win_h/2)
+    keyboard.press("Alt")
+    mouse.press()
+    keyboard.release("Alt")
+
+    # We do the movements in two steps, to reduce the risk of being
+    # blocked by the pointer barrier
+    target_x = mx + mw/2
+    target_y = my + mh/2
+    mouse.move(win_x, target_y, rate=20, time_between_events=0.005)
+    mouse.move(target_x, target_y, rate=20, time_between_events=0.005)
+    mouse.release()
+
+
+# Note: this use to exist within autopilot, moved here due to Autopilot 1.3
+# upgrade.
+def set_primary_monitor(monitor):
+    """Set *monitor* to be the primary monitor.
+
+    :param int monitor: Must be between 0 and the number of configured
+     monitors.
+    :raises: **ValueError** if an invalid monitor is specified.
+    :raises: **BlacklistedDriverError** if your video driver does not
+     support this.
+
+    """
+    try:
+        glxinfo_out = subprocess.check_output("glxinfo")
+    except OSError, e:
+        raise OSError("Failed to run glxinfo: %s. (do you have mesa-utils installed?)" % e)
+
+    for dri in _blacklisted_drivers:
+        if dri in glxinfo_out:
+            raise Display.BlacklistedDriverError('Impossible change the primary monitor for the given driver')
+
+    num_monitors = Display.create().get_num_screens()
+    if monitor < 0 or monitor >= num_monitors:
+        raise ValueError('Monitor %d is not in valid range of 0 <= monitor < %d.' % (num_monitors))
+
+    default_screen = Gdk.Screen.get_default()
+    monitor_name = default_screen.get_monitor_plug_name(monitor)
+
+    if not monitor_name:
+        raise ValueError('Could not get monitor name from monitor number %d.' % (monitor))
+
+    ret = os.spawnlp(os.P_WAIT, "xrandr", "xrandr", "--output", monitor_name, "--primary")
+
+    if ret != 0:
+        raise RuntimeError('Xrandr can\'t set the primary monitor. error code: %d' % (ret))
+
+def reset_display():
+    from autopilot.input._X11 import reset_display
+    reset_display()
 
=== modified file 'tests/autopilot/unity/emulators/__init__.py'
--- tests/autopilot/unity/emulators/__init__.py	2012-09-24 02:59:48 +0000
+++ tests/autopilot/unity/emulators/__init__.py	2013-05-15 16:01:29 +0000
@@ -12,6 +12,7 @@
 from time import sleep
 
 from autopilot.introspection.dbus import DBusIntrospectionObject
+from autopilot.introspection.backends import DBusAddress
 
 
 class UnityIntrospectionObject(DBusIntrospectionObject):
@@ -19,6 +20,8 @@
     DBUS_SERVICE = "com.canonical.Unity"
     DBUS_OBJECT = "/com/canonical/Unity/Debug"
 
+    _Backend = DBusAddress.SessionBus(DBUS_SERVICE, DBUS_OBJECT)
+
 
 def ensure_unity_is_running(timeout=300):
     """Poll the unity debug interface, and return when it's ready for use.
 
=== added file 'tests/autopilot/unity/emulators/compiz.py'
--- tests/autopilot/unity/emulators/compiz.py	1970-01-01 00:00:00 +0000
+++ tests/autopilot/unity/emulators/compiz.py	2013-05-15 16:01:29 +0000
@@ -0,0 +1,63 @@
+from __future__ import absolute_import
+
+"""Functions that wrap compizconfig to avoid some unpleasantness in that module."""
+
+from __future__ import absolute_import
+
+from autopilot.utilities import Silence
+
+_global_context = None
+
+def get_global_context():
+    """Get the compizconfig global context object."""
+    global _global_context
+    if _global_context is None:
+        with Silence():
+            from compizconfig import Context
+            _global_context = Context()
+    return _global_context
+
+
+def _get_plugin(plugin_name):
+    """Get a compizconfig plugin with the specified name.
+
+    Raises KeyError of the plugin named does not exist.
+
+    """
+    ctx = get_global_context()
+    with Silence():
+        try:
+            return ctx.Plugins[plugin_name]
+        except KeyError:
+            raise KeyError("Compiz plugin '%s' does not exist." % (plugin_name))
+
+
+def get_compiz_setting(plugin_name, setting_name):
+    """Get a compiz setting object.
+
+    *plugin_name* is the name of the plugin (e.g. 'core' or 'unityshell')
+    *setting_name* is the name of the setting (e.g. 'alt_tab_timeout')
+
+    :raises: KeyError if the plugin or setting named does not exist.
+
+    :returns: a compiz setting object.
+
+    """
+    plugin = _get_plugin(plugin_name)
+    with Silence():
+        try:
+            return plugin.Screen[setting_name]
+        except KeyError:
+            raise KeyError("Compiz setting '%s' does not exist in plugin '%s'." % (setting_name, plugin_name))
+
+
+def get_compiz_option(plugin_name, setting_name):
+    """Get a compiz setting value.
+
+    This is the same as calling:
+
+    >>> get_compiz_setting(plugin_name, setting_name).Value
+
+    """
+    return get_compiz_setting(plugin_name, setting_name).Value
+
 
=== modified file 'tests/autopilot/unity/emulators/dash.py'
--- tests/autopilot/unity/emulators/dash.py	2013-05-01 22:40:19 +0000
+++ tests/autopilot/unity/emulators/dash.py	2013-05-15 16:01:29 +0000
@@ -9,8 +9,8 @@
 
 from __future__ import absolute_import
 
+from autopilot.input import Keyboard, Mouse
 
-from autopilot.emulators.input import get_keyboard, get_mouse
 from autopilot.keybindings import KeybindingsHelper
 from testtools.matchers import GreaterThan
 
@@ -28,8 +28,8 @@
 
     def __init__(self, *args, **kwargs):
         super(DashController, self).__init__(*args, **kwargs)
-        self.keyboard = get_keyboard()
-        self.mouse = get_mouse()
+        self.keyboard = Keyboard.create()
+        self.mouse = Mouse.create()
 
     def get_dash_view(self):
         """Get the dash view that's attached to this controller."""
@@ -91,7 +91,7 @@
     def preview_animation(self):
         """Returns the average progress of dash slip and animating a preview.
         Between 0.0 and 1.0.
-        
+
         """
         return self.view.preview_animation;
 
@@ -278,38 +278,33 @@
 class Result(UnityIntrospectionObject):
     """A single result in the dash."""
 
-    def __init__(self, *args, **kwargs):
-        super(Result, self).__init__(*args, **kwargs)
-        self.mouse = get_mouse()
-        self.keyboard = get_keyboard()
-
     def activate(self, double_click=True):
         tx = self.x + (self.width / 2)
         ty = self.y + (self.height / 2)
-        self.mouse.move(tx, ty)
-        self.mouse.click(1)
+        m = Mouse.create()
+        m.move(tx, ty)
+        m.click(1)
         if double_click:
-            self.mouse.click(1)
+            m.click(1)
 
     def preview(self, button=1):
         tx = self.x + (self.width / 2)
         ty = self.y + (self.height / 2)
-        self.mouse.move(tx, ty)
-        self.mouse.click(button)
+        m = Mouse.create()
+        m.move(tx, ty)
+        m.click(button)
 
     def preview_key(self):
         tx = self.x + (self.width / 2)
         ty = self.y + (self.height / 2)
-        self.mouse.move(tx, ty)
+        m = Mouse.create()
+        m.move(tx, ty)
 
-        self.keyboard.press_and_release('Menu')
+        k = Keyboard.create()
+        k.press_and_release('Menu')
 
 class FilterBar(UnityIntrospectionObject):
-    """A filterbar, as shown inside a scope."""
-
-    def __init__(self, *args, **kwargs):
-        super(FilterBar, self).__init__(*args, **kwargs)
-        self.mouse = get_mouse()
+    """A filterbar, as shown inside a lens."""
 
     def get_num_filters(self):
         """Get the number of filters in this filter bar."""
@@ -337,8 +332,9 @@
             searchbar = self._get_searchbar()
             tx = searchbar.filter_label_x + (searchbar.filter_label_width / 2)
             ty = searchbar.filter_label_y + (searchbar.filter_label_height / 2)
-            self.mouse.move(tx, ty)
-            self.mouse.click()
+            m = Mouse.create()
+            m.move(tx, ty)
+            m.click()
             self.expanded.wait_for(True)
 
     def ensure_collapsed(self):
@@ -347,8 +343,9 @@
             searchbar = self._get_searchbar()
             tx = searchbar.filter_label_x + (searchbar.filter_label_width / 2)
             ty = searchbar.filter_label_y + (searchbar.filter_label_height / 2)
-            self.mouse.move(tx, ty)
-            self.mouse.click()
+            m = Mouse.create()
+            m.move(tx, ty)
+            m.click()
             self.expanded.wait_for(False)
 
     def _get_searchbar(self):
@@ -366,17 +363,14 @@
 class FilterExpanderLabel(UnityIntrospectionObject):
     """A label that expands into a filter within a filter bar."""
 
-    def __init__(self, *args, **kwargs):
-        super(FilterExpanderLabel, self).__init__(*args, **kwargs)
-        self.mouse = get_mouse()
-
     def ensure_expanded(self):
         """Expand the filter expander label, if it's not already"""
         if not self.expanded:
             tx = self.x + self.width / 2
             ty = self.y + self.height / 2
-            self.mouse.move(tx, ty)
-            self.mouse.click()
+            m = Mouse.create()
+            m.move(tx, ty)
+            m.click()
             self.expanded.wait_for(True)
 
     def ensure_collapsed(self):
@@ -384,8 +378,9 @@
         if self.expanded:
             tx = self.x + self.width / 2
             ty = self.y + self.height / 2
-            self.mouse.move(tx, ty)
-            self.mouse.click()
+            m = Mouse.create()
+            m.move(tx, ty)
+            m.click()
             self.expanded.wait_for(False)
 
 
@@ -419,8 +414,9 @@
         if action:
             tx = action.x + (searchbar.width / 2)
             ty = action.y + (searchbar.height / 2)
-            self.mouse.move(tx, ty)
-            self.mouse.click()
+            m = Mouse.create()
+            m.move(tx, ty)
+            m.click()
 
     @property
     def cover_art(self):
@@ -468,10 +464,6 @@
 class PreviewContainer(UnityIntrospectionObject):
     """A container view for the main dash preview widget."""
 
-    def __init__(self, *args, **kwargs):
-        super(PreviewContainer, self).__init__(*args, **kwargs)
-        self.mouse = get_mouse()
-
     @property
     def content(self):
         return self.get_content()
@@ -507,13 +499,14 @@
 
         tx = navigator.button_x + (navigator.button_width / 2)
         ty = navigator.button_y + (navigator.button_height / 2)
-        self.mouse.move(tx, ty)
+        m = Mouse.create()
+        m.move(tx, ty)
 
         old_preview_initiate_count = self.preview_initiate_count
 
         for i in range(count):
             self.navigate_left_enabled.wait_for(True)
-            self.mouse.click()
+            m.click()
             self.preview_initiate_count.wait_for(GreaterThan(old_preview_initiate_count))
             old_preview_initiate_count = self.preview_initiate_count
 
@@ -523,13 +516,14 @@
 
         tx = navigator.button_x + (navigator.button_width / 2)
         ty = navigator.button_y + (navigator.button_height / 2)
-        self.mouse.move(tx, ty)
+        m = Mouse.create()
+        m.move(tx, ty)
 
         old_preview_initiate_count = self.preview_initiate_count
 
         for i in range(count):
             self.navigate_right_enabled.wait_for(True)
-            self.mouse.click()
+            m.click()
             self.preview_initiate_count.wait_for(GreaterThan(old_preview_initiate_count))
             old_preview_initiate_count = self.preview_initiate_count
 
 
=== modified file 'tests/autopilot/unity/emulators/hud.py'
--- tests/autopilot/unity/emulators/hud.py	2013-03-20 15:21:51 +0000
+++ tests/autopilot/unity/emulators/hud.py	2013-05-15 16:01:29 +0000
@@ -9,7 +9,7 @@
 
 from __future__ import absolute_import
 
-from autopilot.emulators.input import get_keyboard
+from autopilot.input import Keyboard
 from autopilot.keybindings import KeybindingsHelper
 from HTMLParser import HTMLParser
 import re
@@ -24,7 +24,7 @@
 
     def __init__(self, *args, **kwargs):
         super(HudController, self).__init__(*args, **kwargs)
-        self.keyboard = get_keyboard()
+        self.keyboard = Keyboard.create()
 
     def get_hud_view(self):
         views = self.get_children_by_type(HudView)
 
=== modified file 'tests/autopilot/unity/emulators/launcher.py'
--- tests/autopilot/unity/emulators/launcher.py	2013-03-21 11:36:49 +0000
+++ tests/autopilot/unity/emulators/launcher.py	2013-05-15 16:01:29 +0000
@@ -9,10 +9,9 @@
 
 from __future__ import absolute_import
 
-from autopilot.emulators.input import get_mouse
-from autopilot.emulators.X11 import ScreenGeometry
+from autopilot.input import Mouse
+from autopilot.display import Display, move_mouse_to_screen
 from autopilot.keybindings import KeybindingsHelper
-from autopilot.utilities import get_compiz_option
 import logging
 from testtools.matchers import NotEquals
 from time import sleep
@@ -26,6 +25,8 @@
     TrashLauncherIcon,
     )
 
+from unity.emulators.compiz import get_compiz_option
+
 logger = logging.getLogger(__name__)
 
 
@@ -68,8 +69,8 @@
         self.in_keynav_mode = False
         self.in_switcher_mode = False
 
-        self._mouse = get_mouse()
-        self._screen = ScreenGeometry()
+        self._mouse = Mouse.create()
+        self._display = Display.create()
 
     def _perform_key_nav_binding(self, keybinding):
         if not self.in_keynav_mode:
@@ -101,7 +102,7 @@
 
     def move_mouse_to_right_of_launcher(self):
         """Places the mouse to the right of this launcher."""
-        self._screen.move_mouse_to_monitor(self.monitor)
+        move_mouse_to_screen(self.monitor)
         (x, y, w, h) = self.geometry
         target_x = x + w + 10
         target_y = y + h / 2
@@ -112,7 +113,7 @@
 
     def move_mouse_over_launcher(self):
         """Move the mouse over this launcher."""
-        self._screen.move_mouse_to_monitor(self.monitor)
+        move_mouse_to_screen(self.monitor)
         (x, y, w, h) = self.geometry
         target_x = x + w / 2
         target_y = y + h / 2
@@ -137,7 +138,7 @@
         """
         if self.is_showing:
             return
-        self._screen.move_mouse_to_monitor(self.monitor)
+        move_mouse_to_screen(self.monitor)
         (x, y, w, h) = self.geometry
 
         target_x = x - 920 # this is the pressure we need to reveal the launcher.
@@ -148,14 +149,14 @@
 
     def keyboard_reveal_launcher(self):
         """Reveal this launcher using the keyboard."""
-        self._screen.move_mouse_to_monitor(self.monitor)
+        move_mouse_to_screen(self.monitor)
         logger.debug("Revealing launcher with keyboard.")
         self.keybinding_hold("launcher/reveal")
         self.is_showing.wait_for(True)
 
     def keyboard_unreveal_launcher(self):
         """Un-reveal this launcher using the keyboard."""
-        self._screen.move_mouse_to_monitor(self.monitor)
+        move_mouse_to_screen(self.monitor)
         logger.debug("Un-revealing launcher with keyboard.")
         self.keybinding_release("launcher/reveal")
         # only wait if the launcher is set to autohide
@@ -210,7 +211,7 @@
 
     def key_nav_start(self):
         """Start keyboard navigation mode by pressing Alt+F1."""
-        self._screen.move_mouse_to_monitor(self.monitor)
+        move_mouse_to_screen(self.monitor)
         logger.debug("Initiating launcher keyboard navigation with Alt+F1.")
         self.keybinding("launcher/keynav")
         self._get_controller().key_nav_is_active.wait_for(True)
@@ -255,7 +256,7 @@
 
     def switcher_start(self):
         """Start the super+Tab switcher on this launcher."""
-        self._screen.move_mouse_to_monitor(self.monitor)
+        move_mouse_to_screen(self.monitor)
         logger.debug("Starting Super+Tab switcher.")
         self.keybinding_hold_part_then_tap("launcher/switcher")
         self._get_controller().key_nav_is_active.wait_for(True)
 
=== modified file 'tests/autopilot/unity/emulators/panel.py'
--- tests/autopilot/unity/emulators/panel.py	2013-03-20 15:21:51 +0000
+++ tests/autopilot/unity/emulators/panel.py	2013-05-15 16:01:29 +0000
@@ -12,7 +12,7 @@
 import logging
 from time import sleep
 
-from autopilot.emulators.input import get_mouse
+from autopilot.input import Mouse
 from autopilot.keybindings import KeybindingsHelper
 
 from unity.emulators import UnityIntrospectionObject
@@ -53,7 +53,7 @@
 
     def __init__(self, *args, **kwargs):
         super(UnityPanel, self).__init__(*args, **kwargs)
-        self._mouse = get_mouse()
+        self._mouse = Mouse.create()
 
     def __get_menu_view(self):
         """Return the menu view."""
@@ -261,7 +261,7 @@
 
     def __init__(self, *args, **kwargs):
         super(WindowButton, self).__init__(*args, **kwargs)
-        self._mouse = get_mouse()
+        self._mouse = Mouse.create()
 
     def mouse_move_to(self):
         target_x = self.x + self.width / 2
@@ -319,7 +319,7 @@
 
     def __init__(self, *args, **kwargs):
         super(IndicatorEntry, self).__init__(*args, **kwargs)
-        self._mouse = get_mouse()
+        self._mouse = Mouse.create()
 
     def mouse_move_to(self):
         target_x = self.x + self.width / 2
 
=== modified file 'tests/autopilot/unity/emulators/quicklist.py'
--- tests/autopilot/unity/emulators/quicklist.py	2013-03-20 15:21:51 +0000
+++ tests/autopilot/unity/emulators/quicklist.py	2013-05-15 16:01:29 +0000
@@ -11,7 +11,7 @@
 
 import logging
 
-from autopilot.emulators.input import get_mouse
+from autopilot.input import Mouse
 
 from unity.emulators import UnityIntrospectionObject
 
@@ -21,10 +21,6 @@
 class Quicklist(UnityIntrospectionObject):
     """Represents a quicklist."""
 
-    def __init__(self, *args, **kwargs):
-        super(Quicklist, self).__init__(*args, **kwargs)
-        self._mouse = get_mouse()
-
     @property
     def items(self):
         """Individual items in the quicklist."""
@@ -60,7 +56,7 @@
         logger.debug("Moving mouse outside the quicklist %r", self)
         target_x = self.x + self.width + 10
         target_y = self.y + self.height / 2
-        self._mouse.move(target_x, target_y, animate=False)
+        Mouse.create().move(target_x, target_y, animate=False)
 
     @property
     def selected_item(self):
@@ -79,7 +75,7 @@
 
     def __init__(self, *args, **kwargs):
         super(QuicklistMenuItem, self).__init__(*args, **kwargs)
-        self._mouse = get_mouse()
+        self._mouse = Mouse.create()
 
     @property
     def geometry(self):
 
=== modified file 'tests/autopilot/unity/emulators/switcher.py'
--- tests/autopilot/unity/emulators/switcher.py	2013-03-20 15:21:51 +0000
+++ tests/autopilot/unity/emulators/switcher.py	2013-05-15 16:01:29 +0000
@@ -11,7 +11,7 @@
 
 import logging
 
-from autopilot.emulators.input import get_mouse
+from autopilot.input import Mouse
 from autopilot.keybindings import KeybindingsHelper
 
 from unity.emulators import UnityIntrospectionObject
@@ -45,7 +45,7 @@
 
     def __init__(self, *args, **kwargs):
         super(SwitcherController, self).__init__(*args, **kwargs)
-        self._mouse = get_mouse()
+        self._mouse = Mouse.create()
 
     def get_switcher_view(self):
         views = self.get_children_by_type(SwitcherView)
 
=== modified file 'tests/autopilot/unity/emulators/workspace.py'
--- tests/autopilot/unity/emulators/workspace.py	2012-08-29 04:27:50 +0000
+++ tests/autopilot/unity/emulators/workspace.py	2013-05-15 16:01:29 +0000
@@ -9,13 +9,11 @@
 
 from __future__ import absolute_import
 
-
 from autopilot.keybindings import KeybindingsHelper
-from autopilot.utilities import (
-    get_compiz_option,
-    get_desktop_geometry,
-    get_desktop_viewport,
-    )
+from autopilot.display import Display
+
+from unity.emulators.compiz import get_compiz_option
+from unity.emulators.X11 import get_desktop_viewport
 
 
 class WorkspaceManager(KeybindingsHelper):
@@ -40,9 +38,8 @@
         """Re-read information about available workspaces from compiz and X11."""
         self._workspaces_wide = get_compiz_option("core", "hsize")
         self._workspaces_high = get_compiz_option("core", "vsize")
-        self._desktop_width, self.desktop_height = get_desktop_geometry()
-        self._viewport_width = self._desktop_width / self._workspaces_wide
-        self._viewport_height = self.desktop_height / self._workspaces_high
+        # Note: only gets the viewport for the first monitor.
+        _, _, self._viewport_width, self._viewport_height = Display.create().get_screen_geometry(0)
 
     def switch_to(self, workspace_num):
         """Switch to the workspace specified.
 
=== modified file 'tests/autopilot/unity/tests/__init__.py'
--- tests/autopilot/unity/tests/__init__.py	2013-04-17 12:41:39 +0000
+++ tests/autopilot/unity/tests/__init__.py	2013-05-15 16:01:29 +0000
@@ -26,6 +26,8 @@
     HAVE_WINDOWMOCKER=True
 except ImportError:
     HAVE_WINDOWMOCKER=False
+from subprocess import check_output
+import time
 import tempfile
 from testtools.content import text_content
 from testtools.matchers import Equals
@@ -33,12 +35,14 @@
 
 from unity.emulators import ensure_unity_is_running
 from unity.emulators.workspace import WorkspaceManager
+from unity.emulators.compiz import get_compiz_setting, get_global_context
 from unity.emulators.unity import (
     set_log_severity,
     start_log_to_file,
     reset_logging,
     Unity
     )
+from unity.emulators.X11 import reset_display
 
 from Xlib import display
 from Xlib import Xutil
@@ -115,7 +119,7 @@
             #
             # In the event that this doesn't work, wait_for will throw an
             # exception.
-            win = self.start_app_window('Calculator', locale='C')
+            win = self.process_manager.start_app_window('Calculator', locale='C')
             count = 1
             while self.unity.window_manager.showdesktop_active:
                 self.keybinding("window/show_desktop")
@@ -204,8 +208,8 @@
 
         This uses the 'window-mocker' application, which is not part of the
         python-autopilot or unity-autopilot packages. To use this method, you
-        must have python-windowmocker installed. If the package is not installed, 
-        this method will raise a SkipTest exception, causing the calling test 
+        must have python-windowmocker installed. If the package is not installed,
+        this method will raise a SkipTest exception, causing the calling test
         to be silently skipped.
 
         window_spec is a list or dictionary that conforms to the window-mocker
@@ -215,8 +219,8 @@
         if not HAVE_WINDOWMOCKER:
             raise SkipTest("The python-windowmocker package is required to run this test.")
 
-        if 'Window Mocker' not in self.KNOWN_APPS:
-            self.register_known_application(
+        if 'Window Mocker' not in self.process_manager.KNOWN_APPS:
+            self.process_manager.register_known_application(
                 'Window Mocker',
                 'window-mocker.desktop',
                 'window-mocker'
@@ -225,21 +229,79 @@
             file_path = tempfile.mktemp()
             json.dump(window_spec, open(file_path, 'w'))
             self.addCleanup(os.remove, file_path)
-            return self.start_app_window('Window Mocker', [file_path])
+            return self.process_manager.start_app_window('Window Mocker', [file_path])
         else:
-            return self.start_app_window('Window Mocker')
+            return self.process_manager.start_app_window('Window Mocker')
 
     def close_all_windows(self, application_name):
-        for w in self.get_open_windows_by_application(application_name):
+        for w in self.process_manager.get_open_windows_by_application(application_name):
             w.close()
 
-        self.assertThat(lambda: len(self.get_open_windows_by_application(application_name)), Eventually(Equals(0)))
+        self.assertThat(lambda: len(self.process_manager.get_open_windows_by_application(application_name)), Eventually(Equals(0)))
 
     def register_nautilus(self):
-        self.addCleanup(self.unregister_known_application, "Nautilus")
-        self.register_known_application("Nautilus", "nautilus.desktop", "nautilus")
+        self.addCleanup(self.process_manager.unregister_known_application, "Nautilus")
+        self.process_manager.register_known_application("Nautilus", "nautilus.desktop", "nautilus")
 
     def get_startup_notification_timestamp(self, bamf_window):
         atom = display.Display().intern_atom('_NET_WM_USER_TIME')
         atom_type = display.Display().intern_atom('CARDINAL')
         return bamf_window.x_win.get_property(atom, atom_type, 0, 1024).value[0]
+
+    def call_gsettings_cmd(self, command, schema, *args):
+        """Set a desktop wide gsettings option
+
+        Using the gsettings command because there is a bug with importing
+        from gobject introspection and pygtk2 simultaneously, and the Xlib
+        keyboard layout bits are very unwieldy. This seems like the best
+        solution, even a little bit brutish.
+        """
+        cmd = ['gsettings', command, schema] + list(args)
+        # strip to remove the trailing \n.
+        ret = check_output(cmd).strip()
+        time.sleep(5)
+        reset_display()
+        return ret
+
+    def set_unity_option(self, option_name, option_value):
+        """Set an option in the unity compiz plugin options.
+
+        .. note:: The value will be set for the current test only, and
+         automatically undone when the test ends.
+
+        :param option_name: The name of the unity option.
+        :param option_value: The value you want to set.
+        :raises: **KeyError** if the option named does not exist.
+
+        """
+        self.set_compiz_option("unityshell", option_name, option_value)
+
+    def set_compiz_option(self, plugin_name, option_name, option_value):
+        """Set a compiz option for the duration of this test only.
+
+        .. note:: The value will be set for the current test only, and
+         automatically undone when the test ends.
+
+        :param plugin_name: The name of the compiz plugin where the option is
+         registered. If the option is not in a plugin, the string "core" should
+         be used as the plugin name.
+        :param option_name: The name of the unity option.
+        :param option_value: The value you want to set.
+        :raises: **KeyError** if the option named does not exist.
+
+        """
+        old_value = self._set_compiz_option(plugin_name, option_name, option_value)
+        # Cleanup is LIFO, during clean-up also allow unity to respond
+        self.addCleanup(time.sleep, 0.5)
+        self.addCleanup(self._set_compiz_option, plugin_name, option_name, old_value)
+        # Allow unity time to respond to the new setting.
+        time.sleep(0.5)
+
+    def _set_compiz_option(self, plugin_name, option_name, option_value):
+        log.info("Setting compiz option '%s' in plugin '%s' to %r",
+            option_name, plugin_name, option_value)
+        setting = get_compiz_setting(plugin_name, option_name)
+        old_value = setting.Value
+        setting.Value = option_value
+        get_global_context().Write()
+        return old_value
 
=== modified file 'tests/autopilot/unity/tests/launcher/__init__.py'
--- tests/autopilot/unity/tests/launcher/__init__.py	2013-02-04 21:03:37 +0000
+++ tests/autopilot/unity/tests/launcher/__init__.py	2013-05-15 16:01:29 +0000
@@ -8,18 +8,18 @@
 
 """Autopilot test case class for all Launcher tests"""
 
-from autopilot.emulators.X11 import ScreenGeometry
+from autopilot.display import Display
 from autopilot.testcase import multiply_scenarios
 
 from unity.tests import UnityTestCase
+from unity.emulators.X11 import set_primary_monitor
 
 
 def _make_scenarios():
     """Make scenarios for launcher test cases based on the number of configured
     monitors.
     """
-    screen_geometry = ScreenGeometry()
-    num_monitors = screen_geometry.get_num_monitors()
+    num_monitors = Display.create().get_num_screens()
 
     # it doesn't make sense to set only_primary when we're running in a single-monitor setup.
     if num_monitors == 1:
@@ -39,7 +39,6 @@
 
     def setUp(self):
         super(LauncherTestCase, self).setUp()
-        self.screen_geo = ScreenGeometry()
         self.set_unity_log_level("unity.launcher", "DEBUG")
         self.addCleanup(self.set_unity_log_level, "unity.launcher", "INFO")
 
@@ -48,10 +47,10 @@
 
         if self.only_primary:
             try:
-                old_primary_screen = self.screen_geo.get_primary_monitor()
-                self.screen_geo.set_primary_monitor(self.launcher_monitor)
-                self.addCleanup(self.screen_geo.set_primary_monitor, old_primary_screen)
-            except ScreenGeometry.BlacklistedDriverError:
+                old_primary_screen = self.display.get_primary_screen()
+                set_primary_monitor(self.launcher_monitor)
+                self.addCleanup(set_primary_monitor, old_primary_screen)
+            except autopilot.display.BlacklistedDriverError:
                 self.skipTest("Impossible to set the monitor %d as primary" % self.launcher_monitor)
 
     def get_launcher(self):
 
=== modified file 'tests/autopilot/unity/tests/launcher/test_capture.py'
--- tests/autopilot/unity/tests/launcher/test_capture.py	2013-02-04 21:03:37 +0000
+++ tests/autopilot/unity/tests/launcher/test_capture.py	2013-05-15 16:01:29 +0000
@@ -9,7 +9,6 @@
 
 from __future__ import absolute_import
 
-from autopilot.emulators.X11 import ScreenGeometry
 from autopilot.matchers import Eventually
 import logging
 from testtools.matchers import Equals, LessThan, GreaterThan
@@ -23,12 +22,10 @@
 class LauncherCaptureTests(UnityTestCase):
     """Test the launchers ability to capture/not capture the mouse."""
 
-    screen_geo = ScreenGeometry()
-
     def setUp(self):
         super(LauncherCaptureTests, self).setUp()
 
-        if self.screen_geo.get_num_monitors() <= 1:
+        if self.display.get_num_screens() <= 1:
             self.skipTest("This test requires two or more monitors.")
 
         self.set_unity_option('launcher_capture_mouse', True)
@@ -41,8 +38,8 @@
         self.assertThat(launcher.hidemode, Eventually(Equals(mode)))
 
     def leftMostMonitor(self):
-        x1, y1, width, height = self.screen_geo.get_monitor_geometry(0)
-        x2, y2, width, height = self.screen_geo.get_monitor_geometry(1)
+        x1, y1, width, height = self.display.get_screen_geometry(0)
+        x2, y2, width, height = self.display.get_screen_geometry(1)
 
         if x1 < x2:
             return 0
@@ -57,7 +54,7 @@
         """Tests that the launcher captures the mouse when moving between monitors
         while revealed.
         """
-        x, y, width, height = self.screen_geo.get_monitor_geometry(self.rightMostMonitor())
+        x, y, width, height = self.display.get_screen_geometry(self.rightMostMonitor())
         self.mouse.move(x + width / 2, y + height / 2, False)
         self.mouse.move(x - width / 2, y + height / 2, True, 5, .002)
 
@@ -72,7 +69,7 @@
 
         self.set_unity_option('launcher_capture_mouse', False)
 
-        x, y, width, height = self.screen_geo.get_monitor_geometry(self.rightMostMonitor())
+        x, y, width, height = self.display.get_screen_geometry(self.rightMostMonitor())
         self.mouse.move(x + width / 2, y + height / 2, False)
         self.mouse.move(x - width / 2, y + height / 2, True, 5, .002)
 
@@ -88,7 +85,7 @@
         self.set_unity_option('launcher_capture_mouse', False)
         self.setHideMode(1)
 
-        x, y, width, height = self.screen_geo.get_monitor_geometry(self.rightMostMonitor())
+        x, y, width, height = self.display.get_screen_geometry(self.rightMostMonitor())
         self.mouse.move(x + width / 2, y + height / 2, False)
         self.mouse.move(x - width / 2, y + height / 2, True, 5, .002)
 
@@ -104,7 +101,7 @@
         self.set_unity_option('launcher_capture_mouse', False)
         self.setHideMode(1)
 
-        x, y, width, height = self.screen_geo.get_monitor_geometry(self.leftMostMonitor())
+        x, y, width, height = self.display.get_screen_geometry(self.leftMostMonitor())
         self.mouse.move(x + width / 2, y + height / 2, False)
         sleep(1.5)
         self.mouse.move(x + width * 1.5, y + height / 2, True, 5, .002)
@@ -119,7 +116,7 @@
         """
         self.setHideMode(1)
 
-        x, y, width, height = self.screen_geo.get_monitor_geometry(self.leftMostMonitor())
+        x, y, width, height = self.display.get_screen_geometry(self.leftMostMonitor())
         self.mouse.move(x + width / 2, y + height / 2, False)
         sleep(1.5)
         self.mouse.move(x + width * 1.5, y + height / 2, True, 5, .002)
 
=== modified file 'tests/autopilot/unity/tests/launcher/test_icon_behavior.py'
--- tests/autopilot/unity/tests/launcher/test_icon_behavior.py	2013-04-09 18:37:33 +0000
+++ tests/autopilot/unity/tests/launcher/test_icon_behavior.py	2013-05-15 16:01:29 +0000
@@ -51,12 +51,12 @@
         return icon
 
     def ensure_calculator_in_launcher_and_not_running(self):
-        calc = self.start_app("Calculator")
+        calc = self.process_manager.start_app("Calculator")
         calc_icon = self.unity.launcher.model.get_icon(desktop_id=calc.desktop_file)
         self.addCleanup(self.launcher_instance.unlock_from_launcher, calc_icon)
         self.launcher_instance.lock_to_launcher(calc_icon)
-        self.close_all_app("Calculator")
-        self.assertThat(lambda: self.app_is_running("Calculator"), Eventually(Equals(False)))
+        self.process_manager.close_all_app("Calculator")
+        self.assertThat(lambda: self.process_manager.app_is_running("Calculator"), Eventually(Equals(False)))
         return calc_icon
 
     def test_bfb_tooltip_disappear_when_dash_is_opened(self):
@@ -88,7 +88,7 @@
 
     def test_shift_click_opens_new_application_instance(self):
         """Shift+Clicking MUST open a new instance of an already-running application."""
-        app = self.start_app("Calculator")
+        app = self.process_manager.start_app("Calculator")
         icon = self.unity.launcher.model.get_icon(desktop_id=app.desktop_file)
         launcher_instance = self.unity.launcher.get_launcher_for_monitor(0)
 
@@ -103,9 +103,9 @@
         of that application.
 
         """
-        char_win1 = self.start_app_window("Character Map")
-        calc_win = self.start_app_window("Calculator")
-        char_win2 = self.start_app_window("Character Map")
+        char_win1 = self.process_manager.start_app_window("Character Map")
+        calc_win = self.process_manager.start_app_window("Calculator")
+        char_win2 = self.process_manager.start_app_window("Character Map")
 
         self.assertVisibleWindowStack([char_win2, calc_win, char_win1])
 
@@ -136,10 +136,10 @@
     def test_launcher_uses_startup_notification(self):
         """Tests that unity uses startup notification protocol."""
         calc_icon = self.ensure_calculator_in_launcher_and_not_running()
-        self.addCleanup(self.close_all_app, "Calculator")
+        self.addCleanup(self.process_manager.close_all_app, "Calculator")
         self.launcher_instance.click_launcher_icon(calc_icon)
 
-        calc_app = self.bamf.get_running_applications_by_desktop_file(calc_icon.desktop_id)[0]
+        calc_app = self.process_manager.get_running_applications_by_desktop_file(calc_icon.desktop_id)[0]
         calc_window = calc_app.get_windows()[0]
 
         self.assertThat(lambda: self.get_startup_notification_timestamp(calc_window), Eventually(Equals(calc_icon.startup_notification_timestamp)))
@@ -148,16 +148,16 @@
         """Tests that when the trash is opened, clicking on the icon re-focus the trash again"""
         self.register_nautilus()
         self.addCleanup(self.close_all_windows, "Nautilus")
-        self.addCleanup(self.close_all_app, "Calculator")
+        self.addCleanup(self.process_manager.close_all_app, "Calculator")
         self.close_all_windows("Nautilus")
 
         trash_icon = self.unity.launcher.model.get_trash_icon()
         self.launcher_instance.click_launcher_icon(trash_icon)
-        self.assertThat(lambda: len(self.get_open_windows_by_application("Nautilus")), Eventually(Equals(1)))
-        [trash_window] = self.get_open_windows_by_application("Nautilus")
+        self.assertThat(lambda: len(self.process_manager.get_open_windows_by_application("Nautilus")), Eventually(Equals(1)))
+        [trash_window] = self.process_manager.get_open_windows_by_application("Nautilus")
         self.assertThat(lambda: trash_window.is_focused, Eventually(Equals(True)))
 
-        calc_win = self.start_app_window("Calculator")
+        calc_win = self.process_manager.start_app_window("Calculator")
         self.assertThat(lambda: calc_win.is_focused, Eventually(Equals(True)))
         self.assertThat(lambda: trash_window.is_focused, Eventually(Equals(False)))
 
@@ -172,12 +172,12 @@
 
         trash_icon = self.unity.launcher.model.get_trash_icon()
         self.launcher_instance.click_launcher_icon(trash_icon)
-        self.assertThat(lambda: len(self.get_open_windows_by_application("Nautilus")), Eventually(Equals(1)))
+        self.assertThat(lambda: len(self.process_manager.get_open_windows_by_application("Nautilus")), Eventually(Equals(1)))
 
-        nautilus_app = self.get_app_instances("Nautilus")
+        nautilus_app = self.process_manager.get_app_instances("Nautilus")
         nautilus_icon = self.unity.launcher.model.get_icon(desktop_id="nautilus.desktop")
         self.launcher_instance.click_launcher_icon(nautilus_icon)
-        self.assertThat(lambda: len(self.get_open_windows_by_application("Nautilus")), Eventually(Equals(2)))
+        self.assertThat(lambda: len(self.process_manager.get_open_windows_by_application("Nautilus")), Eventually(Equals(2)))
 
     def test_super_number_shortcut_focuses_new_windows(self):
         """Windows launched using super+number must have
@@ -186,7 +186,7 @@
         """
         bfb_icon = self.unity.launcher.model.get_bfb_icon()
         calc_icon = self.ensure_calculator_in_launcher_and_not_running()
-        self.addCleanup(self.close_all_app, "Calculator")
+        self.addCleanup(self.process_manager.close_all_app, "Calculator")
 
         self.launcher_instance.drag_icon_to_position(
             calc_icon,
@@ -197,7 +197,7 @@
         self.addCleanup(self.launcher_instance.keyboard_unreveal_launcher)
         self.keyboard.press_and_release("1");
 
-        calc_app = self.bamf.get_running_applications_by_desktop_file(calc_icon.desktop_id)[0]
+        calc_app = self.process_manager.get_running_applications_by_desktop_file(calc_icon.desktop_id)[0]
         calc_window = calc_app.get_windows()[0]
 
         self.assertThat(lambda: calc_window.is_focused, Eventually(Equals(True)))
@@ -206,8 +206,8 @@
         """This tests shows that when you click on a launcher icon twice,
         when an application window is focused, the spread is initiated.
         """
-        char_win1 = self.start_app_window("Character Map")
-        char_win2 = self.start_app_window("Character Map")
+        char_win1 = self.process_manager.start_app_window("Character Map")
+        char_win2 = self.process_manager.start_app_window("Character Map")
         char_app = char_win1.application
 
         self.assertVisibleWindowStack([char_win2, char_win1])
@@ -224,8 +224,8 @@
         """If scale is initiated through the laucher pressing super must close
         scale and open the dash.
         """
-        char_win1 = self.start_app_window("Character Map")
-        char_win2 = self.start_app_window("Character Map")
+        char_win1 = self.process_manager.start_app_window("Character Map")
+        char_win2 = self.process_manager.start_app_window("Character Map")
         char_app = char_win1.application
 
         self.assertVisibleWindowStack([char_win2, char_win1])
@@ -243,13 +243,13 @@
 
     def test_icon_shows_on_quick_application_reopen(self):
         """Icons must stay on launcher when an application is quickly closed/reopened."""
-        calc = self.start_app("Calculator")
+        calc = self.process_manager.start_app("Calculator")
         desktop_file = calc.desktop_file
         calc_icon = self.unity.launcher.model.get_icon(desktop_id=desktop_file)
         self.assertThat(calc_icon.visible, Eventually(Equals(True)))
 
-        self.close_all_app("Calculator")
-        calc = self.start_app("Calculator")
+        self.process_manager.close_all_app("Calculator")
+        calc = self.process_manager.start_app("Calculator")
         sleep(2)
 
         calc_icon = self.unity.launcher.model.get_icon(desktop_id=desktop_file)
@@ -356,7 +356,7 @@
         """Application icons must be draggable to below the BFB."""
 
         self.ensure_calc_icon_not_in_launcher()
-        calc = self.start_app("Calculator")
+        calc = self.process_manager.start_app("Calculator")
         calc_icon = self.unity.launcher.model.get_icon(desktop_id=calc.desktop_file)
         bfb_icon = self.unity.launcher.model.get_bfb_icon()
 
@@ -373,7 +373,7 @@
         """Application icons must be dragable to below the workspace switcher icon."""
 
         self.ensure_calc_icon_not_in_launcher()
-        calc = self.start_app("Calculator")
+        calc = self.process_manager.start_app("Calculator")
         calc_icon = self.unity.launcher.model.get_icon(desktop_id=calc.desktop_file)
         bfb_icon = self.unity.launcher.model.get_bfb_icon()
         trash_icon = self.unity.launcher.model.get_trash_icon()
 
=== modified file 'tests/autopilot/unity/tests/launcher/test_keynav.py'
--- tests/autopilot/unity/tests/launcher/test_keynav.py	2013-02-04 22:31:47 +0000
+++ tests/autopilot/unity/tests/launcher/test_keynav.py	2013-05-15 16:01:29 +0000
@@ -51,7 +51,7 @@
 
     def test_launcher_keynav_cancel_resume_focus(self):
         """Test that ending the launcher keynav resume the focus."""
-        calc = self.start_app("Calculator")
+        calc = self.process_manager.start_app("Calculator")
         self.assertTrue(calc.is_active)
 
         self.start_keynav_with_cleanup_cancel()
@@ -127,8 +127,8 @@
 
     def test_launcher_keynav_activate_keep_focus(self):
         """Activating a running launcher icon must focus it."""
-        calc = self.start_app("Calculator")
-        mahjongg = self.start_app("Mahjongg")
+        calc = self.process_manager.start_app("Calculator")
+        mahjongg = self.process_manager.start_app("Mahjongg")
         self.assertTrue(mahjongg.is_active)
         self.assertFalse(calc.is_active)
 
@@ -215,7 +215,7 @@
 
     def test_launcher_keynav_cancel_on_click_icon(self):
         """A single click on a launcher icon must cancel keynav."""
-        calc_win = self.start_app_window('Calculator', locale = 'C')
+        calc_win = self.process_manager.start_app_window('Calculator', locale = 'C')
         calc_app = calc_win.application
         calc_icon = self.unity.launcher.model.get_icon(desktop_id=calc_app.desktop_file)
 
 
=== modified file 'tests/autopilot/unity/tests/launcher/test_reveal.py'
--- tests/autopilot/unity/tests/launcher/test_reveal.py	2013-02-04 19:54:47 +0000
+++ tests/autopilot/unity/tests/launcher/test_reveal.py	2013-05-15 16:01:29 +0000
@@ -9,6 +9,7 @@
 
 from __future__ import absolute_import
 
+from autopilot.display import move_mouse_to_screen
 from autopilot.matchers import Eventually
 import logging
 from testtools.matchers import Equals, GreaterThan
@@ -63,7 +64,7 @@
 
     def test_launcher_does_not_reveal_with_mouse_down(self):
         """Launcher must not reveal if have mouse button 1 down."""
-        self.screen_geo.move_mouse_to_monitor(self.launcher_instance.monitor)
+        move_mouse_to_screen(self.launcher_instance.monitor)
         self.mouse.press(1)
         self.addCleanup(self.mouse.release, 1)
         #FIXME: This is really bad API. it says reveal but it's expected to fail. bad bad bad!!
@@ -75,8 +76,8 @@
 
     def test_launcher_stays_open_after_spread(self):
         """Clicking on the launcher to close an active spread must not hide the launcher."""
-        char_win1 = self.start_app_window("Character Map")
-        char_win2 = self.start_app_window("Character Map")
+        char_win1 = self.process_manager.start_app_window("Character Map")
+        char_win2 = self.process_manager.start_app_window("Character Map")
         char_app = char_win1.application
 
         char_icon = self.unity.launcher.model.get_icon(desktop_id=char_app.desktop_file)
@@ -90,7 +91,7 @@
 
     def test_launcher_stays_open_after_icon_click(self):
         """Clicking on a launcher icon must not hide the launcher."""
-        char_win = self.start_app_window("Character Map")
+        char_win = self.process_manager.start_app_window("Character Map")
         char_app = char_win.application
 
         char_icon = self.unity.launcher.model.get_icon(desktop_id=char_app.desktop_file)
@@ -106,10 +107,10 @@
          if self.unity.launcher.model.num_bamf_launcher_icons() >= 10:
              self.skip("There are already more than 9 icons in the launcher")
 
-         desktop_file = self.KNOWN_APPS['Calculator']['desktop-file']
+         desktop_file = self.process_manager.KNOWN_APPS['Calculator']['desktop-file']
          if self.unity.launcher.model.get_icon(desktop_id=desktop_file) != None:
              self.skip("Calculator icon is already on the launcher.")
 
-         self.start_app('Calculator')
+         self.process_manager.start_app('Calculator')
          icon = self.unity.launcher.model.get_icon(desktop_id=desktop_file)
          self.assertThat(icon.shortcut, GreaterThan(0))
 
=== modified file 'tests/autopilot/unity/tests/launcher/test_scroll.py'
--- tests/autopilot/unity/tests/launcher/test_scroll.py	2013-03-13 18:07:17 +0000
+++ tests/autopilot/unity/tests/launcher/test_scroll.py	2013-05-15 16:01:29 +0000
@@ -25,7 +25,7 @@
         apps = ("Calculator", "Mahjongg", "Text Editor", "Character Map", "Terminal", "Remmina")
         
         for app in apps:
-            self.start_app_window(app)
+            self.process_manager.start_app_window(app)
    
     def test_autoscrolling_from_bottom(self):
         """Tests the autoscrolling from the bottom of the Launcher"""
 
=== modified file 'tests/autopilot/unity/tests/launcher/test_switcher.py'
--- tests/autopilot/unity/tests/launcher/test_switcher.py	2013-02-04 19:54:47 +0000
+++ tests/autopilot/unity/tests/launcher/test_switcher.py	2013-05-15 16:01:29 +0000
@@ -47,8 +47,8 @@
 
     def test_launcher_switcher_cancel_resume_focus(self):
         """Test that ending the launcher switcher resume the focus."""
-        self.close_all_app("Calculator")
-        calc = self.start_app("Calculator")
+        self.process_manager.close_all_app("Calculator")
+        calc = self.process_manager.start_app("Calculator")
         self.assertTrue(calc.is_active)
 
         self.start_switcher_with_cleanup_cancel()
@@ -145,8 +145,8 @@
 
     def test_launcher_switcher_activate_keep_focus(self):
         """Activating a running launcher icon should focus the application."""
-        calc = self.start_app("Calculator")
-        mahjongg = self.start_app("Mahjongg")
+        calc = self.process_manager.start_app("Calculator")
+        mahjongg = self.process_manager.start_app("Mahjongg")
         self.assertTrue(mahjongg.is_active)
         self.assertFalse(calc.is_active)
 
 
=== modified file 'tests/autopilot/unity/tests/test_command_lens.py'
--- tests/autopilot/unity/tests/test_command_lens.py	2013-04-24 19:43:55 +0000
+++ tests/autopilot/unity/tests/test_command_lens.py	2013-05-15 16:01:29 +0000
@@ -70,8 +70,8 @@
 
     def test_run_before_refresh(self):
         """Hitting enter before view has updated results must run the correct command."""
-        if self.app_is_running("Text Editor"):
-            self.close_all_app("Text Editor")
+        if self.process_manager.app_is_running("Text Editor"):
+            self.process_manager.close_all_app("Text Editor")
             sleep(1)
 
         self.unity.dash.reveal_command_scope()
@@ -79,8 +79,8 @@
         sleep(1)
         self.keyboard.type("edit", 0.1)
         self.keyboard.press_and_release("Enter", 0.1)
-        self.addCleanup(self.close_all_app,  "Text Editor")
-        app_found = self.bamf.wait_until_application_is_running("gedit.desktop", 5)
+        self.addCleanup(self.process_manager.close_all_app,  "Text Editor")
+        app_found = self.process_manager.wait_until_application_is_running("gedit.desktop", 5)
         self.assertTrue(app_found)
 
     def test_ctrl_tab_switching(self):
 
=== modified file 'tests/autopilot/unity/tests/test_dash.py'
--- tests/autopilot/unity/tests/test_dash.py	2013-04-26 14:08:38 +0000
+++ tests/autopilot/unity/tests/test_dash.py	2013-05-15 16:01:29 +0000
@@ -8,7 +8,8 @@
 
 from __future__ import absolute_import
 
-from autopilot.emulators.clipboard import get_clipboard_contents
+from autopilot.clipboard import get_clipboard_contents
+from autopilot.display import move_mouse_to_screen
 from autopilot.matchers import Eventually
 from testtools.matchers import Equals, NotEquals, GreaterThan
 from time import sleep
@@ -123,7 +124,7 @@
         current_monitor = self.unity.dash.monitor
 
         (x,y,w,h) = self.unity.dash.geometry
-        (screen_x,screen_y,screen_w,screen_h) = self.screen_geo.get_monitor_geometry(current_monitor)
+        (screen_x,screen_y,screen_w,screen_h) = self.display.get_screen_geometry(current_monitor)
 
         self.mouse.move(x + w + (screen_w-((screen_x-x)+w))/2, y + h + (screen_h-((screen_y-y)+h))/2)
         self.mouse.click()
@@ -135,15 +136,15 @@
         focused. Then from the Dash clicking on the maximized window
         must focus that window and close the dash.
         """
-        char_win = self.start_app("Character Map")
+        char_win = self.process_manager.start_app("Character Map")
         self.keybinding("window/maximize")
-        self.start_app("Calculator")
+        self.process_manager.start_app("Calculator")
 
         self.unity.dash.ensure_visible()
 
         #Click bottom right of the screen
-        w = self.screen_geo.get_screen_width()
-        h = self.screen_geo.get_screen_height()
+        w = self.display.get_screen_width()
+        h = self.display.get_screen_height()
         self.mouse.move(w,h)
         self.mouse.click()
 
@@ -506,7 +507,7 @@
     def test_middle_click_paste(self):
         """Tests if Middle mouse button pastes into searchbar"""
 
-        self.start_app_window("Calculator", locale='C')
+        self.process_manager.start_app_window("Calculator", locale='C')
 
         self.keyboard.type("ThirdButtonPaste")
         self.keyboard.press_and_release("Ctrl+a")
@@ -547,7 +548,7 @@
         self.unity.dash.ensure_visible()
         self.addCleanup(self.unity.hud.ensure_hidden)
 
-        self.start_app_window("Calculator")
+        self.process_manager.start_app_window("Calculator")
         sleep(1)
 
         self.keyboard.type("HasFocus")
@@ -648,8 +649,9 @@
         self.assertThat(scope.visible, Eventually(Equals(False)))
 
     def test_dash_position_with_non_default_launcher_width(self):
-        """"There should be no empty space between launcher and dash when the launcher
+        """There should be no empty space between launcher and dash when the launcher
         has a non-default width.
+
         """
         monitor = self.unity.dash.monitor
         launcher = self.unity.launcher.get_launcher_for_monitor(monitor)
@@ -804,8 +806,7 @@
         # make sure the scope result is non-empty
         (file_handle, file_path) = mkstemp()
         self.addCleanup(remove, file_path)
-        gedit_win = self.start_app_window('Text Editor', files=[file_path], locale='C')
-        self.addCleanup(self.close_all_app, 'Text Editor')
+        gedit_win = self.process_manager.start_app_window('Text Editor', files=[file_path], locale='C')
         self.assertProperty(gedit_win, is_focused=True)
 
         scope = self.unity.dash.reveal_file_scope()
@@ -1263,7 +1264,7 @@
 
     def setUp(self):
         super(DashCrossMonitorsTests, self).setUp()
-        if self.screen_geo.get_num_monitors() < 2:
+        if self.display.get_num_screens() < 2:
             self.skipTest("This test requires more than 1 monitor.")
 
     def test_dash_stays_on_same_monitor(self):
@@ -1275,7 +1276,7 @@
         self.unity.dash.ensure_visible()
         self.addCleanup(self.unity.dash.ensure_hidden)
 
-        self.screen_geo.move_mouse_to_monitor((current_monitor + 1) % self.screen_geo.get_num_monitors())
+        move_mouse_to_screen((current_monitor + 1) % self.display.get_num_screens())
         self.keyboard.type("abc")
 
         self.assertThat(self.unity.dash.ideal_monitor, Eventually(Equals(current_monitor)))
@@ -1285,11 +1286,11 @@
 
         self.addCleanup(self.unity.dash.ensure_hidden)
 
-        for monitor in range(self.screen_geo.get_num_monitors()-1):
-            self.screen_geo.move_mouse_to_monitor(monitor)
+        for monitor in range(self.display.get_num_screens()-1):
+            move_mouse_to_screen(monitor)
             self.unity.dash.ensure_visible()
 
-            self.screen_geo.move_mouse_to_monitor(monitor+1)
+            move_mouse_to_screen(monitor+1)
             sleep(.5)
             self.mouse.click()
 
 
=== modified file 'tests/autopilot/unity/tests/test_home_lens.py'
--- tests/autopilot/unity/tests/test_home_lens.py	2013-02-21 10:47:14 +0000
+++ tests/autopilot/unity/tests/test_home_lens.py	2013-05-15 16:01:29 +0000
@@ -30,8 +30,8 @@
         finished yet.
 
         """
-        if self.app_is_running("Text Editor"):
-            self.close_all_app("Text Editor")
+        if self.process_manager.app_is_running("Text Editor"):
+            self.process_manager.close_all_app("Text Editor")
             sleep(1)
 
         kb = self.keyboard
@@ -40,6 +40,6 @@
         self.assertThat(self.unity.dash.search_string, Eventually(Equals("g")))
         kb.type("edit", 0.1)
         kb.press_and_release("Enter", 0.1)
-        self.addCleanup(self.close_all_app,  "Text Editor")
-        app_found = self.bamf.wait_until_application_is_running("gedit.desktop", 5)
+        self.addCleanup(self.process_manager.close_all_app,  "Text Editor")
+        app_found = self.process_manager.wait_until_application_is_running("gedit.desktop", 5)
         self.assertTrue(app_found)
 
=== modified file 'tests/autopilot/unity/tests/test_hud.py'
--- tests/autopilot/unity/tests/test_hud.py	2013-04-24 15:25:08 +0000
+++ tests/autopilot/unity/tests/test_hud.py	2013-05-15 16:01:29 +0000
@@ -10,7 +10,7 @@
 from __future__ import absolute_import
 
 from autopilot.matchers import Eventually
-from autopilot.emulators.X11 import ScreenGeometry
+from autopilot.display import Display, move_mouse_to_screen, is_rect_on_screen
 from autopilot.testcase import multiply_scenarios
 from os import remove, environ
 from os.path import exists
@@ -30,7 +30,7 @@
 
 
 def _make_monitor_scenarios():
-    num_monitors = ScreenGeometry().get_num_monitors()
+    num_monitors = Display.create().get_num_screens()
     scenarios = []
 
     if num_monitors == 1:
@@ -82,8 +82,8 @@
 
         if not environ.get('UBUNTU_MENUPROXY', ''):
             self.patch_environment('UBUNTU_MENUPROXY', 'libappmenu.so')
-        self.hud_monitor = self.screen_geo.get_primary_monitor()
-        self.screen_geo.move_mouse_to_monitor(self.hud_monitor)
+        self.hud_monitor = self.display.get_primary_screen()
+        move_mouse_to_screen(self.hud_monitor)
 
     def test_no_initial_values(self):
         self.unity.hud.ensure_visible()
@@ -152,7 +152,7 @@
         self.assertThat(self.unity.hud.visible, Equals(False))
 
     def test_alt_f4_doesnt_show_hud(self):
-        self.start_app('Calculator')
+        self.process_manager.start_app('Calculator')
         sleep(1)
         # Do a very fast Alt+F4
         self.keyboard.press_and_release("Alt+F4", 0.05)
@@ -176,7 +176,7 @@
         """Ensures that once the hud is dismissed, the same application
         that was focused before hud invocation is refocused.
         """
-        calc = self.start_app("Calculator")
+        calc = self.process_manager.start_app("Calculator")
 
         # first ensure that the application has started and is focused
         self.assertEqual(calc.is_active, True)
@@ -200,8 +200,8 @@
 
         file_path = mktemp()
         self.addCleanup(remove, file_path)
-        gedit_win = self.start_app_window('Text Editor', files=[file_path], locale='C')
-        self.addCleanup(self.close_all_app, 'Text Editor')
+        gedit_win = self.process_manager.start_app_window('Text Editor', files=[file_path], locale='C')
+        self.addCleanup(self.process_manager.close_all_app, 'Text Editor')
         self.assertProperty(gedit_win, is_focused=True)
 
         self.keyboard.type("0")
@@ -254,7 +254,7 @@
     def test_hud_closes_on_spread(self):
         """This test shows that when the spread is initiated, the hud closes."""
         # Need at least one application open for the spread to work.
-        self.start_app_window("Calculator")
+        self.process_manager.start_app_window("Calculator")
         self.unity.hud.ensure_visible()
         self.addCleanup(self.keybinding, "spread/cancel")
         self.keybinding("spread/start")
@@ -317,8 +317,8 @@
 
     def test_app_activate_on_enter(self):
         """Hud must close after activating a search item with Enter."""
-        self.start_app('Text Editor', locale='C')
-        self.addCleanup(self.close_all_app, "Text Editor")
+        self.process_manager.start_app('Text Editor', locale='C')
+        self.addCleanup(self.process_manager.close_all_app, "Text Editor")
 
         self.unity.hud.ensure_visible()
 
@@ -330,7 +330,7 @@
 
         self.keyboard.press_and_release("Enter")
 
-        self.assertFalse(self.app_is_running("Text Editor"))
+        self.assertFalse(self.process_manager.app_is_running("Text Editor"))
 
         self.assertThat(self.unity.hud.visible, Eventually(Equals(False)))
 
@@ -355,7 +355,7 @@
         """Tests that Alt+ArrowKey events are correctly passed to the
         active window when Unity is not responding to them."""
 
-        term_win = self.start_app_window("Terminal")
+        term_win = self.process_manager.start_app_window("Terminal")
         self.assertProperty(term_win, is_focused=True)
 
         # Here we anyway need a sleep, since even though the terminal can have
@@ -427,7 +427,7 @@
         self.unity.hud.ensure_visible()
         self.addCleanup(self.unity.hud.ensure_hidden)
 
-        self.start_app_window("Calculator")
+        self.process_manager.start_app_window("Calculator")
         sleep(1)
 
         self.keyboard.type("HasFocus")
@@ -440,7 +440,7 @@
         current_monitor = self.unity.hud.monitor
 
         (x,y,w,h) = self.unity.hud.geometry
-        (screen_x,screen_y,screen_w,screen_h) = self.screen_geo.get_monitor_geometry(current_monitor)
+        (screen_x,screen_y,screen_w,screen_h) = self.display.get_screen_geometry(current_monitor)
 
         self.mouse.move(x + w + (screen_w-((screen_x-x)+w))/2, y + h + (screen_h-((screen_y-y)+h))/2)
         self.mouse.click()
@@ -452,16 +452,16 @@
         focused. Then from the Hud clicking on the maximized window
         must focus that window and close the hud.
         """
-        char_win = self.start_app("Character Map")
+        char_win = self.process_manager.start_app("Character Map")
         self.assertProperty(char_win, is_active=True)
         self.keybinding("window/maximize")
-        self.start_app("Calculator")
+        self.process_manager.start_app("Calculator")
 
         self.unity.hud.ensure_visible()
 
         #Click bottom right of the screen
-        w = self.screen_geo.get_screen_width()
-        h = self.screen_geo.get_screen_height()
+        w = self.display.get_screen_width()
+        h = self.display.get_screen_height()
         self.mouse.move(w,h)
         self.mouse.click()
 
@@ -470,8 +470,8 @@
     def test_hud_does_not_focus_wrong_window_after_alt_tab(self):
         """Test the Hud focuses the correct window after an Alt+Tab."""
 
-        char_win = self.start_app('Character Map')
-        self.start_app('Calculator')
+        char_win = self.process_manager.start_app('Character Map')
+        self.process_manager.start_app('Calculator')
 
         self.keybinding("switcher/reveal_normal")
         self.assertProperty(char_win, is_active=True)
@@ -506,7 +506,7 @@
         self.set_unity_option('num_launchers', 0)
         self.set_unity_option('launcher_hide_mode', int(self.launcher_autohide))
 
-        self.screen_geo.move_mouse_to_monitor(self.hud_monitor)
+        move_mouse_to_screen(self.hud_monitor)
         sleep(0.5)
 
     def test_multiple_hud_reveal_does_not_break_launcher(self):
@@ -517,9 +517,9 @@
         launcher = self.unity.launcher.get_launcher_for_monitor(self.hud_monitor)
 
         # We need an app to switch to:
-        self.start_app('Character Map')
+        self.process_manager.start_app('Character Map')
         # We need an application to play with - I'll use the calculator.
-        self.start_app('Calculator')
+        self.process_manager.start_app('Calculator')
         sleep(1)
 
         # before we start, make sure there's zero or one active icon:
@@ -560,7 +560,7 @@
         self.set_unity_option('num_launchers', 0)
         self.set_unity_option('launcher_hide_mode', 0)
 
-        self.screen_geo.move_mouse_to_monitor(self.hud_monitor)
+        move_mouse_to_screen(self.hud_monitor)
         sleep(0.5)
 
     def test_hud_launcher_icon_hides_bfb(self):
@@ -616,10 +616,10 @@
 
     def setUp(self):
         super(HudVisualTests, self).setUp()
-        self.screen_geo.move_mouse_to_monitor(self.hud_monitor)
+        move_mouse_to_screen(self.hud_monitor)
         self.set_unity_option('launcher_hide_mode', int(self.launcher_autohide))
         self.set_unity_option('num_launchers', int(self.launcher_primary_only))
-        self.hud_monitor_is_primary = (self.screen_geo.get_primary_monitor() == self.hud_monitor)
+        self.hud_monitor_is_primary = (self.display.get_primary_screen() == self.hud_monitor)
         self.hud_locked = (not self.launcher_autohide and (not self.launcher_primary_only or self.hud_monitor_is_primary))
         sleep(0.5)
 
@@ -630,12 +630,12 @@
         """HUD must be drawn on the monitor where the mouse is."""
         self.unity.hud.ensure_visible()
         self.assertThat(self.unity.hud.monitor, Eventually(Equals(self.hud_monitor)))
-        self.assertTrue(self.screen_geo.is_rect_on_monitor(self.unity.hud.monitor, self.unity.hud.geometry))
+        self.assertTrue(is_rect_on_screen(self.unity.hud.monitor, self.unity.hud.geometry))
 
     def test_hud_geometries(self):
         """Tests the HUD geometries for the given monitor and status."""
         self.unity.hud.ensure_visible()
-        monitor_geo = self.screen_geo.get_monitor_geometry(self.hud_monitor)
+        monitor_geo = self.display.get_screen_geometry(self.hud_monitor)
         monitor_x = monitor_geo[0]
         monitor_w = monitor_geo[2]
         hud_x = self.unity.hud.geometry[0]
@@ -675,8 +675,8 @@
 
     def test_hud_icon_shows_the_focused_application_emblem(self):
         """Tests that the correct HUD icon is shown."""
-        self.close_all_app("Calculator")
-        calc = self.start_app("Calculator")
+        self.process_manager.close_all_app("Calculator")
+        calc = self.process_manager.start_app("Calculator")
         self.assertTrue(calc.is_active)
         self.unity.hud.ensure_visible()
 
@@ -693,8 +693,8 @@
 
     def test_switch_dash_hud_does_not_break_the_focused_application_emblem(self):
         """Switching from Dash to HUD must still show the correct HUD icon."""
-        self.close_all_app("Calculator")
-        calc = self.start_app("Calculator")
+        self.process_manager.close_all_app("Calculator")
+        calc = self.process_manager.start_app("Calculator")
         self.assertTrue(calc.is_active)
 
         self.unity.dash.ensure_visible()
@@ -704,8 +704,8 @@
 
     def test_switch_hud_dash_does_not_break_the_focused_application_emblem(self):
         """Switching from HUD to Dash and back must still show the correct HUD icon."""
-        self.close_all_app("Calculator")
-        calc = self.start_app("Calculator")
+        self.process_manager.close_all_app("Calculator")
+        calc = self.process_manager.start_app("Calculator")
         self.assertTrue(calc.is_active)
 
         self.unity.hud.ensure_visible()
@@ -727,7 +727,7 @@
         self.unity.window_manager.enter_show_desktop()
         self.addCleanup(self.unity.window_manager.leave_show_desktop)
 
-        calc = self.start_app("Calculator")
+        calc = self.process_manager.start_app("Calculator")
         self.assertTrue(calc.is_active)
         self.workspace.switch_to((initial_workspace + 1) % self.workspace.num_workspaces)
         self.unity.dash.ensure_visible()
@@ -776,7 +776,7 @@
 
     def setUp(self):
         super(HudCrossMonitorsTests, self).setUp()
-        if self.screen_geo.get_num_monitors() < 2:
+        if self.display.get_num_screens() < 2:
             self.skipTest("This test requires more than 1 monitor.")
 
     def test_hud_stays_on_same_monitor(self):
@@ -789,7 +789,7 @@
         self.unity.hud.ensure_visible()
         self.addCleanup(self.unity.hud.ensure_hidden)
 
-        self.screen_geo.move_mouse_to_monitor((current_monitor + 1) % self.screen_geo.get_num_monitors())
+        move_mouse_to_screen((current_monitor + 1) % self.display.get_num_screens())
         self.keyboard.type("abc")
 
         self.assertThat(self.unity.hud.ideal_monitor, Eventually(Equals(current_monitor)))
@@ -799,11 +799,11 @@
 
         self.addCleanup(self.unity.hud.ensure_hidden)
 
-        for monitor in range(self.screen_geo.get_num_monitors()-1):
-            self.screen_geo.move_mouse_to_monitor(monitor)
+        for monitor in range(self.display.get_num_screens()-1):
+            move_mouse_to_screen(monitor)
             self.unity.hud.ensure_visible()
 
-            self.screen_geo.move_mouse_to_monitor(monitor+1)
+            move_mouse_to_screen(monitor+1)
             sleep(.5)
             self.mouse.click()
 
 
=== modified file 'tests/autopilot/unity/tests/test_ibus.py'
--- tests/autopilot/unity/tests/test_ibus.py	2013-02-28 12:39:52 +0000
+++ tests/autopilot/unity/tests/test_ibus.py	2013-05-15 16:01:29 +0000
@@ -10,7 +10,7 @@
 
 from __future__ import absolute_import
 
-from autopilot.emulators.ibus import (
+from autopilot.ibus import (
     get_active_input_engines,
     set_active_engines,
     get_available_input_engines,
 
=== modified file 'tests/autopilot/unity/tests/test_panel.py'
--- tests/autopilot/unity/tests/test_panel.py	2013-04-17 15:10:39 +0000
+++ tests/autopilot/unity/tests/test_panel.py	2013-05-15 16:01:29 +0000
@@ -8,8 +8,9 @@
 
 from __future__ import absolute_import
 
-from autopilot.emulators.X11 import ScreenGeometry
-from autopilot.emulators.bamf import BamfWindow
+from autopilot.display import Display
+#from autopilot.emulators.bamf import BamfWindow
+from autopilot.process import Window
 from autopilot.matchers import Eventually
 import logging
 import os
@@ -17,6 +18,7 @@
 from time import sleep
 
 from unity.emulators.panel import IndicatorEntry
+from unity.emulators.X11 import drag_window_to_screen
 from unity.tests import UnityTestCase
 
 import gettext
@@ -25,7 +27,7 @@
 
 
 def _make_monitor_scenarios():
-    num_monitors = ScreenGeometry().get_num_monitors()
+    num_monitors = Display.create().get_num_screens()
     scenarios = []
 
     if num_monitors == 1:
@@ -54,8 +56,8 @@
         Returns the opened BamfWindow
 
         """
-        self.close_all_app(app_name)
-        app_win = self.start_app_window(app_name, locale="C")
+        self.process_manager.close_all_app(app_name)
+        app_win = self.process_manager.start_app_window(app_name, locale="C")
         app = app_win.application
 
         app_win.set_focus()
@@ -82,8 +84,8 @@
 
     def move_window_to_panel_monitor(self, window, restore_position=False):
         """Drags a window to another monitor, eventually restoring it before"""
-        if not isinstance(window, BamfWindow):
-            raise TypeError("Window must be a BamfWindow")
+        if not isinstance(window, Window):
+            raise TypeError("Window must be a autopilot.process.Window")
 
         if window.monitor == self.panel_monitor:
             return
@@ -94,9 +96,9 @@
             sleep(.1)
 
         if restore_position:
-            self.addCleanup(self.screen_geo.drag_window_to_monitor, window, window.monitor)
+            self.addCleanup(drag_window_to_screen, window, window.monitor)
 
-        self.screen_geo.drag_window_to_monitor(window, self.panel_monitor)
+        drag_window_to_screen(window, self.panel_monitor)
         sleep(.25)
         self.assertThat(window.monitor, Equals(self.panel_monitor))
 
@@ -130,7 +132,7 @@
         """Assert that Bamf doesn't know of any open windows with the given xid."""
         # We can't check text_win.closed since we've just destroyed the window.
         # Instead we make sure no window with it's x_id exists.
-        refresh_fn = lambda: [w for w in self.bamf.get_open_windows() if w.x_id == x_id]
+        refresh_fn = lambda: [w for w in self.process_manager.get_open_windows() if w.x_id == x_id]
         self.assertThat(refresh_fn, Eventually(Equals([])))
 
     def sleep_menu_settle_period(self):
@@ -372,7 +374,7 @@
         win_xid = text_win.x_id
 
         self.panel.move_mouse_over_window_buttons()
-        screen_x, screen_y = self.screen_geo.get_monitor_geometry(self.panel_monitor)[:2]
+        screen_x, screen_y = self.display.get_screen_geometry(self.panel_monitor)[:2]
         self.mouse.move(screen_x, screen_y)
         self.mouse.click()
 
@@ -400,7 +402,7 @@
         self.panel.move_mouse_over_window_buttons()
         button = self.panel.window_buttons.minimize
         target_x = button.x + button.width / 2
-        target_y = self.screen_geo.get_monitor_geometry(self.panel_monitor)[1]
+        target_y = self.display.get_screen_geometry(self.panel_monitor)[1]
         self.mouse.move(target_x, target_y)
         self.mouse.click()
 
@@ -429,7 +431,7 @@
         button = self.panel.window_buttons.unmaximize
         button.mouse_move_to()
         target_x = button.x + button.width / 2
-        target_y = self.screen_geo.get_monitor_geometry(self.panel_monitor)[1]
+        target_y = self.display.get_screen_geometry(self.panel_monitor)[1]
         self.mouse.move(target_x, target_y)
         sleep(1)
         self.mouse.click()
@@ -865,7 +867,7 @@
         self.open_new_application_window("Character Map")
         self.sleep_menu_settle_period()
 
-        self.start_app("Character Map")
+        self.process_manager.start_app("Character Map")
         sleep(self.panel.menus.fadein_duration / 1000.0)
         # Not using Eventually here since this is time-critical. Need to work
         # out a better way to do this.
@@ -1145,7 +1147,7 @@
 
     def setUp(self):
         super(PanelCrossMonitorsTests, self).setUp()
-        if self.screen_geo.get_num_monitors() < 2:
+        if self.display.get_num_screens() < 2:
             self.skipTest("This test requires a multimonitor setup")
 
     def test_panel_title_updates_moving_window(self):
@@ -1153,9 +1155,9 @@
         calc_win = self.open_new_application_window("Calculator")
 
         prev_monitor = None
-        for monitor in range(0, self.screen_geo.get_num_monitors()):
+        for monitor in range(0, self.display.get_num_screens()):
             if calc_win.monitor != monitor:
-                self.screen_geo.drag_window_to_monitor(calc_win, monitor)
+                drag_window_to_screen(calc_win, monitor)
 
             if prev_monitor:
                 prev_panel = self.unity.panels.get_panel_for_monitor(prev_monitor)
@@ -1174,7 +1176,7 @@
         self.open_new_application_window("Text Editor", maximized=True)
         self.sleep_menu_settle_period()
 
-        for monitor in range(0, self.screen_geo.get_num_monitors()):
+        for monitor in range(0, self.display.get_num_screens()):
             panel = self.unity.panels.get_panel_for_monitor(monitor)
             panel.move_mouse_over_window_buttons()
 
@@ -1192,7 +1194,7 @@
         self.unity.dash.ensure_visible()
         self.addCleanup(self.unity.dash.ensure_hidden)
 
-        for monitor in range(0, self.screen_geo.get_num_monitors()):
+        for monitor in range(0, self.display.get_num_screens()):
             panel = self.unity.panels.get_panel_for_monitor(monitor)
 
             if self.unity.dash.monitor == monitor:
@@ -1207,7 +1209,7 @@
         self.unity.hud.ensure_visible()
         self.addCleanup(self.unity.hud.ensure_hidden)
 
-        for monitor in range(0, self.screen_geo.get_num_monitors()):
+        for monitor in range(0, self.display.get_num_screens()):
             panel = self.unity.panels.get_panel_for_monitor(monitor)
 
             if self.unity.hud.monitor == monitor:
@@ -1223,7 +1225,7 @@
         """
         text_win = self.open_new_application_window("Text Editor", maximized=True)
 
-        for monitor in range(self.screen_geo.get_num_monitors()):
+        for monitor in range(self.display.get_num_screens()):
             panel = self.unity.panels.get_panel_for_monitor(monitor)
 
             if monitor != text_win.monitor:
@@ -1239,7 +1241,7 @@
         """
         text_win = self.open_new_application_window("Text Editor", maximized=True)
 
-        for monitor in range(self.screen_geo.get_num_monitors()):
+        for monitor in range(self.display.get_num_screens()):
             panel = self.unity.panels.get_panel_for_monitor(monitor)
 
             if monitor != text_win.monitor:
@@ -1254,7 +1256,7 @@
         """
         text_win = self.open_new_application_window("Text Editor", maximized=True)
 
-        for monitor in range(0, self.screen_geo.get_num_monitors()):
+        for monitor in range(0, self.display.get_num_screens()):
             panel = self.unity.panels.get_panel_for_monitor(monitor)
 
             if monitor != text_win.monitor:
@@ -1268,7 +1270,7 @@
         indicator = panel.indicators.get_indicator_by_name_hint("indicator-session")
         self.mouse_open_indicator(indicator)
 
-        for monitor in range(0, self.screen_geo.get_num_monitors()):
+        for monitor in range(0, self.display.get_num_screens()):
             panel = self.unity.panels.get_panel_for_monitor(monitor)
 
             entries = panel.get_indicator_entries(include_hidden_menus=True)
 
=== modified file 'tests/autopilot/unity/tests/test_quicklist.py'
--- tests/autopilot/unity/tests/test_quicklist.py	2013-04-09 18:39:09 +0000
+++ tests/autopilot/unity/tests/test_quicklist.py	2013-05-15 16:01:29 +0000
@@ -9,6 +9,7 @@
 
 from __future__ import absolute_import
 
+from autopilot.display import move_mouse_to_screen
 from autopilot.matchers import Eventually
 import os.path
 from testtools.matchers import Contains, Equals, NotEquals
@@ -40,13 +41,13 @@
 
     def get_desktop_entry(self, application):
         # load the desktop file from disk:
-        desktop_id = self.KNOWN_APPS[application]['desktop-file']
+        desktop_id = self.process_manager.KNOWN_APPS[application]['desktop-file']
         desktop_file = os.path.join('/usr/share/applications', desktop_id)
         return DesktopEntry(desktop_file)
 
     def test_quicklist_actions(self):
         """Test that all actions present in the destop file are shown in the quicklist."""
-        app = self.start_app(self.app_name)
+        app = self.process_manager.start_app(self.app_name)
 
         # get the launcher icon from the launcher:
         launcher_icon = self.unity.launcher.model.get_icon(desktop_id=app.desktop_file)
@@ -70,8 +71,8 @@
         self.register_nautilus()
         self.addCleanup(self.close_all_windows, "Nautilus")
 
-        self.start_app_window("Calculator")
-        self.start_app(self.app_name)
+        self.process_manager.start_app_window("Calculator")
+        self.process_manager.start_app(self.app_name)
 
         nautilus_icon = self.unity.launcher.model.get_icon(desktop_id="nautilus.desktop")
         ql = self.open_quicklist_for_icon(nautilus_icon)
@@ -85,7 +86,7 @@
 
         ql.click_item(new_win_ql_item)
 
-        nautilus_windows_fn = lambda: self.get_open_windows_by_application("Nautilus")
+        nautilus_windows_fn = lambda: self.process_manager.get_open_windows_by_application("Nautilus")
         self.assertThat(lambda: len(nautilus_windows_fn()), Eventually(Equals(1)))
         [nautilus_window] = nautilus_windows_fn()
 
@@ -100,9 +101,9 @@
         Then we activate the Calculator quicklist item.
         Then we actiavte the Mahjongg launcher icon.
         """
-        char_win1 = self.start_app_window("Character Map")
-        calc_win = self.start_app_window("Calculator")
-        char_win2 = self.start_app_window("Character Map")
+        char_win1 = self.process_manager.start_app_window("Character Map")
+        calc_win = self.process_manager.start_app_window("Calculator")
+        char_win2 = self.process_manager.start_app_window("Character Map")
 
         self.assertVisibleWindowStack([char_win2, calc_win, char_win1])
 
@@ -127,8 +128,8 @@
         """This tests shows that when you activate a quicklist application item
         when an application window is focused, the spread is initiated.
         """
-        char_win1 = self.start_app_window("Character Map")
-        char_win2 = self.start_app_window("Character Map")
+        char_win1 = self.process_manager.start_app_window("Character Map")
+        char_win2 = self.process_manager.start_app_window("Character Map")
         char_app = char_win1.application
 
         self.assertVisibleWindowStack([char_win2, char_win1])
@@ -147,7 +148,7 @@
     def test_quicklist_item_triggered_closes_dash(self):
         """When any quicklist item is triggered it must close the dash."""
 
-        calc_win = self.start_app_window("Calculator")
+        calc_win = self.process_manager.start_app_window("Calculator")
         self.assertProperty(calc_win, is_focused=True)
 
         self.unity.dash.ensure_visible()
@@ -163,7 +164,7 @@
 
     def test_quicklist_closes_when_hud_opens(self):
         """When a quicklist is open you must still be able to open the Hud."""
-        calc = self.start_app("Calculator")
+        calc = self.process_manager.start_app("Calculator")
 
         calc_icon = self.unity.launcher.model.get_icon(desktop_id=calc.desktop_file)
         self.open_quicklist_for_icon(calc_icon)
@@ -174,7 +175,7 @@
 
     def test_quicklist_closes_when_dash_opens(self):
         """When the quicklist is open you must still be able to open the dash."""
-        calc = self.start_app("Calculator")
+        calc = self.process_manager.start_app("Calculator")
 
         calc_icon = self.unity.launcher.model.get_icon(desktop_id=calc.desktop_file)
         self.open_quicklist_for_icon(calc_icon)
@@ -190,8 +191,8 @@
         lp:890991
         """
 
-        calc_win = self.start_app_window("Calculator")
-        mahj_win = self.start_app_window("Mahjongg")
+        calc_win = self.process_manager.start_app_window("Calculator")
+        mahj_win = self.process_manager.start_app_window("Mahjongg")
 
         calc_icon = self.unity.launcher.model.get_icon(
             desktop_id=calc_win.application.desktop_file)
@@ -210,7 +211,7 @@
         not re-open the quicklist if already open. It must hide.
         """
 
-        calc_win = self.start_app_window("Calculator")
+        calc_win = self.process_manager.start_app_window("Calculator")
 
         calc_icon = self.unity.launcher.model.get_icon(
             desktop_id=calc_win.application.desktop_file)
@@ -228,12 +229,12 @@
     def setUp(self):
         super(QuicklistKeyNavigationTests, self).setUp()
 
-        desktop_file = self.KNOWN_APPS["Text Editor"]["desktop-file"]
+        desktop_file = self.process_manager.KNOWN_APPS["Text Editor"]["desktop-file"]
         icon_refresh_fn = lambda : self.unity.launcher.model.get_icon(
             desktop_id=desktop_file)
 
         self.assertThat(icon_refresh_fn, Eventually(Equals(None)))
-        self.ql_app = self.start_app("Text Editor")
+        self.ql_app = self.process_manager.start_app("Text Editor")
 
         self.assertThat(icon_refresh_fn, Eventually(NotEquals(None)))
         self.ql_launcher_icon = icon_refresh_fn()
@@ -253,7 +254,7 @@
 
     def open_quicklist_with_keyboard(self):
         """Opens a quicklist using the keyboard."""
-        self.screen_geo.move_mouse_to_monitor(0)
+        move_mouse_to_screen(0)
         self.ql_launcher.key_nav_start()
         self.addCleanup(self.ql_launcher.key_nav_cancel)
 
 
=== modified file 'tests/autopilot/unity/tests/test_shortcut_hint.py'
--- tests/autopilot/unity/tests/test_shortcut_hint.py	2013-02-04 19:54:47 +0000
+++ tests/autopilot/unity/tests/test_shortcut_hint.py	2013-05-15 16:01:29 +0000
@@ -32,8 +32,8 @@
         sleep(1)
 
     def skip_if_monitor_too_small(self):
-        monitor = self.screen_geo.get_primary_monitor()
-        monitor_geo = self.screen_geo.get_monitor_geometry(monitor)
+        monitor = self.display.get_primary_screen()
+        monitor_geo = self.display.get_screen_geometry(monitor)
         monitor_w = monitor_geo[2]
         monitor_h = monitor_geo[3]
         launcher_width = self.unity.launcher.get_launcher_for_monitor(monitor).geometry[2]
@@ -51,7 +51,7 @@
     def get_launcher(self):
         # We could parameterise this so all tests run on both monitors (if MM is
         # set up), but I think it's fine to just always use monitor primary monitor:
-        monitor = self.screen_geo.get_primary_monitor()
+        monitor = self.display.get_primary_screen()
         return self.unity.launcher.get_launcher_for_monitor(monitor)
 
 
 
=== modified file 'tests/autopilot/unity/tests/test_showdesktop.py'
--- tests/autopilot/unity/tests/test_showdesktop.py	2013-02-04 19:54:47 +0000
+++ tests/autopilot/unity/tests/test_showdesktop.py	2013-05-15 16:01:29 +0000
@@ -27,8 +27,8 @@
 
     def launch_test_apps(self):
         """Launch character map and calculator apps, and return their windows."""
-        char_win = self.start_app_window('Character Map', locale='C')
-        calc_win = self.start_app_window('Calculator', locale='C')
+        char_win = self.process_manager.start_app_window('Character Map', locale='C')
+        calc_win = self.process_manager.start_app_window('Calculator', locale='C')
         return (char_win, calc_win)
 
     def test_showdesktop_hides_apps(self):
 
=== modified file 'tests/autopilot/unity/tests/test_spread.py'
--- tests/autopilot/unity/tests/test_spread.py	2013-02-04 19:54:47 +0000
+++ tests/autopilot/unity/tests/test_spread.py	2013-05-15 16:01:29 +0000
@@ -20,11 +20,11 @@
 
     def start_test_application_windows(self, app_name, num_windows=2):
         """Start a given number of windows of the requested application"""
-        self.close_all_app(app_name)
+        self.process_manager.close_all_app(app_name)
         windows = []
 
         for i in range(num_windows):
-            win = self.start_app_window(app_name)
+            win = self.process_manager.start_app_window(app_name)
             if windows:
                 self.assertThat(win.application, Equals(windows[-1].application))
 
@@ -44,7 +44,7 @@
         """Initiate the Spread for windows of the given app"""
         icon = self.unity.launcher.model.get_icon(desktop_id=desktop_id)
         self.assertThat(icon, NotEquals(None))
-        launcher = self.unity.launcher.get_launcher_for_monitor(self.screen_geo.get_primary_monitor())
+        launcher = self.unity.launcher.get_launcher_for_monitor(self.display.get_primary_screen())
 
         self.addCleanup(self.keybinding, "spread/cancel")
         launcher.click_launcher_icon(icon)
@@ -57,7 +57,7 @@
 
     def assertWindowIsClosed(self, xid):
         """Assert that a window is not in the list of the open windows"""
-        refresh_fn = lambda: xid in [w.x_id for w in self.bamf.get_open_windows()]
+        refresh_fn = lambda: xid in [w.x_id for w in self.process_manager.get_open_windows()]
         self.assertThat(refresh_fn, Eventually(Equals(False)))
 
     def test_scale_application_windows(self):
 
=== modified file 'tests/autopilot/unity/tests/test_switcher.py'
--- tests/autopilot/unity/tests/test_switcher.py	2013-02-04 19:54:47 +0000
+++ tests/autopilot/unity/tests/test_switcher.py	2013-05-15 16:01:29 +0000
@@ -8,6 +8,7 @@
 
 from __future__ import absolute_import
 
+from autopilot.display import move_mouse_to_screen
 from autopilot.matchers import Eventually
 from autopilot.testcase import multiply_scenarios
 import logging
@@ -60,7 +61,7 @@
             args = ('Calculator', 'Character Map', 'Character Map')
         windows = []
         for app in args:
-            windows.append(self.start_app_window(app))
+            windows.append(self.process_manager.start_app_window(app))
 
         return windows
 
@@ -77,7 +78,7 @@
 
     def test_switcher_starts_in_normal_mode(self):
         """Switcher must start in normal (i.e.- not details) mode."""
-        self.start_app("Character Map")
+        self.process_manager.start_app("Character Map")
 
         self.unity.switcher.initiate()
         self.addCleanup(self.unity.switcher.terminate)
@@ -97,7 +98,7 @@
 
     def test_application_window_is_fake_decorated(self):
         """When the switcher is in details mode must not show the focused window title."""
-        window = self.start_app_window("Text Editor")
+        window = self.process_manager.start_app_window("Text Editor")
         self.unity.switcher.initiate()
         self.addCleanup(self.unity.switcher.terminate)
 
@@ -109,7 +110,7 @@
 
     def test_application_window_is_fake_decorated_in_detail_mode(self):
         """Starting switcher in details mode must not show the focused window title."""
-        window = self.start_app_window("Text Editor")
+        window = self.process_manager.start_app_window("Text Editor")
         self.unity.switcher.initiate(SwitcherMode.DETAIL)
         self.addCleanup(self.unity.switcher.terminate)
 
@@ -178,7 +179,7 @@
         open the switcher.
 
         """
-        self.start_app("Character Map")
+        self.process_manager.start_app("Character Map")
 
         self.keybinding_hold("switcher/reveal_normal")
         self.addCleanup(self.keybinding_release, "switcher/reveal_normal")
@@ -190,7 +191,7 @@
 
     def test_switcher_cancel(self):
         """Pressing the switcher cancel keystroke must cancel the switcher."""
-        self.start_app("Character Map")
+        self.process_manager.start_app("Character Map")
 
         self.unity.switcher.initiate()
         self.addCleanup(self.unity.switcher.terminate)
@@ -201,7 +202,7 @@
 
     def test_lazy_switcher_cancel(self):
         """Must be able to cancel the switcher after a 'lazy' initiation."""
-        self.start_app("Character Map")
+        self.process_manager.start_app("Character Map")
 
         self.keybinding_hold("switcher/reveal_normal")
         self.addCleanup(self.keybinding_release, "switcher/reveal_normal")
@@ -221,14 +222,14 @@
         # TODO - this test fails in multi-monitor setups. You can't use addCleanup
         # a better way would be to have a scenario'd class for multi-monitor
         # switcher tests.
-        num_monitors = self.screen_geo.get_num_monitors()
+        num_monitors = self.display.get_num_screens()
         if num_monitors == 1:
             self.skip("No point testing this on one monitor")
 
         charmap, calc, mahjongg = self.start_applications()
 
         for monitor in range(num_monitors):
-            self.screen_geo.move_mouse_to_monitor(monitor)
+            move_mouse_to_screen(monitor)
             self.unity.switcher.initiate()
             self.addCleanup(self.unity.switcher.terminate)
             self.assertThat(self.unity.switcher.monitor, Eventually(Equals(monitor)))
@@ -236,7 +237,7 @@
     def test_switcher_alt_f4_is_disabled(self):
         """Tests that alt+f4 does not work while switcher is active."""
 
-        win = self.start_app_window("Text Editor")
+        win = self.process_manager.start_app_window("Text Editor")
 
         self.unity.switcher.initiate()
         self.addCleanup(self.unity.switcher.terminate)
@@ -333,7 +334,7 @@
             self.skipTest("This test requires enabled more than one workspace.")
         initial_workspace = self.workspace.current_workspace
         self.addCleanup(self.workspace.switch_to, initial_workspace)
-        self.start_app_window("Character Map")
+        self.process_manager.start_app_window("Character Map")
         self.workspace.switch_to((initial_workspace + 1) % self.workspace.num_workspaces)
         self.start_applications("Character Map", "Mahjongg")
 
@@ -366,7 +367,7 @@
         """Must be able to switch to details mode using selected scenario keycode.
 
         """
-        self.start_app_window("Character Map")
+        self.process_manager.start_app_window("Character Map")
         self.unity.switcher.initiate()
         self.addCleanup(self.unity.switcher.terminate)
 
@@ -379,7 +380,7 @@
         must select first item in the model in non-details mode.
 
         """
-        self.start_app("Character Map")
+        self.process_manager.start_app("Character Map")
         self.unity.switcher.initiate()
         self.addCleanup(self.unity.switcher.terminate)
         while self.unity.switcher.selection_index < len(self.unity.switcher.icons) - 1:
@@ -437,9 +438,9 @@
         initial_workspace = self.workspace.current_workspace
         self.addCleanup(self.workspace.switch_to, initial_workspace)
 
-        calc = self.start_app("Calculator")
+        calc = self.process_manager.start_app("Calculator")
         self.workspace.switch_to((initial_workspace + 1) % self.workspace.num_workspaces)
-        char_map = self.start_app("Character Map")
+        char_map = self.process_manager.start_app("Character Map")
 
         self.unity.switcher.initiate()
         self.addCleanup(self.unity.switcher.terminate)
@@ -453,9 +454,9 @@
         initial_workspace = self.workspace.current_workspace
         self.addCleanup(self.workspace.switch_to, initial_workspace)
 
-        calc = self.start_app("Calculator")
+        calc = self.process_manager.start_app("Calculator")
         self.workspace.switch_to((initial_workspace + 1) % self.workspace.num_workspaces)
-        char_map = self.start_app("Character Map")
+        char_map = self.process_manager.start_app("Character Map")
 
         self.unity.switcher.initiate(SwitcherMode.ALL)
         self.addCleanup(self.unity.switcher.terminate)
@@ -477,14 +478,14 @@
         # it harder to write the tests.
         self.set_unity_option("alt_tab_timeout", False)
 
-        self.start_app("Character Map")
+        self.process_manager.start_app("Character Map")
 
         self.workspace.switch_to((initial_workspace + 1) % self.workspace.num_workspaces)
-        char_win2 = self.start_app_window("Character Map")
+        char_win2 = self.process_manager.start_app_window("Character Map")
         self.keybinding("window/minimize")
         self.assertProperty(char_win2, is_hidden=True)
 
-        self.start_app("Calculator")
+        self.process_manager.start_app("Calculator")
 
         self.unity.switcher.initiate()
         while self.unity.switcher.current_icon.tooltip_text != char_win2.application.name: