abstractalbummodel.h

Go to the documentation of this file.

/* ============================================================
 *
 * This file is a part of digiKam project
 * https://www.digikam.org
 *
 * Date        : 2009-03-23
 * Description : Qt Model for Albums
 *
 * Copyright (C) 2008-2011 by Marcel Wiesweg <marcel dot wiesweg at gmx dot de>
 * Copyright (C) 2010      by Andi Clemens <andi dot clemens at gmail dot com>
 * Copyright (C) 2012-2022 by Gilles Caulier <caulier dot gilles at gmail dot com>
 *
 * 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_ABSTRACT_ALBUM_MODEL_H
#define DIGIKAM_ABSTRACT_ALBUM_MODEL_H
 
// Qt includes
 
#include <QAbstractItemModel>
#include <QHash>
#include <QPixmap>
#include <QSet>
 
// Local includes
 
#include "album.h"
#include "digikam_export.h"
 
namespace Digikam
{
 
class Album;
class AlbumManager;
class AlbumModelDragDropHandler;
 
class DIGIKAM_GUI_EXPORT AbstractAlbumModel : public QAbstractItemModel
{
    Q_OBJECT
 
public:
 
    enum RootAlbumBehavior
    {
        IncludeRootAlbum,
        IgnoreRootAlbum
    };
 
    enum AlbumDataRole
    {
        AlbumTitleRole    = Qt::UserRole,
        AlbumTypeRole     = Qt::UserRole + 1,
        AlbumPointerRole  = Qt::UserRole + 2,
        AlbumIdRole       = Qt::UserRole + 3,
        AlbumGlobalIdRole = Qt::UserRole + 4,
        AlbumSortRole     = Qt::UserRole + 5
    };
 
public:
 
    explicit AbstractAlbumModel(Album::Type albumType,
                                Album* const rootAlbum,
                                RootAlbumBehavior rootBehavior = IncludeRootAlbum,
                                QObject* const parent = nullptr);
    ~AbstractAlbumModel() override;
 
    void setDragDropHandler(AlbumModelDragDropHandler* handler);
 
    AlbumModelDragDropHandler* dragDropHandler()    const;
 
    Album* albumForIndex(const QModelIndex& index)  const;
 
    QModelIndex indexForAlbum(Album* album)         const;
 
    static Album* retrieveAlbum(const QModelIndex& index);
 
    Album* rootAlbum()                              const;
 
    QModelIndex rootAlbumIndex()                    const;
 
    RootAlbumBehavior rootAlbumBehavior()           const;
 
    Album::Type albumType()                         const;
 
    bool isFaceTagModel()                           const;
 
    QVariant data(const QModelIndex& index, int role = Qt::DisplayRole)                                             const override;
    QVariant headerData(int section, Qt::Orientation orientation, int role = Qt::DisplayRole)                       const override;
    int rowCount(const QModelIndex& parent = QModelIndex())                                                         const override;
    int columnCount(const QModelIndex& parent = QModelIndex())                                                      const override;
    Qt::ItemFlags flags(const QModelIndex& index)                                                                   const override;
    bool hasChildren(const QModelIndex& parent = QModelIndex())                                                     const override;
    QModelIndex index(int row, int column, const QModelIndex& parent = QModelIndex())                               const override;
    QModelIndex parent(const QModelIndex& index)                                                                    const override;
 
    Qt::DropActions supportedDropActions()                                                                          const override;
    QStringList mimeTypes()                                                                                         const override;
    bool dropMimeData(const QMimeData* data, Qt::DropAction action, int row, int column, const QModelIndex& parent)       override;
    QMimeData* mimeData(const QModelIndexList& indexes)                                                             const override;
 
Q_SIGNALS:
 
    void rootAlbumAvailable();
 
protected:
 
    void setEnableDrag(bool enable);
    void setEnableDrop(bool enable);
    void setFaceTagModel(bool enable);
 
    virtual QVariant albumData(Album* a, int role)  const;
 
    virtual QVariant decorationRoleData(Album* a)   const;
 
    virtual QVariant fontRoleData(Album* a)         const;
 
    virtual QVariant sortRoleData(Album* a)         const;
 
    virtual QString columnHeader()                  const;
 
    virtual Qt::ItemFlags itemFlags(Album* album)   const;
 
    virtual bool filterAlbum(Album* album)          const;
 
    virtual void albumCleared(Album* /*album*/) {};
 
    virtual void allAlbumsCleared()             {};
 
protected Q_SLOTS:
 
    void slotAlbumAboutToBeAdded(Album* album, Album* parent, Album* prev);
    void slotAlbumAdded(Album*);
    void slotAlbumAboutToBeDeleted(Album* album);
    void slotAlbumHasBeenDeleted(quintptr);
    void slotAlbumsCleared();
    void slotAlbumIconChanged(Album* album);
    void slotAlbumRenamed(Album* album);
 
private:
 
    class Private;
    Private* const d;
};
 
// ------------------------------------------------------------------
 
class DIGIKAM_GUI_EXPORT AbstractSpecificAlbumModel : public AbstractAlbumModel
{
    Q_OBJECT
 
public:
 
    explicit AbstractSpecificAlbumModel(Album::Type albumType,
                                        Album* const rootAlbum,
                                        RootAlbumBehavior rootBehavior = IncludeRootAlbum,
                                        QObject* const parent = nullptr);
 
protected:
 
    QString  columnHeader() const override;
    void setColumnHeader(const QString& header);
 
    void setupThumbnailLoading();
    void emitDataChangedForChildren(Album* album);
 
protected Q_SLOTS:
 
    void slotGotThumbnailFromIcon(Album* album, const QPixmap& thumbnail);
    void slotThumbnailLost(Album* album);
    void slotReloadThumbnails();
 
protected:
 
    QString m_columnHeader;
};
 
// ------------------------------------------------------------------
 
class DIGIKAM_GUI_EXPORT AbstractCountingAlbumModel : public AbstractSpecificAlbumModel
{
    Q_OBJECT
 
public:
 
 
    explicit AbstractCountingAlbumModel(Album::Type albumType,
                                        Album* const rootAlbum,
                                        RootAlbumBehavior rootBehavior = IncludeRootAlbum,
                                        QObject* const parent = nullptr);
    ~AbstractCountingAlbumModel() override;
 
    bool showCount()                        const;
 
    virtual int albumCount(Album* album)    const;
 
protected:
 
    void setup();
 
public Q_SLOTS:
 
    void setShowCount(bool show);
 
    void setCountMap(const QMap<int, int>& idCountMap);
 
    void excludeChildrenCount(const QModelIndex& index);
 
    void includeChildrenCount(const QModelIndex& index);
 
protected:
 
    void setCount(Album* album, int count);
 
    virtual Album* albumForId(int id)       const = 0;
 
    virtual QString albumName(Album* a)     const;
 
    QVariant albumData(Album* a, int role)  const override;
    void albumCleared(Album* album) override;
    void allAlbumsCleared() override;
 
protected Q_SLOTS:
 
    void slotAlbumMoved(Album* album);
 
private:
 
    void updateCount(Album* album);
 
private:
 
    class Private;
    Private* const d;
};
 
// ------------------------------------------------------------------
 
class DIGIKAM_GUI_EXPORT AbstractCheckableAlbumModel : public AbstractCountingAlbumModel
{
    Q_OBJECT
 
public:
 
    explicit AbstractCheckableAlbumModel(Album::Type albumType,
                                         Album* const rootAlbum,
                                         RootAlbumBehavior rootBehavior = IncludeRootAlbum,
                                         QObject* const parent = nullptr);
    ~AbstractCheckableAlbumModel() override;
 
    void setCheckable(bool isCheckable);
    bool isCheckable()                      const;
 
    void setRootCheckable(bool rootIsCheckable);
    bool rootIsCheckable()                  const;
 
    void setTristate(bool isTristate);
    bool isTristate()                       const;
 
    void setAddExcludeTristate(bool b);
    bool isAddExcludeTristate()             const;
 
    bool isChecked(Album* album)            const;
 
    Qt::CheckState checkState(Album* album) const;
 
    QList<Album*> checkedAlbums()           const;
 
    QList<Album*> partiallyCheckedAlbums()  const;
 
public Q_SLOTS:
 
    void setChecked(Album* album, bool isChecked);
 
    void setCheckState(Album* album, Qt::CheckState state);
 
    void toggleChecked(Album* album);
 
    void resetAllCheckedAlbums();
 
    void resetCheckedAlbums(const QModelIndex& parent = QModelIndex());
 
    void resetCheckedParentAlbums(const QModelIndex& child);
 
    void checkAllAlbums(const QModelIndex& parent = QModelIndex());
 
    void checkAllParentAlbums(const QModelIndex& child);
 
    void invertCheckedAlbums(const QModelIndex& parent = QModelIndex());
 
    void setCheckStateForChildren(Album* album, Qt::CheckState state);
 
    void setCheckStateForParents(Album* album, Qt::CheckState state);
 
Q_SIGNALS:
 
    void checkStateChanged(Album* album, Qt::CheckState checkState);
 
protected:
 
    void prepareAddExcludeDecoration(Album* a, QPixmap& icon)                              const;
 
    QVariant albumData(Album* a, int role)                                                 const override;
    Qt::ItemFlags flags(const QModelIndex& index)                                          const override;
    bool setData(const QModelIndex& index, const QVariant& value, int role = Qt::EditRole)       override;
 
    void albumCleared(Album* album)                                                              override;
    void allAlbumsCleared()                                                                      override;
 
private:
 
    void setDataForParents(const QModelIndex& child, const QVariant& value, int role = Qt::EditRole);
    void setDataForChildren(const QModelIndex& parent, const QVariant& value, int role = Qt::EditRole);
 
private:
 
    class Private;
    Private* const d;
};
 
} // namespace Digikam
 
#endif // DIGIKAM_ABSTRACT_ALBUM_MODEL_H