pointerconstraints.h

/****************************************************************************
Copyright 2016  Martin Gräßlin <[email protected]>

This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) version 3, or any
later version accepted by the membership of KDE e.V. (or its
successor approved by the membership of KDE e.V.), which shall
act as a proxy defined in Section 6 of version 3 of the license.

This library 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
Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public
License along with this library.  If not, see <http://www.gnu.org/licenses/>.
****************************************************************************/
#ifndef KWAYLAND_CLIENT_POINTERCONSTRAINTS_H
#define KWAYLAND_CLIENT_POINTERCONSTRAINTS_H

#include <QObject>

#include <KWayland/Client/kwaylandclient_export.h>

struct zwp_pointer_constraints_v1;
struct zwp_locked_pointer_v1;
struct zwp_confined_pointer_v1;

class QPointF;

namespace KWayland
{
namespace Client
{

class EventQueue;
class LockedPointer;
class Surface;
class Region;
class ConfinedPointer;
class Pointer;

class KWAYLANDCLIENT_EXPORT PointerConstraints : public QObject
{
    Q_OBJECT
public:
    explicit PointerConstraints(QObject *parent = nullptr);
    virtual ~PointerConstraints();

    void setup(zwp_pointer_constraints_v1 *pointerconstraints);
    bool isValid() const;
    void release();
    void destroy();

    void setEventQueue(EventQueue *queue);
    EventQueue *eventQueue();

    enum class LifeTime {
        OneShot,
        Persistent
    };

    LockedPointer *lockPointer(Surface *surface, Pointer *pointer, Region *region, LifeTime lifetime, QObject *parent = nullptr);

    ConfinedPointer *confinePointer(Surface *surface, Pointer *pointer, Region *region, LifeTime lifetime, QObject *parent = nullptr);

    operator zwp_pointer_constraints_v1*();
    operator zwp_pointer_constraints_v1*() const;

Q_SIGNALS:
    void removed();

private:
    class Private;
    QScopedPointer<Private> d;
};

class KWAYLANDCLIENT_EXPORT LockedPointer : public QObject
{
    Q_OBJECT
public:
    virtual ~LockedPointer();

    void setup(zwp_locked_pointer_v1 *lockedpointer);
    bool isValid() const;
    void release();
    void destroy();

    void setCursorPositionHint(const QPointF &surfaceLocal);

    void setRegion(Region *region);

    operator zwp_locked_pointer_v1*();
    operator zwp_locked_pointer_v1*() const;

Q_SIGNALS:
    void locked();

    void unlocked();

private:
    friend class PointerConstraints;
    explicit LockedPointer(QObject *parent = nullptr);
    class Private;
    QScopedPointer<Private> d;
};

class KWAYLANDCLIENT_EXPORT ConfinedPointer : public QObject
{
    Q_OBJECT
public:
    virtual ~ConfinedPointer();

    void setup(zwp_confined_pointer_v1 *confinedpointer);
    bool isValid() const;
    void release();
    void destroy();

    void setRegion(Region *region);

    operator zwp_confined_pointer_v1*();
    operator zwp_confined_pointer_v1*() const;

Q_SIGNALS:
    void confined();

    void unconfined();

private:
    friend class PointerConstraints;
    explicit ConfinedPointer(QObject *parent = nullptr);
    class Private;
    QScopedPointer<Private> d;
};


}
}

#endif