Merge lp:~artmello/gallery-app/gallery-app-remove_image_provider into lp:gallery-app

[Arthur Mello]

Remove photo-image-provider to use the one provided by ubunut-ui-extras
Move photo-metadata from photoeditor to photo folder

Remove photo-image-provider to use the one provided by ubunut-ui-extras
Move photo-metadata from photoeditor to photo folder

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:1263
http://jenkins.qa.ubuntu.com/job/gallery-app-ci/1224/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/gallery-app-vivid-amd64-ci/152
    SUCCESS: http://jenkins.qa.ubuntu.com/job/gallery-app-vivid-armhf-ci/152
        deb: http://jenkins.qa.ubuntu.com/job/gallery-app-vivid-armhf-ci/152/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/gallery-app-vivid-i386-ci/152
    UNSTABLE: http://jenkins.qa.ubuntu.com/job/generic-click-autopilot-vivid-touch/367
    UNSTABLE: http://jenkins.qa.ubuntu.com/job/generic-click-autopilot-runner-touch/1038
    SUCCESS: http://jenkins.qa.ubuntu.com/job/generic-click-builder-vivid-armhf/907
    SUCCESS: http://s-jenkins.ubuntu-ci:8080/job/touch-flash-device/26678

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/gallery-app-ci/1224/rebuild

review: Needs Fixing (continuous-integration)

[Florian Boucault (fboucault)]

Pretty good. Too bad to realise there is still some code duplication (PhotoMetadata). In fact there is a delta between the version in gallery and the one in ui-extras. Can you fix it here? Here is the diff:

http://pastebin.ubuntu.com/14503418/

review: Needs Fixing

[lp:~artmello/gallery-app/gallery-app-remove_image_provider]

1264. By Arthur Mello on 2016-01-15

Reduce delta between photo metadata in gallery and in ui-extras

[Arthur Mello (artmello)]

I tried to reduce the delta between both versions of photo-metadata. But I don't think we can change the order of exposure time keys on gallery version of it. It is desired that when you import some photo into gallery it shows up in today's event, so when some new file arrives we save the date at Exif.Photo.DateTimeDigitized. When we are reading exposure time we should check this field first, otherwise we could use another date for ordering.

=== modified file 'rc/qml/MediaViewer/SingleMediaViewer.qml'
--- rc/qml/MediaViewer/SingleMediaViewer.qml	2015-11-05 19:04:22 +0000
+++ rc/qml/MediaViewer/SingleMediaViewer.qml	2016-01-15 12:56:08 +0000
@@ -21,6 +21,7 @@
 import Ubuntu.Components.Popups 1.3
 import Ubuntu.Content 1.3
 import Ubuntu.Thumbnailer 0.1
+import Ubuntu.Components.Extras 0.2
 import Gallery 1.0
 import "../Components"
 

=== modified file 'src/CMakeLists.txt'
--- src/CMakeLists.txt	2015-02-27 14:07:07 +0000
+++ src/CMakeLists.txt	2016-01-15 12:56:08 +0000
@@ -6,7 +6,6 @@
 add_subdirectory(database)
 add_subdirectory(event)
 add_subdirectory(media)
-add_subdirectory(photoeditor)
 add_subdirectory(medialoader)
 add_subdirectory(photo)
 add_subdirectory(qml)
@@ -27,7 +26,6 @@
     ${gallery_event_src_SOURCE_DIR}
     ${gallery_album_src_SOURCE_DIR}
     ${gallery_photo_src_SOURCE_DIR}
-    ${gallery_photoeditor_src_SOURCE_DIR}
     ${gallery_video_src_SOURCE_DIR}
     ${gallery_qml_src_SOURCE_DIR}
     ${CMAKE_BINARY_DIR}
@@ -62,7 +60,6 @@
     gallery-media
     gallery-medialoader
     gallery-photo
-    gallery-photoeditor
     gallery-qml
     gallery-util
     gallery-video

=== modified file 'src/gallery-application.cpp'
--- src/gallery-application.cpp	2015-12-16 12:49:12 +0000
+++ src/gallery-application.cpp	2016-01-15 12:56:08 +0000
@@ -36,9 +36,6 @@
 // photo
 #include "photo.h"
 
-// photoeditor
-#include "photo-image-provider.h"
-
 // qml
 #include "qml-album-collection-model.h"
 #include "qml-event-collection-model.h"
@@ -219,11 +216,6 @@
 {
     m_view->setTitle("Gallery");
 
-    PhotoImageProvider* provider = new PhotoImageProvider();
-    provider->setLogging(true);
-    m_view->engine()->addImageProvider(PhotoImageProvider::PROVIDER_ID,
-                             provider);
-
     QSize size = m_formFactors[m_cmdLineParser->formFactor()];
 
     if (m_cmdLineParser->isPortrait())

=== modified file 'src/photo/CMakeLists.txt'
--- src/photo/CMakeLists.txt	2015-02-27 13:17:00 +0000
+++ src/photo/CMakeLists.txt	2016-01-15 12:56:08 +0000
@@ -8,22 +8,27 @@
     ${gallery_database_src_SOURCE_DIR}
     ${gallery_media_src_SOURCE_DIR}
     ${gallery_medialoader_src_SOURCE_DIR}
-    ${gallery_photoeditor_src_SOURCE_DIR}
     ${gallery_util_src_SOURCE_DIR}
+    ${EXIV2_INCLUDEDIR}
     ${CMAKE_BINARY_DIR}
     )
 
 set(gallery_photo_HDRS
     photo.h
+    photo-metadata.h
     )
 
 set(gallery_photo_SRCS
     photo.cpp
+    photo-metadata.cpp
     )
 
 add_library(${GALLERY_PHOTO_LIB}
     ${gallery_photo_SRCS}
     )
 
-qt5_use_modules(${GALLERY_PHOTO_LIB} Widgets Core Quick)
+qt5_use_modules(${GALLERY_PHOTO_LIB} Widgets Core Qml Quick Xml)
 
+target_link_libraries( ${GALLERY_PHOTO_LIB}
+    ${EXIV2_LIBRARIES}
+    )

=== renamed file 'src/photoeditor/photo-metadata.cpp' => 'src/photo/photo-metadata.cpp'
--- src/photoeditor/photo-metadata.cpp	2015-05-06 20:15:54 +0000
+++ src/photo/photo-metadata.cpp	2016-01-15 12:56:08 +0000
@@ -219,7 +219,7 @@
 {
     Exiv2::ExifData& exif_data = m_image->exifData();
 
-    exif_data[EXIF_ORIENTATION_KEY] = orientation;
+    exif_data[EXIF_ORIENTATION_KEY] = (Exiv2::UShortValue)orientation;
 
     if (!m_keysPresent.contains(EXIF_ORIENTATION_KEY))
         m_keysPresent.insert(EXIF_ORIENTATION_KEY);

=== renamed file 'src/photoeditor/photo-metadata.h' => 'src/photo/photo-metadata.h'
=== removed directory 'src/photoeditor'
=== removed file 'src/photoeditor/CMakeLists.txt'
--- src/photoeditor/CMakeLists.txt	2015-12-16 12:49:12 +0000
+++ src/photoeditor/CMakeLists.txt	1970-01-01 00:00:00 +0000
@@ -1,34 +0,0 @@
-project(gallery_photoeditor_src)
-
-set(GALLERY_PHOTOEDITOR_LIB gallery-photoeditor)
-
-include_directories(
-    ${gallery_src_SOURCE_DIR}
-    ${gallery_core_src_SOURCE_DIR}
-    ${gallery_database_src_SOURCE_DIR}
-    ${gallery_media_src_SOURCE_DIR}
-    ${gallery_medialoader_src_SOURCE_DIR}
-    ${gallery_util_src_SOURCE_DIR}
-    ${EXIV2_INCLUDEDIR}
-    ${CMAKE_BINARY_DIR}
-    )
-
-set(gallery_photoeditor_HDRS
-    photo-image-provider.h
-    photo-metadata.h
-    )
-
-set(gallery_photoeditor_SRCS
-    photo-image-provider.cpp
-    photo-metadata.cpp
-    )
-
-add_library(${GALLERY_PHOTOEDITOR_LIB}
-    ${gallery_photoeditor_SRCS}
-    )
-
-qt5_use_modules(${GALLERY_PHOTOEDITOR_LIB} Core Qml Quick Xml Widgets)
-
-target_link_libraries( ${GALLERY_PHOTOEDITOR_LIB}
-    ${EXIV2_LIBRARIES}
-    )

=== removed file 'src/photoeditor/photo-image-provider.cpp'
--- src/photoeditor/photo-image-provider.cpp	2015-11-23 17:42:29 +0000
+++ src/photoeditor/photo-image-provider.cpp	1970-01-01 00:00:00 +0000
@@ -1,443 +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:
- * Lucas Beeler <[e-mail]>
- * Jim Nelson <[e-mail]>
- * Ugo Riboni <[e-mail]>
- */
-
-#include "photo-image-provider.h"
-#include "photo-metadata.h"
-
-#include <QDebug>
-#include <QElapsedTimer>
-#include <QImageReader>
-#include <QSize>
-#include <QUrlQuery>
-
-const char* PhotoImageProvider::PROVIDER_ID = "photo";
-const char* PhotoImageProvider::PROVIDER_ID_SCHEME = "image://photo/";
-
-const long MAX_CACHE_BYTES = 20L * 1024L * 1024L;
-
-/*!
- * \brief PhotoImageProvider::PhotoImageProvider
- */
-PhotoImageProvider::PhotoImageProvider()
-    : QQuickImageProvider(QQuickImageProvider::Image),
-      m_cachedBytes(0),
-      m_logImageLoading(false),
-      m_emitCacheSignals(false)
-{
-}
-
-/*!
- * \brief PhotoImageProvider::~PhotoImageProvider
- */
-PhotoImageProvider::~PhotoImageProvider()
-{
-    // NOTE: This assumes that we are not receiving requests any longer
-    while (!m_cachingOrder.isEmpty())
-        delete m_cache.value(m_cachingOrder.takeFirst());
-}
-
-#define LOG_IMAGE_STATUS(status) { \
-    if (m_logImageLoading) \
-    loggingStr += status; \
-    }
-
-/*!
- * \brief PhotoImageProvider::requestImage
- * \param id
- * \param size
- * \param requestedSize
- * \return
- */
-QImage PhotoImageProvider::requestImage(const QString& id,
-                                                  QSize* size, const QSize& requestedSize)
-{
-    // for LOG_IMAGE_STATUS
-    QString loggingStr = "";
-    QElapsedTimer timer;
-    if (m_logImageLoading) timer.start();
-
-    QUrl url(id);
-
-    QImage readyImage;
-    uint bytesLoaded = 0;
-
-    CachedImage* cachedImage = claimCachedImageEntry(id, loggingStr);
-    Q_ASSERT(cachedImage != NULL);
-
-    readyImage = fetchCachedImage(cachedImage, requestedSize, &bytesLoaded,
-                                  loggingStr);
-    if (readyImage.isNull())
-        LOG_IMAGE_STATUS("load-failure ");
-
-    releaseCachedImageEntry(cachedImage, bytesLoaded);
-
-    if (m_logImageLoading) {
-        if (bytesLoaded > 0) {
-            qDebug("%s %s req:%dx%d ret:%dx%d cache:%ldb/%d loaded:%db time:%lldms", qPrintable(loggingStr),
-                   qPrintable(id), requestedSize.width(), requestedSize.height(), readyImage.width(),
-                   readyImage.height(), m_cachedBytes, m_cache.size(), bytesLoaded,
-                   timer.elapsed());
-        } else {
-            qDebug("%s %s req:%dx%d ret:%dx%d cache:%ldb/%d time:%lldms", qPrintable(loggingStr),
-                   qPrintable(id), requestedSize.width(), requestedSize.height(), readyImage.width(),
-                   readyImage.height(), m_cachedBytes, m_cache.size(), timer.elapsed());
-        }
-    }
-
-    if (size != NULL)
-        *size = readyImage.size();
-
-    return readyImage;
-}
-
-/*!
- * \brief PhotoImageProvider::setLogging enables to print photo loading
- * times to stout
- * \param enableLogging
- */
-void PhotoImageProvider::setLogging(bool enableLogging)
-{
-    m_logImageLoading = enableLogging;
-}
-
-/*!
- * \brief PhotoImageProvider::setEmitCacheSignals enabled emitting signals to
- * track the status of the internal cache.
- * \param emitCacheSignals
- */
-void PhotoImageProvider::setEmitCacheSignals(bool emitCacheSignals)
-{
-    m_emitCacheSignals = emitCacheSignals;
-}
-
-/*!
- * \brief PhotoImageProvider::claim_cached_image_entry
- * Returns a CachedImage with an inUseCount > 0, meaning it cannot be
- * removed from the cache until released
- * \param id
- * \param loggingStr
- * \return
- */
-PhotoImageProvider::CachedImage* PhotoImageProvider::claimCachedImageEntry(
-        const QString& id, QString& loggingStr)
-{
-    // lock the cache table and retrieve the element for the cached image; if
-    // not found, create one as a placeholder
-    m_cacheMutex.lock();
-
-    CachedImage* cachedImage = m_cache.value(id, NULL);
-    if (cachedImage != NULL) {
-        // remove CachedImage before prepending to FIFO
-        m_cachingOrder.removeOne(id);
-    } else {
-        cachedImage = new CachedImage(id);
-        m_cache.insert(id, cachedImage);
-        LOG_IMAGE_STATUS("new-cache-entry ");
-    }
-
-    // add to front of FIFO
-    m_cachingOrder.prepend(id);
-
-    // should be the same size, always
-    Q_ASSERT(m_cache.size() == m_cachingOrder.size());
-
-    // claim the CachedImage *while cacheMutex_ is locked* ... this prevents the
-    // CachedImage from being removed from the cache while its being filled
-    cachedImage->cleanCount++;
-
-    m_cacheMutex.unlock();
-
-    return cachedImage;
-}
-
-/*!
- * \brief PhotoImageProvider::fetch_cached_image Inspects and loads a proper image
- * Inspects and loads a proper image for this request into the CachedImage
- * \param cachedImage
- * \param requestedSize
- * \param bytesLoaded
- * \param loggingStr
- * \return
- */
-QImage PhotoImageProvider::fetchCachedImage(CachedImage *cachedImage,
-                                            const QSize& requestedSize,
-                                            uint* bytesLoaded,
-                                            QString& loggingStr)
-{
-    Q_ASSERT(cachedImage != NULL);
-
-    QString file = QUrl(cachedImage->id).path();
-
-    // the final image returned to the user
-    QImage readyImage;
-    Q_ASSERT(readyImage.isNull());
-
-    // lock the cached image itself to access
-    cachedImage->imageMutex.lock();
-
-    // Depending on the file system used the last modified date of a file
-    // might have a really low resolution (2s for FAT32, 1s for ext3). Therefore
-    // we have to take the worse case and accept that there will be additional cache
-    // misses when an image is requested again just after it has been cached.
-    // There is no alternative to this other than accepting false cache hits, which
-    // would result in bugs in the application.
-    QFileInfo photoFile(file);
-    QDateTime fileLastModified = photoFile.lastModified();
-    fileLastModified = fileLastModified.addSecs(2);
-
-    // if image is available, see if a fit
-    if (cachedImage->isCacheHit(requestedSize)) {
-        if (cachedImage->cachedAt > fileLastModified) {
-            readyImage = cachedImage->image;
-            LOG_IMAGE_STATUS("cache-hit ");
-            if (m_emitCacheSignals) Q_EMIT cacheHit(cachedImage->id, requestedSize);
-        } else {
-            // if the file was modified after the image was cached, reload it
-            LOG_IMAGE_STATUS("cache-stale ");
-            if (m_emitCacheSignals) cacheMiss(cachedImage->id, requestedSize, true);
-        }
-    } else {
-        LOG_IMAGE_STATUS("cache-miss ");
-        if (m_emitCacheSignals) cacheMiss(cachedImage->id, requestedSize, false);
-    }
-
-    if (bytesLoaded != NULL)
-        *bytesLoaded = 0;
-
-    // if unavailable or stale, load now
-    if (readyImage.isNull()) {
-        QImageReader reader(file);
-
-        // load file's original size
-        QSize fullSize = reader.size();
-        QSize loadSize(fullSize);
-
-        // use scaled load-and-decode if size has been requested
-        if (fullSize.isValid() && (requestedSize.width() > 0 || requestedSize.height() > 0)) {
-            loadSize.scale(requestedSize, Qt::KeepAspectRatio);
-            if (loadSize.width() > fullSize.width() || loadSize.height() > fullSize.height())
-                loadSize = fullSize;
-        }
-
-        if (loadSize != fullSize) {
-            LOG_IMAGE_STATUS("scaled-load ");
-
-            // configure reader for scaled load-and-decode
-            reader.setScaledSize(loadSize);
-        } else {
-            LOG_IMAGE_STATUS("full-load ");
-        }
-
-        readyImage = reader.read();
-        if (!readyImage.isNull()) {
-            if (!fullSize.isValid())
-                fullSize = readyImage.size();
-
-            Orientation orientation = TOP_LEFT_ORIGIN;
-            std::unique_ptr<PhotoMetadata> metadata(PhotoMetadata::fromFile(file));
-            if (metadata.get() != NULL)
-                orientation = metadata->orientation();
-
-            // rotate image if not TOP LEFT
-            if (orientation != TOP_LEFT_ORIGIN)  {
-                readyImage = readyImage.transformed(
-                            OrientationCorrection::fromOrientation(orientation).toTransform());
-            }
-
-            // If we are reloading an image, the cache total byte count will be the
-            // difference in size between the old image and the new one (could be negative, for
-            // example in cases of cropping).
-            // If we are not reloading, then the current count will be zero and the total byte
-            // count will be the full size of the newly loaded image.
-            int currentByteCount = readyImage.byteCount();
-
-            cachedImage->storeImage(readyImage, fullSize, orientation);
-            if (m_emitCacheSignals) Q_EMIT cacheAdd(cachedImage->id, requestedSize, loadSize);
-
-            if (bytesLoaded != NULL)
-                *bytesLoaded = readyImage.byteCount() - currentByteCount;
-        } else {
-            qDebug("Unable to load %s: %s", qPrintable(cachedImage->id),
-                   qPrintable(reader.errorString()));
-        }
-    } else {
-        // if the image comes from the cache and the requested size is smaller
-        // than what we cached, scale the image before returning it
-        if (requestedSize.isValid()) {
-            readyImage = readyImage.scaled(requestedSize, Qt::KeepAspectRatio);
-        }
-    }
-
-    cachedImage->imageMutex.unlock();
-
-    return readyImage;
-}
-
-/*!
- * \brief PhotoImageProvider::release_cached_image_entry
- * Releases a CachedImage to the cache; takes its bytes loaded (0 if nothing
- * was loaded) and returns the current cached byte total
- * \param cachedImage
- * \param bytesLoaded
- * \param currentCacheEntries
- */
-void PhotoImageProvider::releaseCachedImageEntry
-(CachedImage *cachedImage, uint bytesLoaded)
-{
-    Q_ASSERT(cachedImage != NULL);
-
-    // update total cached bytes and remove excess bytes
-    m_cacheMutex.lock();
-
-    m_cachedBytes += bytesLoaded;
-
-    // update the CachedImage use count and byte count inside of *cachedMutex_ lock*
-    Q_ASSERT(cachedImage->cleanCount > 0);
-    cachedImage->cleanCount--;
-    if (bytesLoaded != 0)
-        cachedImage->byteCount = bytesLoaded;
-
-    // trim the cache
-    QList<CachedImage*> dropList;
-    while (m_cachedBytes > MAX_CACHE_BYTES && !m_cachingOrder.isEmpty()) {
-        QString droppedFile = m_cachingOrder.takeLast();
-
-        CachedImage* droppedCachedImage = m_cache.value(droppedFile);
-        Q_ASSERT(droppedCachedImage != NULL);
-
-        // for simplicity, stop when dropped item is in use or doesn't contain
-        // an image (which it won't for too long) ... will clean up next time
-        // through
-        if (droppedCachedImage->cleanCount > 0) {
-            m_cachingOrder.append(droppedFile);
-
-            break;
-        }
-
-        // remove from map
-        m_cache.remove(droppedFile);
-
-        // decrement total cached size
-        m_cachedBytes -= droppedCachedImage->byteCount;
-        Q_ASSERT(m_cachedBytes >= 0);
-
-        dropList.append(droppedCachedImage);
-    }
-
-    // coherency is good
-    Q_ASSERT(m_cache.size() == m_cachingOrder.size());
-
-    m_cacheMutex.unlock();
-
-    // perform actual deletion outside of lock
-    while (!dropList.isEmpty())
-        delete dropList.takeFirst();
-}
-
-/*!
- * \brief PhotoImageProvider::orientSize
- * \param size
- * \param orientation
- * \return
- */
-QSize PhotoImageProvider::orientSize(const QSize& size, Orientation orientation)
-{
-    switch (orientation) {
-    case LEFT_TOP_ORIGIN:
-    case RIGHT_TOP_ORIGIN:
-    case RIGHT_BOTTOM_ORIGIN:
-    case LEFT_BOTTOM_ORIGIN:
-        return QSize(size.height(), size.width());
-        break;
-
-    default:
-        // no change
-        return size;
-    }
-}
-
-/*!
- * \brief PhotoImageProvider::CachedImage::CachedImage
- * \param id the full URI of the image
- * \param fileName the filename for the URI (the file itself)
- */
-PhotoImageProvider::CachedImage::CachedImage(const QString& id)
-    : id(id), orientation(TOP_LEFT_ORIGIN), cleanCount(0), byteCount(0)
-{
-}
-
-/*!
- * \brief PhotoImageProvider::CachedImage::storeImage
- * Importand: the following should only be called when imageMutex_ is locked
- * \param image
- * \param fullSize
- * \param orientation
- */
-void PhotoImageProvider::CachedImage::storeImage(const QImage& newImage,
-                                                           const QSize& newFullSize,
-                                                           Orientation newOrientation)
-{
-    image = newImage;
-    fullSize = orientSize(newFullSize, orientation);
-    orientation = newOrientation;
-    cachedAt = QDateTime::currentDateTime();
-}
-
-/*!
- * \brief PhotoImageProvider::CachedImage::isReady
- * \return
- */
-bool PhotoImageProvider::CachedImage::isReady() const
-{
-    return !image.isNull();
-}
-
-/*!
- * \brief PhotoImageProvider::CachedImage::isFullSized
- * \return
- */
-bool PhotoImageProvider::CachedImage::isFullSized() const
-{
-    return isReady() && (image.size() == fullSize);
-}
-
-/*!
- * \brief PhotoImageProvider::CachedImage::isCacheHit
- * \param requestedSize
- * \return
- */
-bool PhotoImageProvider::CachedImage::isCacheHit(const QSize& requestedSize) const
-{
-    if (!isReady())
-        return false;
-
-    if (isFullSized())
-        return true;
-
-    QSize properRequestedSize = orientSize(requestedSize, orientation);
-
-    if ((properRequestedSize.width() != 0 && image.width() >= properRequestedSize.width())
-            || (properRequestedSize.height() != 0 && image.height() >= properRequestedSize.height())) {
-        return true;
-    }
-
-    return false;
-}

=== removed file 'src/photoeditor/photo-image-provider.h'
--- src/photoeditor/photo-image-provider.h	2015-02-26 20:28:06 +0000
+++ src/photoeditor/photo-image-provider.h	1970-01-01 00:00:00 +0000
@@ -1,124 +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:
- * Lucas Beeler <[e-mail]>
- * Jim Nelson <[e-mail]>
- * Ugo Riboni <[e-mail]>
-*/
-
-#ifndef PHOTO_IMAGE_PROVIDER_H_
-#define PHOTO_IMAGE_PROVIDER_H_
-
-// util
-#include "orientation.h"
-
-#include <QDateTime>
-#include <QFileInfo>
-#include <QImage>
-#include <QMap>
-#include <QMutex>
-#include <QObject>
-#include <QQuickImageProvider>
-#include <QSize>
-#include <QString>
-#include <QUrl>
-
-/*!
- * We use a custom image provider for the following reasons:
- *
- * 1. QML's image loader does not respect EXIF orientation.  This provider will
- *    rotate and mirror the image as necessary.
- *
- * 2. QML's image caching appears to be directly related to image size (scaling)
- *    which leads to thrashing when animating a thumbnail or loading images at
- *    various sizes.
- *    The strategy here is to cache the largest requested size of the image
- *    and downscale it if smaller versions are requested. This minimizes
- *    expensive JPEG load-and-decodes.
- *
- * 3. Logging allows for monitoring of all image I/O, useful when debugging and
- *    optimizing, and signals can be emitted to monitor and test cache operation.
- *
- * 4. The QML cache does not check if a file has been modified on disk after it
- *    was cached, but our cache does. You should always set Image.cache to false
- *    when loading images from this provider in QML.
- */
-class PhotoImageProvider : public QObject, public QQuickImageProvider
-{
-    Q_OBJECT
-
-public:
-    static const char* PROVIDER_ID;
-    static const char* PROVIDER_ID_SCHEME;
-
-    PhotoImageProvider();
-    virtual ~PhotoImageProvider();
-
-    virtual QImage requestImage(const QString& id, QSize* size,
-                                const QSize& requestedSize);
-
-    void setLogging(bool enableLogging);
-    void setEmitCacheSignals(bool emitCacheSignals);
-
-Q_SIGNALS:
-    void cacheHit(QString id, QSize size);
-    void cacheMiss(QString id, QSize size, bool wasStale);
-    void cacheAdd(QString id, QSize size, QSize cachedSize);
-
-private:
-    class CachedImage {
-    public:
-        const QString id;
-        QMutex imageMutex;
-
-        // these fields should only be accessed when imageMutex_ is locked
-        QImage image;
-        QSize fullSize;
-        Orientation orientation;
-        QDateTime cachedAt;
-
-        // the following should only be accessed when cacheMutex_ is locked; the
-        // counter controls removing a CachedImage entry from the cache table
-        int cleanCount;
-        uint byteCount;
-
-        CachedImage(const QString& id);
-
-        void storeImage(const QImage& newImage, const QSize& newFullSize,
-                        Orientation newOrientation);
-        bool isFullSized() const;
-        bool isReady() const;
-        bool isCacheHit(const QSize& requestedSize) const;
-    };
-
-    QMap<QString, CachedImage*> m_cache;
-    QList<QString> m_cachingOrder;
-    QMutex m_cacheMutex;
-    long m_cachedBytes;
-    bool m_logImageLoading;
-    bool m_emitCacheSignals;
-
-    static QSize orientSize(const QSize& size, Orientation orientation);
-
-    CachedImage* claimCachedImageEntry(const QString& id, QString& loggingStr);
-
-    QImage fetchCachedImage(CachedImage* cachedImage, const QSize& requestedSize,
-                              uint* bytesLoaded, QString& loggingStr);
-
-    void releaseCachedImageEntry(CachedImage* cachedImage, uint bytesLoaded);
-};
-
-#endif // PHOTO_IMAGE_PROVIDER_H_

=== modified file 'tests/unittests/mediaobjectfactory/CMakeLists.txt'
--- tests/unittests/mediaobjectfactory/CMakeLists.txt	2015-08-19 19:24:21 +0000
+++ tests/unittests/mediaobjectfactory/CMakeLists.txt	2016-01-15 12:56:08 +0000
@@ -14,14 +14,13 @@
     ${gallery_media_src_SOURCE_DIR}
     ${gallery_medialoader_src_SOURCE_DIR}
     ${gallery_photo_src_SOURCE_DIR}
-    ${gallery_photoeditor_src_SOURCE_DIR}
     ${gallery_util_src_SOURCE_DIR}
     ${gallery_video_src_SOURCE_DIR}
     )
 
 QT5_WRAP_CPP(MEDIAOBJECTFACTORY_MOCS
     ${gallery_database_src_SOURCE_DIR}/media-table.h
-    ${gallery_photoeditor_src_SOURCE_DIR}/photo-metadata.h
+    ${gallery_photo_src_SOURCE_DIR}/photo-metadata.h
     ${gallery_medialoader_src_SOURCE_DIR}/video-metadata.h
     )
 

=== modified file 'tests/unittests/photo-metadata/CMakeLists.txt'
--- tests/unittests/photo-metadata/CMakeLists.txt	2015-05-08 17:05:20 +0000
+++ tests/unittests/photo-metadata/CMakeLists.txt	2016-01-15 12:56:08 +0000
@@ -13,7 +13,6 @@
     ${gallery_media_src_SOURCE_DIR}
     ${gallery_medialoader_src_SOURCE_DIR}
     ${gallery_photo_src_SOURCE_DIR}
-    ${gallery_photoeditor_src_SOURCE_DIR}
     ${gallery_util_src_SOURCE_DIR}
     ${gallery_video_src_SOURCE_DIR}
     ${EXIV2_INCLUDEDIR}
@@ -32,7 +31,7 @@
 add_definitions(-DSAMPLE_IMAGE_DIR="${CMAKE_CURRENT_SOURCE_DIR}/images")
 add_executable(photo-metadata
     tst_photo-metadata.cpp
-    ${gallery_photoeditor_src_SOURCE_DIR}/photo-metadata.cpp
+    ${gallery_photo_src_SOURCE_DIR}/photo-metadata.cpp
     ../stubs/album-table_stub.cpp
     ../stubs/database_stub.cpp
     ../stubs/media-table_stub.cpp

=== modified file 'tests/unittests/photo-metadata/tst_photo-metadata.cpp'
--- tests/unittests/photo-metadata/tst_photo-metadata.cpp	2015-05-08 17:05:20 +0000
+++ tests/unittests/photo-metadata/tst_photo-metadata.cpp	2016-01-15 12:56:08 +0000
@@ -16,7 +16,7 @@
 
 #include <QtTest/QtTest>
 
-#include "photoeditor/photo-metadata.h"
+#include "photo/photo-metadata.h"
 
 class tst_PhotoMetadata : public QObject
 {

=== modified file 'tests/unittests/video/CMakeLists.txt'
--- tests/unittests/video/CMakeLists.txt	2015-02-26 20:28:06 +0000
+++ tests/unittests/video/CMakeLists.txt	2016-01-15 12:56:08 +0000
@@ -19,7 +19,6 @@
     ${gallery_media_src_SOURCE_DIR}
     ${gallery_medialoader_src_SOURCE_DIR}
     ${gallery_photo_src_SOURCE_DIR}
-    ${gallery_photoeditor_src_SOURCE_DIR}
     ${gallery_qml_src_SOURCE_DIR}
     ${gallery_util_src_SOURCE_DIR}
     ${gallery_video_src_SOURCE_DIR}
@@ -47,7 +46,6 @@
     gallery-media
     gallery-medialoader
     gallery-photo
-    gallery-photoeditor
     gallery-qml
     gallery-util
     gallery-video