collectionscannerhints.h

Go to the documentation of this file.

/* ============================================================
 *
 * This file is a part of digiKam project
 * https://www.digikam.org
 *
 * Date        : 2008-09-09
 * Description : Hint data containers for the collection scanner
 *
 * Copyright (C) 2008 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_COLLECTION_SCANNER_HINTS_H
#define DIGIKAM_COLLECTION_SCANNER_HINTS_H
 
#include "digikam_config.h"
 
// Qt includes
 
#include <QDateTime>
#include <QList>
#include <QStringList>
 
#ifdef HAVE_DBUS
#   include <QDBusArgument>
#   include "dbenginedbusutils.h"
#endif
 
// Local includes
 
#include "digikam_export.h"
 
namespace Digikam
{
 
class AlbumCopyMoveHint;
class CollectionLocation;
class CollectionScannerObserver;
class ItemInfo;
class ItemCopyMoveHint;
class ItemChangeHint;
class ItemMetadataAdjustmentHint;
 
class CollectionScannerHintContainer
{
public:
 
 
    CollectionScannerHintContainer()                                 = default;
    virtual ~CollectionScannerHintContainer()                        = default;
 
    virtual void recordHints(const QList<AlbumCopyMoveHint>& hints)  = 0;
    virtual void recordHints(const QList<ItemCopyMoveHint>& hints)   = 0;
    virtual void recordHints(const QList<ItemChangeHint>& hints)     = 0;
    virtual void recordHint(const ItemMetadataAdjustmentHint& hints) = 0;
 
    virtual void clear()                                             = 0;
 
private:
 
    Q_DISABLE_COPY(CollectionScannerHintContainer)
};
 
// ------------------------------------------------------------------------------
 
namespace CollectionScannerHints
{
 
class DIGIKAM_DATABASE_EXPORT Album
{
public:
 
    Album();
    Album(int albumRootId, int albumId);
 
    bool isNull()                       const;
    uint qHash()                        const;
    bool operator==(const Album& other) const;
 
public:
 
    int albumRootId;
    int albumId;
};
 
// ---------------------------------------------------------------------------
 
class DIGIKAM_DATABASE_EXPORT DstPath
{
public:
 
    DstPath();
    DstPath(int albumRootId, const QString& relativePath);
 
    bool isNull()                         const;
    uint qHash()                          const;
    bool operator==(const DstPath& other) const;
 
public:
 
    int     albumRootId;
    QString relativePath;
};
 
// ---------------------------------------------------------------------------
 
class DIGIKAM_DATABASE_EXPORT Item
{
public:
 
    Item();
    explicit Item(qlonglong id);
 
    bool isNull()                      const;
    uint qHash()                       const;
    bool operator==(const Item& other) const;
 
public:
 
    qlonglong id;
};
 
inline uint qHash(const Album& src)
{
    return src.qHash();
}
 
inline uint qHash(const DstPath& dst)
{
    return dst.qHash();
}
 
inline uint qHash(const Item& item)
{
    return item.qHash();
}
 
} // namespace CollectionScannerHints
 
// ---------------------------------------------------------------------------
 
class DIGIKAM_DATABASE_EXPORT AlbumCopyMoveHint
{
public:
 
    AlbumCopyMoveHint();
    AlbumCopyMoveHint(int srcAlbumRootId, int srcAlbum,
                      int dstAlbumRootId, const QString& dstRelativePath);
 
    int albumRootIdSrc()                                          const;
    int albumIdSrc()                                              const;
    bool isSrcAlbum(int albumRootId, int albumId)                 const;
 
    CollectionScannerHints::Album src()                           const
    {
        return m_src;
    }
 
    int albumRootIdDst()                                          const;
    QString relativePathDst()                                     const;
    bool isDstAlbum(int albumRootId, const QString& relativePath) const;
 
    CollectionScannerHints::DstPath dst()                         const
    {
        return m_dst;
    }
 
    uint qHash()                                                  const;
 
    bool operator==(const CollectionScannerHints::Album& src)     const
    {
        return (src == m_src);
    }
 
    bool operator==(const CollectionScannerHints::DstPath& dst)   const
    {
        return (dst == m_dst);
    }
 
#ifdef HAVE_DBUS
 
    AlbumCopyMoveHint& operator<<(const QDBusArgument& argument);
    const AlbumCopyMoveHint& operator>>(QDBusArgument& argument)  const;
 
#endif
 
    operator const CollectionScannerHints::Album& ()              const
    {
        return m_src;
    }
 
    operator const CollectionScannerHints::DstPath& ()            const
    {
        return m_dst;
    }
 
protected:
 
    CollectionScannerHints::Album   m_src;
    CollectionScannerHints::DstPath m_dst;
};
 
// ---------------------------------------------------------------------------
 
class DIGIKAM_DATABASE_EXPORT ItemCopyMoveHint
{
public:
 
    ItemCopyMoveHint();
    ItemCopyMoveHint(const QList<qlonglong>& srcIds,
                     int dstAlbumRootId,
                     int albumId,
                     const QStringList& dstNames);
 
    QList<qlonglong> srcIds()                                   const;
    bool isSrcId(qlonglong id)                                  const;
    int albumRootIdDst()                                        const;
    int albumIdDst()                                            const;
    bool isDstAlbum(int albumRootId, int albumId)               const;
 
    CollectionScannerHints::Album dst()                         const
    {
        return m_dst;
    }
 
    QStringList dstNames()                                      const;
    QString dstName(qlonglong id)                               const;
 
    bool operator==(const CollectionScannerHints::Album& dst)   const
    {
        return (dst == m_dst);
    }
 
#ifdef HAVE_DBUS
 
    ItemCopyMoveHint& operator<<(const QDBusArgument& argument);
    const ItemCopyMoveHint& operator>>(QDBusArgument& argument) const;
 
#endif
 
    operator const CollectionScannerHints::Album& ()            const
    {
        return m_dst;
    }
 
protected:
 
    QList<qlonglong>              m_srcIds;
    CollectionScannerHints::Album m_dst;
    QStringList                   m_dstNames;
};
 
// ---------------------------------------------------------------------------
 
class DIGIKAM_DATABASE_EXPORT ItemChangeHint
{
public:
 
    enum ChangeType
    {
        ItemModified, 
        ItemRescan    
    };
 
public:
 
    ItemChangeHint();
    explicit ItemChangeHint(const QList<qlonglong>& srcIds,
                            ChangeType type = ItemModified);
 
    QList<qlonglong> ids()                                      const;
    bool isId(qlonglong id)                                     const;
    ChangeType changeType()                                     const;
 
    bool isModified()                                           const
    {
        return (changeType() == ItemModified);
    }
 
    bool needsRescan()                                          const
    {
        return (changeType() == ItemRescan);
    }
 
#ifdef HAVE_DBUS
 
    ItemChangeHint& operator<<(const QDBusArgument& argument);
    const ItemChangeHint& operator>>(QDBusArgument& argument)   const;
 
#endif
 
protected:
 
    QList<qlonglong>  m_ids;
    ChangeType        m_type;
};
 
// ---------------------------------------------------------------------------
 
class DIGIKAM_DATABASE_EXPORT ItemMetadataAdjustmentHint
{
public:
 
    enum AdjustmentStatus
    {
        AboutToEditMetadata,       
        MetadataEditingFinished,   
        MetadataEditingAborted     
    };
 
public:
 
    ItemMetadataAdjustmentHint();
    explicit ItemMetadataAdjustmentHint(qlonglong id,
                                        AdjustmentStatus status,
                                        const QDateTime& modificationDateOnDisk,
                                        qlonglong fileSize);
 
    qlonglong id()                                                          const;
    AdjustmentStatus adjustmentStatus()                                     const;
    QDateTime modificationDate()                                            const;
    qlonglong fileSize()                                                    const;
 
    bool isAboutToEdit()                                                    const
    {
        return (adjustmentStatus() == AboutToEditMetadata);
    }
 
    bool isEditingFinished()                                                const
    {
        return (adjustmentStatus() == MetadataEditingFinished);
    }
 
    bool isEditingFinishedAborted()                                         const
    {
        return (adjustmentStatus() == MetadataEditingAborted);
    }
 
#ifdef HAVE_DBUS
 
    ItemMetadataAdjustmentHint& operator<<(const QDBusArgument& argument);
    const ItemMetadataAdjustmentHint& operator>>(QDBusArgument& argument)   const;
 
#endif
 
protected:
 
    qlonglong         m_id;
    AdjustmentStatus  m_status;
    QDateTime         m_modificationDate;
    qlonglong         m_fileSize;
};
 
inline uint qHash(const Digikam::AlbumCopyMoveHint& hint)
{
    return hint.qHash();
}
 
} // namespace Digikam
 
#ifdef HAVE_DBUS
 
DECLARE_METATYPE_FOR_DBUS(Digikam::AlbumCopyMoveHint)
DECLARE_METATYPE_FOR_DBUS(Digikam::ItemCopyMoveHint)
DECLARE_METATYPE_FOR_DBUS(Digikam::ItemChangeHint)
 
#endif
 
#endif // DIGIKAM_COLLECTION_SCANNER_HINTS_H