Merge into trunk : orientationLock : Code : Unity 8

Reviewer	Review Type	Date Requested	Status
Daniel d'Andrada (community)		2014-08-27	Approve on 2014-09-12
PS Jenkins bot (community)	continuous-integration		Needs Fixing on 2014-09-11
Review via email: mp+232484@code.launchpad.net

Revision history for this message

Daniel d'Andrada (dandrader) wrote on 2014-08-29:

#

270 + surface.orientation = Qt.binding( function() { return root.orientation; } );

Use a Binding component instead, like it's already done for surface.enabled and surface.interactive.

review: Needs Fixing

Revision history for this message

PS Jenkins bot (ps-jenkins) wrote on 2014-09-08:

#

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/unity8-ci/4254/rebuild

review: Needs Fixing (continuous-integration)

Revision history for this message

Daniel d'Andrada (dandrader) wrote on 2014-09-08:

#

OrientationLock::savedOrientation is not being used anywhere.

----------------------------------------------------------------

In plugins/Unity/Session/plugin.cpp:

"""
-static QObject *dbusunitysessionservice_provider(QQmlEngine *engine, QJSEngine *scriptEngine)
+static QObject *dbusunitysessionservice_provider(QQmlEngine */*engine*/, QJSEngine */*jsEngine*/)
{
- Q_UNUSED(engine)
- Q_UNUSED(scriptEngine)
-
"""

Why? Is using Q_UNUSED() bad form?

---------------------------------------------------------------------

In qml/Shell.qml

"""
+ readonly property int deviceOrientation: Screen.angleBetween(Screen.primaryOrientation, Screen.orientation)
"""

Please call it "orientation angle" or "rotation" instead of "orientation" as it's not a Qt.ScreenOrientation type.

---------------------------------------------------------------------

In qml/Stages/TabletStage.qml:

"""
+ onInteractiveChanged: {
+ if (interactive) {
+ appDelegate.orientation = Qt.binding( function() { return root.orientation; } );
+ } else {
+ appDelegate.orientation = root.orientation; // breaks the binding intentionally
+ }
+ }
"""

Could it use the same approach as qml/Stages/PhoneStage.qml?

---------------------------------------------------------------------

Run "make tryShell", "make tryApplicationWindow" or "make trySpreadDelegate". The "SURFACE" word is rotated.

---------------------------------------------------------------------

Please rotate the whole MirSurfaceItem mock and not just its text. Like this:
http://paste.ubuntu.com/8292833/

-----------------------------------------------------------------------

Add a test in SessionContainer that verifies that child sessions rotate along with the root one.

In qml/Stages/ApplicationWindow.qml:

"""
surface.orientation = Qt.binding( function() { return root.orientation; } );
"""

Please make it a Binding{} and put it alongside other similar bindings in SessionContainer.qml
Then ApplicationWindow.orientation would be just an alias to its internal SessionContainer.orientation.

OrientationLock::savedOrientation is not being used anywhere.

----------------------------------------------------------------

In plugins/Unity/Session/plugin.cpp:

"""
-static QObject *dbusunitysessionservice_provider(QQmlEngine *engine, QJSEngine *scriptEngine)
+static QObject *dbusunitysessionservice_provider(QQmlEngine */*engine*/, QJSEngine */*jsEngine*/)
 {
-    Q_UNUSED(engine)
-    Q_UNUSED(scriptEngine)
-
"""

Why? Is using Q_UNUSED() bad form?

---------------------------------------------------------------------

In qml/Shell.qml

"""
+        readonly property int deviceOrientation: Screen.angleBetween(Screen.primaryOrientation, Screen.orientation)
"""

Please call it "orientation angle" or "rotation" instead of "orientation" as it's not a Qt.ScreenOrientation type.

---------------------------------------------------------------------

In qml/Stages/TabletStage.qml:

"""
+                    onInteractiveChanged: {
+                        if (interactive) {
+                            appDelegate.orientation = Qt.binding( function() { return root.orientation; } );
+                        } else {
+                            appDelegate.orientation = root.orientation; // breaks the binding intentionally
+                        }
+                    }
"""

Could it use the same approach as qml/Stages/PhoneStage.qml?

---------------------------------------------------------------------

Run "make tryShell", "make tryApplicationWindow" or "make trySpreadDelegate". The "SURFACE" word is rotated.

---------------------------------------------------------------------

Please rotate the whole MirSurfaceItem mock and not just its text. Like this:
http://paste.ubuntu.com/8292833/

-----------------------------------------------------------------------

Add a test in SessionContainer that verifies that child sessions rotate along with the root one.

In qml/Stages/ApplicationWindow.qml:

"""
                surface.orientation = Qt.binding( function() { return root.orientation; } );
"""

Please make it a Binding{} and put it alongside other similar bindings in SessionContainer.qml
Then ApplicationWindow.orientation would be just an alias to its internal SessionContainer.orientation.

review: Needs Fixing

Revision history for this message

Daniel d'Andrada (dandrader) wrote on 2014-09-08:

#

> [...]
> Please call it "orientation angle" or "rotation" instead of "orientation" as
> it's not a Qt.ScreenOrientation type.
> [...]

Actually "rotation" would clash with Item.rotation.

Revision history for this message

Daniel d'Andrada (dandrader) wrote on 2014-09-09:

#

By the way, have you checked how does that work with the virtual keyboard? eg: if you lock the app orientation, will the vkb keep rotating?

lp:~gerboland/unity8/orientationLock updated on 2014-09-09

1212. By Gerry Boland on 2014-09-09: Merge trunk

Revision history for this message

PS Jenkins bot (ps-jenkins) wrote on 2014-09-10:

#

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/unity8-ci/4258/rebuild

review: Needs Fixing (continuous-integration)

lp:~gerboland/unity8/orientationLock updated on 2014-09-10

1213. By Gerry Boland on 2014-09-10: Use OrientationLock.savedOrientation. Rename deviceOrientation to deviceOrientationAngle
1214. By Gerry Boland on 2014-09-10: TabletStage: Use Binding instead of JS settings a binding
1215. By Gerry Boland on 2014-09-10: MockMirSurfaceItem: Rotate whole thing, even if image looks weird
1216. By Gerry Boland on 2014-09-10: Use Binding instead JS establised binding

Revision history for this message

PS Jenkins bot (ps-jenkins) wrote on 2014-09-10:

#

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/unity8-ci/4270/rebuild

review: Needs Fixing (continuous-integration)

Revision history for this message

PS Jenkins bot (ps-jenkins) wrote on 2014-09-10:

#

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/unity8-ci/4271/rebuild

review: Needs Fixing (continuous-integration)

lp:~gerboland/unity8/orientationLock updated on 2014-09-11

1217. By Gerry Boland on 2014-09-11: Propagate orientation to all child surfaces, update tests to suit
1218. By Gerry Boland on 2014-09-11: Oopsie, orientation will work now
1219. By Gerry Boland on 2014-09-11: Add test for SurfaceContainer

Revision history for this message

Gerry Boland (gerboland) wrote on 2014-09-11:

#

> OrientationLock::savedOrientation is not being used anywhere.
I added code to use it, but it's not persistent over logout/in yet so is a touch pointless. I wanted to implement the persistence in a separate MR, but I can do it now if you like.

> ----------------------------------------------------------------
>
> In plugins/Unity/Session/plugin.cpp:
>
> """
> -static QObject *dbusunitysessionservice_provider(QQmlEngine *engine,
> QJSEngine *scriptEngine)
> +static QObject *dbusunitysessionservice_provider(QQmlEngine */*engine*/,
> QJSEngine */*jsEngine*/)
> {
> - Q_UNUSED(engine)
> - Q_UNUSED(scriptEngine)
> -
> """
>
> Why? Is using Q_UNUSED() bad form?

I recall Saviq saying he preferred this to Q_UNUSED. Depends on how clever the compiler is really - if we don't name the argument then the compiler definitely knows not to bother with it. But if we use Q_UNUSED it depends on if the compiler is smart enough to guess our intentions. I prefer this way too really.

> ---------------------------------------------------------------------
>
> In qml/Shell.qml
>
> """
> + readonly property int deviceOrientation:
> Screen.angleBetween(Screen.primaryOrientation, Screen.orientation)
> """
>
> Please call it "orientation angle" or "rotation" instead of "orientation" as
> it's not a Qt.ScreenOrientation type.

Done.

> ---------------------------------------------------------------------
>
> In qml/Stages/TabletStage.qml:
>
> """
> + onInteractiveChanged: {
> + if (interactive) {
> + appDelegate.orientation = Qt.binding( function()
> { return root.orientation; } );
> + } else {
> + appDelegate.orientation = root.orientation; //
> breaks the binding intentionally
> + }
> + }
> """
>
> Could it use the same approach as qml/Stages/PhoneStage.qml?

Done

>
> ---------------------------------------------------------------------
>
> Run "make tryShell", "make tryApplicationWindow" or "make trySpreadDelegate".
> The "SURFACE" word is rotated.
>
> ---------------------------------------------------------------------
>
> Please rotate the whole MirSurfaceItem mock and not just its text. Like this:
> http://paste.ubuntu.com/8292833/

The orientation of the word was my hint to tester the orientation of the mock surface - I thought rotating the image and scaling it was more ugly. But I did it your way, and yeah it's more clear what's going on.

> -----------------------------------------------------------------------
>
> Add a test in SessionContainer that verifies that child sessions rotate along
> with the root one.

Done

> In qml/Stages/ApplicationWindow.qml:
>
> """
> surface.orientation = Qt.binding( function() { return
> root.orientation; } );
> """
>
> Please make it a Binding{} and put it alongside other similar bindings in
> SessionContainer.qml
> Then ApplicationWindow.orientation would be just an alias to its internal
> SessionContainer.orientation.

Done

> OrientationLock::savedOrientation is not being used anywhere.
I added code to use it, but it's not persistent over logout/in yet so is a touch pointless. I wanted to implement the persistence in a separate MR, but I can do it now if you like.

> ----------------------------------------------------------------
> 
> In plugins/Unity/Session/plugin.cpp:
> 
> """
> -static QObject *dbusunitysessionservice_provider(QQmlEngine *engine,
> QJSEngine *scriptEngine)
> +static QObject *dbusunitysessionservice_provider(QQmlEngine */*engine*/,
> QJSEngine */*jsEngine*/)
>  {
> -    Q_UNUSED(engine)
> -    Q_UNUSED(scriptEngine)
> -
> """
> 
> Why? Is using Q_UNUSED() bad form?

I recall Saviq saying he preferred this to Q_UNUSED. Depends on how clever the compiler is really - if we don't name the argument then the compiler definitely knows not to bother with it. But if we use Q_UNUSED it depends on if the compiler is smart enough to guess our intentions. I prefer this way too really.

> ---------------------------------------------------------------------
> 
> In qml/Shell.qml
> 
> """
> +        readonly property int deviceOrientation:
> Screen.angleBetween(Screen.primaryOrientation, Screen.orientation)
> """
> 
> Please call it "orientation angle" or "rotation" instead of "orientation" as
> it's not a Qt.ScreenOrientation type.

Done.

> ---------------------------------------------------------------------
> 
> In qml/Stages/TabletStage.qml:
> 
> """
> +                    onInteractiveChanged: {
> +                        if (interactive) {
> +                            appDelegate.orientation = Qt.binding( function()
> { return root.orientation; } );
> +                        } else {
> +                            appDelegate.orientation = root.orientation; //
> breaks the binding intentionally
> +                        }
> +                    }
> """
> 
> Could it use the same approach as qml/Stages/PhoneStage.qml?

Done

> 
> ---------------------------------------------------------------------
> 
> Run "make tryShell", "make tryApplicationWindow" or "make trySpreadDelegate".
> The "SURFACE" word is rotated.
> 
> ---------------------------------------------------------------------
> 
> Please rotate the whole MirSurfaceItem mock and not just its text. Like this:
> http://paste.ubuntu.com/8292833/

The orientation of the word was my hint to tester the orientation of the mock surface - I thought rotating the image and scaling it was more ugly. But I did it your way, and yeah it's more clear what's going on.

> -----------------------------------------------------------------------
> 
> Add a test in SessionContainer that verifies that child sessions rotate along
> with the root one.

Done

> In qml/Stages/ApplicationWindow.qml:
> 
> """
>                 surface.orientation = Qt.binding( function() { return
> root.orientation; } );
> """
> 
> Please make it a Binding{} and put it alongside other similar bindings in
> SessionContainer.qml
> Then ApplicationWindow.orientation would be just an alias to its internal
> SessionContainer.orientation.

Done

Revision history for this message

Gerry Boland (gerboland) wrote on 2014-09-11:

#

> By the way, have you checked how does that work with the virtual keyboard? eg:
> if you lock the app orientation, will the vkb keep rotating?

Application tells the keyboard what geometry to be, so it always suits what orientation the app is in. If orientation locked, app orientation does not change, and so keyboard doesn't either.

lp:~gerboland/unity8/orientationLock updated on 2014-09-11

1220. By Gerry Boland on 2014-09-11: Bad copy/paste, fix orientation on tablet

Revision history for this message

PS Jenkins bot (ps-jenkins) wrote on 2014-09-11:

#

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/unity8-ci/4275/rebuild

review: Needs Fixing (continuous-integration)

Revision history for this message

PS Jenkins bot (ps-jenkins) wrote on 2014-09-11:

#

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/unity8-ci/4284/rebuild

review: Needs Fixing (continuous-integration)

Revision history for this message

Daniel d'Andrada (dandrader) wrote on 2014-09-12:

#

In tests/qmltests/Stages/tst_SessionContainer.qml

"""
tryCompare(sessionContainer, "orientation", sessionContainer.orientation);
"""

Huh!? You're comparing sessionContainer.orientation to itself?
You probably meant:
tryCompare(childContainer, "orientation", sessionContainer.orientation);

Calling it rootSessionContainer instead of just sessionContainer would also help to clarify things. But that's just a suggestion.

-----------------------------------------------------

In tests/qmltests/Stages/tst_SessionContainer.qml

"""
/* Text orientation changes are propagated to all children immediately */
"""

typo. s/Text/Test

------------------------------------------------------

"""
--- qml/Stages/ApplicationWindow.qml 2014-09-03 16:38:10 +0000
+++ qml/Stages/ApplicationWindow.qml 2014-09-11 10:41:11 +0000
@@ -27,6 +27,7 @@ Item {

// to be set from outside
property QtObject application
+ property int orientation

     QtObject {
         id: d
@@ -111,6 +112,7 @@ Item {
         id: sessionContainer
         session: application ? application.session : null
         anchors.fill: parent
+ orientation: root.orientation

onSurfaceChanged: {
if (sessionContainer.surface) {
"""

Just a suggestion (feel free to change it or not):
I think it's better to use property aliases in such cases as they seem to be more efficient (besides being more concise) than property bindings. But who knows, maybe they boil down to the same in the qml engine...

review: Needs Fixing

Revision history for this message

Daniel d'Andrada (dandrader) wrote on 2014-09-12:

#

* Did you perform an exploratory manual test run of the code change and any related functionality?
Yes. Works fine.

* Did CI run pass? If not, please explain why.
No but due to an unrelated failure.

Revision history for this message

Gerry Boland (gerboland) wrote on 2014-09-12:

#

> In tests/qmltests/Stages/tst_SessionContainer.qml
>
> """
> tryCompare(sessionContainer, "orientation",
> sessionContainer.orientation);
> """
>
> Huh!? You're comparing sessionContainer.orientation to itself?
> You probably meant:
> tryCompare(childContainer, "orientation", sessionContainer.orientation);

Yep silly me. Thanks for catching that.

> Calling it rootSessionContainer instead of just sessionContainer would also
> help to clarify things. But that's just a suggestion.

Done. And used childSessionContainer while I was at it.

> -----------------------------------------------------
>
> In tests/qmltests/Stages/tst_SessionContainer.qml
>
> """
> /* Text orientation changes are propagated to all children immediately */
> """
>
> typo. s/Text/Test

Done

> ------------------------------------------------------
>
> """
> --- qml/Stages/ApplicationWindow.qml 2014-09-03 16:38:10 +0000
> +++ qml/Stages/ApplicationWindow.qml 2014-09-11 10:41:11 +0000
> @@ -27,6 +27,7 @@ Item {
>
> // to be set from outside
> property QtObject application
> + property int orientation
>
> QtObject {
> id: d
> @@ -111,6 +112,7 @@ Item {
> id: sessionContainer
> session: application ? application.session : null
> anchors.fill: parent
> + orientation: root.orientation
>
> onSurfaceChanged: {
> if (sessionContainer.surface) {
> """
>
> Just a suggestion (feel free to change it or not):
> I think it's better to use property aliases in such cases as they seem to be
> more efficient (besides being more concise) than property bindings. But who
> knows, maybe they boil down to the same in the qml engine...

I've no idea how aliases work. I suppose they must be more efficient, but I also heard from a Qt developer (working on the QtQuickComponents) that they're expensive. So I don't know! I tend not to use them as (in this instance) it's harder to see immediately that SessionContainer has an orientation property, and you need to scroll around to figure out what sets that property. Personal taste I guess :) Mind if I leave it alone? If we learn it is indeed an optimization, I'll switch it.

> In tests/qmltests/Stages/tst_SessionContainer.qml
> 
> """
>                 tryCompare(sessionContainer, "orientation",
> sessionContainer.orientation);
> """
> 
> Huh!? You're comparing sessionContainer.orientation to itself?
> You probably meant:
> tryCompare(childContainer, "orientation", sessionContainer.orientation);

Yep silly me. Thanks for catching that.

> Calling it rootSessionContainer instead of just sessionContainer would also
> help to clarify things. But that's just a suggestion.

Done. And used childSessionContainer while I was at it.

> -----------------------------------------------------
> 
> In tests/qmltests/Stages/tst_SessionContainer.qml
> 
> """
> /* Text orientation changes are propagated to all children immediately */
> """
> 
> typo. s/Text/Test

Done

> ------------------------------------------------------
> 
> """
> --- qml/Stages/ApplicationWindow.qml    2014-09-03 16:38:10 +0000
> +++ qml/Stages/ApplicationWindow.qml    2014-09-11 10:41:11 +0000
> @@ -27,6 +27,7 @@ Item {
> 
>      // to be set from outside
>      property QtObject application
> +    property int orientation
> 
>      QtObject {
>          id: d
> @@ -111,6 +112,7 @@ Item {
>          id: sessionContainer
>          session: application ? application.session : null
>          anchors.fill: parent
> +        orientation: root.orientation
> 
>          onSurfaceChanged: {
>              if (sessionContainer.surface) {
> """
> 
> Just a suggestion (feel free to change it or not):
> I think it's better to use property aliases in such cases as they seem to be
> more efficient (besides being more concise) than property bindings. But who
> knows, maybe they boil down to the same in the qml engine...

I've no idea how aliases work. I suppose they must be more efficient, but I also heard from a Qt developer (working on the QtQuickComponents) that they're expensive. So I don't know! I tend not to use them as (in this instance) it's harder to see immediately that SessionContainer has an orientation property, and you need to scroll around to figure out what sets that property. Personal taste I guess :) Mind if I leave it alone? If we learn it is indeed an optimization, I'll switch it.

lp:~gerboland/unity8/orientationLock updated on 2014-09-12

1221. By Gerry Boland on 2014-09-12: test_SessionContainer: stupid compare statements fixed. Using root & child prefixes to clarify things
1222. By Gerry Boland on 2014-09-12: Typo

Revision history for this message

Daniel d'Andrada (dandrader) wrote on 2014-09-12:

#

Thumbs up.

--------------------

"""
tryCompare(rootSessionContainer, "orientation", childSessionContainer.orientation);
"""

Nitpick:
You should swap rootSessionContainer with childSessionContainer, as the last parameter is the expected value.
Ie, you expect childSessionContainer.orientation (the property whose value should change) to eventually be rootSessionContainer.orientation (the value that you've manually set), not the other way round.

review: Approve

Unity 8

Merge lp:~gerboland/unity8/orientationLock into lp:unity8

Commit message

Description of the change

Preview Diff

Subscribers

 === modified file 'plugins/Unity/Session/CMakeLists.txt'
 --- plugins/Unity/Session/CMakeLists.txt	2014-06-13 13:13:16 +0000
 +++ plugins/Unity/Session/CMakeLists.txt	2014-09-12 19:54:38 +0000
@@ -1,10 +1,16 @@
++include(FindPkgConfig)
++
++pkg_search_module(GIO REQUIRED gio-2.0)
++
  include_directories(
      ${CMAKE_CURRENT_SOURCE_DIR}
++    ${GIO_INCLUDE_DIRS}
+ )
  set(QMLSESSIONPLUGIN_SRC
      plugin.cpp
      dbusunitysessionservice.cpp
++    orientationlock.cpp
+     )
  add_library(UnitySession-qml MODULE
@@ -12,6 +18,7 @@
+     )
  qt5_use_modules(UnitySession-qml DBus Qml)
++target_link_libraries(UnitySession-qml ${GIO_LDFLAGS})
  # export the qmldir and qmltypes files
  add_unity8_plugin(Unity.Session 0.1 Unity/Session TARGETS UnitySession-qml)
 === added file 'plugins/Unity/Session/orientationlock.cpp'
 --- plugins/Unity/Session/orientationlock.cpp	1970-01-01 00:00:00 +0000
 +++ plugins/Unity/Session/orientationlock.cpp	2014-09-12 19:54:38 +0000
@@ -0,0 +1,74 @@
++/*
++ * Copyright (C) 2014 Canonical, Ltd.
++ *
++ * This program is free software: you can redistribute it and/or modify it under
++ * the terms of the GNU Lesser General Public License version 3, as published by
++ * the Free Software Foundation.
++ *
++ * This program is distributed in the hope that it will be useful, but WITHOUT
++ * ANY WARRANTY; without even the implied warranties of MERCHANTABILITY,
++ * SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
++ * Lesser General Public License for more details.
++ *
++ * You should have received a copy of the GNU Lesser General Public License
++ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
++ */
++
++#include "orientationlock.h"
++
++#include <QDBusConnection>
++#include <QDBusInterface>
++
++OrientationLock::OrientationLock(QObject *parent)
++    : QObject(parent)
++    , m_enabled(false)
++    , m_savedOrientation(Qt::PortraitOrientation)
++{
++    systemSettings = g_settings_new("com.ubuntu.touch.system");
++    g_signal_connect(systemSettings, "changed::rotation-lock",
++                     G_CALLBACK(OrientationLock::onEnabledChangedProxy), this);
++    m_enabled = g_settings_get_boolean(systemSettings, "rotation-lock");
++}
++
++OrientationLock::~OrientationLock()
++{
++    g_signal_handlers_disconnect_by_data(systemSettings, this);
++    g_object_unref(systemSettings);
++}
++
++bool OrientationLock::enabled() const
++{
++    return m_enabled;
++}
++
++Qt::ScreenOrientation OrientationLock::savedOrientation() const
++{
++    return m_savedOrientation;
++}
++
++void OrientationLock::onEnabledChangedProxy(GSettings */*settings*/, const gchar */*key*/, gpointer data)
++{
++    OrientationLock* _this = static_cast<OrientationLock*>(data);
++    _this->onEnabledChanged();
++}
++
++void OrientationLock::onEnabledChanged()
++{
++    const bool enabled = g_settings_get_boolean(systemSettings, "rotation-lock");
++    if (m_enabled != enabled) {
++        m_enabled = enabled;
++        Q_EMIT enabledChanged();
++    }
++}
++
++void OrientationLock::setSavedOrientation(const Qt::ScreenOrientation orientation)
++{
++    if (orientation == m_savedOrientation) {
++        return;
++    }
++
++    m_savedOrientation = orientation;
++
++    //TODO - save value with dbus to persist over sessions
++    Q_EMIT savedOrientationChanged();
++}
 === added file 'plugins/Unity/Session/orientationlock.h'
 --- plugins/Unity/Session/orientationlock.h	1970-01-01 00:00:00 +0000
 +++ plugins/Unity/Session/orientationlock.h	2014-09-12 19:54:38 +0000
@@ -0,0 +1,62 @@
++/*
++ * Copyright (C) 2014 Canonical, Ltd.
++ *
++ * This program is free software: you can redistribute it and/or modify it under
++ * the terms of the GNU Lesser General Public License version 3, as published by
++ * the Free Software Foundation.
++ *
++ * This program is distributed in the hope that it will be useful, but WITHOUT
++ * ANY WARRANTY; without even the implied warranties of MERCHANTABILITY,
++ * SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
++ * Lesser General Public License for more details.
++ *
++ * You should have received a copy of the GNU Lesser General Public License
++ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
++ */
++
++#ifndef ORIENTATIONLOCK_H
++#define ORIENTATIONLOCK_H
++
++#include <gio/gio.h>
++#include <QtCore/QObject>
++#include <QtDBus/QDBusInterface>
++
++/**
++ * @brief The OrientationLock class exports orientation lock related properties to QML
++ * It has two properties:
++ *    - readonly boolean with the Orientation lock property state
++ *    - Qt::ScreenOrientation to save the locked orientation state across Sessions (only relevant if lock is true)
++ */
++class OrientationLock : public QObject
++{
++    Q_OBJECT
++
++    Q_PROPERTY(bool enabled READ enabled NOTIFY enabledChanged)
++    Q_PROPERTY(Qt::ScreenOrientation savedOrientation READ savedOrientation WRITE setSavedOrientation
++                   NOTIFY savedOrientationChanged)
++
++public:
++    explicit OrientationLock(QObject *parent = 0);
++    ~OrientationLock();
++
++    bool enabled() const;
++    Qt::ScreenOrientation savedOrientation() const;
++    void setSavedOrientation(const Qt::ScreenOrientation orientation);
++
++Q_SIGNALS:
++    void enabledChanged();
++    void savedOrientationChanged();
++
++private Q_SLOTS:
++    static void onEnabledChangedProxy(GSettings *settings, const gchar *key, gpointer data);
++    void onEnabledChanged();
++
++private:
++    QDBusInterface *dbusInterface;
++    GSettings *systemSettings;
++
++    bool m_enabled;
++    Qt::ScreenOrientation m_savedOrientation;
++};
++
++#endif // ORIENTATIONLOCK_H
 === modified file 'plugins/Unity/Session/plugin.cpp'
 --- plugins/Unity/Session/plugin.cpp	2014-05-07 15:21:51 +0000
 +++ plugins/Unity/Session/plugin.cpp	2014-09-12 19:54:38 +0000
@@ -18,23 +18,27 @@
  #include "plugin.h"
  #include "dbusunitysessionservice.h"
++#include "orientationlock.h"
  #include <QAbstractItemModel>
  #include <QDBusConnection>
  #include <QtQml/qqml.h>
--static QObject *dbusunitysessionservice_provider(QQmlEngine *engine, QJSEngine *scriptEngine)
++static QObject *dbusunitysessionservice_provider(QQmlEngine */*engine*/, QJSEngine */*jsEngine*/)
+ {
--    Q_UNUSED(engine)
--    Q_UNUSED(scriptEngine)
--
      return new DBusUnitySessionService();
+ }
++static QObject *orientationlock_provider(QQmlEngine */*engine*/, QJSEngine */*jsEngine*/)
++{
++    return new OrientationLock();
++}
++
  void SessionPlugin::registerTypes(const char *uri)
+ {
      qmlRegisterType<QAbstractItemModel>();
      Q_ASSERT(uri == QLatin1String("Unity.Session"));
      qmlRegisterSingletonType<DBusUnitySessionService>(uri, 0, 1, "DBusUnitySessionService", dbusunitysessionservice_provider);
++    qmlRegisterSingletonType<OrientationLock>(uri, 0, 1, "OrientationLock", orientationlock_provider);
+ }
 === modified file 'qml/Shell.qml'
 --- qml/Shell.qml	2014-09-08 14:15:51 +0000
 +++ qml/Shell.qml	2014-09-12 19:54:38 +0000
@@ -15,6 +15,7 @@
   */
  import QtQuick 2.0
++import QtQuick.Window 2.0
  import AccountsService 0.1
  import GSettings 1.0
  import Unity.Application 0.1
@@ -61,6 +62,22 @@
      property int failedLoginsDelayAttempts: 7 // number of failed logins
      property int failedLoginsDelaySeconds: 5 * 60 // seconds of forced waiting
++    property int orientation
++    readonly property int deviceOrientationAngle: Screen.angleBetween(Screen.primaryOrientation, Screen.orientation)
++    onDeviceOrientationAngleChanged: {
++        if (!OrientationLock.enabled) {
++            orientation = Screen.orientation;
++        }
++    }
++    readonly property bool orientationLockEnabled: OrientationLock.enabled
++    onOrientationLockEnabledChanged: {
++        if (orientationLockEnabled) {
++            OrientationLock.savedOrientation = Screen.orientation;
++        } else {
++            orientation = Screen.orientation;
++        }
++    }
++
      function activateApplication(appId) {
          if (ApplicationManager.findApplication(appId)) {
              ApplicationManager.requestFocusApplication(appId);
@@ -85,6 +102,9 @@
      Component.onCompleted: {
          Theme.name = "Ubuntu.Components.Themes.SuruGradient"
++        if (orientationLockEnabled) {
++            orientation = OrientationLock.savedOrientation;
++        }
+     }
      GSettings {
@@ -207,6 +227,11 @@
                  property: "inverseProgress"
                  value: launcher.progress
+             }
++            Binding {
++                target: applicationsDisplayLoader.item
++                property: "orientation"
++                value: shell.orientation
++            }
+         }
+     }
 === modified file 'qml/Stages/ApplicationWindow.qml'
 --- qml/Stages/ApplicationWindow.qml	2014-09-03 16:38:10 +0000
 +++ qml/Stages/ApplicationWindow.qml	2014-09-12 19:54:38 +0000
@@ -27,6 +27,7 @@
      // to be set from outside
      property QtObject application
++    property int orientation
      QtObject {
          id: d
@@ -111,6 +112,7 @@
          id: sessionContainer
          session: application ? application.session : null
          anchors.fill: parent
++        orientation: root.orientation
          onSurfaceChanged: {
              if (sessionContainer.surface) {
 === modified file 'qml/Stages/PhoneStage.qml'
 --- qml/Stages/PhoneStage.qml	2014-09-02 14:57:05 +0000
 +++ qml/Stages/PhoneStage.qml	2014-09-12 19:54:38 +0000
@@ -18,6 +18,7 @@
  import Ubuntu.Components 0.1
  import Ubuntu.Gestures 0.1
  import Unity.Application 0.1
++import Unity.Session 0.1
  import Utils 0.1
  import "../Components"
@@ -30,6 +31,7 @@
      property bool interactive
      property bool spreadEnabled: true // If false, animations and right edge will be disabled
      property real inverseProgress: 0 // This is the progress for left edge drags, in pixels.
++    property int orientation: Qt.PortraitOrientation
      color: "black"
@@ -372,6 +374,13 @@
                          progress: appDelegate.progress - spreadView.positionMarker1
+                     }
++                    Binding {
++                        target: appDelegate
++                        property: "orientation"
++                        when: appDelegate.interactive
++                        value: root.orientation
++                    }
++
                      onClicked: {
                          if (spreadView.phase == 2) {
                              if (ApplicationManager.focusedApplicationId == ApplicationManager.get(index).appId) {
 === modified file 'qml/Stages/SessionContainer.qml'
 --- qml/Stages/SessionContainer.qml	2014-09-02 15:51:04 +0000
 +++ qml/Stages/SessionContainer.qml	2014-09-12 19:54:38 +0000
@@ -24,12 +24,14 @@
      readonly property var childSessions: session ? session.childSessions : null
      readonly property alias surface: _surfaceContainer.surface
      property bool interactive: true
++    property int orientation
      readonly property alias surfaceContainer: _surfaceContainer
      SurfaceContainer {
          id: _surfaceContainer
          anchors.fill: parent
          surface: session ? session.surface : null
++        orientation: root.orientation
+     }
      Binding {
@@ -74,6 +76,11 @@
                  target: item; when: item
                  property: "height"; value: root.height
+             }
++
++            Binding {
++                target: item; when: item
++                property: "orientation"; value: root.orientation
++            }
+         }
+     }
 === modified file 'qml/Stages/SpreadDelegate.qml'
 --- qml/Stages/SpreadDelegate.qml	2014-08-27 20:58:10 +0000
 +++ qml/Stages/SpreadDelegate.qml	2014-09-12 19:54:38 +0000
@@ -36,6 +36,7 @@
      property alias swipeToCloseEnabled: dragArea.enabled
      property bool closeable
      property alias application: appWindow.application
++    property int orientation
      Item {
          objectName: "appWindowWithShadow"
@@ -62,6 +63,7 @@
+             }
              interactive: root.interactive
++            orientation: root.orientation
+         }
+     }
 === modified file 'qml/Stages/SurfaceContainer.qml'
 --- qml/Stages/SurfaceContainer.qml	2014-09-01 12:48:57 +0000
 +++ qml/Stages/SurfaceContainer.qml	2014-09-12 19:54:38 +0000
@@ -22,6 +22,7 @@
      objectName: "surfaceContainer"
      property Item surface: null
      property bool hadSurface: false
++    property int orientation
      onSurfaceChanged: {
          if (surface) {
@@ -34,6 +35,10 @@
          target: surface
          property: "anchors.fill"; value: root
+     }
++    Binding {
++        target: surface
++        property: "orientation"; value: root.orientation
++    }
      states: [
          State {
 === modified file 'qml/Stages/TabletStage.qml'
 --- qml/Stages/TabletStage.qml	2014-09-02 18:10:49 +0000
 +++ qml/Stages/TabletStage.qml	2014-09-12 19:54:38 +0000
@@ -34,6 +34,7 @@
      property real maximizedAppTopMargin
      property bool interactive
      property real inverseProgress: 0 // This is the progress for left edge drags, in pixels.
++    property int orientation: Qt.PortraitOrientation
      onInverseProgressChanged: {
          // This can't be a simple binding because that would be triggered after this handler
@@ -535,6 +536,13 @@
                          return progress;
+                     }
++                    Binding {
++                        target: spreadTile
++                        property: "orientation"
++                        when: spreadTile.interactive
++                        value: root.orientation
++                    }
++
                      onClicked: {
                          if (spreadView.phase == 2) {
                              spreadView.snapTo(index);
 === modified file 'tests/mocks/Unity/Application/MirSurfaceItem.cpp'
 --- tests/mocks/Unity/Application/MirSurfaceItem.cpp	2014-08-29 14:50:49 +0000
 +++ tests/mocks/Unity/Application/MirSurfaceItem.cpp	2014-09-12 19:54:38 +0000
@@ -39,6 +39,7 @@
      , m_type(type)
      , m_state(state)
      , m_live(true)
++    , m_orientation(Qt::PortraitOrientation)
      , m_qmlItem(nullptr)
      , m_screenshotUrl(screenshot)
+ {
@@ -108,6 +109,19 @@
+     }
+ }
++void MirSurfaceItem::setOrientation(const Qt::ScreenOrientation orientation)
++{
++    if (m_orientation == orientation)
++        return;
++
++    m_orientation = orientation;
++
++    QQmlProperty orientationProp(m_qmlItem, "orientation");
++    orientationProp.write(QVariant::fromValue(orientation));
++
++    Q_EMIT orientationChanged();
++}
++
  void MirSurfaceItem::setSession(Session* session)
+ {
      m_session = session;
 === modified file 'tests/mocks/Unity/Application/MirSurfaceItem.h'
 --- tests/mocks/Unity/Application/MirSurfaceItem.h	2014-09-01 12:24:06 +0000
 +++ tests/mocks/Unity/Application/MirSurfaceItem.h	2014-09-12 19:54:38 +0000
@@ -34,6 +34,7 @@
      Q_PROPERTY(State state READ state NOTIFY stateChanged)
      Q_PROPERTY(QString name READ name CONSTANT)
      Q_PROPERTY(bool live READ live NOTIFY liveChanged)
++    Q_PROPERTY(Qt::ScreenOrientation orientation READ orientation WRITE setOrientation NOTIFY orientationChanged DESIGNABLE false)
  public:
      enum Type {
@@ -64,6 +65,9 @@
      State state() const { return m_state; }
      QString name() const { return m_name; }
      bool live() const { return m_live; }
++    Qt::ScreenOrientation orientation() const { return m_orientation; }
++
++    void setOrientation(const Qt::ScreenOrientation orientation);
      void setSession(Session* item);
      void setScreenshot(const QUrl& screenshot);
@@ -76,6 +80,7 @@
      void typeChanged(Type);
      void stateChanged(State);
      void liveChanged(bool live);
++    void orientationChanged();
      void inputMethodRequested();
      void inputMethodDismissed();
@@ -104,6 +109,7 @@
      const Type m_type;
      State m_state;
      bool m_live;
++    Qt::ScreenOrientation m_orientation;
      QQmlComponent *m_qmlContentComponent;
      QQuickItem *m_qmlItem;
@@ -114,5 +120,6 @@
  Q_DECLARE_METATYPE(MirSurfaceItem*)
  Q_DECLARE_METATYPE(QList<MirSurfaceItem*>)
++Q_DECLARE_METATYPE(Qt::ScreenOrientation)
  #endif // MIRSURFACEITEM_H
 === modified file 'tests/mocks/Unity/Application/MirSurfaceItem.qml'
 --- tests/mocks/Unity/Application/MirSurfaceItem.qml	2014-08-18 16:59:08 +0000
 +++ tests/mocks/Unity/Application/MirSurfaceItem.qml	2014-09-12 19:54:38 +0000
@@ -21,12 +21,22 @@
      id: root
      color: "pink"
--    anchors.fill: parent
--
      implicitWidth: units.gu(40)
      implicitHeight: units.gu(70)
++    rotation: {
++        if (orientation == Qt.PortraitOrientation) return 0;
++        else if (orientation == Qt.LandscapeOrientation) return 90;
++        else if (orientation == Qt.InvertedPortraitOrientation) return 180;
++        else return 270;
++    }
++    x: parent ? (parent.width - width) / 2 : 0
++    y: parent ? (parent.height - height) / 2 : 0
++    width: parent ? (rotation == 0 || rotation == 180 ? parent.width : parent.height) : implicitWidth
++    height: parent ? (rotation == 0 || rotation == 180 ? parent.height : parent.width) : implicitHeight
++
      property alias screenshotSource: screenshotImage.source
++    property int orientation: Qt.PortraitOrientation
      property bool wantInputMethod: false
 === modified file 'tests/qmltests/Stages/tst_ApplicationWindow.qml'
 --- tests/qmltests/Stages/tst_ApplicationWindow.qml	2014-09-02 23:25:33 +0000
 +++ tests/qmltests/Stages/tst_ApplicationWindow.qml	2014-09-12 19:54:38 +0000
@@ -50,6 +50,7 @@
          ApplicationWindow {
              anchors.fill: parent
              application: fakeApplication
++            orientation: Qt.PortraitOrientation
+         }
+     }
      FocusScope {
@@ -147,6 +148,24 @@
+                 }
+             }
++            Button {
++                anchors { left: parent.left; right: parent.right }
++                text: "Rotate device \u27F3"
++                onClicked: {
++                    var orientation = applicationWindowLoader.item.orientation
++                    if (orientation == Qt.PortraitOrientation) {
++                        orientation = Qt.LandscapeOrientation;
++                    } else if (orientation == Qt.LandscapeOrientation) {
++                        orientation = Qt.InvertedPortraitOrientation;
++                    } else if (orientation == Qt.InvertedPortraitOrientation) {
++                        orientation = Qt.InvertedLandscapeOrientation;
++                    } else {
++                        orientation = Qt.PortraitOrientation;
++                    }
++                    applicationWindowLoader.item.orientation = orientation;
++                }
++            }
++
+         }
+     }
 === modified file 'tests/qmltests/Stages/tst_PhoneStage.qml'
 --- tests/qmltests/Stages/tst_PhoneStage.qml	2014-08-27 21:39:17 +0000
 +++ tests/qmltests/Stages/tst_PhoneStage.qml	2014-09-12 19:54:38 +0000
@@ -31,6 +31,8 @@
          anchors { fill: parent; rightMargin: units.gu(30) }
          dragAreaWidth: units.gu(2)
          maximizedAppTopMargin: units.gu(3) + units.dp(2)
++        interactive: true
++        orientation: Qt.PortraitOrientation
+     }
      Binding {
@@ -67,6 +69,21 @@
                      ApplicationManager.get(appList.selectedAppIndex).setState(ApplicationInfoInterface.Stopped);
+                 }
+             }
++            Button {
++                anchors { left: parent.left; right: parent.right }
++                text: "Rotate device \u27F3"
++                onClicked: {
++                    if (phoneStage.orientation == Qt.PortraitOrientation) {
++                        phoneStage.orientation = Qt.LandscapeOrientation;
++                    } else if (phoneStage.orientation == Qt.LandscapeOrientation) {
++                        phoneStage.orientation = Qt.InvertedPortraitOrientation;
++                    } else if (phoneStage.orientation == Qt.InvertedPortraitOrientation) {
++                        phoneStage.orientation = Qt.InvertedLandscapeOrientation;
++                    } else {
++                        phoneStage.orientation = Qt.PortraitOrientation;
++                    }
++                }
++            }
+         }
          ListView {
              id: appList
@@ -256,6 +273,46 @@
              compare(ApplicationManager.focusedApplicationId, selectedApp.appId);
+         }
++        function test_orientation_change_sent_to_focused_app() {
++            phoneStage.orientation = Qt.PortraitOrientation;
++            addApps(1);
++
++            var spreadView = findChild(phoneStage, "spreadView");
++            var app = findChild(spreadView, "appDelegate0");
++            tryCompare(app, "orientation", Qt.PortraitOrientation);
++
++            phoneStage.orientation = Qt.LandscapeOrientation;
++            tryCompare(app, "orientation", Qt.LandscapeOrientation);
++        }
++
++        function test_orientation_change_not_sent_to_apps_while_spread_open() {
++            phoneStage.orientation = Qt.PortraitOrientation;
++            addApps(1);
++
++            var spreadView = findChild(phoneStage, "spreadView");
++            var app = findChild(spreadView, "appDelegate0");
++            tryCompare(app, "orientation", Qt.PortraitOrientation);
++
++            goToSpread();
++            phoneStage.orientation = Qt.LandscapeOrientation;
++            tryCompare(app, "orientation", Qt.PortraitOrientation);
++        }
++
++        function test_orientation_change_not_sent_to_unfocused_app_until_it_focused() {
++            phoneStage.orientation = Qt.PortraitOrientation;
++            addApps(1);
++
++            var spreadView = findChild(phoneStage, "spreadView");
++            var app = findChild(spreadView, "appDelegate0");
++
++            goToSpread();
++            phoneStage.orientation = Qt.LandscapeOrientation;
++            tryCompare(app, "orientation", Qt.PortraitOrientation);
++
++            phoneStage.select(app.application.appId);
++            tryCompare(app, "orientation", Qt.LandscapeOrientation);
++        }
++
          function cleanup() {
              while (ApplicationManager.count > 1) {
                  var oldCount = ApplicationManager.count;
@@ -263,6 +320,7 @@
                  ApplicationManager.stopApplication(ApplicationManager.get(closingIndex).appId)
                  tryCompare(ApplicationManager, "count", oldCount - 1)
+             }
++            phoneStage.orientation = Qt.PortraitOrientation;
+         }
+     }
+ }
 === modified file 'tests/qmltests/Stages/tst_SessionContainer.qml'
 --- tests/qmltests/Stages/tst_SessionContainer.qml	2014-09-02 15:51:20 +0000
 +++ tests/qmltests/Stages/tst_SessionContainer.qml	2014-09-12 19:54:38 +0000
@@ -41,6 +41,7 @@
          SessionContainer {
              id: sessionContainer
              anchors.fill: parent
++            orientation: Qt.PortraitOrientation
+         }
+     }
@@ -112,6 +113,24 @@
                      session: sessionContainerLoader.item ? sessionContainerLoader.item.session : null
+                 }
+             }
++
++            Button {
++                anchors { left: parent.left; right: parent.right }
++                text: "Rotate device \u27F3"
++                onClicked: {
++                    var orientation = sessionContainerLoader.item.orientation
++                    if (orientation == Qt.PortraitOrientation) {
++                        orientation = Qt.LandscapeOrientation;
++                    } else if (orientation == Qt.LandscapeOrientation) {
++                        orientation = Qt.InvertedPortraitOrientation;
++                    } else if (orientation == Qt.InvertedPortraitOrientation) {
++                        orientation = Qt.InvertedLandscapeOrientation;
++                    } else {
++                        orientation = Qt.PortraitOrientation;
++                    }
++                    sessionContainerLoader.item.orientation = orientation;
++                }
++            }
+         }
+     }
@@ -263,5 +282,49 @@
              // wait for animation to end
              tryCompareFunction(function() { return isContainerAnimating(childContainer); }, false);
+         }
++
++        function test_orientationPropagatedToChildren_data() {
++            return [ { tag: "count=1", count: 1 },
++                     { tag: "count=4", count: 4 } ];
++        }
++
++        /* Test orientation changes are propagated to all children immediately */
++        function test_orientationPropagatedToChildren(data) {
++            sessionCheckbox.checked = true;
++            var rootSessionContainer = sessionContainerLoader.item;
++            compare(rootSessionContainer.childSessions.count(), 0);
++
++            var i;
++            var sessions = [];
++            for (i = 0; i < data.count; i++) {
++                var session = ApplicationTest.addChildSession(rootSessionContainer.session,
++                                                              "gallery");
++                session.createSurface();
++                rootSessionContainer.session.addChildSession(session);
++
++                // Check child SessionContainer has orientation matching the parent
++                var delegate = findChild(rootSessionContainer, "childDelegate" + i);
++                var childSessionContainer = findChild(delegate, "sessionContainer");
++
++                tryCompare(rootSessionContainer, "orientation", childSessionContainer.orientation);
++
++                sessions.push(session);
++            }
++
++            // Change orientation and verify all children updated
++            rootSessionContainer.orientation = Qt.LandscapeOrientation;
++
++            for (i = 0; i < data.count; i++) {
++                var delegate = findChild(rootSessionContainer, "childDelegate" + i);
++                var childSessionContainer = findChild(delegate, "sessionContainer");
++
++                tryCompare(rootSessionContainer, "orientation", childSessionContainer.orientation);
++            }
++
++            // Clean up
++            for (i = data.count-1; i >= 0; i--) {
++                ApplicationTest.removeSession(sessions[i]);
++            }
++        }
+     }
+ }