File indexing completed on 2024-04-21 16:16:18

0001 /*
0002     SPDX-FileCopyrightText: 2014 Martin Gräßlin <mgraesslin@kde.org>
0003     SPDX-FileCopyrightText: 2021 Vlad Zahorodnii <vlad.zahorodnii@kde.org>
0004 
0005     SPDX-License-Identifier: LGPL-2.1-only OR LGPL-3.0-only OR LicenseRef-KDE-Accepted-LGPL
0006 */
0007 #pragma once
0008 
0009 #include "kwin_export.h"
0010 
0011 #include <QMatrix4x4>
0012 #include <QObject>
0013 #include <QPoint>
0014 
0015 struct wl_client;
0016 struct wl_resource;
0017 
0018 namespace KWaylandServer
0019 {
0020 class AbstractDataSource;
0021 class AbstractDropHandler;
0022 class DragAndDropIcon;
0023 class DataDeviceInterface;
0024 class Display;
0025 class KeyboardInterface;
0026 class PointerInterface;
0027 class SeatInterfacePrivate;
0028 class SurfaceInterface;
0029 class TextInputV1Interface;
0030 class TextInputV2Interface;
0031 class TextInputV3Interface;
0032 class TouchInterface;
0033 
0034 /**
0035  * Describes the source types for axis events. This indicates to the
0036  * client how an axis event was physically generated; a client may
0037  * adjust the user interface accordingly. For example, scroll events
0038  * from a "finger" source may be in a smooth coordinate space with
0039  * kinetic scrolling whereas a "wheel" source may be in discrete steps
0040  * of a number of lines.
0041  *
0042  * The "continuous" axis source is a device generating events in a
0043  * continuous coordinate space, but using something other than a
0044  * finger. One example for this source is button-based scrolling where
0045  * the vertical motion of a device is converted to scroll events while
0046  * a button is held down.
0047  *
0048  * The "wheel tilt" axis source indicates that the actual device is a
0049  * wheel but the scroll event is not caused by a rotation but a
0050  * (usually sideways) tilt of the wheel.
0051  */
0052 enum class PointerAxisSource {
0053     Unknown,
0054     Wheel,
0055     Finger,
0056     Continuous,
0057     WheelTilt,
0058 };
0059 
0060 /**
0061  * This enum type is used to describe the state of a pointer button. It
0062  * is equivalent to the @c wl_pointer.button_state enum.
0063  */
0064 enum class PointerButtonState : quint32 {
0065     Released = 0,
0066     Pressed = 1,
0067 };
0068 
0069 /**
0070  * This enum type is used to describe the state of a keyboard key. It is
0071  * equivalent to the @c wl_keyboard.key_state enum.
0072  */
0073 enum class KeyboardKeyState : quint32 {
0074     Released = 0,
0075     Pressed = 1,
0076 };
0077 
0078 /**
0079  * @brief Represents a Seat on the Wayland Display.
0080  *
0081  * A Seat is a set of input devices (e.g. Keyboard, Pointer and Touch) the client can connect
0082  * to. The server needs to announce which input devices are supported and passes dedicated input
0083  * focus to a SurfaceInterface. Only the focused surface receives input events.
0084  *
0085  * The SeatInterface internally handles enter and release events when setting a focused surface.
0086  * Also it handles input translation from global to the local coordination, removing the need from
0087  * the user of the API to track the focused surfaces and can just interact with this class.
0088  *
0089  * To create a SeatInterface use @link Display::createSeat @endlink. Then one can set up what is
0090  * supported. Last but not least create needs to be called.
0091  *
0092  * @code
0093  * SeatInterface *seat = display->createSeat();
0094  * // set up
0095  * seat->setName(QStringLiteral("seat0"));
0096  * seat->setHasPointer(true);
0097  * seat->setHasKeyboard(true);
0098  * seat->setHasTouch(false);
0099  * // now fully create
0100  * seat->create();
0101  * @endcode
0102  *
0103  * To forward input events one needs to set the focused surface, update time stamp and then
0104  * forward the actual events:
0105  *
0106  * @code
0107  * // example for pointer
0108  * seat->setTimestamp(100);
0109  * seat->notifyPointerEnter(surface, QPointF(350, 210), QPointF(100, 200)); // surface at it's global position
0110  * seat->notifyPointerFrame();
0111  * seat->setTimestamp(110);
0112  * seat->notifyPointerButton(Qt::LeftButton, PointerButtonState::Pressed);
0113  * seat->notifyPointerFrame();
0114  * seat->setTimestamp(120);
0115  * seat->notifyPointerButton(Qt::LeftButton, PointerButtonState::Released);
0116  * seat->notifyPointerFrame();
0117  * @endcode
0118  *
0119  * @see KeyboardInterface
0120  * @see PointerInterface
0121  * @see TouchInterface
0122  * @see SurfaceInterface
0123  */
0124 class KWIN_EXPORT SeatInterface : public QObject
0125 {
0126     Q_OBJECT
0127 public:
0128     explicit SeatInterface(Display *display, QObject *parent = nullptr);
0129     virtual ~SeatInterface();
0130 
0131     Display *display() const;
0132     QString name() const;
0133     bool hasPointer() const;
0134     bool hasKeyboard() const;
0135     bool hasTouch() const;
0136 
0137     void setName(const QString &name);
0138     void setHasPointer(bool has);
0139     void setHasKeyboard(bool has);
0140     void setHasTouch(bool has);
0141 
0142     void setTimestamp(std::chrono::microseconds time);
0143     std::chrono::milliseconds timestamp() const;
0144 
0145     /**
0146      * @name Drag'n'Drop related methods
0147      */
0148     ///@{
0149     /**
0150      * @returns whether there is currently a drag'n'drop going on.
0151      * @see isDragPointer
0152      * @see isDragTouch
0153      * @see dragStarted
0154      * @see dragEnded
0155      */
0156     bool isDrag() const;
0157     /**
0158      * @returns whether the drag'n'drop is operated through the pointer device
0159      * @see isDrag
0160      * @see isDragTouch
0161      */
0162     bool isDragPointer() const;
0163     /**
0164      * @returns whether the drag'n'drop is operated through the touch device
0165      * @see isDrag
0166      * @see isDragPointer
0167      */
0168     bool isDragTouch() const;
0169     /**
0170      * @returns The transformation applied to go from global to local coordinates for drag motion events.
0171      * @see dragSurfaceTransformation
0172      */
0173     QMatrix4x4 dragSurfaceTransformation() const;
0174     /**
0175      * @returns The currently focused Surface for drag motion events.
0176      * @see dragSurfaceTransformation
0177      * @see dragSurfaceChanged
0178      */
0179     SurfaceInterface *dragSurface() const;
0180     /**
0181      * @returns The DataDeviceInterface which started the drag and drop operation.
0182      * @see isDrag
0183      */
0184     KWaylandServer::AbstractDataSource *dragSource() const;
0185     /**
0186      * Sets the current drag target to @p surface.
0187      *
0188      * Sends a drag leave event to the current target and an enter event to @p surface.
0189      * The enter position is derived from @p globalPosition and transformed by @p inputTransformation.
0190      */
0191     void setDragTarget(AbstractDropHandler *dropTarget, SurfaceInterface *surface, const QPointF &globalPosition, const QMatrix4x4 &inputTransformation);
0192     /**
0193      * Sets the current drag target to @p surface.
0194      *
0195      * Sends a drag leave event to the current target and an enter event to @p surface.
0196      * The enter position is derived from current global position and transformed by @p inputTransformation.
0197      */
0198     void setDragTarget(AbstractDropHandler *dropTarget, SurfaceInterface *surface, const QMatrix4x4 &inputTransformation = QMatrix4x4());
0199     ///@}
0200 
0201     AbstractDropHandler *dropHandlerForSurface(SurfaceInterface *surface) const;
0202 
0203     /**
0204      * If there is a current drag in progress, force it to cancel
0205      */
0206     void cancelDrag();
0207 
0208     /**
0209      * @name Pointer related methods
0210      */
0211     ///@{
0212     /**
0213      * Updates the global pointer @p pos.
0214      *
0215      * Sends a pointer motion event to the focused pointer surface.
0216      */
0217     void notifyPointerMotion(const QPointF &pos);
0218     /**
0219      * @returns the global pointer position
0220      */
0221     QPointF pointerPos() const;
0222     /**
0223      * Sets the focused pointer @p surface.
0224      * All pointer events will be sent to the @p surface till a new focused pointer surface gets
0225      * installed. When the focus pointer surface changes a leave event is sent to the previous
0226      * focused surface.
0227      *
0228      * To unset the focused pointer surface pass @c nullptr as @p surface.
0229      *
0230      * Pointer motion events are adjusted to the local position based on the @p surfacePosition.
0231      * If the surface changes it's position in the global coordinate system
0232      * use setFocusedPointerSurfacePosition to update.
0233      * The surface position is used to create the base transformation matrix to go from global
0234      * to surface local coordinates. The default generated matrix is a translation with
0235      * negative @p surfacePosition.
0236      *
0237      * @param surface The surface which should become the new focused pointer surface.
0238      * @param surfacePosition The position of the surface in the global coordinate system
0239      *
0240      * @see setPointerPos
0241      * @see focucedPointerSurface
0242      * @see focusedPointer
0243      * @see setFocusedPointerSurfacePosition
0244      * @see focusedPointerSurfacePosition
0245      * @see setFocusedPointerSurfaceTransformation
0246      * @see focusedPointerSurfaceTransformation
0247      */
0248     void notifyPointerEnter(SurfaceInterface *surface, const QPointF &position, const QPointF &surfacePosition = QPointF());
0249     /**
0250      * Sets the focused pointer @p surface.
0251      * All pointer events will be sent to the @p surface till a new focused pointer surface gets
0252      * installed. When the focus pointer surface changes a leave event is sent to the previous
0253      * focused surface.
0254      *
0255      * To unset the focused pointer surface pass @c nullptr as @p surface.
0256      *
0257      * Pointer motion events are adjusted to the local position based on the @p transformation.
0258      * If the surface changes it's position in the global coordinate system
0259      * use setFocusedPointerSurfaceTransformation to update.
0260      *
0261      * @param surface The surface which should become the new focused pointer surface.
0262      * @param transformation The transformation to transform global into local coordinates
0263      *
0264      * @see setPointerPos
0265      * @see focucedPointerSurface
0266      * @see focusedPointer
0267      * @see setFocusedPointerSurfacePosition
0268      * @see focusedPointerSurfacePosition
0269      * @see setFocusedPointerSurfaceTransformation
0270      * @see focusedPointerSurfaceTransformation
0271      */
0272     void notifyPointerEnter(SurfaceInterface *surface, const QPointF &position, const QMatrix4x4 &transformation);
0273     void notifyPointerLeave();
0274     /**
0275      * @returns The currently focused pointer surface, that is the surface receiving pointer events.
0276      * @see notifyPointerEnter
0277      * @see notifyPointerLeave
0278      */
0279     SurfaceInterface *focusedPointerSurface() const;
0280     PointerInterface *pointer() const;
0281     /**
0282      * Updates the global position of the currently focused pointer surface.
0283      *
0284      * Updating the focused surface position also generates a new transformation matrix.
0285      * The default generated matrix is a translation with negative @p surfacePosition.
0286      * If a different transformation is required a dedicated call to
0287      * @link setFocusedPointerSurfaceTransformation is required.
0288      *
0289      * @param surfacePosition The new global position of the focused pointer surface
0290      * @see focusedPointerSurface
0291      * @see focusedPointerSurfaceTransformation
0292      * @see setFocusedPointerSurfaceTransformation
0293      */
0294     void setFocusedPointerSurfacePosition(const QPointF &surfacePosition);
0295     /**
0296      * @returns The position of the focused pointer surface in global coordinates.
0297      * @see setFocusedPointerSurfacePosition
0298      * @see focusedPointerSurfaceTransformation
0299      */
0300     QPointF focusedPointerSurfacePosition() const;
0301     /**
0302      * Sets the @p transformation for going from global to local coordinates.
0303      *
0304      * The default transformation gets generated from the surface position and reset whenever
0305      * the surface position changes.
0306      *
0307      * @see focusedPointerSurfaceTransformation
0308      * @see focusedPointerSurfacePosition
0309      * @see setFocusedPointerSurfacePosition
0310      */
0311     void setFocusedPointerSurfaceTransformation(const QMatrix4x4 &transformation);
0312     /**
0313      * @returns The transformation applied to pointer position to go from global to local coordinates.
0314      * @see setFocusedPointerSurfaceTransformation
0315      */
0316     QMatrix4x4 focusedPointerSurfaceTransformation() const;
0317     /**
0318      * Marks the specified @a button as pressed or released based on @a state.
0319      */
0320     void notifyPointerButton(quint32 button, PointerButtonState state);
0321     /**
0322      * @overload
0323      */
0324     void notifyPointerButton(Qt::MouseButton button, PointerButtonState state);
0325     void notifyPointerFrame();
0326     /**
0327      * @returns whether the @p button is pressed
0328      */
0329     bool isPointerButtonPressed(quint32 button) const;
0330     /**
0331      * @returns whether the @p button is pressed
0332      */
0333     bool isPointerButtonPressed(Qt::MouseButton button) const;
0334     /**
0335      * @returns the last serial for @p button.
0336      */
0337     quint32 pointerButtonSerial(quint32 button) const;
0338     /**
0339      * @returns the last serial for @p button.
0340      */
0341     quint32 pointerButtonSerial(Qt::MouseButton button) const;
0342     /**
0343      * Sends axis events to the currently focused pointer surface.
0344      *
0345      * @param orientation The scroll axis.
0346      * @param delta The length of a vector along the specified axis @p orientation.
0347      * @param deltaV120 The high-resolution scrolling axis value.
0348      * @param source Describes how the axis event was physically generated.
0349      */
0350     void notifyPointerAxis(Qt::Orientation orientation, qreal delta, qint32 deltaV120, PointerAxisSource source);
0351     /**
0352      * @returns true if there is a pressed button with the given @p serial
0353      */
0354     bool hasImplicitPointerGrab(quint32 serial) const;
0355 
0356     /**
0357      * A relative motion is in the same dimension as regular motion events,
0358      * except they do not represent an absolute position. For example,
0359      * moving a pointer from (x, y) to (x', y') would have the equivalent
0360      * relative motion (x' - x, y' - y). If a pointer motion caused the
0361      * absolute pointer position to be clipped by for example the edge of the
0362      * monitor, the relative motion is unaffected by the clipping and will
0363      * represent the unclipped motion.
0364      *
0365      * This method also contains non-accelerated motion deltas (@p deltaNonAccelerated).
0366      * The non-accelerated delta is, when applicable, the regular pointer motion
0367      * delta as it was before having applied motion acceleration and other
0368      * transformations such as normalization.
0369      *
0370      * Note that the non-accelerated delta does not represent 'raw' events as
0371      * they were read from some device. Pointer motion acceleration is device-
0372      * and configuration-specific and non-accelerated deltas and accelerated
0373      * deltas may have the same value on some devices.
0374      *
0375      * Relative motions are not coupled to wl_pointer.motion events (see {@link setPointerPos},
0376      * and can be sent in combination with such events, but also independently. There may
0377      * also be scenarios where wl_pointer.motion is sent, but there is no
0378      * relative motion. The order of an absolute and relative motion event
0379      * originating from the same physical motion is not guaranteed.
0380      *
0381      * Sending relative pointer events only makes sense if the RelativePointerManagerInterface
0382      * is created on the Display.
0383      *
0384      * @param delta Motion vector
0385      * @param deltaNonAccelerated non-accelerated motion vector
0386      * @param microseconds timestamp with microseconds granularity
0387      * @see setPointerPos
0388      */
0389     void relativePointerMotion(const QPointF &delta, const QPointF &deltaNonAccelerated, std::chrono::microseconds timestamp);
0390 
0391     /**
0392      * Starts a multi-finger swipe gesture for the currently focused pointer surface.
0393      *
0394      * Such gestures are normally reported through dedicated input devices such as touchpads.
0395      *
0396      * The gesture is usually initiated by multiple fingers moving in the
0397      * same direction but once initiated the direction may change.
0398      * The precise conditions of when such a gesture is detected are
0399      * implementation-dependent.
0400      *
0401      * Only one gesture (either swipe or pinch or hold) can be active at a given time.
0402      *
0403      * @param fingerCount The number of fingers involved in this multi-finger touchpad gesture
0404      *
0405      * @see PointerGesturesInterface
0406      * @see focusedPointerSurface
0407      * @see updatePointerSwipeGesture
0408      * @see endPointerSwipeGesture
0409      * @see cancelPointerSwipeGesture
0410      * @see startPointerPinchGesture
0411      */
0412     void startPointerSwipeGesture(quint32 fingerCount);
0413 
0414     /**
0415      * The position of the logical center of the currently active multi-finger swipe gesture changes.
0416      *
0417      * @param delta coordinates are relative coordinates of the logical center of the gesture compared to the previous event.
0418      * @see startPointerSwipeGesture
0419      * @see endPointerSwipeGesture
0420      * @see cancelPointerSwipeGesture
0421      */
0422     void updatePointerSwipeGesture(const QPointF &delta);
0423 
0424     /**
0425      * The multi-finger swipe gesture ended. This may happen when one or more fingers are lifted.
0426      * @see startPointerSwipeGesture
0427      * @see updatePointerSwipeGesture
0428      * @see cancelPointerSwipeGesture
0429      * @see 5.29
0430      */
0431     void endPointerSwipeGesture();
0432 
0433     /**
0434      * The multi-finger swipe gestures ended and got cancelled by the Wayland compositor.
0435      * @see startPointerSwipeGesture
0436      * @see updatePointerSwipeGesture
0437      * @see endPointerSwipeGesture
0438      */
0439     void cancelPointerSwipeGesture();
0440 
0441     /**
0442      * Starts a multi-finch pinch gesture for the currently focused pointer surface.
0443      *
0444      * Such gestures are normally reported through dedicated input devices such as touchpads.
0445      *
0446      * The gesture is usually initiated by multiple fingers moving towards
0447      * each other or away from each other, or by two or more fingers rotating
0448      * around a logical center of gravity. The precise conditions of when
0449      * such a gesture is detected are implementation-dependent.
0450      *
0451      * Only one gesture (either swipe or pinch or hold) can be active at a given time.
0452      *
0453      * @param fingerCount The number of fingers involved in this multi-touch touchpad gesture
0454      *
0455      * @see PointerGesturesInterface
0456      * @see focusedPointerSurface
0457      * @see updatePointerPinchGesture
0458      * @see endPointerPinchGesture
0459      * @see cancelPointerPinchGesture
0460      * @see startPointerSwipeGesture
0461      */
0462     void startPointerPinchGesture(quint32 fingerCount);
0463 
0464     /**
0465      * The position of the logical center, the rotation or the relative scale of this
0466      * multi-finger pinch gesture changes.
0467      *
0468      * @param delta coordinates are relative coordinates of the logical center of the gesture compared to the previous event.
0469      * @param scale an absolute scale compared to the gesture start
0470      * @param rotation relative angle in degrees clockwise compared to the previous start of update
0471      * @see startPointerPinchGesture
0472      * @see endPointerPinchGesture
0473      * @see cancelPointerPinchGesture
0474      */
0475     void updatePointerPinchGesture(const QPointF &delta, qreal scale, qreal rotation);
0476 
0477     /**
0478      *
0479      * @see startPointerPinchGesture
0480      * @see updatePointerPinchGesture
0481      * @see cancelPointerPinchGesture
0482      */
0483     void endPointerPinchGesture();
0484 
0485     /**
0486      *
0487      * @see startPointerPinchGesture
0488      * @see updatePointerPinchGesture
0489      * @see endPointerPinchGesture
0490      */
0491     void cancelPointerPinchGesture();
0492 
0493     /**
0494      * Starts a multi-finger hold gesture for the currently focused pointer surface.
0495      *
0496      * Such gestures are normally reported through dedicated input devices such as touchpads.
0497      *
0498      * The gesture is usually initiated by multiple fingers being held down on the touchpad.
0499      * The precise conditions of when such a gesture is detected are
0500      * implementation-dependent.
0501      *
0502      * Only one gesture (either swipe or pinch or hold) can be active at a given time.
0503      *
0504      * @param fingerCount The number of fingers involved in this multi-finger touchpad gesture
0505      *
0506      * @see PointerGesturesInterface
0507      * @see focusedPointerSurface
0508      * @see endPointerHoldeGesture
0509      * @see cancelPointerHoldGesture
0510      */
0511     void startPointerHoldGesture(quint32 fingerCount);
0512 
0513     /**
0514      * The multi-finger hold gesture ended. This may happen when one or more fingers are lifted.
0515      * @see startPointerHoldGesture
0516      * @see cancelPointerHoldGesture
0517      */
0518     void endPointerHoldGesture();
0519 
0520     /**
0521      * The multi-finger swipe gestures ended and got cancelled by the Wayland compositor.
0522      * @see startPointerHoldGesture
0523      * @see endPointerHoldGesture
0524      */
0525     void cancelPointerHoldGesture();
0526     ///@}
0527 
0528     /**
0529      * Passes keyboard focus to @p surface.
0530      *
0531      * If the SeatInterface has the keyboard capability, also the focused
0532      * text input surface will be set to @p surface.
0533      *
0534      * @see focusedKeyboardSurface
0535      * @see hasKeyboard
0536      * @see setFocusedTextInputSurface
0537      */
0538     void setFocusedKeyboardSurface(SurfaceInterface *surface);
0539     SurfaceInterface *focusedKeyboardSurface() const;
0540     KeyboardInterface *keyboard() const;
0541     void notifyKeyboardKey(quint32 keyCode, KeyboardKeyState state);
0542     void notifyKeyboardModifiers(quint32 depressed, quint32 latched, quint32 locked, quint32 group);
0543     ///@}
0544 
0545     /**
0546      * @name  touch related methods
0547      */
0548     ///@{
0549     void setFocusedTouchSurface(SurfaceInterface *surface, const QPointF &surfacePosition = QPointF());
0550     SurfaceInterface *focusedTouchSurface() const;
0551     TouchInterface *touch() const;
0552     void setFocusedTouchSurfacePosition(const QPointF &surfacePosition);
0553     QPointF focusedTouchSurfacePosition() const;
0554     void notifyTouchDown(qint32 id, const QPointF &globalPosition);
0555     void notifyTouchUp(qint32 id);
0556     void notifyTouchMotion(qint32 id, const QPointF &globalPosition);
0557     void notifyTouchFrame();
0558     void notifyTouchCancel();
0559     bool isTouchSequence() const;
0560     QPointF firstTouchPointPosition() const;
0561     /**
0562      * @returns true if there is a touch sequence going on associated with a touch
0563      * down of the given @p serial.
0564      */
0565     bool hasImplicitTouchGrab(quint32 serial) const;
0566     ///@}
0567 
0568     /**
0569      * @name Text input related methods.
0570      */
0571     ///@{
0572     /**
0573      * Passes text input focus to @p surface.
0574      *
0575      * If the SeatInterface has the keyboard capability this method will
0576      * be invoked automatically when setting the focused keyboard surface.
0577      *
0578      * In case there is a TextInputV2Interface for the @p surface, the enter
0579      * event will be triggered on the TextInputV2Interface for @p surface.
0580      * The focusedTextInput will be set to that TextInputV2Interface. If there
0581      * is no TextInputV2Interface for that @p surface, it might get updated later on.
0582      * In both cases the signal focusedTextInputChanged will be emitted.
0583      *
0584      * @see focusedTextInputSurface
0585      * @see focusedTextInput
0586      * @see focusedTextInputChanged
0587      * @see setFocusedKeyboardSurface
0588      */
0589     void setFocusedTextInputSurface(SurfaceInterface *surface);
0590     /**
0591      * @returns The SurfaceInterface which is currently focused for text input.
0592      * @see setFocusedTextInputSurface
0593      */
0594     SurfaceInterface *focusedTextInputSurface() const;
0595 
0596     TextInputV1Interface *textInputV1() const;
0597 
0598     /**
0599      * The currently focused text input, may be @c null even if there is a
0600      * focused text input surface set.
0601      *
0602      * The focused text input might not be enabled for the {@link focusedTextInputSurface}.
0603      * It is recommended to check the enabled state before interacting with the
0604      * TextInputV2Interface.
0605      *
0606      * @see focusedTextInputChanged
0607      * @see focusedTextInputSurface
0608      */
0609     TextInputV2Interface *textInputV2() const;
0610 
0611     TextInputV3Interface *textInputV3() const;
0612     ///@}
0613 
0614     /**
0615      * @returns The DataDeviceInterface holding the current clipboard selection.
0616      * @see selectionChanged
0617      * @see setSelection
0618      * This may be null
0619      */
0620     KWaylandServer::AbstractDataSource *selection() const;
0621 
0622     /**
0623      * This method allows to manually set the @p dataDevice for the current clipboard selection.
0624      * The clipboard selection is handled automatically in SeatInterface.
0625      * If a DataDeviceInterface belonging to the current focused KeyboardInterface
0626      * sets a selection, the current clipboard selection will be updated automatically.
0627      * With this method it's possible to override the automatic clipboard update for
0628      * e.g. the case of a clipboard manager.
0629      *
0630      * @param dataDevice Sets the current clipboard selection.
0631      * @see selection
0632      * @see selectionChanged
0633      */
0634     void setSelection(AbstractDataSource *selection);
0635 
0636     KWaylandServer::AbstractDataSource *primarySelection() const;
0637     void setPrimarySelection(AbstractDataSource *selection);
0638 
0639     void startDrag(AbstractDataSource *source, SurfaceInterface *sourceSurface, int dragSerial = -1, DragAndDropIcon *dragIcon = nullptr);
0640 
0641     /**
0642      * Returns the additional icon attached to the cursor during a drag-and-drop operation.
0643      * This function returns @c null if no drag-and-drop is active or no icon has been attached.
0644      */
0645     DragAndDropIcon *dragIcon() const;
0646 
0647     static SeatInterface *get(wl_resource *native);
0648 
0649 Q_SIGNALS:
0650     void nameChanged(const QString &);
0651     void hasPointerChanged(bool);
0652     void hasKeyboardChanged(bool);
0653     void hasTouchChanged(bool);
0654     void pointerPosChanged(const QPointF &pos);
0655     void touchMoved(qint32 id, quint32 serial, const QPointF &globalPosition);
0656     void timestampChanged();
0657 
0658     /**
0659      * Emitted whenever the selection changes
0660      * @see selection
0661      * @see setSelection
0662      */
0663     void selectionChanged(KWaylandServer::AbstractDataSource *);
0664 
0665     /**
0666      * Emitted whenever the primary selection changes
0667      * @see primarySelection
0668      */
0669     void primarySelectionChanged(KWaylandServer::AbstractDataSource *);
0670 
0671     /**
0672      * Emitted when a drag'n'drop operation is started
0673      * @see dragEnded
0674      */
0675     void dragStarted();
0676     /**
0677      * Emitted when a drag'n'drop operation ended, either by dropping or canceling.
0678      * @see dragStarted
0679      */
0680     void dragEnded();
0681     /**
0682      * Emitted whenever the drag surface for motion events changed.
0683      * @see dragSurface
0684      */
0685     void dragSurfaceChanged();
0686 
0687     /** Emitted when a drop ocurrs in a drag'n'drop operation. This is emitted
0688      * before dragEnded
0689      */
0690     void dragDropped();
0691     /**
0692      * Emitted whenever the focused text input changed.
0693      * @see focusedTextInput
0694      */
0695     void focusedTextInputSurfaceChanged();
0696     /**
0697      * Emitted whenever the focused keyboard is about to change.
0698      * @see focusedKeyboardSurface
0699      */
0700     void focusedKeyboardSurfaceAboutToChange(SurfaceInterface *nextSurface);
0701 
0702 private:
0703     std::unique_ptr<SeatInterfacePrivate> d;
0704     friend class SeatInterfacePrivate;
0705 };
0706 
0707 }
0708 
0709 Q_DECLARE_METATYPE(KWaylandServer::SeatInterface *)