itemvisibilitycontroller.h

Go to the documentation of this file.

/* ============================================================
 *
 * This file is a part of digiKam project
 * https://www.digikam.org
 *
 * Date        : 2010-09-20
 * Description : Managing visibility state with animations
 *
 * Copyright (C) 2010-2011 by Marcel Wiesweg <marcel dot wiesweg at gmx dot de>
 * 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_ITEM_VISIBILITY_CONTROLLER_H
#define DIGIKAM_ITEM_VISIBILITY_CONTROLLER_H
 
// Qt includes
 
#include <QAbstractAnimation>
#include <QVariant>
 
// Local includes
 
#include "digikam_export.h"
 
class QEasingCurve;
class QPropertyAnimation;
 
namespace Digikam
{
 
class DIGIKAM_EXPORT ItemVisibilityController : public QObject
{
    Q_OBJECT
    Q_PROPERTY(bool  shallBeShown READ shallBeShown WRITE setShallBeShown)
    Q_PROPERTY(bool  visible      READ isVisible    WRITE setVisible)
 
public:
 
    enum State
    {
        Hidden,
        FadingIn,
        Visible,
        FadingOut
    };
    Q_ENUM(State)
 
    enum IncludeFadingOutMode
    {
        IncludeFadingOut,
 
        ExcludeFadingOut
    };
 
public:
 
    explicit ItemVisibilityController(QObject* const parent = nullptr);
    ~ItemVisibilityController() override;
 
    bool  shallBeShown()                                                        const;
    bool  isVisible()                                                           const;
    State state()                                                               const;
 
    bool  hasVisibleItems(IncludeFadingOutMode mode = IncludeFadingOut)         const;
 
    void clear();
 
    void addItem(QObject* object);
    void removeItem(QObject* object);
 
    QList<QObject*> items()                                                     const;
 
    QList<QObject*> visibleItems(IncludeFadingOutMode mode = IncludeFadingOut)  const;
 
    void setEasingCurve(const QEasingCurve& easing);
    void setAnimationDuration(int msecs);
 
Q_SIGNALS:
 
    void propertiesAssigned(bool visible);
 
    void propertiesAssigned(QObject* item, bool visible);
 
    void hiddenAndRemoved(QObject* item);
 
public Q_SLOTS:
 
    void setShallBeShown(bool shallBeShown);
    void setShallBeShownDirectly(bool shallBeShown);
 
    void setItemThatShallBeShown(QObject* item);
 
    void show();
    void hide();
    void setVisible(bool visible);
    void setDirectlyVisible(bool visible);
 
    void showItem(QObject* item);
    void hideItem(QObject* item);
    void setItemVisible(QObject* item, bool visible);
    void setItemDirectlyVisible(QObject* item, bool visible);
 
    void hideAndRemoveItem(QObject* item);
 
protected:
 
    virtual QPropertyAnimation* createAnimation(QObject* item);
 
protected Q_SLOTS:
 
    void animationFinished();
    void objectDestroyed(QObject*);
 
private:
 
    class Private;
    Private* const d;
};
 
// ------------------------------------------------------------------------------------------
 
class DIGIKAM_EXPORT ItemVisibilityControllerPropertyObject : public QObject
{
    Q_OBJECT
    Q_PROPERTY(qreal opacity READ opacity   WRITE setOpacity NOTIFY opacityChanged)
    Q_PROPERTY(bool  visible READ isVisible WRITE setVisible NOTIFY visibleChanged)
 
public:
 
    explicit ItemVisibilityControllerPropertyObject(QObject* const parent = nullptr);
 
    qreal opacity()                 const;
    void setOpacity(qreal opacity);
 
    bool isVisible()                const;
    void setVisible(bool visible);
 
Q_SIGNALS:
 
    void opacityChanged();
    void visibleChanged();
 
protected:
 
    qreal m_opacity;
    bool  m_visible;
};
 
// ------------------------------------------------------------------------------------------
 
class DIGIKAM_EXPORT AnimatedVisibility : public ItemVisibilityControllerPropertyObject
{
    Q_OBJECT
 
public:
 
    explicit AnimatedVisibility(QObject* const parent = nullptr);
 
    ItemVisibilityController* controller() const;
 
protected:
 
    ItemVisibilityController* m_controller;
};
 
// ------------------------------------------------------------------------------------------
 
class DIGIKAM_EXPORT HidingStateChanger : public ItemVisibilityController
{
    Q_OBJECT
 
public:
 
    explicit HidingStateChanger(QObject* const parent = nullptr);
 
    HidingStateChanger(QObject* const target, const QByteArray& property, QObject* const parent = nullptr);
 
    void setTargetObject(QObject* const object);
    void setPropertyName(const QByteArray& propertyName);
 
public Q_SLOTS:
 
    void changeValue(const QVariant& value);
 
Q_SIGNALS:
 
    void stateChanged();
 
    void finished();
 
protected Q_SLOTS:
 
    void slotPropertiesAssigned(bool);
 
protected:
 
    QObject*   m_object;
    QByteArray m_property;
    QVariant   m_value;
};
 
} // namespace Digikam
 
#endif // DIGIKAM_ITEM_VISIBILITY_CONTROLLER_H