File indexing completed on 2024-11-10 04:56:32

 /*
     KWin - the KDE window manager
     This file is part of the KDE project.
 
     SPDX-FileCopyrightText: 2014 Martin Gräßlin <mgraesslin@kde.org>
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 #pragma once
 
 #include "input.h"
 
 #include <libinput.h>
 
 namespace KWin
 {
 namespace LibInput
 {
 
 class Device;
 
 class Event
 {
 public:
     virtual ~Event();
 
     libinput_event_type type() const;
     Device *device() const;
     libinput_device *nativeDevice() const;
 
     operator libinput_event *()
     {
         return m_event;
     }
     operator libinput_event *() const
     {
         return m_event;
     }
 
     static std::unique_ptr<Event> create(libinput_event *event);
 
 protected:
     Event(libinput_event *event, libinput_event_type type);
 
 private:
     libinput_event *m_event;
     libinput_event_type m_type;
     mutable Device *m_device;
 };
 
 class KeyEvent : public Event
 {
 public:
     KeyEvent(libinput_event *event);
     ~KeyEvent() override;
 
     uint32_t key() const;
     InputRedirection::KeyboardKeyState state() const;
     std::chrono::microseconds time() const;
 
     operator libinput_event_keyboard *()
     {
         return m_keyboardEvent;
     }
     operator libinput_event_keyboard *() const
     {
         return m_keyboardEvent;
     }
 
 private:
     libinput_event_keyboard *m_keyboardEvent;
 };
 
 class PointerEvent : public Event
 {
 public:
     PointerEvent(libinput_event *event, libinput_event_type type);
     ~PointerEvent() override;
 
     QPointF absolutePos() const;
     QPointF absolutePos(const QSize &size) const;
     QPointF delta() const;
     QPointF deltaUnaccelerated() const;
     uint32_t button() const;
     InputRedirection::PointerButtonState buttonState() const;
     std::chrono::microseconds time() const;
     QList<InputRedirection::PointerAxis> axis() const;
     qreal scrollValue(InputRedirection::PointerAxis a) const;
     qint32 scrollValueV120(InputRedirection::PointerAxis axis) const;
 
     operator libinput_event_pointer *()
     {
         return m_pointerEvent;
     }
     operator libinput_event_pointer *() const
     {
         return m_pointerEvent;
     }
 
 private:
     libinput_event_pointer *m_pointerEvent;
 };
 
 class TouchEvent : public Event
 {
 public:
     TouchEvent(libinput_event *event, libinput_event_type type);
     ~TouchEvent() override;
 
     std::chrono::microseconds time() const;
     QPointF absolutePos() const;
     QPointF absolutePos(const QSize &size) const;
     qint32 id() const;
 
     operator libinput_event_touch *()
     {
         return m_touchEvent;
     }
     operator libinput_event_touch *() const
     {
         return m_touchEvent;
     }
 
 private:
     libinput_event_touch *m_touchEvent;
 };
 
 class GestureEvent : public Event
 {
 public:
     ~GestureEvent() override;
 
     std::chrono::microseconds time() const;
     int fingerCount() const;
 
     QPointF delta() const;
 
     bool isCancelled() const;
 
     operator libinput_event_gesture *()
     {
         return m_gestureEvent;
     }
     operator libinput_event_gesture *() const
     {
         return m_gestureEvent;
     }
 
 protected:
     GestureEvent(libinput_event *event, libinput_event_type type);
     libinput_event_gesture *m_gestureEvent;
 };
 
 class PinchGestureEvent : public GestureEvent
 {
 public:
     PinchGestureEvent(libinput_event *event, libinput_event_type type);
     ~PinchGestureEvent() override;
 
     qreal scale() const;
     qreal angleDelta() const;
 };
 
 class SwipeGestureEvent : public GestureEvent
 {
 public:
     SwipeGestureEvent(libinput_event *event, libinput_event_type type);
     ~SwipeGestureEvent() override;
 };
 
 class HoldGestureEvent : public GestureEvent
 {
 public:
     HoldGestureEvent(libinput_event *event, libinput_event_type type);
     ~HoldGestureEvent() override;
 };
 
 class SwitchEvent : public Event
 {
 public:
     SwitchEvent(libinput_event *event, libinput_event_type type);
     ~SwitchEvent() override;
 
     enum class State {
         Off,
         On
     };
     State state() const;
 
     std::chrono::microseconds time() const;
 
 private:
     libinput_event_switch *m_switchEvent;
 };
 
 class TabletToolEvent : public Event
 {
 public:
     TabletToolEvent(libinput_event *event, libinput_event_type type);
 
     std::chrono::microseconds time() const
     {
         return std::chrono::microseconds(libinput_event_tablet_tool_get_time_usec(m_tabletToolEvent));
     }
     bool xHasChanged() const
     {
         return libinput_event_tablet_tool_x_has_changed(m_tabletToolEvent);
     }
     bool yHasChanged() const
     {
         return libinput_event_tablet_tool_y_has_changed(m_tabletToolEvent);
     }
     bool pressureHasChanged() const
     {
         return libinput_event_tablet_tool_pressure_has_changed(m_tabletToolEvent);
     }
     bool distanceHasChanged() const
     {
         return libinput_event_tablet_tool_distance_has_changed(m_tabletToolEvent);
     }
     bool tiltXHasChanged() const
     {
         return libinput_event_tablet_tool_tilt_x_has_changed(m_tabletToolEvent);
     }
     bool tiltYHasChanged() const
     {
         return libinput_event_tablet_tool_tilt_y_has_changed(m_tabletToolEvent);
     }
     bool rotationHasChanged() const
     {
         return libinput_event_tablet_tool_rotation_has_changed(m_tabletToolEvent);
     }
     bool sliderHasChanged() const
     {
         return libinput_event_tablet_tool_slider_has_changed(m_tabletToolEvent);
     }
 
     // uncomment when depending on libinput 1.14 or when implementing totems
     //     bool sizeMajorHasChanged() const { return
     //     libinput_event_tablet_tool_size_major_has_changed(m_tabletToolEvent); } bool
     //     sizeMinorHasChanged() const { return
     //     libinput_event_tablet_tool_size_minor_has_changed(m_tabletToolEvent); }
     bool wheelHasChanged() const
     {
         return libinput_event_tablet_tool_wheel_has_changed(m_tabletToolEvent);
     }
     QPointF position() const
     {
         return {libinput_event_tablet_tool_get_x(m_tabletToolEvent),
                 libinput_event_tablet_tool_get_y(m_tabletToolEvent)};
     }
     QPointF delta() const
     {
         return {libinput_event_tablet_tool_get_dx(m_tabletToolEvent),
                 libinput_event_tablet_tool_get_dy(m_tabletToolEvent)};
     }
     qreal pressure() const
     {
         return libinput_event_tablet_tool_get_pressure(m_tabletToolEvent);
     }
     qreal distance() const
     {
         return libinput_event_tablet_tool_get_distance(m_tabletToolEvent);
     }
     int xTilt() const
     {
         return libinput_event_tablet_tool_get_tilt_x(m_tabletToolEvent);
     }
     int yTilt() const
     {
         return libinput_event_tablet_tool_get_tilt_y(m_tabletToolEvent);
     }
     qreal rotation() const
     {
         return libinput_event_tablet_tool_get_rotation(m_tabletToolEvent);
     }
     qreal sliderPosition() const
     {
         return libinput_event_tablet_tool_get_slider_position(m_tabletToolEvent);
     }
     // Uncomment when depending on libinput 1.14 or when implementing totems
     // qreal sizeMajor() const { return
     //     libinput_event_tablet_tool_get_size_major(m_tabletToolEvent); }
     // qreal sizeMinor() const {
     //     return libinput_event_tablet_tool_get_size_minor(m_tabletToolEvent); }
     qreal wheelDelta() const
     {
         return libinput_event_tablet_tool_get_wheel_delta(m_tabletToolEvent);
     }
     int wheelDeltaDiscrete() const
     {
         return libinput_event_tablet_tool_get_wheel_delta_discrete(m_tabletToolEvent);
     }
 
     bool isTipDown() const
     {
         const auto state = libinput_event_tablet_tool_get_tip_state(m_tabletToolEvent);
         return state == LIBINPUT_TABLET_TOOL_TIP_DOWN;
     }
     bool isNearby() const
     {
         const auto state = libinput_event_tablet_tool_get_proximity_state(m_tabletToolEvent);
         return state == LIBINPUT_TABLET_TOOL_PROXIMITY_STATE_IN;
     }
 
     QPointF transformedPosition(const QSize &size) const;
 
     struct libinput_tablet_tool *tool()
     {
         return libinput_event_tablet_tool_get_tool(m_tabletToolEvent);
     }
 
 private:
     libinput_event_tablet_tool *m_tabletToolEvent;
 };
 
 class TabletToolButtonEvent : public Event
 {
 public:
     TabletToolButtonEvent(libinput_event *event, libinput_event_type type);
 
     uint buttonId() const
     {
         return libinput_event_tablet_tool_get_button(m_tabletToolEvent);
     }
 
     bool isButtonPressed() const
     {
         const auto state = libinput_event_tablet_tool_get_button_state(m_tabletToolEvent);
         return state == LIBINPUT_BUTTON_STATE_PRESSED;
     }
 
     struct libinput_tablet_tool *tool()
     {
         return libinput_event_tablet_tool_get_tool(m_tabletToolEvent);
     }
 
     std::chrono::microseconds time() const
     {
         return std::chrono::microseconds(libinput_event_tablet_tool_get_time_usec(m_tabletToolEvent));
     }
 
 private:
     libinput_event_tablet_tool *m_tabletToolEvent;
 };
 
 class TabletPadRingEvent : public Event
 {
 public:
     TabletPadRingEvent(libinput_event *event, libinput_event_type type);
 
     int position() const
     {
         return libinput_event_tablet_pad_get_ring_position(m_tabletPadEvent);
     }
     int number() const
     {
         return libinput_event_tablet_pad_get_ring_number(m_tabletPadEvent);
     }
     libinput_tablet_pad_ring_axis_source source() const
     {
         return libinput_event_tablet_pad_get_ring_source(m_tabletPadEvent);
     }
     std::chrono::microseconds time() const
     {
         return std::chrono::microseconds(libinput_event_tablet_pad_get_time_usec(m_tabletPadEvent));
     }
 
 private:
     libinput_event_tablet_pad *m_tabletPadEvent;
 };
 
 class TabletPadStripEvent : public Event
 {
 public:
     TabletPadStripEvent(libinput_event *event, libinput_event_type type);
 
     int position() const
     {
         return libinput_event_tablet_pad_get_strip_position(m_tabletPadEvent);
     }
     int number() const
     {
         return libinput_event_tablet_pad_get_strip_number(m_tabletPadEvent);
     }
     libinput_tablet_pad_strip_axis_source source() const
     {
         return libinput_event_tablet_pad_get_strip_source(m_tabletPadEvent);
     }
     std::chrono::microseconds time() const
     {
         return std::chrono::microseconds(libinput_event_tablet_pad_get_time_usec(m_tabletPadEvent));
     }
 
 private:
     libinput_event_tablet_pad *m_tabletPadEvent;
 };
 
 class TabletPadButtonEvent : public Event
 {
 public:
     TabletPadButtonEvent(libinput_event *event, libinput_event_type type);
 
     uint buttonId() const
     {
         return libinput_event_tablet_pad_get_button_number(m_tabletPadEvent);
     }
     bool isButtonPressed() const
     {
         const auto state = libinput_event_tablet_pad_get_button_state(m_tabletPadEvent);
         return state == LIBINPUT_BUTTON_STATE_PRESSED;
     }
     std::chrono::microseconds time() const
     {
         return std::chrono::microseconds(libinput_event_tablet_pad_get_time_usec(m_tabletPadEvent));
     }
 
 private:
     libinput_event_tablet_pad *m_tabletPadEvent;
 };
 
 inline libinput_event_type Event::type() const
 {
     return m_type;
 }
 
 }
 }