1. 16 Jul, 2020 1 commit
  2. 15 Jul, 2020 1 commit
  3. 29 Apr, 2020 1 commit
  4. 16 Mar, 2020 1 commit
  5. 23 Jan, 2020 1 commit
  6. 17 May, 2019 1 commit
    • Vlad Zahorodnii's avatar
      Allow compositors to send discrete axis values · ddff2c06
      Vlad Zahorodnii authored
      Summary:
      So far not all v5 features were implemented because most of them are
      optional. But given that XWayland needs axis_discrete event maybe it's
      time to implement them.
      
      CCBUG: 404152
      
      Reviewers: #kwin, davidedmundson
      
      Reviewed By: #kwin, davidedmundson
      
      Subscribers: davidedmundson, mthw, kde-frameworks-devel
      
      Tags: #frameworks
      
      Differential Revision: https://phabricator.kde.org/D18933
      ddff2c06
  7. 06 Feb, 2019 1 commit
    • Roman Gilg's avatar
      [server] Add surface data proxy mechanism · 0b33f078
      Roman Gilg authored
      Summary:
      Allows a compositor to set a proxy surface to handle drag and drop
      operations place of the actual surface the drag originated from.
      
      One proxy surface can handle multiple origin surfaces at the same time. These
      need to get registered once. The active remote surface gets set when a pointer
      button is pressed on the surface.
      
      Test Plan: Manually with KWin's Xwayland DnD patches.
      
      Reviewers: #kwin
      
      Subscribers: davidedmundson, kde-frameworks-devel
      
      Tags: #frameworks
      
      Differential Revision: https://phabricator.kde.org/D15421
      0b33f078
  8. 24 Oct, 2018 1 commit
    • Roman Gilg's avatar
      [server] Respect input region of sub-surfaces on pointer surface focus · 24bdc067
      Roman Gilg authored
      Summary:
      KWayland takes always the top-most child surface at a given position for its
      pointer input. But if a sub-surface sets its input region, it should not select
      this one when the position is out of its input region, but rather try the
      surface below.
      
      Test Plan:
      My testing was only on my Xwayland branch. Supposed to also fix a problem
      with Firefox native Wayland port.
      
      Reviewers: #frameworks, graesslin, davidedmundson
      
      Reviewed By: davidedmundson
      
      Subscribers: davidedmundson, zzag, kde-frameworks-devel, graesslin, plasma-devel
      
      Tags: #frameworks, #plasma_on_wayland
      
      Differential Revision: https://phabricator.kde.org/D7038
      24bdc067
  9. 26 Jun, 2018 1 commit
    • Roman Gilg's avatar
      [server] Send frame event instead of flush on relative pointer motion · 5e195c2a
      Roman Gilg authored
      Summary:
      This solves for me not working relative pointer motion with grab/lock in
      Xwayland applications.
      
      Looking at the Xwayland code it is clear, that it expects a frame event on
      wl_pointer versions 5 and above after relative motion events. wl_pointer
      version 5 support was added to KWayland in b6bd28ab.
      
      If the cursor is locked no absolute motion events are sent. In this case to
      make sure relative motion events are processed by the client, send the frame
      event after every relative motion.
      
      BUG: 395815
      
      Test Plan: Manually with Neverball in Xwayland mode.
      
      Reviewers: #plasma, #kwin, #frameworks, davidedmundson
      
      Reviewed By: #plasma, #kwin, davidedmundson
      
      Subscribers: davidedmundson, kde-frameworks-devel
      
      Tags: #frameworks
      
      Maniphest Tasks: T8923
      
      Differential Revision: https://phabricator.kde.org/D13257
      5e195c2a
  10. 04 Mar, 2018 1 commit
    • Martin Flöser's avatar
      [server] Add support for the frame semantics of Pointer version 5 · b6bd28ab
      Martin Flöser authored
      Summary:
      This change implements the required changes for wl_seat version 5.
      There seem to be applications which require version 5 and refuse to
      start if the server doesn't provide it. Thus we need to provide it.
      
      The main difference with version 5 is that pointer need to send a
      frame event after each logical group of events. As we don't support the
      new events from version 5 yet, we just emit the frame after each event
      and implement the suggested semantics for the enter/leave behavior.
      
      To really make use of this, we will have to implement additions in the
      API and then in KWin to expose the new API elements. But to just support
      the semantics we don't need it.
      
      BUG: 389189
      FIXED-IN: 5.45
      
      Test Plan: Extended autotest
      
      Reviewers: #kwin, #plasma, #frameworks
      
      Subscribers: plasma-devel
      
      Tags: #frameworks, #plasma
      
      Differential Revision: https://phabricator.kde.org/D10235
      b6bd28ab
  11. 19 Jul, 2017 1 commit
  12. 24 Nov, 2016 1 commit
    • Martin Flöser's avatar
      Implementation of PointerConstraints protcol · a6825301
      Martin Flöser authored
      Summary:
      The pointer constraints protocol is an unstable protocol and thus
      the implementation follows the semantics of unstable protocols.
      
      The protocol allows to create a constraint on the pointer - either a
      lock or a confinement on a surface. Those are not activated at once, but
      when the compositor actively grants it.
      
      During lock no further pointer motion is emitted, during confinement the
      pointer is kept in a certain area.
      
      This implements T4451.
      
      Reviewers: #plasma_on_wayland
      
      Subscribers: plasma-devel
      
      Tags: #plasma_on_wayland
      
      Differential Revision: https://phabricator.kde.org/D3466
      a6825301
  13. 07 Nov, 2016 1 commit
    • Martin Flöser's avatar
      Implementation of PointerGestures protocol · 75acb783
      Martin Flöser authored
      Summary:
      Pointer gestures are created for a pointer and there are two types of
      gestures: swipe and pinch.
      
      At a given time there can only be one active gesture. The implementation
      in SeatInterface ensures that there can only be one active gesture.
      
      Each gesture consists of a start event, 0 to multiple update events and
      an end event. The end can also be a cancel. To better support this the
      implementation doesn't follow the protocol and splits end and cancel
      into dedicated methods in the server side and into dedicated signals in
      the client side.
      
      Reviewers: #plasma_on_wayland
      
      Subscribers: plasma-devel
      
      Tags: #plasma_on_wayland
      
      Differential Revision: https://phabricator.kde.org/D3169
      75acb783
  14. 11 Oct, 2016 1 commit
    • Martin Flöser's avatar
      Implement support for the relative pointer protocol · 6dd6729f
      Martin Flöser authored
      Summary:
      This change implements the zwp_relative_pointer_v1 protocol which allows
      to send relative motion events.
      
      The (unstable) protocol consists of a RelativePointerManager which
      creates RelativePointers for a given Pointer. This interface currently
      only has one event to report the relative motion. It carries the delta,
      the non-accelerated-delta and a timestamp in microsends granularity.
      
      On the server side the implementation is mostly internal. Once a
      RelativePointerManagerInterface is created one can send relative motion
      events through the SeatInterface. The SeatInterface takes care of
      sending it to the responding RelativePointerInterface. The protocol does
      not restrict the sending of "normal" and relative motion events. Thus it
      can be combined in any way one wants. This allows to have a rather
      simple implementation. A user of the SeatInterface can just start to
      feed the relative motion events (if the information is available) to the
      SeatInterface together with the pointer events.
      
      On client side a new RelativePointerManager and RelativePointer class
      are added. The RelativePointerManager creates the RelativePointer for a
      given Pointer. The event sent to RelativePointer is transformed in a
      normal signal.
      
      Reviewers: #plasma
      
      Subscribers: plasma-devel
      
      Tags: #plasma_on_wayland
      
      Differential Revision: https://phabricator.kde.org/D2978
      6dd6729f
  15. 14 Jul, 2016 1 commit
  16. 28 Jun, 2016 1 commit
    • Martin Flöser's avatar
      Properly handle destroying a Pointer resource · 9651216b
      Martin Flöser authored
      Summary:
      On client side the newer wl_pointer_release is used which is a
      destructor call. On server side the shared destroy callback is used
      and it's ensured that KWayland doesn't crash if called into the
      PointerInterface between unbound and destroyed.
      
      Test Plan:
      Test case extended to cover the condition of an unbound
      PointerInterface.
      
      Reviewers: #plasma_on_wayland
      
      Subscribers: plasma-devel
      
      Tags: #plasma_on_wayland
      
      Differential Revision: https://phabricator.kde.org/D2037
      9651216b
  17. 19 May, 2016 1 commit
    • Martin Flöser's avatar
      [server] Improve the handling when clients disconnect · fd01e59a
      Martin Flöser authored
      Summary:
      So far the server component performed manual cleanup in some cases
      when a client disconnects. But this is not needed: the Wayland library
      calls the static unbind methods which do cleanup. If we cleanup ourselves
      this can result in double deletes in the worst case, so let's only use
      the Wayland functionality.
      
      Adjusted:
      * RegionInterface
      * SurfaceInterface
      * ShellSurfaceInterface (doesn't take a parent anymore)
      * DpmsInterface
      * QtSurfaceExtensionInterface
      * KeyboardInterface
      * PointerInterface
      * TouchInterface
      * DataOfferInterface
      * PlasmaShellSurfaceInterface
      
      For each adjusted case a test case is added to verify that the cleanup
      works. Exceptions are DpmsInterface as the actual Resource is not exposed
      at all in the Server component and DataOfferInterface as that is server
      side created.
      
      Reviewers: #plasma
      
      Subscribers: plasma-devel
      
      Tags: #plasma
      
      Differential Revision: https://phabricator.kde.org/D1640
      fd01e59a
  18. 06 Apr, 2016 2 commits
    • Martin Flöser's avatar
    • Martin Flöser's avatar
      [server] Support sub-surfaces from PointerInterface · 14653e63
      Martin Flöser authored
      Summary:
      The idea behind this change is to make the existance of sub-surfaces
      an implementation detail for pointer events. The user of the library
      does not need to care about on which sub-surface the pointer is on.
      It only needs to care about the main surface and passes the focus to
      the main surface.
      
      Internally the PointerInterface takes care of sending the enter to
      the sub-surface at the current pointer position. Also whenever the
      pointer position changes, the PointerInterface evaluates whether it
      triggered a change for the focused sub-surface and sends enter/leave
      events accordingly. If the focused sub-surface does not change, it
      sends motion events as normally, but of course under consideration
      of the sub-surface position.
      
      Overall this means that from pointer usage perspective a user of the
      library doesn't need to care about the fact that there are sub-surfaces
      at all. The library does the correct thing for it.
      
      Reviewers: #plasma
      
      Subscribers: plasma-devel
      
      Projects: #plasma
      
      Differential Revision: https://phabricator.kde.org/D1329
      14653e63
  19. 02 Mar, 2016 1 commit
    • Martin Flöser's avatar
      [server] Implement support for drag'n'drop through pointer device · 413025c2
      Martin Flöser authored
      Summary:
      How drag'n'drop works on Wayland:
      When a surface has a pointer grab and a button pressed on the surface
      (implicit grab) the client can initiate a drag'n'drop operation on the
      data device. For this the client needs to provide a data source
      describing the data to be transmitted with the drag'n'drop operation.
      
      When a drag'n'drop operation is active all pointer events are interpreted
      as part of the drag'n'drop operation, the pointer device is grabbed.
      Pointer events are no longer sent to the focused pointer but to the
      focused data device. When the pointer moves to another surface an
      enter event is sent to a data device for that surface and a leave
      event is sent to the data device previously focused. An enter event
      carries a data offer which is created from the data source for the
      operation.
      
      During pointer motion there is a feedback mechanism. The data offer
      can signal to the data source that it can or cannot accept the data
      at the current pointer position. This can be used by the client being
      dragged from to update the cursor.
      
      The drag'n'drop operation ends with the implicit grab being removed,
      that is the pressed pointer button which triggered the operation gets
      released. The server sends a drop event to the focused data device.
      
      The data transfer can now be started. For that the receiving client
      creates a pipe and passes the file descriptor through the data offer
      to the sending data source. The sending client will write into the
      file descriptor and close it to finish the transfer.
      
      Drag'n'drop could also be initiated through a touch device grab, but
      this is not yet implemented.
      
      The implementation in this change focuses on the adjustments for pointer.
      For the user of the library drag'n'drop is implemented in the
      SeatInterface. Signals are emitted whenever drag is started or ended.
      The interaction for pointer events hardly changes. Motion, button press
      and button release can still be indicated in the same way. If a button
      release removes the implicit grab the drop is automatically performed,
      without the user of the library having to do anything.
      
      The only change during drag and drop for the library user is that
      setFocusedPointerSurface is blocked. To update the current drag target
      the library user should use setDragTarget. Sending the enter/leave to the
      data device gets performed automatically.
      
      The data device which triggered the drag and drop operation is exposed
      in the SeatInterface. The user of the library should make sure to render
      the additional drag icon provided on the data device. At least QtWayland
      based applications will freeze during drag and drop if the icon doesn't
      get rendered.
      
      The implementation is currently still lacking the client side and due to
      that also auto test. It's currently only tested with QtWayland clients.
      
      Reviewers: #plasma, sebas
      
      Subscribers: plasma-devel
      
      Projects: #plasma
      
      Differential Revision: https://phabricator.kde.org/D1046
      413025c2
  20. 24 Feb, 2016 1 commit
    • Martin Flöser's avatar
      [server] Properly initialize Cursor · ba276f41
      Martin Flöser authored
      Summary:
      The Cursor wasn't properly initialized. E.g. the damage signal didn't
      get connected resulting in the server not noticing when the cursor
      changes. The damage only got connected if a new cursor got instelled by
      the client on the same pointer.
      
      This change ensures that the Cursor is properly initialized by calling
      into the same method as when the cursor changed.
      
      The tests are extended by a new test case for damaging the surface.
      
      Reviewers: #plasma
      
      Subscribers: plasma-devel
      
      Projects: #plasma
      
      Differential Revision: https://phabricator.kde.org/D1022
      ba276f41
  21. 08 Dec, 2015 1 commit
    • Martin Flöser's avatar
      [server] Add support for pointer input transformation · 2fabeeac
      Martin Flöser authored
      So far we only supported mapping global to surface-local coordinates
      using a 2D-offset. With this change it's possible to register a
      QMatrix4x4 to describe the transformation for going from global to
      surface-local coordinates in a full 3D space.
      
      The existing 2D-offset is transformed to use the new matrix based
      variant describing a translation.
      
      REVIEW: 126271
      2fabeeac
  22. 09 Sep, 2015 1 commit
    • Martin Flöser's avatar
      Fix doxygen generation · 502e1c5d
      Martin Flöser authored
      Doxygen doesn't like our callback listener at all. We need to hide
      it from doxygen, otherwise docu doesn't get generated.
      502e1c5d
  23. 03 Jun, 2015 1 commit
  24. 26 May, 2015 1 commit
  25. 21 Apr, 2015 1 commit
    • Martin Flöser's avatar
      [server] Better split flushing events and dispatch events · 9c65ef76
      Martin Flöser authored
      Running real world applications (Xwayland) showed that it doesn't like
      at all that we do a dispatch when we are going to flush. This caused
      in a very reliable manner a "Connection closed" error in XWayland, taking
      down the client and in return the (xwayland-enabled) server.
      9c65ef76
  26. 20 Apr, 2015 1 commit
  27. 27 Feb, 2015 1 commit
  28. 27 Nov, 2014 1 commit
  29. 26 Nov, 2014 4 commits
  30. 25 Nov, 2014 5 commits
  31. 19 Nov, 2014 1 commit
  32. 13 Nov, 2014 1 commit
    • Martin Flöser's avatar
      Global::Private can create the wl_global · 7589dff8
      Martin Flöser authored
      Version and interface get passed to the ctor allowing Global::Private
      to implement ::create instead of providing a pure virtual method.
      Also the static bind method is added to the Global::Private which
      delegates into a pure virtual method.
      7589dff8