mythnotificationcenter_private.h

Go to the documentation of this file.

//
//  mythnotificationcenter_private.h
//  MythTV
//
//  Created by Jean-Yves Avenard on 30/06/13.
//  Copyright (c) 2013 Bubblestuff Pty Ltd. All rights reserved.
//
 
#ifndef MythTV_mythnotificationcenter_private_h
#define MythTV_mythnotificationcenter_private_h
 
#include <QTimer>
#include <QMutex>
#include <QList>
#include <QMap>
 
#include <cstdint>
 
#include "mythscreenstack.h"
#include "mythscreentype.h"
#include "mythuiimage.h"
#include "mythuitext.h"
#include "mythuiprogressbar.h"
#include "mythnotificationcenter.h"
#include "mythuistatetype.h"
 
// Forward declarations
class MythNotificationScreen;
class MythNotificationScreenStack;
 
static constexpr int MIN_LIFE {1000};
 
class NCPrivate : public QObject
{
    Q_OBJECT
 
public slots:
    void ScreenDeleted(void);
 
public:
    NCPrivate(void);
    ~NCPrivate() override;
 
    bool Queue(const MythNotification &notification);
 
    static MythNotificationCenter *GetInstance(void);
 
    int  Register(void *from);
    void UnRegister(void *from, int id, bool closeimemdiately = false);
 
    /*
     * OSD drawing utilities
     */
 
    QDateTime ScreenExpiryTime(const MythScreenType *screen);
    bool ScreenCreated(const MythScreenType *screen);
    void GetNotificationScreens(QList<MythScreenType*> &screens);
    void UpdateScreen(MythScreenType *screen);
    int DisplayedNotifications(void) const;
    int QueuedNotifications(void) const;
    bool RemoveFirst(void);
    void ProcessQueue(void);
 
    void ScreenStackDeleted(void);
 
private:
 
    MythNotificationScreen *CreateScreen(MythNotification *notification,
                                           int id = -1);
    void DeleteAllRegistrations(void);
    void DeleteAllScreens(void);
    void DeleteUnregistered(void);
    int InsertScreen(MythNotificationScreen *screen);
    int RemoveScreen(MythNotificationScreen *screen);
    void RefreshScreenPosition(int from = 0);
 
    MythNotificationScreenStack            *m_originalScreenStack {nullptr};
    MythNotificationScreenStack            *m_screenStack         {nullptr};
    QList<MythNotification*>                m_notifications;
    QList<MythNotificationScreen*>        m_screens;
    QList<MythNotificationScreen*>        m_deletedScreens;
    QMap<int, MythNotificationScreen*>    m_registrations;
    QList<int>                              m_suspended;
    QMap<int,bool>                          m_unregistered;
    QMap<int, void*>                        m_clients;
    QMutex                                  m_lock;
    int                                     m_currentId           {0};
    QMap<MythNotificationScreen*, MythNotificationScreen*> m_converted;
};
 
class MythNotificationScreen : public MythScreenType
{
    Q_OBJECT
 
public:
    explicit MythNotificationScreen(MythScreenStack *stack,
                             int id = -1);
    MythNotificationScreen(MythScreenStack *stack,
                             MythNotification &notification);
    MythNotificationScreen(MythScreenStack *stack,
                             const MythNotificationScreen &screen);
    
    ~MythNotificationScreen() override;
 
    bool keyPressEvent(QKeyEvent *event) override; // MythScreenType
 
    // These two methods are declared by MythScreenType and their signatures
    // should not be changed
    bool Create(void) override; // MythScreenType
 
    void SetNotification(MythNotification &notification);
 
    void UpdateArtwork(const QImage &image);
    void UpdateArtwork(const QString &image);
    void UpdateMetaData(const DMAP &data);
    void UpdatePlayback(float progress, const QString &text);
    void UpdateFrom(const MythNotificationScreen &s);
 
    void SetSingleShotTimer(std::chrono::seconds s, bool update = false);
    void SetErrorState(void) const;
 
    // UI methods
    void AdjustYPosition(void);
    void AdjustIndex(int by, bool set=false);
    void SetIndex(int index);
    int  GetHeight(void);
 
    enum Content : uint8_t {
        kNone       = 0,
        kImage      = 1 << 0,
        kDuration   = 1 << 1,
        kMetaData   = 1 << 2,
        kStyle      = 1 << 3,
        kNoArtwork  = 1 << 4,
        kAll        = 0xFF,
    };
 
signals:
    void ScreenDeleted();
 
public slots:
    void ProcessTimer(void);
 
protected:
    void Init(void)  override; // MythScreenType
 
public:
    int                         m_id;
    QImage                      m_image;
    QString                     m_imagePath;
    QString                     m_title;
    QString                     m_origin;
    QString                     m_description;
    QString                     m_extra;
    std::chrono::seconds        m_duration        {-1s};
    float                       m_progress        {-1.0F};
    QString                     m_progresstext;
    bool                        m_fullscreen      {false};
    bool                        m_added           {false};
    bool                        m_created         {false};
    std::underlying_type_t<Content> m_content     {kNone};
    std::underlying_type_t<Content> m_update      {kAll};
    MythNotification::Type      m_type            {MythNotification::kNew};
    MythUIImage                *m_artworkImage    {nullptr};
    MythUIText                 *m_titleText       {nullptr};
    MythUIText                 *m_originText      {nullptr};
    MythUIText                 *m_descriptionText {nullptr};
    MythUIText                 *m_extraText       {nullptr};
    MythUIText                 *m_progresstextText{nullptr};
    MythUIProgressBar          *m_progressBar     {nullptr};
    MythUIStateType            *m_errorState      {nullptr};
    MythUIStateType            *m_mediaState      {nullptr};
    QDateTime                   m_creation;
    QDateTime                   m_expiry;
    int                         m_index           {0};
    MythPoint                   m_position;
    QTimer                     *m_timer           {nullptr};
    QString                     m_style;
    VNMask                      m_visibility      {(VNMask)MythNotification::kAll};
    MythNotification::Priority  m_priority        {MythNotification::kDefault};
    bool                        m_refresh         {true};
};
 
 
class MythNotificationScreenStack : public MythScreenStack
{
public:
    MythNotificationScreenStack(MythMainWindow *parent, const QString& name,
                                NCPrivate *owner)
        : MythScreenStack(parent, name), m_owner(owner)
    {
    }
 
    ~MythNotificationScreenStack() override
    {
        m_owner->ScreenStackDeleted();
    }
 
    void CheckDeletes()
    {
        for (auto * screen : std::as_const(m_toDelete))
        {
            screen->SetAlpha(0);
            screen->SetVisible(false);
            screen->Close();
        }
        MythScreenStack::CheckDeletes();
    }
 
    static const int kFadeVal = 20;
 
    void PopScreen(MythScreenType *screen, bool allowFade = true,
                   bool deleteScreen = true) override; // MythScreenStack
    MythScreenType *GetTopScreen(void) const override; // MythScreenStack
private:
    NCPrivate *m_owner {nullptr};
 
};
 
#endif