aerothemeplasma/KWin/smod_kwin_theme/breeze/kstyle/breezewindowmanager.h

/*
 * SPDX-FileCopyrightText: 2014 Hugo Pereira Da Costa <hugo.pereira@free.fr>
 *
 * SPDX-License-Identifier: GPL-2.0-or-later
 */

#ifndef breezewindowmanager_h
#define breezewindowmanager_h

#include "breeze.h"
#include "breezestyleconfigdata.h"
#include "config-breeze.h"

#include <QEvent>

#include <QApplication>
#include <QBasicTimer>
#include <QObject>
#include <QSet>
#include <QString>
#include <QWidget>

#if BREEZE_HAVE_QTQUICK
#include <QQuickItem>
#endif

namespace Breeze
{
class WindowManager : public QObject
{
    Q_OBJECT

public:
    //* constructor
    explicit WindowManager(QObject *);

    //* initialize
    /** read relevant options from config */
    void initialize();

    //* register widget
    void registerWidget(QWidget *);

#if BREEZE_HAVE_QTQUICK
    //* register quick item
    void registerQuickItem(QQuickItem *);
#endif

    //* unregister widget
    void unregisterWidget(QWidget *);

    //* event filter [reimplemented]
    bool eventFilter(QObject *, QEvent *) override;

protected:
    //* timer event,
    /** used to start drag if button is pressed for a long enough time */
    void timerEvent(QTimerEvent *) override;

    //* mouse press event
    bool mousePressEvent(QObject *, QEvent *);

    //* mouse move event
    bool mouseMoveEvent(QObject *, QEvent *);

    //* mouse release event
    bool mouseReleaseEvent(QObject *, QEvent *);

    //*@name configuration
    //@{

    //* enable state
    bool enabled() const
    {
        return _enabled;
    }

    //* enable state
    void setEnabled(bool value)
    {
        _enabled = value;
    }

    //* drag mode
    int dragMode() const
    {
        return _dragMode;
    }

    //* drag mode
    void setDragMode(int value)
    {
        _dragMode = value;
    }

    //* drag distance (pixels)
    void setDragDistance(int value)
    {
        _dragDistance = value;
    }

    //* drag delay (msec)
    void setDragDelay(int value)
    {
        _dragDelay = value;
    }

    //* set list of whiteListed widgets
    /**
    white list is read from options and is used to adjust
    per-app window dragging issues
    */
    void initializeWhiteList();

    //* set list of blackListed widgets
    /**
    black list is read from options and is used to adjust
    per-app window dragging issues
    */
    void initializeBlackList();

    //@}

    //* returns true if widget is dragable
    bool isDragable(QWidget *);

    //* returns true if widget is dragable
    bool isBlackListed(QWidget *);

    //* returns true if widget is dragable
    bool isWhiteListed(QWidget *) const;

    //* returns true if drag can be started from current widget
    bool canDrag(QWidget *);

    //* returns true if drag can be started from current widget and position
    /** child at given position is passed as second argument */
    bool canDrag(QWidget *, QWidget *, const QPoint &);

    //* reset drag
    void resetDrag();

    //* start drag
    void startDrag(QWindow *);

    //* utility function
    bool isDockWidgetTitle(const QWidget *) const;

    //*@name lock
    //@{

    void setLocked(bool value)
    {
        _locked = value;
    }

    //* lock
    bool isLocked() const
    {
        return _locked;
    }

    //@}

    //* returns first widget matching given class, or nullptr if none
    template<typename T>
    T findParent(const QWidget *) const;

private:
    //* enability
    bool _enabled = true;

    //* drag mode
    int _dragMode = StyleConfigData::WD_FULL;

    //* drag distance
    /** this is copied from kwin::geometry */
    int _dragDistance = QApplication::startDragDistance();

    //* drag delay
    /** this is copied from kwin::geometry */
    int _dragDelay = QApplication::startDragTime();

    //* wrapper for exception id
    class ExceptionId
    {
    public:
        //* constructor
        explicit ExceptionId(const QString &value)
        {
            const QStringList args(value.split(QChar::fromLatin1('@')));
            if (args.isEmpty()) {
                return;
            }
            _exception.second = args[0].trimmed();
            if (args.size() > 1) {
                _exception.first = args[1].trimmed();
            }
        }

        const QString &appName() const
        {
            return _exception.first;
        }

        const QString &className() const
        {
            return _exception.second;
        }

    private:
        QPair<QString, QString> _exception;

        friend uint qHash(const ExceptionId &value)
        {
            return qHash(value._exception);
        }

        friend bool operator==(const ExceptionId &lhs, const ExceptionId &rhs)
        {
            return lhs._exception == rhs._exception;
        }
    };

    //* exception set
    using ExceptionSet = QSet<ExceptionId>;

    //* list of white listed special widgets
    /**
    it is read from options and is used to adjust
    per-app window dragging issues
    */
    ExceptionSet _whiteList;

    //* list of black listed special widgets
    /**
    it is read from options and is used to adjust
    per-app window dragging issues
    */
    ExceptionSet _blackList;

    //* drag point
    QPoint _dragPoint;
    QPoint _globalDragPoint;

    //* drag timer
    QBasicTimer _dragTimer;

    //* target being dragged
    /** Weak pointer is used in case the target gets deleted while drag is in progress */
    WeakPointer<QWidget> _target;

#if BREEZE_HAVE_QTQUICK
    WeakPointer<QQuickItem> _quickTarget;
#endif

    //* true if drag is about to start
    bool _dragAboutToStart = false;

    //* true if drag is in progress
    bool _dragInProgress = false;

    //* true if drag is locked
    bool _locked = false;

    //* true if the event we are intercepting passed trough a QQuickWidget.
    /**In this case we shouldn't start a drag, because if it was to start, we would have done it in the event filter of a qquickwidget.
     * Event handlers don't accept input events, but they do block QQuickItems to receive the event, so the event may have been
     * managed by an handler and not blocked by the root qml item.
     **/
    bool _eventInQQuickWidget = false;

    //* application event filter
    QObject *_appEventFilter = nullptr;

    //* allow access of all private members to the app event filter
    friend class AppEventFilter;
};

//____________________________________________________________________
template<typename T>
T WindowManager::findParent(const QWidget *widget) const
{
    if (!widget) {
        return nullptr;
    }
    for (QWidget *parent = widget->parentWidget(); parent; parent = parent->parentWidget()) {
        if (T cast = qobject_cast<T>(parent)) {
            return cast;
        }
    }

    return nullptr;
}

}

#endif