albummanager.h

Go to the documentation of this file.

/* ============================================================
 *
 * This file is a part of digiKam project
 * https://www.digikam.org
 *
 * Date        : 2004-06-15
 * Description : Albums manager interface.
 *
 * Copyright (C) 2004      by Renchi Raju <renchi dot raju at gmail dot com>
 * Copyright (C) 2006-2022 by Gilles Caulier <caulier dot gilles at gmail dot com>
 * Copyright (C) 2006-2011 by Marcel Wiesweg <marcel dot wiesweg at gmx dot de>
 *
 * This program is free software; you can redistribute it
 * and/or modify it under the terms of the GNU General
 * Public License as published by the Free Software Foundation;
 * either version 2, or (at your option)
 * any later version.
 *
 * 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.
 *
 * ============================================================ */
 
#ifndef DIGIKAM_ALBUM_MANAGER_H
#define DIGIKAM_ALBUM_MANAGER_H
 
// Qt includes
 
#include <QList>
#include <QObject>
#include <QString>
#include <QMap>
#include <QUrl>
#include <QDate>
#include <QFileInfo>
 
// Local includes
 
#include "album.h"
#include "coredbalbuminfo.h"
#include "dbengineparameters.h"
#include "digikam_export.h"
#include "itemlisterrecord.h"
 
namespace Digikam
{
 
class FAlbum;
class CollectionLocation;
class AlbumChangeset;
class TagChangeset;
class SearchChangeset;
class CollectionImageChangeset;
class ImageTagChangeset;
 
class DIGIKAM_GUI_EXPORT AlbumManager : public QObject
{
    Q_OBJECT
 
public:
 
    static AlbumManager* instance();
 
    void startScan();
 
    void cleanUp();
 
    void refresh();
 
    void prepareItemCounts();
 
    bool isShowingOnlyAvailableAlbums() const;
    void setShowOnlyAvailableAlbums(bool onlyAvailable);
 
private Q_SLOTS:
 
    void slotImagesDeleted(const QList<qlonglong>& imageIds);
 
    // -----------------------------------------------------------------------------
 
 
public:
 
    bool setDatabase(const DbEngineParameters& params, bool priority,
                     const QString& suggestedAlbumRoot = QString());
 
    void changeDatabase(const DbEngineParameters& params);
 
    bool databaseEqual(const DbEngineParameters& parameters) const;
 
    void addFakeConnection();
    void removeFakeConnection();
 
    static void checkDatabaseDirsAfterFirstRun(const QString& dbPath, const QString& albumPath);
 
private:
 
    static bool moveToBackup(const QFileInfo& info);
    static bool copyToNewLocation(const QFileInfo& oldFile,
                                  const QFileInfo& newFile,
                                  const QString& otherMessage = QString());
 
 
    // -----------------------------------------------------------------------------
 
 
private:
 
    bool handleCollectionStatusChange(const CollectionLocation& location, int oldStatus);
 
    void addAlbumRoot(const CollectionLocation& location);
    void removeAlbumRoot(const CollectionLocation& location);
 
private Q_SLOTS:
 
    void slotCollectionLocationStatusChanged(const CollectionLocation&, int);
    void slotCollectionLocationPropertiesChanged(const CollectionLocation& location);
    void slotCollectionImageChange(const CollectionImageChangeset& changeset);
 
 
    // -----------------------------------------------------------------------------
 
 
public:
 
    void setCurrentAlbums(const QList<Album*>& albums);
 
    AlbumList currentAlbums()                       const;
 
    void clearCurrentAlbums();
 
    Album*    findAlbum(int gid)                    const;
 
    Album*    findAlbum(Album::Type type, int id)   const;
 
    QHash<int, QString> albumTitles()               const;
 
    bool isMovingAlbum(Album* album) const;
 
    qlonglong getItemFromAlbum(Album* const album, const QString& fileName);
 
private:
 
    bool hasDirectChildAlbumWithTitle(Album* parent, const QString& title);
    void notifyAlbumDeletion(Album* album);
    void updateAlbumPathHash();
    void addGuardedPointer(Album* a, Album** pointer);
    void removeGuardedPointer(Album* a, Album** pointer);
    void changeGuardedPointer(Album* oldAlbum, Album* a, Album** pointer);
    void invalidateGuardedPointers(Album* album);
 
private Q_SLOTS:
 
    void slotAlbumsJobResult();
    void slotAlbumsJobData(const QMap<int, int>& albumsStatMap);
    void slotAlbumChange(const AlbumChangeset& changeset);
    void getAlbumItemsCount();
 
Q_SIGNALS:
 
    void signalAlbumAboutToBeAdded(Album* album, Album* parent, Album* prev);
 
    void signalAlbumAdded(Album* album);
 
    void signalAlbumAboutToBeDeleted(Album* album);
 
    void signalAlbumDeleted(Album* album);
 
    void signalAlbumHasBeenDeleted(quintptr);
 
    void signalAlbumsCleared();
    void signalAlbumCurrentChanged(const QList<Album*>& albums);
    void signalAllAlbumsLoaded();
 
    void signalAlbumIconChanged(Album* album);
    void signalAlbumRenamed(Album* album);
    void signalAlbumNewPath(Album* album);
 
    void signalAlbumAboutToBeMoved(Album* album);
 
    void signalAlbumMoved(Album* album);
    void signalAlbumsUpdated(int type);
 
    void signalShowOnlyAvailableAlbumsChanged(bool showsOnlyAvailableAlbums);
 
 
    // -----------------------------------------------------------------------------
 
 
public:
 
    AlbumList allDAlbums()                  const;
 
    DAlbum*   findDAlbum(int id)            const;
 
    QMap<YearMonth, int> getDAlbumsCount()  const;
 
private Q_SLOTS:
 
    void slotDatesJobResult();
    void slotDatesJobData(const QHash<QDateTime, int>& datesStatMap);
 
    void scanDAlbumsScheduled();
    void scanDAlbums();
 
Q_SIGNALS:
 
    void signalDAlbumsDirty(const QMap<YearMonth, int>&);
    void signalDatesHashDirty(const QHash<QDateTime, int>&);
    void signalAllDAlbumsLoaded();
 
 
    // -----------------------------------------------------------------------------
 
 
public:
 
    AlbumList allPAlbums()                  const;
 
    PAlbum* currentPAlbum()                 const;
 
    PAlbum*   findPAlbum(const QUrl& url)   const;
 
    PAlbum*   findPAlbum(int id)            const;
 
    QMap<int, int> getPAlbumsCount()        const;
 
    void removeWatchedPAlbums(const PAlbum* const album);
 
    PAlbum* createPAlbum(PAlbum* parent, const QString& name,
                         const QString& caption, const QDate& date,
                         const QString& category,
                         QString& errMsg);
 
    PAlbum* createPAlbum(const QString& albumRootPath, const QString& name,
                         const QString& caption, const QDate& date,
                         const QString& category,
                         QString& errMsg);
 
    PAlbum* createPAlbum(const CollectionLocation& location, const QString& name,
                         const QString& caption, const QDate& date,
                         const QString& category,
                         QString& errMsg);
 
    bool renamePAlbum(PAlbum* album, const QString& newName,
                      QString& errMsg);
 
    bool updatePAlbumIcon(PAlbum* album, qlonglong iconID, QString& errMsg);
 
private:
 
    bool showDatabaseSetupPage(const QString& error, bool priority, const QString& suggestedAlbumRoot);
    void insertPAlbum(PAlbum* album, PAlbum* parent);
    void removePAlbum(PAlbum* album);
 
private Q_SLOTS:
 
    void scanPAlbums();
    void updateChangedPAlbums();
 
Q_SIGNALS:
 
    void signalPAlbumsDirty(const QMap<int, int>&);
 
 
    // -----------------------------------------------------------------------------
 
 
public:
 
    AlbumList allTAlbums()                       const;
 
    QList<TAlbum*> currentTAlbums()              const;
 
    TAlbum*   findTAlbum(int id)                 const;
 
    TAlbum*   findTAlbum(const QString& tagPath) const;
 
    QMap<int, int> getTAlbumsCount()             const;
 
    TAlbum* createTAlbum(TAlbum* parent, const QString& name,
                         const QString& iconkde, QString& errMsg);
 
    AlbumList findOrCreateTAlbums(const QStringList& tagPaths);
 
    bool deleteTAlbum(TAlbum* album, QString& errMsg, bool askUser = true);
 
    bool renameTAlbum(TAlbum* album, const QString& name, QString& errMsg);
 
    bool moveTAlbum(TAlbum* album, TAlbum* newParent, QString& errMsg);
 
    bool mergeTAlbum(TAlbum* album, TAlbum* destAlbum, bool dialog, QString& errMsg);
 
    bool updateTAlbumIcon(TAlbum* album, const QString& iconKDE,
                          qlonglong iconID, QString& errMsg);
 
    AlbumList getRecentlyAssignedTags(bool includeInternal = false)                                      const;
 
    QStringList tagPaths(const QList<int>& tagIDs, bool leadingSlash=true, bool includeInternal = false) const;
 
    QStringList tagNames(const QList<int>& tagIDs, bool includeInternal = false)                         const;
 
    QHash<int, QString> tagPaths(bool leadingSlash=true, bool includeInternal = false)                   const;
 
    QHash<int, QString> tagNames(bool includeInternal = false)                                           const;
 
    AlbumList findTagsWithProperty(const QString& property);
    AlbumList findTagsWithProperty(const QString& property, const QString& value);
 
    QList<int> subTags(int tagId, bool recursive = false);
 
private:
 
    void askUserForWriteChangedTAlbumToFiles(TAlbum* const album);
    void askUserForWriteChangedTAlbumToFiles(const QList<qlonglong>& imageIds);
 
    void insertTAlbum(TAlbum* album, TAlbum* parent);
    void removeTAlbum(TAlbum* album);
 
private Q_SLOTS:
 
    void scanTAlbums();
 
    void slotTagsJobResult();
    void slotTagsJobData(const QMap<int, int>& tagsStatMap);
    void slotTagChange(const TagChangeset& changeset);
    void slotImageTagChange(const ImageTagChangeset& changeset);
 
    void getTagItemsCount();
    void tagItemsCount();
 
Q_SIGNALS:
 
    void signalTAlbumsDirty(const QMap<int, int>&);
    void signalTagPropertiesChanged(TAlbum* album);
 
 
    // -----------------------------------------------------------------------------
 
 
public:
 
    AlbumList allSAlbums()                                  const;
 
    SAlbum*   findSAlbum(int id)                            const;
 
    SAlbum*   findSAlbum(const QString& name)               const;
 
    QList<SAlbum*> findSAlbumsBySearchType(int searchType)  const;
 
    SAlbum* createSAlbum(const QString& name,
                         DatabaseSearch::Type type,
                         const QString& query);
 
    bool updateSAlbum(SAlbum* album,
                      const QString& changedQuery,
                      const QString& changedName = QString(),
                      DatabaseSearch::Type type = DatabaseSearch::UndefinedType);
 
    bool deleteSAlbum(SAlbum* album);
 
private Q_SLOTS:
 
    void scanSAlbums();
 
    void slotSearchChange(const SearchChangeset& changeset);
 
Q_SIGNALS:
 
    void signalUpdateDuplicatesAlbums(const QList<SAlbum*>& modifiedAlbums,
                                      const QList<qlonglong>& deletedImages);
    void signalSearchUpdated(SAlbum* album);
 
 
    // -----------------------------------------------------------------------------
 
 
public:
 
    QMap<int, int> getFaceCount()            const;
 
    QMap<int, int> getUnconfirmedFaceCount() const;
 
private Q_SLOTS:
 
    void slotPeopleJobResult();
    void slotPeopleJobData(const QMap<QString,
                           QMap<int, int> >& facesStatMap);
    void personItemsCount();
 
Q_SIGNALS:
 
    void signalFaceCountsDirty(const QMap<int, int>& faceCount,
                               const QMap<int, int>& uFaceCount,
                               const QList<int>& toUpdatedFaces);
 
 
private:
 
    // Disable
    AlbumManager();
    explicit AlbumManager(QObject*) = delete;
    ~AlbumManager() override;
 
    friend class AlbumManagerCreator;
 
    static AlbumManager* internalInstance;
 
public:
 
    // Declared public because it used in ChangingDB class.
    class Private;
 
private:
 
    Private* const d;
 
    template <class T> friend class AlbumPointer;
    friend class Album;
};
 
} // namespace Digikam
 
#endif // DIGIKAM_ALBUM_MANAGER_H