Merge lp:~mardy/unity-2d/spread-a11y-geometry into lp:unity-2d

[Alberto Mardegan]

[spread] Allow keyboard navigation between workspaces

Turn the Workspace repeater into a GridView, which takes care of giving the
keyboard focus to the proper child element.

This branch is based on lp:~mardy/unity-2d/geometry, and doesn't exhibit the issue of having the desktop background jumping to the left when the exit animation has been completed.

[Florian Boucault (fboucault)]

Quite nice functionally. Though I did spot one issue: when a workspace is zoomed and you hover an unzoomed workspace, the zoomed workspace is instantly unzoomed and the one hovered becomes focus.

review: Needs Fixing (functional)

[Florian Boucault (fboucault)]

You did not actually implement accessibility in the workspace switcher, which is completely fine. The bug report might be confusing in that respect. Bottom line: do we have a separate bug report for adding a11y?

[Florian Boucault (fboucault)]

I see the issue I raised earlier was raised by Michaŀ in https://code.launchpad.net/~mardy/unity-2d/spread-a11y/+merge/78593
That was your answer:
"The first issue with the mouse hover could be avoided, but I chose it this way because I think it's more intuitive than requiring to click outside -- and indeed, if you zoomed into a workspace and then move the mouse out of it, you probably want to dismiss it (and if not, it's easy enough to bring it back to zoomed state). Let me know if I should change this."

I'll consult with design now.

[Florian Boucault (fboucault)]

btw, which one is the one that is going to be merged? this MR or that one: https://code.launchpad.net/~mardy/unity-2d/spread-a11y/+merge/78593

[Florian Boucault (fboucault)]

> I see the issue I raised earlier was raised by Michaŀ in
> https://code.launchpad.net/~mardy/unity-2d/spread-a11y/+merge/78593
> That was your answer:
> "The first issue with the mouse hover could be avoided, but I chose it this
> way because I think it's more intuitive than requiring to click outside -- and
> indeed, if you zoomed into a workspace and then move the mouse out of it, you
> probably want to dismiss it (and if not, it's easy enough to bring it back to
> zoomed state). Let me know if I should change this."
>
> I'll consult with design now.

Design, in the person of John Lea, spotted at least one issue with that automatic zoom on hover: when the user reaches for the launcher the zoomed workspace is automatically unzoomed, which is confusing.

[Alberto Mardegan (mardy)]

> btw, which one is the one that is going to be merged? this MR or that one:
> https://code.launchpad.net/~mardy/unity-2d/spread-a11y/+merge/78593

This one. I'll cancel the old one.

I'll fix the unzooming on mouse movement; about the a11y, you are right, this is about keyboard navigation only. I'm not aware of any existing bug.

[Alberto Mardegan (mardy)]

Updated the code. Now the zoomed view is not exited with just a mouse hover.

[Michał Sawicz (saviq)]

One more thing:
1. Invoke spread;
2. Zoom to a workspace with 2+ windows;
3. Click on another workspace;

Expected:
Current workspace unzooms, clicked workspace gets focus and highlight;

Current result:
Highlight shows up where current workspace should be, current workspace unzooms and remains focused;

review: Needs Fixing (functional)

[Alberto Mardegan (mardy)]

> One more thing:
> 1. Invoke spread;
> 2. Zoom to a workspace with 2+ windows;
> 3. Click on another workspace;

Fixed, MR updated.

[Lohith D Shivamurthy (dyams)]

There are issues I observed:

1) Invoke the Spread.
2) Now mouse hover over any other workspace in the spread.
3) The any other workspace is highlighted.
4) Now Press Spread shortcut, Super+S.

Expected:
The highlighted workspace(mouse hovered) should be brought to front.

Actual:
The previously zoomed workspace in brought to front again, ignored the current choice.

-----------------------------------------------------
Other issue is :

1) Have at least 2+ windows in two different workspaces
2) Invoke spread
3) Now click on a workspace which contains at least two windows
3) workspace comes front with window selection. (75% Zoomed)
4) Press Spread shortcut, Super+S key

Expected:
The spread should come back to its previous state again where all workspaces are shown in the Grid.

Actual:
Some other workspace is brought to front completely.

[Alberto Mardegan (mardy)]

Sorry, I have to step out of this, as I don't have time for fixing the issues raised.

[Gerry Boland (gerboland)]

Unit tests not passing just yet, so merge will fail. Wait for my fixes then merge.

[Lohith D Shivamurthy (dyams)]

There is merge conflict in places/dashdeclarativeview.cpp

mardy: would it be possible for you to resolve this? Please
It would be very helpful, if you could do so.

rebase your branch with current trunk. You have to edit only two lines.

Thank you.

[Lohith D Shivamurthy (dyams)]

This branch is moved to new location.
Please follow the new branch here
https://code.launchpad.net/~dyams/unity-2d/mardy-spread-a11y-geometry/+merge/83773

Thank you

=== modified file 'libunity-2d-private/Unity2d/GnomeBackground.qml'
--- libunity-2d-private/Unity2d/GnomeBackground.qml	2011-10-21 08:07:49 +0000
+++ libunity-2d-private/Unity2d/GnomeBackground.qml	2011-11-02 20:30:31 +0000
@@ -24,6 +24,8 @@
 Item {
     property string overlay_color
     property real overlay_alpha
+    property int offsetX: -1
+    property int offsetY: -1
     
     /* Avoid redraw at rendering */
     CacheEffect {
@@ -86,8 +88,8 @@
         /* by default, place the background on top of the desktop background,
            no matter where the DeclarativeView or the parent object are placed.
         */
-        x: parent.mapFromItem(null, -declarativeView.globalPosition.x, 0).x
-        y: parent.mapFromItem(null, 0, -declarativeView.globalPosition.y).y
+        x: offsetX != -1 ? offsetX : parent.mapFromItem(null, -declarativeView.globalPosition.x, 0).x
+        y: offsetY != -1 ? offsetY : parent.mapFromItem(null, 0, -declarativeView.globalPosition.y).y
 
         /* Possible modes are:
             - "wallpaper"

=== modified file 'libunity-2d-private/src/screeninfo.cpp'
--- libunity-2d-private/src/screeninfo.cpp	2011-10-03 11:13:44 +0000
+++ libunity-2d-private/src/screeninfo.cpp	2011-11-02 20:30:31 +0000
@@ -71,6 +71,12 @@
 
 QRect ScreenInfo::availableGeometry() const
 {
+    int screen = QX11Info::appScreen();
+    return QApplication::desktop()->availableGeometry(screen);
+}
+
+QRect ScreenInfo::panelsFreeGeometry() const
+{
     /* We cannot just return the system's availableGeometry(), because that
      * doesn't consider the Launcher, if it's set to auto-hide. */
     int screen = QX11Info::appScreen();
@@ -105,6 +111,7 @@
 {
     if (screen == QX11Info::appScreen()) {
         Q_EMIT availableGeometryChanged(availableGeometry());
+        Q_EMIT panelsFreeGeometryChanged(panelsFreeGeometry());
     }
 }
 

=== modified file 'libunity-2d-private/src/screeninfo.h'
--- libunity-2d-private/src/screeninfo.h	2011-07-29 13:49:34 +0000
+++ libunity-2d-private/src/screeninfo.h	2011-11-02 20:30:31 +0000
@@ -21,6 +21,7 @@
     Q_PROPERTY(unsigned int activeWindow READ activeWindow NOTIFY activeWindowChanged)
     Q_PROPERTY(QRect geometry READ geometry NOTIFY geometryChanged)
     Q_PROPERTY(QRect availableGeometry READ availableGeometry NOTIFY availableGeometryChanged)
+    Q_PROPERTY(QRect panelsFreeGeometry READ panelsFreeGeometry NOTIFY panelsFreeGeometryChanged)
     Q_PROPERTY(bool isCompositingManagerRunning READ isCompositingManagerRunning
                                                 NOTIFY isCompositingManagerRunningChanged)
 
@@ -36,6 +37,7 @@
     WorkspacesInfo *workspaces() { return &m_workspacesInfo; }
     unsigned int activeWindow() const { return m_activeWindow; }
     QRect availableGeometry() const;
+    QRect panelsFreeGeometry() const;
     QRect geometry() const;
     bool isCompositingManagerRunning() const;
 
@@ -43,6 +45,7 @@
     void activeWindowChanged(unsigned int activeWindow);
     void geometryChanged(QRect geometry);
     void availableGeometryChanged(QRect availableGeometry);
+    void panelsFreeGeometryChanged(QRect panelsFreeGeometry);
     void workspacesChanged(WorkspacesInfo *workspaces);
     void isCompositingManagerRunningChanged(bool);
 

=== modified file 'places/app/dashdeclarativeview.cpp'
--- places/app/dashdeclarativeview.cpp	2011-10-03 11:13:44 +0000
+++ places/app/dashdeclarativeview.cpp	2011-11-02 20:30:31 +0000
@@ -59,7 +59,6 @@
     setTransparentBackground(QX11Info::isCompositingManagerRunning());
 
     QDesktopWidget* desktop = QApplication::desktop();
-    connect(desktop, SIGNAL(resized(int)), SIGNAL(screenGeometryChanged()));
     connect(desktop, SIGNAL(resized(int)), SIGNAL(updateDashModeDependingOnScreenGeometry()));
     connect(desktop, SIGNAL(workAreaResized(int)), SLOT(onWorkAreaResized(int)));
 
@@ -74,7 +73,6 @@
     }
 
     updateSize();
-    availableGeometryChanged();
 }
 
 
@@ -112,7 +110,7 @@
 void
 DashDeclarativeView::fitToAvailableSpace()
 {
-    QRect rect = availableGeometry();
+    QRect rect = m_screenInfo->panelsFreeGeometry();
     move(rect.topLeft());
     setFixedSize(rect.size());
 }
@@ -120,7 +118,7 @@
 void
 DashDeclarativeView::resizeToDesktopModeSize()
 {
-    QRect rect = availableGeometry();
+    QRect rect = m_screenInfo->panelsFreeGeometry();
     int screenRight = rect.right();
 
     rect.setWidth(qMin(DASH_DESKTOP_WIDTH, rect.width()));
@@ -261,19 +259,6 @@
     setActive(true);
 }
 
-const QRect
-DashDeclarativeView::screenGeometry() const
-{
-    QDesktopWidget* desktop = QApplication::desktop();
-    return desktop->screenGeometry(this);
-}
-
-QRect
-DashDeclarativeView::availableGeometry() const
-{
-    return m_screenInfo->availableGeometry();
-}
-
 void
 DashDeclarativeView::keyPressEvent(QKeyEvent* event)
 {

=== modified file 'places/app/dashdeclarativeview.h'
--- places/app/dashdeclarativeview.h	2011-10-03 11:13:44 +0000
+++ places/app/dashdeclarativeview.h	2011-11-02 20:30:31 +0000
@@ -32,8 +32,6 @@
     Q_PROPERTY(bool expanded READ expanded WRITE setExpanded NOTIFY expandedChanged)
     Q_PROPERTY(DashMode dashMode READ dashMode WRITE setDashMode NOTIFY dashModeChanged)
     Q_PROPERTY(QString activeLens READ activeLens WRITE setActiveLens NOTIFY activeLensChanged)
-    Q_PROPERTY(QRect screenGeometry READ screenGeometry NOTIFY screenGeometryChanged)
-    Q_PROPERTY(QRect availableGeometry READ availableGeometry NOTIFY availableGeometryChanged)
 
 public:
     enum DashMode {
@@ -46,8 +44,6 @@
     bool active() const;
     DashMode dashMode() const;
     const QString& activeLens() const;
-    const QRect screenGeometry() const;
-    QRect availableGeometry() const;
     bool expanded() const;
 
     /* setters */
@@ -67,9 +63,6 @@
     void expandedChanged(bool);
     void activeLensChanged(const QString&);
 
-    void screenGeometryChanged();
-    void availableGeometryChanged();
-
 protected:
     void resizeEvent(QResizeEvent*);
     virtual void showEvent(QShowEvent *event);

=== modified file 'spread/Windows.qml'
--- spread/Windows.qml	2011-08-09 13:33:24 +0000
+++ spread/Windows.qml	2011-11-02 20:30:31 +0000
@@ -32,22 +32,23 @@
 
    The context property called control is the initiator of the entire spread process, and
    is triggered by D-Bus calls on the C++ side.
-
-   The ScreenInfo's property availableGeometry represents the available space on the screen (i.e.
-   screen minus launcher, panels, etc.).
 */
 
 GridView {
     id: windows
 
     signal clicked
+    signal entered
     signal windowActivated(variant window)
 
+    keyNavigationWraps: state == "zoomed"
+
     MouseArea {
         anchors.fill: parent
         onClicked: windows.clicked()
         /* Eating all mouse events so that they are not passed beneath the workspace */
         hoverEnabled: true
+        onEntered: windows.entered()
     }
 
     /* This proxy model takes care of removing all windows that are not on
@@ -79,7 +80,12 @@
     cellWidth: Math.floor(width / columns)
     cellHeight: height / rows
 
-    model: filteredByApplication
+    /* Set the model only when the component is ready; otherwise, the
+     * initialization gets somehow messed up and the "columns" and "rows"
+     * variables are set to those of the first workspace. */
+    Component.onCompleted: {
+        model = filteredByApplication
+    }
 
     delegate:
         Item {
@@ -93,6 +99,11 @@
                 itemHeight: window.size.height
                 parent: windows
             }
+            /* We are not using GridView.isCurrentItem because it mysteriously
+             * returns "false" the first time the spread is activated. Couldn't
+             * reproduce the same behaviour with simpler test cases.
+             */
+            focus: GridView.view.currentIndex == index
 
             /* Workaround http://bugreports.qt.nokia.com/browse/QTBUG-15642 where onAdd is not called for the first item */
             //GridView.onAdd:
@@ -106,8 +117,10 @@
                 switch (event.key) {
                     case Qt.Key_Enter:
                     case Qt.Key_Return:
+                    {
                         windows.windowActivated(spreadWindow)
                         event.accepted = true
+                    }
                 }
             }
 
@@ -121,7 +134,8 @@
 
                 onEntered: {
                     windows.currentIndex = index
-                    cell.forceActiveFocus()
+                    /* Make sure the workspace is notified as well */
+                    windows.entered()
                 }
 
                 onClicked: windows.windowActivated(spreadWindow)
@@ -141,14 +155,12 @@
                 Behavior on height { enabled: spreadWindow.animateFollow; NumberAnimation { duration: Utils.transitionDuration; easing.type: Easing.InOutQuad } }
 
                 windowInfo: window
-                state: windows.state
+                state: windows.state == "screen" ? "screen" : "spread"
                 states: [
                     State {
                         name: "screen"
                         PropertyChanges {
                             target: spreadWindow
-                            /* Note that we subtract the availableGeometry x and y since window.location is
-                            expressed in global screen coordinates. */
                             x: window.position.x - declarativeView.globalPosition.x
                             y: window.position.y - declarativeView.globalPosition.y
                             width: window.size.width

=== modified file 'spread/Workspace.qml'
--- spread/Workspace.qml	2011-08-10 00:10:39 +0000
+++ spread/Workspace.qml	2011-11-02 20:30:31 +0000
@@ -23,100 +23,150 @@
 FocusScope {
     id: workspace
 
-    transformOrigin: Item.TopLeft
-
     property real unzoomedScale
-    property int unzoomedX
-    property int unzoomedY
     property real zoomedScale
     property int zoomedX
     property int zoomedY
+    property alias windowCount: windows.count
 
+    property int screenOriginX
+    property int screenOriginY
     signal clicked
-
-    GnomeBackground {
-        anchors.fill: parent
-        overlay_color: "black"
-        overlay_alpha: 0
-
-        clip: true
-        cached: false
-    }
-
-    Windows {
-        state: workspace.state == "screen" ? "screen" : "spread"
-        anchors.fill: parent
-        focus: true
-        onClicked: workspace.clicked()
-        onWindowActivated: {
-            if (workspace.state != "zoomed") {
-                workspace.clicked()
-            } else {
-                /* Hack to make sure the window is on top of the others during the
-                   outro animation */
-                window.z = 9999
-                switcher.activateWindow(window.windowInfo)
-            }
-        }
-    }
-
-    states: [
-        State {
-            name: "unzoomed"
-            PropertyChanges {
-                target: workspace
-                scale: unzoomedScale
-                x: unzoomedX
-                y: unzoomedY
-                z: 0
-            }
-        },
-        State {
-            name: "zoomed"
-            PropertyChanges {
-                target: workspace
-                scale: zoomedScale
-                x: zoomedX
-                y: zoomedY
-                z: 2
-            }
-        },
-        State {
-            name: "screen"
-            PropertyChanges {
-                target: workspace
-                scale: 1.0
-                x: 0
-                y: 0
-                z: 2
-            }
-        }
-    ]
-
-    transitions: [
-        Transition {
-            NumberAnimation {
-                target: workspace
-                properties: "x,y,scale"
-                duration: Utils.transitionDuration
-                easing.type: Easing.InOutQuad
-            }
-        },
-        Transition {
-            to: "unzoomed"
-            SequentialAnimation {
-                /* When going to default state put the workspace underneath the
-                   workspace in zoomed state but not on the same plane as the
-                   workspaces also in the default state until the end of the transition. */
-                PropertyAction { property: "z"; value: 1 }
+    signal entered
+
+    onStateChanged: {
+        screenOriginX = mapFromItem(switcher, 0, 0).x
+        screenOriginY = mapFromItem(switcher, 0, 0).y
+    }
+
+    Item {
+        id: workspaceWindow
+
+        transformOrigin: Item.TopLeft
+        width: switcher.width
+        height: switcher.height
+        state: parent.state
+
+        GnomeBackground {
+            anchors.fill: parent
+            overlay_color: "black"
+            overlay_alpha: 0
+
+            clip: true
+            cached: false
+            offsetX: -screen.panelsFreeGeometry.x
+            offsetY: -screen.panelsFreeGeometry.y
+        }
+
+        Windows {
+            id: windows
+            state: workspace.state
+            anchors.fill: parent
+            focus: true
+            onClicked: workspace.clicked()
+            onEntered: workspace.entered()
+            onWindowActivated: {
+                if (workspace.state != "zoomed") {
+                    workspace.clicked()
+                } else {
+                    /* Hack to make sure the window is on top of the others during the
+                       outro animation */
+                    window.z = 9999
+                    switcher.activateWindow(window.windowInfo)
+                }
+            }
+        }
+
+        states: [
+            State {
+                name: "unzoomed"
+                PropertyChanges {
+                    target: workspaceWindow
+                    scale: unzoomedScale
+                    x: switcher.spacing / 2
+                    y: switcher.spacing / 2
+                }
+                PropertyChanges {
+                    target: workspace
+                    z: 0
+                }
+            },
+            State {
+                name: "zoomed"
+                PropertyChanges {
+                    target: workspaceWindow
+                    scale: zoomedScale
+                    x: zoomedX + workspace.screenOriginX
+                    y: zoomedY + workspace.screenOriginY
+                }
+                PropertyChanges {
+                    target: workspace
+                    z: 2
+                }
+            },
+            State {
+                name: "screen"
+                PropertyChanges {
+                    target: workspaceWindow
+                    scale: 1.0
+                    x: workspace.screenOriginX
+                    y: workspace.screenOriginY
+                }
+                PropertyChanges {
+                    target: workspace
+                    z: 2
+                }
+            }
+        ]
+
+        transitions: [
+            Transition {
+                /* Disable animations when coming from the base state */
+                from: ""
+            },
+            Transition {
                 NumberAnimation {
-                    target: workspace
+                    target: workspaceWindow
                     properties: "x,y,scale"
                     duration: Utils.transitionDuration
                     easing.type: Easing.InOutQuad
                 }
-                PropertyAction { property: "z" }
+            },
+            Transition {
+                to: "unzoomed"
+                SequentialAnimation {
+                    /* When going to default state put the workspace underneath the
+                       workspace in zoomed state but not on the same plane as the
+                       workspaces also in the default state until the end of the transition. */
+                    PropertyAction { target: workspace; property: "z"; value: 1 }
+                    NumberAnimation {
+                        target: workspaceWindow
+                        properties: "x,y,scale"
+                        duration: Utils.transitionDuration
+                        easing.type: Easing.InOutQuad
+                    }
+                    PropertyAction { target: workspace; property: "z" }
+                }
+            }
+        ]
+    }
+
+    Keys.onPressed: {
+        switch (event.key) {
+            case Qt.Key_Enter:
+            case Qt.Key_Return:
+            {
+                clicked()
+                event.accepted = true
             }
         }
-    ]
+    }
+
+    function setFocusOnFirstWindow() {
+        windows.currentIndex = 0
+    }
+
+    function setFocusOnLastWindow() {
+        windows.currentIndex = windows.count - 1
+    }
 }

=== modified file 'spread/Workspaces.qml'
--- spread/Workspaces.qml	2011-10-18 12:19:18 +0000
+++ spread/Workspaces.qml	2011-11-02 20:30:31 +0000
@@ -29,28 +29,35 @@
     property int rows: screen.workspaces.rows
 
     property int margin: 35
-    property int spacing: 5
+    property int spacing: 4
 
     /* Effective area available for laying out the workspaces after considering
        inter-workspace spaces */
-    property int availableWidth: switcher.width - ((columns - 1) * spacing)
-    property int availableHeight: switcher.height - ((rows - 1) * spacing)
-
-    /* Scale of each workspace when laid out in the switcher grid
-       Note that all scale calculations are done using the desktop's available
-       geometry as this is the "natural" (initial) size of every workspace.
-
-       FIXME: this seems to be broken in the case of 10 workspaces and 4x4 layout.
-              it does only display a 3x3 grid for some reason.
-    */
-    property bool isLayoutHorizontal: (columns * screen.availableGeometry.width) >
-                                      (rows * screen.availableGeometry.height)
-    property real cellScale: (isLayoutHorizontal) ? (availableWidth / columns / switcher.width) :
-                                                    (availableHeight / rows / switcher.height)
+    property int availableWidth: switcher.width - (columns * spacing)
+    property int availableHeight: switcher.height - (rows * spacing)
+
+    property int maxCellWidth: Math.floor(availableWidth / columns)
+    property int maxCellHeight: Math.floor(availableHeight / rows)
+    /* Depending on the aspect ratio of the final workspaces layout, we will
+       have either vertical or horizontal margins. That is, we will either:
+       - use maxCellWidth as base cell width and compute the height based on the
+         screen ratio, or
+       - use maxCellHeight for the base cell height and compute the width based
+         on the screen ratio.
+       To figure out which way to go, compute the other size and see how things
+       would fit inside the screen.  */
+    property int computedCellHeight: maxCellWidth * switcher.height / switcher.width
+    property int computedCellWidth: maxCellHeight * switcher.width / switcher.height
+
+    property bool useWidth: (computedCellHeight + spacing) * rows <= switcher.height
+
+    property int cellWidth: useWidth ? maxCellWidth : computedCellWidth
+    property int cellHeight: useWidth ? computedCellHeight : maxCellHeight
+    property real cellScale: cellWidth / switcher.width
 
     /* Scale of a workspace when the user zooms on it (fills most of the switcher, leaving a margin to see
        the corners of the other workspaces below it) */
-    property bool isDesktopHorizontal: screen.availableGeometry.width > screen.availableGeometry.height
+    property bool isDesktopHorizontal: screen.panelsFreeGeometry.width > screen.panelsFreeGeometry.height
     property real zoomedScale: (isDesktopHorizontal) ? ((width - 2*margin) / switcher.width) :
                                                        ((height - 2*margin) / switcher.height)
 
@@ -71,34 +78,62 @@
     /* Group all Workspace elements into a single Item to help workspaceByNumber
        iterate over less items than it would need to if the Repeater was adding children
        to the switcher itself. */
-    Repeater {
+    GridView {
         id: workspaces
+        anchors.centerIn: parent
+
+        width: cellWidth * columns
+        height: cellHeight * rows
 
         model: screen.workspaces.count
+        cellWidth: parent.cellWidth + spacing
+        cellHeight: parent.cellHeight + spacing
+        keyNavigationWraps: true
+        property string windowFocus
+        Keys.onPressed: {
+            if (event.key == Qt.Key_Left || event.key == Qt.Key_Up) {
+                windowFocus = "last"
+            } else if (event.key == Qt.Key_Right || event.key == Qt.Key_Down) {
+                windowFocus = "first"
+            }
+        }
+
+        highlight: Rectangle {
+            color: "orange"
+            x: workspaces.currentItem.x
+            y: workspaces.currentItem.y
+            z: -1
+            width: workspaces.cellWidth
+            height: workspaces.cellHeight
+            visible: workspaces.currentItem.state == "unzoomed"
+        }
+        highlightFollowsCurrentItem: false
+
         delegate: Workspace {
             id: workspace
 
-            /* FIXME: This is ok right now since we ignore screen.orientation and
-               screen.startingCorner, but we should respect them eventually */
             property int workspaceNumber: index
-            property int row: Math.floor(index / columns)
-            property int column: index % columns
-
-            width: switcher.width
-            height: switcher.height
-
-            /* Organize the workspaces in a grid in 'unzoomed' state */
-            unzoomedX: column * (switcher.width * cellScale) + (column * switcher.spacing)
-            unzoomedY: row * (switcher.height * cellScale) + (row * switcher.spacing)
+
+            width: workspaces.cellWidth
+            height: workspaces.cellHeight
+
             unzoomedScale:  switcher.cellScale
 
             /* Center the workspace in 'zoomed' state */
-            zoomedX: (switcher.width - width*zoomedScale) / 2
-            zoomedY: (switcher.height - height*zoomedScale) / 2
+            zoomedX: switcher.width * (1 - zoomedScale) / 2
+            zoomedY: switcher.height * (1 - zoomedScale) / 2
             zoomedScale: switcher.zoomedScale
 
-            focus: zoomedWorkspace == workspaceNumber
-
+            Connections {
+                target: workspaces
+                onCurrentIndexChanged: {
+                    if (workspaces.windowFocus == "first") {
+                        setFocusOnFirstWindow()
+                    } else if (workspaces.windowFocus == "last") {
+                        setFocusOnLastWindow()
+                    }
+                }
+            }
             state: {
                 if (initial) {
                     if (screen.workspaces.current == workspaceNumber) {
@@ -115,16 +150,32 @@
                 }
             }
 
+            onEntered: {
+                if (zoomedWorkspace == -1) {
+                    workspaces.currentIndex = index
+                }
+            }
+
             onClicked: {
                 if (zoomedWorkspace == workspaceNumber) {
                     activateWorkspace(workspaceNumber)
                 } else if (zoomedWorkspace == -1) {
-                    zoomedWorkspace = workspaceNumber
+                    if (windowCount <= 1) {
+                        activateWorkspace(workspaceNumber)
+                    } else {
+                        workspaces.currentIndex = index
+                        zoomedWorkspace = workspaceNumber
+                    }
                 } else {
+                    workspaces.currentIndex = index
                     zoomedWorkspace = -1
                 }
             }
         }
+
+        onCurrentIndexChanged: {
+            zoomedWorkspace = -1
+        }
     }
 
     /* FIXME: bad naming. Ideas: screenModeActivated, initialState */
@@ -166,9 +217,10 @@
 
         spreadView.show()
         spreadView.forceActivateWindow()
+        workspaces.currentIndex = screen.workspaces.current
         /* This is necessary otherwise we don't get keypresses until the user does a
            mouse over on a window */
-        switcher.forceActiveFocus()
+        workspaces.forceActiveFocus()
         initial = false
     }
 

=== modified file 'spread/app/spreadview.cpp'
--- spread/app/spreadview.cpp	2011-10-03 11:13:44 +0000
+++ spread/app/spreadview.cpp	2011-11-02 20:30:31 +0000
@@ -38,7 +38,7 @@
 
     if(screen == current_screen)
     {
-        QRect geometry = m_screenInfo->availableGeometry();
+        QRect geometry = m_screenInfo->panelsFreeGeometry();
         setGeometry(geometry);
         setFixedSize(geometry.size());
     }