Merge lp:~unity-2d-team/unity-2d/unity-2d-shell-shaped-testability-shapetests into lp:~unity-2d-team/unity-2d/unity-2d-shell

[Ugo Riboni]

[shell] Shape the shell window input according to what components are visible

[Michał Sawicz (saviq)]

* inputshapemask.cpp:19 always add a trailing slash to unity2dDirectory() as it doesn't do that internally (see bug 918669)
* one thing I'm afraid of: animating the launcher shape looks unnecessary and a resource drain, could we have just the "fully-on-screen" shape, enabled or disabled as soon as the launcher is supposed to be shown?
* unity2ddeclarativeview.cpp:161 any reason for the #include there?

[lp:~unity-2d-team/unity-2d/unity-2d-shell-shaped-testability-shapetests]

927. By Michał Sawicz on 2012-01-19

Merge from shell

[Michał Sawicz (saviq)]

* getshape.cpp:72 unnecessary space before semicolon
* getshape.cpp maybe use QUrl::fromLocalFile / toLocalFile to handle things like ~?
* getshape.cpp doesn't seem to handle masks, just rectangles?
* input_shaping.rb:9 I'm sure Gerry will be pleased ;)
* input_shaping.rb:35 open_window_at has been refactored into a separate TmpWindow class, see autohide_show_tests.rb
* input_shaping.rb:68 maybe use a constant like other UNITY_2D_* do?, especially if #{pwd} is really $PWD
* input_shaping.rb:92 says "Launcher Autohide and Show Tests"
* input_shaping.rb:92 maybe abstract the constants to run-tests.rb? we do have the launcher width in launcher tests, too, might make sense to only have them in one place
* input_shaping.rb:94 DASH_HEIGHT_COLLAPSED looks unused?
* input_shaping.rb:128 says Launcher, should be Shell?
* input_shaping.rb:188 why D-Bus? do we actually need / want to expose that over D-Bus?

review: Needs Fixing

[lp:~unity-2d-team/unity-2d/unity-2d-shell-shaped-testability-shapetests]

928. By Ugo Riboni on 2012-01-19

Fix minor style issue and make use of unity2dDirectory more robust

929. By Ugo Riboni on 2012-01-19

Don't animate the shape of the launcher

930. By Ugo Riboni on 2012-01-19

Add missing verification image

[Gerry Boland (gerboland)]

Please can you add a comment of the following form to each test case?:

# Test case objectives:
# * Check the Launcher position on Empty desktop
# Pre-conditions
# * Desktop with no running applications
# Test steps
# * Verify something
# * Click a button
# * Verify this happens
# Post-conditions
# * What non-unity2d thing should exist at test end
# References
# * None (lp bug number?)

This helps show what test cases need to be altered for future changes, and lets non-experts analyse the coverage of our test-suite.

And one more thing: "desktop_geometry" could be added to the Ruby XDo library

[lp:~unity-2d-team/unity-2d/unity-2d-shell-shaped-testability-shapetests]

931. By Ugo Riboni on 2012-01-19

Fix style issues, use verify in tests and not assert, remove dead code, include shell tests in the global test run

932. By Ugo Riboni on 2012-01-19

Put back asserts in the utility functions as verify seems to work inside tests only

933. By Ugo Riboni on 2012-01-19

Ensure we're running a panel before the test battery starts. Fix some style issues.

934. By Ugo Riboni on 2012-01-20

Remove the test for same size before comparing images, and add return code check instead

935. By Ugo Riboni on 2012-01-20

Tap the button to close shortcuts instead of fiddling with internal variables

936. By Ugo Riboni on 2012-01-20

Put back the image size tests as they never hurt, and use verify_true to check the return of the compare_images

937. By Ugo Riboni on 2012-01-20

Wait a bit after simulating taps and keystrokes, to ensure everything settles before getting shapes

[Michał Sawicz (saviq)]

review: Approve

=== modified file 'CMakeLists.txt'
--- CMakeLists.txt	2012-01-10 16:41:53 +0000
+++ CMakeLists.txt	2012-01-20 13:41:29 +0000
@@ -97,6 +97,7 @@
 add_subdirectory(spread)
 add_subdirectory(shell)
 add_subdirectory(po)
+add_subdirectory(tests/getshape)
 
 # uninstall target
 configure_file("${CMAKE_CURRENT_SOURCE_DIR}/cmake_uninstall.cmake.in" "${CMAKE_CURRENT_BINARY_DIR}/cmake_uninstall.cmake" IMMEDIATE @ONLY)

=== modified file 'libunity-2d-private/Unity2d/plugin.cpp'
--- libunity-2d-private/Unity2d/plugin.cpp	2012-01-20 10:19:06 +0000
+++ libunity-2d-private/Unity2d/plugin.cpp	2012-01-20 13:41:29 +0000
@@ -69,6 +69,11 @@
 #include "spreadmonitor.h"
 #include "focuspath.h"
 
+#include "unity2ddeclarativeview.h"
+#include "inputshapemanager.h"
+#include "inputshaperectangle.h"
+#include "inputshapemask.h"
+
 #include <QtDeclarative/qdeclarative.h>
 #include <QDeclarativeEngine>
 #include <QDeclarativeContext>
@@ -161,6 +166,11 @@
     qmlRegisterType<GestureHandler>(uri, 0, 1, "GestureHandler");
     qmlRegisterType<WindowsIntersectMonitor>(uri, 0, 1, "WindowsIntersectMonitor");
     qmlRegisterType<SpreadMonitor>(uri, 0, 1, "SpreadMonitor");
+
+    qmlRegisterType<InputShapeManager>(uri, 0, 1, "InputShapeManager");
+    qmlRegisterType<InputShapeRectangle>(uri, 0, 1, "InputShapeRectangle");
+    qmlRegisterType<InputShapeMask>(uri, 0, 1, "InputShapeMask");
+    qmlRegisterType<Unity2DDeclarativeView>();
 }
 
 void Unity2dPlugin::initializeEngine(QDeclarativeEngine *engine, const char *uri)

=== modified file 'libunity-2d-private/src/CMakeLists.txt'
--- libunity-2d-private/src/CMakeLists.txt	2012-01-20 10:19:06 +0000
+++ libunity-2d-private/src/CMakeLists.txt	2012-01-20 13:41:29 +0000
@@ -73,6 +73,9 @@
     abstractdbusservicemonitor.cpp
     spreadmonitor.cpp
     focuspath.cpp
+    inputshapemanager.cpp
+    inputshaperectangle.cpp
+    inputshapemask.cpp
     )
 
 # Build

=== added file 'libunity-2d-private/src/inputshapemanager.cpp'
--- libunity-2d-private/src/inputshapemanager.cpp	1970-01-01 00:00:00 +0000
+++ libunity-2d-private/src/inputshapemanager.cpp	2012-01-20 13:41:29 +0000
@@ -0,0 +1,87 @@
+#include <QDebug>
+#include <QRect>
+#include <QX11Info>
+#include <QRegion>
+
+#include "inputshapemanager.h"
+#include "unity2ddeclarativeview.h"
+#include "screeninfo.h"
+
+// X11
+#include <X11/Xlib.h>
+#include <X11/Xregion.h>
+#include <X11/extensions/shape.h>
+
+InputShapeManager::InputShapeManager(QObject *parent) :
+    QObject(parent),
+    m_target(0)
+{
+}
+
+void InputShapeManager::updateManagedShape()
+{
+    if (m_target == NULL || !m_target->isVisible()) {
+        return;
+    }
+
+    QBitmap inputShape(m_target->width(), m_target->height());
+    inputShape.fill(Qt::color0);
+    QPainter painter(&inputShape);
+
+    Q_FOREACH(InputShapeRectangle* shape, m_shapes) {
+        if (shape->enabled()) {
+            painter.drawPixmap(shape->rectangle().x(), shape->rectangle().y(),
+                               shape->shape());
+        }
+    }
+
+    // FIXME: A more efficient way of doing this would be to call XShapeCombineMask passing an X11
+    // pixmap created from the mask bitmap. However for some reason I wasn't able to figure out yet
+    // I get a lot of warnings when calling QBitmap::handle, so for now I'm passing a region as a
+    // workaround.
+    XShapeCombineRegion(QX11Info::display(), m_target->effectiveWinId(), ShapeInput,
+                        0, 0, QRegion(inputShape).handle(), ShapeSet);
+}
+
+Unity2DDeclarativeView* InputShapeManager::target() const
+{
+    return m_target;
+}
+
+void InputShapeManager::setTarget(Unity2DDeclarativeView *target)
+{
+    if (m_target != target) {
+        if (m_target != NULL) m_target->disconnect(this);
+
+        //TODO: de-shape the current target view, if any, before shaping the new one. not used now
+        //      as we never change the view anyway.
+
+        m_target = target;
+        if (m_target != NULL) {
+            // due to the way xshape works we need to re-apply the shaping every time the target window
+            // is mapped again.
+            connect(m_target, SIGNAL(shown()), SLOT(updateManagedShape()));
+            connect(m_target, SIGNAL(sceneResized(QSize)), SLOT(updateManagedShape()));
+        }
+        Q_EMIT targetChanged();
+        updateManagedShape();
+    }
+}
+
+QDeclarativeListProperty<InputShapeRectangle> InputShapeManager::shapes()
+{
+    return QDeclarativeListProperty<InputShapeRectangle>(this, this, &InputShapeManager::appendShape);
+}
+
+void InputShapeManager::appendShape(QDeclarativeListProperty<InputShapeRectangle> *list, InputShapeRectangle *shape)
+{
+    InputShapeManager* instance = qobject_cast<InputShapeManager*>(list->object);
+    if (instance != NULL) {
+        instance->m_shapes.append(shape);
+        instance->connect(shape, SIGNAL(shapeChanged()), SLOT(updateManagedShape()));
+        instance->connect(shape, SIGNAL(enabledChanged()), SLOT(updateManagedShape()));
+        instance->updateManagedShape();
+    }
+}
+
+#include "inputshapemanager.moc"

=== added file 'libunity-2d-private/src/inputshapemanager.h'
--- libunity-2d-private/src/inputshapemanager.h	1970-01-01 00:00:00 +0000
+++ libunity-2d-private/src/inputshapemanager.h	2012-01-20 13:41:29 +0000
@@ -0,0 +1,38 @@
+#ifndef INPUTSHAPEMANAGER_H
+#define INPUTSHAPEMANAGER_H
+
+#include <QObject>
+#include <QDeclarativeListProperty>
+
+#include "inputshaperectangle.h"
+
+class Unity2DDeclarativeView;
+
+class InputShapeManager : public QObject
+{
+    Q_OBJECT
+    Q_PROPERTY(Unity2DDeclarativeView* target READ target WRITE setTarget NOTIFY targetChanged)
+    Q_PROPERTY(QDeclarativeListProperty<InputShapeRectangle> shapes READ shapes)
+    Q_CLASSINFO("DefaultProperty", "shapes")
+
+public:
+    explicit InputShapeManager(QObject *parent = 0);
+    Unity2DDeclarativeView* target() const;
+    void setTarget(Unity2DDeclarativeView* target);
+    QDeclarativeListProperty<InputShapeRectangle> shapes();
+
+Q_SIGNALS:
+    void targetChanged();
+
+public Q_SLOTS:
+    void updateManagedShape();
+
+protected:
+    static void appendShape(QDeclarativeListProperty<InputShapeRectangle> *property, InputShapeRectangle *value);
+
+private:
+    Unity2DDeclarativeView* m_target;
+    QList<InputShapeRectangle*> m_shapes;
+};
+
+#endif // INPUTSHAPEMANAGER_H

=== added file 'libunity-2d-private/src/inputshapemask.cpp'
--- libunity-2d-private/src/inputshapemask.cpp	1970-01-01 00:00:00 +0000
+++ libunity-2d-private/src/inputshapemask.cpp	2012-01-20 13:41:29 +0000
@@ -0,0 +1,88 @@
+#include "inputshapemask.h"
+#include "config.h"
+
+#include <QBitmap>
+#include <QDebug>
+
+InputShapeMask::InputShapeMask(QObject *parent) :
+    QObject(parent),
+    m_enabled(true)
+{
+}
+
+void InputShapeMask::updateShape()
+{
+    QBitmap newShape;
+
+    if (!m_source.isEmpty() && m_color.isValid()) {
+        QPixmap image;
+        QString path = unity2dDirectory() + "/" + m_source;
+        if (image.load(path)) {
+            newShape = image.createMaskFromColor(m_color.rgb(), Qt::MaskInColor);
+        } else {
+            qWarning() << "Failed to load input shape mask image from" << path;
+        }
+    }
+
+    m_shape = newShape;
+    Q_EMIT shapeChanged();
+}
+
+QString InputShapeMask::source() const
+{
+    return m_source;
+}
+
+QColor InputShapeMask::color() const
+{
+    return m_color;
+}
+
+QPoint InputShapeMask::position() const
+{
+    return m_position;
+}
+
+bool InputShapeMask::enabled() const
+{
+    return m_enabled;
+}
+
+QBitmap InputShapeMask::shape() const
+{
+    return m_shape;
+}
+
+void InputShapeMask::setSource(const QString &source)
+{
+    if (m_source != source) {
+        m_source = source;
+        updateShape();
+    }
+}
+
+void InputShapeMask::setColor(const QColor &color)
+{
+    if (m_color != color) {
+        m_color = color;
+        updateShape();
+    }
+}
+
+void InputShapeMask::setPosition(const QPoint &position)
+{
+    if (m_position != position) {
+        m_position = position;
+        Q_EMIT positionChanged();
+    }
+}
+
+void InputShapeMask::setEnabled(bool enabled)
+{
+    if (m_enabled != enabled) {
+        m_enabled = enabled;
+        Q_EMIT enabledChanged();
+    }
+}
+
+#include "inputshapemask.moc"

=== added file 'libunity-2d-private/src/inputshapemask.h'
--- libunity-2d-private/src/inputshapemask.h	1970-01-01 00:00:00 +0000
+++ libunity-2d-private/src/inputshapemask.h	2012-01-20 13:41:29 +0000
@@ -0,0 +1,48 @@
+#ifndef INPUTSHAPEMASK_H
+#define INPUTSHAPEMASK_H
+
+#include <QObject>
+#include <QColor>
+#include <QPoint>
+#include <QBitmap>
+
+class InputShapeMask : public QObject
+{
+    Q_OBJECT
+    Q_PROPERTY(QString source READ source WRITE setSource)
+    Q_PROPERTY(QColor color READ color WRITE setColor)
+    Q_PROPERTY(QPoint position READ position WRITE setPosition NOTIFY positionChanged)
+    Q_PROPERTY(QBitmap shape READ shape NOTIFY shapeChanged)
+    Q_PROPERTY(bool enabled READ enabled WRITE setEnabled NOTIFY enabledChanged)
+
+public:
+    explicit InputShapeMask(QObject *parent = 0);
+
+    QString source() const;
+    QColor color() const;
+    QPoint position() const;
+    bool enabled() const;
+    QBitmap shape() const;
+
+    void setSource(const QString& source);
+    void setColor(const QColor& color);
+    void setPosition(const QPoint& position);
+    void setEnabled(bool enabled);
+
+Q_SIGNALS:
+    void enabledChanged();
+    void shapeChanged();
+    void positionChanged();
+
+protected:
+    void updateShape();
+
+private:
+    QString m_source;
+    QColor m_color;
+    QPoint m_position;
+    bool m_enabled;
+    QBitmap m_shape;
+};
+
+#endif // INPUTSHAPEMASK_H

=== added file 'libunity-2d-private/src/inputshaperectangle.cpp'
--- libunity-2d-private/src/inputshaperectangle.cpp	1970-01-01 00:00:00 +0000
+++ libunity-2d-private/src/inputshaperectangle.cpp	2012-01-20 13:41:29 +0000
@@ -0,0 +1,86 @@
+#include "inputshaperectangle.h"
+#include "inputshapemask.h"
+
+#include <QBitmap>
+#include <QPainter>
+#include <QPainterPath>
+#include <QDebug>
+#include <QRect>
+
+InputShapeRectangle::InputShapeRectangle(QObject *parent) :
+    QObject(parent),
+    m_enabled(true)
+{
+}
+
+void InputShapeRectangle::updateShape()
+{
+    QBitmap newShape(m_rectangle.width(), m_rectangle.height());
+    newShape.fill(Qt::color1);
+
+    if (!m_rectangle.isEmpty() && m_masks.count() > 0) {
+        QPainter painter(&newShape);
+        painter.setBackgroundMode(Qt::OpaqueMode);
+
+        Q_FOREACH (InputShapeMask* mask, m_masks) {
+            if (mask->enabled()) {
+                painter.drawPixmap(mask->position(), mask->shape());
+            }
+        }
+    }
+
+    m_shape = newShape;
+    Q_EMIT shapeChanged();
+}
+
+QRect InputShapeRectangle::rectangle() const
+{
+    return m_rectangle;
+}
+
+void InputShapeRectangle::setRectangle(QRect rectangle)
+{
+    if (rectangle != m_rectangle) {
+        m_rectangle = rectangle;
+        updateShape();
+        Q_EMIT rectangleChanged();
+    }
+}
+
+bool InputShapeRectangle::enabled() const
+{
+    return m_enabled;
+}
+
+void InputShapeRectangle::setEnabled(bool enabled)
+{
+    if (enabled != m_enabled) {
+        m_enabled = enabled;
+        Q_EMIT enabledChanged();
+
+    }
+}
+
+QBitmap InputShapeRectangle::shape() const
+{
+    return m_shape;
+}
+
+QDeclarativeListProperty<InputShapeMask> InputShapeRectangle::masks()
+{
+    return QDeclarativeListProperty<InputShapeMask>(this, this, &InputShapeRectangle::appendMask);
+}
+
+void InputShapeRectangle::appendMask(QDeclarativeListProperty<InputShapeMask> *list, InputShapeMask *mask)
+{
+    InputShapeRectangle* instance = qobject_cast<InputShapeRectangle*>(list->object);
+    if (instance != NULL) {
+        instance->m_masks.append(mask);
+        instance->connect(mask, SIGNAL(enabledChanged()), SLOT(updateShape()));
+        instance->connect(mask, SIGNAL(shapeChanged()), SLOT(updateShape()));
+        instance->connect(mask, SIGNAL(positionChanged()), SLOT(updateShape()));
+        instance->updateShape();
+    }
+}
+
+#include "inputshaperectangle.moc"

=== added file 'libunity-2d-private/src/inputshaperectangle.h'
--- libunity-2d-private/src/inputshaperectangle.h	1970-01-01 00:00:00 +0000
+++ libunity-2d-private/src/inputshaperectangle.h	2012-01-20 13:41:29 +0000
@@ -0,0 +1,49 @@
+#ifndef INPUTSHAPERECTANGLE_H
+#define INPUTSHAPERECTANGLE_H
+
+#include <QObject>
+#include <QRect>
+#include <QBitmap>
+#include <QDeclarativeListProperty>
+#include <QList>
+
+class InputShapeMask;
+
+class InputShapeRectangle : public QObject
+{
+    Q_OBJECT
+    Q_PROPERTY(QRect rectangle READ rectangle WRITE setRectangle NOTIFY rectangleChanged)
+    Q_PROPERTY(bool enabled READ enabled WRITE setEnabled NOTIFY enabledChanged)
+    Q_PROPERTY(QBitmap shape READ shape NOTIFY shapeChanged)
+    Q_PROPERTY(QDeclarativeListProperty<InputShapeMask> masks READ masks)
+    Q_CLASSINFO("DefaultProperty", "masks")
+
+public:
+    explicit InputShapeRectangle(QObject *parent = 0);
+
+    QRect rectangle() const;
+    void setRectangle(QRect rectangle);
+    bool enabled() const;
+    void setEnabled(bool enabled);
+    QBitmap shape() const;
+    QDeclarativeListProperty<InputShapeMask> masks();
+
+protected:
+    static void appendMask(QDeclarativeListProperty<InputShapeMask> *list, InputShapeMask *mask);
+
+protected Q_SLOTS:
+    void updateShape();
+
+Q_SIGNALS:
+    void rectangleChanged();
+    void enabledChanged();
+    void shapeChanged();
+
+private:
+    QRect m_rectangle;
+    bool m_enabled;
+    QBitmap m_shape;
+    QList<InputShapeMask*> m_masks;
+};
+
+#endif // INPUTSHAPERECTANGLE_H

=== modified file 'libunity-2d-private/src/unity2ddeclarativeview.cpp'
--- libunity-2d-private/src/unity2ddeclarativeview.cpp	2011-12-08 19:41:38 +0000
+++ libunity-2d-private/src/unity2ddeclarativeview.cpp	2012-01-20 13:41:29 +0000
@@ -21,6 +21,7 @@
 #include <QVariant>
 #include <QX11Info>
 #include <QFileInfo>
+#include <QShowEvent>
 
 #include <X11/Xlib.h>
 #include <X11/Xatom.h>
@@ -158,6 +159,11 @@
     Q_EMIT globalPositionChanged(globalPosition());
 }
 
+void Unity2DDeclarativeView::showEvent(QShowEvent *event)
+{
+    Q_EMIT shown();
+}
+
 
 /* Obtaining & Discarding Keyboard Focus for Window on Demand
  *

=== modified file 'libunity-2d-private/src/unity2ddeclarativeview.h'
--- libunity-2d-private/src/unity2ddeclarativeview.h	2011-12-08 19:41:38 +0000
+++ libunity-2d-private/src/unity2ddeclarativeview.h	2012-01-20 13:41:29 +0000
@@ -44,10 +44,12 @@
     void useOpenGLChanged(bool);
     void transparentBackgroundChanged(bool);
     void globalPositionChanged(QPoint);
+    void shown();
 
 protected:
     void setupViewport();
     virtual void moveEvent(QMoveEvent* event);
+    virtual void showEvent(QShowEvent *event);
 
 protected Q_SLOTS:
     void forceActivateWindow();

=== modified file 'shell/MERGE-TODO'
--- shell/MERGE-TODO	2012-01-10 16:41:53 +0000
+++ shell/MERGE-TODO	2012-01-20 13:41:29 +0000
@@ -3,8 +3,6 @@
 
 = High =
 
-* Shell window should be input-shaped so that the part that belongs to neither dash nor launcher does not receive input
-  - This should also work correctly with the dash bottom-right corner which is already input shaped.
 * The panel now has window buttons to close, minimize, maximize the dash. Make these work with the shell and remove the
   bottom-right maximize button we have now.
 * Add back this Launcher feature: when alt+f1 is pressed and launcher already has focus, the shell window should be deactivated

=== modified file 'shell/Shell.qml'
--- shell/Shell.qml	2012-01-17 11:25:08 +0000
+++ shell/Shell.qml	2012-01-20 13:41:29 +0000
@@ -23,7 +23,7 @@
 Item {
     id: shell
     height: screen.availableGeometry.height
-    width: shell.childrenRect.width
+    width: screen.availableGeometry.width
 
     Accessible.name: "shell"
 
@@ -114,4 +114,30 @@
             declarativeView.forceDeactivateWindow()
         }
     }
+
+    InputShapeManager {
+        target: declarativeView
+
+        InputShapeRectangle {
+            // Prevent the launcher mask to ever go to negative values or be less than 1 pixel
+            // (to preserve the autohide/intellihide edge detection)
+            rectangle: Qt.rect(0, launcherLoader.y,
+                               launcherLoader.visibilityController.shown ? launcherLoader.width : 1,
+                               launcherLoader.height)
+            enabled: launcherLoader.status == Loader.Ready
+        }
+
+        InputShapeRectangle {
+            rectangle: Qt.rect(dashLoader.x, dashLoader.y, dashLoader.width, dashLoader.height)
+            enabled: dashLoader.status == Loader.Ready && dashLoader.item.active
+
+            InputShapeMask {
+                id: shape1
+                source: "shell/dash/artwork/desktop_dash_background_no_transparency.png"
+                color: "red"
+                position: Qt.point(dashLoader.width - 50, dashLoader.height - 49)
+                enabled: declarativeView.dashMode == ShellDeclarativeView.DesktopMode
+            }
+        }
+    }
 }

=== modified file 'shell/app/shelldeclarativeview.cpp'
--- shell/app/shelldeclarativeview.cpp	2012-01-17 13:59:13 +0000
+++ shell/app/shelldeclarativeview.cpp	2012-01-20 13:41:29 +0000
@@ -166,7 +166,7 @@
 void
 ShellDeclarativeView::showEvent(QShowEvent *event)
 {
-    QDeclarativeView::showEvent(event);
+    Unity2DDeclarativeView::showEvent(event);
     /* Note that this has to be called everytime the window is shown, as the WM
        will remove the flags when the window is hidden */
     setWMFlags();
@@ -254,51 +254,6 @@
 }
 
 void
-ShellDeclarativeView::resizeEvent(QResizeEvent* event)
-{
-    if (!QX11Info::isCompositingManagerRunning()) {
-        updateMask();
-    }
-    QDeclarativeView::resizeEvent(event);
-}
-
-static QBitmap
-createCornerMask()
-{
-    QPixmap pix(unity2dDirectory() + "/shell/dash/artwork/desktop_dash_background_no_transparency.png");
-    return pix.createMaskFromColor(Qt::red, Qt::MaskOutColor);
-}
-
-void
-ShellDeclarativeView::updateMask()
-{
-    if (m_mode == FullScreenMode) {
-        clearMask();
-        return;
-    }
-    QBitmap bmp(size());
-    {
-        static QBitmap corner = createCornerMask();
-        static QBitmap top = corner.copy(0, 0, corner.width(), 1);
-        static QBitmap left = corner.copy(0, 0, 1, corner.height());
-
-        const int cornerX = bmp.width() - corner.width();
-        const int cornerY = bmp.height() - corner.height();
-
-        QPainter painter(&bmp);
-        painter.fillRect(bmp.rect(), Qt::color1);
-        painter.setBackgroundMode(Qt::OpaqueMode);
-        painter.setBackground(Qt::color1);
-        painter.setPen(Qt::color0);
-        painter.drawPixmap(cornerX, cornerY, corner);
-
-        painter.drawTiledPixmap(cornerX, 0, top.width(), cornerY, top);
-        painter.drawTiledPixmap(0, cornerY, cornerX, left.height(), left);
-    }
-    setMask(bmp);
-}
-
-void
 ShellDeclarativeView::toggleDash()
 {
     if (dashActive()) {

=== modified file 'shell/app/shelldeclarativeview.h'
--- shell/app/shelldeclarativeview.h	2011-12-21 18:42:06 +0000
+++ shell/app/shelldeclarativeview.h	2012-01-20 13:41:29 +0000
@@ -104,7 +104,6 @@
     void onAltF1Pressed();
 
 protected:
-    void resizeEvent(QResizeEvent*);
     virtual void showEvent(QShowEvent *event);
     virtual void mouseMoveEvent(QMouseEvent *event);
     virtual void leaveEvent(QEvent *event);
@@ -118,6 +117,7 @@
     void updateMask();
     void setWMFlags();
     bool isSpreadActive();
+    void updateInputShape();
 
     DashMode m_mode;
     bool m_expanded;

=== modified file 'shell/dash/Home.qml'
--- shell/dash/Home.qml	2012-01-10 10:42:46 +0000
+++ shell/dash/Home.qml	2012-01-20 13:41:29 +0000
@@ -155,6 +155,7 @@
 
         AbstractButton {
             id: closeShortcutsButton
+            objectName: "closeShortcutsButton"
 
             anchors.left: parent.left
             anchors.top: parent.top

=== added directory 'tests/getshape'
=== added file 'tests/getshape/CMakeLists.txt'
--- tests/getshape/CMakeLists.txt	1970-01-01 00:00:00 +0000
+++ tests/getshape/CMakeLists.txt	2012-01-20 13:41:29 +0000
@@ -0,0 +1,22 @@
+# Sources
+set(shell_SRCS
+    getshape.cpp
+    )
+
+qt4_wrap_cpp(shell_MOC_SRCS ${shell_MOC_HDRS})
+
+# Build
+
+add_executable(getshape ${shell_SRCS} ${shell_MOC_SRCS})
+
+include_directories(
+    ${CMAKE_CURRENT_SOURCE_DIR}
+    ${CMAKE_CURRENT_BINARY_DIR}
+    )
+
+target_link_libraries(getshape
+    ${QT_QTCORE_LIBRARIES}
+    ${QT_QTGUI_LIBRARIES}
+    ${X11_Xext_LIB}
+    ${X11_X11_LIB}
+    )

=== added file 'tests/getshape/getshape.cpp'
--- tests/getshape/getshape.cpp	1970-01-01 00:00:00 +0000
+++ tests/getshape/getshape.cpp	2012-01-20 13:41:29 +0000
@@ -0,0 +1,102 @@
+/*
+ * Copyright (C) 2010 Canonical, Ltd.
+ *
+ * Authors:
+ *  Florian Boucault <[e-mail]>
+ *  Ugo Riboni <[e-mail]>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 3.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+// QT
+#include <QApplication>
+#include <QX11Info>
+#include <QDebug>
+#include <QStringList>
+
+#include <QBitmap>
+#include <QRegion>
+#include <QPainter>
+#include <QPainterPath>
+
+// X11
+#include <X11/Xlib.h>
+#include <X11/extensions/shape.h>
+
+void printUsage()
+{
+    qDebug() << "ARGUMENTS: window_id [output_file]";
+}
+
+int handle_x11_errors(Display *display, XErrorEvent *theEvent)
+{
+    qWarning() << "Failed to call X11 function XShapeGetRectangles.";
+    qWarning() << "The window ID that was passed to it was probably not valid anymore.";
+    qWarning() << "X error code:" << theEvent->error_code;
+    qWarning() << "X Request code" << theEvent->request_code;
+    exit(4);
+}
+
+int main(int argc, char *argv[])
+{
+    QApplication application(argc, argv);
+    QStringList arguments = application.arguments();
+
+    if (arguments.length() < 2) {
+        printUsage();
+        return 1;
+    }
+
+    bool ok;
+    Window windowId = arguments.at(1).toLongLong(&ok, 0);
+    if (!ok) {
+        qWarning() << "Window ID is not a valid integer:" << arguments.at(1);
+        return 2;
+    }
+
+    QString outputFile;
+    if (arguments.length() > 2) {
+        outputFile = arguments.at(2);
+    }
+
+    XErrorHandler old_handler = XSetErrorHandler(handle_x11_errors);
+
+    QRegion region;
+    int count, ordering;
+    XRectangle *rects = XShapeGetRectangles(QX11Info::display(), windowId,
+                                            ShapeInput, &count, &ordering);
+    XSync(QX11Info::display(), False);
+    XSetErrorHandler(old_handler);
+
+    for (int i = 0; i < count; i++) {
+        region = region.united(QRect(rects[i].x, rects[i].y, rects[i].width, rects[i].height));
+
+        printf("%dx%d@%d,%d", rects[i].width, rects[i].height, rects[i].x, rects[i].y);
+    }
+
+    if (!outputFile.isEmpty()) {
+        QBitmap bitmap(region.boundingRect().width(), region.boundingRect().height());
+        bitmap.fill(Qt::color0);
+        QPainter painter(&bitmap);
+        QPainterPath path;
+        path.addRegion(region);
+        painter.fillPath(path, Qt::color1);
+        painter.end();
+        if (!bitmap.save(outputFile)) {
+            qWarning() << "Failed to save file with path:" << outputFile;
+            return 3;
+        }
+    }
+
+    return 0;
+}

=== modified file 'tests/run-tests.rb'
--- tests/run-tests.rb	2012-01-18 12:18:20 +0000
+++ tests/run-tests.rb	2012-01-20 13:41:29 +0000
@@ -62,7 +62,7 @@
 require 'testhelper'
 
 # List of directories in which to search for test cases
-test_directories = ['launcher', 'panel', 'places', 'spread', 'window-manager', 'other']
+test_directories = ['launcher', 'panel', 'places', 'spread', 'shell', 'window-manager', 'other']
 
 # Only run scan for tests if this script is directly called
 if __FILE__ == $0

=== added directory 'tests/shell'
=== added file 'tests/shell/input_shaping.rb'
--- tests/shell/input_shaping.rb	1970-01-01 00:00:00 +0000
+++ tests/shell/input_shaping.rb	2012-01-20 13:41:29 +0000
@@ -0,0 +1,239 @@
+#!/usr/bin/env ruby1.8
+=begin
+/*
+ * This file is part of unity-2d
+ *
+ * Copyright 2011 Canonical Ltd.
+ *
+ * Authors:
+ * - Ugo Riboni <[e-mail]>
+ * - Gerry Boland <[e-mail]>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 3.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+=end
+
+require '../run-tests.rb' unless $INIT_COMPLETED
+require 'xdo/xwindow'
+require 'xdo/keyboard'
+require 'xdo/mouse'
+require 'timeout'
+require 'tmpdir'
+require 'tempfile'
+include TDriverVerify
+
+def desktop_geometry
+    out = %x{xdotool getdisplaygeometry}
+    return out.split.collect { |coord| coord.to_i }
+end
+
+# We just need a temp file name but ruby insist on creating it, so we just delete it first.
+def tempfilename(base, extension = ".tmp")
+    maskfile = Tempfile.new([base, extension])
+    maskpath = maskfile.path
+    maskfile.close
+    maskfile.unlink
+    return maskpath
+end
+
+def get_shell_shape
+    pwd = File.expand_path(File.dirname(__FILE__))
+
+    # Try to find the shell window
+    shell_ids = XDo::XWindow::search('unity-2d-shell')
+    assert(!shell_ids.empty?, "Failed to retrieve the shell window id")
+    shell_id = shell_ids[0]
+
+    # Get the shape of the shell window using our custom tool
+    maskpath = tempfilename('shape', '.png')
+    out = %x{#{pwd}/../getshape/getshape #{shell_id} #{maskpath}}
+    assert($?.exitstatus == 0, "Failed to call getshape to get the shape of the window")
+    return maskpath
+end
+
+# Compare two images using ImageMagick. Perform a pixel-by-pixel comparison and return true
+# only if all the pixels are identical.
+def compare_images(image1, image2)
+    # Before checking the pixels make sure the two images are the same size, otherwise some times
+    # IM will hang for a long time (probably trying to do some super clever subimage matching).
+    size1 = %x{identify -format '%wx%h' #{image1}}
+    size2 = %x{identify -format '%wx%h' #{image2}}
+    return false if size1 != size2
+
+    # Discard the difference image and redirect stderr to stdout as IM will output the number of
+    # different pixels there for some reason.
+    difference = %x{compare #{image1} #{image2} -metric AE /dev/null 2>&1}.chop.to_i
+
+    # If the images are too different or have different sizes IM will exit with return code 1.
+    # Unfortunately it's the same code we have when there is any error (like a wrong filename),
+    # so the best we can do is just return false
+    return false if $?.exitstatus != 0
+
+    return difference == 0
+end
+
+############################# Test Suite #############################
+context "Shell input shape tests" do
+  pwd = File.expand_path(File.dirname(__FILE__)) + '/'
+
+  PANEL_HEIGHT = 24
+  LAUNCHER_WIDTH = 65
+
+  # Run once at the beginning of this test suite
+  startup do
+    system 'killall unity-2d-shell > /dev/null 2>&1'
+    system 'killall unity-2d-shell > /dev/null 2>&1'
+    system 'killall unity-2d-panel > /dev/null 2>&1'
+
+    # Need panel running as position of shell depends on it
+    @@sut = TDriver.sut(:Id => "sut_qt")
+    @@panel = @@sut.run(:name => UNITY_2D_PANEL,
+                        :arguments => "-testability" )
+
+    # Minimize all windows
+    XDo::XWindow.toggle_minimize_all
+  end
+  
+  # Run once at the end of this test suite
+  shutdown do
+  end
+
+  # Run before each test case begins
+  setup do
+    #Ensure mouse out of the way
+    XDo::Mouse.move(200,200,10,true)    
+
+    # Execute the application 
+    @sut = TDriver.sut(:Id => "sut_qt")    
+    @app = @sut.run(:name => UNITY_2D_SHELL,
+                    :arguments => "-testability",
+                    :sleeptime => 2)
+    # Make certain application is ready for testing
+    verify(10){ @app.Launcher() }
+  end
+
+  # Run after each test case completes
+  teardown do
+    system "pkill -nf unity-2d-shell"
+  end
+
+  #####################################################################################
+  # Test cases
+
+  test "Shape of launcher alone" do
+    XDo::Keyboard.alt_F1
+    maskpath = get_shell_shape()
+
+    # Since the shape of the launcher is dependent on screen geometry, calculate what it should be
+    # then use imagemagick to create an image that contains only a black rectangle where the
+    # launcher should be.
+    screen_width, screen_height = desktop_geometry()
+    screen_height -= PANEL_HEIGHT
+    comparepath = tempfilename('shape', '.png')
+    %x{convert xc:black -background black -extent #{LAUNCHER_WIDTH}x#{screen_height} #{comparepath}}
+
+    identical = compare_images(maskpath, comparepath)
+
+    File.unlink(maskpath)
+    File.unlink(comparepath)
+
+    verify_true(10, "The actual shape does not match the expected shape") { identical }
+  end
+
+  test "Shape of launcher and desktop mode dash" do
+    XDo::Keyboard.simulate('{SUPER}')
+    sleep 1
+    maskpath = get_shell_shape()
+
+    # Since the shape of the launcher is dependent on screen geometry, calculate what it should be,
+    # then draw a black rectangle and compose it at the left side of the dash verification image.
+
+    screen_width, screen_height = desktop_geometry()
+    screen_height -= PANEL_HEIGHT
+
+    verifypath = "#{pwd}/verification/dash_desktop.png"
+    out = %x{identify -format "%wx%h" #{verifypath}}
+    verify_width = out.split("x")[0].to_i
+    verify_width += LAUNCHER_WIDTH
+
+    comparepath = tempfilename('shape', '.png')
+
+    %x{convert #{verifypath} \
+       -gravity northeast -extent #{verify_width}x#{screen_height}! \
+       \\( xc:black -background black -extent #{LAUNCHER_WIDTH}x#{screen_height} \\) \
+       -gravity northwest -compose over -composite #{comparepath}}
+
+    identical = compare_images(maskpath, comparepath)
+
+    File.unlink(maskpath)
+    File.unlink(comparepath)
+
+    verify_true(10, "The actual shape does not match the expected shape") { identical }
+  end
+
+  test "Shape of launcher and fullscreen mode dash" do
+    XDo::Keyboard.simulate('{SUPER}')
+    sleep 1
+    @app.ShellDeclarativeView()['dashMode'] = 'FullScreenMode'
+    sleep 1
+
+    maskpath = get_shell_shape()
+
+    # Compare with just one big rectangle filling the entire screen minus the panel area
+    screen_width, screen_height = desktop_geometry()
+    screen_height -= PANEL_HEIGHT
+    comparepath = tempfilename('shape', '.png')
+    %x{convert xc:black -background black -extent #{screen_width}x#{screen_height} #{comparepath}}
+
+    identical = compare_images(maskpath, comparepath)
+
+    File.unlink(maskpath)
+    File.unlink(comparepath)
+
+    verify_true(10, "The actual shape does not match the expected shape") { identical }
+  end
+
+  test "Shape of launcher and collapsed desktop mode dash" do
+    XDo::Keyboard.simulate('{SUPER}')
+    sleep 1
+    @app.AbstractButton(:name => 'closeShortcutsButton').tap
+    sleep 1
+
+    maskpath = get_shell_shape()
+
+    # Since the shape of the launcher is dependent on screen geometry, calculate what it should be,
+    # then draw a black rectangle and compose it at the left side of the dash verification image.
+
+    screen_width, screen_height = desktop_geometry()
+    screen_height -= PANEL_HEIGHT
+
+    verifypath = "#{pwd}/verification/dash_collapsed.png"
+    out = %x{identify -format "%wx%h" #{verifypath}}
+    verify_width = out.split("x")[0].to_i
+    verify_width += LAUNCHER_WIDTH
+
+    comparepath = tempfilename('shape', '.png')
+
+    %x{convert #{verifypath} \
+       -gravity northeast -extent #{verify_width}x#{screen_height}! \
+       \\( xc:black -background black -extent #{LAUNCHER_WIDTH}x#{screen_height} \\) \
+       -gravity northwest -compose over -composite #{comparepath}}
+
+    identical = compare_images(maskpath, comparepath)
+
+    File.unlink(maskpath)
+    File.unlink(comparepath)
+
+    verify_true(10, "The actual shape does not match the expected shape") { identical }
+  end
+end

=== added directory 'tests/shell/verification'
=== added file 'tests/shell/verification/dash_collapsed.png'
Binary files tests/shell/verification/dash_collapsed.png	1970-01-01 00:00:00 +0000 and tests/shell/verification/dash_collapsed.png	2012-01-20 13:41:29 +0000 differ
=== added file 'tests/shell/verification/dash_desktop.png'
Binary files tests/shell/verification/dash_desktop.png	1970-01-01 00:00:00 +0000 and tests/shell/verification/dash_desktop.png	2012-01-20 13:41:29 +0000 differ