itemdelegateoverlay.h

Go to the documentation of this file.

/* ============================================================
 *
 * This file is a part of digiKam project
 * https://www.digikam.org
 *
 * Date        : 2009-04-29
 * Description : Qt item view for images - delegate additions
 *
 * Copyright (C) 2009-2011 by Marcel Wiesweg <marcel dot wiesweg at gmx dot de>
 *
 * 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_DELEGATE_OVERLAY_H
#define DIGIKAM_ITEM_DELEGATE_OVERLAY_H
 
// Qt includes
 
#include <QAbstractItemView>
 
// Local includes
 
#include "digikam_export.h"
 
namespace Digikam
{
 
class ItemViewHoverButton;
 
class DIGIKAM_EXPORT ItemDelegateOverlay : public QObject
{
    Q_OBJECT
 
public:
 
    explicit ItemDelegateOverlay(QObject* const parent = nullptr);
    ~ItemDelegateOverlay() override;
 
    virtual void setActive(bool active);
 
    virtual void mouseMoved(QMouseEvent* e, const QRect& visualRect, const QModelIndex& index);
    virtual void paint(QPainter* p, const QStyleOptionViewItem& option, const QModelIndex& index);
 
    void setView(QAbstractItemView* view);
    QAbstractItemView* view()                            const;
 
    void setDelegate(QAbstractItemDelegate* delegate);
    QAbstractItemDelegate* delegate()                    const;
 
    virtual bool acceptsDelegate(QAbstractItemDelegate*) const { return true; }
 
Q_SIGNALS:
 
    void update(const QModelIndex& index);
 
    void requestNotification(const QModelIndex& index, const QString& message);
    void hideNotification();
 
protected Q_SLOTS:
 
    virtual void visualChange();
 
protected:
 
    bool               affectsMultiple(const QModelIndex& index)         const;
    QList<QModelIndex> affectedIndexes(const QModelIndex& index)         const;
    int                numberOfAffectedIndexes(const QModelIndex& index) const;
 
    bool viewHasMultiSelection()                                         const;
 
protected:
 
    QAbstractItemView*     m_view;
    QAbstractItemDelegate* m_delegate;
};
 
#define REQUIRE_DELEGATE(Delegate)                                                                                                           \
                                                                                                                                             \
public:                                                                                                                                      \
                                                                                                                                             \
    void setDelegate(Delegate* delegate)                                 { ItemDelegateOverlay::setDelegate(delegate);                     } \
    Delegate* delegate() const                                           { return static_cast<Delegate*>(ItemDelegateOverlay::delegate()); } \
    virtual bool acceptsDelegate(QAbstractItemDelegate*d) const override { return dynamic_cast<Delegate*>(d);                              } \
                                                                                                                                             \
private:
 
// -------------------------------------------------------------------------------------------
 
class DIGIKAM_EXPORT AbstractWidgetDelegateOverlay : public ItemDelegateOverlay
{
    Q_OBJECT
 
public:
 
    explicit AbstractWidgetDelegateOverlay(QObject* const parent);
 
    void setActive(bool active)                     override;
 
protected:
 
    virtual QWidget* createWidget() = 0;
 
    virtual void hide();
 
    QWidget* parentWidget()                           const;
 
    virtual bool checkIndex(const QModelIndex& index) const;
 
    virtual void viewportLeaveEvent(QObject* obj, QEvent* event);
 
    virtual void widgetEnterEvent();
    virtual void widgetLeaveEvent();
 
    void widgetEnterNotifyMultiple(const QModelIndex& index);
    void widgetLeaveNotifyMultiple();
    virtual QString notifyMultipleMessage(const QModelIndex&, int number);
 
    bool checkIndexOnEnter(const QModelIndex& index)  const;
 
protected Q_SLOTS:
 
    virtual void slotEntered(const QModelIndex& index);
 
    virtual void slotReset();
    virtual void slotViewportEntered();
    virtual void slotRowsRemoved(const QModelIndex& parent, int start, int end);
    virtual void slotLayoutChanged();
 
protected:
 
    bool eventFilter(QObject* obj, QEvent* event)           override;
 
protected:
 
    QWidget* m_widget;
 
    bool     m_mouseButtonPressedOnWidget;
};
 
// -------------------------------------------------------------------------------------------
 
class DIGIKAM_EXPORT HoverButtonDelegateOverlay : public AbstractWidgetDelegateOverlay
{
    Q_OBJECT
 
public:
 
    explicit HoverButtonDelegateOverlay(QObject* const parent);
 
    void setActive(bool active)                 override;
 
    ItemViewHoverButton* button()                 const;
 
protected:
 
    virtual ItemViewHoverButton* createButton() = 0;
 
    virtual void updateButton(const QModelIndex& index) = 0;
 
    QWidget* createWidget()                     override;
    void visualChange()                         override;
 
protected Q_SLOTS:
 
    void slotEntered(const QModelIndex& index)  override;
    void slotReset()                            override;
};
 
// -------------------------------------------------------------------------------------------
 
class DIGIKAM_EXPORT PersistentWidgetDelegateOverlay : public AbstractWidgetDelegateOverlay
{
    Q_OBJECT
 
public:
 
    explicit PersistentWidgetDelegateOverlay(QObject* const parent);
    ~PersistentWidgetDelegateOverlay() override;
 
    void setActive(bool active)                                         override;
 
    bool isPersistent() const;
 
public Q_SLOTS:
 
    void setPersistent(bool persistent);
    void enterPersistentMode();
    void leavePersistentMode();
 
    void storeFocus();
 
protected:
 
    QModelIndex index() const;
 
    void slotEntered(const QModelIndex& index)                          override;
    void slotReset()                                                    override;
    void slotViewportEntered()                                          override;
    void slotRowsRemoved(const QModelIndex& parent, int start, int end) override;
    void slotLayoutChanged()                                            override;
    void viewportLeaveEvent(QObject* obj, QEvent* event)                override;
    void hide()                                                         override;
 
    virtual void setFocusOnWidget();
 
    virtual void showOnIndex(const QModelIndex& index);
 
    void restoreFocus();
 
private:
 
    class Private;
    Private* const d;
};
 
// -------------------------------------------------------------------------------------------
 
class DIGIKAM_EXPORT ItemDelegateOverlayContainer
{
public:
 
    ItemDelegateOverlayContainer()          = default;
    virtual ~ItemDelegateOverlayContainer() = default;
 
    QList<ItemDelegateOverlay*> overlays() const;
 
    void installOverlay(ItemDelegateOverlay* overlay);
    void removeOverlay(ItemDelegateOverlay* overlay);
    void setAllOverlaysActive(bool active);
    void setViewOnAllOverlays(QAbstractItemView* view);
    void removeAllOverlays();
    void mouseMoved(QMouseEvent* e, const QRect& visualRect, const QModelIndex& index);
 
/*
    void visualChange();
    void requestNotification(const QModelIndex& index, const QString& message);
    void hideNotification();
*/
 
protected:
 
    virtual void drawOverlays(QPainter* p, const QStyleOptionViewItem& option, const QModelIndex& index) const;
 
    virtual void overlayDestroyed(QObject* o);
 
    virtual QAbstractItemDelegate* asDelegate() = 0;
 
protected:
 
    QList<ItemDelegateOverlay*> m_overlays;
 
private:
 
    Q_DISABLE_COPY(ItemDelegateOverlayContainer)
};
 
} // namespace Digikam
 
#endif // DIGIKAM_ITEM_DELEGATE_OVERLAY_H