Merge lp:~dyams/unity-2d/mm-updates-pips into lp:unity-2d

[Lohith D Shivamurthy]

[shell][Multimonitor] update pips to show whether application belongs to current screen or not

[lp:~dyams/unity-2d/mm-updates-pips]

922. By Lohith D Shivamurthy on 2012-02-20

fix comments

Unmerged revisions

922. By Lohith D Shivamurthy on 2012-02-20

fix comments

921. By Lohith D Shivamurthy on 2012-02-16

[shell] update pips to show whether application belongs to current screen or not

=== modified file 'libunity-2d-private/src/launcherapplication.cpp'
--- libunity-2d-private/src/launcherapplication.cpp	2012-02-06 12:07:47 +0000
+++ libunity-2d-private/src/launcherapplication.cpp	2012-02-16 08:16:20 +0000
@@ -43,6 +43,7 @@
 // libunity-2d
 #include <unity2dtr.h>
 #include <debug_p.h>
+#include <screeninfo.h>
 
 // Qt
 #include <Qt>
@@ -62,6 +63,14 @@
 #include <libsn/sn.h>
 }
 
+#define GOBJECT_CALLBACK0(callbackName, slot) \
+static void \
+callbackName(GObject* src, QObject* dst) \
+{ \
+    QMetaObject::invokeMethod(dst, slot); \
+}
+GOBJECT_CALLBACK0(geometryChangedCB, "onWindowGeometryChanged")
+
 const char* SHORTCUT_NICK_PROPERTY = "nick";
 
 LauncherApplication::LauncherApplication()
@@ -91,6 +100,7 @@
 
 LauncherApplication::~LauncherApplication()
 {
+    disconnectWindowSignals();
 }
 
 bool
@@ -526,6 +536,29 @@
         WnckWindow* window = wnck_window_get(xids->at(i));
         g_signal_connect(G_OBJECT(window), "workspace-changed",
             G_CALLBACK(LauncherApplication::onWindowWorkspaceChanged), this);
+        g_signal_connect(G_OBJECT(window), "geometry-changed", G_CALLBACK(geometryChangedCB), this);
+    }
+}
+
+void
+LauncherApplication::disconnectWindowSignals()
+{
+    if (m_application == NULL || m_application->running() == false) {
+        return;
+    }
+
+    QScopedPointer<BamfUintList> xids(m_application->xids());
+    int size = xids->size();
+    if (size < 1) {
+        return;
+    }
+
+    WnckScreen* screen = wnck_screen_get_default();
+    wnck_screen_force_update(screen);
+
+    for (int i = 0; i < size; ++i) {
+        WnckWindow* window = wnck_window_get(xids->at(i));
+        g_signal_handlers_disconnect_by_func(window, gpointer(geometryChangedCB), this);
     }
 }
 
@@ -537,6 +570,7 @@
         WnckWindow* wnck_window = wnck_window_get(window->xid());
         g_signal_connect(G_OBJECT(wnck_window), "workspace-changed",
              G_CALLBACK(LauncherApplication::onWindowWorkspaceChanged), this);
+        g_signal_connect(G_OBJECT(window), "geometry-changed", G_CALLBACK(geometryChangedCB), this);
     }
 }
 
@@ -665,6 +699,42 @@
     return windowCount;
 }
 
+int
+LauncherApplication::windowCountOnCurrentScreen(int screen)
+{
+    int windowCount = 0;
+
+    if (!m_application) {
+        return windowCount;
+    }
+
+    ScreenInfo screenInfo(screen);
+    QScopedPointer<BamfUintList> xids(m_application->xids());
+    for (int i = 0; i < xids->size(); i++) {
+        /* When geting the wnck window, it's possible we get a NULL
+           return value because wnck hasn't updated its internal list yet,
+           so we need to force it once to be sure */
+        WnckWindow *window = wnck_window_get(xids->at(i));
+        if (window == NULL) {
+            wnck_screen_force_update(wnck_screen_get_default());
+            window = wnck_window_get(xids->at(i));
+            if (window == NULL) {
+                continue;
+            }
+        }
+
+        // Check the window screen
+        int x, y, width, height;
+        wnck_window_get_geometry(window, &x, &y, &width, &height);
+        QRect windowRect(x, y, width, height);
+        QPoint pos = windowRect.center();
+        if (ScreenInfo::screenNumber(pos) == screen) {
+            windowCount++;
+        }
+    }
+    return windowCount;
+}
+
 void
 LauncherApplication::activate()
 {
@@ -986,6 +1056,18 @@
     return false;
 }
 
+bool
+LauncherApplication::belongsToDifferentScreen(int screen)
+{
+    int totalWindows = windowCount();
+    int windowsInCurrentScreen = windowCountOnCurrentScreen(screen);
+    if (totalWindows > 0 && windowsInCurrentScreen == 0) {
+        return true;
+    }
+
+    return false;
+}
+
 void
 LauncherApplication::onIndicatorMenuUpdated()
 {
@@ -1110,6 +1192,12 @@
 }
 
 void
+LauncherApplication::onWindowGeometryChanged()
+{
+    windowGeometryChanged();
+}
+
+void
 LauncherApplication::onDragEnter(DeclarativeDragDropEvent* event)
 {
     QList<QUrl> urls = validateUrisForLaunch(event->mimeData());

=== modified file 'libunity-2d-private/src/launcherapplication.h'
--- libunity-2d-private/src/launcherapplication.h	2012-02-06 12:07:47 +0000
+++ libunity-2d-private/src/launcherapplication.h	2012-02-16 08:16:20 +0000
@@ -105,7 +105,9 @@
 
     Q_INVOKABLE virtual void createMenuActions();
     Q_INVOKABLE virtual bool belongsToDifferentWorkspace();
+    Q_INVOKABLE virtual bool belongsToDifferentScreen(int screen);
     Q_INVOKABLE void connectWindowSignals();
+    void disconnectWindowSignals();
 
     void updateOverlaysState(const QString& sender, const QMap<QString, QVariant>& properties);
 
@@ -151,6 +153,8 @@
     void onDragEnter(DeclarativeDragDropEvent*);
     void onDrop(DeclarativeDragDropEvent*);
 
+    void onWindowGeometryChanged();
+
 private:
     QPointer<BamfApplication> m_application;
     QFileSystemWatcher *m_desktopFileWatcher;
@@ -175,6 +179,7 @@
     void createDynamicMenuActions();
     void createStaticMenuActions();
     int windowCountOnCurrentWorkspace();
+    int windowCountOnCurrentScreen(int);
     template<typename T>
     bool updateOverlayState(const QMap<QString, QVariant>& properties,
                             const QString& propertyName, T* member);

=== modified file 'libunity-2d-private/src/launcheritem.cpp'
--- libunity-2d-private/src/launcheritem.cpp	2012-02-06 12:07:47 +0000
+++ libunity-2d-private/src/launcheritem.cpp	2012-02-16 08:16:20 +0000
@@ -93,6 +93,12 @@
 }
 
 bool
+LauncherItem::belongsToDifferentScreen(int)
+{
+    return false;
+}
+
+bool
 LauncherItem::progressBarVisible() const
 {
     return false;

=== modified file 'libunity-2d-private/src/launcheritem.h'
--- libunity-2d-private/src/launcheritem.h	2012-02-06 12:07:47 +0000
+++ libunity-2d-private/src/launcheritem.h	2012-02-16 08:16:20 +0000
@@ -80,6 +80,7 @@
     Q_INVOKABLE virtual void createMenuActions() = 0;
     Q_INVOKABLE virtual void launchNewInstance();
     Q_INVOKABLE virtual bool belongsToDifferentWorkspace();
+    Q_INVOKABLE virtual bool belongsToDifferentScreen(int);
 
 protected:
     LauncherContextualMenu* m_menu;
@@ -102,6 +103,7 @@
     void emblemVisibleChanged(bool);
     void emblemChanged(QString);
     void windowWorkspaceChanged();
+    void windowGeometryChanged();
 
 public Q_SLOTS:
     /* Default implementation of drag’n’drop handling, should be overridden in

=== modified file 'libunity-2d-private/src/screeninfo.cpp'
--- libunity-2d-private/src/screeninfo.cpp	2012-02-01 16:28:13 +0000
+++ libunity-2d-private/src/screeninfo.cpp	2012-02-16 08:16:20 +0000
@@ -198,6 +198,21 @@
     return m_corner;
 }
 
+int
+ScreenInfo::cursorScreen()
+{
+    QDesktopWidget* desktop = QApplication::desktop();
+    QPoint cursorPos(QCursor::pos());
+    return desktop->screenNumber(cursorPos);
+}
+
+int
+ScreenInfo::screenNumber(QPoint point)
+{
+    QDesktopWidget* desktop = QApplication::desktop();
+    return desktop->screenNumber(point);
+}
+
 void
 ScreenInfo::setCorner(Corner corner)
 {

=== modified file 'libunity-2d-private/src/screeninfo.h'
--- libunity-2d-private/src/screeninfo.h	2012-02-01 15:01:21 +0000
+++ libunity-2d-private/src/screeninfo.h	2012-02-16 08:16:20 +0000
@@ -39,6 +39,8 @@
     int screen() const;
     QWidget* widget() const;
     Corner corner() const;
+    static int cursorScreen();
+    static int screenNumber(QPoint);
 
     /* Setters */
     void setScreen(int screen);

=== modified file 'shell/Shell.qml'
--- shell/Shell.qml	2012-02-13 09:15:03 +0000
+++ shell/Shell.qml	2012-02-16 08:16:20 +0000
@@ -106,7 +106,11 @@
 
     Loader {
         id: dashLoader
-        source: "dash/Dash.qml"
+        /* TODO : In case of multi-monitors, there should be only one dash,
+           which could be moved to any screen.
+           ATM, we are displaying dash for the leftmost screen only. other screens will not support dash yet.
+        */
+        source: (declarativeView.isTopLeftShell ? "dash/Dash.qml" : "")
         anchors.top: parent.top
         x: Utils.isLeftToRight() ? launcherLoader.width : shell.width - width - launcherLoader.width
         onLoaded: item.focus = true

=== modified file 'shell/app/CMakeLists.txt'
--- shell/app/CMakeLists.txt	2012-02-13 23:46:04 +0000
+++ shell/app/CMakeLists.txt	2012-02-16 08:16:20 +0000
@@ -8,12 +8,14 @@
     dashdbus.cpp
     launcherdbus.cpp
     shelldeclarativeview.cpp
+    shellmanager.cpp
     )
 
 set(shell_MOC_HDRS
     dashdbus.h
     launcherdbus.h
     shelldeclarativeview.h
+    shellmanager.h
     )
 
 qt4_wrap_cpp(shell_MOC_SRCS ${shell_MOC_HDRS})

=== modified file 'shell/app/shell.cpp'
--- shell/app/shell.cpp	2012-02-13 23:46:04 +0000
+++ shell/app/shell.cpp	2012-02-16 08:16:20 +0000
@@ -21,30 +21,16 @@
 // QT
 #include <QApplication>
 #include <QDebug>
-#include <QtDeclarative>
-#include <QDeclarativeEngine>
-#include <QDeclarativeView>
-#include <QDesktopWidget>
-#include <QDBusConnection>
-#include <QDBusConnectionInterface>
-#include <QDeclarativeContext>
-#include <QAbstractEventDispatcher>
 #include <QDir>
-
-// X11
-#include <X11/Xlib.h>
+#include <QUrl>
 
 // unity-2d
 #include <gnomesessionclient.h>
 #include <unity2dapplication.h>
-#include <unity2ddebug.h>
 
 // Local
 #include "config.h"
-#include "shelldeclarativeview.h"
-#include "dashclient.h"
-#include "dashdbus.h"
-#include "launcherdbus.h"
+#include "shellmanager.h"
 
 int main(int argc, char *argv[])
 {
@@ -71,32 +57,7 @@
     GnomeSessionClient client(INSTALL_PREFIX "/share/applications/unity-2d-shell.desktop");
     client.connectToSessionManager();
 
-    qmlRegisterType<ShellDeclarativeView>("Unity2d", 1, 0, "ShellDeclarativeView");
-    ShellDeclarativeView view;
-    view.setAccessibleName("Shell");
-    if (arguments.contains("-opengl")) {
-        view.setUseOpenGL(true);
-    }
-
-    application.installX11EventFilter(&view);
-
-    view.engine()->addImportPath(unity2dImportPath());
-    view.engine()->setBaseUrl(QUrl::fromLocalFile(unity2dDirectory() + "/shell/"));
-
-    /* Load the QML UI, focus and show the window */
-    view.setResizeMode(QDeclarativeView::SizeViewToRootObject);
-    view.rootContext()->setContextProperty("declarativeView", &view);
-    // WARNING This declaration of dashClient used to be in Unity2d/plugin.cpp
-    // but it lead to locks when both the shell and the spread were started
-    // at the same time since SpreadMonitor QDBusServiceWatcher::serviceRegistered
-    // and DashClient QDBusServiceWatcher::serviceRegistered
-    // triggered at the same time ending up with both creating QDBusInterface
-    // to eachother in the main thread meaning they would block
-    // In case you need to have a DashClient in the spread the fix for the problem
-    // is moving the QDbusInterface creation to a thread so it does not block
-    // the main thread
-    view.rootContext()->setContextProperty("dashClient", DashClient::instance());
-    view.setSource(rootFileUrl);
+    ShellManager shells(rootFileUrl);
 
     /* Unset DESKTOP_AUTOSTART_ID in order to avoid child processes (launched
        applications) to use the same client id.
@@ -113,14 +74,5 @@
        (see e.g. https://bugs.launchpad.net/bugs/684471). */
     QDir::setCurrent(QDir::homePath());
 
-    DashDBus dashDBus(&view);
-    if (!dashDBus.connectToBus()) {
-        qCritical() << "Another instance of the Dash already exists. Quitting.";
-        return -1;
-    }
-
-    LauncherDBus launcherDBus(&view);
-    launcherDBus.connectToBus();
-
     return application.exec();
 }

=== modified file 'shell/app/shelldeclarativeview.cpp'
--- shell/app/shelldeclarativeview.cpp	2012-02-13 23:46:04 +0000
+++ shell/app/shelldeclarativeview.cpp	2012-02-16 08:16:20 +0000
@@ -22,11 +22,6 @@
 // libunity-2d-private
 #include <debug_p.h>
 #include <hotkey.h>
-#include <hotkeymonitor.h>
-#include <keyboardmodifiersmonitor.h>
-#include <keymonitor.h>
-#include <dashclient.h>
-#include <launcherclient.h>
 #include <screeninfo.h>
 #include <strutmanager.h>
 
@@ -47,46 +42,20 @@
 #include <X11/Xlib.h>
 #include <X11/Xatom.h>
 
-static const int KEY_HOLD_THRESHOLD = 250;
-
 static const char* COMMANDS_LENS_ID = "commands.lens";
 
-ShellDeclarativeView::ShellDeclarativeView()
+ShellDeclarativeView::ShellDeclarativeView(const QUrl &sourceFileUrl, bool isTopLeftShell, int screen)
     : Unity2DDeclarativeView()
     , m_mode(DesktopMode)
     , m_expanded(true)
     , m_active(false)
-    , m_superKeyPressed(false)
-    , m_superKeyHeld(false)
+    , m_isTopLeftShell(isTopLeftShell)
+    , m_sourceFileUrl(sourceFileUrl)
 {
     setAttribute(Qt::WA_X11NetWmWindowTypeDock, true);
     setTransparentBackground(QX11Info::isCompositingManagerRunning());
 
-    m_screenInfo = new ScreenInfo(ScreenInfo::TopLeft, this);
-
-    m_superKeyHoldTimer.setSingleShot(true);
-    m_superKeyHoldTimer.setInterval(KEY_HOLD_THRESHOLD);
-    connect(&m_superKeyHoldTimer, SIGNAL(timeout()), SLOT(updateSuperKeyHoldState()));
-    connect(this, SIGNAL(superKeyTapped()), SLOT(toggleDash()));
-
-    connect(&launcher2dConfiguration(), SIGNAL(superKeyEnableChanged(bool)), SLOT(updateSuperKeyMonitoring()));
-    updateSuperKeyMonitoring();
-
-    /* Alt+F1 reveal the launcher and gives the keyboard focus to the Dash Button. */
-    Hotkey* altF1 = HotkeyMonitor::instance().getHotkeyFor(Qt::Key_F1, Qt::AltModifier);
-    connect(altF1, SIGNAL(pressed()), SLOT(onAltF1Pressed()));
-
-    /* Alt+F2 shows the dash with the commands lens activated. */
-    Hotkey* altF2 = HotkeyMonitor::instance().getHotkeyFor(Qt::Key_F2, Qt::AltModifier);
-    connect(altF2, SIGNAL(pressed()), SLOT(showCommandsLens()));
-
-    /* Super+{n} for 0 ≤ n ≤ 9 activates the item with index (n + 9) % 10. */
-    for (Qt::Key key = Qt::Key_0; key <= Qt::Key_9; key = (Qt::Key) (key + 1)) {
-        Hotkey* hotkey = HotkeyMonitor::instance().getHotkeyFor(key, Qt::MetaModifier);
-        connect(hotkey, SIGNAL(pressed()), SLOT(forwardNumericHotkey()));
-        hotkey = HotkeyMonitor::instance().getHotkeyFor(key, Qt::MetaModifier | Qt::ShiftModifier);
-        connect(hotkey, SIGNAL(pressed()), SLOT(forwardNumericHotkey()));
-    }
+    m_screenInfo = new ScreenInfo(screen, this);
 
     connect(m_screenInfo, SIGNAL(availableGeometryChanged(QRect)), SLOT(updateShellPosition()));
     updateShellPosition();
@@ -172,6 +141,9 @@
     /* 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();
+    if (source().isEmpty()) {
+        setSource(m_sourceFileUrl);
+    }
 }
 
 void
@@ -262,7 +234,7 @@
 }
 
 void
-ShellDeclarativeView::onAltF1Pressed()
+ShellDeclarativeView::toggleLauncher()
 {
     if (!isActiveWindow()) {
         forceActivateWindow();
@@ -279,117 +251,27 @@
     }
 }
 
-/* ----------------- super key handling ---------------- */
-
-void
-ShellDeclarativeView::updateSuperKeyHoldState()
-{
-    /* If the key was released in the meantime, just do nothing, otherwise
-       consider the key being held, unless we're told to ignore it. */
-    if (m_superKeyPressed && !m_superPressIgnored) {
-        m_superKeyHeld = true;
-        Q_EMIT superKeyHeldChanged(m_superKeyHeld);
-    }
-}
-
-void
-ShellDeclarativeView::updateSuperKeyMonitoring()
-{
-    KeyboardModifiersMonitor *modifiersMonitor = KeyboardModifiersMonitor::instance();
-    KeyMonitor *keyMonitor = KeyMonitor::instance();
-    HotkeyMonitor& hotkeyMonitor = HotkeyMonitor::instance();
-
-    QVariant value = launcher2dConfiguration().property("superKeyEnable");
-    if (!value.isValid() || value.toBool() == true) {
-        hotkeyMonitor.enableModifiers(Qt::MetaModifier);
-        QObject::connect(modifiersMonitor,
-                         SIGNAL(keyboardModifiersChanged(Qt::KeyboardModifiers)),
-                         this, SLOT(setHotkeysForModifiers(Qt::KeyboardModifiers)));
-        /* Ignore Super presses if another key was pressed simultaneously
-           (i.e. a shortcut). https://bugs.launchpad.net/unity-2d/+bug/801073 */
-        QObject::connect(keyMonitor,
-                         SIGNAL(keyPressed()),
-                         this, SLOT(ignoreSuperPress()));
-        setHotkeysForModifiers(modifiersMonitor->keyboardModifiers());
-    } else {
-        hotkeyMonitor.disableModifiers(Qt::MetaModifier);
-        QObject::disconnect(modifiersMonitor,
-                            SIGNAL(keyboardModifiersChanged(Qt::KeyboardModifiers)),
-                            this, SLOT(setHotkeysForModifiers(Qt::KeyboardModifiers)));
-        QObject::disconnect(keyMonitor,
-                            SIGNAL(keyPressed()),
-                            this, SLOT(ignoreSuperPress()));
-        m_superKeyHoldTimer.stop();
-        m_superKeyPressed = false;
-        if (m_superKeyHeld) {
-            m_superKeyHeld = false;
-            Q_EMIT superKeyHeldChanged(false);
-        }
-    }
-}
-
-void
-ShellDeclarativeView::setHotkeysForModifiers(Qt::KeyboardModifiers modifiers)
-{
-    /* This is the new new state of the Super key (AKA Meta key), while
-       m_superKeyPressed is the previous state of the key at the last modifiers change. */
-    bool superKeyPressed = modifiers.testFlag(Qt::MetaModifier);
-
-    if (m_superKeyPressed != superKeyPressed) {
-        m_superKeyPressed = superKeyPressed;
-        if (superKeyPressed) {
-            m_superPressIgnored = false;
-            /* If the key is pressed, start up a timer to monitor if it's being held short
-               enough to qualify as just a "tap" or as a proper hold */
-            m_superKeyHoldTimer.start();
-        } else {
-            m_superKeyHoldTimer.stop();
-
-            /* If the key is released, and was not being held, it means that the user just
-               performed a "tap". Unless we're told to ignore that tap, that is. */
-            if (!m_superKeyHeld && !m_superPressIgnored) {
-                Q_EMIT superKeyTapped();
-            }
-            /* Otherwise the user just terminated a hold. */
-            else if(m_superKeyHeld){
-                m_superKeyHeld = false;
-                Q_EMIT superKeyHeldChanged(m_superKeyHeld);
-            }
-        }
-    }
-}
-
-void
-ShellDeclarativeView::ignoreSuperPress()
-{
-    /* There was a key pressed, ignore current super tap/hold */
-    m_superPressIgnored = true;
-}
-
-void
-ShellDeclarativeView::forwardNumericHotkey()
-{
-    Hotkey* hotkey = qobject_cast<Hotkey*>(sender());
-    if (hotkey != NULL) {
-        /* Shortcuts from 1 to 9 should activate the items with index
-           from 1 to 9 (index 0 being the so-called "BFB" or Dash launcher).
-           Shortcut for 0 should activate item with index 10.
-           In other words, the indexes are activated in the same order as
-           the keys appear on a standard keyboard. */
-        Qt::Key key = hotkey->key();
-        if (key >= Qt::Key_1 && key <= Qt::Key_9) {
-            int index = key - Qt::Key_0;
-            if (hotkey->modifiers() & Qt::ShiftModifier) {
-                Q_EMIT newInstanceShortcutPressed(index);
-            } else {
-                Q_EMIT activateShortcutPressed(index);
-            }
-        } else if (key == Qt::Key_0) {
-            if (hotkey->modifiers() & Qt::ShiftModifier) {
-                Q_EMIT newInstanceShortcutPressed(10);
-            } else {
-                Q_EMIT activateShortcutPressed(10);
-            }
+void
+ShellDeclarativeView::processNumericHotkey(Hotkey* hotkey)
+{
+    /* Shortcuts from 1 to 9 should activate the items with index
+       from 1 to 9 (index 0 being the so-called "BFB" or Dash launcher).
+       Shortcut for 0 should activate item with index 10.
+       In other words, the indexes are activated in the same order as
+       the keys appear on a standard keyboard. */
+    Qt::Key key = hotkey->key();
+    if (key >= Qt::Key_1 && key <= Qt::Key_9) {
+        int index = key - Qt::Key_0;
+        if (hotkey->modifiers() & Qt::ShiftModifier) {
+            Q_EMIT newInstanceShortcutPressed(index);
+        } else {
+            Q_EMIT activateShortcutPressed(index);
+        }
+    } else if (key == Qt::Key_0) {
+        if (hotkey->modifiers() & Qt::ShiftModifier) {
+            Q_EMIT newInstanceShortcutPressed(10);
+        } else {
+            Q_EMIT activateShortcutPressed(10);
         }
     }
 }
@@ -466,3 +348,26 @@
 {
     return m_monitoredAreaContainsMouse;
 }
+
+void
+ShellDeclarativeView::setIsTopLeftShell(bool ashell)
+{
+    if (m_isTopLeftShell == ashell) {
+        return;
+    }
+
+    m_isTopLeftShell = ashell;
+    Q_EMIT isTopLeftShellChanged(m_isTopLeftShell);
+}
+
+void
+ShellDeclarativeView::setScreenNumber(int screen)
+{
+    m_screenInfo->setScreen(screen);
+}
+
+int
+ShellDeclarativeView::screenNumber() const
+{
+    return m_screenInfo->screen();
+}

=== modified file 'shell/app/shelldeclarativeview.h'
--- shell/app/shelldeclarativeview.h	2012-02-13 23:46:04 +0000
+++ shell/app/shelldeclarativeview.h	2012-02-16 08:16:20 +0000
@@ -27,6 +27,7 @@
 class LauncherClient;
 class DashDBus;
 class ScreenInfo;
+class Hotkey;
 
 class ShellDeclarativeView : public Unity2DDeclarativeView, public AbstractX11EventFilter
 {
@@ -38,7 +39,7 @@
     Q_PROPERTY(DashMode dashMode READ dashMode WRITE setDashMode NOTIFY dashModeChanged)
     Q_PROPERTY(QString activeLens READ activeLens WRITE setActiveLens NOTIFY activeLensChanged)
     Q_PROPERTY(bool focus READ hasFocus NOTIFY focusChanged) // overridden to add notify
-    Q_PROPERTY(bool superKeyHeld READ superKeyHeld NOTIFY superKeyHeldChanged)
+    Q_PROPERTY(bool isTopLeftShell READ isTopLeftShell WRITE setIsTopLeftShell NOTIFY isTopLeftShellChanged)
     Q_PROPERTY(bool haveCustomHomeShortcuts READ haveCustomHomeShortcuts)
 
     /* These two properties and mouse movement tracking on the widget are added here only because
@@ -56,7 +57,7 @@
         DesktopMode,
         FullScreenMode
     };
-    explicit ShellDeclarativeView();
+    explicit ShellDeclarativeView(const QUrl &sourceFileUrl = QUrl(), bool isTopLeftShell = false, int screen = 0);
 
     /* getters */
     bool dashActive() const;
@@ -64,19 +65,28 @@
     DashMode dashMode() const;
     const QString& activeLens() const;
     bool expanded() const;
-    bool superKeyHeld() const { return m_superKeyHeld; }
     QRect monitoredArea() const;
     bool monitoredAreaContainsMouse() const;
+    bool isTopLeftShell() const { return m_isTopLeftShell; }
 
     /* setters */
     Q_SLOT void setDashActive(bool active);
     Q_INVOKABLE void setDashMode(DashMode);
     Q_INVOKABLE void setActiveLens(const QString& activeLens);
     Q_INVOKABLE void setExpanded(bool);
+    void setScreenNumber(int);
+    int screenNumber() const;
     void setMonitoredArea(QRect monitoredArea);
+    void setIsTopLeftShell(bool);
 
     virtual bool x11EventFilter(XEvent* event);
 
+    void toggleDash();
+    void toggleLauncher();
+    void showCommandsLens();
+
+    void processNumericHotkey(Hotkey*);
+
 Q_SIGNALS:
     void dashActiveChanged(bool);
     void dashModeChanged(DashMode);
@@ -89,22 +99,10 @@
     void monitoredAreaContainsMouseChanged();
 
     void addWebFavoriteRequested(const QUrl& url);
-    void superKeyHeldChanged(bool superKeyHeld);
-    void superKeyTapped();
     void activateShortcutPressed(int itemIndex);
     void newInstanceShortcutPressed(int itemIndex);
     void launcherFocusRequested();
-
-private Q_SLOTS:
-    void updateSuperKeyMonitoring();
-    void updateSuperKeyHoldState();
-    void setHotkeysForModifiers(Qt::KeyboardModifiers modifiers);
-    void forwardNumericHotkey();
-    void ignoreSuperPress();
-
-    void toggleDash();
-    void showCommandsLens();
-    void onAltF1Pressed();
+    void isTopLeftShellChanged(bool);
 
 protected:
     virtual void showEvent(QShowEvent *event);
@@ -126,12 +124,10 @@
     QString m_activeLens; /* Lens id of the active lens */
     bool m_active;
 
-    bool m_superKeyPressed;
-    bool m_superKeyHeld;
-    bool m_superPressIgnored;
-    QTimer m_superKeyHoldTimer;
     QRect m_monitoredArea;
     bool m_monitoredAreaContainsMouse;
+    bool m_isTopLeftShell;
+    QUrl m_sourceFileUrl;
 
     friend class DashDBus;
     friend class LauncherDBus;

=== added file 'shell/app/shellmanager.cpp'
--- shell/app/shellmanager.cpp	1970-01-01 00:00:00 +0000
+++ shell/app/shellmanager.cpp	2012-02-16 08:16:20 +0000
@@ -0,0 +1,380 @@
+/*
+ * This file is part of unity-2d
+ *
+ * Copyright 2010 Canonical Ltd.
+ *
+ * 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/>
+ */
+
+#include "shellmanager.h"
+
+// Qt
+#include <QApplication>
+#include <QDebug>
+#include <QtDeclarative>
+#include <QDeclarativeEngine>
+#include <QDeclarativeView>
+#include <QDesktopWidget>
+#include <QDBusConnection>
+#include <QDBusConnectionInterface>
+#include <QDeclarativeContext>
+#include <QAbstractEventDispatcher>
+
+// libunity-2d-private
+#include <hotkeymonitor.h>
+#include <hotkey.h>
+#include <keyboardmodifiersmonitor.h>
+#include <keymonitor.h>
+#include <screeninfo.h>
+
+// Local
+#include "shelldeclarativeview.h"
+#include "dashclient.h"
+#include "dashdbus.h"
+#include "gesturehandler.h"
+#include "launcherdbus.h"
+#include "config.h"
+
+// unity-2d
+#include <unity2ddebug.h>
+#include <unity2dapplication.h>
+
+// X11
+#include <X11/Xlib.h>
+
+static const int KEY_HOLD_THRESHOLD = 250;
+
+struct ShellManagerPrivate
+{
+    ShellManagerPrivate()
+        : q(0)
+        , m_dashDBus(0)
+        , m_launcherDBus(0)
+        , m_superKeyPressed(false)
+        , m_superKeyHeld(false)
+    {}
+
+    ShellDeclarativeView* initShell(bool isTopLeft, int screen);
+    void updateScreenCount(int newCount);
+    ShellDeclarativeView* activeShell() const;
+
+    ShellManager *q;
+    QList<ShellDeclarativeView *> m_viewList;
+    DashDBus * m_dashDBus;
+    LauncherDBus* m_launcherDBus;
+    QUrl m_sourceFileUrl;
+
+    bool m_superKeyPressed;
+    bool m_superKeyHeld;
+    bool m_superPressIgnored;
+    QTimer m_superKeyHoldTimer;
+};
+
+
+ShellDeclarativeView *
+ShellManagerPrivate::initShell(bool isTopLeft, int screen)
+{
+    const QStringList arguments = qApp->arguments();
+    ShellDeclarativeView * view = new ShellDeclarativeView(m_sourceFileUrl, isTopLeft, screen);
+    view->setAccessibleName("Shell");
+    if (arguments.contains("-opengl")) {
+        view->setUseOpenGL(true);
+    }
+
+    Unity2dApplication::instance()->installX11EventFilter(view);
+
+    view->engine()->addImportPath(unity2dImportPath());
+    view->engine()->setBaseUrl(QUrl::fromLocalFile(unity2dDirectory() + "/shell/"));
+
+    /* Load the QML UI, focus and show the window */
+    view->setResizeMode(QDeclarativeView::SizeViewToRootObject);
+    view->rootContext()->setContextProperty("declarativeView", view);
+    view->rootContext()->setContextProperty("shellManager", q);
+    // WARNING This declaration of dashClient used to be in Unity2d/plugin.cpp
+    // but it lead to locks when both the shell and the spread were started
+    // at the same time since SpreadMonitor QDBusServiceWatcher::serviceRegistered
+    // and DashClient QDBusServiceWatcher::serviceRegistered
+    // triggered at the same time ending up with both creating QDBusInterface
+    // to eachother in the main thread meaning they would block
+    // In case you need to have a DashClient in the spread the fix for the problem
+    // is moving the QDbusInterface creation to a thread so it does not block
+    // the main thread
+    view->rootContext()->setContextProperty("dashClient", DashClient::instance());
+
+    if (!m_dashDBus) {
+        m_dashDBus = new DashDBus(view);
+        if (!m_dashDBus->connectToBus()) {
+            qCritical() << "Another instance of the Dash already exists. Quitting.";
+            return 0;
+        }
+    }
+
+    if (!m_launcherDBus) {
+        m_launcherDBus = new LauncherDBus(view);
+        m_launcherDBus->connectToBus();
+    }
+
+    view->show();
+
+    return view;
+}
+
+ShellDeclarativeView *
+ShellManagerPrivate::activeShell() const
+{
+    int cursorScreen = ScreenInfo::cursorScreen();
+    Q_FOREACH(ShellDeclarativeView * shell, m_viewList) {
+        if (shell->screenNumber() == cursorScreen) {
+            return shell;
+        }
+    }
+    return 0;
+}
+
+void
+ShellManagerPrivate::updateScreenCount(int newCount)
+{
+    if (newCount > 0) {
+        QDesktopWidget* desktop = QApplication::desktop();
+        int size = m_viewList.size();
+        ShellDeclarativeView* shell = 0;
+
+        /* The first shell is always the one on the leftmost screen. */
+        QPoint p;
+        if (QApplication::isRightToLeft()) {
+            p = QPoint(desktop->width() - 1, 0);
+        }
+        int leftmost = desktop->screenNumber(p);
+        if (size > 0) {
+            shell = m_viewList[0];
+        } else {
+            shell = initShell(true, leftmost);
+            m_viewList.append(shell);
+        }
+        shell->setScreenNumber(leftmost);
+
+        /* Update the position of other existing Shells, and instantiate new
+           Shells as needed. */
+        int i = 1;
+        for (int screen = 0; screen < newCount; ++screen) {
+            if (screen == leftmost) {
+                continue;
+            }
+            if (i < size) {
+                shell = m_viewList[i];
+            } else {
+                shell = initShell(false, screen);
+                m_viewList.append(shell);
+            }
+            shell->setIsTopLeftShell(false);
+            shell->setScreenNumber(screen);
+            ++i;
+        }
+    }
+    /* Remove extra Shells if any. */
+    while (m_viewList.size() > newCount) {
+        m_viewList.takeLast()->deleteLater();
+    }
+}
+
+/* -------------------------- ShellManager -----------------------------*/
+
+ShellManager::ShellManager(const QUrl &sourceFileUrl, QObject* parent) :
+    QObject(parent)
+    ,d(new ShellManagerPrivate)
+{
+    d->q = this;
+    d->m_sourceFileUrl = sourceFileUrl;
+
+    qmlRegisterType<ShellDeclarativeView>("Unity2d", 1, 0, "ShellDeclarativeView");
+
+    QDesktopWidget* desktop = QApplication::desktop();
+
+    d->updateScreenCount(desktop->screenCount());
+
+    connect(desktop, SIGNAL(screenCountChanged(int)), SLOT(onScreenCountChanged(int)));
+
+    d->m_superKeyHoldTimer.setSingleShot(true);
+    d->m_superKeyHoldTimer.setInterval(KEY_HOLD_THRESHOLD);
+    connect(&d->m_superKeyHoldTimer, SIGNAL(timeout()), SLOT(updateSuperKeyHoldState()));
+
+    connect(&launcher2dConfiguration(), SIGNAL(superKeyEnableChanged(bool)), SLOT(updateSuperKeyMonitoring()));
+    updateSuperKeyMonitoring();
+
+    /* Alt+F1 reveal the launcher and gives the keyboard focus to the Dash Button. */
+    Hotkey* altF1 = HotkeyMonitor::instance().getHotkeyFor(Qt::Key_F1, Qt::AltModifier);
+    connect(altF1, SIGNAL(pressed()), SLOT(onAltF1Pressed()));
+
+    /* Alt+F2 shows the dash with the commands lens activated. */
+    Hotkey* altF2 = HotkeyMonitor::instance().getHotkeyFor(Qt::Key_F2, Qt::AltModifier);
+    connect(altF2, SIGNAL(pressed()), SLOT(onAltF2Pressed()));
+
+    /* Super+{n} for 0 ≤ n ≤ 9 activates the item with index (n + 9) % 10. */
+    for (Qt::Key key = Qt::Key_0; key <= Qt::Key_9; key = (Qt::Key) (key + 1)) {
+        Hotkey* hotkey = HotkeyMonitor::instance().getHotkeyFor(key, Qt::MetaModifier);
+        connect(hotkey, SIGNAL(pressed()), SLOT(onNumericHotkeyPressed()));
+        hotkey = HotkeyMonitor::instance().getHotkeyFor(key, Qt::MetaModifier | Qt::ShiftModifier);
+        connect(hotkey, SIGNAL(pressed()), SLOT(onNumericHotkeyPressed()));
+    }
+}
+
+ShellManager::~ShellManager()
+{
+    qDeleteAll(d->m_viewList);
+    delete d;
+}
+
+void
+ShellManager::onScreenCountChanged(int newCount)
+{
+    d->updateScreenCount(newCount);
+}
+
+/* ----------------- super key handling ---------------- */
+
+void
+ShellManager::updateSuperKeyHoldState()
+{
+    /* If the key was released in the meantime, just do nothing, otherwise
+       consider the key being held, unless we're told to ignore it. */
+    if (d->m_superKeyPressed && !d->m_superPressIgnored) {
+        d->m_superKeyHeld = true;
+        Q_EMIT superKeyHeldChanged(d->m_superKeyHeld);
+    }
+}
+
+void
+ShellManager::updateSuperKeyMonitoring()
+{
+    KeyboardModifiersMonitor *modifiersMonitor = KeyboardModifiersMonitor::instance();
+    KeyMonitor *keyMonitor = KeyMonitor::instance();
+    HotkeyMonitor& hotkeyMonitor = HotkeyMonitor::instance();
+
+    QVariant value = launcher2dConfiguration().property("superKeyEnable");
+    if (!value.isValid() || value.toBool() == true) {
+        hotkeyMonitor.enableModifiers(Qt::MetaModifier);
+        QObject::connect(modifiersMonitor,
+                         SIGNAL(keyboardModifiersChanged(Qt::KeyboardModifiers)),
+                         this, SLOT(setHotkeysForModifiers(Qt::KeyboardModifiers)));
+        /* Ignore Super presses if another key was pressed simultaneously
+           (i.e. a shortcut). https://bugs.launchpad.net/unity-2d/+bug/801073 */
+        QObject::connect(keyMonitor,
+                         SIGNAL(keyPressed()),
+                         this, SLOT(ignoreSuperPress()));
+        setHotkeysForModifiers(modifiersMonitor->keyboardModifiers());
+    } else {
+        hotkeyMonitor.disableModifiers(Qt::MetaModifier);
+        QObject::disconnect(modifiersMonitor,
+                            SIGNAL(keyboardModifiersChanged(Qt::KeyboardModifiers)),
+                            this, SLOT(setHotkeysForModifiers(Qt::KeyboardModifiers)));
+        QObject::disconnect(keyMonitor,
+                            SIGNAL(keyPressed()),
+                            this, SLOT(ignoreSuperPress()));
+        d->m_superKeyHoldTimer.stop();
+        d->m_superKeyPressed = false;
+        if (d->m_superKeyHeld) {
+            d->m_superKeyHeld = false;
+            Q_EMIT superKeyHeldChanged(false);
+        }
+    }
+}
+
+void
+ShellManager::setHotkeysForModifiers(Qt::KeyboardModifiers modifiers)
+{
+    /* This is the new new state of the Super key (AKA Meta key), while
+       d->m_superKeyPressed is the previous state of the key at the last modifiers change. */
+    bool superKeyPressed = modifiers.testFlag(Qt::MetaModifier);
+
+    if (d->m_superKeyPressed != superKeyPressed) {
+        d->m_superKeyPressed = superKeyPressed;
+        if (superKeyPressed) {
+            d->m_superPressIgnored = false;
+            /* If the key is pressed, start up a timer to monitor if it's being held short
+               enough to qualify as just a "tap" or as a proper hold */
+            d->m_superKeyHoldTimer.start();
+        } else {
+            d->m_superKeyHoldTimer.stop();
+
+            /* If the key is released, and was not being held, it means that the user just
+               performed a "tap". Unless we're told to ignore that tap, that is. */
+            if (!d->m_superKeyHeld && !d->m_superPressIgnored) {
+                onSuperKeyTapped();
+            }
+            /* Otherwise the user just terminated a hold. */
+            else if(d->m_superKeyHeld){
+                d->m_superKeyHeld = false;
+                Q_EMIT superKeyHeldChanged(d->m_superKeyHeld);
+            }
+        }
+    }
+}
+
+void
+ShellManager::ignoreSuperPress()
+{
+    /* There was a key pressed, ignore current super tap/hold */
+    d->m_superPressIgnored = true;
+}
+
+void
+ShellManager::onSuperKeyTapped()
+{
+    // TODO : In future, All shells should be able to handle the Dash
+    // Note: Always, first item in the list is the topLeft shell
+    // In any case, just iterate through the list
+    Q_FOREACH(ShellDeclarativeView *shell, d->m_viewList) {
+        if (shell->isTopLeftShell()) {
+            shell->toggleDash();
+            break;
+        }
+    }
+}
+
+bool
+ShellManager::superKeyHeld() const
+{
+    return d->m_superKeyHeld;
+}
+
+/*------------------ Hotkeys Handling -----------------------*/
+
+void
+ShellManager::onAltF1Pressed()
+{
+    ShellDeclarativeView * activeShell = d->activeShell();
+    if (activeShell) {
+        activeShell->toggleLauncher();
+    }
+}
+
+void
+ShellManager::onAltF2Pressed()
+{
+    ShellDeclarativeView * activeShell = d->activeShell();
+    if (activeShell) {
+        activeShell->showCommandsLens();
+    }
+}
+
+void
+ShellManager::onNumericHotkeyPressed()
+{
+    Hotkey* hotkey = qobject_cast<Hotkey*>(sender());
+    if (hotkey) {
+        ShellDeclarativeView * activeShell = d->activeShell();
+        if (activeShell) {
+            activeShell->processNumericHotkey(hotkey);
+        }
+    }
+}

=== added file 'shell/app/shellmanager.h'
--- shell/app/shellmanager.h	1970-01-01 00:00:00 +0000
+++ shell/app/shellmanager.h	2012-02-16 08:16:20 +0000
@@ -0,0 +1,58 @@
+/*
+ * This file is part of unity-2d
+ *
+ * Copyright 2010 Canonical Ltd.
+ *
+ * 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/>
+ */
+#ifndef SHELLMANAGER_H
+#define SHELLMANAGER_H
+
+#include <QObject>
+struct ShellManagerPrivate;
+
+class QUrl;
+
+class ShellManager : public QObject
+{
+    Q_OBJECT
+    Q_PROPERTY(bool superKeyHeld READ superKeyHeld NOTIFY superKeyHeldChanged)
+
+public:
+    ShellManager(const QUrl &sourceFileUrl, QObject* parent = 0);
+    ~ShellManager();
+
+    bool superKeyHeld() const;
+
+Q_SIGNALS:
+    void superKeyHeldChanged(bool superKeyHeld);
+
+private Q_SLOTS:
+    void onScreenCountChanged(int);
+
+    void updateSuperKeyMonitoring();
+    void updateSuperKeyHoldState();
+    void setHotkeysForModifiers(Qt::KeyboardModifiers modifiers);
+    void ignoreSuperPress();
+    void onSuperKeyTapped();
+
+    void onAltF1Pressed();
+    void onAltF2Pressed();
+    void onNumericHotkeyPressed();
+
+private:
+    Q_DISABLE_COPY(ShellManager)
+    ShellManagerPrivate * const d;
+};
+
+#endif // SHELLMANAGER_H

=== modified file 'shell/launcher/LauncherList.qml'
--- shell/launcher/LauncherList.qml	2012-02-09 11:59:16 +0000
+++ shell/launcher/LauncherList.qml	2012-02-16 08:16:20 +0000
@@ -93,7 +93,7 @@
         }
 
         function updatePips() {
-            if (item.belongsToDifferentWorkspace()) {
+            if (item.belongsToDifferentWorkspace() || item.belongsToDifferentScreen(declarativeView.screen.screen)) {
                 launcherItem.pips = 1
                 launcherItem.pipSource = "launcher/artwork/launcher_arrow_outline_ltr.png";
             } else {
@@ -125,7 +125,7 @@
         emblemVisible: item.emblemVisible
 
         /* Launcher of index 0 is the so-called BFB or Dash launcher */
-        shortcutVisible: declarativeView.superKeyHeld &&
+        shortcutVisible: shellManager.superKeyHeld &&
                          ((item.toString().indexOf("LauncherApplication") == 0 && index > 0 && index <= 10) ||
                           item.shortcutKey != 0)
         shortcutText: {
@@ -310,6 +310,7 @@
                                                 width, height, xid)
             onWindowCountChanged: updatePips()
             onWindowWorkspaceChanged: updatePips()
+            onWindowGeometryChanged: updatePips()
             /* Not all items are applications. */
             ignoreUnknownSignals: true
         }

=== modified file 'shell/launcher/LauncherLoader.qml'
--- shell/launcher/LauncherLoader.qml	2012-02-10 11:17:36 +0000
+++ shell/launcher/LauncherLoader.qml	2012-02-16 08:16:20 +0000
@@ -70,7 +70,7 @@
     }
 
     Connections {
-        target: declarativeView
+        target: shellManager
         onSuperKeyHeldChanged: {
             if (superKeyHeld) visibilityController.beginForceVisible()
             else visibilityController.endForceVisible()