galleryslide.h

Go to the documentation of this file.

 
 
#ifndef GALLERYSLIDE_H
#define GALLERYSLIDE_H
 
#include <QQueue>
 
#include "libmythmetadata/imagetypes.h"
#include "libmythui/mythuiimage.h"
 
// Min/max zoom extents available in slideshow
#define MIN_ZOOM (0.1F)
#define MAX_ZOOM (20.0F)
 
class Slide;
 
class AbstractAnimation : public QObject
{
    Q_OBJECT
public:
    AbstractAnimation() = default;
    virtual void Start(bool forwards, float speed = 1.0);
    virtual void Stop()                 { m_running = false; }
    virtual void SetSpeed(float speed) { m_speed = speed; }
    virtual void Pulse() = 0;
    virtual void Clear()                {}
 
protected slots:
    virtual void Finished()  { m_running = false; emit finished(); }
 
signals:
    void         finished();
 
protected:
    bool  m_forwards {true}; 
    bool  m_running {false}; 
    float m_speed   {0.0F};  
};
 
 
class Animation : public AbstractAnimation, public QVariantAnimation
{
public:
    enum Type : std::uint8_t {None, Alpha, Position, Zoom, HorizontalZoom, VerticalZoom, Angle};
 
    explicit Animation(Slide *image, Type type = Alpha)
        : m_parent(image), m_type(type) {}
    void Start(bool forwards = true, float speed = 1.0) override; // AbstractAnimation
    void Pulse() override; // AbstractAnimation
    void Set(const QVariant& from, const QVariant& to,
             std::chrono::milliseconds duration = 500ms,
             const QEasingCurve& curve = QEasingCurve::InOutCubic,
             UIEffects::Centre centre = UIEffects::Middle);
 
protected:
    void updateCurrentValue(const QVariant &value) override; // QVariantAnimation
 
    // Should be MythUItype but that impacts elsewhere: SetZoom must become
    // virtual, which causes compiler (fn hiding) warnings in subtitles
    Slide            *m_parent  {nullptr};
    Type              m_type;
    UIEffects::Centre m_centre  {UIEffects::Middle};
    std::chrono::milliseconds m_elapsed {0ms};
    std::chrono::milliseconds m_lastUpdate { MythDate::currentMSecsSinceEpochAsDuration() };
};
 
 
class GroupAnimation : public AbstractAnimation
{
public:
    GroupAnimation() = default;
    ~GroupAnimation() override                        { GroupAnimation::Clear(); }
    void Pulse() override                     = 0; // AbstractAnimation
    void Start(bool forwards, float speed = 1.0) override      // AbstractAnimation
        { AbstractAnimation::Start(forwards, speed); }
    void SetSpeed(float speed) override                        // AbstractAnimation
        { AbstractAnimation::SetSpeed(speed); }
    virtual void Add(AbstractAnimation *child);
    void Clear() override; // AbstractAnimation
 
protected:
    QList<AbstractAnimation *> m_group;
};
 
 
class SequentialAnimation : public GroupAnimation
{
    Q_OBJECT
public:
    SequentialAnimation() = default;
    void Pulse() override; // GroupAnimation
    void Start(bool forwards, float speed = 1.0) override; // GroupAnimation
    void SetSpeed(float speed) override; // GroupAnimation
 
protected slots:
    void Finished() override; // AbstractAnimation
 
protected:
    int m_current {-1}; 
};
 
 
class ParallelAnimation : public GroupAnimation
{
    Q_OBJECT
public:
    ParallelAnimation() = default;
    void Pulse() override; // GroupAnimation
    void Start(bool forwards, float speed = 1.0) override; // GroupAnimation
    void SetSpeed(float speed) override; // GroupAnimation
 
protected slots:
    void Finished() override; // AbstractAnimation
 
protected:
    int m_finished {0}; 
};
 
 
class PanAnimation : public Animation
{
public:
    explicit PanAnimation(Slide *image) : Animation(image) {}
protected:
    void updateCurrentValue(const QVariant &value) override; // Animation
};
 
 
class Slide : public MythUIImage
{
    Q_OBJECT
public:
    Slide(MythUIType *parent, const QString& name, MythUIImage *image);
    ~Slide() override;
 
    void      Clear();
    bool      LoadSlide(const ImagePtrK& im, int direction = 0, bool notifyCompletion = false);
    ImagePtrK GetImageData() const  { return m_data; }
    void      Zoom(int percentage);
    void      SetZoom(float zoom);
    void      Pan(QPoint offset);
    void      SetPan(QPoint pos);
    bool      CanZoomIn() const     { return m_zoom < MAX_ZOOM; }
    bool      CanZoomOut() const    { return m_zoom > MIN_ZOOM; }
    bool      IsEmpty() const       { return m_state == kEmpty || !m_waitingFor; }
    bool      IsLoaded() const      { return m_state >= kLoaded && m_waitingFor; }
    bool      FailedLoad() const    { return m_state == kFailed; }
    int       GetDirection() const  { return m_direction; }
    void      Pulse() override; // MythUIImage
 
    QChar     GetDebugState() const;
 
public slots:
    void      SlideLoaded();
 
signals:
    void      ImageLoaded(Slide*);
 
private:
    enum SlideState : std::uint8_t { kEmpty, kLoading, kLoaded, kFailed }; // Order is significant
 
    SlideState    m_state         {kEmpty};  
    ImagePtrK     m_data          {nullptr}; 
    ImagePtrK     m_waitingFor    {nullptr};
    float         m_zoom          {1.0F};    
    int           m_direction     {0};
    Animation    *m_zoomAnimation {nullptr}; 
    PanAnimation *m_panAnimation  {nullptr}; 
    QPoint        m_pan           {0,0};     
};
 
 
class SlideBuffer : public QObject
{
    Q_OBJECT
public:
    SlideBuffer() = default;
    ~SlideBuffer() override;
 
    void   Initialise(MythUIImage &image);
    void   Teardown();
    bool   Load(const ImagePtrK& im, int direction);
    void   Preload(const ImagePtrK& im);
    void   ReleaseCurrent();
    Slide &GetCurrent()
    {
        QMutexLocker lock(&m_mutexQ);
        return *(m_queue.head());
    }
 
    Slide  &GetNext()
    {
        QMutexLocker lock(&m_mutexQ);
        return *(m_queue.at(1));
    }
 
signals:
    void SlideReady(int count);
 
private slots:
    void Flush(Slide *slide, const QString& reason);
    void Flush(Slide *slide);
 
protected:
    QString BufferState();
 
    // Must be recursive to enable Flush->signal->Get whilst retaining lock
    QRecursiveMutex m_mutexQ;      
    QQueue<Slide*> m_queue;        
    int            m_nextLoad {0}; 
};
 
#endif // GALLERYSLIDE_H