galleryviews.h

Go to the documentation of this file.

 
#ifndef GALLERYVIEWS_H
#define GALLERYVIEWS_H
 
#include <utility>
 
#include <QSet>
#include <QVector>
 
// MythTV headers
#include "libmythmetadata/imagemanager.h"
 
 
enum SlideOrderType : std::uint8_t {
    kOrdered  = 0, 
    kShuffle  = 1, 
    kRandom   = 2, 
    kSeasonal = 3  
};
 
 
using WeightList = QVector<double>;
 
 
class MarkedFiles : public QSet<int>
{
public:
    MarkedFiles() = default;
    void Initialise(int id)      { m_valid = true; m_parent = id; clear();}
    void Clear()                 { m_valid = false; clear(); }
    bool IsFor(int id) const     { return m_valid && m_parent == id; }
    void Add(const ImageIdList& newIds);
    void Add(int id)             { insert(id); }
    void Invert(const ImageIdList& all);
 
private:
    bool m_valid  {false};
    int  m_parent {0};
};
 
 
class MenuSubjects
{
public:
    MenuSubjects() = default;
    MenuSubjects(const ImagePtrK& selection, ssize_t childCount,
                 MarkedFiles &marked, MarkedFiles &prevMarked,
                 bool hiddenMarked, bool unhiddenMarked)
        : m_selected(selection),
          m_selectedMarked(selection && marked.contains(selection->m_id)),
          m_markedId(marked.values()),  m_prevMarkedId(prevMarked.values()),
          m_childCount(childCount),
          m_hiddenMarked(hiddenMarked), m_unhiddenMarked(unhiddenMarked)
    {}
 
    ImagePtrK   m_selected       {nullptr}; 
    bool        m_selectedMarked {false};   
    ImageIdList m_markedId;                 
    ImageIdList m_prevMarkedId;             
    ssize_t     m_childCount     {0};       
    bool        m_hiddenMarked   {false};   
    bool        m_unhiddenMarked {false};   
};
 
class FileCacheEntry
{
public:
    // Default constructor for QHash 'undefined entry'
    FileCacheEntry() = default;
    FileCacheEntry(int parent, QString url, QString thumbUrl)
        : m_parent(parent), m_url(std::move(url)), m_thumbUrl(std::move(thumbUrl))  {}
 
    QString ToString(int id) const
    { return QString("File %1 Parent %2").arg(id).arg(m_parent); }
 
    int     m_parent {GALLERY_DB_ID};
    QString m_url;
    QString m_thumbUrl;
};
 
 
class FlatView
{
public:
    explicit FlatView(SlideOrderType order)
        : m_order(order), m_mgr(ImageManagerFe::getInstance()) {}
    virtual ~FlatView()         { Clear(); }
 
    int          GetParentId() const { return m_parentId; }
    ImageListK   GetAllNodes() const;
    ImagePtrK    GetSelected() const;
    ImagePtrK    HasNext(int inc) const;
    ImagePtrK    HasPrev(int inc) const;
    ImagePtrK    Next(int inc);
    ImagePtrK    Prev(int inc);
    QString      GetPosition() const;
    bool         Select(int id, int fallback = 0);
    virtual bool LoadFromDb(int parentId);
    QStringList  ClearImage(int id, bool remove = false);
    void         ClearCache();
    bool         Update(int id);
    void         Rotate(int id);
    void         Clear(bool resetParent = true);
 
    QString      GetCachedThumbUrl(int id) const
    { return m_fileCache.value(id).m_thumbUrl; }
 
protected:
    static WeightList CalculateSeasonalWeights(ImageList &files);
 
    void Populate(ImageList &files);
    void Cache(int id, int parent, const QString &url, const QString &thumb);
 
    int                   m_parentId {-1};
    SlideOrderType        m_order {kOrdered};
    ImageManagerFe       &m_mgr;
    QHash<int, ImagePtrK> m_images;   
    ImageIdList           m_sequence; 
    int                   m_active {0};   
 
    QHash<int, FileCacheEntry> m_fileCache;
};
 
 
class DirCacheEntry
{
public:
    DirCacheEntry() = default;
    DirCacheEntry(int parentId, int dirs, int files,
                  QList<ThumbPair> thumbs, int thumbCount)
        : m_parent(parentId), m_thumbCount(thumbCount),
          m_dirCount(dirs), m_fileCount(files), m_thumbs(std::move(thumbs)) {}
 
    QString ToString(int id) const;
 
    int              m_parent     {0};
    int              m_thumbCount {0};
    int              m_dirCount   {-1};
    int              m_fileCount  {-1};
    QList<ThumbPair> m_thumbs;
};
 
 
class DirectoryView : public FlatView
{
public:
    explicit DirectoryView(SlideOrderType order);
 
    ImagePtrK GetParent() const
    { return m_sequence.isEmpty() ? ImagePtrK() : m_images.value(m_sequence.at(0)); }
 
    QString      GetPosition() const;
    bool         LoadFromDb(int parentId) override; // FlatView
    void         Clear(bool resetParent = true);
    MenuSubjects GetMenuSubjects();
    QStringList  RemoveImage(int id, bool deleted = false);
    void         ClearCache();
    void         MarkAll();
    void         Mark(int id, bool mark);
    void         InvertMarked();
    void         ClearMarked();
    bool         IsMarked(int id) const
    { return m_marked.contains(id) || m_prevMarked.contains(id); }
 
protected:
    void         SetDirectory(int newParent);
    void         LoadDirThumbs(ImageItem &parent, int thumbsNeeded, int level = 0);
    void         PopulateThumbs(ImageItem &parent, int thumbsNeeded,
                                const ImageList &files, const ImageList &dirs,
                                int level = 0);
    ImageIdList  GetChildren() const  { return m_sequence.mid(1); }
    bool         PopulateFromCache(ImageItem &dir, int required);
    void         Cache(ImageItemK &dir, int thumbCount);
 
    MarkedFiles m_marked;       
    MarkedFiles m_prevMarked;   
 
    QHash<int, DirCacheEntry>  m_dirCache;
};
 
 
class TreeView : public FlatView
{
public:
    explicit TreeView(SlideOrderType order) : FlatView(order) {}
 
    bool LoadFromDb(int parentId) override; // FlatView
};
 
 
#endif // GALLERYVIEWS_H