Merge lp:~zeller-benjamin/ubuntu-ui-toolkit/trusty-builds into lp:ubuntu-ui-toolkit

[Benjamin Zeller]

- Some out of source build fixes
- Implicit casting of QPointer<QObject> to QObject* does not work on trusty

- Some out of source build fixes
- Implicit casting of QPointer<QObject> to QObject* does not work on trusty

Unmerged revisions

2090. By Benjamin Zeller on 2016-09-03

Implicit casting of QPointer<QObject> to QObject* does not work on trusty

2089. By Benjamin Zeller on 2016-09-03

Fix out of source builds

=== modified file 'apicheck/apicheck.pro'
--- apicheck/apicheck.pro	2016-01-22 09:31:54 +0000
+++ apicheck/apicheck.pro	2016-09-03 13:06:01 +0000
@@ -4,7 +4,5 @@
 QT += core-private gui-private testlib quick-private
 CONFIG += no_keywords
 SOURCES += apicheck.cpp
-installPath = $$[QT_INSTALL_LIBS]/ubuntu-ui-toolkit
-apicheck.path = $$installPath
-apicheck.files = apicheck
-INSTALLS += $$TARGET
+target.path = $$[QT_INSTALL_LIBS]/ubuntu-ui-toolkit 
+INSTALLS += target

=== modified file 'app-launch-profiler/app-launch-tracepoints.c'
--- app-launch-profiler/app-launch-tracepoints.c	2016-08-16 08:43:28 +0000
+++ app-launch-profiler/app-launch-tracepoints.c	2016-09-03 13:06:01 +0000
@@ -28,8 +28,8 @@
 
 int main (int argc, char* argv[])
 {
-    #pragma unused(argc)
-    #pragma unused(argv)
+    (void)argc;
+    (void)argv;
     tracepoint(app,invokeApplauncher);
     return 0;
 }

=== modified file 'components.api'
--- components.api	2016-08-09 03:48:53 +0000
+++ components.api	2016-09-03 13:06:01 +0000
@@ -10,13 +10,17 @@
     readonly property bool pressed
     readonly property UCMargins sensingMargins
 Ubuntu.Components.Action 1.3 1.0 0.1 UCAction: QtObject
+    property bool checkable 1.3
+    property bool checked 1.3
     property string description
     property bool enabled
+    property ExclusiveGroup exclusiveGroup 1.3
     property string iconName
     property url iconSource
     property Component itemHint
     property string keywords
     signal triggered(var value)
+    signal toggled(bool value) 1.3
     function trigger(var value)
     function trigger()
     property string name
@@ -59,9 +63,12 @@
 Ubuntu.Components.ActionList 1.0 0.1: QtObject
     property list<Action> actions
     default property list<Action> children
-Ubuntu.Components.ActionList 1.3: QtObject
-    property list<Action> actions
-    default property list<Action> children
+Ubuntu.Components.ActionList 1.3 ActionList: QtObject
+    default property list<Action> actions
+    signal added(Action action)
+    signal removed(Action action)
+    function addAction(Action action)
+    function removeAction(Action action)
 Ubuntu.Components.ActionManager 1.0 0.1 UCActionManager: QtObject
     default property list<Action> actions
     readonly property ActionContext globalContext
@@ -458,6 +465,10 @@
     OperationPending
 Ubuntu.Metrics.Event: Enum
     UserInterfaceReady
+Ubuntu.Components.ExclusiveGroup 1.3 ExclusiveGroup: ActionList
+    readonly property QtObject current
+    function bindCheckable(QtObject object)
+    function unbindCheckable(QtObject object)
 Ubuntu.Components.ListItems.Expandable 1.0 0.1: Empty
     property bool collapseOnClick
     property double collapsedHeight

=== modified file 'debian/control'
--- debian/control	2016-08-18 16:51:24 +0000
+++ debian/control	2016-09-03 13:06:01 +0000
@@ -77,6 +77,7 @@
          qml-module-qtquick-layouts,
          qml-module-qtquick-window2,
          qml-module-qtquick2,
+         qml-module-ubuntu-components-labs,
          qml-module-ubuntu-performancemetrics,
          qtdeclarative5-unity-action-plugin (>= 1.1.0),
          suru-icon-theme,

=== modified file 'debian/control.gles'
--- debian/control.gles	2016-07-28 10:54:13 +0000
+++ debian/control.gles	2016-09-03 13:06:01 +0000
@@ -103,6 +103,7 @@
          qml-module-qtquick-layouts,
          qml-module-qtquick-window2,
          qml-module-qtquick2,
+         qml-module-ubuntu-components-labs,
          qml-module-ubuntu-performancemetrics-gles,
          qtdeclarative5-unity-action-plugin (>= 1.1.0),
          suru-icon-theme,

=== modified file 'debian/libubuntugestures5-dev.install'
--- debian/libubuntugestures5-dev.install	2016-07-06 11:27:11 +0000
+++ debian/libubuntugestures5-dev.install	2016-09-03 13:06:01 +0000
@@ -5,7 +5,6 @@
 usr/include/*/qt5/UbuntuGestures/ubuntugesturesglobal.h
 usr/include/*/qt5/UbuntuGestures/ubuntugesturesmodule.h
 usr/include/*/qt5/UbuntuGestures/ubuntugesturesversion.h
-usr/lib/*/libUbuntuGestures.la
 usr/lib/*/libUbuntuGestures.prl
 usr/lib/*/libUbuntuGestures.so
 usr/lib/*/pkgconfig/UbuntuGestures.pc

=== modified file 'debian/libubuntumetrics5-dev.install'
--- debian/libubuntumetrics5-dev.install	2016-07-26 16:33:27 +0000
+++ debian/libubuntumetrics5-dev.install	2016-09-03 13:06:01 +0000
@@ -6,7 +6,6 @@
 usr/include/*/qt5/UbuntuMetrics/logger.h
 usr/include/*/qt5/UbuntuMetrics/ubuntumetricsglobal.h
 usr/include/*/qt5/UbuntuMetrics/ubuntumetricsversion.h
-usr/lib/*/libUbuntuMetrics.la
 usr/lib/*/libUbuntuMetrics.prl
 usr/lib/*/libUbuntuMetrics.so
 usr/lib/*/pkgconfig/UbuntuMetrics.pc

=== modified file 'debian/libubuntutoolkit5-dev.install'
--- debian/libubuntutoolkit5-dev.install	2016-07-07 07:21:48 +0000
+++ debian/libubuntutoolkit5-dev.install	2016-09-03 13:06:01 +0000
@@ -5,7 +5,6 @@
 usr/include/*/qt5/UbuntuToolkit/ubuntutoolkitglobal.h
 usr/include/*/qt5/UbuntuToolkit/ubuntutoolkitmodule.h
 usr/include/*/qt5/UbuntuToolkit/ubuntutoolkitversion.h
-usr/lib/*/libUbuntuToolkit.la
 usr/lib/*/libUbuntuToolkit.prl
 usr/lib/*/libUbuntuToolkit.so
 usr/lib/*/pkgconfig/UbuntuToolkit.pc

=== modified file 'debian/rules'
--- debian/rules	2016-07-07 18:47:22 +0000
+++ debian/rules	2016-09-03 13:06:01 +0000
@@ -43,6 +43,7 @@
 	mkdir -p debian/tmp/`qmake -query QT_INSTALL_DOCS`/qch
 	mkdir -p debian/tmp/usr/share/ubuntu-ui-toolkit/doc
 	cp -r $(CURDIR)/documentation/*qch debian/tmp/`qmake -query QT_INSTALL_DOCS`/qch
+	rm -f debian/tmp/usr/lib/$(DEB_HOST_MULTIARCH)/*.la
 	# FIXME: Due to autopilot not being in the archive we ship docs for now
 	# sphinx-build -b singlehtml documentation/autopilot-helpers documentation/autopilot-helpers/_build/html
 	# sphinx-build -b json documentation/autopilot-helpers documentation/autopilot-helpers/_build/json

=== modified file 'documentation/overview.qdoc'
--- documentation/overview.qdoc	2016-07-27 15:40:52 +0000
+++ documentation/overview.qdoc	2016-09-03 13:06:01 +0000
@@ -129,6 +129,22 @@
      \endcode
      \annotatedlist ubuntu-services
 
+     \part Performance Metrics
+     Available through:
+     \code
+         import Ubuntu.PerformanceMetrics 1.0
+     \endcode
+     \annotatedlist ubuntu-performance-metrics
+
+     \part Labs
+     The Labs module contains a set of components which have unstable API. Those
+     should not be used in applications as their interface may change any time.
+     Available through:
+     \code
+         import Ubuntu.Components.Labs 1.0
+     \endcode
+     \annotatedlist ubuntu-labs
+
      \part Test extensions
      Available through:
      \code

=== modified file 'src/Ubuntu/Components/1.2/ActivityIndicator.qml'
--- src/Ubuntu/Components/1.2/ActivityIndicator.qml	2016-08-17 14:42:42 +0000
+++ src/Ubuntu/Components/1.2/ActivityIndicator.qml	2016-09-03 13:06:01 +0000
@@ -52,5 +52,10 @@
     */
     property bool running: false
 
+    implicitWidth: units.gu(3)
+    implicitHeight: units.gu(3)
+    width: units.gu(3)
+    height: units.gu(3)
+
     style: Theme.createStyleComponent("ActivityIndicatorStyle.qml", indicator)
 }

=== removed file 'src/Ubuntu/Components/1.3/ActionList.qml'
--- src/Ubuntu/Components/1.3/ActionList.qml	2016-05-25 12:48:10 +0000
+++ src/Ubuntu/Components/1.3/ActionList.qml	1970-01-01 00:00:00 +0000
@@ -1,47 +0,0 @@
-/*
- * Copyright 2012 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 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 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/>.
- */
-
-import QtQuick 2.4
-import Ubuntu.Components 1.3
-
-/*!
-    \qmltype ActionList
-    \inqmlmodule Ubuntu.Components
-    \ingroup ubuntu
-    \brief List of \l Action items
-*/
-
-QtObject {
-    id: list
-    // internal objects using nested elements,
-    // which isn't allowed by QtObject; this fix makes this possible
-    /*!
-      Default property to allow adding of children.
-      \qmlproperty list<Action> children
-      \default
-      */
-    default property alias children: list.actions
-
-    /*!
-      List of already defined actions when not defining them as children of the ActionList.
-      Note that when you set this property, the children of the ActionList will be ignored,
-      so do not set the list and define children.
-
-      The advantage of setting actions over using the children is that the same
-      \l Action items can be used in several sets of actions.
-      */
-    property list<Action> actions
-}

=== modified file 'src/Ubuntu/Components/1.3/ActivityIndicator.qml'
--- src/Ubuntu/Components/1.3/ActivityIndicator.qml	2016-08-17 14:42:42 +0000
+++ src/Ubuntu/Components/1.3/ActivityIndicator.qml	2016-09-03 13:06:01 +0000
@@ -52,5 +52,10 @@
     */
     property bool running: false
 
+    implicitWidth: units.gu(3)
+    implicitHeight: units.gu(3)
+    width: units.gu(3)
+    height: units.gu(3)
+
     styleName: "ActivityIndicatorStyle"
 }

=== modified file 'src/Ubuntu/Components/ComponentModule.pro'
--- src/Ubuntu/Components/ComponentModule.pro	2016-07-29 13:21:05 +0000
+++ src/Ubuntu/Components/ComponentModule.pro	2016-09-03 13:06:01 +0000
@@ -78,7 +78,6 @@
 
 #1.3
 QML_FILES += 1.3/ActionBar.qml \
-             1.3/ActionList.qml \
              1.3/ActivityIndicator.qml \
 	     1.3/AdaptivePageLayout.qml \
              1.3/AnimatedItem.qml \

=== modified file 'src/Ubuntu/Components/Popups/1.3/Popover.qml'
--- src/Ubuntu/Components/Popups/1.3/Popover.qml	2016-03-17 17:40:51 +0000
+++ src/Ubuntu/Components/Popups/1.3/Popover.qml	2016-09-03 13:06:01 +0000
@@ -33,9 +33,8 @@
     \qml
         import QtQuick 2.4
         import Ubuntu.Components 1.3
-        import Ubuntu.Components.ListItems 1.3 as ListItem
         import Ubuntu.Components.Popups 1.3
-
+        import Ubuntu.Components.ListItems 1.3 as Old_ListItem
         Rectangle {
             color: theme.palette.normal.background
             width: units.gu(80)
@@ -52,29 +51,35 @@
                             top: parent.top
                             right: parent.right
                         }
-                        ListItem.Header { text: "Standard list items" }
-                        ListItem.Standard { text: "Do something" }
-                        ListItem.Standard { text: "Do something else" }
-                        ListItem.Header { text: "Buttons" }
-                        ListItem.SingleControl {
-                            highlightWhenPressed: false
-                            control: Button {
-                                text: "Do nothing"
-                                anchors {
-                                    fill: parent
-                                    margins: units.gu(1)
-                                }
-                            }
-                        }
-                        ListItem.SingleControl {
-                            highlightWhenPressed: false
-                            control: Button {
-                                text: "Close"
-                                anchors {
-                                    fill: parent
-                                    margins: units.gu(1)
-                                }
-                                onClicked: PopupUtils.close(popover)
+
+                        // there is no equivalent yet to ListItem.Header
+                        Old_ListItem.Header { text: "Standard list items" }
+
+                        ListItem {
+                            // shall specify the height when Using ListItemLayout inside ListItem
+                            height: somethingLayout.height + (divider.visible ? divider.height : 0)
+                            ListItemLayout {
+                                id: somethingLayout
+                                title.text: "Do somethings"
+                            }
+                            onClicked: console.log("clicked on ListItem with onClicked implemented")
+                        }
+                        ListItem {
+                            // shall specify the height when Using ListItemLayout inside ListItem
+                            height: somethingElseLayout.height + (divider.visible ? divider.height : 0)
+                            ListItemLayout {
+                                id: somethingElseLayout
+                                title.text: "Do somethings"
+                                subtitle.text: "else"
+                            }
+                        }
+                        ListItem {
+                            // shall specify the height when Using ListItemLayout inside ListItem
+                            height: closeBtn.height + (divider.visible ? divider.height : 0)
+                            Button {
+                                id: closeBtn
+                                text: "Close button"
+                                onClicked: PopupUtils.close(popover);
                             }
                         }
                     }

=== modified file 'src/Ubuntu/Components/Popups/1.3/popupUtils.js'
--- src/Ubuntu/Components/Popups/1.3/popupUtils.js	2016-04-13 19:32:20 +0000
+++ src/Ubuntu/Components/Popups/1.3/popupUtils.js	2016-09-03 13:06:01 +0000
@@ -60,6 +60,11 @@
         return null;
     }
 
+    if (!rootObject) {
+        print("PopupUtils.open(): Failed to get the root object.");
+        return null;
+    }
+
     var popupObject;
     if (params !== undefined) {
         popupObject = popupComponent.createObject(rootObject, params);

=== modified file 'src/Ubuntu/Components/Themes/Ambiance/1.2/ActivityIndicatorStyle.qml'
--- src/Ubuntu/Components/Themes/Ambiance/1.2/ActivityIndicatorStyle.qml	2016-08-17 14:42:42 +0000
+++ src/Ubuntu/Components/Themes/Ambiance/1.2/ActivityIndicatorStyle.qml	2016-09-03 13:06:01 +0000
@@ -20,8 +20,6 @@
 Image {
     id: container
 
-    implicitWidth: units.gu(3)
-    implicitHeight: units.gu(3)
     smooth: true
     visible: styledItem.running
     fillMode: Image.PreserveAspectFit

=== modified file 'src/Ubuntu/Components/Themes/Ambiance/1.3/ActivityIndicatorStyle.qml'
--- src/Ubuntu/Components/Themes/Ambiance/1.3/ActivityIndicatorStyle.qml	2016-08-17 14:42:42 +0000
+++ src/Ubuntu/Components/Themes/Ambiance/1.3/ActivityIndicatorStyle.qml	2016-09-03 13:06:01 +0000
@@ -20,8 +20,6 @@
 Image {
     id: container
 
-    implicitWidth: units.gu(3)
-    implicitHeight: units.gu(3)
     smooth: true
     visible: styledItem.running && styledItem.visible
     fillMode: Image.PreserveAspectFit

=== modified file 'src/Ubuntu/Components/Themes/Ambiance/1.3/ScrollbarStyle.qml'
--- src/Ubuntu/Components/Themes/Ambiance/1.3/ScrollbarStyle.qml	2016-08-02 11:18:34 +0000
+++ src/Ubuntu/Components/Themes/Ambiance/1.3/ScrollbarStyle.qml	2016-09-03 13:06:01 +0000
@@ -316,7 +316,9 @@
         property string propPosRatio: (isVertical) ? "yPosition" : "xPosition"
         property string propSizeRatio: (isVertical) ? "heightRatio" : "widthRatio"
         property string propCoordinate: (isVertical) ? "y" : "x"
+        property string otherPropCoordinate: (isVertical) ? "x" : "y"
         property string propSize: (isVertical) ? "height" : "width"
+        property string otherPropSize: (isVertical) ? "width" : "height"
         property string propAtBeginning: (isVertical) ? "atYBeginning" : "atXBeginning"
         property string propAtEnd: (isVertical) ? "atYEnd" : "atXEnd"
 
@@ -622,8 +624,6 @@
                     property bool lockDrag: false
 
                     property bool hoveringThumb: false
-                    property string scrollingProp: isVertical ? "y" : "x"
-                    property string sizeProp: isVertical ? "height" : "width"
 
                     function initDrag(isMouse) {
                         __disableStateBinding = true
@@ -648,20 +648,29 @@
                         if (!thumbArea.pressed) return
 
                         var mouseScrollingProp = isVertical ? mouseY : mouseX
-                        if (mouseScrollingProp < slider[scrollingProp]) {
+                        if (mouseScrollingProp < slider[scrollbarUtils.propCoordinate]) {
                             scrollBy(-pageSize*visuals.longScrollingRatio, true)
-                        } else if (mouseScrollingProp > slider[scrollingProp] + slider[sizeProp]) {
+                        } else if (mouseScrollingProp > slider[scrollbarUtils.propCoordinate] + slider[scrollbarUtils.propSize]) {
                             scrollBy(pageSize*visuals.longScrollingRatio, true)
                         }
                     }
 
+                    //we consider hover if it's inside the TROUGH along the scrolling axis
+                    //and inside the THUMB along the non-scrolling axis
+                    //NOTE: mouseX and mouseY are assumed to be relative to thumbArea
                     function handleHover(mouseX, mouseY) {
+                        //NOTE: we're assuming thumbArea has same size/position as the trough.
+                        //Use mapToItem to map the coordinates if that assumption falls (i.e. to implement
+                        //a larger touch detection area around the thumb)
                         var mouseScrollingProp = isVertical ? mouseY : mouseX
-                        //don't count as hover if the user is already press-and-holding the trough to
-                        //scroll page by page
+                        var otherProp = isVertical ? mouseX : mouseY
+
+                        //don't count as hover if the user is already press-and-holding
+                        //the trough to scroll page by page
                         hoveringThumb = !(pressHoldTimer.running && pressHoldTimer.startedBy === thumbArea)
-                                && mouseScrollingProp >= slider[scrollingProp] &&
-                                mouseScrollingProp <= slider[scrollingProp] + slider[sizeProp]
+                                && mouseScrollingProp >= slider[scrollbarUtils.propCoordinate] &&
+                                mouseScrollingProp <= slider[scrollbarUtils.propCoordinate] + slider[scrollbarUtils.propSize] &&
+                                otherProp >= 0 && otherProp <= trough[scrollbarUtils.otherPropSize]
                     }
 
                     function saveFlickableScrollingState() {
@@ -691,14 +700,9 @@
                         previousY = mouse.y
                     }
 
-                    anchors {
-                        fill: trough
-                        // set margins adding 2 dp for error area
-                        leftMargin: (!isVertical || frontAligned) ? 0 : units.dp(-2)
-                        rightMargin: (!isVertical || rearAligned) ? 0 : units.dp(-2)
-                        topMargin: (isVertical || topAligned) ?  0 : units.dp(-2)
-                        bottomMargin: (isVertical || bottomAligned) ?  0 : units.dp(-2)
-                    }
+                    //NOTE: remember to update the handleHover check if you add anchor margins
+                    anchors.fill: trough
+
                     enabled: isScrollable && interactive && __canFitSteppersAndShorterThumb
                     onPressed: {
                         cacheMousePosition(mouse)
@@ -710,8 +714,8 @@
                         if (firstStepper.visible) {
                             var mouseScrollingProp = isVertical ? mouseY : mouseX
                             //don't start the press and hold timer to avoid conflicts with the drag
-                            if (mouseScrollingProp < slider[scrollingProp] ||
-                                    mouseScrollingProp > (slider[scrollingProp] + slider[sizeProp])) {
+                            if (mouseScrollingProp < slider[scrollbarUtils.propCoordinate] ||
+                                    mouseScrollingProp > (slider[scrollbarUtils.propCoordinate] + slider[scrollbarUtils.propSize])) {
                                 handlePress(mouseX, mouseY)
                                 pressHoldTimer.startTimer(thumbArea)
                             } else {
@@ -761,7 +765,8 @@
                         pressHoldTimer.stop()
                     }
                     onReleased: {
-                        handleHover(mouseX, mouseY)
+                        //don't call handleHover here as touch release also triggers this handler
+                        //see bug #1616868
                         resetDrag()
                         pressHoldTimer.stop()
                     }
@@ -797,18 +802,29 @@
 
                     //logic to support different colour on hovering
                     hoverEnabled: true
+                    //This means this mouse filter will only handle real mouse events!
+                    //i.e. the synthesized mouse events created when you use
+                    //touchscreen will not trigger it! This way we can have logic that
+                    //will not trigger when using touch
+                    Mouse.ignoreSynthesizedEvents: true
                     Mouse.enabled: true
-                    Mouse.ignoreSynthesizedEvents: true
                     Mouse.onEntered: {
                         hoveringThumb = false
                         handleHover(event.x, event.y)
                     }
                     Mouse.onPositionChanged: {
+                        //We need to update the hover state also onPosChanged because this area
+                        //covers the whole trough, not just the thumb, so entered/exited are not enough
+                        //e.g. when mouse moves from inside the thumb to inside the trough, or when you
+                        //click on the trough and the thumb scrolls and goes under the mouse cursor
                         handleHover(mouse.x, mouse.y)
                     }
                     Mouse.onExited: {
                         hoveringThumb = false
                     }
+                    Mouse.onReleased: {
+                        handleHover(mouse.x, mouse.y)
+                    }
 
                     Timer {
                         id: pressHoldTimer
@@ -845,6 +861,7 @@
 
             MouseArea {
                 id: steppersMouseArea
+                objectName: "steppersMouseArea"
                 //size is handled by the states
 
                 property bool hoveringFirstStepper: false
@@ -897,12 +914,7 @@
                     hoveringFirstStepper = false
                     hoveringSecondStepper = false
                 }
-
-                //We don't change the size of the images because we let the image reader figure the size out,
-                //though that means we have to hide the images somehow while the mousearea is visible but has
-                //null size. We choose to enable clipping here instead of creating bindings on images' visible prop
-                clip: true
-                onPressed: {
+                Mouse.onPressed: {
                     //This additional trigger of the hovering logic is useful especially in testing
                     //environments, where simulating a click on the first stepper will generate onEntered,
                     //but then clicking on the second one (without a mouseMove) won't, because they're
@@ -910,7 +922,16 @@
                     //we ensure that the hovering logic is correct even when there are no mouse moves between
                     //clicks on different steppers (like it happens in tst_actionSteppers test).
                     handleHover(mouse)
+                }
+                Mouse.onReleased: {
+                    handleHover(mouse)
+                }
 
+                //We don't change the size of the images because we let the image reader figure the size out,
+                //though that means we have to hide the images somehow while the mousearea is visible but has
+                //null size. We choose to enable clipping here instead of creating bindings on images' visible prop
+                clip: true
+                onPressed: {
                     handlePress()
                     pressHoldTimer.startTimer(steppersMouseArea)
                 }
@@ -952,7 +973,7 @@
                         anchors.centerIn: parent
                         width: __stepperAssetWidth
                         rotation: isVertical ? 180 : 90
-                        //NOTE: Qt.resolvedUrl was removed because it does not seem to be needed and 
+                        //NOTE: Qt.resolvedUrl was removed because it does not seem to be needed and
                         //the QML profiler showed it's relatively expensive
                         source: visible ? "../artwork/toolkit_scrollbar-stepper.svg" : ""
                         asynchronous: true
@@ -998,7 +1019,7 @@
                         anchors.centerIn: parent
                         width: __stepperAssetWidth
                         rotation: isVertical ? 0 : -90
-                        //NOTE: Qt.resolvedUrl was removed because it does not seem to be needed and     
+                        //NOTE: Qt.resolvedUrl was removed because it does not seem to be needed and
                         //the QML profiler showed it's relatively expensive
                         source: visible ? "../artwork/toolkit_scrollbar-stepper.svg" : ""
                         asynchronous: true

=== added file 'src/Ubuntu/Components/Themes/Ambiance/1.3/ScrollingActionBarStyle.qml'
--- src/Ubuntu/Components/Themes/Ambiance/1.3/ScrollingActionBarStyle.qml	1970-01-01 00:00:00 +0000
+++ src/Ubuntu/Components/Themes/Ambiance/1.3/ScrollingActionBarStyle.qml	2016-09-03 13:06:01 +0000
@@ -0,0 +1,203 @@
+/*
+ * Copyright 2016 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 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 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/>.
+ */
+import QtQuick 2.4
+import Ubuntu.Components 1.3
+import Ubuntu.Components.Styles 1.3 as Style
+
+Style.ActionBarStyle {
+    id: actionBarStyle
+    implicitHeight: units.gu(5)
+
+    clip: true // avoid showing the icons that are scrolled out of the view.
+    backgroundColor: theme.palette.normal.background
+    buttons {
+        foregroundColor: theme.palette.normal.backgroundText
+        pressedForegroundColor: buttons.foregroundColor
+        disabledForegroundColor: theme.palette.disabled.backgroundText
+        backgroundColor: "transparent" // background is already colored
+        pressedBackgroundColor: theme.palette.highlighted.background
+        disabledBackgroundColor: buttons.backgroundColor
+    }
+
+    property QtObject scrollButtons: Style.ActionItemProperties {
+        foregroundColor: actionBarStyle.buttons.foregroundColor
+        pressedForegroundColor: actionBarStyle.buttons.pressedForegroundColor
+        backgroundColor: actionBarStyle.backgroundColor // must be opaque to hide the icon buttons
+        pressedBackgroundColor: actionBarStyle.buttons.pressedBackgroundColor
+        property real width: units.gu(4)
+        property int fadeDuration: UbuntuAnimation.FastDuration
+    }
+
+    /*!
+      The default action delegate if the styled item does
+      not provide a delegate.
+     */
+    // FIXME: This ListItem { AbstractButton { } } construction can be avoided
+    //  when StyledItem supports cursor keys navigation, see bug #1573616.
+    // FIXME: For the first and last item in the list, it is possible to move
+    //  the focus inside the ListItem to the AbstractButton, see bug #1590005.
+    // FIXME: Focus can go on disabled item. See bug #1611327.
+    defaultDelegate: ListItem {
+        width: units.gu(4)
+        height: actionBarStyle.height
+        enabled: modelData.enabled
+        objectName: modelData.objectName + "_button"
+        AbstractButton {
+            id: button
+            anchors.fill: parent
+            style: IconButtonStyle {
+                foregroundColor: button.pressed ?
+                                     actionBarStyle.buttons.pressedForegroundColor :
+                                     button.enabled ?
+                                         actionBarStyle.buttons.foregroundColor :
+                                         actionBarStyle.buttons.disabledForegroundColor
+                backgroundColor: button.pressed ?
+                                     actionBarStyle.buttons.pressedBackgroundColor :
+                                     button.enabled ?
+                                         actionBarStyle.buttons.backgroundColor :
+                                         actionBarStyle.buttons.disabledBackgroundColor
+            }
+            action: modelData
+            activeFocusOnTab: false
+        }
+        divider.visible: false
+    }
+
+    Rectangle {
+        color: actionBarStyle.backgroundColor
+        id: listViewContainer
+        anchors.fill: parent
+
+        property var visibleActions: getVisibleActions(styledItem.actions)
+        function getVisibleActions(actions) {
+            var visibleActionList = [];
+            for (var i = 0; i < actions.length; i++) {
+                var action = actions[i];
+                if (action && action.hasOwnProperty("visible") && action.visible) {
+                    visibleActionList.push(action);
+                }
+            }
+            return visibleActionList;
+        }
+
+        ListView {
+            id: actionsListView
+            objectName: "actions_listview"
+            anchors {
+                right: parent.right
+                top: parent.top
+                bottom: parent.bottom
+                rightMargin: scrollButtons.width
+            }
+            displayMarginBeginning: scrollButtons.width
+            displayMarginEnd: scrollButtons.width
+            leftMargin: -scrollButtons.width
+            rightMargin: -scrollButtons.width
+            width: listViewContainer.width - 2*scrollButtons.width
+            layoutDirection: Qt.RightToLeft
+
+            orientation: ListView.Horizontal
+            boundsBehavior: Flickable.StopAtBounds
+            delegate: styledItem.delegate
+            model: listViewContainer.visibleActions
+
+            // This gives the correct behavior when scrollButtons.width is
+            //  larger/smaller/equal compared to the width of the delegate.
+            onCurrentIndexChanged: positionViewAtIndex(currentIndex, ListView.Contain)
+
+            SmoothedAnimation {
+                objectName: "actions_scroll_animation"
+                id: contentXAnim
+                target: actionsListView
+                property: "contentX"
+                duration: UbuntuAnimation.FastDuration
+            }
+
+            // direction == 1 to show more icons on the left
+            // direction == -1 to show more icons on the right
+            function scroll(direction) {
+                if (contentXAnim.running) contentXAnim.stop();
+                var newContentX = actionsListView.contentX - (actionsListView.width * direction);
+                contentXAnim.from = actionsListView.contentX;
+                // make sure we don't overshoot bounds
+                contentXAnim.to = MathUtils.clamp(
+                            newContentX,
+                            originX + scrollButtons.width,
+                            actionsListView.originX + actionsListView.contentWidth
+                            - actionsListView.width - scrollButtons.width);
+                contentXAnim.start();
+            }
+        }
+
+        Component {
+            id: scrollButtonComponent
+            AbstractButton {
+                id: scrollButton
+                width: actionBarStyle.scrollButtons.width
+                enabled: opacity === 1.0
+                onClicked: actionsListView.scroll(scrollDirection)
+                opacity: buttonOpacity
+                objectName: buttonName
+                Behavior on opacity {
+                    UbuntuNumberAnimation {
+                        duration: actionBarStyle.scrollButtons.fadeDuration
+                    }
+                }
+                Rectangle {
+                    anchors.fill: parent
+                    color: scrollButton.pressed ? actionBarStyle.scrollButtons.pressedBackgroundColor
+                                                : actionBarStyle.scrollButtons.backgroundColor
+                }
+                Icon {
+                    // FIXME: Use new theme icon from
+                    //  https://code.launchpad.net/~tiheum/ubuntu-themes/toolkit-arrows/+merge/298609
+                    //  after it lands in overlay and archive.
+                    anchors.centerIn: parent
+                    width: units.gu(1)
+                    height: units.gu(1)
+                    rotation: iconRotation
+                    name: "chevron"
+                    color: scrollButton.pressed ? actionBarStyle.scrollButtons.pressedForegroundColor
+                                                : actionBarStyle.scrollButtons.foregroundColor
+                }
+            }
+        }
+        Loader {
+            anchors {
+                left: parent.left
+                top: parent.top
+                bottom: parent.bottom
+            }
+            sourceComponent: scrollButtonComponent
+            property int iconRotation: 180
+            property real buttonOpacity: actionsListView.atXBeginning ? 0.0 : 1.0
+            property int scrollDirection: 1
+            property string buttonName: "leading_scroll_button"
+        }
+        Loader {
+            anchors {
+                right: parent.right
+                top: parent.top
+                bottom: parent.bottom
+            }
+            sourceComponent: scrollButtonComponent
+            property int iconRotation: 0
+            property real buttonOpacity: actionsListView.atXEnd ? 0.0 : 1.0
+            property int scrollDirection: -1
+            property string buttonName: "trailing_scroll_button"
+        }
+    }
+}

=== modified file 'src/Ubuntu/Components/Themes/Ambiance/Ambiance.pro'
--- src/Ubuntu/Components/Themes/Ambiance/Ambiance.pro	2016-04-21 11:34:55 +0000
+++ src/Ubuntu/Components/Themes/Ambiance/Ambiance.pro	2016-09-03 13:06:01 +0000
@@ -103,6 +103,7 @@
              1.3/ProgressionVisualStyle.qml \
              1.3/PullToRefreshStyle.qml \
              1.3/ScrollbarStyle.qml \
+             1.3/ScrollingActionBarStyle.qml \
              1.3/SectionsStyle.qml \
              1.3/SheetForegroundStyle.qml \
              1.3/SliderStyle.qml \

=== modified file 'src/Ubuntu/Components/Themes/Ambiance/qmldir'
--- src/Ubuntu/Components/Themes/Ambiance/qmldir	2016-02-19 11:18:51 +0000
+++ src/Ubuntu/Components/Themes/Ambiance/qmldir	2016-09-03 13:06:01 +0000
@@ -59,6 +59,7 @@
 #version 1.3
 AmbianceNormal 1.3 ./1.3/AmbianceNormal.qml
 ActionBarStyle 1.3 ./1.3/ActionBarStyle.qml
+ScrollingActionBarStyle 1.3 ./1.3/ScrollingActionBarStyle.qml
 MainViewStyle 1.3 ./1.3/MainViewStyle.qml
 ListItemOptionSelector 1.3 ./1.3/ListItemOptionSelector.qml
 OptionSelectorStyle 1.3 ./1.3/OptionSelectorStyle.qml

=== modified file 'src/Ubuntu/Components/qmldir'
--- src/Ubuntu/Components/qmldir	2016-07-29 13:21:05 +0000
+++ src/Ubuntu/Components/qmldir	2016-09-03 13:06:01 +0000
@@ -96,7 +96,6 @@
 #################################################
 #version 1.3
 ActionBar 1.3 1.3/ActionBar.qml
-ActionList 1.3 1.3/ActionList.qml
 AdaptivePageLayout 1.3 1.3/AdaptivePageLayout.qml
 PageColumnsLayout 1.3 1.3/PageColumnsLayout.qml
 PageColumn 1.3 1.3/PageColumn.qml

=== modified file 'src/Ubuntu/Test/UbuntuTestCase13.qml'
--- src/Ubuntu/Test/UbuntuTestCase13.qml	2016-03-15 13:17:53 +0000
+++ src/Ubuntu/Test/UbuntuTestCase13.qml	2016-09-03 13:06:01 +0000
@@ -15,7 +15,7 @@
  */
 
 import QtQuick 2.4
-import QtTest 1.0
+import QtTest 1.1
 import Ubuntu.Components 1.3
 
 /*!

=== modified file 'src/Ubuntu/UbuntuMetrics/applicationmonitor.cpp'
--- src/Ubuntu/UbuntuMetrics/applicationmonitor.cpp	2016-08-06 00:54:30 +0000
+++ src/Ubuntu/UbuntuMetrics/applicationmonitor.cpp	2016-09-03 13:06:01 +0000
@@ -567,7 +567,9 @@
         event.generic.id = id;
         // We don't bother fixing up non null-terminated string, just potential
         // overflows.
-        event.generic.stringSize = qMin(size, UMGenericEvent::maxStringSize);
+        // Note: GCC5 comoiler/linker cannot find UMGenericEvent::maxStringSize
+        // if used in qMin(); force type to satisfy it
+        event.generic.stringSize = qMin(size, quint32(UMGenericEvent::maxStringSize));
         memcpy(event.generic.string, string, event.generic.stringSize);
         d->m_loggingThread->push(&event);
         return true;

=== modified file 'src/Ubuntu/UbuntuToolkit/UbuntuToolkit.pro'
--- src/Ubuntu/UbuntuToolkit/UbuntuToolkit.pro	2016-08-04 17:25:09 +0000
+++ src/Ubuntu/UbuntuToolkit/UbuntuToolkit.pro	2016-09-03 13:06:01 +0000
@@ -44,7 +44,15 @@
     mousetouchadaptor_p.h \
     mousetouchadaptor_p_p.h \
     propertychange_p.h \
-    ubuntutoolkitmodule.h
+    ubuntutoolkitmodule.h \
+    splitview_p.h \
+    splitview_p_p.h \
+    privates/splitviewhandler_p_p.h \
+    menu_p_p.h \
+    menubar_p_p.h \
+    menu_p.h \
+    menubar_p.h \
+    menugroup_p.h
 
 SOURCES += \ 
     colorutils.cpp \
@@ -52,7 +60,13 @@
     asyncloader.cpp \
     mousetouchadaptor.cpp \
     propertychange.cpp \
-    ubuntutoolkitmodule.cpp
+    ubuntutoolkitmodule.cpp \
+    splitview.cpp \
+    privates/splitviewhandler.cpp \
+    splitviewlayout.cpp \
+    menu.cpp \
+    menubar.cpp \
+    menugroup.cpp
 
 HEADERS += \
     uctheme_p.h \
@@ -149,7 +163,9 @@
     privates/appheaderbase_p.h \
     label_p.h \
     ucbottomedgeregion_p_p.h \
-    privates/ucscrollbarutils_p.h
+    privates/ucscrollbarutils_p.h \
+    actionlist_p.h \
+    exclusivegroup_p.h
 
 SOURCES += \
     uctheme.cpp \
@@ -226,7 +242,9 @@
     privates/ucpagewrapper.cpp \
     privates/ucpagewrapperincubator.cpp \
     privates/appheaderbase.cpp \
-    privates/ucscrollbarutils.cpp
+    privates/ucscrollbarutils.cpp \
+    actionlist.cpp \
+    exclusivegroup.cpp
 
 # adapters
 SOURCES += $$PWD/adapters/alarmsadapter_organizer.cpp

=== added file 'src/Ubuntu/UbuntuToolkit/actionlist.cpp'
--- src/Ubuntu/UbuntuToolkit/actionlist.cpp	1970-01-01 00:00:00 +0000
+++ src/Ubuntu/UbuntuToolkit/actionlist.cpp	2016-09-03 13:06:01 +0000
@@ -0,0 +1,158 @@
+/*
+ * Copyright 2016 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 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 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 "actionlist_p.h"
+#include "ucaction_p.h"
+
+UT_NAMESPACE_BEGIN
+
+/*!
+ * \qmltype ActionList
+ * \inqmlmodule Ubuntu.Components
+ * \ingroup ubuntu
+ * \brief List of \l Action items
+ * An ActionList provies a way of grouping actions together.
+ * \qml
+ * ActionList {
+ *     Action {
+ *         id: action1
+ *     }
+ *     Action {
+ *         id: action2
+ *     }
+ * }
+ * \endqml
+ */
+/*!
+ * \qmlsignal ActionList::added(Action action)
+ * \since Ubuntu.Components 1.3
+ * Signal called when an action is added to the list
+ */
+/*!
+ * \qmlsignal ActionList::removed(Action action)
+ * \since Ubuntu.Components 1.3
+ * Signal called when an action is removed from the list
+ */
+ActionList::ActionList(QObject *parent)
+    : QObject(parent)
+{
+}
+
+/*!
+ * \qmlmethod ActionList::addAction(Action action)
+ * \since Ubuntu.Components 1.3
+ * Adds an Action to the list programatically.
+ * \qml
+ * Item {
+ *     Instantiator {
+ *         model: 4
+ *         onObjectAdded: actionList.addAction(object)
+ *         onObjectRemoved: actionList.removeAction(object)
+ *
+ *         Action {}
+ *     }
+ *
+ *     ActionList {
+ *         id: actionList
+ *     }
+ * }
+ * \endqml
+ * \sa ActionList::removeAction
+ */
+void ActionList::addAction(UCAction *action)
+{
+    if (m_actions.contains(action)) {
+        return;
+    }
+    m_actions.append(action);
+    Q_EMIT added(action);
+}
+
+/*!
+ * \qmlmethod ActionList::removeAction(Action action)
+ * \since Ubuntu.Components 1.3
+ * Removes an action from the list programatically.
+ * \sa ActionList::addAction
+ */
+void ActionList::removeAction(UCAction *action)
+{
+    if (!action) {
+        return;
+    }
+    if (m_actions.removeOne(action)) {
+        Q_EMIT removed(action);
+    }
+}
+
+/*!
+ * \qmlproperty list<Action> ActionList::actions
+ * \default
+ * List of Actions in this ActionList
+ * Note that when you set this property, the children of the ActionList will be ignored,
+ * so do not set the list and define children.
+ *
+ * The advantage of setting actions over using the children is that the same
+ * \l Action items can be used in several sets of actions.
+ */
+QQmlListProperty<UCAction> ActionList::actions()
+{
+    return QQmlListProperty<UCAction>(this, 0,
+                                      ActionList::append,
+                                      ActionList::count,
+                                      ActionList::at,
+                                      ActionList::clear);
+}
+
+const QList<UCAction*> &ActionList::list() const
+{
+    return m_actions;
+}
+
+void ActionList::append(QQmlListProperty<UCAction> *list, UCAction *action)
+{
+    ActionList *actionList = qobject_cast<ActionList*>(list->object);
+    if (actionList) {
+        actionList->addAction(action);
+    }
+}
+
+void ActionList::clear(QQmlListProperty<UCAction> *list)
+{
+    ActionList *actionList = qobject_cast<ActionList*>(list->object);
+    if (actionList) {
+        actionList->m_actions.clear();
+    }
+}
+
+UCAction* ActionList::at(QQmlListProperty<UCAction> *list, int index)
+{
+    ActionList *actionList = qobject_cast<ActionList*>(list->object);
+    if (actionList) {
+        return actionList->m_actions.value(index, nullptr);
+    }
+    return Q_NULLPTR;
+}
+
+int ActionList::count(QQmlListProperty<UCAction> *list)
+{
+    ActionList *actionList = qobject_cast<ActionList*>(list->object);
+    if (actionList) {
+        return actionList->m_actions.count();
+    }
+    return 0;
+}
+
+UT_NAMESPACE_END

=== added file 'src/Ubuntu/UbuntuToolkit/actionlist_p.h'
--- src/Ubuntu/UbuntuToolkit/actionlist_p.h	1970-01-01 00:00:00 +0000
+++ src/Ubuntu/UbuntuToolkit/actionlist_p.h	2016-09-03 13:06:01 +0000
@@ -0,0 +1,58 @@
+/*
+ * Copyright 2016 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 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 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 ACTIONLIST_H
+#define ACTIONLIST_H
+
+#include <QObject>
+#include <QtQml/QQmlListProperty>
+#include "ubuntutoolkitglobal.h"
+
+UT_NAMESPACE_BEGIN
+
+class UCAction;
+class UBUNTUTOOLKIT_EXPORT ActionList : public QObject
+{
+    Q_OBJECT
+    Q_PROPERTY(QQmlListProperty<UT_PREPEND_NAMESPACE(UCAction)> actions READ actions)
+    Q_CLASSINFO("DefaultProperty", "actions")
+public:
+    explicit ActionList(QObject *parent = 0);
+
+    QQmlListProperty<UCAction> actions();
+
+    const QList<UCAction*> &list() const;
+
+public Q_SLOTS:
+    void addAction(UT_PREPEND_NAMESPACE(UCAction) *action);
+    void removeAction(UT_PREPEND_NAMESPACE(UCAction) *action);
+
+Q_SIGNALS:
+    void added(UCAction *action);
+    void removed(UCAction *action);
+
+protected:
+    QList<UCAction*> m_actions;
+
+    static void append(QQmlListProperty<UCAction> *list, UCAction *action);
+    static void clear(QQmlListProperty<UCAction> *list);
+    static UCAction* at(QQmlListProperty<UCAction> *list, int index);
+    static int count(QQmlListProperty<UCAction> *list);
+};
+
+UT_NAMESPACE_END
+
+#endif // ACTIONLIST_H

=== added file 'src/Ubuntu/UbuntuToolkit/exclusivegroup.cpp'
--- src/Ubuntu/UbuntuToolkit/exclusivegroup.cpp	1970-01-01 00:00:00 +0000
+++ src/Ubuntu/UbuntuToolkit/exclusivegroup.cpp	2016-09-03 13:06:01 +0000
@@ -0,0 +1,168 @@
+/*
+ * Copyright 2016 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 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 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 "exclusivegroup_p.h"
+#include "ucaction_p.h"
+
+#include <QSignalMapper>
+
+#define CHECKED_PROPERTY "checked"
+
+UT_NAMESPACE_BEGIN
+
+static const char *checkableSignals[] = {
+    "toggled(bool)",
+    0
+};
+
+static bool isChecked(const QObject *o)
+{
+    if (!o) return false;
+    QVariant checkedVariant = o->property(CHECKED_PROPERTY);
+    return checkedVariant.isValid() && checkedVariant.toBool();
+}
+
+/*!
+ * \qmltype ExclusiveGroup
+ * \inqmlmodule Ubuntu.Components
+ * \since Ubuntu.Components 1.3
+ * \ingroup ubuntu
+ * \inherits ActionList
+ * \brief ExclusiveGroup provides a way to declare several checkable controls as mutually exclusive.
+ *
+ * The ExclusiveGroup will only allow a single object to have it's checkable property set to "true"
+ * at any one time. The exclusive group accepts child Actions, but objects other than Actions can be
+ * used by using the \l bindCheckable function as long as they support one of the required signals,
+ * and a "checked" property.
+ * \qml
+ * ExclusiveGroup {
+ *     Action {
+ *         parameterType: Action.Bool
+ *         state: true
+ *     }
+ *     Action {
+ *         parameterType: Action.Bool
+ *         state: false
+ *     }
+ * }
+ * \endqml
+ */
+ExclusiveGroup::ExclusiveGroup(QObject *parent)
+    : ActionList(parent)
+    , m_signalMapper(new QSignalMapper(this))
+    , m_entranceGuard(false)
+{
+    connect(this, &ActionList::added, this, &ExclusiveGroup::onActionAdded);
+    connect(this, &ActionList::removed, this, &ExclusiveGroup::onActionRemoved);
+
+    int index = m_signalMapper->metaObject()->indexOfMethod("map()");
+    m_updateCurrentMethod = m_signalMapper->metaObject()->method(index);
+    connect(m_signalMapper, static_cast<void(QSignalMapper::*)(QObject *)>(&QSignalMapper::mapped), this, [this](QObject *object) {
+        if (isChecked(object)) {
+            setCurrent(object);
+        }
+    });
+}
+
+void ExclusiveGroup::onActionAdded(UCAction *action)
+{
+    action->setExclusiveGroup(this);
+}
+
+void ExclusiveGroup::onActionRemoved(UCAction *action)
+{
+    action->setExclusiveGroup(nullptr);
+}
+
+/*!
+ * \qmlproperty Action ExclusiveGroup::current
+ * Returns the currently checked action
+ */
+void ExclusiveGroup::setCurrent(QObject *object)
+{
+    if (m_current == object)
+        return;
+
+    if (m_current)
+        m_current->setProperty(CHECKED_PROPERTY, QVariant(false));
+    m_current = object;
+    if (m_current)
+        m_current->setProperty(CHECKED_PROPERTY, QVariant(true));
+    Q_EMIT currentChanged();
+}
+
+QObject *ExclusiveGroup::current() const
+{
+    return m_current.data();
+}
+
+/*!
+ * \qmlmethod void ExclusiveGroup::bindCheckable(object object)
+ * Explicitly bind an objects checkability to this exclusive group.
+ * \note This only works with objects which support the following signals signals:
+ * \list
+ *  \li \b toggled(bool)
+ * \endlist
+ * \qml
+ * Item {
+ *     ExclusiveGroup {
+ *         id: exclusiveGroup
+ *     }
+ *     Instantiator {
+ *         model: 4
+ *         onObjectAdded: exclusiveGroup.bindCheckable(object)
+ *         onObjectRemoved: exclusiveGroup.unbindCheckable(object)
+ *
+ *         Action {
+ *             checkable: true
+ *         }
+ *     }
+ * }
+ * \endqml
+ * \sa ExclusiveGroup::unbindCheckable
+ */
+void ExclusiveGroup::bindCheckable(QObject *object)
+{
+    for (const char **signalName = checkableSignals; *signalName; signalName++) {
+        int signalIndex = object->metaObject()->indexOfSignal(*signalName);
+        if (signalIndex != -1) {
+            QMetaMethod signalMethod = object->metaObject()->method(signalIndex);
+            connect(object, signalMethod, m_signalMapper, m_updateCurrentMethod, Qt::UniqueConnection);
+            m_signalMapper->setMapping(object, object);
+            connect(object, SIGNAL(destroyed(QObject*)), this, SLOT(unbindCheckable(QObject*)), Qt::UniqueConnection);
+            if (!m_current && isChecked(object))
+                setCurrent(object);
+            break;
+        }
+    }
+}
+
+/*!
+ * \qmlmethod void ExclusiveGroup::unbindCheckable(object object)
+ * Explicitly unbind an objects checkability from this exclusive group.
+ * \sa ExclusiveGroup::bindCheckable
+ */
+void ExclusiveGroup::unbindCheckable(QObject *object)
+{
+    if (m_current == object)
+        setCurrent(0);
+
+    disconnect(object, 0, m_signalMapper, 0);
+    disconnect(object, SIGNAL(destroyed(QObject*)), this, SLOT(unbindCheckable(QObject*)));
+}
+
+UT_NAMESPACE_END

=== added file 'src/Ubuntu/UbuntuToolkit/exclusivegroup_p.h'
--- src/Ubuntu/UbuntuToolkit/exclusivegroup_p.h	1970-01-01 00:00:00 +0000
+++ src/Ubuntu/UbuntuToolkit/exclusivegroup_p.h	2016-09-03 13:06:01 +0000
@@ -0,0 +1,62 @@
+/*
+ * Copyright 2016 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 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 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 EXCLUSIVEGROUP_H
+#define EXCLUSIVEGROUP_H
+
+#include "actionlist_p.h"
+#include "ubuntutoolkitglobal.h"
+
+#include <QMetaMethod>
+#include <QPointer>
+
+class QSignalMapper;
+
+UT_NAMESPACE_BEGIN
+
+class UBUNTUTOOLKIT_EXPORT ExclusiveGroup : public ActionList
+{
+    Q_OBJECT
+    Q_PROPERTY(QObject* current READ current NOTIFY currentChanged)
+
+public:
+    explicit ExclusiveGroup(QObject *parent = 0);
+
+    QObject* current() const;
+
+    Q_INVOKABLE void bindCheckable(QObject* object);
+    Q_INVOKABLE void unbindCheckable(QObject* object);
+
+Q_SIGNALS:
+    void currentChanged();
+
+protected Q_SLOTS:
+    void onActionAdded(UCAction* action);
+    void onActionRemoved(UCAction* action);
+
+private:
+    void setCurrent(QObject* action);
+
+    QSignalMapper* m_signalMapper;
+    QPointer<QObject> m_current;
+    QMetaMethod m_updateCurrentMethod;
+    bool m_entranceGuard;
+};
+
+UT_NAMESPACE_END
+
+#endif // EXCLUSIVEGROUP_H

=== added file 'src/Ubuntu/UbuntuToolkit/menu.cpp'
--- src/Ubuntu/UbuntuToolkit/menu.cpp	1970-01-01 00:00:00 +0000
+++ src/Ubuntu/UbuntuToolkit/menu.cpp	2016-09-03 13:06:01 +0000
@@ -0,0 +1,671 @@
+/*
+ * Copyright 2016 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 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 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 "menu_p.h"
+#include "menu_p_p.h"
+#include "menubar_p.h"
+#include "actionlist_p.h"
+#include "menugroup_p.h"
+
+// Qt
+#include <QPointer>
+#include <QQuickItem>
+#include <QLoggingCategory>
+#include <QtGui/qpa/qplatformtheme.h>
+#include <QtGui/qpa/qplatformmenu.h>
+#include <private/qguiapplication_p.h>
+#include <private/qquickitem_p.h>
+
+#include <functional>
+
+Q_LOGGING_CATEGORY(ucMenu, "ubuntu.components.Menu", QtMsgType::QtWarningMsg)
+
+UT_NAMESPACE_BEGIN
+
+namespace {
+
+QWindow* findWindowForObject(QObject* object)
+{
+    QObject* window = object;
+    while (window && !window->isWindowType()) {
+        window = window->parent();
+        if (QQuickItem* item = qobject_cast<QQuickItem*>(window)) {
+            window = item->window();
+        }
+    }
+    return qobject_cast<QWindow*>(window);
+}
+
+// recursively get the all the object from the menu group which are not lists or groups.
+QObjectList getActionsFromMenuGroup(MenuGroup* menuGroup) {
+
+    QObjectList objectList;
+
+    Q_FOREACH(QObject* data, menuGroup->list()) {
+
+        if (auto actionList = qobject_cast<ActionList*>(data)) {
+            Q_FOREACH(UCAction* action, actionList->list()) {
+                objectList << action;
+            }
+        } else if (auto subMenuGroup = qobject_cast<MenuGroup*>(data)) {
+            objectList << getActionsFromMenuGroup(subMenuGroup);
+        } else {
+            objectList << data;
+        }
+    }
+    return objectList;
+}
+
+// recursively get the first object from the menu group which is not a list or a group.
+QObject* getFirstObject(MenuGroup* menuGroup) {
+
+    Q_FOREACH(QObject* data, menuGroup->list()) {
+
+        if (auto subMenuGroup = qobject_cast<MenuGroup*>(data)) {
+            QObject* object = getFirstObject(subMenuGroup);
+            if (object) { return object; }
+        } else if (auto actionList = qobject_cast<ActionList*>(data)) {
+            return actionList->list().count() > 0 ? actionList->list()[0] : 0;
+        } else {
+            return data;
+        }
+    }
+    return Q_NULLPTR;
+}
+
+}
+
+MenuPrivate::MenuPrivate(Menu *qq)
+    : q_ptr(qq)
+    , m_platformMenu(QGuiApplicationPrivate::platformTheme()->createPlatformMenu())
+{
+}
+
+MenuPrivate::~MenuPrivate()
+{
+    qDeleteAll(m_platformItems);
+    m_platformItems.clear();
+
+    delete m_platformMenu;
+    m_platformMenu = Q_NULLPTR;
+}
+
+void MenuPrivate::insertObject(int index, QObject *o)
+{
+    Q_Q(Menu);
+    if (!o) return;
+    qCDebug(ucMenu).nospace() << "Menu::insertObject(index="<< index << ", object=" << o << ")";
+
+    if (!m_platformMenu) {
+        m_data.insert(m_data.count() > index ? index : m_data.count(), o);
+        return;
+    }
+
+    // If the menus contains lists or groups, we need to alter the insertion index to account for them.
+    int actualIndex = 0;
+    bool insertSeparator = false;
+    for (int i = 0; i < index && i < m_data.count(); i++) {
+        QObject* data = m_data[i];
+
+        int dataObjectCount = 0;
+        if (auto menuGroup = qobject_cast<MenuGroup*>(data)) {
+            dataObjectCount = getActionsFromMenuGroup(menuGroup).count();
+        } else if (auto list = qobject_cast<ActionList*>(data)) {
+            dataObjectCount = list->list().count();
+        } else {
+            dataObjectCount = 1;
+        }
+        actualIndex += dataObjectCount;
+        // insert a separator before the new item if there are previous items.
+        insertSeparator |= dataObjectCount > 0;
+
+        // account for item separators if it's not the last data item.
+        actualIndex += dataObjectCount > 0 && (i+1 < index && i+1 < m_data.count()) ? 1: 0;
+    }
+
+    // need to make sure the item after the insertion index has a separator
+    if (index < m_data.count()) {
+        QObject* data = m_data.at(index);
+        QObject* objectToSeparate(Q_NULLPTR);
+
+        if (auto menuGroup = qobject_cast<MenuGroup*>(data)) {
+            objectToSeparate = getFirstObject(menuGroup);
+        } else if (auto actionList = qobject_cast<ActionList*>(data)) {
+            objectToSeparate = actionList->list().count() > 0 ? actionList->list()[0] : 0;
+        } else {
+            objectToSeparate = data;
+        }
+
+        if (objectToSeparate && m_platformItems.contains(objectToSeparate)) {
+            m_platformItems.value(objectToSeparate)->setSeparator();
+        }
+    }
+
+    m_data.insert(m_data.count() > index ? index : m_data.count(), o);
+
+    // if an object changes, we need to remove and re-add it.
+    std::function<void()> refreshObject = [o, this]() {
+        int index = m_data.indexOf(o);
+        if (index >= 0)  {
+            removeObject(o);
+            insertObject(index, o);
+        }
+    };
+
+    // Get All the menu item objects
+    QObjectList objects;
+    if (auto menuGroup = qobject_cast<MenuGroup*>(o)) {
+        Q_FOREACH(QObject* menuGroupObject, getActionsFromMenuGroup(menuGroup)) {
+            objects << menuGroupObject;
+        }
+        // connect to content changes
+        QObject::connect(menuGroup, &MenuGroup::changed, q, refreshObject);
+    } else if (auto actionList = qobject_cast<ActionList*>(o)) {
+        Q_FOREACH(UCAction* action, actionList->list()) {
+            objects << action;
+        }
+        // connect to content changes
+        QObject::connect(actionList, &ActionList::added, q, refreshObject);
+        QObject::connect(actionList, &ActionList::removed, q, refreshObject);
+    } else {
+        objects << o;
+    }
+
+    Q_FOREACH(QObject* platformObject, objects) {
+        // add to platform
+        auto platformWrapper = new PlatformItemWrapper(platformObject, q);
+        platformWrapper->insert(actualIndex++, insertSeparator);
+        if (platformWrapper->hasSeparator()) { // we also inserted an separator, need to increment for next position.
+            actualIndex++;
+        }
+        insertSeparator = false;
+        m_platformItems[platformObject] = platformWrapper;
+        // map the inserted item with the object which sources the platformItem info.
+        if (!m_dataPlatformObjectMap.contains(o, platformObject)) {
+            m_dataPlatformObjectMap.insertMulti(o, platformObject);
+        }
+
+        QObject::connect(platformObject, &QObject::destroyed, q, [o, this](QObject* platformObject) {
+            m_dataPlatformObjectMap.remove(o, platformObject);
+
+            if (m_platformItems.contains(platformObject)) {
+                PlatformItemWrapper* wrapper = m_platformItems.take(platformObject);
+                wrapper->remove();
+                delete wrapper;
+            }
+        });
+    }
+}
+
+void MenuPrivate::removeObject(QObject *o)
+{
+    Q_Q(Menu);
+    m_data.removeOne(o);
+    qCDebug(ucMenu).nospace() << "Menu::removeObject(" << o << ")";
+
+    if (m_platformMenu) {
+        if (auto menuGroup = qobject_cast<MenuGroup*>(o)) {
+            // disconnect from content changes
+            QObject::disconnect(menuGroup, &MenuGroup::changed, q, 0);
+        }  else if (ActionList* actionList = qobject_cast<ActionList*>(o)) {
+            // disconnect from content changes
+            QObject::disconnect(actionList, &ActionList::added, q, 0);
+            QObject::disconnect(actionList, &ActionList::removed, q, 0);
+        }
+
+        QList<QObject*> platformObjects = m_dataPlatformObjectMap.values(o);
+        m_dataPlatformObjectMap.remove(o);
+
+        Q_FOREACH(QObject* platformObject, platformObjects) {
+            // remove from platform.
+            if (m_platformItems.contains(platformObject)) {
+                PlatformItemWrapper* wrapper = m_platformItems.take(platformObject);
+                wrapper->remove();
+                delete wrapper;
+            }
+        }
+    }
+}
+
+void MenuPrivate::_q_updateEnabled()
+{
+    Q_Q(Menu);
+
+    bool isEnabled = q->isEnabled();
+    if (m_platformMenu) { m_platformMenu->setEnabled(isEnabled); }
+}
+
+void MenuPrivate::_q_updateText()
+{
+    Q_Q(Menu);
+
+    QString text = q->text();
+    if (m_platformMenu) { m_platformMenu->setText(text); }
+}
+
+void MenuPrivate::_q_updateIcon()
+{
+    Q_Q(Menu);
+
+    QIcon icon;
+    if (!q->iconSource().isEmpty()) {
+        icon = QIcon(q->iconSource().path());
+    } else if (!q->iconName().isEmpty()) {
+        icon = QIcon::fromTheme(q->iconName());
+    }
+
+    if (m_platformMenu) { m_platformMenu->setIcon(icon); }
+}
+
+void MenuPrivate::_q_updateVisible()
+{
+    Q_Q(Menu);
+
+    bool visible = q->visible();
+    if (m_platformMenu) { m_platformMenu->setVisible(visible); }
+}
+
+void MenuPrivate::data_append(QQmlListProperty<QObject> *prop, QObject *o)
+{
+    Menu *q = qobject_cast<Menu *>(prop->object);
+    q->appendObject(o);
+}
+
+int MenuPrivate::data_count(QQmlListProperty<QObject> *prop)
+{
+    MenuPrivate *p = static_cast<MenuPrivate *>(prop->data);
+    return p->m_data.count();
+}
+
+QObject *MenuPrivate::data_at(QQmlListProperty<QObject> *prop, int index)
+{
+    MenuPrivate *p = static_cast<MenuPrivate *>(prop->data);
+    return p->m_data.value(index, Q_NULLPTR);
+}
+
+void MenuPrivate::data_clear(QQmlListProperty<QObject> *prop)
+{
+    MenuPrivate *p = static_cast<MenuPrivate *>(prop->data);
+    p->m_data.clear();
+}
+
+/*!
+ * \qmltype Menu
+ * \inqmlmodule Ubuntu.Components
+ * \ingroup ubuntu
+ * \brief Menu defines a context menu or submenu structure of a MenuBar
+ *
+ * Example usage:
+ * \qml
+ * import QtQuick 2.4
+ * import Ubuntu.Components 1.3
+ * Menu {
+ *     text: "&File"
+ *
+ *     MenuGroup {
+ *         Action {
+ *             text: "&New"
+ *             shortcut: "Ctrl+N"
+ *         }
+ *
+ *         Action {
+ *             text: "&Open"
+ *             shortcut: "Ctrl+O"
+ *         }
+ *     }
+ *
+ *     Menu {
+ *         text: "Recent Files"
+ *
+ *         ActionList {
+ *             Action { text: "1.txt" }
+ *             Action { text: "2.txt" }
+ *             Action { text: "3.txt" }
+ *         }
+ *     }
+ *
+ *     Action {
+ *         action: Action {
+ *             text: "E&xit"
+ *             shortcut: "Ctrl+X"
+ *         }
+ *     }
+ * }
+ * \endqml
+ */
+Menu::Menu(QObject *parent)
+    : UCAction(parent)
+    , d_ptr(new MenuPrivate(this))
+{
+    Q_D(Menu);
+
+    connect(this, SIGNAL(enabledChanged()), this, SLOT(_q_updateEnabled()));
+    connect(this, SIGNAL(textChanged()), this, SLOT(_q_updateText()));
+    connect(this, SIGNAL(iconNameChanged()), this, SLOT(_q_updateIcon()));
+    connect(this, SIGNAL(iconSourceChanged()), this, SLOT(_q_updateIcon()));
+    connect(this, SIGNAL(visibleChanged()), this, SLOT(_q_updateVisible()));
+}
+
+Menu::~Menu()
+{
+}
+
+/*!
+ * \qmlproperty list<Object> Menu::data
+ * \default
+ * List of objects representing menu items within the menu.
+ *
+ * Currently supports Menu, Action, AcionList & MenuGroup objects.
+ * \note Item object which do not support platformItem will not be exported for native menus.
+ */
+QQmlListProperty<QObject> Menu::data()
+{
+    Q_D(Menu);
+    return QQmlListProperty<QObject>(this, d,
+                                     &MenuPrivate::data_append,
+                                     &MenuPrivate::data_count,
+                                     &MenuPrivate::data_at,
+                                     &MenuPrivate::data_clear);
+}
+
+/*!
+ * \qmlmethod Menu::appendObject(object o)
+ * Add a object tto the menu
+ */
+void Menu::appendObject(QObject *o)
+{
+    Q_D(Menu);
+
+    insertObject(d->m_data.count(), o);
+}
+
+/*!
+ * \qmlmethod Menu::insertObject(int index, object o)
+ * Inserts an item at the index in the menu.
+ *
+ * Currently supports Menu, Action, AcionList & MenuGroup objects.
+ * \note Item object which do not support platformItem will not be exported for native menus.
+ */
+void Menu::insertObject(int index, QObject *o)
+{
+    Q_D(Menu);
+    d->insertObject(index, o);
+}
+
+/*!
+ * \qmlmethod Menu::removeObject(object o)
+ * Removes the item from the menu.
+ */
+void Menu::removeObject(QObject *o)
+{
+    Q_D(Menu);
+    qCDebug(ucMenu) << "Menu::removeObject" << o;
+
+    d->removeObject(o);
+}
+
+QPlatformMenu* Menu::platformMenu() const
+{
+    Q_D(const Menu);
+    return d->m_platformMenu;
+}
+
+/*!
+ * \qmlmethod Menu::show(point point)
+ * Show the menu popup at the given point
+ */
+void Menu::show(const QPoint &point)
+{
+    Q_D(Menu);
+    qCDebug(ucMenu, "Menu::popup(%s, point(%d,%d))", qPrintable(text()), point.x(), point.y());
+
+    if (d->m_platformMenu) {
+        d->m_platformMenu->showPopup(findWindowForObject(this), QRect(point, QSize()), Q_NULLPTR);
+    }
+}
+
+/*!
+ * \qmlmethod Menu::dismiss()
+ * Dismiss and destroy the menu popup.
+ */
+void Menu::dismiss()
+{
+    Q_D(Menu);
+    qCDebug(ucMenu, "Menu::dismiss(%s)", qPrintable(text()));
+
+    if (d->m_platformMenu) {
+        d->m_platformMenu->dismiss();
+    }
+}
+
+
+PlatformItemWrapper::PlatformItemWrapper(QObject *target, Menu* menu)
+    : QObject(menu)
+    , m_target(target)
+    , m_menu(menu)
+    , m_platformItem(menu->platformMenu() ? menu->platformMenu()->createMenuItem() : Q_NULLPTR)
+    , m_platformItemSeparator(Q_NULLPTR)
+    , m_inserted(false)
+{
+    if (Menu* menu = qobject_cast<Menu*>(m_target)) {
+        if (m_platformItem) {
+            m_platformItem->setMenu(menu->platformMenu());
+        }
+
+        connect(menu, &Menu::visibleChanged, this, &PlatformItemWrapper::updateVisible);
+        connect(menu, &Menu::textChanged, this, &PlatformItemWrapper::updateText);
+        connect(menu, &Menu::enabledChanged, this, &PlatformItemWrapper::updateEnabled);
+        connect(menu, &Menu::iconSourceChanged, this, &PlatformItemWrapper::updateIcon);
+        connect(menu, &Menu::iconNameChanged, this, &PlatformItemWrapper::updateIcon);
+
+    } else if (UCAction* action = qobject_cast<UCAction*>(m_target)) {
+
+        connect(action, &UCAction::visibleChanged, this, &PlatformItemWrapper::updateVisible);
+        connect(action, &UCAction::textChanged, this, &PlatformItemWrapper::updateText);
+        connect(action, &UCAction::enabledChanged, this, &PlatformItemWrapper::updateEnabled);
+        connect(action, &UCAction::iconSourceChanged, this, &PlatformItemWrapper::updateIcon);
+        connect(action, &UCAction::iconNameChanged, this, &PlatformItemWrapper::updateIcon);
+        connect(action, &UCAction::shortcutChanged, this, &PlatformItemWrapper::updateShortcut);
+        connect(action, &UCAction::checkableChanged, this, &PlatformItemWrapper::updateCheck);
+        connect(action, &UCAction::toggled, this, &PlatformItemWrapper::updateCheck);
+
+        if (m_platformItem) {
+            // Connect to activate (with inversion for checkables)
+            connect(m_platformItem, &QPlatformMenuItem::activated, action, [action]() {
+                action->trigger();
+            });
+        }
+
+    }
+    syncPlatformItem();
+}
+
+PlatformItemWrapper::~PlatformItemWrapper()
+{
+    if (m_inserted && m_menu && m_menu->platformMenu()) {
+        m_menu->platformMenu()->removeMenuItem(m_platformItem);
+        if (m_platformItemSeparator) {
+            m_menu->platformMenu()->removeMenuItem(m_platformItemSeparator);
+            delete m_platformItemSeparator;
+        }
+    }
+    delete m_platformItem;
+}
+
+void PlatformItemWrapper::insert(int index, bool withSeparator)
+{
+    if (m_inserted) return;
+    qCDebug(ucMenu).nospace() << " PlatformItemWrapper::insert(menu=" << m_menu
+                                                        << ", index=" << index
+                                                        << ", object=" << m_target << ")";
+
+    auto platformMenu = m_menu->platformMenu();
+    if (!platformMenu) return;
+    if (!m_platformItem) return;
+
+    QPlatformMenuItem* before = platformMenu->menuItemAt(index);
+    platformMenu->insertMenuItem(m_platformItem, before);
+    m_inserted = true;
+
+    if (withSeparator) setSeparator();
+}
+
+void PlatformItemWrapper::remove()
+{
+    if (!m_inserted) return;
+    qCDebug(ucMenu).nospace() << " PlatformItemWrapper::remove(menu=" << m_menu
+                                                        << ", object=" << m_target << ")";
+
+    auto platformMenu = m_menu->platformMenu();
+    if (!platformMenu) return;
+    if (!m_platformItem) return;
+
+    platformMenu->removeMenuItem(m_platformItem);
+    m_inserted = false;
+
+    if (m_platformItemSeparator) {
+        qCDebug(ucMenu).nospace() << " PlatformItemWrapper::removeSeparator(menu=" << m_menu
+                                                            << ", object=" << m_target << ")";
+        platformMenu->removeMenuItem(m_platformItemSeparator);
+        delete m_platformItemSeparator;
+        m_platformItemSeparator = Q_NULLPTR;
+    }
+}
+
+void PlatformItemWrapper::setSeparator()
+{
+    // already created
+    if (m_platformItemSeparator) return;
+    // not inserted yet.
+    if (!m_inserted) return;
+
+    auto platformMenu = m_menu->platformMenu();
+    if (!platformMenu) return;
+
+    // insert separator before?
+    m_platformItemSeparator = platformMenu->createMenuItem();
+    if (m_platformItemSeparator) {
+        qCDebug(ucMenu).nospace() << " PlatformItemWrapper::setSeparator(menu=" << m_menu
+                                                            << ", object=" << m_target << ")";
+
+        m_platformItemSeparator->setIsSeparator(true);
+        platformMenu->insertMenuItem(m_platformItemSeparator, m_platformItem);
+    }
+}
+
+void PlatformItemWrapper::updateVisible()
+{
+    if (Menu* menu = qobject_cast<Menu*>(m_target)) {
+        if (m_platformItem) m_platformItem->setVisible(menu->visible());
+        if (menu->platformMenu()) menu->platformMenu()->setVisible(menu->visible());
+    } else if (UCAction* action = qobject_cast<UCAction*>(m_target)) {
+        if (m_platformItem) m_platformItem->setVisible(action->visible());
+    }
+}
+
+void PlatformItemWrapper::updateEnabled()
+{
+    if (Menu* menu = qobject_cast<Menu*>(m_target)) {
+        if (m_platformItem) m_platformItem->setEnabled(menu->isEnabled());
+        if (menu->platformMenu()) menu->platformMenu()->setEnabled(menu->isEnabled());
+    } else if (UCAction* action = qobject_cast<UCAction*>(m_target)) {
+        if (m_platformItem) m_platformItem->setEnabled(action->isEnabled());
+    }
+}
+
+void PlatformItemWrapper::updateText()
+{
+    if (Menu* menu = qobject_cast<Menu*>(m_target)) {
+        if (m_platformItem) m_platformItem->setText(menu->text());
+        if (menu->platformMenu()) menu->platformMenu()->setText(menu->text());
+    } else if (UCAction* action = qobject_cast<UCAction*>(m_target)) {
+        if (m_platformItem) m_platformItem->setText(action->text());
+    }
+}
+
+void PlatformItemWrapper::updateIcon()
+{
+    QIcon icon;
+    if (Menu* menu = qobject_cast<Menu*>(m_target)) {
+
+        if (!menu->iconSource().isEmpty()) {
+            icon = QIcon(menu->iconSource().path());
+        } else if (!menu->iconName().isEmpty()) {
+            icon = QIcon::fromTheme(menu->iconName());
+        }
+        if (menu->platformMenu()) menu->platformMenu()->setIcon(icon);
+
+    } else if (UCAction* action = qobject_cast<UCAction*>(m_target)) {
+
+        if (!action->iconSource().isEmpty()) {
+            icon = QIcon(action->iconSource().path());
+        } else if (!action->iconName().isEmpty()) {
+            icon = QIcon::fromTheme(action->iconName());
+        }
+    }
+
+    if (m_platformItem) { m_platformItem->setIcon(icon); }
+}
+
+
+inline QKeySequence sequenceFromVariant(const QVariant& variant)
+{
+    if (variant.type() == QVariant::Int) {
+        return static_cast<QKeySequence::StandardKey>(variant.toInt());
+    }
+    if (variant.type() == QVariant::String) {
+        return QKeySequence::fromString(variant.toString());
+    }
+    return QKeySequence();
+}
+
+void PlatformItemWrapper::updateShortcut()
+{
+    if (!m_platformItem) return;
+
+    if (UCAction* action = qobject_cast<UCAction*>(m_target)) {
+        m_platformItem->setShortcut(sequenceFromVariant(action->shortcut()));
+    }
+}
+
+void PlatformItemWrapper::updateCheck()
+{
+    if (!m_platformItem) return;
+
+    if (UCAction* action = qobject_cast<UCAction*>(m_target)) {
+        bool checkable = action->isCheckable();
+        m_platformItem->setCheckable(checkable);
+        m_platformItem->setChecked(checkable && action->isChecked());
+    }
+}
+
+void PlatformItemWrapper::syncPlatformItem()
+{
+    updateVisible();
+    updateEnabled();
+    updateText();
+    updateIcon();
+    updateShortcut();
+    updateCheck();
+
+    if (m_menu->platformMenu() && m_platformItem) {
+        m_menu->platformMenu()->syncMenuItem(m_platformItem);
+    }
+}
+
+UT_NAMESPACE_END
+
+#include "moc_menu_p.cpp"

=== added file 'src/Ubuntu/UbuntuToolkit/menu_p.h'
--- src/Ubuntu/UbuntuToolkit/menu_p.h	1970-01-01 00:00:00 +0000
+++ src/Ubuntu/UbuntuToolkit/menu_p.h	2016-09-03 13:06:01 +0000
@@ -0,0 +1,75 @@
+/*
+ * Copyright 2016 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 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 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 MENU_P_H
+#define MENU_P_H
+
+#include <QQmlListProperty>
+#include <QLoggingCategory>
+#include <QPointer>
+#include <ubuntutoolkitglobal.h>
+
+#include "ucaction_p.h"
+
+Q_DECLARE_LOGGING_CATEGORY(ucMenu);
+
+class QPlatformMenu;
+class QPlatformMenuItem;
+class QQuickItem;
+
+UT_NAMESPACE_BEGIN
+
+class MenuPrivate;
+class MenuBar;
+class UCAction;
+class UBUNTUTOOLKIT_EXPORT Menu : public UCAction
+{
+    Q_OBJECT
+
+    Q_PROPERTY(QQmlListProperty<QObject> data READ data FINAL)
+    Q_CLASSINFO("DefaultProperty", "data")
+
+public:
+    explicit Menu(QObject *parent = 0);
+    ~Menu();
+
+    QQmlListProperty<QObject> data();
+
+    Q_INVOKABLE void appendObject(QObject* obj);
+    Q_INVOKABLE void insertObject(int index, QObject* obj);
+    Q_INVOKABLE void removeObject(QObject* obj);
+
+    QPlatformMenu *platformMenu() const;
+
+public Q_SLOTS:
+    void show(const QPoint& pt);
+    void dismiss();
+
+private:
+    Q_DISABLE_COPY(Menu)
+    Q_DECLARE_PRIVATE(Menu)
+    QScopedPointer<MenuPrivate> d_ptr;
+
+    Q_PRIVATE_SLOT(d_func(), void _q_updateEnabled())
+    Q_PRIVATE_SLOT(d_func(), void _q_updateText())
+    Q_PRIVATE_SLOT(d_func(), void _q_updateIcon())
+    Q_PRIVATE_SLOT(d_func(), void _q_updateVisible())
+};
+
+UT_NAMESPACE_END
+
+#endif // MENU_P_H

=== added file 'src/Ubuntu/UbuntuToolkit/menu_p_p.h'
--- src/Ubuntu/UbuntuToolkit/menu_p_p.h	1970-01-01 00:00:00 +0000
+++ src/Ubuntu/UbuntuToolkit/menu_p_p.h	2016-09-03 13:06:01 +0000
@@ -0,0 +1,95 @@
+/*
+ * Copyright 2016 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 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 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 MENU_P_P_H
+#define MENU_P_P_H
+
+#include "menu_p.h"
+#include <ubuntutoolkitglobal.h>
+
+class QObject;
+class QQmlComponent;
+
+UT_NAMESPACE_BEGIN
+
+class UCAction;
+class Menu;
+class PlatformItemWrapper;
+
+class MenuPrivate
+{
+    Q_DECLARE_PUBLIC(Menu)
+public:
+    MenuPrivate(Menu *qq);
+    virtual ~MenuPrivate();
+
+    void insertObject(int index, QObject *obj);
+    void removeObject(QObject *obj);
+
+    void _q_updateEnabled();
+    void _q_updateText();
+    void _q_updateIcon();
+    void _q_updateVisible();
+
+    static void data_append(QQmlListProperty<QObject> *prop, QObject *o);
+    static int data_count(QQmlListProperty<QObject> *prop);
+    static QObject *data_at(QQmlListProperty<QObject> *prop, int index);
+    static void data_clear(QQmlListProperty<QObject> *prop);
+
+    Menu* q_ptr;
+    QPlatformMenu* m_platformMenu;
+    UCAction* m_action;
+
+    QHash<QObject*, PlatformItemWrapper*> m_platformItems;
+    QMultiHash<QObject*, QObject*> m_dataPlatformObjectMap;
+    QVector<QObject*> m_data;
+};
+
+class PlatformItemWrapper : public QObject
+{
+    Q_OBJECT
+public:
+    PlatformItemWrapper(QObject *target, Menu* menu);
+    ~PlatformItemWrapper();
+
+    void insert(int index, bool withSeparator);
+    void remove();
+    void setSeparator();
+
+    bool hasSeparator() const { return m_platformItemSeparator != Q_NULLPTR; }
+
+public Q_SLOTS:
+    void updateVisible();
+    void updateEnabled();
+    void updateText();
+    void updateIcon();
+    void updateShortcut();
+    void updateCheck();
+
+private:
+    void syncPlatformItem();
+
+    QObject* m_target;
+    QPointer<Menu> m_menu;
+    QPlatformMenuItem* m_platformItem;
+    QPlatformMenuItem* m_platformItemSeparator;
+    bool m_inserted;
+};
+
+UT_NAMESPACE_END
+
+#endif // MENU_P_P_H

=== added file 'src/Ubuntu/UbuntuToolkit/menubar.cpp'
--- src/Ubuntu/UbuntuToolkit/menubar.cpp	1970-01-01 00:00:00 +0000
+++ src/Ubuntu/UbuntuToolkit/menubar.cpp	2016-09-03 13:06:01 +0000
@@ -0,0 +1,340 @@
+/*
+ * Copyright 2016 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 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 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 "menubar_p.h"
+#include "menubar_p_p.h"
+
+// Qt
+#include <QQuickItem>
+#include <QQuickWindow>
+#include <QLoggingCategory>
+#include <private/qguiapplication_p.h>
+#include <QtGui/qpa/qplatformtheme.h>
+#include <QtGui/qpa/qplatformmenu.h>
+
+UT_NAMESPACE_BEGIN
+
+MenuBarPrivate::MenuBarPrivate(MenuBar *qq)
+    : q_ptr(qq)
+{
+    m_platformBar = QGuiApplicationPrivate::platformTheme()->createPlatformMenuBar();
+}
+
+MenuBarPrivate::~MenuBarPrivate()
+{
+    qDeleteAll(m_platformMenus);
+    m_platformMenus.clear();
+
+    delete m_platformBar;
+    m_platformBar = Q_NULLPTR;
+}
+
+void MenuBarPrivate::insertMenu(int index, Menu* menu)
+{
+    Q_Q(MenuBar);
+    Menu* prevMenu = m_menus.count() > index ? m_menus[index] : Q_NULLPTR;
+
+    m_menus.insert(index, menu);
+
+    // add to platform
+    if (m_platformBar && menu->platformMenu()) {
+        auto platformWrapper = new PlatformMenuWrapper(menu, q);
+        platformWrapper->insert(prevMenu ? prevMenu->platformMenu() : Q_NULLPTR);
+        m_platformMenus[menu] = platformWrapper;
+
+        QObject::connect(menu, &QObject::destroyed, q, [this](QObject* object) {
+            if (m_platformMenus.contains(object)) {
+                PlatformMenuWrapper* wrapper = m_platformMenus.take(object);
+                wrapper->remove();
+                delete wrapper;
+            }
+        });
+    }
+}
+
+void MenuBarPrivate::removeMenu(Menu *menu)
+{
+    m_menus.removeOne(menu);
+
+    if (m_platformBar) {
+        if (m_platformMenus.contains(menu)) {
+            PlatformMenuWrapper* wrapper = m_platformMenus.take(menu);
+            wrapper->remove();
+            delete wrapper;
+        }
+    }
+}
+
+void MenuBarPrivate::menu_append(QQmlListProperty<Menu> *prop, Menu *o)
+{
+    MenuBarPrivate *q = static_cast<MenuBarPrivate *>(prop->data);
+    // menubar is the menus parent
+    o->setParent(prop->object);
+    q->insertMenu(q->m_menus.count(), o);
+}
+
+int MenuBarPrivate::menu_count(QQmlListProperty<Menu> *prop)
+{
+    MenuBarPrivate *p = static_cast<MenuBarPrivate *>(prop->data);
+    return p->m_menus.count();
+}
+
+Menu *MenuBarPrivate::menu_at(QQmlListProperty<Menu> *prop, int index)
+{
+    MenuBarPrivate *p = static_cast<MenuBarPrivate *>(prop->data);
+    return p->m_menus.value(index);
+}
+
+void MenuBarPrivate::menu_clear(QQmlListProperty<Menu> *prop)
+{
+    MenuBarPrivate *p = static_cast<MenuBarPrivate *>(prop->data);
+    p->m_menus.clear();
+}
+
+/*!
+ * \qmltype MenuBar
+ * \inqmlmodule Ubuntu.Components 1.3
+ * \ingroup ubuntu
+ * \brief MenuBar defines an application menu bar structure
+ *
+ * Example usage:
+ * \qml
+ * import QtQuick 2.4
+ * import Ubuntu.Components 1.3
+ * MainView {
+ *     MenuBar {
+ *         Menu {
+ *             text: "_File"
+ *
+ *             MenuItem {
+ *                 text: "_New"
+ *                 shortcut: "Ctrl+N"
+ *             }
+ *
+ *             MenuItem {
+ *                 text: "_Open"
+ *                 shortcut: "Ctrl+O"
+ *             }
+ *
+ *             MenuSeparator {}
+ *
+ *             MenuItem {
+ *                 action: exitAction
+ *             }
+ *         }
+ *
+ *         Menu {
+ *             text: "_Edit"
+ *
+ *             MenuItem {
+ *                 text: "_Undo"
+ *                 iconSource: "image://theme/undo"
+ *             }
+ *         }
+ *         Menu {
+ *             text: "_Window"
+ *
+ *             MenuItem {
+ *                 text: "Fullscreen"
+ *                 checkable: true
+ *                 checked: false
+ *             }
+ *         }
+ *     }
+ *     Action {
+ *         id: boundAction
+ *         text: "E_xit"
+ *         onTriggered: {
+ *             Qt.quit();
+ *         }
+ *     }
+ * }
+ * \endqml
+ */
+MenuBar::MenuBar(QObject *parent)
+    : QObject(parent)
+    , d_ptr(new MenuBarPrivate(this))
+{
+}
+
+MenuBar::~MenuBar()
+{
+}
+
+/*!
+  * \qmlmethod void MenuBar::appendMenu(Menu menu)
+  * Append a Menu to the MenuBar
+ */
+void MenuBar::appendMenu(Menu *menu)
+{
+    Q_D(MenuBar);
+    insertMenu(d->m_menus.count(), menu);
+}
+
+/*!
+  * \qmlmethod void MenuBar::insertMenu(int index, Menu menu)
+  * Insert a Menu to the MenuBar at the specified position
+ */
+void MenuBar::insertMenu(int index, Menu *menu)
+{
+    Q_D(MenuBar);
+    if (!menu) return;
+
+    d->insertMenu(index, menu);
+    Q_EMIT menusChanged();
+}
+
+/*!
+  * \qmlmethod void MenuBar::removeMenu(Menu menu)
+  * Remove a Menu from the MenuBar
+ */
+void MenuBar::removeMenu(Menu *menu)
+{
+    Q_D(MenuBar);
+    if (!menu) return;
+
+    d->removeMenu(menu);
+    Q_EMIT menusChanged();
+}
+/*!
+ * \qmlproperty list<Menu> MenuBar::menus
+ * \default
+ * List of Menus in this MenuBar.
+ */
+QQmlListProperty<Menu> MenuBar::menus()
+{
+    Q_D(MenuBar);
+    return QQmlListProperty<Menu>(this, d,
+                                     &MenuBarPrivate::menu_append,
+                                     &MenuBarPrivate::menu_count,
+                                     &MenuBarPrivate::menu_at,
+                                    &MenuBarPrivate::menu_clear);
+}
+
+QPlatformMenuBar *MenuBar::platformMenuBar() const
+{
+    Q_D(const MenuBar);
+    return d->m_platformBar;
+}
+
+void MenuBar::classBegin()
+{
+}
+
+void MenuBar::componentComplete()
+{
+    Q_D(MenuBar);
+
+    auto parentItem = qobject_cast<QQuickItem*>(parent());
+    if (parentItem && d->m_platformBar) {
+        d->m_platformBar->handleReparent(parentItem->window());
+    }
+}
+
+
+PlatformMenuWrapper::PlatformMenuWrapper(Menu *target, MenuBar* bar)
+    : QObject(bar)
+    , m_bar(bar)
+    , m_target(target)
+    , m_inserted(false)
+{
+    connect(m_target.data(), &Menu::visibleChanged, this, &PlatformMenuWrapper::updateVisible);
+    connect(m_target.data(), &Menu::textChanged, this, &PlatformMenuWrapper::updateText);
+    connect(m_target.data(), &Menu::enabledChanged, this, &PlatformMenuWrapper::updateEnabled);
+    connect(m_target.data(), &Menu::iconSourceChanged, this, &PlatformMenuWrapper::updateIcon);
+    connect(m_target.data(), &Menu::iconNameChanged, this, &PlatformMenuWrapper::updateIcon);
+
+    syncPlatformMenu();
+}
+
+PlatformMenuWrapper::~PlatformMenuWrapper()
+{
+    if (m_inserted && m_bar && m_bar->platformMenuBar()) {
+        if (m_target && m_target->platformMenu()) {
+            m_bar->platformMenuBar()->removeMenu(m_target->platformMenu());
+        }
+    }
+}
+
+void PlatformMenuWrapper::insert(QPlatformMenu *before)
+{
+    if (m_inserted) return;
+    qCDebug(ucMenu).nospace() << " PlatformMenuWrapper::insert(bar=" << m_bar
+                                                        << ", before=" << before
+                                                        << ", menu=" << m_target << ")";
+
+    auto platformBar = m_bar->platformMenuBar();
+    if (!platformBar) return;
+    auto platformMenu = m_target->platformMenu();
+    if (!platformMenu) return;
+
+    platformBar->insertMenu(platformMenu, before);
+    m_inserted = true;
+}
+
+void PlatformMenuWrapper::remove()
+{
+    if (!m_inserted) return;
+    qCDebug(ucMenu).nospace() << " PlatformMenuWrapper::remove(bar=" << m_bar
+                                                        << ", menu=" << m_target << ")";
+
+    auto platformBar = m_bar->platformMenuBar();
+    if (!platformBar) return;
+    auto platformMenu = m_target->platformMenu();
+    if (!platformMenu) return;
+
+    platformBar->removeMenu(platformMenu);
+    m_inserted = false;
+}
+
+void PlatformMenuWrapper::updateVisible()
+{
+    if (m_target->platformMenu()) m_target->platformMenu()->setVisible(m_target->visible());
+}
+
+void PlatformMenuWrapper::updateEnabled()
+{
+    if (m_target->platformMenu()) m_target->platformMenu()->setEnabled(m_target->isEnabled());
+}
+
+void PlatformMenuWrapper::updateText()
+{
+    if (m_target->platformMenu()) m_target->platformMenu()->setText(m_target->text());
+}
+
+void PlatformMenuWrapper::updateIcon()
+{
+    QIcon icon;
+    if (!m_target->iconSource().isEmpty()) {
+        icon = QIcon(m_target->iconSource().path());
+    } else if (!m_target->iconName().isEmpty()) {
+        icon = QIcon::fromTheme(m_target->iconName());
+    }
+    if (m_target->platformMenu()) m_target->platformMenu()->setIcon(icon);
+}
+
+void PlatformMenuWrapper::syncPlatformMenu()
+{
+    updateVisible();
+    updateEnabled();
+    updateText();
+    updateIcon();
+}
+
+UT_NAMESPACE_END
+
+#include "moc_menubar_p.cpp"

=== added file 'src/Ubuntu/UbuntuToolkit/menubar_p.h'
--- src/Ubuntu/UbuntuToolkit/menubar_p.h	1970-01-01 00:00:00 +0000
+++ src/Ubuntu/UbuntuToolkit/menubar_p.h	2016-09-03 13:06:01 +0000
@@ -0,0 +1,65 @@
+/*
+ * Copyright 2016 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 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 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 MENUBAR_P_H
+#define MENUBAR_P_H
+
+#include "menu_p.h"
+#include <ubuntutoolkitglobal.h>
+
+#include <QQmlParserStatus>
+
+class QPlatformMenuBar;
+
+UT_NAMESPACE_BEGIN
+
+class MenuBarPrivate;
+class UBUNTUTOOLKIT_EXPORT MenuBar : public QObject, public QQmlParserStatus
+{
+    Q_OBJECT
+    Q_INTERFACES(QQmlParserStatus)
+
+    Q_PROPERTY(QQmlListProperty<UT_PREPEND_NAMESPACE(Menu)> menus READ menus NOTIFY menusChanged FINAL)
+    Q_CLASSINFO("DefaultProperty", "menus")
+
+public:
+    explicit MenuBar(QObject *parent = 0);
+    ~MenuBar();
+
+    Q_INVOKABLE void appendMenu(Menu *menu);
+    Q_INVOKABLE void insertMenu(int index, Menu *menu);
+    Q_INVOKABLE void removeMenu(Menu *menu);
+
+    QQmlListProperty<Menu> menus();
+
+    QPlatformMenuBar *platformMenuBar() const;
+
+    void classBegin() Q_DECL_OVERRIDE;
+    void componentComplete() Q_DECL_OVERRIDE;
+
+Q_SIGNALS:
+    void menusChanged();
+
+private:
+    Q_DISABLE_COPY(MenuBar)
+    Q_DECLARE_PRIVATE(MenuBar)
+    QScopedPointer<MenuBarPrivate> d_ptr;
+};
+
+UT_NAMESPACE_END
+
+#endif // MENUBAR_P_H

=== added file 'src/Ubuntu/UbuntuToolkit/menubar_p_p.h'
--- src/Ubuntu/UbuntuToolkit/menubar_p_p.h	1970-01-01 00:00:00 +0000
+++ src/Ubuntu/UbuntuToolkit/menubar_p_p.h	2016-09-03 13:06:01 +0000
@@ -0,0 +1,78 @@
+/*
+ * Copyright 2016 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 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 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 MENUBAR_P_P_H
+#define MENUBAR_P_P_H
+
+#include "menubar_p.h"
+#include <ubuntutoolkitglobal.h>
+
+class QPlatformMenuBar;
+
+UT_NAMESPACE_BEGIN
+
+class PlatformMenuWrapper;
+
+class MenuBarPrivate
+{
+    Q_DECLARE_PUBLIC(MenuBar)
+public:
+    MenuBarPrivate(MenuBar *qq);
+    ~MenuBarPrivate();
+
+    void insertMenu(int index, Menu *menu);
+    void removeMenu(Menu *menu);
+
+    static void menu_append(QQmlListProperty<Menu> *prop, Menu *o);
+    static int menu_count(QQmlListProperty<Menu> *prop);
+    static Menu *menu_at(QQmlListProperty<Menu> *prop, int index);
+    static void menu_clear(QQmlListProperty<Menu> *prop);
+
+    MenuBar* q_ptr;
+    QPlatformMenuBar* m_platformBar;
+    QVector<Menu*> m_menus;
+    QHash<QObject*, PlatformMenuWrapper*> m_platformMenus;
+};
+
+class PlatformMenuWrapper : public QObject
+{
+    Q_OBJECT
+public:
+    PlatformMenuWrapper(Menu *target, MenuBar *bar);
+    ~PlatformMenuWrapper();
+
+    void insert(QPlatformMenu *before);
+    void remove();
+
+public Q_SLOTS:
+    void updateVisible();
+    void updateEnabled();
+    void updateText();
+    void updateIcon();
+
+private:
+    void syncPlatformMenu();
+
+    QPointer<MenuBar> m_bar;
+    QPointer<Menu> m_target;
+    bool m_inserted;
+};
+
+UT_NAMESPACE_END
+
+#endif // MENUBAR_P_P_H
+

=== added file 'src/Ubuntu/UbuntuToolkit/menugroup.cpp'
--- src/Ubuntu/UbuntuToolkit/menugroup.cpp	1970-01-01 00:00:00 +0000
+++ src/Ubuntu/UbuntuToolkit/menugroup.cpp	2016-09-03 13:06:01 +0000
@@ -0,0 +1,164 @@
+/*
+ * Copyright 2016 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 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 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 "menugroup_p.h"
+#include "actionlist_p.h"
+#include "ucaction_p.h"
+
+UT_NAMESPACE_BEGIN
+
+/*!
+ * \qmltype MenuGroup
+ * \inqmlmodule Ubuntu.Components
+ * \ingroup ubuntu
+ * \brief Logical list of items for a menu.
+ *
+ * Example usage:
+ * \qml
+ * import QtQuick 2.4
+ * import Ubuntu.Components 1.3
+ * Menu {
+ *     text: "Edit"
+ *
+ *     MenuGroup {
+ *         Action { text: "Undo" }
+ *         Action { text: "Redo" }
+ *     }
+ *
+ *     MenuGroup {
+ *         Action { text: "Cut" }
+ *         ActionList {
+ *             Action { text: "Copy" }
+ *             Action { text: "Paste" }
+ *         }
+ *     }
+ *
+ *     MenuGroup {
+ *         Action { text: "Select All" }
+ *     }
+ * }
+ * \endqml
+ */
+/*!
+ * \qmlsignal MenuGroup::added(Object action)
+ * Signal called when a action is added to the list
+ */
+
+/*!
+ * \qmlsignal MenuGroup::removed(Object action)
+ * Signal called when a action is removed from the list
+ */
+/*!
+ * \qmlsignal MenuGroup::changed()
+ * Signal called when the contents of the group change,
+ * including child content changes (eg. \l ActionList child add/remove)
+ */
+MenuGroup::MenuGroup(QObject *parent)
+    : QObject(parent)
+{
+}
+
+/*!
+ * \qmlmethod MenuGroup::addObject(Object object)
+ * Adds an Object to the list programatically.
+ */
+void MenuGroup::addObject(QObject *object)
+{
+    if (m_data.contains(object)) {
+        return;
+    }
+    m_data.push_back(object);
+
+    if (auto childGroup = qobject_cast<MenuGroup*>(object)) {
+        connect(childGroup, &MenuGroup::changed, this, &MenuGroup::changed);
+    } else if (auto actionList = qobject_cast<ActionList*>(object)) {
+        connect(actionList, &ActionList::added, this, &MenuGroup::changed);
+        connect(actionList, &ActionList::removed, this, &MenuGroup::changed);
+    }
+
+    Q_EMIT added(object);
+    Q_EMIT changed();
+}
+
+/*!
+ * \qmlmethod MenuGroup::removeObject(Object object)
+ * Removes an object from the list programatically.
+ */
+void MenuGroup::removeObject(QObject *object)
+{
+    if (!object) {
+        return;
+    }
+    if (m_data.removeOne(object)) {
+        disconnect(object, 0, this, 0);
+        Q_EMIT removed(object);
+        Q_EMIT changed();
+    }
+}
+
+/*!
+
+ * \qmlproperty list<Object> MenuGroup::data
+ * \default
+ * List of Objects in this MenuGroup
+ * Note that when you set this property, the children of the MenuGroup will be ignored,
+ * so do not set the list and define children.
+ */
+QQmlListProperty<QObject> MenuGroup::data()
+{
+    return QQmlListProperty<QObject>(this, 0, MenuGroup::append, MenuGroup::count, MenuGroup::at, MenuGroup::clear);
+}
+
+const QVector<QObject*> &MenuGroup::list() const
+{
+    return m_data;
+}
+
+void MenuGroup::append(QQmlListProperty<QObject> *list, QObject *object)
+{
+    MenuGroup *menuGroup = qobject_cast<MenuGroup*>(list->object);
+    if (menuGroup) {
+        menuGroup->addObject(object);
+    }
+}
+
+int MenuGroup::count(QQmlListProperty<QObject> *list)
+{
+    MenuGroup *menuGroup = qobject_cast<MenuGroup*>(list->object);
+    if (menuGroup) {
+        return menuGroup->m_data.count();
+    }
+    return 0;
+}
+
+QObject* MenuGroup::at(QQmlListProperty<QObject> *list, int index)
+{
+    MenuGroup *menuGroup = qobject_cast<MenuGroup*>(list->object);
+    if (menuGroup && index >=0 && menuGroup->m_data.count() > index) {
+        return menuGroup->m_data[index];
+    }
+    return Q_NULLPTR;
+}
+
+void MenuGroup::clear(QQmlListProperty<QObject> *list)
+{
+    MenuGroup *menuGroup = qobject_cast<MenuGroup*>(list->object);
+    if (menuGroup) {
+        menuGroup->m_data.clear();
+    }
+}
+
+UT_NAMESPACE_END

=== added file 'src/Ubuntu/UbuntuToolkit/menugroup_p.h'
--- src/Ubuntu/UbuntuToolkit/menugroup_p.h	1970-01-01 00:00:00 +0000
+++ src/Ubuntu/UbuntuToolkit/menugroup_p.h	2016-09-03 13:06:01 +0000
@@ -0,0 +1,60 @@
+/*
+ * Copyright 2016 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 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 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 MENUGROUP_P_H
+#define MENUGROUP_P_H
+
+#include <ubuntutoolkitglobal.h>
+
+#include <QObject>
+#include <QVector>
+#include <QQmlListProperty>
+
+UT_NAMESPACE_BEGIN
+
+class MenuGroup : public QObject
+{
+    Q_OBJECT
+    Q_PROPERTY(QQmlListProperty<QObject> data READ data)
+    Q_CLASSINFO("DefaultProperty", "data")
+public:
+    explicit MenuGroup(QObject *parent = 0);
+
+    QQmlListProperty<QObject> data();
+
+    const QVector<QObject*> &list() const;
+
+public Q_SLOTS:
+    void addObject(QObject *object);
+    void removeObject(QObject *object);
+
+Q_SIGNALS:
+    void added(QObject *object);
+    void removed(QObject *object);
+    void changed();
+
+protected:
+    QVector<QObject*> m_data;
+
+    static void append(QQmlListProperty<QObject> *list, QObject *action);
+    static int count(QQmlListProperty<QObject> *list);
+    static QObject* at(QQmlListProperty<QObject> *list, int);
+    static void clear(QQmlListProperty<QObject> *list);
+};
+
+UT_NAMESPACE_END
+
+#endif // MENUGROUP_P_H

=== added file 'src/Ubuntu/UbuntuToolkit/privates/splitviewhandler.cpp'
--- src/Ubuntu/UbuntuToolkit/privates/splitviewhandler.cpp	1970-01-01 00:00:00 +0000
+++ src/Ubuntu/UbuntuToolkit/privates/splitviewhandler.cpp	2016-09-03 13:06:01 +0000
@@ -0,0 +1,137 @@
+/*
+ * Copyright 2016 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 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 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/>.
+ *
+ * Author: Zsombor Egri <[e-mail]>
+ */
+
+#include "splitviewhandler_p_p.h"
+#include <QtQuick/private/qquickanchors_p.h>
+#include <QtQuick/private/qquickitem_p.h>
+#include <QtQuick/private/qquickevents_p_p.h>
+#include <QtQml/QQmlEngine>
+#include <QtQml/QQmlInfo>
+#include <splitview_p_p.h>
+
+UT_NAMESPACE_BEGIN
+
+SplitViewHandler::SplitViewHandler(QQuickItem *parent)
+    : QQuickMouseArea(parent)
+{
+    // for testing purposes
+    setObjectName("resize_handle");
+    setFlag(ItemHasContents);
+    setHoverEnabled(true);
+    setAcceptedButtons(Qt::LeftButton);
+
+    setCursorShape(Qt::SplitHCursor);
+    setParentItem(parent);
+
+    // attach the handler to the parent's rigth edge
+    QQuickItemPrivate *dParent = QQuickItemPrivate::get(parentItem());
+    QQuickAnchors *anchors = QQuickItemPrivate::get(this)->anchors();
+    anchors->setTop(dParent->top());
+    anchors->setBottom(dParent->bottom());
+    anchors->setLeft(dParent->right());
+
+    // capture mouse events
+    connect(this, SIGNAL(pressed(QQuickMouseEvent*)), this, SLOT(onPressed(QQuickMouseEvent*)));
+    connect(this, &SplitViewHandler::released, this, &SplitViewHandler::onReleased);
+    connect(this, &SplitViewHandler::positionChanged, this, &SplitViewHandler::onPositionChanged);
+}
+
+SplitViewHandler::~SplitViewHandler()
+{
+    if (spacing) {
+        disconnect(*spacing);
+    }
+    delete spacing;
+}
+
+void SplitViewHandler::connectToView(SplitView *view)
+{
+    this->view = view;
+    // grab the context of the parent
+    QQmlEngine::setContextForObject(this, qmlContext(view));
+
+    // bind SplitView spacing, use it to specify the resize handle
+    auto resizer = [view, this]() {
+        setWidth(view->spacing());
+    };
+    spacing = new QMetaObject::Connection;
+    *spacing = connect(view, &SplitView::spacingChanged, resizer);
+    setWidth(view->spacing());
+
+    // connect to receive handle delegate
+    connect(view, &SplitView::handleDelegateChanged,
+            this, &SplitViewHandler::onDelegateChanged);
+
+    onDelegateChanged();
+}
+
+void SplitViewHandler::onPressed(QQuickMouseEvent *event)
+{
+    prevPos = QPointF(event->x(), event->y());
+}
+
+void SplitViewHandler::onReleased(QQuickMouseEvent *event)
+{
+    Q_UNUSED(event);
+    prevPos = QPointF();
+}
+
+void SplitViewHandler::onPositionChanged(QQuickMouseEvent *event)
+{
+    if (!pressed()) {
+        return;
+    }
+    qreal dx = event->x() - prevPos.x();
+    SplitViewAttached *attached = SplitViewAttached::get(parentItem());
+    if (attached) {
+        attached->resize(dx);
+    }
+}
+
+void SplitViewHandler::onDelegateChanged()
+{
+    static bool warningShown = false;
+    // the child is an instance of the delegate
+    QList<QQuickItem*> children = childItems();
+    qDeleteAll(children);
+
+    // and set the new delegate - if any
+    if (SplitViewPrivate::get(view)->handleDelegate) {
+        QQmlContext *context = new QQmlContext(qmlContext(this), this);
+        context->setContextProperty("handle", QVariant::fromValue(this));
+        QObject *object = SplitViewPrivate::get(view)->handleDelegate->beginCreate(context);
+        if (object) {
+            QQuickItem *item = qobject_cast<QQuickItem*>(object);
+            if (!item) {
+                if (!warningShown) {
+                    qmlInfo(view) << "handle delegate not an Item";
+                    warningShown = true;
+                }
+                SplitViewPrivate::get(view)->handleDelegate->completeCreate();
+                delete object;
+            } else {
+                warningShown = false;
+                QQml_setParent_noEvent(item, this);
+                item->setParentItem(this);
+                SplitViewPrivate::get(view)->handleDelegate->completeCreate();
+            }
+        }
+    }
+}
+
+UT_NAMESPACE_END

=== added file 'src/Ubuntu/UbuntuToolkit/privates/splitviewhandler_p_p.h'
--- src/Ubuntu/UbuntuToolkit/privates/splitviewhandler_p_p.h	1970-01-01 00:00:00 +0000
+++ src/Ubuntu/UbuntuToolkit/privates/splitviewhandler_p_p.h	2016-09-03 13:06:01 +0000
@@ -0,0 +1,52 @@
+/*
+ * Copyright 2016 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 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 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/>.
+ *
+ * Author: Zsombor Egri <[e-mail]>
+ */
+
+#ifndef SPLITVIEWHANDLER_H
+#define SPLITVIEWHANDLER_H
+
+#include <QtQuick/QQuickItem>
+#include <QtCore/QPointer>
+#include <QtQuick/private/qquickmousearea_p.h>
+#include <ubuntutoolkitglobal.h>
+
+UT_NAMESPACE_BEGIN
+
+class SplitView;
+class SplitViewHandler : public QQuickMouseArea
+{
+    Q_OBJECT
+public:
+    explicit SplitViewHandler(QQuickItem *parent = 0);
+    ~SplitViewHandler();
+    void connectToView(SplitView *view);
+
+protected:
+    QPointF prevPos;
+    QPointer<SplitView> view;
+    QMetaObject::Connection *spacing{nullptr};
+
+private Q_SLOTS:
+    void onPressed(QQuickMouseEvent *event);
+    void onReleased(QQuickMouseEvent *event);
+    void onPositionChanged(QQuickMouseEvent *event);
+    void onDelegateChanged();
+};
+
+UT_NAMESPACE_END
+
+#endif // SPLITVIEWHANDLER_H

=== modified file 'src/Ubuntu/UbuntuToolkit/quickutils.cpp'
--- src/Ubuntu/UbuntuToolkit/quickutils.cpp	2016-07-07 07:21:48 +0000
+++ src/Ubuntu/UbuntuToolkit/quickutils.cpp	2016-09-03 13:06:01 +0000
@@ -36,6 +36,7 @@
 
 QuickUtils::QuickUtils(QObject *parent) :
     QObject(parent),
+    m_rootWindow(0),
     m_rootView(0),
     m_mouseAttached(false),
     m_keyboardAttached(false)
@@ -86,7 +87,7 @@
     // make sure we have the m_rootView updated
     lookupQuickView();
     if (!object) {
-        return (m_rootView) ? m_rootView->rootObject() : 0;
+        return m_rootView ? m_rootView->rootObject() : (m_rootWindow ? m_rootWindow->contentItem() : 0);
     }
 
     QQuickItem *item = qobject_cast<QQuickItem*>(object);
@@ -175,9 +176,10 @@
  */
 void QuickUtils::lookupQuickView()
 {
-    if (m_rootView)
+    if (m_rootWindow)
         return;
     Q_FOREACH (QWindow *w, QGuiApplication::topLevelWindows()) {
+        m_rootWindow = qobject_cast<QQuickWindow*>(w);
         m_rootView = qobject_cast<QQuickView*>(w);
         if (m_rootView) {
             // connect in case we get the root object changed

=== modified file 'src/Ubuntu/UbuntuToolkit/quickutils_p.h'
--- src/Ubuntu/UbuntuToolkit/quickutils_p.h	2016-07-07 07:21:48 +0000
+++ src/Ubuntu/UbuntuToolkit/quickutils_p.h	2016-09-03 13:06:01 +0000
@@ -85,6 +85,7 @@
 
 private:
     explicit QuickUtils(QObject *parent = 0);
+    QPointer<QQuickWindow> m_rootWindow;
     QPointer<QQuickView> m_rootView;
     QStringList m_omitIM;
     bool m_mouseAttached;

=== added file 'src/Ubuntu/UbuntuToolkit/splitview.cpp'
--- src/Ubuntu/UbuntuToolkit/splitview.cpp	1970-01-01 00:00:00 +0000
+++ src/Ubuntu/UbuntuToolkit/splitview.cpp	2016-09-03 13:06:01 +0000
@@ -0,0 +1,675 @@
+/*
+ * Copyright 2016 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 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 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/>.
+ *
+ * Author: Zsombor Egri <[e-mail]>
+ */
+
+#include <QtQuick/private/qquickitem_p.h>
+#include <QtQuick/private/qquickanchors_p.h>
+#include <QtQml/QQmlInfo>
+
+#include "splitview_p.h"
+#include "splitview_p_p.h"
+#include "ucunits_p.h"
+#include "ucpagetreenode_p.h"
+
+#include "privates/splitviewhandler_p_p.h"
+
+#define DEFAULT_SPACING_DP      4
+
+UT_NAMESPACE_BEGIN
+
+/*!
+ * \qmltype SplitView
+ * \inqmlmodule Ubuntu.Components.Labs 1.0
+ * \inherits QQuickBasePositioner
+ * \ingroup ubuntu-labs
+ * \brief A view component with a flexible layout configuration setup.
+ *
+ * The component arranges the declared child elements horizontally based on an active
+ * column configuration layout. Child elements are considered to be views, and each view
+ * is identified with a column index, specified by the SplitView.column attached property.
+ * Views should not have width declared, because the width of each view is specified
+ * by the active layout's configuration (ViewColumn) and will overwrite the value
+ * specified by the view. On the other hand they should have a height specified, or
+ * they can be anchored to the top and bottom of the view. SplitView being a positioner,
+ * remember not to anchor horizontal anchor lines or anchor fill the columns.
+ *
+ * In order for a SplitView to show some content it must have at least one active layout
+ * present. Views which are not configured by the active layout will be hidden. Hidden
+ * views may be resized, therefore if the content is size sensitive (i.e. the amount
+ * shown differs depending on the space available), make sure the content of your view
+ * does take this into account.
+ * \code
+ * import QtQuick 2.4
+ * import Ubuntu.Components 1.3
+ * import Ubuntu.Components.Labs 1.0
+ *
+ * MainView {
+ *     id: main
+ *     width: units.gu(300)
+ *     height: units.gu(80)
+ *     SplitView {
+ *         anchors.fill: parent
+ *         layouts: [
+ *             SplitViewLayout {
+ *                 when: main.width < units.gu(80)
+ *                 ViewColumn {
+ *                     fillWidth: true
+ *                 }
+ *             },
+ *             SplitViewLayout {
+ *                 when: main.width >= units.gu(80)
+ *                 ViewColumn {
+ *                     minimumWidth: units.gu(30)
+ *                     maximumWidth: units.gu(100)
+ *                     preferredWidth: units.gu(40)
+ *                 }
+ *                 ViewColumn {
+ *                     minimumWidth: units.gu(40)
+ *                     fillWidth: true
+ *                 }
+ *             }
+ *         ]
+ *     }
+ *
+ *     Page {
+ *         id: column1
+ *         height: parent.height
+ *     }
+ *     Page {
+ *         id: column2
+ *         height: parent.height
+ *     }
+ * }
+ * \endcode
+ *
+ * The SplitView can be used with a Repeater in case the content of the view columns
+ * doesn't need to be preserved between layout changes. The example above with a
+ * Repeater would look as follows:
+ * \code
+ * import QtQuick 2.4
+ * import Ubuntu.Components 1.3
+ * import Ubuntu.Components.Labs 1.0
+ *
+ * MainView {
+ *     id: main
+ *     width: units.gu(300)
+ *     height: units.gu(80)
+ *     SplitView {
+ *         id: view
+ *         anchors.fill: parent
+ *         layouts: [
+ *             SplitViewLayout {
+ *                 when: main.width < units.gu(80)
+ *                 ViewColumn {
+ *                     fillWidth: true
+ *                 }
+ *             },
+ *             SplitViewLayout {
+ *                 when: main.width >= units.gu(80)
+ *                 ViewColumn {
+ *                     minimumWidth: units.gu(30)
+ *                     maximumWidth: units.gu(100)
+ *                     preferredWidth: units.gu(40)
+ *                 }
+ *                 ViewColumn {
+ *                     minimumWidth: units.gu(40)
+ *                     fillWidth: true
+ *                 }
+ *             }
+ *         ]
+ *     }
+ *
+ *     Repeater {
+ *         model: view.activeLayout.columns
+ *         Page {
+ *             height: parent.height
+ *         }
+ *     }
+ * }
+ * \endcode
+ *
+ * \section2 Resizing
+ * SplitView provides the ability to resize view columns. Each column has an attached
+ * handle which provides the ability to resize the columns using a mouse or touch.
+ * Columns can be resized if the spacing property is set and the column configurations
+ * allow that (see \l spacing property).
+ *
+ * \section2 Attached properties
+ * SplitView provides a set of attached properties to each column view. Views can in
+ * this way have access to various values of the SplitView and configurations.
+ */
+
+/*!
+ * \qmlproperty real SplitView::spacing
+ * Spacing between view columns. A value bigger than 0 enables resizing of columns with
+ * a \l{ViewColumn::minimumWidth}{minimumWidth} lower than \l {ViewColumn::maximumWidth}{maximumWidth}.
+ * If spacing is 0 the columns cannot be resized.
+ * Defaults to 4 device pixels.
+ */
+void SplitView::setSpacing2(qreal spacing, bool reset)
+{
+    Q_D(SplitView);
+    if (reset && d->defaultSpacing) {
+        QObject::disconnect(*d->defaultSpacing);
+        delete d->defaultSpacing;
+        d->defaultSpacing = Q_NULLPTR;
+    }
+    if (qFuzzyCompare(this->spacing(), spacing)) {
+        return;
+    }
+    static_cast<QQuickBasePositioner*>(this)->setSpacing(spacing);
+}
+
+/******************************************************************************
+ * SplitViewAttached
+ */
+SplitViewAttached::SplitViewAttached(QObject *parent)
+    : QObject(*(new SplitViewAttachedPrivate), parent)
+{
+}
+
+SplitViewAttached *SplitViewAttached::get(QQuickItem *item)
+{
+    SplitViewAttached *attached = static_cast<SplitViewAttached*>(
+                qmlAttachedPropertiesObject<SplitView>(item, false));
+    return attached;
+}
+
+ViewColumn *SplitViewAttachedPrivate::getConfig(QQuickItem *attachee)
+{
+    SplitViewAttached *attached = SplitViewAttached::get(attachee);
+    if (!attached) {
+        return nullptr;
+    }
+    return get(attached)->config();
+}
+
+void SplitViewAttachedPrivate::configure(SplitView *view, int column)
+{
+    this->column = column;
+    splitView = view;
+    Q_EMIT q_func()->columnChanged();
+}
+
+void SplitViewAttached::resize(qreal delta)
+{
+    Q_D(SplitViewAttached);
+    ViewColumn *config = d->config();
+    if (config) {
+        config->resize(delta);
+    }
+}
+
+/*!
+ * \qmlattachedproperty ViewColumn SplitView::columnConfig
+ * The attached property holds the active layout's column configuration data.
+ * The value is null if there is no active configuration value provided for
+ * the column.
+ */
+UT_PREPEND_NAMESPACE(ViewColumn*) SplitViewAttachedPrivate::config()
+{
+    if (!splitView || column < 0) {
+        return nullptr;
+    }
+    SplitViewPrivate *d = SplitViewPrivate::get(splitView);
+    if (!d->activeLayout) {
+        return nullptr;
+    }
+    if (SplitViewLayoutPrivate::get(d->activeLayout)->columnData.size() <= column) {
+        return nullptr;
+    }
+    return SplitViewLayoutPrivate::get(d->activeLayout)->columnData[column];
+}
+
+/*!
+ * \qmlattachedproperty SplitView SplitView::view
+ * Contains the SplitView instance of the column.
+ */
+
+/*!
+ * \qmlattachedproperty int SplitView::column
+ * The property holds the column index the view is configured to.
+ */
+
+/******************************************************************************
+ * SplitView
+ */
+SplitViewPrivate::SplitViewPrivate(SplitView *qq)
+    : q_ptr(qq)
+{
+}
+
+SplitViewPrivate::~SplitViewPrivate()
+{
+}
+
+UT_PREPEND_NAMESPACE(SplitViewAttached) *SplitView::qmlAttachedProperties(QObject *owner)
+{
+    return new SplitViewAttached(owner);
+}
+
+// layouts property
+/*!
+ * \qmlproperty list<SplitViewLayout> SplitView::layouts
+ * The property holds the layout configurations declared for the given SplitView.
+ * \sa SplitViewLayout
+ */
+void SplitViewPrivate::layout_Append(QQmlListProperty<SplitViewLayout> *list, SplitViewLayout* layout)
+{
+    SplitView *view = static_cast<SplitView*>(list->object);
+    SplitViewPrivate *d = SplitViewPrivate::get(view);
+    d->columnLatouts.append(layout);
+    // parent layout to view
+    layout->setParent(view);
+    // capture layout activation
+    QObject::connect(layout, SIGNAL(whenChanged()), view, SLOT(changeLayout()), Qt::DirectConnection);
+    Q_EMIT view->layoutsChanged();
+}
+int SplitViewPrivate::layout_Count(QQmlListProperty<SplitViewLayout> *list)
+{
+    SplitView *view = static_cast<SplitView*>(list->object);
+    SplitViewPrivate *d = SplitViewPrivate::get(view);
+    return d->columnLatouts.size();
+}
+SplitViewLayout *SplitViewPrivate::layout_At(QQmlListProperty<SplitViewLayout> *list, int index)
+{
+    SplitView *view = static_cast<SplitView*>(list->object);
+    SplitViewPrivate *d = SplitViewPrivate::get(view);
+    return d->columnLatouts.at(index);
+}
+void SplitViewPrivate::layout_Clear(QQmlListProperty<SplitViewLayout> *list)
+{
+    SplitView *view = static_cast<SplitView*>(list->object);
+    SplitViewPrivate *d = SplitViewPrivate::get(view);
+    for (SplitViewLayout *layout : d->columnLatouts) {
+        // disconnect layout activation
+        QObject::disconnect(layout, SIGNAL(whenChanged()), view, SLOT(changeLayout()));
+        delete layout;
+    }
+    d->columnLatouts.clear();
+    d->activeLayout = nullptr;
+    Q_EMIT view->layoutsChanged();
+}
+QQmlListProperty<SplitViewLayout> SplitViewPrivate::layouts()
+{
+    Q_Q(SplitView);
+    return QQmlListProperty<SplitViewLayout>(q, (void*)&columnLatouts,
+                                             &layout_Append,
+                                             &layout_Count,
+                                             &layout_At,
+                                             &layout_Clear);
+}
+
+/*!
+ * \qmlproperty SplitViewLayout SplitView::activeLayout
+ * \readonly
+ * The property holds the active SplitViewLayout instance, or null is no layout
+ * is active.
+ */
+UT_PREPEND_NAMESPACE(SplitViewLayout) *SplitViewPrivate::getActiveLayout()
+{
+    return activeLayout;
+}
+
+// invoked when one of the SplitViewLayouts emits whenChanged()
+void SplitViewPrivate::changeLayout()
+{
+    // go through layouts and check who's the active one
+    SplitViewLayout *newActive = nullptr;
+    for (SplitViewLayout *layout : columnLatouts) {
+        if (SplitViewLayoutPrivate::get(layout)->when) {
+            newActive = layout;
+            break;
+        }
+    }
+    if (newActive == activeLayout) {
+        return;
+    }
+
+    // Q: should we reset the sizes of the previous layout?
+    // at least it feels  right to preserve the last state of the layout...
+    activeLayout = newActive;
+
+    Q_EMIT q_func()->activeLayoutChanged();
+
+    updateLayout();
+    if (q_func()->sender()) {
+        // was called by a whenChanged() signal invocation
+        recalculateWidths(RecalculateAll);
+    }
+}
+
+void SplitViewPrivate::updateLayout()
+{
+    Q_Q(SplitView);
+    for (QQuickItem *child : q->childItems()) {
+        bool visible = true;
+        ViewColumn *columnConfig = SplitViewAttachedPrivate::getConfig(child);
+        if (!columnConfig) {
+            // no configuration for the column, hide it
+            visible = false;
+        } else {
+            ViewColumnPrivate *config = ViewColumnPrivate::get(columnConfig);
+            visible = activeLayout
+                    && (config->column < SplitViewLayoutPrivate::get(activeLayout)->columnData.size());
+        }
+        dirty = dirty | (child->isVisible() != visible);
+        child->setVisible(visible);
+    }
+}
+
+void SplitViewPrivate::recalculateWidths(RelayoutOperation operation)
+{
+    if (!activeLayout || (!QQuickItemPrivate::get(q_func())->componentComplete && !dirty)) {
+        return;
+    }
+    Q_Q(SplitView);
+
+    // remove the spacing from the width
+    qreal fillWidth = q->width() - q->spacing() * (SplitViewLayoutPrivate::get(activeLayout)->columnData.size() - 1);
+    // stack of columns with fillWidth true
+    QList<QQuickItem*> fillStack;
+
+    for (QQuickItem *child : q->childItems()) {
+        ViewColumn *columnConfig = SplitViewAttachedPrivate::getConfig(child);
+        if (!columnConfig) {
+            continue;
+        }
+        ViewColumnPrivate *config = ViewColumnPrivate::get(columnConfig);
+
+        if (config->fillWidth && !config->resized) {
+            // add to the fillWidth stack
+            if (operation & CalculateFillWidth) {
+                fillStack << child;
+            }
+        } else {
+            if (operation & SetPreferredSize) {
+                child->setWidth(config->preferredWidth);
+            }
+            if (operation & CalculateFillWidth) {
+                fillWidth -= config->preferredWidth;
+            }
+        }
+    }
+
+    // split the width between the stacked fillWidth columns
+    if (fillStack.size() && (operation & CalculateFillWidth)) {
+        fillWidth /= fillStack.size();
+        for (QQuickItem *child : fillStack) {
+            // even though the column is fillWidth, it may have min and max specified;
+            // check if the size can be applied
+            ViewColumnPrivate *config = ViewColumnPrivate::get(SplitViewAttachedPrivate::getConfig(child));
+            config->setPreferredWidth(fillWidth, false);
+            // update preferredWidth so it can be used in case of resize
+            child->setWidth(config->preferredWidth);
+        }
+    }
+    dirty = false;
+}
+
+/*!
+ * \qmlproperty Component SplitView::handleDelegate
+ * The property holds the delegate to be shown for the column resizing handle.
+ * The delegate is for pure visual, mouse and touch handling is provided by the
+ * SplitView component itself. The component provides a context property called
+ * \e handle which embeds the visuals. This can be used to anchor the visuals
+ * to the resize handle. The thickness of the handle is driven by the \l spacing
+ * property.
+ * \code
+ * import QtQuick 2.4
+ * import Ubuntu.Components 1.3
+ * import Ubuntu.Components.Labs 1.0
+ *
+ * MainView {
+ *     id: main
+ *     width: units.gu(300)
+ *     height: units.gu(80)
+ *
+ *     SplitView {
+ *         anchors.fill: parent
+ *         handleDelegate: Rectangle {
+ *             anchors {
+ *                 fill: parent
+ *                 leftMargin: units.dp(2)
+ *                 rightMargin: units.dp(2)
+ *                 topMargin: handle.height / 2 - units.gu(3)
+ *                 bottomMargin: handle.height / 2 - units.gu(3)
+ *             }
+ *             color: UbuntuColors.graphite
+ *             scale: handle.containsMouse || handle.pressed ? 1.6 : 1.0
+ *             Behavior on scale { UbuntuNumberAnimation {} }
+ *         }
+ *         layouts: [
+ *             SplitViewLayout {
+ *                 when: main.width < units.gu(80)
+ *                 ViewColumn {
+ *                     fillWidth: true
+ *                 }
+ *             },
+ *             SplitViewLayout {
+ *                 when: main.width >= units.gu(80)
+ *                 ViewColumn {
+ *                     minimumWidth: units.gu(30)
+ *                     maximumWidth: units.gu(100)
+ *                     preferredWidth: units.gu(40)
+ *                 }
+ *                 ViewColumn {
+ *                     minimumWidth: units.gu(40)
+ *                     fillWidth: true
+ *                 }
+ *             }
+ *         ]
+ *     }
+ *
+ *     Page {
+ *         id: column1
+ *         height: parent.height
+ *     }
+ *     Page {
+ *         id: column2
+ *         height: parent.height
+ *     }
+ * }
+ * \endcode
+ */
+
+SplitView::SplitView(QQuickItem *parent)
+    : QQuickBasePositioner(Horizontal, parent)
+    , d_ptr(new SplitViewPrivate(this))
+{
+    Q_D(SplitView);
+    d->init();
+}
+
+SplitView::SplitView(SplitViewPrivate &dd, QQuickItem *parent)
+    : QQuickBasePositioner(Vertical, parent)
+    , d_ptr(&dd)
+{
+    Q_D(SplitView);
+    d->init();
+}
+
+SplitView::~SplitView()
+{
+    Q_D(SplitView);
+    delete d;
+}
+
+void SplitViewPrivate::init()
+{
+    Q_Q(SplitView);
+    auto spacingHandle = [q]() {
+        q->setSpacing2(UCUnits::instance(q)->dp(DEFAULT_SPACING_DP), false);
+    };
+    defaultSpacing = new QMetaObject::Connection;
+    *defaultSpacing = QObject::connect(UCUnits::instance(q), &UCUnits::gridUnitChanged, spacingHandle);
+
+    // connect the spacingChanged signals
+    QObject::connect(q, SIGNAL(spacingChanged()), q, SIGNAL(spacingChanged2()));
+
+    // set the defaults
+    q->setSpacing2(UCUnits::instance(q)->dp(DEFAULT_SPACING_DP), false);
+}
+
+void SplitView::doPositioning(QSizeF *contentSize)
+{
+    // Inspired from QtQuick QQuickRow code
+    // FIXME: revisit the code once we move to Qt 5.6 as there were more properties added to positioner
+
+    // calculate the layout before we go into the positioning
+    d_func()->recalculateWidths(SplitViewPrivate::RecalculateAll);
+
+    //Precondition: All items in the positioned list have a valid item pointer and should be positioned
+    QQuickItemPrivate *d = QQuickItemPrivate::get(this);
+    qreal hoffset = 0;
+
+    QList<qreal> hoffsets;
+    for (int ii = 0; ii < positionedItems.count(); ++ii) {
+        PositionedItem &child = positionedItems[ii];
+
+        if (!d->effectiveLayoutMirror) {
+            positionItemX(hoffset, &child);
+        } else {
+            hoffsets << hoffset;
+        }
+
+        contentSize->setHeight(qMax(contentSize->height(), child.item->height()));
+
+        hoffset += child.item->width();
+        hoffset += spacing();
+    }
+
+    if (hoffset != 0) { //If we positioned any items, undo the extra spacing from the last item
+        hoffset -= spacing();
+    }
+    contentSize->setWidth(hoffset);
+
+    if (!d->effectiveLayoutMirror) {
+        return;
+    }
+
+    //Right to Left layout
+    qreal end = 0;
+    if (!widthValid()) {
+        end = contentSize->width();
+    } else {
+        end = width();
+    }
+
+    int acc = 0;
+    for (int ii = 0; ii < positionedItems.count(); ++ii) {
+        PositionedItem &child = positionedItems[ii];
+        hoffset = end - hoffsets[acc++] - child.item->width();
+        positionItemX(hoffset, &child);
+    }
+}
+
+void SplitView::reportConflictingAnchors()
+{
+    // Inspired from QtQuick QQuickColumn code
+    bool anchorConflict = false;
+    for (int ii = 0; ii < positionedItems.count(); ++ii) {
+        const PositionedItem &child = positionedItems.at(ii);
+        if (child.item) {
+            QQuickAnchors *anchors = QQuickItemPrivate::get(static_cast<QQuickItem *>(child.item))->_anchors;
+            if (anchors) {
+                // can we patch out the anchors (Page?)
+                if (qobject_cast<UCPageTreeNode*>(child.item)) {
+                    // unset left anchor
+                    anchors->resetLeft();
+                }
+                QQuickAnchors::Anchors usedAnchors = anchors->usedAnchors();
+                if (usedAnchors & QQuickAnchors::LeftAnchor ||
+                        usedAnchors & QQuickAnchors::RightAnchor ||
+                        usedAnchors & QQuickAnchors::HCenterAnchor ||
+                        anchors->fill() || anchors->centerIn()) {
+                    anchorConflict = true;
+                    break;
+                }
+            }
+        }
+    }
+    if (anchorConflict) {
+        qmlInfo(this) << "Cannot specify left, right, horizontalCenter, fill or centerIn anchors for items inside SplitView."
+                      << " SplitView will not function.";
+    }
+}
+
+void SplitView::componentComplete()
+{
+    Q_D(SplitView);
+    d->changeLayout();
+    QQuickBasePositioner::componentComplete();
+}
+
+void SplitView::geometryChanged(const QRectF &newGeometry, const QRectF &oldGeometry)
+{
+    QQuickBasePositioner::geometryChanged(newGeometry, oldGeometry);
+    // if we have fillWidths, recalculate those!
+    // call this on horizontal resize, vertical one will do its job
+    if (newGeometry.width() != oldGeometry.width()) {
+        Q_D(SplitView);
+        d->recalculateWidths(SplitViewPrivate::CalculateFillWidth);
+    }
+}
+
+void SplitView::itemChange(ItemChange change, const ItemChangeData &data)
+{
+    QQuickBasePositioner::itemChange(change, data);
+    // we must exclude Repeater
+    switch (change) {
+    case ItemChildAddedChange:
+        if (data.item && !data.item->inherits("QQuickRepeater")) {
+            // attach properties and configure
+            SplitViewAttached *attached = static_cast<SplitViewAttached*>(
+                        qmlAttachedPropertiesObject<SplitView>(data.item, true));
+
+            Q_D(SplitView);
+            SplitViewAttachedPrivate::get(attached)->configure(this, d->viewCount++);
+
+            // attach the split handler to it
+            SplitViewHandler *handler = new SplitViewHandler(data.item);
+            handler->connectToView(this);
+        }
+        break;
+    case ItemChildRemovedChange:
+        if (data.item && !data.item->inherits("QQuickRepeater")) {
+            Q_D(SplitView);
+            d->viewCount--;
+        }
+        break;
+    default: // ommit the rest
+        break;
+    }
+}
+
+/******************************************************************
+ * properties
+ */
+
+void SplitViewPrivate::setHandle(QQmlComponent *delegate)
+{
+    if (handleDelegate == delegate) {
+        return;
+    }
+    handleDelegate = delegate;
+    Q_EMIT q_func()->handleDelegateChanged();
+}
+
+UT_NAMESPACE_END
+
+#include "moc_splitview_p.cpp"

=== added file 'src/Ubuntu/UbuntuToolkit/splitview_p.h'
--- src/Ubuntu/UbuntuToolkit/splitview_p.h	1970-01-01 00:00:00 +0000
+++ src/Ubuntu/UbuntuToolkit/splitview_p.h	2016-09-03 13:06:01 +0000
@@ -0,0 +1,160 @@
+/*
+ * Copyright 2016 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 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 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/>.
+ *
+ * Author: Zsombor Egri <[e-mail]>
+ */
+
+#ifndef SPLITVIEW_P_H
+#define SPLITVIEW_P_H
+
+#include <QtQuick/private/qquickpositioners_p.h>
+
+#include "ubuntutoolkitglobal.h"
+
+UT_NAMESPACE_BEGIN
+
+class ViewColumnPrivate;
+class ViewColumn : public QObject, public QQmlParserStatus
+{
+    Q_OBJECT
+    Q_INTERFACES(QQmlParserStatus)
+    Q_PRIVATE_PROPERTY(ViewColumn::d_func(), bool fillWidth MEMBER fillWidth WRITE setFillWidth NOTIFY fillWidthChanged)
+    Q_PRIVATE_PROPERTY(ViewColumn::d_func(), qreal minimumWidth MEMBER minimumWidth WRITE setMinimumWidth NOTIFY minimumWidthChanged)
+    Q_PRIVATE_PROPERTY(ViewColumn::d_func(), qreal maximumWidth MEMBER maximumWidth WRITE setMaximumWidth NOTIFY maximumWidthChanged)
+    Q_PRIVATE_PROPERTY(ViewColumn::d_func(), qreal preferredWidth MEMBER preferredWidth WRITE setPreferredWidth NOTIFY preferredWidthChanged)
+public:
+    explicit ViewColumn(QObject *parent = 0);
+
+    bool resize(qreal delta);
+
+Q_SIGNALS:
+    void minimumWidthChanged();
+    void maximumWidthChanged();
+    void preferredWidthChanged();
+    void fillWidthChanged();
+
+protected:
+    // from QQmlParserStatus
+    void classBegin() override {}
+    void componentComplete() override;
+private:
+    Q_DECLARE_PRIVATE(ViewColumn)
+};
+
+class SplitViewLayoutPrivate;
+class SplitViewLayout : public QObject
+{
+    Q_OBJECT
+
+    Q_PRIVATE_PROPERTY(SplitViewLayout::d_func(), bool when MEMBER when NOTIFY whenChanged)
+#ifdef Q_QDOC
+    Q_PRIVATE_PROPERTY(SplitViewLayout::d_func(), QQmlListProperty<ViewColumn> columns READ columns NOTIFY columnsChanged DESIGNABLE false)
+#else
+    Q_PRIVATE_PROPERTY(SplitViewLayout::d_func(), QQmlListProperty<UT_PREPEND_NAMESPACE(ViewColumn)> columns READ columns NOTIFY columnsChanged DESIGNABLE false)
+#endif
+    Q_CLASSINFO("DefaultProperty", "columns")
+public:
+    explicit SplitViewLayout(QObject *parent = 0);
+
+Q_SIGNALS:
+    void whenChanged();
+    void columnsChanged();
+
+private:
+    Q_DECLARE_PRIVATE(SplitViewLayout)
+};
+
+class SplitView;
+class SplitViewAttachedPrivate;
+class SplitViewAttached : public QObject
+{
+    Q_OBJECT
+    Q_PRIVATE_PROPERTY(SplitViewAttached::d_func(), int column READ getColumn NOTIFY columnChanged)
+#ifdef Q_QDOC
+    Q_PRIVATE_PROPERTY(SplitViewAttached::d_func(), SplitView* view READ view)
+    Q_PRIVATE_PROPERTY(SplitViewAttached::d_func(), ViewColumn* columnConfig READ config NOTIFY columnChanged)
+#else
+    Q_PRIVATE_PROPERTY(SplitViewAttached::d_func(), UT_PREPEND_NAMESPACE(SplitView*) view READ view)
+    Q_PRIVATE_PROPERTY(SplitViewAttached::d_func(), UT_PREPEND_NAMESPACE(ViewColumn*) columnConfig READ config NOTIFY columnChanged)
+#endif
+public:
+    explicit SplitViewAttached(QObject *parent = 0);
+
+    static SplitViewAttached *get(QQuickItem *item);
+
+    void resize(qreal delta);
+
+Q_SIGNALS:
+    void columnChanged();
+
+private:
+    Q_DECLARE_PRIVATE(SplitViewAttached)
+};
+
+class SplitViewPrivate;
+class SplitView : public QQuickBasePositioner
+{
+    Q_OBJECT
+#ifdef Q_QDOC
+    Q_PRIVATE_PROPERTY(SplitView::d_func(), QQmlListProperty<SplitViewLayout> layouts READ layouts NOTIFY layoutsChanged DESIGNABLE false)
+    Q_PRIVATE_PROPERTY(SplitView::d_func(), SplitViewLayout *activeLayout READ getActiveLayout NOTIFY activeLayoutChanged)
+#else
+    Q_PRIVATE_PROPERTY(SplitView::d_func(), QQmlListProperty<UT_PREPEND_NAMESPACE(SplitViewLayout)> layouts READ layouts NOTIFY layoutsChanged DESIGNABLE false)
+    Q_PRIVATE_PROPERTY(SplitView::d_func(), UT_PREPEND_NAMESPACE(SplitViewLayout) *activeLayout READ getActiveLayout NOTIFY activeLayoutChanged)
+#endif
+    Q_PRIVATE_PROPERTY(SplitView::d_func(), QQmlComponent *handleDelegate MEMBER handleDelegate WRITE setHandle NOTIFY handleDelegateChanged)
+    // overrides
+    Q_PROPERTY(qreal spacing READ spacing WRITE setSpacing2 NOTIFY spacingChanged2)
+public:
+    explicit SplitView(QQuickItem *parent = 0);
+
+    static UT_PREPEND_NAMESPACE(SplitViewAttached) *qmlAttachedProperties(QObject*);
+
+Q_SIGNALS:
+    void layoutsChanged();
+    void activeLayoutChanged();
+    void handleDelegateChanged();
+    void spacingChanged2();
+
+protected:
+    SplitView(SplitViewPrivate &, QQuickItem *);
+    ~SplitView();
+
+    // property setters
+    void setSpacing2(qreal spacing, bool reset = true);
+
+    // from QQuickBasePositioner
+    void doPositioning(QSizeF *contentSize) override;
+    void reportConflictingAnchors() override;
+
+    // overrides
+    void componentComplete() override;
+    void geometryChanged(const QRectF &newGeometry, const QRectF &oldGeometry) override;
+    void itemChange(ItemChange, const ItemChangeData &) override;
+private:
+    // QQuickBasePositionerPrivate is not an exported API, therefore we cannot derive from it
+    SplitViewPrivate* const d_ptr;
+    Q_DECLARE_PRIVATE_D(d_ptr, SplitView)
+    Q_PRIVATE_SLOT(d_func(), void changeLayout())
+};
+
+UT_NAMESPACE_END
+
+QML_DECLARE_TYPE(UT_PREPEND_NAMESPACE(ViewColumn))
+QML_DECLARE_TYPE(UT_PREPEND_NAMESPACE(SplitViewLayout))
+QML_DECLARE_TYPE(UT_PREPEND_NAMESPACE(SplitView))
+QML_DECLARE_TYPEINFO(UT_PREPEND_NAMESPACE(SplitView), QML_HAS_ATTACHED_PROPERTIES)
+
+#endif // SPLITVIEW_P_H

=== added file 'src/Ubuntu/UbuntuToolkit/splitview_p_p.h'
--- src/Ubuntu/UbuntuToolkit/splitview_p_p.h	1970-01-01 00:00:00 +0000
+++ src/Ubuntu/UbuntuToolkit/splitview_p_p.h	2016-09-03 13:06:01 +0000
@@ -0,0 +1,154 @@
+/*
+ * Copyright 2016 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 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 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/>.
+ *
+ * Author: Zsombor Egri <[e-mail]>
+ */
+
+#ifndef SPLITVIEW_P_P_H
+#define SPLITVIEW_P_P_H
+
+#include "splitview_p.h"
+#include <QtCore/private/qobject_p.h>
+
+UT_NAMESPACE_BEGIN
+
+class ViewColumnPrivate : public QObjectPrivate
+{
+    Q_DECLARE_PUBLIC(ViewColumn)
+
+public:
+    ViewColumnPrivate() {}
+
+    static ViewColumnPrivate *get(ViewColumn *q)
+    {
+        return q ? q->d_func() : nullptr;
+    }
+
+    void setMinimumWidth(qreal width);
+    void setMaximumWidth(qreal width);
+    void setPreferredWidth(qreal width, bool notify = true);
+    void setFillWidth(bool fill);
+
+    void recalculateLayoutContent();
+
+    qreal minimumWidth{0.0};
+    qreal maximumWidth{std::numeric_limits<qreal>::max()};
+    qreal preferredWidth{0.0};
+    int column{-1};
+    bool fillWidth{false};
+    bool resized{false};
+    bool completed{false};
+};
+
+class SplitViewLayoutPrivate : public QObjectPrivate
+{
+    Q_DECLARE_PUBLIC(SplitViewLayout)
+public:
+    SplitViewLayoutPrivate() {}
+    static SplitViewLayoutPrivate *get(SplitViewLayout *q)
+    {
+        return q->d_func();
+    }
+
+    QQmlListProperty<UT_PREPEND_NAMESPACE(ViewColumn)> columns();
+
+    QList<ViewColumn*> columnData;
+    bool when{false};
+
+private:
+    static void columns_Append(QQmlListProperty<ViewColumn> *, ViewColumn*);
+    static int columns_Count(QQmlListProperty<ViewColumn> *);
+    static ViewColumn *columns_At(QQmlListProperty<ViewColumn> *, int);
+    static void columns_Clear(QQmlListProperty<ViewColumn> *);
+};
+
+class SplitViewAttachedPrivate : public QObjectPrivate
+{
+    Q_DECLARE_PUBLIC(SplitViewAttached)
+public:
+    SplitViewAttachedPrivate() {}
+
+    static SplitViewAttachedPrivate *get(SplitViewAttached *q)
+    {
+        return q->d_func();
+    }
+    static ViewColumn *getConfig(QQuickItem *attachee);
+
+    UT_PREPEND_NAMESPACE(SplitView*) view() const
+    {
+        return splitView;
+    }
+    int getColumn() const
+    {
+        return column;
+    }
+    void configure(SplitView *view, int column);
+    UT_PREPEND_NAMESPACE(ViewColumn*) config();
+
+    SplitView *splitView{nullptr};
+    int column{-1};
+};
+
+class SplitViewPrivate
+{
+    SplitView *const q_ptr{nullptr};
+    Q_DECLARE_PUBLIC(SplitView)
+
+public:
+    enum RelayoutOperation {
+        SetPreferredSize = 0x01,
+        CalculateFillWidth = 0x02,
+        RecalculateAll = 0xFF
+    };
+
+    SplitViewPrivate(SplitView *qq);
+    virtual ~SplitViewPrivate();
+    void init();
+
+    static SplitViewPrivate *get(SplitView *q)
+    {
+        return q->d_func();
+    }
+
+    QQmlListProperty<QObject> data();
+    QQmlListProperty<UT_PREPEND_NAMESPACE(SplitViewLayout)> layouts();
+    UT_PREPEND_NAMESPACE(SplitViewLayout) *getActiveLayout();
+
+    void updateLayout();
+    void recalculateWidths(RelayoutOperation operation);
+    void setHandle(QQmlComponent *delegate);
+
+    // private slots
+    void changeLayout();
+
+    // members
+    QList<SplitViewLayout*> columnLatouts;
+    SplitViewLayout* activeLayout{nullptr};
+    QQmlComponent *handleDelegate{nullptr};
+    QMetaObject::Connection *defaultSpacing{nullptr};
+    int viewCount{0};
+    bool dirty{false};
+
+private:
+    static void layout_Append(QQmlListProperty<SplitViewLayout> *, SplitViewLayout*);
+    static int layout_Count(QQmlListProperty<SplitViewLayout> *);
+    static SplitViewLayout *layout_At(QQmlListProperty<SplitViewLayout> *, int);
+    static void layout_Clear(QQmlListProperty<SplitViewLayout> *);
+};
+
+UT_NAMESPACE_END
+
+#endif // SPLITVIEW_P_P_H
+

=== added file 'src/Ubuntu/UbuntuToolkit/splitviewlayout.cpp'
--- src/Ubuntu/UbuntuToolkit/splitviewlayout.cpp	1970-01-01 00:00:00 +0000
+++ src/Ubuntu/UbuntuToolkit/splitviewlayout.cpp	2016-09-03 13:06:01 +0000
@@ -0,0 +1,252 @@
+/* Copyright 2016 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 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 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/>.
+ *
+ * Author: Zsombor Egri <[e-mail]>
+ */
+
+#include <QtQuick/private/qquickitem_p.h>
+#include <QtQuick/private/qquickanchors_p.h>
+#include <QtQml/QQmlInfo>
+
+#include "splitview_p.h"
+#include "splitview_p_p.h"
+#include "ucmathutils_p.h"
+
+UT_NAMESPACE_BEGIN
+
+/******************************************************************************
+ * ViewColumn configuration object
+ */
+/*!
+ * \qmltype ViewColumn
+ * \inmodule Ubuntu.Components.Labs
+ * \ingroup ubuntu-labs
+ * \brief View column metrics configuration for SplitView.
+ *
+ * The component provides width metrics configuration for SplitView layout
+ * columns. The values are applied on columns by an active SplitViewLayout.
+ * On resizing, the values are preserved for the entire lifetime of the
+ * component, even when the active layout is changed into an other one.
+ * When changed back, the previous values will be used.
+ */
+ViewColumn::ViewColumn(QObject *parent)
+    : QObject(*(new ViewColumnPrivate), parent)
+{
+}
+
+void ViewColumn::componentComplete()
+{
+    // check preferredWidth, its value may need fixing
+    Q_D(ViewColumn);
+    d->setPreferredWidth(d->preferredWidth);
+    d->completed = true;
+}
+
+void ViewColumnPrivate::recalculateLayoutContent()
+{
+    SplitViewLayout *layout = qobject_cast<SplitViewLayout*>(parent);
+    if (!layout) {
+        qFatal("ViewColumn declared outside of SplitViewLayout");
+    }
+    SplitView *view = qobject_cast<SplitView*>(SplitViewLayoutPrivate::get(layout)->parent);
+    if (!view) {
+        qFatal("SplitViewLayout not used in any SplitView");
+    }
+
+    SplitViewPrivate *dView = SplitViewPrivate::get(view);
+    if (dView->activeLayout == layout) {
+        dView->recalculateWidths(SplitViewPrivate::RecalculateAll);
+    }
+}
+
+/*!
+ * \qmlproperty real ViewColumn::minimumWidth
+ * Specifies the minimum width of the column. The number must be a positive value
+ * and less or equal than the maximumWidth value.
+ */
+void ViewColumnPrivate::setMinimumWidth(qreal width)
+{
+    if (qFuzzyCompare(minimumWidth, width)) {
+        return;
+    }
+    if (width < 0.0) {
+        qmlInfo(q_func()) << "minimumWidth cannot be a negative value";
+        return;
+    }
+    if (width > maximumWidth) {
+        qmlInfo(q_func()) << "minimumWidth is greater than maximumWidth";
+        return;
+    }
+    minimumWidth = width;
+    Q_EMIT q_func()->minimumWidthChanged();
+    // clamp preferredWidth if needed
+    setPreferredWidth(preferredWidth);
+    recalculateLayoutContent();
+}
+
+/*!
+ * \qmlproperty real ViewColumn::maximumWidth
+ * Specifies the maximum width of the column. The number must be a positive value
+ * and bigger than the minimumWidth value.
+ */
+void ViewColumnPrivate::setMaximumWidth(qreal width)
+{
+    if (qFuzzyCompare(maximumWidth, width)) {
+        return;
+    }
+    if (width < 0.0) {
+        qmlInfo(q_func()) << "maximumWidth cannot be a negative value";
+        return;
+    }
+    if (width < minimumWidth) {
+        qmlInfo(q_func()) << "maximumWidth is smaller than minimumWidth";
+        return;
+    }
+    maximumWidth = width;
+    Q_EMIT q_func()->maximumWidthChanged();
+    setPreferredWidth(preferredWidth);
+    recalculateLayoutContent();
+}
+
+/*!
+ * \qmlproperty real ViewColumn::preferredWidth
+ * The property holds the preferred width of the column. The value must be situated
+ * in between minimumWidth and maximumWidth. In case fillWidth is set, the value will
+ * hold the actual width of the column, but setting its value will not affect the
+ * width of the column.
+ */
+void ViewColumnPrivate::setPreferredWidth(qreal width, bool notify)
+{
+    // clamp
+    width = UCMathUtils::clamp(width, minimumWidth, maximumWidth);
+    if (qFuzzyCompare(preferredWidth, width)) {
+        return;
+    }
+    preferredWidth = width;
+    if (notify) {
+        Q_EMIT q_func()->preferredWidthChanged();
+        recalculateLayoutContent();
+    }
+}
+
+/*!
+ * \qmlproperty bool ViewColumn::fillWidth
+ * If set, the column width will take the space available after all the other
+ * columns with non-fill width are configured. This means that if there is more
+ * than one column configured to fill width, the reminder width is split evenly
+ * between these columns. If all columns are configured to fill width, the colum
+ * widths will be split evenly between all the columns.
+ * \note When a column configured with fillWidth is resized, the properties will
+ * not be altered, but the fillWidth wioll no longer be taken into account. Instead,
+ * the preferredWidth will drive the width of that column from that point on.
+ */
+void ViewColumnPrivate::setFillWidth(bool fill)
+{
+    if (fill == fillWidth) {
+        return;
+    }
+    fillWidth = fill;
+    Q_EMIT q_func()->fillWidthChanged();
+    recalculateLayoutContent();
+}
+
+bool ViewColumn::resize(qreal delta)
+{
+    Q_D(ViewColumn);
+    // apply limits
+    qreal newWidth = d->preferredWidth + delta;
+    // clamp
+    newWidth = UCMathUtils::clamp(newWidth, d->minimumWidth, d->maximumWidth);
+    if (newWidth != d->preferredWidth) {
+        d->resized = true;
+        d->setPreferredWidth(newWidth);
+        return true;
+    }
+    return false;
+}
+
+/******************************************************************************
+ * SplitViewLayout layouts configuration
+ */
+/*!
+ * \qmltype SplitViewLayout
+ * \inmodule Ubuntu.Components.Labs
+ * \ingroup ubuntu-labs
+ * \brief Layout configuration for SplitView.
+ *
+ * SplitViewLayout defines a layout configuration and the condition when the layout is
+ * expected to be applied. In case multiple layout conditions evaluate to true, the first
+ * one in the list will be activated.
+ */
+SplitViewLayout::SplitViewLayout(QObject *parent)
+    : QObject(*(new SplitViewLayoutPrivate), parent)
+{
+}
+
+void SplitViewLayoutPrivate::columns_Append(QQmlListProperty<ViewColumn> *list, ViewColumn* data)
+{
+    SplitViewLayout *layout = static_cast<SplitViewLayout*>(list->object);
+    SplitViewLayoutPrivate *d = SplitViewLayoutPrivate::get(layout);
+    ViewColumnPrivate::get(data)->column = d->columnData.size();
+    // make sure ViewColumn is parented to the layout definition
+    data->setParent(layout);
+    d->columnData.append(data);
+    Q_EMIT layout->columnsChanged();
+}
+int SplitViewLayoutPrivate::columns_Count(QQmlListProperty<ViewColumn> *list)
+{
+    SplitViewLayout *layout = static_cast<SplitViewLayout*>(list->object);
+    SplitViewLayoutPrivate *d = SplitViewLayoutPrivate::get(layout);
+    return d->columnData.size();
+}
+ViewColumn *SplitViewLayoutPrivate::columns_At(QQmlListProperty<ViewColumn> *list, int index)
+{
+    SplitViewLayout *layout = static_cast<SplitViewLayout*>(list->object);
+    SplitViewLayoutPrivate *d = SplitViewLayoutPrivate::get(layout);
+    return d->columnData.at(index);
+}
+void SplitViewLayoutPrivate::columns_Clear(QQmlListProperty<ViewColumn> *list)
+{
+    SplitViewLayout *layout = static_cast<SplitViewLayout*>(list->object);
+    SplitViewLayoutPrivate *d = SplitViewLayoutPrivate::get(layout);
+    qDeleteAll(d->columnData);
+    d->columnData.clear();
+    Q_EMIT layout->columnsChanged();
+}
+
+/*!
+ * \qmlproperty list<ViewColumn> SplitViewLayout::columns
+ * \default
+ * The property holds the column configurations for the layout. If the view has more
+ * columns than the configuration specifies, the extra columns will be hidden (their
+ * visible property will be set to false!). Also, the hidden column sizes may change,
+ * therefore size-sensitive content must be aware of this.
+ */
+QQmlListProperty<UT_PREPEND_NAMESPACE(ViewColumn)> SplitViewLayoutPrivate::columns()
+{
+    Q_Q(SplitViewLayout);
+    return QQmlListProperty<UT_PREPEND_NAMESPACE(ViewColumn)>(q, &columnData,
+                                                              &columns_Append,
+                                                              &columns_Count,
+                                                              &columns_At,
+                                                              &columns_Clear);
+}
+
+/*!
+ * \qmlproperty bool SplitViewLayout::when
+ * Specifies the condition when to apply the layout. Usually holds a binding which
+ * evaluates to true or false to activate the layout.
+ */
+
+UT_NAMESPACE_END

=== modified file 'src/Ubuntu/UbuntuToolkit/ubuntutoolkitmodule.cpp'
--- src/Ubuntu/UbuntuToolkit/ubuntutoolkitmodule.cpp	2016-08-06 00:55:32 +0000
+++ src/Ubuntu/UbuntuToolkit/ubuntutoolkitmodule.cpp	2016-09-03 13:06:01 +0000
@@ -89,6 +89,13 @@
 #include <privates/ucpagewrapper_p.h>
 #include <privates/appheaderbase_p.h>
 #include <privates/ucscrollbarutils_p.h>
+#include <actionlist_p.h>
+#include <exclusivegroup_p.h>
+#include <menu_p.h>
+#include <menubar_p.h>
+#include <menugroup_p.h>
+
+#include <splitview_p.h>
 
 // styles
 #include <ucbottomedgestyle_p.h>
@@ -374,6 +381,8 @@
     qmlRegisterType<UCPageTreeNode>(uri, 1, 3, "PageTreeNode");
     qmlRegisterType<UCPopupContext>(uri, 1, 3, "PopupContext");
     qmlRegisterType<UCMainViewBase>(uri, 1, 3, "MainViewBase");
+    qmlRegisterType<ActionList>(uri, 1, 3, "ActionList");
+    qmlRegisterType<ExclusiveGroup>(uri, 1, 3, "ExclusiveGroup");
 }
 
 void UbuntuToolkitModule::undefineModule()
@@ -404,15 +413,20 @@
  */
 void UbuntuLabsModule::initializeModule(QQmlEngine *engine, QQmlExtensionPlugin *plugin)
 {
-    Q_UNUSED(engine);
     Q_UNUSED(plugin);
+
+    // qmlplugindump requires that quickutils is initialized.
+    QuickUtils::instance(engine);
 }
 
 void UbuntuLabsModule::defineModule(const char *uri)
 {
-    Q_UNUSED(uri);
-    // a fake component so we can have the module types file created
-    qmlRegisterType<QObject>(uri, 1, 0, "ZiObject");
+    qmlRegisterType<SplitView>(uri, 1, 0, "SplitView");
+    qmlRegisterType<SplitViewLayout>(uri, 1, 0, "SplitViewLayout");
+    qmlRegisterType<ViewColumn>(uri, 1, 0, "ViewColumn");
+    qmlRegisterType<Menu>(uri, 1, 0, "Menu");
+    qmlRegisterType<MenuBar>(uri, 1, 0, "MenuBar");
+    qmlRegisterType<MenuGroup>(uri, 1, 0, "MenuGroup");
 }
 
 void UbuntuLabsModule::undefineModule()

=== modified file 'src/Ubuntu/UbuntuToolkit/ucaction.cpp'
--- src/Ubuntu/UbuntuToolkit/ucaction.cpp	2016-07-07 07:21:48 +0000
+++ src/Ubuntu/UbuntuToolkit/ucaction.cpp	2016-09-03 13:06:01 +0000
@@ -17,6 +17,7 @@
 #include "ucaction_p.h"
 #include "quickutils_p.h"
 #include "ucactioncontext_p.h"
+#include "exclusivegroup_p.h"
 
 #include <QtDebug>
 #include <QtQml/QQmlInfo>
@@ -149,6 +150,18 @@
  *     text: "&Call"
  * }
  * \endqml
+ *
+ * \section2 Checkable property
+ * Since Ubuntu.Components 1.3 Action supports the checkable/checked properties.
+ * \qml
+ * Button {
+ *     action: Action {
+ *         checkable: true
+ *         checked: false
+ *     }
+ *     color: action.checked ? UbuntuColor.green : UbuntuColor.red
+ * }
+ * \endqml
  */
 
 /*!
@@ -160,6 +173,14 @@
  */
 
 /*!
+ * \qmlsignal Action::toggled(bool value)
+ * Signal called when the action's checked property changes.
+ * \note The toggled signal should be used for checkable actions rather than the
+ * triggered signal.
+ * \sa Action::checkable, Action::checked, ExclusiveGroup
+ */
+
+/*!
  * \qmlproperty string Action::description
  * User visible secondary description for the action. Description is more verbose
  * than the \l text and should describe the Action with couple of words.
@@ -250,51 +271,17 @@
  * \endqml
  */
 
-/*!
- * \qmlproperty enum Action::parameterType
- * Type of the parameter passed to \l trigger and \l triggered.
- * Type is an enumeration:
- * \list
- *  \li \b Action.None: No paramater. (default)
- *  \li \b Action.String: String parameter.
- *  \li \b Action.Integer: Integer parameter.
- *  \li \b Action.Bool: Boolean parameter.
- *  \li \b Action.Real: Single precision floating point parameter.
- *  \li \b Action.Object: The parameter is an object.
- * \endlist
- * \qml
- * Action {
- *     id: action
- *     parameterType: Action.String
- *     onTriggered: {
- *         // value arguments now contain strings
- *         console.log(value);
- *     }
- *     Component.onCompleted: action.trigger("Hello World")
- * }
- * \endqml
- */
-
-/*!
- * \qmlproperty bool Action::enabled
- * If set to false the action can not be triggered. Components visualizing the
- * action migth either hide the action or make it insensitive. However visibility
- * can be controlled separately using the \l visible property.
- */
-
-/*!
- * \qmlproperty bool Action::visible
- * Specifies whether the action is visible to the user. Defaults to true.
- */
-
 UCAction::UCAction(QObject *parent)
     : QObject(parent)
+    , m_exclusiveGroup(Q_NULLPTR)
     , m_itemHint(Q_NULLPTR)
     , m_parameterType(None)
     , m_factoryIconSource(true)
     , m_enabled(true)
     , m_visible(true)
     , m_published(false)
+    , m_checkable(false)
+    , m_checked(false)
 {
     generateName();
     // FIXME: we need QInputDeviceInfo to detect the keyboard attechment
@@ -436,6 +423,163 @@
     Q_EMIT shortcutChanged();
 }
 
+/*!
+ * \qmlproperty bool Action::visible
+ * Specifies whether the action is visible to the user. Defaults to true.
+ */
+void UCAction::setVisible(bool visible)
+{
+    if (m_visible == visible) {
+        return;
+    }
+    m_visible = visible;
+    Q_EMIT visibleChanged();
+}
+
+/*!
+ * \qmlproperty bool Action::enabled
+ * If set to false the action can not be triggered. Components visualizing the
+ * action migth either hide the action or make it insensitive. However visibility
+ * can be controlled separately using the \l visible property.
+ */
+void UCAction::setEnabled(bool enabled)
+{
+    if (m_enabled == enabled) {
+        return;
+    }
+    m_enabled = enabled;
+    Q_EMIT enabledChanged();
+
+}
+
+/*!
+ * \qmlproperty enum Action::parameterType
+ * Type of the parameter passed to \l trigger and \l triggered.
+ * Type is an enumeration:
+ * \list
+ *  \li \b Action.None: No paramater. (default)
+ *  \li \b Action.String: String parameter.
+ *  \li \b Action.Integer: Integer parameter.
+ *  \li \b Action.Bool: Boolean parameter.
+ *  \li \b Action.Real: Single precision floating point parameter.
+ *  \li \b Action.Object: The parameter is an object.
+ * \endlist
+ * \qml
+ * Action {
+ *     id: action
+ *     parameterType: Action.String
+ *     onTriggered: {
+ *         // value arguments now contain strings
+ *         console.log(value);
+ *     }
+ *     Component.onCompleted: action.trigger("Hello World")
+ * }
+ * \endqml
+ */
+void UCAction::setParameterType(UCAction::Type type)
+{
+    if (m_parameterType == type) {
+        return;
+    }
+    m_parameterType = type;
+    Q_EMIT parameterTypeChanged();
+}
+
+/*!
+ * \qmlproperty bool Action::checkable
+ * \since Ubuntu.Components 1.3
+ * Whether the action can be checked. Defaults to false.
+ * \sa Action::checked, Action::toggled, ExclusiveGroup
+ */
+void UCAction::setCheckable(bool checkable)
+{
+    if (m_checkable == checkable) {
+        return;
+    }
+    m_checkable = checkable;
+    Q_EMIT checkableChanged();
+
+    // If the Action is already checked, assert the check state.
+    if (m_checked)
+        Q_EMIT toggled(m_checkable);
+}
+
+/*!
+ * \qmlproperty bool Action::checked
+ * \since Ubuntu.Components 1.3
+ * If the action is checkable, this property reflects its checked state. Defaults to false.
+ * Its value is also false while checkable is false.
+ * \sa Action::checkable, Action::toggled, ExclusiveGroup
+ */
+void UCAction::setChecked(bool checked)
+{
+    if (m_checked == checked) {
+        return;
+    }
+    m_checked = checked;
+
+    if (m_checkable) {
+        Q_EMIT toggled(checked);
+    }
+}
+
+/*!
+ * \qmlproperty ExclusiveGroup Action::exclusiveGroup
+ * \since Ubuntu.Components 1.3
+ * The \l ExclusiveGroup associated with this action.
+ * An exclusive group allows the \l checked property to belinked to other actions,
+ * as in radio controls.
+ * \qml
+ * Column {
+ *     ExclusiveGroup {
+ *         Action {
+ *             id: action1
+ *             checkable: true
+ *             checked: true
+ *         }
+ *         Action {
+ *             id: action2
+ *             checkable: true
+ *         }
+ *         Action {
+ *             id: action3
+ *             checkable: true
+ *         }
+ *     }
+ *
+ *     Button {
+ *         action: action1
+ *         color: action.checked ? UbuntuColor.green : UbuntuColor.red
+ *     }
+ *     Button {
+ *         action: action2
+ *         color: action.checked ? UbuntuColor.green : UbuntuColor.red
+ *     }
+ *     Button {
+ *         action: action3
+ *         color: action.checked ? UbuntuColor.green : UbuntuColor.grey
+ *     }
+ * }
+ * \endqml
+ */
+void UCAction::setExclusiveGroup(ExclusiveGroup *exclusiveGroup)
+{
+    if (m_exclusiveGroup == exclusiveGroup) {
+        return;
+    }
+
+    if (m_exclusiveGroup) {
+        m_exclusiveGroup->unbindCheckable(this);
+    }
+
+    m_exclusiveGroup = exclusiveGroup;
+
+    if (m_exclusiveGroup) {
+        m_exclusiveGroup->bindCheckable(this);
+    }
+    Q_EMIT exclusiveGroupChanged();
+}
+
 bool UCAction::event(QEvent *event)
 {
     if (event->type() != QEvent::Shortcut)
@@ -475,6 +619,11 @@
     if (!m_enabled) {
         return;
     }
+
+    if (m_checkable && !(m_checked && m_exclusiveGroup)) {
+        setChecked(!m_checked);
+    }
+
     if (!isValidType(value.type())) {
         Q_EMIT triggered(QVariant());
     } else {

=== modified file 'src/Ubuntu/UbuntuToolkit/ucaction_p.h'
--- src/Ubuntu/UbuntuToolkit/ucaction_p.h	2016-07-07 07:21:48 +0000
+++ src/Ubuntu/UbuntuToolkit/ucaction_p.h	2016-09-03 13:06:01 +0000
@@ -53,7 +53,7 @@
     }
 }
 
-class UCActionAttached;
+class ExclusiveGroup;
 class UBUNTUTOOLKIT_EXPORT UCAction : public QObject
 {
     Q_OBJECT
@@ -62,19 +62,23 @@
     Q_ENUMS(Type)
     Q_PROPERTY(QString name MEMBER m_name WRITE setName NOTIFY nameChanged)
     Q_PROPERTY(QString text READ text WRITE setText RESET resetText NOTIFY textChanged)
-    Q_PROPERTY(QString iconName MEMBER m_iconName WRITE setIconName NOTIFY iconNameChanged)
+    Q_PROPERTY(QString iconName READ iconName WRITE setIconName NOTIFY iconNameChanged)
     Q_PROPERTY(QString description MEMBER m_description NOTIFY descriptionChanged)
     Q_PROPERTY(QString keywords MEMBER m_keywords NOTIFY keywordsChanged)
-    Q_PROPERTY(bool enabled MEMBER m_enabled NOTIFY enabledChanged)
-    Q_PROPERTY(Type parameterType MEMBER m_parameterType NOTIFY parameterTypeChanged)
+    Q_PROPERTY(bool enabled READ isEnabled WRITE setEnabled NOTIFY enabledChanged)
+    Q_PROPERTY(Type parameterType READ parameterType WRITE setParameterType NOTIFY parameterTypeChanged)
+
+    Q_PROPERTY(bool checkable READ isCheckable WRITE setCheckable NOTIFY checkableChanged REVISION 1)
+    Q_PROPERTY(bool checked READ isChecked WRITE setChecked NOTIFY toggled REVISION 1)
+    Q_PROPERTY(ExclusiveGroup* exclusiveGroup READ exclusiveGroup WRITE setExclusiveGroup NOTIFY exclusiveGroupChanged REVISION 1)
 
     // Toolkit Actions API
-    Q_PROPERTY(QUrl iconSource MEMBER m_iconSource WRITE setIconSource NOTIFY iconSourceChanged)
-    Q_PROPERTY(bool visible MEMBER m_visible NOTIFY visibleChanged)
+    Q_PROPERTY(QUrl iconSource READ iconSource WRITE setIconSource NOTIFY iconSourceChanged)
+    Q_PROPERTY(bool visible READ visible WRITE setVisible NOTIFY visibleChanged)
     Q_PROPERTY(QQmlComponent *itemHint MEMBER m_itemHint WRITE setItemHint)
 
     // QtQuickControls.Action
-    Q_PROPERTY(QVariant shortcut MEMBER m_shortcut WRITE setShortcut RESET resetShortcut NOTIFY shortcutChanged REVISION 1)
+    Q_PROPERTY(QVariant shortcut READ shortcut WRITE setShortcut RESET resetShortcut NOTIFY shortcutChanged REVISION 1)
 public:
     enum Type {
         None,
@@ -108,11 +112,26 @@
     QString text();
     void setText(const QString &text);
     void resetText();
+    QString iconName() const { return m_iconName; }
     void setIconName(const QString &name);
+    QUrl iconSource() const { return m_iconSource; }
     void setIconSource(const QUrl &url);
     void setItemHint(QQmlComponent *);
+    QVariant shortcut() const { return m_shortcut; }
     void setShortcut(const QVariant&);
     void resetShortcut();
+    bool visible() const { return m_visible; }
+    void setVisible(bool visible);
+    void setEnabled(bool enabled);
+    void setParameterType(Type type);
+    Type parameterType() const { return m_parameterType; }
+    void setCheckable(bool checkable);
+    bool isCheckable() const { return m_checkable; }
+    void setChecked(bool checked);
+    bool isChecked() const { return m_checkable && m_checked; }
+
+    ExclusiveGroup *exclusiveGroup() const { return m_exclusiveGroup; }
+    void setExclusiveGroup(ExclusiveGroup *exclusiveGroup);
 
 Q_SIGNALS:
     void nameChanged();
@@ -125,13 +144,18 @@
     void iconSourceChanged();
     void visibleChanged();
     void shortcutChanged();
+    Q_REVISION(1) void checkableChanged();
+    Q_REVISION(1) void exclusiveGroupChanged();
+
     void triggered(const QVariant &value);
+    Q_REVISION(1) void toggled(bool value);
 
 public Q_SLOTS:
     void trigger(const QVariant &value = QVariant());
 
 private:
     QPODVector<QQuickItem*, 4> m_owningItems;
+    ExclusiveGroup *m_exclusiveGroup;
     QString m_name;
     QString m_text;
     QString m_iconName;
@@ -146,6 +170,8 @@
     bool m_enabled:1;
     bool m_visible:1;
     bool m_published:1;
+    bool m_checkable:1;
+    bool m_checked:1;
 
     friend class UCActionContext;
     friend class UCActionItem;

=== modified file 'src/Ubuntu/UbuntuToolkit/uclistitem.cpp'
--- src/Ubuntu/UbuntuToolkit/uclistitem.cpp	2016-07-14 07:41:06 +0000
+++ src/Ubuntu/UbuntuToolkit/uclistitem.cpp	2016-09-03 13:06:01 +0000
@@ -537,7 +537,7 @@
  * there will be no highlight happening if the click happens on the active component.
  * \qml
  * import QtQuick 2.4
- * import Ubuntu.Components 1.2
+ * import Ubuntu.Components 1.3
  *
  * MainView {
  *    width: units.gu(40)
@@ -572,20 +572,29 @@
  *            onClicked: console.log("clicked on ListItem with trailingActions set")
  *        }
  *        ListItem {
- *            Label {
- *                text: "onClicked implemented"
+ *            // shall specify the height when Using ListItemLayout inside ListItem
+ *            height: clickImplementedLayout.height + (divider.visible ? divider.height : 0)
+ *            ListItemLayout {
+ *                id: clickImplementedLayout
+ *                title.text: "onClicked implemented"
  *            }
  *            onClicked: console.log("clicked on ListItem with onClicked implemented")
  *        }
  *        ListItem {
- *            Label {
- *                text: "onPressAndHold implemented"
+ *            // shall specify the height when Using ListItemLayout inside ListItem
+ *            height: pressHoldLayout.height + (divider.visible ? divider.height : 0)
+ *            ListItemLayout {
+ *                id: pressHoldLayout
+ *                title.text: "onPressAndHold implemented"
  *            }
  *            onPressAndHold: console.log("long-pressed on ListItem with onPressAndHold implemented")
  *        }
  *        ListItem {
- *            Label {
- *                text: "No highlight"
+ *            // shall specify the height when Using ListItemLayout inside ListItem
+ *            height: noHighlightLayout.height + (divider.visible ? divider.height : 0)
+ *            ListItemLayout {
+ *                id: noHighlightLayout
+ *                title.text: "No highlight"
  *            }
  *        }
  *    }
@@ -671,7 +680,7 @@
  * to the view itself.
  * \qml
  * import QtQuick 2.4
- * import Ubuntu.Components 1.2
+ * import Ubuntu.Components 1.3
  *
  * Flickable {
  *    width: units.gu(40)
@@ -735,7 +744,7 @@
  * Example of live drag implementation:
  * \qml
  * import QtQuick 2.4
- * import Ubuntu.Components 1.2
+ * import Ubuntu.Components 1.3
  *
  * ListView {
  *     model: ListModel {
@@ -746,8 +755,11 @@
  *         }
  *     }
  *     delegate: ListItem {
- *         Label {
- *             text: modelData
+ *         // shall specify the height when Using ListItemLayout inside ListItem
+ *         height: modelLayout.height + (divider.visible ? divider.height : 0)
+ *         ListItemLayout {
+ *             id: modelLayout
+ *             title.text: modelData
  *         }
  *         color: dragMode ? "lightblue" : "lightgray"
  *         onPressAndHold: ListView.view.ViewItems.dragMode =
@@ -769,7 +781,7 @@
  * Example of drag'n'drop implementation:
  * \qml
  * import QtQuick 2.4
- * import Ubuntu.Components 1.2
+ * import Ubuntu.Components 1.3
  *
  * ListView {
  *     model: ListModel {
@@ -780,8 +792,11 @@
  *         }
  *     }
  *     delegate: ListItem {
- *         Label {
- *             text: modelData
+ *         // shall specify the height when Using ListItemLayout inside ListItem
+ *         height: modelLayout.height + (divider.visible ? divider.height : 0)
+ *         ListItemLayout {
+ *             id: modelLayout
+ *             title.text: modelData
  *         }
  *         color: dragMode ? "lightblue" : "lightgray"
  *         onPressAndHold: ListView.view.ViewItems.dragMode =
@@ -815,13 +830,16 @@
  * can still be implemented with these kind of lists as well.
  * \qml
  * import QtQuick 2.4
- * import Ubuntu.Components 1.2
+ * import Ubuntu.Components 1.3
  *
  * ListView {