Merge lp:~fboucault/ubuntu-ui-extras/editor_with_halide into lp:ubuntu-ui-extras

[Florian Boucault]

PhotoEditor: use Halide instead of custom editing functions.

[lp:~fboucault/ubuntu-ui-extras/editor_with_halide]

76. By Florian Boucault on 2015-06-10

Fixed deb dependencies.

[Florian Boucault (fboucault)]

Depends on https://code.launchpad.net/~fboucault/camera-app/dynamic_header_actions/+merge/261533

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:76
http://jenkins.qa.ubuntu.com/job/ubuntu-ui-extras-ci/72/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/ubuntu-ui-extras-vivid-amd64-ci/33/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/ubuntu-ui-extras-vivid-armhf-ci/33/console

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/ubuntu-ui-extras-ci/72/rebuild

review: Needs Fixing (continuous-integration)

[lp:~fboucault/ubuntu-ui-extras/editor_with_halide]

77. By Florian Boucault on 2015-06-12

Fix for long loading when editing starts.

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:77
http://jenkins.qa.ubuntu.com/job/ubuntu-ui-extras-ci/73/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/ubuntu-ui-extras-vivid-amd64-ci/34/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/ubuntu-ui-extras-vivid-armhf-ci/34/console

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/ubuntu-ui-extras-ci/73/rebuild

review: Needs Fixing (continuous-integration)

[lp:~fboucault/ubuntu-ui-extras/editor_with_halide]

78. By Florian Boucault on 2015-06-12

Enclosed classes into PhotoEditor namespace as to not conflict with Gallery's version of the same classes.

79. By Florian Boucault on 2015-06-12

Enable function as late as possible.

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:79
http://jenkins.qa.ubuntu.com/job/ubuntu-ui-extras-ci/74/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/ubuntu-ui-extras-vivid-amd64-ci/35/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/ubuntu-ui-extras-vivid-armhf-ci/35/console

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/ubuntu-ui-extras-ci/74/rebuild

review: Needs Fixing (continuous-integration)

[system-apps-ci-bot (system-apps-ci-bot)]

FAILED: Continuous integration, rev:79
https://jenkins.canonical.com/system-apps/job/lp-ubuntu-ui-extras-ci/2/
Executed test runs:
    FAILURE: https://jenkins.canonical.com/system-apps/job/build/641/console
    FAILURE: https://jenkins.canonical.com/system-apps/job/build-0-fetch/641/console

Click here to trigger a rebuild:
https://jenkins.canonical.com/system-apps/job/lp-ubuntu-ui-extras-ci/2/rebuild

review: Needs Fixing (continuous-integration)

Unmerged revisions

79. By Florian Boucault on 2015-06-12

Enable function as late as possible.

78. By Florian Boucault on 2015-06-12

Enclosed classes into PhotoEditor namespace as to not conflict with Gallery's version of the same classes.

77. By Florian Boucault on 2015-06-12

Fix for long loading when editing starts.

76. By Florian Boucault on 2015-06-10

Fixed deb dependencies.

75. By Florian Boucault on 2015-06-10

PhotoEditor: use Halide instead of custom editing functions.

=== modified file 'debian/control'
--- debian/control	2015-02-12 13:20:41 +0000
+++ debian/control	2015-06-12 13:08:47 +0000
@@ -31,6 +31,7 @@
          qtdeclarative5-qtquick2-plugin,
          qtdeclarative5-ubuntu-ui-toolkit-plugin,
          qtdeclarative5-window-plugin,
+         qtdeclarative5-halide-plugin0.1,
          libexiv2-13,
 Provides: qtdeclarative5-ubuntu-ui-extras0.1
 Conflicts: qtdeclarative5-ubuntu-ui-extras0.1

=== modified file 'modules/Ubuntu/Components/Extras/PhotoEditor.qml'
--- modules/Ubuntu/Components/Extras/PhotoEditor.qml	2015-03-02 20:25:09 +0000
+++ modules/Ubuntu/Components/Extras/PhotoEditor.qml	2015-06-12 13:08:47 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2014 Canonical Ltd
+ * Copyright (C) 2015 Canonical Ltd
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License version 3 as
@@ -18,94 +18,301 @@
 import Ubuntu.Components 1.1
 import Ubuntu.Components.Popups 1.0
 import Ubuntu.Components.Extras 0.2
+import QtHalide 0.1
 import "PhotoEditor"
 
 Item {
     id: editor
-    property string photo
-    property bool modified: stack.modified
+
+    // public API
 
     signal closed(bool photoWasModified)
 
-    property list<Action> actions
-    actions: [stack.undoAction, stack.redoAction]
-
-    EditStack {
-        id: stack
-        data: photoData
-        actionsEnabled: !exposureSelector.visible && !cropper.visible && !photoData.busy
-        onRevertRequested: PopupUtils.open(revertPromptComponent)
-    }
-
-    property list<Action> toolActions: [
-        Action {
-            objectName: "cropButton"
-            text: i18n.tr("Crop")
-            iconSource: Qt.resolvedUrl("PhotoEditor/assets/edit_crop.png")
-            onTriggered: {
-                photoData.isLongOperation = false;
-                cropper.start("image://photo/" + photoData.path);
-            }
-        },
-        Action {
-            objectName: "rotateButton"
-            text: i18n.tr("Rotate")
-            iconSource: Qt.resolvedUrl("PhotoEditor/assets/edit_rotate_left.png")
-            onTriggered: {
-                photoData.isLongOperation = false;
-                photoData.rotateRight()
-            }
+    property list<Action> actions: [
+        Action {
+            text: i18n.tr("Revert to Original")
+            iconName: "reset"
+            enabled: internal.actionsEnabled && (internal.hasOriginal || internal.undoStates.length != 0)
+            onTriggered: PopupUtils.open(revertPromptComponent)
+        },
+        Action {
+            text: i18n.tr("Undo")
+            iconName: "undo"
+            enabled: internal.actionsEnabled && internal.undoStates.length != 0
+            onTriggered: internal.undo()
+        },
+        Action {
+            text: i18n.tr("Redo")
+            iconName: "redo"
+            enabled: internal.actionsEnabled && internal.redoStates.length != 0
+            onTriggered: internal.redo()
         }
     ]
 
-    function close(saveIfModified) {
-        stack.endEditingSession(saveIfModified);
-        editor.closed(editor.modified);
-    }
-
-    function open(photo) {
-        editor.photo = photo;
-        stack.startEditingSession(photo);
-        photoData.path = stack.currentFile;
-        image.source = "image://photo/" + photoData.path;
-    }
-
+    function open(photoFile) {
+        internal.currentFile = photoFile;
+        internal.currentFileModified = false;
+        internal.clearAllStates();
+    }
+
+    function close() {
+        if (internal.undoStates.length != 0) {
+            internal.saveToDisk(function() {editor.closed(internal.currentFileModified)});
+        } else {
+            editor.closed(internal.currentFileModified);
+        }
+        internal.clearAllStates();
+    }
+
+    // private
+
+    QtObject {
+        id: internal
+
+        property string currentFile
+        property string originalFile: FileUtils.parentDirectory(internal.currentFile)
+                                      + "/.original/" + FileUtils.nameFromPath(internal.currentFile)
+        property bool hasOriginal: FileUtils.exists(internal.originalFile)
+        property bool currentFileModified: false
+        property bool actionsEnabled: !busyIndicator.running && !cropper.active
+        property var undoStates: []
+        property var redoStates: []
+
+        // pop/push helper functions necessary to make sure that undoStates.length
+        // and redoStates.length emit a modification signal
+        function popUndoState() {
+            var state = internal.undoStates.pop();
+            internal.undoStates = internal.undoStates;
+            return state;
+        }
+
+        function popRedoState() {
+            var state = internal.redoStates.pop();
+            internal.redoStates = internal.redoStates;
+            return state;
+        }
+
+        function pushUndoState(state) {
+            internal.undoStates.push(state);
+            internal.undoStates = internal.undoStates;
+        }
+
+        function pushRedoState(state) {
+            internal.redoStates.push(state);
+            internal.redoStates = internal.redoStates;
+        }
+
+        function clearUndoStates() {
+            for (var i=0; i<internal.undoStates.length; i++) {
+                internal.undoStates[i].destroy();
+            }
+            internal.undoStates = [];
+        }
+
+        function clearRedoStates() {
+            for (var i=0; i<internal.redoStates.length; i++) {
+                internal.redoStates[i].destroy();
+            }
+            internal.redoStates = [];
+        }
+
+        function clearAllStates() {
+            internal.clearUndoStates();
+            internal.clearRedoStates();
+        }
+
+        property list<Action> toolActions: [
+            EditorAction {
+                objectName: "cropButton"
+                text: i18n.tr("Crop")
+                iconSource: Qt.resolvedUrl("PhotoEditor/assets/edit_crop.png")
+                halideFunction: functionTransform
+                halideTransform: previewTransform
+                manualCommit: true
+                function execute() {
+                    cropper.start(previewTransform.output, commit);
+                }
+            },
+            EditorAction {
+                objectName: "rotateButton"
+                text: i18n.tr("Rotate")
+                iconSource: Qt.resolvedUrl("PhotoEditor/assets/edit_rotate_right.png")
+                halideFunction: functionTransform
+                halideTransform: previewTransform
+                function execute() {
+                    functionTransform.rotateRight90();
+                    exifOrientation.rotateRight90();
+                }
+            }
+        ]
+
+        function undo() {
+            var undoState = internal.popUndoState();
+            if (undoState) {
+                previewTransform.live = false;
+                var redoState = internal.snapshotFunctionState(undoState.target);
+                internal.pushRedoState(redoState);
+                undoState.restore();
+                undoState.destroy();
+                previewTransform.live = true;
+            }
+        }
+
+        function redo() {
+            var redoState = internal.popRedoState();
+            if (redoState) {
+                previewTransform.live = false;
+                var undoState = internal.snapshotFunctionState(redoState.target);
+                internal.pushUndoState(undoState);
+                redoState.restore();
+                redoState.destroy();
+                previewTransform.live = true;
+            }
+        }
+
+        function revertToOriginal() {
+            previewTransform.live = false;
+            for (var i=internal.undoStates.length-1; i>=0; i--) {
+                internal.undoStates[i].restore();
+            }
+            internal.clearAllStates();
+
+            if (internal.hasOriginal) {
+                FileUtils.copy(internal.originalFile, internal.currentFile);
+                FileUtils.remove(internal.originalFile);
+                internal.hasOriginal = false;
+                previewImage.reload();
+                internal.currentFileModified = true;
+            }
+            previewTransform.live = true;
+        }
+
+        function snapshotFunctionState(targetFunction) {
+            var functionStateComponent = Qt.createComponent("PhotoEditor/FunctionStateSaver.qml");
+            var state = functionStateComponent.createObject(null, {"target": targetFunction});
+            state.save();
+            return state;
+        }
+
+        property var saveToDiskCallback
+        function saveToDisk(callback) {
+            internal.saveToDiskCallback = callback;
+            saveImage.source = internal.currentFile;
+        }
+    }
+
+    // preview pipeline
     Rectangle {
         color: "black"
         anchors.fill: parent
     }
 
-    Image {
-        id: image
+    MouseArea {
         anchors.fill: parent
-        asynchronous: true
-        cache: false
-        source: photoData.path ? "image://photo/" + photoData.path : ""
-        fillMode: Image.PreserveAspectFit
-        sourceSize {
-            width: image.width
-            height: image.height
-        }
+    }
+
+    HalideImage {
+        id: previewImage
+        sourceSize: Qt.size(Math.max(editor.width, editor.height), 0)
+        source: internal.currentFile
 
         function reload() {
-            image.asynchronous = false;
-            image.source = "";
-            image.asynchronous = true;
-            image.source = "image://photo/" + photoData.path;
-        }
-    }
-
-    PhotoData {
-        id: photoData
-        onDataChanged: image.reload()
-        property bool isLongOperation: false
-
-        onEditFinished: {
-            console.log("Edit finished")
-            // If we are editing exposure we don't need to checkpoint at every
-            // edit, and the exposure UI will checkpoint when the user confirms.
-            if (exposureSelector.opacity > 0) exposureSelector.reload()
-            else stack.checkpoint()
+            previewImage.source = "";
+            previewImage.source = internal.currentFile;
+        }
+    }
+
+    HalideTransform {
+        id: previewTransform
+        input: previewImage
+        live: true
+
+        FunctionTransform {
+            id: functionTransform
+            enabled: false
+        }
+    }
+
+    HalideImageRenderer {
+        anchors.fill: parent
+        image: previewTransform.output
+        fillMode: HalideImageRenderer.PreserveAspectFit
+    }
+
+    ExifOrientation {
+        id: exifOrientation
+    }
+
+    // saving pipeline
+    HalideImage {
+        id: saveImage
+        onStatusChanged: {
+            if (status == HalideImage.Ready) {
+                saveTransform.save();
+                source = "";
+            }
+        }
+    }
+
+    HalideTransform {
+        id: saveTransform
+        input: saveImage
+        live: false
+
+        FunctionTransform {
+            id: functionTransformSave
+        }
+
+        function copyProperties(objectSource, objectDestination) {
+            for (var prop in objectSource) {
+                if (typeof(objectSource[prop]) !== "function") {
+                    objectDestination[prop] = objectSource[prop];
+                }
+            }
+        }
+
+        function save() {
+            for (var i=0; i<saveTransform.functions.count; i++) {
+                var previewFunction = previewTransform.functions.get(i);
+                var saveFunction = saveTransform.functions.get(i);
+                copyProperties(previewFunction, saveFunction);
+            }
+
+            if (!internal.hasOriginal) {
+                FileUtils.createDirectory(FileUtils.parentDirectory(internal.originalFile));
+                FileUtils.copy(internal.currentFile, internal.originalFile);
+                internal.hasOriginal = true;
+            }
+            saveTransform.scheduleUpdate(true);
+        }
+
+        onUpdatingChanged: {
+            if (!saveTransform.updating) {
+                // update is finished
+                photoMetadata.fileName = internal.currentFile;
+
+                if (functionTransform.rotationOnly) {
+                    // special case when only rotating: we implement the rotation by
+                    // modifying the EXIF rotation tag
+                    photoMetadata.orientation = exifOrientation.add(photoMetadata.orientation,
+                                                                    exifOrientation.orientation);
+                    photoMetadata.save();
+                } else {
+                    // the actual pixels are being rotated: reset EXIF orientation tag
+                    photoMetadata.orientation = 1;
+                    photoMetadata.saveImage(saveTransform.output.image);
+                }
+            }
+        }
+    }
+
+    PhotoMetadata {
+        id: photoMetadata
+        onSavingChanged: {
+            if (!saving) {
+                internal.currentFileModified = true;
+                internal.saveToDiskCallback();
+            }
         }
     }
 
@@ -114,6 +321,8 @@
 
         anchors.fill: parent
 
+        source: "PhotoEditor/CropInteractor.qml"
+        active: false
         opacity: 0.0
         visible: opacity > 0
         Behavior on opacity { UbuntuNumberAnimation { } }
@@ -122,72 +331,50 @@
             target: cropper.item
             ignoreUnknownSignals: true
             onCropped: {
-                var qtRect = Qt.rect(rect.x, rect.y, rect.width, rect.height);
-                photoData.crop(qtRect);
+                functionTransform.crop(rect.x, rect.y, rect.width, rect.height);
                 cropper.opacity = 0.0;
-                cropper.source = ""
+                cropper.active = false;
+                cropper.callback();
             }
             onCanceled: {
                 cropper.opacity = 0.0;
-                cropper.source = ""
+                cropper.active = false;
             }
         }
 
-        function start(target) {
-            source = "PhotoEditor/CropInteractor.qml";
+        property var callback
+
+        function start(target, callback) {
+            cropper.callback = callback;
+            cropper.active = true;
             item.targetPhoto = target;
         }
 
         onLoaded: opacity = 1.0
     }
 
-    ExposureAdjuster {
-        id: exposureSelector
-        anchors.fill: parent
-        opacity: 0.0
-        enabled: !photoData.busy
-        onExposureChanged: {
-            // Restore the starting version of the image, otherwise we will
-            // accumulate compensations over the previous ones.
-            stack.restoreSnapshot(stack.level)
-            photoData.exposureCompensation(exposure)
-        }
-        onConfirm: {
-            stack.checkpoint();
-            exposureSelector.opacity = 0.0
-        }
-        onCancel: {
-            stack.restoreSnapshot(stack.level)
-            exposureSelector.opacity = 0.0
-        }
-        visible: opacity > 0
-    }
-
     ActionsBar {
         id: actionsBar
         objectName: "editorActionsBar"
         anchors.bottom: parent.bottom
         anchors.left: parent.left
         anchors.right: parent.right
+        toolActions: internal.toolActions
+        enabled: visible
 
+        opacity: cropper.opacity == 0 ? 1.0 : 0.0
         visible: opacity > 0.0
-        opacity: (exposureSelector.opacity == 0 && cropper.opacity == 0) ? 1.0 : 0.0
-
-        enabled: !photoData.busy
-        toolActions: {
-            // This is necessary because QML does not let us declare a list with
-            // mixed component declarations and identifiers, like this:
-            // property list<Action> foo: { Action{}, someOtherAction }
-            var list = [];
-            for (var i = 0; i < editor.toolActions.length; i++)
-                list.push(editor.toolActions[i]);
-            list.push(stack.revertAction);
-            return list;
-        }
-
         Behavior on opacity { UbuntuNumberAnimation {} }
     }
 
+    BusyIndicator {
+        id: busyIndicator
+        anchors.centerIn: parent
+        text: i18n.tr("Saving modifications...")
+        running: previewTransform.updating || saveTransform.updating || photoMetadata.saving
+        longOperation: saveTransform.updating || photoMetadata.saving
+    }
+
     Component {
           id: revertPromptComponent
           Dialog {
@@ -213,18 +400,10 @@
                       color: UbuntuColors.green
                       onClicked: {
                           PopupUtils.close(revertPrompt)
-                          stack.revertToPristine()
+                          internal.revertToOriginal();
                       }
                   }
               }
           }
      }
-
-    BusyIndicator {
-        id: busyIndicator
-        anchors.centerIn: parent
-        text: i18n.tr("Enhancing photo...")
-        running: photoData.busy
-        longOperation: photoData.isLongOperation
-    }
 }

=== modified file 'modules/Ubuntu/Components/Extras/PhotoEditor/ActionsBar.qml'
--- modules/Ubuntu/Components/Extras/PhotoEditor/ActionsBar.qml	2015-03-10 21:31:16 +0000
+++ modules/Ubuntu/Components/Extras/PhotoEditor/ActionsBar.qml	2015-06-12 13:08:47 +0000
@@ -50,6 +50,11 @@
                 action: modelData
                 enabled: bar.enabled
 
+                Rectangle {
+                    anchors.fill: parent
+                    color: pressed ? Qt.rgba(1.0, 1.0, 1.0, 0.3) : Qt.rgba(0.0, 0.0, 0.0, 0.0)
+                }
+
                 Icon {
                     anchors.centerIn: parent
                     name: modelData.iconName
@@ -57,6 +62,7 @@
                     width: units.gu(3)
                     height: units.gu(3)
                     opacity: modelData.enabled && parent.enabled ? 1.0 : 0.5
+                    color: "white"
                 }
             }
         }

=== modified file 'modules/Ubuntu/Components/Extras/PhotoEditor/BusyIndicator.qml'
--- modules/Ubuntu/Components/Extras/PhotoEditor/BusyIndicator.qml	2015-03-11 00:24:51 +0000
+++ modules/Ubuntu/Components/Extras/PhotoEditor/BusyIndicator.qml	2015-06-12 13:08:47 +0000
@@ -14,23 +14,25 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-import QtQuick 2.0
-import Ubuntu.Components 0.1
+import QtQuick 2.3
+import Ubuntu.Components 1.0
 
 Item {
     id: busy
-    width: childrenRect.width
-    height: childrenRect.height
+    width: busyColumn.width
+    height: busyColumn.height
     property alias text: label.text
     property alias running: spinner.running
     property bool longOperation: false
 
-    visible: running
+    visible: opacity != 0.0
+    opacity: running ? 1.0 : 0.0
+    Behavior on opacity { UbuntuNumberAnimation {} }
 
     UbuntuShape {
         id: busyUbuntuShape
         objectName: "busyUbuntuShape"
-        color: "white"
+        color: "black"
         anchors.centerIn: parent
         width: parent.width + units.gu(4)
         height: parent.height + units.gu(4)
@@ -41,7 +43,7 @@
         id: busyColumn
         objectName: "busyColumn"
         anchors.centerIn: parent
-        width: childrenRect.width
+        width: label.width
         spacing: units.gu(2)
 
         ActivityIndicator {
@@ -55,6 +57,7 @@
             anchors.horizontalCenter: parent.horizontalCenter
             horizontalAlignment: Text.AlignHCenter
             visible: longOperation
+            color: "white"
         }
     }
 }

=== modified file 'modules/Ubuntu/Components/Extras/PhotoEditor/CropInteractor.qml'
--- modules/Ubuntu/Components/Extras/PhotoEditor/CropInteractor.qml	2015-01-15 10:48:51 +0000
+++ modules/Ubuntu/Components/Extras/PhotoEditor/CropInteractor.qml	2015-06-12 13:08:47 +0000
@@ -20,6 +20,7 @@
 
 import QtQuick 2.3
 import Ubuntu.Components 1.1
+import QtHalide 0.1
 import "GraphicsRoutines.js" as GraphicsRoutines
 
 /*!
@@ -30,7 +31,7 @@
 
     color: "black"
 
-    property alias targetPhoto: original.source
+    property alias targetPhoto: original.image
 
     property string matteColor: "black"
     property real matteOpacity: 0.6
@@ -41,12 +42,7 @@
     signal canceled()
 
     function computeRectSet() {
-        var actualImage = Qt.rect(
-            (original.width - original.paintedWidth) / 2.0,
-            (original.height - original.paintedHeight) / 2.0,
-            original.paintedWidth,
-            original.paintedHeight
-        );
+        var actualImage = Qt.rect(0, 0, original.width, original.height);
         var photoPreview = GraphicsRoutines.fitRect(viewport, actualImage);
 
         var unfitCrop = Qt.rect(0, 0, photoPreview.width, photoPreview.height);
@@ -102,7 +98,7 @@
         }
     }
 
-    Image {
+    HalideImageRenderer {
         id: original
 
         x: viewport.x
@@ -111,30 +107,23 @@
         height: viewport.height
         transformOrigin: Item.TopLeft
         fillMode: Image.PreserveAspectFit
-        cache: false
-        sourceSize {
-            width: original.width
-            height: original.height
-        }
-
-        onStatusChanged: {
-            if (status == Image.Ready) {
-                var rects = computeRectSet();
-
-                overlay.initialFrameX = rects.cropFrame.x;
-                overlay.initialFrameY = rects.cropFrame.y;
-                overlay.initialFrameWidth = rects.cropFrame.width;
-                overlay.initialFrameHeight = rects.cropFrame.height;
-
-                overlay.resetFor(rects);
-                overlay.visible = true;
-
-                x = rects.photoExtent.x;
-                y = rects.photoExtent.y;
-                width = rects.photoPreview.width;
-                height = rects.photoPreview.height;
-                scale = rects.photoExtentScale;
-            }
+
+        onImageChanged: {
+            var rects = computeRectSet();
+
+            overlay.initialFrameX = rects.cropFrame.x;
+            overlay.initialFrameY = rects.cropFrame.y;
+            overlay.initialFrameWidth = rects.cropFrame.width;
+            overlay.initialFrameHeight = rects.cropFrame.height;
+
+            overlay.resetFor(rects);
+            overlay.visible = true;
+
+            x = rects.photoExtent.x;
+            y = rects.photoExtent.y;
+            width = rects.photoPreview.width;
+            height = rects.photoPreview.height;
+            scale = rects.photoExtentScale;
         }
     }
 }

=== removed file 'modules/Ubuntu/Components/Extras/PhotoEditor/EditStack.qml'
--- modules/Ubuntu/Components/Extras/PhotoEditor/EditStack.qml	2015-02-11 14:46:34 +0000
+++ modules/Ubuntu/Components/Extras/PhotoEditor/EditStack.qml	1970-01-01 00:00:00 +0000
@@ -1,134 +0,0 @@
-/*
- * Copyright (C) 2014 Canonical Ltd
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 3 as
- * published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- */
-
-import QtQuick 2.3
-import Ubuntu.Components 1.1
-import Ubuntu.Components.Extras 0.2
-
-Item {
-    property PhotoData data
-    property bool actionsEnabled: true
-    property var items: []
-    property int level: 0
-    property string editingSessionPath
-    property string currentFile
-    property string originalFile
-    property string pristineFile
-    property bool modified: level > 0 || _revertedInThisSession
-
-    property bool _revertedInThisSession
-    property bool _pristineFileExists
-
-    signal revertRequested
-
-    function startEditingSession(original) {
-        var originalFileName = FileUtils.nameFromPath(original);
-        var baseName = FileUtils.parentDirectory(original) +
-                       "/.photo_editing." + originalFileName + ".";
-        editingSessionPath = FileUtils.createTemporaryDirectory(baseName);
-        if (editingSessionPath == "") return false;
-
-        originalFile = original;
-        currentFile = editingSessionPath + "/current";
-
-        pristineFile = FileUtils.parentDirectory(original) +
-                       "/.original/" + originalFileName
-        _revertedInThisSession = false;
-        _pristineFileExists = FileUtils.exists(pristineFile)
-
-        FileUtils.copy(originalFile, currentFile)
-
-        items = [createSnapshot(0)];
-        level = 0;
-        return true;
-    }
-
-    function endEditingSession(saveIfModified) {
-        if (saveIfModified && modified) { // file modified
-            // if we don't have a copy of the very first original, create one
-            if (!_pristineFileExists) {
-                FileUtils.createDirectory(FileUtils.parentDirectory(pristineFile));
-                FileUtils.copy(originalFile, pristineFile);
-            } else {
-                // if we reverted to original (and made no other changes)
-                // we don't need to keep the pristine copy around
-                if (_revertedInThisSession && level <= 0) {
-                    FileUtils.remove(pristineFile);
-                }
-            }
-
-            FileUtils.copy(currentFile, originalFile); // actually save
-        }
-
-        FileUtils.removeDirectory(editingSessionPath, true); // clear editing cache
-        editingSessionPath = originalFile = pristineFile = currentFile = "";
-    }
-
-    function createSnapshot(name) {
-        var snapshotFile = editingSessionPath + "/edit." + name;
-        FileUtils.copy(currentFile, snapshotFile);
-        return snapshotFile;
-    }
-
-    function restoreSnapshot(name) {
-        var snapshotFile = editingSessionPath + "/edit." + name;
-        FileUtils.copy(snapshotFile, currentFile);
-        data.refreshFromDisk();
-    }
-
-    function checkpoint() {
-        level++;
-        items = items.slice(0, level);
-        items.push(createSnapshot(items.length));
-    }
-
-    function revertToPristine() {
-        if (!FileUtils.exists(pristineFile)) {
-            restoreSnapshot(0);
-            items = items.slice(0, 1);
-            level = 0;
-        } else {
-            FileUtils.copy(pristineFile, currentFile);
-            data.refreshFromDisk();
-            items = [];
-            checkpoint();
-            level = 0;
-            _revertedInThisSession = true;
-        }
-    }
-
-    property Action undoAction: Action {
-            text: i18n.tr("Undo")
-            iconName: "undo"
-            enabled: items.length > 0 && level > 0 && actionsEnabled
-            onTriggered: restoreSnapshot(--level);
-    }
-
-    property Action redoAction: Action {
-            text: i18n.tr("Redo")
-            iconName: "redo"
-            enabled: level < items.length - 1 && actionsEnabled
-            onTriggered: restoreSnapshot(++level);
-    }
-
-    property Action revertAction: Action {
-            text: i18n.tr("Revert to Original")
-            iconSource: Qt.resolvedUrl("assets/edit_revert.png")
-            enabled: actionsEnabled &&
-                     (level > 0 || (!_revertedInThisSession && _pristineFileExists))
-            onTriggered: revertRequested()
-    }
-}

=== added file 'modules/Ubuntu/Components/Extras/PhotoEditor/EditorAction.qml'
--- modules/Ubuntu/Components/Extras/PhotoEditor/EditorAction.qml	1970-01-01 00:00:00 +0000
+++ modules/Ubuntu/Components/Extras/PhotoEditor/EditorAction.qml	2015-06-12 13:08:47 +0000
@@ -0,0 +1,48 @@
+/*
+ * Copyright (C) 2015 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.3
+import Ubuntu.Components 1.1
+import QtHalide 0.1
+
+Action {
+    id: editorAction
+
+    property HalideFunction halideFunction
+    property HalideTransform halideTransform
+    property bool manualCommit: false
+    property var savedState
+
+    onTriggered: {
+        halideTransform.live = false;
+        savedState = internal.snapshotFunctionState(halideFunction);
+        execute();
+        if (!manualCommit) {
+            commit();
+        }
+    }
+
+    function commit() {
+        internal.pushUndoState(savedState);
+        internal.clearRedoStates();
+        halideFunction.enabled = true;
+        halideTransform.live = true;
+    }
+
+    function execute() {
+        // to be overridden by subclasses
+    }
+}

=== added file 'modules/Ubuntu/Components/Extras/PhotoEditor/ExifOrientation.qml'
--- modules/Ubuntu/Components/Extras/PhotoEditor/ExifOrientation.qml	1970-01-01 00:00:00 +0000
+++ modules/Ubuntu/Components/Extras/PhotoEditor/ExifOrientation.qml	2015-06-12 13:08:47 +0000
@@ -0,0 +1,32 @@
+/*
+ * Copyright (C) 2015 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 QtQml 2.0
+
+QtObject {
+    property int orientation: 1
+    property var sequence: [1, 6, 3, 8]
+
+    function rotateRight90() {
+        var index = (sequence.indexOf(orientation) + 1) % sequence.length;
+        orientation = sequence[index];
+    }
+
+    function add(a, b) {
+        var index = (sequence.indexOf(a) + sequence.indexOf(b)) % sequence.length;
+        return sequence[index];
+    }
+}

=== added file 'modules/Ubuntu/Components/Extras/PhotoEditor/FunctionStateSaver.qml'
--- modules/Ubuntu/Components/Extras/PhotoEditor/FunctionStateSaver.qml	1970-01-01 00:00:00 +0000
+++ modules/Ubuntu/Components/Extras/PhotoEditor/FunctionStateSaver.qml	2015-06-12 13:08:47 +0000
@@ -0,0 +1,56 @@
+/*
+ * Copyright (C) 2015 Canonical Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+import QtQuick 2.3
+
+QtObject {
+    property QtObject target
+    property var values
+
+    function qmltypeof(obj, className) {
+        // className plus "(" is the class instance without modification
+        // className plus "_QML" is the class instance with user-defined properties
+        if (obj != null) {
+            var str = obj.toString();
+            return str.indexOf(className + "(") == 0 || str.indexOf(className + "_QML") == 0;
+        } else {
+            return false;
+        }
+    }
+
+    function copy(destination, prop, value) {
+        if (qmltypeof(value, "QMatrix4x4")) {
+            destination[prop] = value.transposed().transposed();
+        } else {
+            destination[prop] = value;
+        }
+    }
+
+    function save() {
+        values = {};
+        for (var prop in target) {
+            if (typeof(target[prop]) !== "function") {
+                copy(values, prop, target[prop]);
+            }
+        }
+    }
+
+    function restore() {
+        for (var prop in values) {
+            copy(target, prop, values[prop]);
+        }
+    }
+}

=== added file 'modules/Ubuntu/Components/Extras/PhotoEditor/FunctionTransform.qml'
--- modules/Ubuntu/Components/Extras/PhotoEditor/FunctionTransform.qml	1970-01-01 00:00:00 +0000
+++ modules/Ubuntu/Components/Extras/PhotoEditor/FunctionTransform.qml	2015-06-12 13:08:47 +0000
@@ -0,0 +1,77 @@
+/*
+ * Copyright (C) 2015 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.3
+import QtHalide 0.1
+
+HalideFunction {
+    name: "transform"
+
+    property bool rotationOnly: true
+    property HalideImage input
+    property matrix4x4 transform: Qt.matrix4x4(1, 0, 0, 0,
+                                               0, 1, 0, 0,
+                                               0, 0, 1, 0,
+                                               0, 0, 0, 1)
+    property matrix4x4 size: Qt.matrix4x4(1, 0, 0, 0,
+                                          0, 1, 0, 0,
+                                          0, 0, 1, 0,
+                                          0, 0, 0, 1)
+
+    function rotateRight90() {
+        var angle = Math.PI/2;
+        var resizing = Qt.matrix4x4(Math.cos(angle), Math.sin(angle), 0, 0,
+                                    Math.sin(angle), Math.cos(angle), 0, 0,
+                                    0,               0,               1, 0,
+                                    0,               0,               0, 1);
+
+        var originalSize = Qt.vector3d(1, 1, 1);
+        var inputSize = size.times(originalSize);
+        var outputSize = resizing.times(inputSize);
+
+        var centering = Qt.matrix4x4(1, 0, (outputSize.x - inputSize.x)/2, 0,
+                                     0, 1, (outputSize.y - inputSize.y)/2, 0,
+                                     0, 0, 1,                              0,
+                                     0, 0, 0,                              1);
+        var translation = Qt.matrix4x4(1, 0, inputSize.x/2.0, 0,
+                                       0, 1, inputSize.y/2.0, 0,
+                                       0, 0, 1,               0,
+                                       0, 0, 0,               1);
+        var rotation = Qt.matrix4x4(Math.cos(angle), -Math.sin(angle), 0, 0,
+                                    Math.sin(angle), Math.cos(angle),  0, 0,
+                                    0, 0,                              1, 0,
+                                    0, 0,                              0, 1);
+        transform = transform.times(centering.times(translation.times(rotation.times(translation.inverted()))).inverted());
+        size = resizing.times(size);
+    }
+
+    function crop(startX, startY, cropWidth, cropHeight) {
+        rotationOnly = false;
+        var resizing = Qt.matrix4x4(cropWidth, 0,          0, 0,
+                                    0,         cropHeight, 0, 0,
+                                    0,         0,          1, 0,
+                                    0,         0,          0, 1);
+
+        var originalSize = Qt.vector3d(1, 1, 1);
+        var inputSize = size.times(originalSize);
+        var translation = Qt.matrix4x4(1, 0, startX*inputSize.x, 0,
+                                       0, 1, startY*inputSize.y, 0,
+                                       0, 0, 1,                  0,
+                                       0, 0, 0,                  1);
+        transform = transform.times(translation);
+        size = resizing.times(size);
+    }
+}

=== removed file 'modules/Ubuntu/Components/Extras/PhotoEditor/assets/[e-mail]'
Binary files modules/Ubuntu/Components/Extras/PhotoEditor/assets/[e-mail]	2015-02-03 16:38:18 +0000 and modules/Ubuntu/Components/Extras/PhotoEditor/assets/[e-mail]	1970-01-01 00:00:00 +0000 differ
=== renamed file 'modules/Ubuntu/Components/Extras/PhotoEditor/assets/[e-mail]' => 'modules/Ubuntu/Components/Extras/PhotoEditor/assets/[e-mail]'
Binary files modules/Ubuntu/Components/Extras/PhotoEditor/assets/[e-mail]	2015-02-03 16:38:18 +0000 and modules/Ubuntu/Components/Extras/PhotoEditor/assets/[e-mail]	2015-06-12 13:08:47 +0000 differ
=== modified file 'modules/Ubuntu/Components/Extras/plugin/CMakeLists.txt'
--- modules/Ubuntu/Components/Extras/plugin/CMakeLists.txt	2014-12-09 10:57:19 +0000
+++ modules/Ubuntu/Components/Extras/plugin/CMakeLists.txt	2015-06-12 13:08:47 +0000
@@ -1,5 +1,10 @@
 include(FindPkgConfig)
 pkg_check_modules(EXIV2 REQUIRED exiv2)             # photoeditor
+pkg_check_modules(HALIDE Halide)
+
+# Necessary to use Halide's Generators
+add_definitions("-std=c++11")
+add_definitions("-fno-rtti")
 
 set(PLUGIN_SRC
     components.cpp
@@ -11,16 +16,14 @@
 
 set(PHOTO_EDITOR_PLUGIN_SRC
     photoeditor/file-utils.cpp
-    photoeditor/orientation.cpp
-    photoeditor/photo-data.cpp
     photoeditor/photo-image-provider.cpp
     photoeditor/photo-metadata.cpp
-    photoeditor/imaging.cpp
-    photoeditor/photo-edit-thread.cpp
+    photoeditor/generator_transform.cpp
     )
 
 include_directories(
     ${CMAKE_BINARY_DIR}
+    ${HALIDE_INCLUDE_DIRS}
 )
 
 add_library(ubuntu-ui-extras-plugin SHARED ${PLUGIN_SRC} ${PLUGIN_HDRS}
@@ -28,6 +31,7 @@
 qt5_use_modules(ubuntu-ui-extras-plugin Core Qml Quick Xml Widgets)
 target_link_libraries(ubuntu-ui-extras-plugin
     ${EXIV2_LIBRARIES}
+    ${HALIDE_LIBRARIES}
     )
 
 # Qt5's cmake does not export QT_IMPORTS_DIR, lets query qmake on our own for now

=== modified file 'modules/Ubuntu/Components/Extras/plugin/components.cpp'
--- modules/Ubuntu/Components/Extras/plugin/components.cpp	2015-06-12 13:08:47 +0000
+++ modules/Ubuntu/Components/Extras/plugin/components.cpp	2015-06-12 13:08:47 +0000
@@ -19,7 +19,7 @@
 #include "components.h"
 #include "example/example-model.h"
 
-#include "photoeditor/photo-data.h"
+#include "photoeditor/photo-metadata.h"
 #include "photoeditor/photo-image-provider.h"
 #include "photoeditor/file-utils.h"
 
@@ -29,8 +29,8 @@
     qmlRegisterType<ExampleModel>(uri, 0, 2, "ExampleModel");
 
     // PhotoEditor component
-    qmlRegisterType<PhotoData>(uri, 0, 2, "PhotoData");
-    qmlRegisterSingletonType<FileUtils>(uri, 0, 2, "FileUtils",
+    qmlRegisterType<PhotoEditor::PhotoMetadata>(uri, 0, 2, "PhotoMetadata");
+    qmlRegisterSingletonType<PhotoEditor::FileUtils>(uri, 0, 2, "FileUtils",
                                         exportFileUtilsSingleton);
 }
 
@@ -49,5 +49,5 @@
     Q_UNUSED(engine);
     Q_UNUSED(scriptEngine);
 
-    return new FileUtils();
+    return new PhotoEditor::FileUtils();
 }

=== modified file 'modules/Ubuntu/Components/Extras/plugin/photoeditor/file-utils.cpp'
--- modules/Ubuntu/Components/Extras/plugin/photoeditor/file-utils.cpp	2014-11-25 15:44:31 +0000
+++ modules/Ubuntu/Components/Extras/plugin/photoeditor/file-utils.cpp	2015-06-12 13:08:47 +0000
@@ -22,6 +22,8 @@
 #include <QFileInfo>
 #include <QTemporaryDir>
 
+namespace PhotoEditor {
+
 FileUtils::FileUtils(QObject *parent) :
     QObject(parent)
 {
@@ -95,3 +97,5 @@
 {
     return QFileInfo::exists(path);
 }
+
+}

=== modified file 'modules/Ubuntu/Components/Extras/plugin/photoeditor/file-utils.h'
--- modules/Ubuntu/Components/Extras/plugin/photoeditor/file-utils.h	2014-12-09 15:15:43 +0000
+++ modules/Ubuntu/Components/Extras/plugin/photoeditor/file-utils.h	2015-06-12 13:08:47 +0000
@@ -19,6 +19,8 @@
 
 #include <QObject>
 
+namespace PhotoEditor {
+
 class FileUtils : public QObject
 {
     Q_OBJECT
@@ -39,4 +41,6 @@
     Q_INVOKABLE bool exists(QString path) const;
 };
 
+}
+
 #endif // PHOTOUTILS_H

=== added file 'modules/Ubuntu/Components/Extras/plugin/photoeditor/generator_transform.cpp'
--- modules/Ubuntu/Components/Extras/plugin/photoeditor/generator_transform.cpp	1970-01-01 00:00:00 +0000
+++ modules/Ubuntu/Components/Extras/plugin/photoeditor/generator_transform.cpp	2015-06-12 13:08:47 +0000
@@ -0,0 +1,65 @@
+/*
+ * Copyright (C) 2015 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 <Halide.h>
+#include "halide_generators_common.h"
+
+namespace {
+
+class Transform : public HalideGeneratorExtended<Transform> {
+public:
+    Halide::ImageParam input{ Halide::type_of<uint8_t>(), 3, "input" };
+    Halide::ImageParam transform{ Halide::type_of<float>(), 2, "transform" };
+    Halide::ImageParam size{ Halide::type_of<float>(), 2, "size" };
+
+    Halide::Func build()  {
+        Halide::Var x, y, c;
+        Halide::Func function;
+        Halide::Func clamped;
+        clamped(x, y, c) = input(Halide::clamp(x, 0, input.width()-1),
+                                 Halide::clamp(y, 0, input.height()-1), c);
+        function(x, y, c) = clamped(Halide::cast<int>(transform(0, 0)*x + transform(0, 1)*y + transform(0, 2)*input.width()),
+                                    Halide::cast<int>(transform(1, 0)*x + transform(1, 1)*y + transform(1, 2)*input.height()),
+                                    c);
+        schedule_cpu_and_glsl(this, input, function, x, y, c);
+
+        set_packed(input);
+        set_packed(function.output_buffer());
+
+        return function;
+    }
+
+    float getMatrixValue(Halide::ImageParam matrix, unsigned int row, unsigned int column) {
+        return ((float*)(matrix.get().raw_buffer()->host))[row + column * matrix.get().extent(1)];
+    }
+
+    QRect getOutputGeometry() {
+        int input_width = input.get().extent(0);
+        int input_height = input.get().extent(1);
+        int width = getMatrixValue(size, 0, 0) * input_width + getMatrixValue(size, 0, 1) * input_height;
+        int height = getMatrixValue(size, 1, 0) * input_width + getMatrixValue(size, 1, 1) * input_height;
+
+        QRect out;
+        out.setWidth(width);
+        out.setHeight(height);
+
+        return out;
+    }
+};
+
+Halide::RegisterGenerator<Transform> register_transform{"transform"};
+
+}

=== added file 'modules/Ubuntu/Components/Extras/plugin/photoeditor/halide_common.h'
--- modules/Ubuntu/Components/Extras/plugin/photoeditor/halide_common.h	1970-01-01 00:00:00 +0000
+++ modules/Ubuntu/Components/Extras/plugin/photoeditor/halide_common.h	2015-06-12 13:08:47 +0000
@@ -0,0 +1,91 @@
+/*
+ * Copyright (C) 2015 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 HALIDE_COMMON_H
+#define HALIDE_COMMON_H
+
+#include <QtCore/QRect>
+#include <QtCore/QHash>
+#include <QtGui/QImage>
+#include <Halide.h>
+
+typedef QRect (*getOutputGeometryFunction)(Halide::Internal::GeneratorBase*);
+
+class GeneratorHelperRegistry
+{
+public:
+    static QHash<Halide::Internal::GeneratorBase*, getOutputGeometryFunction>* getOutputGeometryRegistry() {
+        static QHash<Halide::Internal::GeneratorBase*, getOutputGeometryFunction>* registry = new QHash<Halide::Internal::GeneratorBase*, getOutputGeometryFunction>;
+        return registry;
+    }
+};
+
+inline void set_packed(Halide::OutputImageParam image, int channels = 4) {
+    image.set_stride(0, channels);
+    image.set_stride(2, 1);
+    image.set_extent(2, channels);
+}
+
+inline buffer_t* packedBuffer(uint8_t* pixels, int width, int height, int channels)
+{
+    buffer_t* buffer = new buffer_t;
+    memset(buffer, 0, sizeof(buffer_t));
+    buffer->host = pixels;
+    buffer->elem_size = 1;
+    buffer->extent[0] = width;
+    buffer->extent[1] = height;
+    buffer->extent[2] = channels;
+    buffer->stride[0] = buffer->extent[2];
+    buffer->stride[1] = buffer->extent[0] * buffer->stride[0];
+    buffer->stride[2] = 1;
+    return buffer;
+}
+
+inline buffer_t* halideBufferTFromQImage(QImage& image)
+{
+    image = image.convertToFormat(QImage::Format_RGBA8888);
+    return packedBuffer(image.bits(), image.width(), image.height(), 4);
+}
+
+inline Halide::Buffer halideBufferFromQImage(QImage& image)
+{
+    buffer_t* buft = halideBufferTFromQImage(image);
+    buft->host_dirty = true;
+    Halide::Buffer buffer(Halide::type_of<uint8_t>(), buft);
+    delete buft;
+    return buffer;
+}
+
+inline Halide::Buffer halideBufferFromTexture(uint textureId, QSize size)
+{
+    buffer_t* buft = packedBuffer(NULL, size.width(), size.height(), 4);
+    buft->dev = textureId;
+    Halide::Buffer buffer = Halide::Buffer(Halide::type_of<uint8_t>(), buft);
+    delete buft;
+    return buffer;
+}
+
+inline QRect getOutputGeometry(Halide::Internal::GeneratorBase* generator)
+{
+    getOutputGeometryFunction getOutputGeometry = GeneratorHelperRegistry::getOutputGeometryRegistry()->value(generator, 0);
+    return getOutputGeometry ? getOutputGeometry(generator) : QRect();
+}
+
+
+
+#endif // HALIDE_COMMON_H
+
+

=== added file 'modules/Ubuntu/Components/Extras/plugin/photoeditor/halide_generators_common.h'
--- modules/Ubuntu/Components/Extras/plugin/photoeditor/halide_generators_common.h	1970-01-01 00:00:00 +0000
+++ modules/Ubuntu/Components/Extras/plugin/photoeditor/halide_generators_common.h	2015-06-12 13:08:47 +0000
@@ -0,0 +1,63 @@
+/*
+ * Copyright (C) 2015 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 HALIDE_GENERATORS_COMMON_H
+#define HALIDE_GENERATORS_COMMON_H
+
+#include <Halide.h>
+#include <QtCore/QRect>
+#include "halide_common.h"
+
+inline void schedule_cpu_and_glsl(Halide::Internal::GeneratorBase* generator, Halide::ImageParam& input, Halide::Func& function, Halide::Var x, Halide::Var y, Halide::Var c) {
+    Halide::Target target = generator->get_target();
+    if (target.has_feature(Halide::Target::OpenGL)) {
+        // Schedule for GLSL
+        input.set_bounds(2, 0, 3);
+        function.bound(c, 0, 4);
+        function.glsl(x, y, c);
+    } else {
+        // Schedule for CPU
+        function.vectorize(c, 4).parallel(y);
+    }
+}
+
+template <class T> class HalideGeneratorExtended : public Halide::Generator<T> {
+public:
+    HalideGeneratorExtended() {
+        GeneratorHelperRegistry::getOutputGeometryRegistry()->insert(this, &HalideGeneratorExtended::staticGetOutputGeometry);
+    }
+
+    static QRect staticGetOutputGeometry(Halide::Internal::GeneratorBase* generator) {
+        return (static_cast<HalideGeneratorExtended*>(generator))->getOutputGeometry();
+    }
+
+    virtual QRect getOutputGeometry() {
+        QRect out;
+        Q_FOREACH(Halide::Internal::Parameter parameter, this->get_filter_parameters()) {
+            if (parameter.is_buffer() && QString::fromStdString(parameter.name()) == "input") {
+                out.setWidth(parameter.get_buffer().extent(0));
+                out.setHeight(parameter.get_buffer().extent(1));
+                return out;
+            }
+        }
+        return out;
+    }
+};
+
+
+#endif // HALIDE_GENERATORS_COMMON_H
+
+

=== removed file 'modules/Ubuntu/Components/Extras/plugin/photoeditor/imaging.cpp'
--- modules/Ubuntu/Components/Extras/plugin/photoeditor/imaging.cpp	2014-12-02 12:02:00 +0000
+++ modules/Ubuntu/Components/Extras/plugin/photoeditor/imaging.cpp	1970-01-01 00:00:00 +0000
@@ -1,363 +0,0 @@
-/*
- * Copyright (C) 2012 Canonical Ltd
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 3 as
- * published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- *
- * Authors:
- * Lucas Beeler <[e-mail]>
- */
-
-
-#include <QApplication>
-#include <qmath.h>
-
-#include "imaging.h"
-
-/*!
- * \brief HSVTransformation::transformPixel
- * \param pixel_color
- * \return
- */
-QColor HSVTransformation::transformPixel(const QColor &pixel_color) const
-{
-    QColor result;
-
-    int h, s, v;
-    pixel_color.getHsv(&h, &s, &v);
-
-    v = remap_table_[v];
-
-    result.setHsv(h, s, v);
-
-    return result;
-}
-
-/*!
- * \brief IntensityHistogram::IntensityHistogram
- * \param basis_image
- */
-IntensityHistogram::IntensityHistogram(const QImage& basis_image)
-{
-    for (int i = 0; i < 256; i++)
-        m_counts[i] = 0;
-
-    int width = basis_image.width();
-    int height = basis_image.height();
-
-    for (int j = 0; j < height; j++) {
-        QApplication::processEvents();
-
-        for (int i = 0; i < width; i++) {
-            QColor c = QColor(basis_image.pixel(i, j));
-            int intensity = c.value();
-            m_counts[intensity]++;
-        }
-    }
-
-    float pixel_count = (float)(width * height);
-    float accumulator = 0.0f;
-    for (int i = 0; i < 256; i++) {
-        m_probabilities[i] = ((float) m_counts[i]) / pixel_count;
-        accumulator += m_probabilities[i];
-        m_cumulativeProbabilities[i] = accumulator;
-    }
-}
-
-/*!
- * \brief IntensityHistogram::getCumulativeProbability
- * \param level
- * \return
- */
-float IntensityHistogram::getCumulativeProbability(int level)
-{
-    return m_cumulativeProbabilities[level];
-}
-
-
-const float ToneExpansionTransformation::DEFAULT_LOW_DISCARD_MASS = 0.02f;
-const float ToneExpansionTransformation::DEFAULT_HIGH_DISCARD_MASS = 0.98f;
-/*!
- * \brief ToneExpansionTransformation::ToneExpansionTransformation
- * \param h
- * \param low_discard_mass
- * \param high_discard_mass
- */
-ToneExpansionTransformation::ToneExpansionTransformation(IntensityHistogram h,
-                                                         float low_discard_mass, float high_discard_mass)
-{
-    if (low_discard_mass == -1.0f)
-        low_discard_mass = DEFAULT_LOW_DISCARD_MASS;
-    if (high_discard_mass == -1.0f)
-        high_discard_mass = DEFAULT_HIGH_DISCARD_MASS;
-
-    m_lowDiscardMass = low_discard_mass;
-    m_highDiscardMass = high_discard_mass;
-
-    m_lowKink = 0;
-    m_highKink = 255;
-
-    while (h.getCumulativeProbability(m_lowKink) < low_discard_mass)
-        m_lowKink++;
-
-    while (h.getCumulativeProbability(m_highKink) > high_discard_mass)
-        m_highKink--;
-
-    m_lowKink = clampi(m_lowKink, 0, 255);
-    m_highKink = clampi(m_highKink, 0, 255);
-
-    buildRemapTable();
-}
-
-/*!
- * \brief ToneExpansionTransformation::isIdentity
- * \return
- */
-bool ToneExpansionTransformation::isIdentity() const
-{
-    return ((m_lowKink == 0) && (m_highKink == 255));
-}
-
-/*!
- * \brief ToneExpansionTransformation::buildRemapTable
- */
-void ToneExpansionTransformation::buildRemapTable()
-{
-    float low_kink_f = ((float) m_lowKink) / 255.0f;
-    float high_kink_f = ((float) m_highKink) / 255.0f;
-
-    float slope = 1.0f / (high_kink_f - low_kink_f);
-    float intercept = -(low_kink_f / (high_kink_f - low_kink_f));
-
-    int i = 0;
-    for ( ; i <= m_lowKink; i++)
-        remap_table_[i] = 0;
-
-    for ( ; i < m_highKink; i++)
-        remap_table_[i] = (int) ((255.0f * (slope * (((float) i) / 255.0f) +
-                                            intercept)) + 0.5);
-
-    for ( ; i < 256; i++)
-        remap_table_[i] = 255;
-}
-
-/*!
- * \brief ToneExpansionTransformation::lowDiscardMass
- * \return
- */
-float ToneExpansionTransformation::lowDiscardMass() const
-{
-    return m_lowDiscardMass;
-}
-
-/*!
- * \brief ToneExpansionTransformation::highDiscardMass
- * \return
- */
-float ToneExpansionTransformation::highDiscardMass() const
-{
-    return m_highDiscardMass;
-}
-
-
-/*!
- * \brief HermiteGammaApproximationFunction::HermiteGammaApproximationFunction
- * \param user_interval_upper
- */
-HermiteGammaApproximationFunction::HermiteGammaApproximationFunction(
-        float user_interval_upper)
-{
-    m_nonzeroIntervalUpper = clampf(user_interval_upper, 0.1f, 1.0f);
-    m_xScale = 1.0f / m_nonzeroIntervalUpper;
-}
-
-/*!
- * \brief HermiteGammaApproximationFunction::evaluate
- * \param x
- * \return
- */
-float HermiteGammaApproximationFunction::evaluate(float x)
-{
-    if (x < 0.0f)
-        return 0.0f;
-    else if (x > m_nonzeroIntervalUpper)
-        return 0.0f;
-    else {
-        float indep_var = m_xScale * x;
-
-        float dep_var =  6.0f * ((indep_var * indep_var * indep_var) -
-                                 (2.0f * (indep_var * indep_var)) + (indep_var));
-
-        return clampf(dep_var, 0.0f, 1.0f);
-    }
-}
-
-
-const float ShadowDetailTransformation::MAX_EFFECT_SHIFT = 0.5f;
-const float ShadowDetailTransformation::MIN_TONAL_WIDTH = 0.1f;
-const float ShadowDetailTransformation::MAX_TONAL_WIDTH = 1.0f;
-const float ShadowDetailTransformation::TONAL_WIDTH = 1.0f;
-/*!
- * \brief ShadowDetailTransformation::ShadowDetailTransformation
- * \param intensity
- */
-ShadowDetailTransformation::ShadowDetailTransformation(float intensity)
-{
-    m_intensity = intensity;
-    float effect_shift = MAX_EFFECT_SHIFT * intensity;
-
-    HermiteGammaApproximationFunction func =
-            HermiteGammaApproximationFunction(TONAL_WIDTH);
-
-    for (int i = 0; i < 256; i++) {
-        float x = ((float) i) / 255.0f;
-        float weight = func.evaluate(x);
-
-        int remapped = (int) ((255.0f * (weight * (x + effect_shift)) + ((1.0f -
-                                                                          weight) * x)) + 0.5f);
-        remap_table_[i] = clampi(remapped, i, 255);
-    }
-}
-
-/*!
- * \brief ShadowDetailTransformation::isIdentity
- * \return
- */
-bool ShadowDetailTransformation::isIdentity() const
-{
-    return (m_intensity == 0.0f);
-}
-
-
-const int AutoEnhanceTransformation::SHADOW_DETECT_MIN_INTENSITY = 2;
-const int AutoEnhanceTransformation::SHADOW_DETECT_MAX_INTENSITY = 90;
-const int AutoEnhanceTransformation::SHADOW_DETECT_INTENSITY_RANGE =
-        AutoEnhanceTransformation::SHADOW_DETECT_MAX_INTENSITY -
-        AutoEnhanceTransformation::SHADOW_DETECT_MIN_INTENSITY;
-const int AutoEnhanceTransformation::EMPIRICAL_DARK = 40;
-const float AutoEnhanceTransformation::SHADOW_AGGRESSIVENESS_MUL = 0.45f;
-/*!
- * \brief AutoEnhanceTransformation::AutoEnhanceTransformation
- * \param basis
- */
-AutoEnhanceTransformation::AutoEnhanceTransformation(const QImage& basis)
-    : m_shadowTransform(0), m_toneExpansionTransform(0)
-{
-    IntensityHistogram histogram = IntensityHistogram(basis);
-
-    /* compute the percentage of pixels in the image that fall into the
-     shadow range -- this measures "of the pixels in the image, how many of
-     them are in shadow?" */
-    float pct_in_range = 100.0f *
-            (histogram.getCumulativeProbability(SHADOW_DETECT_MAX_INTENSITY) -
-             histogram.getCumulativeProbability(SHADOW_DETECT_MIN_INTENSITY));
-
-    /* compute the mean intensity of the pixels that are in the shadow range --
-     this measures "of those pixels that are in shadow, just how dark are
-     they?" */
-    float sh_prob_mu =
-            (histogram.getCumulativeProbability(SHADOW_DETECT_MIN_INTENSITY) +
-             histogram.getCumulativeProbability(SHADOW_DETECT_MAX_INTENSITY)) * 0.5f;
-    int sh_intensity_mu = SHADOW_DETECT_MIN_INTENSITY;
-    for ( ; sh_intensity_mu <= SHADOW_DETECT_MAX_INTENSITY; sh_intensity_mu++) {
-        if (histogram.getCumulativeProbability(sh_intensity_mu) >= sh_prob_mu)
-            break;
-    }
-
-    /* if more than 30 percent of the pixels in the image are in the shadow
-     detection range, or if the mean intensity within the shadow range is less
-     than an empirically determined threshold below which pixels appear very
-     dark, regardless of the percent of pixels in it, then perform shadow
-     detail enhancement. Otherwise, skip shadow detail enhancement and perform
-     contrast expansion only */
-    if ((pct_in_range > 30.0f) || ((pct_in_range > 10.0f) &&
-                                   (sh_intensity_mu < EMPIRICAL_DARK))) {
-        float shadow_trans_effect_size = ((((float) SHADOW_DETECT_MAX_INTENSITY) -
-                                           ((float) sh_intensity_mu)) /
-                                          ((float) SHADOW_DETECT_INTENSITY_RANGE));
-        shadow_trans_effect_size *= SHADOW_AGGRESSIVENESS_MUL;
-
-        m_shadowTransform
-                = new ShadowDetailTransformation(shadow_trans_effect_size);
-
-        QImage shadow_corrected_image = QImage(basis);
-        // Can't write into indexed images, due to a limitation in Qt.
-        if (shadow_corrected_image.format() == QImage::Format_Indexed8)
-            shadow_corrected_image = shadow_corrected_image.convertToFormat(
-                        QImage::Format_RGB32);
-
-        for (int j = 0; j < shadow_corrected_image.height(); j++) {
-            QApplication::processEvents();
-
-            for (int i = 0; i < shadow_corrected_image.width(); i++) {
-                QColor px = m_shadowTransform->transformPixel(
-                            QColor(shadow_corrected_image.pixel(i, j)));
-                shadow_corrected_image.setPixel(i, j, px.rgb());
-            }
-        }
-
-        m_toneExpansionTransform = new ToneExpansionTransformation(
-                    IntensityHistogram(shadow_corrected_image), 0.005f, 0.995f);
-
-    } else {
-        m_toneExpansionTransform = new ToneExpansionTransformation(
-                    IntensityHistogram(basis));
-    }
-}
-
-/*!
- * \brief AutoEnhanceTransformation::~AutoEnhanceTransformation
- */
-AutoEnhanceTransformation::~AutoEnhanceTransformation()
-{
-    if (m_shadowTransform)
-        delete m_shadowTransform;
-    delete m_toneExpansionTransform;
-}
-
-/*!
- * \brief AutoEnhanceTransformation::transformPixel
- * \param pixel_color
- * \return
- */
-QColor AutoEnhanceTransformation::transformPixel(
-        const QColor& pixel_color) const
-{
-    QColor px = pixel_color;
-
-    if (m_shadowTransform)
-        px = m_shadowTransform->transformPixel(px);
-
-    px = m_toneExpansionTransform->transformPixel(px);
-
-    /* if tone expansion occurs, boost saturation to compensate for boosted
-     dynamic range */
-    if (!m_toneExpansionTransform->isIdentity()) {
-        int h, s, v;
-        px.getHsv(&h, &s, &v);
-
-        float compensation_multiplier =
-                (m_toneExpansionTransform->lowDiscardMass() < 0.01f) ? 1.02f : 1.10f;
-
-        s = (int) (((float) s) * compensation_multiplier);
-        s = clampi(s, 0, 255);
-
-        px.setHsv(h, s, v);
-    }
-
-    return px;
-}
-
-bool AutoEnhanceTransformation::isIdentity() const
-{
-    return false;
-}

=== removed file 'modules/Ubuntu/Components/Extras/plugin/photoeditor/imaging.h'
--- modules/Ubuntu/Components/Extras/plugin/photoeditor/imaging.h	2014-12-02 12:02:00 +0000
+++ modules/Ubuntu/Components/Extras/plugin/photoeditor/imaging.h	1970-01-01 00:00:00 +0000
@@ -1,169 +0,0 @@
-/*
- * Copyright (C) 2012 Canonical Ltd
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 3 as
- * published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- *
- * Authors:
- * Lucas Beeler <[e-mail]>
- */
-
-#ifndef GALLERY_UTIL_IMAGING_H_
-#define GALLERY_UTIL_IMAGING_H_
-
-#include <QColor>
-#include <QImage>
-#include <QVector4D>
-
-/*!
- * \brief clampi
- * \param i
- * \param min
- * \param max
- * \return
- */
-inline int clampi(int i, int min, int max) {
-    return (i < min) ? min : ((i > max) ? max : i);
-}
-
-/*!
- * \brief clampf
- * \param x
- * \param min
- * \param max
- * \return
- */
-inline float clampf(float x, float min, float max) {
-    return (x < min) ? min : ((x > max) ? max : x);
-}
-
-/*!
- * \brief The HSVTransformation class
- */
-class HSVTransformation
-{
-public:
-    HSVTransformation() { }
-    virtual ~HSVTransformation() { }
-
-    virtual QColor transformPixel(const QColor& pixel_color) const;
-    virtual bool isIdentity() const = 0;
-
-protected:
-    int remap_table_[256];
-};
-
-/*!
- * \brief The IntensityHistogram class
- */
-class IntensityHistogram
-{
-public:
-    IntensityHistogram(const QImage& basis_image);
-    virtual ~IntensityHistogram() { }
-
-    float getCumulativeProbability(int level);
-
-private:
-    int m_counts[256];
-    float m_probabilities[256];
-    float m_cumulativeProbabilities[256];
-};
-
-/*!
- * \brief The ToneExpansionTransformation class
- */
-class ToneExpansionTransformation : public virtual HSVTransformation
-{
-    static const float DEFAULT_LOW_DISCARD_MASS;
-    static const float DEFAULT_HIGH_DISCARD_MASS;
-
-public:
-    ToneExpansionTransformation(IntensityHistogram h, float lowDiscardMass =
-            -1.0f, float highDiscardMass = -1.0f);
-    virtual ~ToneExpansionTransformation() { }
-
-    bool isIdentity() const;
-
-    float lowDiscardMass() const;
-    float highDiscardMass() const;
-
-private:
-    void buildRemapTable();
-
-    int m_lowKink;
-    int m_highKink;
-    float m_lowDiscardMass;
-    float m_highDiscardMass;
-};
-
-/*!
- * \brief The HermiteGammaApproximationFunction class
- */
-class HermiteGammaApproximationFunction
-{
-public:
-    HermiteGammaApproximationFunction(float user_interval_upper);
-    virtual ~HermiteGammaApproximationFunction() { }
-
-    float evaluate(float x);
-
-private:
-    float m_xScale;
-    float m_nonzeroIntervalUpper;
-};
-
-/*!
- * \brief The ShadowDetailTransformation class
- */
-class ShadowDetailTransformation : public virtual HSVTransformation
-{
-    static const float MAX_EFFECT_SHIFT;
-    static const float MIN_TONAL_WIDTH;
-    static const float MAX_TONAL_WIDTH;
-    static const float TONAL_WIDTH;
-
-public:
-    ShadowDetailTransformation(float intensity);
-
-    bool isIdentity() const;
-
-private:
-    float m_intensity;
-};
-
-/*!
- * \brief The AutoEnhanceTransformation class
- */
-class AutoEnhanceTransformation : public virtual HSVTransformation
-{
-    static const int SHADOW_DETECT_MIN_INTENSITY;
-    static const int SHADOW_DETECT_MAX_INTENSITY;
-    static const int SHADOW_DETECT_INTENSITY_RANGE;
-    static const int EMPIRICAL_DARK;
-    static const float SHADOW_AGGRESSIVENESS_MUL;
-
-public:
-    AutoEnhanceTransformation(const QImage& basis_image);
-    virtual ~AutoEnhanceTransformation();
-
-    QColor transformPixel(const QColor& pixel_color) const;
-    bool isIdentity() const;
-
-private:
-    ShadowDetailTransformation* m_shadowTransform;
-    ToneExpansionTransformation* m_toneExpansionTransform;
-};
-
-
-#endif  // GALLERY_UTIL_IMAGING_H_
-

=== removed file 'modules/Ubuntu/Components/Extras/plugin/photoeditor/orientation.cpp'
--- modules/Ubuntu/Components/Extras/plugin/photoeditor/orientation.cpp	2014-11-19 10:14:20 +0000
+++ modules/Ubuntu/Components/Extras/plugin/photoeditor/orientation.cpp	1970-01-01 00:00:00 +0000
@@ -1,152 +0,0 @@
-/*
- * Copyright (C) 2011 Canonical Ltd
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 3 as
- * published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- *
- * Authors:
- * Lucas Beeler <[e-mail]>
- */
-
-#include <cstdio>
-
-#include "orientation.h"
-
-/*!
- * \brief OrientationCorrection::fromOrientation
- * \param o
- * \return
- */
-OrientationCorrection OrientationCorrection::fromOrientation(Orientation o)
-{
-    double rotation_angle = 0.0;
-    double horizontal_scale_factor = 1.0;
-
-    switch (o) {
-    case TOP_RIGHT_ORIGIN:
-        horizontal_scale_factor = -1.0;
-        break;
-
-    case BOTTOM_RIGHT_ORIGIN:
-        rotation_angle = 180.0;
-        break;
-
-    case BOTTOM_LEFT_ORIGIN:
-        horizontal_scale_factor = -1.0;
-        rotation_angle = 180.0;
-        break;
-
-    case LEFT_TOP_ORIGIN:
-        horizontal_scale_factor = -1.0;
-        rotation_angle = -90.0;
-        break;
-
-    case RIGHT_TOP_ORIGIN:
-        rotation_angle = 90.0;
-        break;
-
-    case RIGHT_BOTTOM_ORIGIN:
-        horizontal_scale_factor = -1.0;
-        rotation_angle = 90.0;
-        break;
-
-    case LEFT_BOTTOM_ORIGIN:
-        rotation_angle = -90.0;
-        break;
-
-    default:
-        ; // do nothing
-        break;
-    }
-
-    return OrientationCorrection(rotation_angle, horizontal_scale_factor);
-}
-
-/*!
- * \brief OrientationCorrection::identity
- * \return
- */
-OrientationCorrection OrientationCorrection::identity()
-{
-    return OrientationCorrection(0.0, 1.0);
-}
-
-/*!
- * \brief OrientationCorrection::rotateOrientation
- * \param orientation
- * \param left
- * \return
- */
-Orientation OrientationCorrection::rotateOrientation(Orientation orientation, bool left)
-{
-    QVector<Orientation> sequence_a;
-    QVector<Orientation> sequence_b;
-    sequence_a <<
-                  TOP_LEFT_ORIGIN << LEFT_BOTTOM_ORIGIN << BOTTOM_RIGHT_ORIGIN << RIGHT_TOP_ORIGIN;
-    sequence_b <<
-                  TOP_RIGHT_ORIGIN << RIGHT_BOTTOM_ORIGIN << BOTTOM_LEFT_ORIGIN << LEFT_TOP_ORIGIN;
-
-    const QVector<Orientation>& sequence = (
-                sequence_a.contains(orientation) ? sequence_a : sequence_b);
-
-    int current = sequence.indexOf(orientation);
-    int jump = (left ? 1 : sequence.count() - 1);
-    int next = (current + jump) % sequence.count();
-
-    return sequence[next];
-}
-
-/*!
- * \brief OrientationCorrection::toTransform
- * Returns the correction as a QTransform.
- * \return Returns the correction as a QTransform.
- */
-QTransform OrientationCorrection::toTransform() const
-{
-    QTransform result;
-    result.scale(m_horizontalScaleFactor, 1.0);
-    result.rotate(m_rotationAngle);
-
-    return result;
-}
-
-/*!
- * \brief OrientationCorrection::isFlippedFrom
- * Returns whether the two orientations are flipped relative to each other.
- * Ignores rotation_angle; only checks horizontal_scale_factor_.
- * \param other
- * \return
- */
-bool OrientationCorrection::isFlippedFrom(
-        const OrientationCorrection& other) const
-{
-    return (m_horizontalScaleFactor != other.m_horizontalScaleFactor);
-}
-
-/*!
- * \brief OrientationCorrection::getNormalizedRotationDifference
- * Returns the rotation difference in degrees (this - other), normalized to
- * 0, 90, 180, or 270.  Ignores the horizontal_scale_factor_.
- * \param other
- * \return
- */
-int OrientationCorrection::getNormalizedRotationDifference(
-        const OrientationCorrection& other) const
-{
-    int degrees_rotation = (int)m_rotationAngle - (int)other.m_rotationAngle;
-    if (degrees_rotation < 0)
-        degrees_rotation += 360;
-
-    Q_ASSERT(degrees_rotation == 0 || degrees_rotation == 90 ||
-             degrees_rotation == 180 || degrees_rotation == 270);
-    return degrees_rotation;
-}

=== removed file 'modules/Ubuntu/Components/Extras/plugin/photoeditor/orientation.h'
--- modules/Ubuntu/Components/Extras/plugin/photoeditor/orientation.h	2014-11-19 10:14:20 +0000
+++ modules/Ubuntu/Components/Extras/plugin/photoeditor/orientation.h	1970-01-01 00:00:00 +0000
@@ -1,64 +0,0 @@
-/*
- * Copyright (C) 2011 Canonical Ltd
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 3 as
- * published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- *
- * Authors:
- * Lucas Beeler <[e-mail]>
- */
-
-#ifndef GALLERY_ORIENTATION_H_
-#define GALLERY_ORIENTATION_H_
-
-#include <QTransform>
-
-enum Orientation {
-    ORIGINAL_ORIENTATION = 0,
-    MIN_ORIENTATION = 1,
-    TOP_LEFT_ORIGIN = 1,
-    TOP_RIGHT_ORIGIN = 2,
-    BOTTOM_RIGHT_ORIGIN = 3,
-    BOTTOM_LEFT_ORIGIN = 4,
-    LEFT_TOP_ORIGIN = 5,
-    RIGHT_TOP_ORIGIN = 6,
-    RIGHT_BOTTOM_ORIGIN = 7,
-    LEFT_BOTTOM_ORIGIN = 8,
-    MAX_ORIENTATION = 8
-};
-
-/*!
- * \brief The OrientationCorrection struct
- */
-class OrientationCorrection
-{
-public:
-    static OrientationCorrection fromOrientation(Orientation o);
-    static OrientationCorrection identity();
-    static Orientation rotateOrientation(Orientation orientation, bool left);
-
-    QTransform toTransform() const;
-
-    bool isFlippedFrom(const OrientationCorrection& other) const;
-    int getNormalizedRotationDifference(const OrientationCorrection& other) const;
-
-private:
-    OrientationCorrection(double rotation_angle, double horizontal_scale_factor)
-        : m_rotationAngle(rotation_angle),
-          m_horizontalScaleFactor(horizontal_scale_factor) { }
-
-    const double m_rotationAngle;
-    const double m_horizontalScaleFactor;
-};
-
-
-#endif // GALLERY_ORIENTATION_H_

=== removed file 'modules/Ubuntu/Components/Extras/plugin/photoeditor/photo-data.cpp'
--- modules/Ubuntu/Components/Extras/plugin/photoeditor/photo-data.cpp	2015-03-02 20:25:09 +0000
+++ modules/Ubuntu/Components/Extras/plugin/photoeditor/photo-data.cpp	1970-01-01 00:00:00 +0000
@@ -1,275 +0,0 @@
-/*
- * Copyright (C) 2011-2014 Canonical Ltd
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 3 as
- * published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- *
- * Authors:
- * Jim Nelson <[e-mail]>
- * Lucas Beeler <[e-mail]>
- * Charles Lindsay <[e-mail]>
- * Eric Gregory <[e-mail]>
- * Clint Rogers <[e-mail]>
- * Ugo Riboni <[e-mail]>
- */
-
-#include "photo-data.h"
-#include "photo-edit-command.h"
-#include "photo-edit-thread.h"
-
-// medialoader
-#include "photo-metadata.h"
-
-// util
-#include "imaging.h"
-
-#include <QApplication>
-#include <QDebug>
-#include <QDir>
-#include <QFileInfo>
-#include <QImage>
-#include <QImageReader>
-#include <QImageWriter>
-#include <QStack>
-#include <QStandardPaths>
-
-/*!
- * \brief Photo::isValid
- * \param file
- * \return
- */
-bool PhotoData::isValid(const QFileInfo& file)
-{
-    QImageReader reader(file.filePath());
-    QByteArray format = reader.format();
-
-    if (QString(format).toLower() == "tiff") {
-        // QImageReader.canRead() will detect some raw files as readable TIFFs,
-        // though QImage will fail to load them.
-        QString extension = file.suffix().toLower();
-        if (extension != "tiff" && extension != "tif")
-            return false;
-    }
-
-    PhotoMetadata* tmp = PhotoMetadata::fromFile(file);
-    if (tmp == NULL)
-        return false;
-
-    delete tmp;
-    return reader.canRead() &&
-            QImageWriter::supportedImageFormats().contains(reader.format());
-}
-
-/*!
- * \brief Photo::Photo
- * \param file
- */
-PhotoData::PhotoData()
-    : QObject(),
-    m_editThread(0),
-    m_busy(false),
-    m_orientation(TOP_LEFT_ORIGIN)
-{
-}
-
-void PhotoData::setPath(QString path)
-{
-    if (QFileInfo(path).absoluteFilePath() != m_file.absoluteFilePath()) {
-        QFileInfo newFile(path);
-        if (newFile.exists() && newFile.isFile()) {
-            QByteArray format = QImageReader(newFile.absoluteFilePath()).format();
-            m_fileFormat = QString(format).toLower();
-            if (m_fileFormat == "jpg") // Why does Qt expose two different names here?
-                m_fileFormat = "jpeg";
-
-            m_file = newFile;
-            Q_EMIT pathChanged();
-
-            if (fileFormatHasMetadata()) {
-                PhotoMetadata* metadata = PhotoMetadata::fromFile(newFile.absoluteFilePath());
-                m_orientation = metadata->orientation();
-                delete metadata;
-                Q_EMIT orientationChanged();
-            }
-        }
-    }
-}
-
-QString PhotoData::path() const
-{
-    return m_file.absoluteFilePath();
-}
-
-QFileInfo PhotoData::file() const
-{
-    return m_file;
-}
-
-/*!
- * \brief Photo::~Photo
- */
-PhotoData::~PhotoData()
-{
-    if (m_editThread) {
-        m_editThread->wait();
-        finishEditing();
-    }
-}
-
-/*!
- * \brief Photo::orientation
- * \return
- */
-Orientation PhotoData::orientation() const
-{  
-    return m_orientation;
-}
-
-void PhotoData::refreshFromDisk()
-{
-    if (fileFormatHasMetadata()) {
-        PhotoMetadata* metadata = PhotoMetadata::fromFile(m_file.absoluteFilePath());
-        qDebug() << "Refreshing orient." << m_orientation << "to" << metadata->orientation();
-        m_orientation = metadata->orientation();
-        delete metadata;
-        Q_EMIT orientationChanged();
-    }
-
-    Q_EMIT dataChanged();
-}
-
-/*!
- * \brief Photo::rotateRight
- */
-void PhotoData::rotateRight()
-{
-    Orientation current = fileFormatHasOrientation() ? orientation() :
-                                                       TOP_LEFT_ORIGIN;
-    Orientation rotated = OrientationCorrection::rotateOrientation(current,
-                                                                   false);
-    qDebug() << " Rotate from orientation " << current << "to" << rotated;
-
-    PhotoEditCommand command;
-    command.type = EDIT_ROTATE;
-    command.orientation = rotated;
-    asyncEdit(command);
-}
-
-/*!
- * \brief Photo::autoEnhance
- */
-void PhotoData::autoEnhance()
-{
-    PhotoEditCommand command;
-    command.type = EDIT_ENHANCE;
-    asyncEdit(command);
-}
-
-/*!
- * \brief Photo::exposureCompensation Changes the brightnes of the image
- * \param value Value for the compensation. -1.0 moves the image into total black.
- * +1.0 to total white. 0.0 leaves it as it is.
- */
-void PhotoData::exposureCompensation(qreal value)
-{
-    PhotoEditCommand command;
-    command.type = EDIT_COMPENSATE_EXPOSURE;
-    command.exposureCompensation = value;
-    asyncEdit(command);
-}
-
-/*!
- * \brief Photo::crop
- * Specify all coords in [0.0, 1.0], where 1.0 is the full size of the image.
- * They will be clamped to this range if you don't.
- * \param vrect the rectangle specifying the region to be cropped
- */
-void PhotoData::crop(QVariant vrect)
-{
-    PhotoEditCommand command;
-    command.type = EDIT_CROP;
-    command.crop_rectangle = vrect.toRectF();
-    asyncEdit(command);
-}
-
-/*!
- * \brief Photo::asyncEdit does edit the photo according to the given command
- * in a background thread.
- * \param The command defining the edit operation to perform.
- */
-void PhotoData::asyncEdit(const PhotoEditCommand& command)
-{
-    if (m_busy) {
-        qWarning() << "Can't start edit operation while another one is running.";
-        return;
-    }
-    m_busy = true;
-    Q_EMIT busyChanged();
-    m_editThread = new PhotoEditThread(this, command);
-    connect(m_editThread, SIGNAL(finished()), this, SLOT(finishEditing()));
-    m_editThread->start();
-}
-
-/*!
- * \brief Photo::finishEditing do all the updates once the editing is done
- */
-void PhotoData::finishEditing()
-{
-    if (!m_editThread || m_editThread->isRunning())
-        return;
-
-    m_editThread->deleteLater();
-    m_editThread = 0;
-    m_busy = false;
-
-    refreshFromDisk();
-
-    Q_EMIT busyChanged();
-    Q_EMIT editFinished();
-}
-
-/*!
- * \brief Photo::fileFormat returns the file format as QString
- * \return
- */
-const QString &PhotoData::fileFormat() const
-{
-    return m_fileFormat;
-}
-
-/*!
- * \brief Photo::fileFormatHasMetadata
- * \return
- */
-bool PhotoData::fileFormatHasMetadata() const
-{
-    return (m_fileFormat == "jpeg" || m_fileFormat == "tiff" ||
-            m_fileFormat == "png");
-}
-
-/*!
- * \brief Photo::fileFormatHasOrientation
- * \return
- */
-bool PhotoData::fileFormatHasOrientation() const
-{
-    return (m_fileFormat == "jpeg");
-}
-
-/*!
- * \brief Photo::busy return true if there is an editing operation in progress
- * \return
- */
-bool PhotoData::busy() const
-{
-    return m_busy;
-}

=== removed file 'modules/Ubuntu/Components/Extras/plugin/photoeditor/photo-data.h'
--- modules/Ubuntu/Components/Extras/plugin/photoeditor/photo-data.h	2015-03-02 20:25:09 +0000
+++ modules/Ubuntu/Components/Extras/plugin/photoeditor/photo-data.h	1970-01-01 00:00:00 +0000
@@ -1,92 +0,0 @@
-/*
- * Copyright (C) 2011-2014 Canonical Ltd
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 3 as
- * published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- *
- * Authors:
- * Jim Nelson <[e-mail]>
- * Lucas Beeler <[e-mail]>
- * Charles Lindsay <[e-mail]>
- * Ugo Riboni <[e-mail]>
- */
-
-#ifndef PHOTO_DATA_H_
-#define PHOTO_DATA_H_
-
-// util
-#include "orientation.h"
-
-// QT
-#include <QFileInfo>
-#include <QVariant>
-
-class PhotoEditCommand;
-class PhotoEditThread;
-
-/*!
- * \brief The Photo class
- */
-class PhotoData : public QObject
-{
-    Q_OBJECT
-
-    Q_PROPERTY(QString path READ path WRITE setPath NOTIFY pathChanged)
-    Q_PROPERTY(int orientation READ orientation NOTIFY orientationChanged)
-    Q_PROPERTY(bool busy READ busy NOTIFY busyChanged)
-
-public:
-    explicit PhotoData();
-    virtual ~PhotoData();
-
-    static bool isValid(const QFileInfo& file);
-
-    QString path() const;
-    void setPath(QString path);
-    QFileInfo file() const;
-    bool busy() const;
-
-    virtual Orientation orientation() const;
-
-    Q_INVOKABLE void refreshFromDisk();
-    Q_INVOKABLE void rotateRight();
-    Q_INVOKABLE void autoEnhance();
-    Q_INVOKABLE void exposureCompensation(qreal value);
-    Q_INVOKABLE void crop(QVariant vrect);
-
-    const QString &fileFormat() const;
-    bool fileFormatHasMetadata() const;
-    bool fileFormatHasOrientation() const;
-
-Q_SIGNALS:
-    void pathChanged();
-    void orientationChanged();
-    void busyChanged();
-
-    void editFinished();
-    void dataChanged();
-
-private Q_SLOTS:
-    void finishEditing();
-
-private:
-    void asyncEdit(const PhotoEditCommand& state);
-
-    QString m_fileFormat;
-    PhotoEditThread *m_editThread;
-    QFileInfo m_file;
-    bool m_busy;
-
-    Orientation m_orientation;
-};
-
-#endif  // PHOTO_DATA_H_

=== removed file 'modules/Ubuntu/Components/Extras/plugin/photoeditor/photo-edit-thread.cpp'
--- modules/Ubuntu/Components/Extras/plugin/photoeditor/photo-edit-thread.cpp	2015-01-28 12:11:56 +0000
+++ modules/Ubuntu/Components/Extras/plugin/photoeditor/photo-edit-thread.cpp	1970-01-01 00:00:00 +0000
@@ -1,185 +0,0 @@
-/*
- * Copyright (C) 2013-2014 Canonical Ltd
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 3 as
- * published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- */
-
-#include "photo-edit-thread.h"
-#include "photo-data.h"
-
-// medialoader
-#include "photo-metadata.h"
-
-// util
-#include "imaging.h"
-
-#include <QDebug>
-
-/*!
- * \brief PhotoEditThread::PhotoEditThread
- */
-PhotoEditThread::PhotoEditThread(PhotoData *photo, const PhotoEditCommand &command)
-    : QThread(),
-      m_photo(photo),
-      m_command(command)
-{
-}
-
-/*!
- * \brief PhotoEditThread::command resturns the editing command used for this processing
- * \return
- */
-const PhotoEditCommand &PhotoEditThread::command() const
-{
-    return m_command;
-}
-
-/*!
- * \brief PhotoEditThread::run \reimp
- */
-void PhotoEditThread::run()
-{
-    // The only operation in which we don't have to work on the actual image
-    // pixels is image rotation in the case where we can simply change the
-    // metadata rotation field.
-    if (m_command.type == EDIT_ROTATE && m_photo->fileFormatHasOrientation()) {
-        handleSimpleMetadataRotation(m_command);
-        return;
-    }
-
-    // In all other cases we load the image, do the work, and save it back.
-    QImage image(m_photo->file().filePath(), m_photo->fileFormat().toStdString().c_str());
-    if (image.isNull()) {
-        qWarning() << "Error loading" << m_photo->file().filePath() << "for editing";
-        return;
-    }
-
-    // Copy all metadata from the original image so that we can save it to the
-    // new one after modifying the pixels.
-    PhotoMetadata* original = PhotoMetadata::fromFile(m_photo->file());
-
-    // If the photo was previously rotated through metadata and we are editing
-    // the actual pixels, first rotate the image to match the orientation so
-    // that the correct pixels are edited.
-    // Obviously don't do this in the case we have been asked to do a rotation
-    // operation on the pixels, as we would do it later as the operation itself.
-    if (m_photo->fileFormatHasOrientation() && m_command.type != EDIT_ROTATE) {
-        Orientation orientation = m_photo->orientation();
-        QTransform transform = OrientationCorrection::fromOrientation(orientation).toTransform();
-        image = image.transformed(transform);
-    }
-
-    if (m_command.type == EDIT_ROTATE) {
-        QTransform transform = OrientationCorrection::fromOrientation(m_command.orientation).toTransform();
-        image = image.transformed(transform);
-    } else if (m_command.type == EDIT_CROP) {
-        QRect rect;
-        rect.setX(qBound(0.0, m_command.crop_rectangle.x(), 1.0) * image.width());
-        rect.setY(qBound(0.0, m_command.crop_rectangle.y(), 1.0) * image.height());
-        rect.setWidth(qBound(0.0, m_command.crop_rectangle.width(), 1.0) * image.width());
-        rect.setHeight(qBound(0.0, m_command.crop_rectangle.height(), 1.0) * image.height());
-
-        image = image.copy(rect);
-    } else if (m_command.type == EDIT_ENHANCE) {
-        image = enhanceImage(image);
-    } else if (m_command.type == EDIT_COMPENSATE_EXPOSURE) {
-        image = compensateExposure(image, m_command.exposureCompensation);
-    } else {
-        qWarning() << "Edit thread running with unknown or no operation.";
-        return;
-    }
-
-    bool saved = image.save(m_photo->file().filePath(),
-                            m_photo->fileFormat().toStdString().c_str(), 90);
-    if (!saved)
-        qWarning() << "Error saving edited" << m_photo->file().filePath();
-
-    PhotoMetadata* copy = PhotoMetadata::fromFile(m_photo->file());
-    original->copyTo(copy);
-    copy->setOrientation(TOP_LEFT_ORIGIN); // reset previous orientation
-    copy->updateThumbnail(image);
-    copy->save();
-
-    delete original;
-    delete copy;
-}
-
-/*!
- * \brief PhotoEditThread::handleSimpleMetadataRotation
- * Handler for the case of an image whose only change is to its
- * orientation; used to skip re-encoding of JPEGs.
- * \param state
- */
-void PhotoEditThread::handleSimpleMetadataRotation(const PhotoEditCommand& state)
-{
-    PhotoMetadata* metadata = PhotoMetadata::fromFile(m_photo->file());
-    metadata->setOrientation(state.orientation);
-    metadata->save();
-    delete(metadata);
-}
-
-/*!
- * \brief PhotoEditThread::enhanceImage
- */
-QImage PhotoEditThread::enhanceImage(const QImage& image)
-{
-    int width = image.width();
-    int height = image.height();
-
-    QImage sample_img = (image.width() > 400) ? image.scaledToWidth(400) : image;
-
-    AutoEnhanceTransformation enhance = AutoEnhanceTransformation(sample_img);
-
-    QImage::Format dest_format = image.format();
-
-    // Can't write into indexed images, due to a limitation in Qt.
-    if (dest_format == QImage::Format_Indexed8)
-        dest_format = QImage::Format_RGB32;
-
-    QImage enhanced_image(width, height, dest_format);
-
-    for (int j = 0; j < height; j++) {
-        for (int i = 0; i < width; i++) {
-            QColor px = enhance.transformPixel(
-                        QColor(image.pixel(i, j)));
-            enhanced_image.setPixel(i, j, px.rgb());
-        }
-    }
-
-    return enhanced_image;
-}
-
-/*!
- * \brief PhotoEditThread::compensateExposure Compensates the exposure
- * Compensating the exposure is a change in brightnes
- * \param image Image to change the brightnes
- * \param compansation -1.0 is total dark, +1.0 is total bright
- * \return The image with adjusted brightnes
- */
-QImage PhotoEditThread::compensateExposure(const QImage &image, qreal compensation)
-{
-    int shift = qBound(-255, (int)(255*compensation), 255);
-    QImage result(image.width(), image.height(), image.format());
-
-    for (int j = 0; j < image.height(); j++) {
-        for (int i = 0; i <image.width(); i++) {
-            QColor px = image.pixel(i, j);
-            int red = qBound(0, px.red() + shift, 255);
-            int green = qBound(0, px.green() + shift, 255);
-            int blue = qBound(0, px.blue() + shift, 255);
-            result.setPixel(i, j, qRgb(red, green, blue));
-        }
-    }
-
-    return result;
-}

=== removed file 'modules/Ubuntu/Components/Extras/plugin/photoeditor/photo-edit-thread.h'
--- modules/Ubuntu/Components/Extras/plugin/photoeditor/photo-edit-thread.h	2014-12-02 11:43:13 +0000
+++ modules/Ubuntu/Components/Extras/plugin/photoeditor/photo-edit-thread.h	1970-01-01 00:00:00 +0000
@@ -1,56 +0,0 @@
-/*
- * Copyright (C) 2013-2014 Canonical Ltd
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 3 as
- * published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- */
-
-#ifndef GALLERY_PHOTO_EDIT_THREAD_H_
-#define GALLERY_PHOTO_EDIT_THREAD_H_
-
-#include "photo-caches.h"
-#include "photo-edit-command.h"
-
-// util
-#include "orientation.h"
-
-#include <QImage>
-#include <QThread>
-#include <QUrl>
-
-class PhotoData;
-
-/*!
- * \brief The PhotoEditThread class
- */
-class PhotoEditThread: public QThread
-{
-    Q_OBJECT
-public:
-    PhotoEditThread(PhotoData *photo, const PhotoEditCommand& command);
-
-    const PhotoEditCommand& command() const;
-
-protected:
-    void run() Q_DECL_OVERRIDE;
-
-private:
-    QImage enhanceImage(const QImage& image);
-    QImage compensateExposure(const QImage& image, qreal compansation);
-    QImage doColorBalance(const QImage& image, qreal brightness, qreal contrast, qreal saturation, qreal hue);
-    void handleSimpleMetadataRotation(const PhotoEditCommand& state);
-
-    PhotoData *m_photo;
-    PhotoEditCommand m_command;
-};
-
-#endif

=== modified file 'modules/Ubuntu/Components/Extras/plugin/photoeditor/photo-metadata.cpp'
--- modules/Ubuntu/Components/Extras/plugin/photoeditor/photo-metadata.cpp	2015-06-12 13:08:47 +0000
+++ modules/Ubuntu/Components/Extras/plugin/photoeditor/photo-metadata.cpp	2015-06-12 13:08:47 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2011 Canonical Ltd
+ * Copyright (C) 2015 Canonical Ltd
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License version 3 as
@@ -13,269 +13,106 @@
  * You should have received a copy of the GNU General Public License
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  *
- * Authors:
- * Lucas Beeler <[e-mail]>
  */
 
 #include "photo-metadata.h"
 
-#include <cstdio>
 #include <QBuffer>
+#include <QtConcurrent/QtConcurrent>
 
 namespace {
-const Orientation DEFAULT_ORIENTATION = TOP_LEFT_ORIGIN;
 const char* EXIF_ORIENTATION_KEY = "Exif.Image.Orientation";
-const char* EXIF_DATETIMEDIGITIZED_KEY = "Exif.Photo.DateTimeDigitized";
-const char* EXPOSURE_TIME_KEYS[] = {
-    "Exif.Photo.DateTimeOriginal",
-    "Xmp.exif.DateTimeOriginal",
-    "Xmp.xmp.CreateDate",
-    "Exif.Photo.DateTimeDigitized",
-    "Xmp.exif.DateTimeDigitized",
-    "Exif.Image.DateTime"
-};
-const size_t NUM_EXPOSURE_TIME_KEYS = 6;
-const char* EXIF_DATE_FORMATS[] = {
-    "%d:%d:%d %d:%d:%d",
-
-    // for Minolta DiMAGE E223 (colon, instead of space, separates day from
-    // hour in exif)
-    "%d:%d:%d:%d:%d:%d",
-
-    // for Samsung NV10 (which uses a period instead of colons for the date
-    // and two spaces between date and time)
-    "%d.%d.%d  %d:%d:%d"
-};
-const size_t NUM_EXIF_DATE_FORMATS = 3;
-const float THUMBNAIL_SCALE = 8.5;
-
-const char* get_first_matched(const char* keys[], size_t n_keys,
-                              const QSet<QString>& in) {
-    for (size_t i = 0; i < n_keys; i++) {
-        if (in.contains(keys[i]))
-            return keys[i];
-    }
-    
-    return NULL;
-}
-
-bool is_xmp_key(const char* key) {
-    return (key != NULL) ? (std::strncmp("Xmp.", key, 4) == 0) : false;
-}
-
-bool is_exif_key(const char* key) {
-    return (key != NULL) ? (std::strncmp("Exif.", key, 5) == 0) : false;
-}
-
-// caller should test if 's' could be successfully parsed by invoking the
-// isValid() method on the returned QDateTime instance; if isValid() == false,
-// 's' couldn't be parsed
-QDateTime parse_xmp_date_string(const char* s) {
-    return QDateTime::fromString(s, Qt::ISODate);
-}
-
-// caller should test if 's' could be successfully parsed by invoking the
-// isValid() method on the returned QDateTime instance; if isValid() == false,
-// 's' couldn't be parsed
-QDateTime parse_exif_date_string(const char* s) {
-    for (size_t i = 0; i < NUM_EXIF_DATE_FORMATS; i++) {
-        int year, month, day, hour, minute, second;
-        if (std::sscanf(s, EXIF_DATE_FORMATS[i], &year, &month, &day, &hour,
-                        &minute, &second) == 6) {
-            // no need to check year, month, day, hour, minute and second variables
-            // for bogus values before using them -- if the values are bogus, the
-            // resulting QDateTime will be invalid, which is exactly what we want
-            return QDateTime(QDate(year, month, day), QTime(hour, minute, second));
-        }
-    }
-    
-    // the no argument QDateTime constructor produces an invalid QDateTime,
-    // which is what we want
-    return QDateTime();
-}
-} // namespace
-
-/*!
- * \brief PhotoMetadata::PhotoMetadata
- * \param filepath
- */
-PhotoMetadata::PhotoMetadata(const char* filepath)
-    : m_fileSourceInfo(filepath)
-{
-    m_image = Exiv2::ImageFactory::open(filepath);
-    m_image->readMetadata();
-}
-
-/*!
- * \brief PhotoMetadata::fromFile
- * \param filepath
- * \return
- */
-PhotoMetadata* PhotoMetadata::fromFile(const char* filepath)
-{
-    PhotoMetadata* result = NULL;
-    try {
-        result = new PhotoMetadata(filepath);
-
-        if (!result->m_image->good()) {
-            qDebug("Invalid image metadata in %s", filepath);
-            delete result;
-            return NULL;
-        }
-
-        Exiv2::ExifData& exif_data = result->m_image->exifData();
-        Exiv2::ExifData::const_iterator end = exif_data.end();
-        for (Exiv2::ExifData::const_iterator i = exif_data.begin(); i != end; i++)
-            result->m_keysPresent.insert(QString(i->key().c_str()));
-
-        Exiv2::XmpData& xmp_data = result->m_image->xmpData();
-        Exiv2::XmpData::const_iterator end1 = xmp_data.end();
-        for (Exiv2::XmpData::const_iterator i = xmp_data.begin(); i != end1; i++)
-            result->m_keysPresent.insert(QString(i->key().c_str()));
-
-        return result;
-    } catch (Exiv2::AnyError& e) {
-        qDebug("Error loading image metadata: %s", e.what());
-        delete result;
-        return NULL;
-    }
-}
-
-/*!
- * \brief PhotoMetadata::fromFile
- * \param file
- * \return
- */
-PhotoMetadata* PhotoMetadata::fromFile(const QFileInfo &file)
-{
-    return PhotoMetadata::fromFile(file.absoluteFilePath().toStdString().c_str());
-}
-
-/*!
- * \brief PhotoMetadata::orientation
- * \return
- */
-Orientation PhotoMetadata::orientation() const
+
+} // anonymous namespace
+
+namespace PhotoEditor {
+
+PhotoMetadata::PhotoMetadata()
+{
+    connect(&m_saveWatcher, SIGNAL(finished()), this, SIGNAL(savingChanged()));
+}
+
+QString PhotoMetadata::fileName() const
+{
+    return m_fileName;
+}
+
+void PhotoMetadata::setFileName(QString fileName)
+{
+    if (fileName != m_fileName) {
+        m_fileName = fileName;
+        try {
+            m_image = Exiv2::ImageFactory::open(fileName.toStdString());
+            if (!m_image->good()) {
+                qDebug("Invalid image metadata in %s", fileName.toLocal8Bit().constData());
+            }
+            m_image->readMetadata();
+        } catch (Exiv2::AnyError& e) {
+            qDebug("Error loading image metadata: %s", e.what());
+        }
+        Q_EMIT fileNameChanged();
+    }
+}
+
+int PhotoMetadata::orientation() const
 {
     Exiv2::ExifData& exif_data = m_image->exifData();
 
     if (exif_data.empty())
-        return DEFAULT_ORIENTATION;
-
-    if (m_keysPresent.find(EXIF_ORIENTATION_KEY) == m_keysPresent.end())
-        return DEFAULT_ORIENTATION;
+        return TOP_LEFT_ORIGIN;
 
     long orientation_code = exif_data[EXIF_ORIENTATION_KEY].toLong();
     if (orientation_code < MIN_ORIENTATION || orientation_code > MAX_ORIENTATION)
-        return DEFAULT_ORIENTATION;
+        return TOP_LEFT_ORIGIN;
 
     return static_cast<Orientation>(orientation_code);
 }
 
-/*!
- * \brief PhotoMetadata::exposureTime
- * \return
- */
-QDateTime PhotoMetadata::exposureTime() const
-{
-    const char* matched = get_first_matched(EXPOSURE_TIME_KEYS,
-                                            NUM_EXPOSURE_TIME_KEYS, m_keysPresent);
-    if (matched == NULL)
-        return QDateTime();
-
-    if (is_exif_key(matched))
-        return parse_exif_date_string(m_image->exifData()[matched].toString().c_str());
-
-    if (is_xmp_key(matched))
-        return parse_xmp_date_string(m_image->xmpData()[matched].toString().c_str());
-
-    // No valid/known tag for exposure date/time
-    return QDateTime();
-}
-
-/*!
- * \brief PhotoMetadata::orientationCorrection
- * \return
- */
-OrientationCorrection PhotoMetadata::orientationCorrection() const
-{
-    return OrientationCorrection::fromOrientation(orientation());
-}
-
-/*!
- * \brief PhotoMetadata::orientationTransform
- * \return
- */
-QTransform PhotoMetadata::orientationTransform() const
-{
-    return orientationCorrection().toTransform();
-}
-
-/*!
- * \brief PhotoMetadata::setOrientation
- * \param orientation
- */
-void PhotoMetadata::setOrientation(Orientation orientation)
+void PhotoMetadata::setOrientation(int orientation)
 {
     Exiv2::ExifData& exif_data = m_image->exifData();
-
     exif_data[EXIF_ORIENTATION_KEY] = (Exiv2::UShortValue)orientation;
-
-    if (!m_keysPresent.contains(EXIF_ORIENTATION_KEY))
-        m_keysPresent.insert(EXIF_ORIENTATION_KEY);
-}
-
-/*!
- * \brief PhotoMetadata::setDateTimeDigitized
- * \param digitized
- */
-void PhotoMetadata::setDateTimeDigitized(const QDateTime& digitized)
-{
-    try {
-        if (!m_image->good()) {
-            qDebug("Do not set DateTimeDigitized, invalid image metadata.");
-            return;
-        }
- 
-        Exiv2::ExifData& exif_data = m_image->exifData();
- 
-        exif_data[EXIF_DATETIMEDIGITIZED_KEY] = digitized.toString("yyyy:MM:dd hh:mm:ss").toStdString();
- 
-        if (!m_keysPresent.contains(EXIF_DATETIMEDIGITIZED_KEY))
-            m_keysPresent.insert(EXIF_DATETIMEDIGITIZED_KEY);
- 
-    } catch (Exiv2::AnyError& e) {
-        qDebug("Do not set DateTimeDigitized, error reading image metadata; %s", e.what());
-        return;
-    }
-}
-
-/*!
- * \brief PhotoMetadata::save
- * \return
- */
-bool PhotoMetadata::save() const
-{
-    try {
-        m_image->writeMetadata();
-        return true;
-    } catch (Exiv2::AnyError& e) {
-        return false;
-    }
-}
-
-void PhotoMetadata::copyTo(PhotoMetadata *other) const
-{
-    other->m_image->setMetadata(*m_image);
+}
+
+bool PhotoMetadata::saving() const
+{
+    return m_saveWatcher.isRunning();
 }
 
 void PhotoMetadata::updateThumbnail(QImage image)
 {
-    QImage scaled = image.scaled(image.width() / THUMBNAIL_SCALE,
-                                 image.height() / THUMBNAIL_SCALE);
+    QImage scaled = image.scaled(256, 256,  Qt::KeepAspectRatio);
     QBuffer jpeg;
     jpeg.open(QIODevice::WriteOnly);
     scaled.save(&jpeg, "jpeg");
     Exiv2::ExifThumb thumb(m_image->exifData());
     thumb.setJpegThumbnail((Exiv2::byte*) jpeg.data().constData(), jpeg.size());
 }
+
+void PhotoMetadata::saveImage(QImage image)
+{
+    QFuture<void> future = QtConcurrent::run(this, &PhotoMetadata::doSaveImage, image);
+    m_saveWatcher.setFuture(future);
+    Q_EMIT savingChanged();
+}
+
+void PhotoMetadata::save()
+{
+    QFuture<void> future = QtConcurrent::run(this, &PhotoMetadata::doSave);
+    m_saveWatcher.setFuture(future);
+    Q_EMIT savingChanged();
+}
+
+void PhotoMetadata::doSaveImage(QImage image)
+{
+    image.save(m_fileName);
+    updateThumbnail(image);
+    m_image->writeMetadata();
+}
+
+
+void PhotoMetadata::doSave()
+{
+    m_image->writeMetadata();
+}
+}

=== modified file 'modules/Ubuntu/Components/Extras/plugin/photoeditor/photo-metadata.h'
--- modules/Ubuntu/Components/Extras/plugin/photoeditor/photo-metadata.h	2015-03-02 20:25:09 +0000
+++ modules/Ubuntu/Components/Extras/plugin/photoeditor/photo-metadata.h	2015-06-12 13:08:47 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2011 Canonical Ltd
+ * Copyright (C) 2015 Canonical Ltd
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License version 3 as
@@ -13,55 +13,68 @@
  * You should have received a copy of the GNU General Public License
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  *
- * Authors:
- * Lucas Beeler <[e-mail]>
  */
 
-#ifndef GALLERY_PHOTO_METADATA_H_
-#define GALLERY_PHOTO_METADATA_H_
-
-// util
-#include "orientation.h"
-
-#include <QDateTime>
-#include <QFileInfo>
-#include <QObject>
-#include <QString>
-#include <QSet>
-#include <QTransform>
-#include <QImage>
+#ifndef PHOTO_METADATA_H
+#define PHOTO_METADATA_H
+
+#include <QtCore/QObject>
+#include <QtCore/QString>
+#include <QtCore/QFutureWatcher>
+#include <QtGui/QImage>
 
 #include <exiv2/exiv2.hpp>
 
-/*!
- * \brief The PhotoMetadata class
- */
+enum Orientation {
+    ORIGINAL_ORIENTATION = 0,
+    MIN_ORIENTATION = 1,
+    TOP_LEFT_ORIGIN = 1,
+    TOP_RIGHT_ORIGIN = 2,
+    BOTTOM_RIGHT_ORIGIN = 3,
+    BOTTOM_LEFT_ORIGIN = 4,
+    LEFT_TOP_ORIGIN = 5,
+    RIGHT_TOP_ORIGIN = 6,
+    RIGHT_BOTTOM_ORIGIN = 7,
+    LEFT_BOTTOM_ORIGIN = 8,
+    MAX_ORIENTATION = 8
+};
+namespace PhotoEditor {
+
 class PhotoMetadata : public QObject
 {
     Q_OBJECT
 
+    Q_PROPERTY(QString fileName READ fileName WRITE setFileName NOTIFY fileNameChanged)
+    Q_PROPERTY(int orientation READ orientation WRITE setOrientation NOTIFY orientationChanged)
+    Q_PROPERTY(bool saving READ saving NOTIFY savingChanged)
+
 public:
-    static PhotoMetadata* fromFile(const char* filepath);
-    static PhotoMetadata* fromFile(const QFileInfo& file);
-
-    QDateTime exposureTime() const;
-    Orientation orientation() const;
-    QTransform orientationTransform() const;
-    OrientationCorrection orientationCorrection() const;
-
-    void setOrientation(Orientation orientation);
-    void setDateTimeDigitized(const QDateTime& digitized);
-
+    PhotoMetadata();
+
+    QString fileName() const;
+    int orientation() const;
+    bool saving() const;
+
+    void setFileName(QString fileName);
+    void setOrientation(int orientation);
+
+    Q_INVOKABLE void saveImage(QImage image);
+    Q_INVOKABLE void save();
+
+Q_SIGNALS:
+    void fileNameChanged();
+    void orientationChanged();
+    void savingChanged();
+
+protected:
     void updateThumbnail(QImage image);
-    void copyTo(PhotoMetadata* other) const;
-    bool save() const;
+    void doSaveImage(QImage image);
+    void doSave();
 
 private:
-    PhotoMetadata(const char* filepath);
-    
     Exiv2::Image::AutoPtr m_image;
-    QSet<QString> m_keysPresent;
-    QFileInfo m_fileSourceInfo;
+    QString m_fileName;
+    QFutureWatcher<void> m_saveWatcher;
 };
-
-#endif // GALLERY_PHOTO_METADATA_H_
+}
+#endif // PHOTO_METADATA_H

=== renamed file 'tests/unittests/assets/croptest.png' => 'tests/unittests/assets/savetest.png'
=== modified file 'tests/unittests/sampledata.qrc'
--- tests/unittests/sampledata.qrc	2014-12-03 12:33:01 +0000
+++ tests/unittests/sampledata.qrc	2015-06-12 13:08:47 +0000
@@ -5,6 +5,6 @@
         <file>assets/windmill_rotated_90.jpg</file>
         <file>assets/windmill.jpg</file>
         <file>assets/thorns.jpg</file>
-        <file>assets/croptest.png</file>
+        <file>assets/savetest.png</file>
     </qresource>
 </RCC>

=== modified file 'tests/unittests/tst_PhotoEditorPhoto.cpp'
--- tests/unittests/tst_PhotoEditorPhoto.cpp	2014-12-03 12:50:39 +0000
+++ tests/unittests/tst_PhotoEditorPhoto.cpp	2015-06-12 13:08:47 +0000
@@ -14,8 +14,6 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-#include "photo-data.h"
-
 #include <QColor>
 #include <QDebug>
 #include <QDir>
@@ -23,6 +21,9 @@
 #include <QSignalSpy>
 #include <QTemporaryDir>
 #include <QTest>
+#include "photo-metadata.h"
+
+using namespace PhotoEditor;
 
 class PhotoEditorPhotoTest: public QObject
 {
@@ -32,9 +33,8 @@
 
     void testBasicProperties();
     void testOrientation();
-    void testRefresh();
-    void testRotate();
-    void testCrop();
+    void testSaveImage();
+    void testSetOrientationAndSave();
 
     void cleanupTestCase();
 
@@ -65,13 +65,11 @@
     QDir source = QDir(m_workingDir.path());
     QString path = source.absoluteFilePath("windmill.jpg");
 
-    PhotoData photo;
-    photo.setPath(path);
-    QVERIFY(photo.path() == path);
-    QVERIFY(photo.file() == QFileInfo(path));
-    QVERIFY(photo.fileFormat() == "jpeg");
-    QVERIFY(photo.fileFormatHasMetadata() == true);
-    QVERIFY(photo.fileFormatHasOrientation() == true);
+    PhotoMetadata photo;
+    photo.setFileName(path);
+    QVERIFY(photo.fileName() == path);
+    QVERIFY(photo.orientation() == TOP_LEFT_ORIGIN);
+    QVERIFY(photo.saving() == false);
 }
 
 void PhotoEditorPhotoTest::testOrientation()
@@ -79,163 +77,68 @@
     QDir source = QDir(m_workingDir.path());
     QString path = source.absoluteFilePath("windmill.jpg");
 
-    PhotoData photo;
-    photo.setPath(path);
+    PhotoMetadata photo;
+    photo.setFileName(path);
     QVERIFY(photo.orientation() == TOP_LEFT_ORIGIN);
 
-    PhotoData photo2;
+    PhotoMetadata photo2;
     QString path2 = source.absoluteFilePath("windmill_rotated_90.jpg");
-    photo2.setPath(path2);
+    photo2.setFileName(path2);
     QVERIFY(photo2.orientation() == RIGHT_TOP_ORIGIN);
 
-    // Test updating the original PhotoData by changing path
-    photo.setPath(path2);
+    // Test updating the original PhotoMetadata by changing path
+    photo.setFileName(path2);
     QVERIFY(photo.orientation() == RIGHT_TOP_ORIGIN);
 }
 
-void PhotoEditorPhotoTest::testRefresh()
+void PhotoEditorPhotoTest::testSaveImage()
 {
     // Work on a copy to avoid disturbing other tests
     QDir source = QDir(m_workingDir.path());
-    QString path = source.absoluteFilePath("testrefresh.jpg");
-    qDebug() << QFile::copy(source.absoluteFilePath("windmill.jpg"), path);
+    QString path = source.absoluteFilePath("savetestcopy.png");
+    QFile::remove(path);
+    QFile::copy(source.absoluteFilePath("savetest.png"), path);
 
     // Load the file.
-    PhotoData photo;
-    photo.setPath(path);
-    Orientation orientation = photo.orientation();
-
-    // Now overwrite it with another file with different rotation and verify
-    // the new data is correct
-    QFile::remove(path);
-    QFile::copy(source.absoluteFilePath("windmill_rotated_90.jpg"), path);
-
-    photo.refreshFromDisk();
-    QVERIFY(orientation != photo.orientation());
+    PhotoMetadata photo;
+    photo.setFileName(path);
+
+    // Now overwrite it with another QImage and verify the new data is correct
+    QImage otherImage(source.absoluteFilePath("windmill.jpg"));
+
+    QVERIFY(photo.saving() == false);
+    photo.saveImage(otherImage);
+    QVERIFY(photo.saving() == true);
+    QTRY_VERIFY(photo.saving() == false);
+
+    QImage result(path);
+    QCOMPARE(result, otherImage);
 }
 
-void PhotoEditorPhotoTest::testRotate()
+void PhotoEditorPhotoTest::testSetOrientationAndSave()
 {
     // Work on a copy to avoid disturbing other tests
     QDir source = QDir(m_workingDir.path());
-    QString path = source.absoluteFilePath("testrotate.jpg");
+    QString path = source.absoluteFilePath("windmillcopy.jpg");
     QFile::remove(path);
     QFile::copy(source.absoluteFilePath("windmill.jpg"), path);
 
-    PhotoData photo;
-    photo.setPath(path);
-    QVERIFY(photo.path() == path);
+    PhotoMetadata photo;
+    photo.setFileName(path);
     QVERIFY(photo.orientation() == TOP_LEFT_ORIGIN);
 
-    QSignalSpy spy(&photo, SIGNAL(busyChanged()));
-    photo.rotateRight();
-    spy.wait(5000);
-
+    photo.setOrientation(RIGHT_TOP_ORIGIN);
     QVERIFY(photo.orientation() == RIGHT_TOP_ORIGIN);
 
-    spy.clear();
-    photo.rotateRight();
-    spy.wait(5000);
-
-    QVERIFY(photo.orientation() == BOTTOM_RIGHT_ORIGIN);
-
-    spy.clear();
-    photo.rotateRight();
-    spy.wait(5000);
-
-    QVERIFY(photo.orientation() == LEFT_BOTTOM_ORIGIN);
-
-    spy.clear();
-    photo.rotateRight();
-    spy.wait(5000);
-
-    QVERIFY(photo.orientation() == TOP_LEFT_ORIGIN);
-}
-
-void PhotoEditorPhotoTest::testCrop()
-{
-    QDir source = QDir(m_workingDir.path());
-    QString path = source.absoluteFilePath("tmp.png");
-
-    QFile::remove(path);
-    QFile::copy(source.absoluteFilePath("croptest.png"), path);
-    PhotoData photo;
-    photo.setPath(path);
-
-    // Verify cropping a vertical strip at the left edge
-    QSignalSpy spy(&photo, SIGNAL(busyChanged()));
-    photo.crop(QRectF(0, 0, 0.1, 1.0));
-    spy.wait(5000);
-
-    QImage cropped(path);
-    QImage compare(QSize(10, 100), cropped.format());
-    compare.fill(QColor(0, 0, 0));
-    QVERIFY(compare == cropped);
-
-    // Verify cropping a square from the center
-    QFile::remove(path);
-    QFile::copy(source.absoluteFilePath("croptest.png"), path);
-    photo.setPath(path);
-
-    spy.clear();
-    photo.crop(QRectF(0.4, 0.4, 0.2, 0.2));
-    spy.wait(5000);
-
-    cropped = QImage(path);
-    compare = QImage(QSize(20, 20), cropped.format());
-    compare.fill(QColor(0, 255, 0));
-    QVERIFY(compare == cropped);
-
-    // Verify cropping a thin strip from the top after rotating the image.
-    // Incidentally this also tests rotation of an image without EXIF tags
-    QFile::remove(path);
-    QFile::copy(source.absoluteFilePath("croptest.png"), path);
-    photo.setPath(path);
-
-    spy.clear();
-    photo.rotateRight();
-    spy.wait(5000);
-
-    spy.clear();
-    photo.crop(QRectF(0.0, 0.0, 1.0, 0.1));
-    spy.wait(5000);
-
-    cropped = QImage(path);
-    compare = QImage(QSize(100, 10), cropped.format());
-    compare.fill(QColor(0, 0, 0));
-    QVERIFY(compare == cropped);
-
-    // When rotating an image without EXIF, the orientation is fixed
-    QVERIFY(photo.orientation() == TOP_LEFT_ORIGIN);
-
-    // Test progressive cropping by carving off the bottom horizontal strip and
-    // then cropping the center part of it
-    QFile::remove(path);
-    QFile::copy(source.absoluteFilePath("croptest.png"), path);
-    photo.setPath(path);
-
-    spy.clear();
-    photo.crop(QRectF(0.0, 0.9, 1.0, 0.1));
-    spy.wait(5000);
-    spy.clear();
-    photo.crop(QRectF(0.1, 0.0, 0.8, 1.0));
-    spy.wait(5000);
-
-    cropped = QImage(path);
-    compare = QImage(QSize(80, 10), cropped.format());
-    compare.fill(QColor(0, 0, 255));
-    QVERIFY(compare == cropped);
-
-    // Test a cropping rectangle outside of boundaries
-    QFile::remove(path);
-    QFile::copy(source.absoluteFilePath("croptest.png"), path);
-    photo.setPath(path);
-
-    spy.clear();
-    photo.crop(QRectF(-1.0, -100.0, 2405.0, 2.0));
-    spy.wait(5000);
-    cropped = QImage(path);
-    QVERIFY(cropped.size() == QSize(100, 100));
+    QVERIFY(photo.saving() == false);
+    photo.save();
+    QVERIFY(photo.saving() == true);
+    QTRY_VERIFY(photo.saving() == false);
+
+    // Reread the metadata and check the orientation
+    PhotoMetadata otherPhoto;
+    otherPhoto.setFileName(path);
+    QVERIFY(otherPhoto.orientation() == RIGHT_TOP_ORIGIN);
 }