1. 19 Jan, 2016 1 commit
    • Jason Ekstrand's avatar
      Track protocol object versions inside wl_proxy. · 557032e3
      Jason Ekstrand authored
      
      
      This provides a standardized mechanism for tracking protocol object
      versions in client code.  The wl_display object is created with version 1.
      Every time an object is created from within wl_registry_bind, it gets the
      bound version.  Every other time an object is created, it simply inherits
      it's version from the parent object that created it.
      
      (comments and minor reformatting added
      by Derek Foreman <derekf@osg.samsung.com>)
      Reviewed-by: Pekka Paalanen's avatarPekka Paalanen <pekka.paalanen@collabora.co.uk>
      
      Second trivial commit squashed into this one:
      Authored by Derek Foreman <derekf@osg.samsung.com>
      Signed-off-by: default avatarDerek Foreman <derekf@osg.samsung.com>
      (it's literally one of code and a lot of comments)
      
      This sets wl_display's version (for proxy version query purposes)
      to 0.  Any proxy created with unversioned API (this happens when
      a client compiled with old headers links against new wayland)
      will inherit this 0.
      
      This gives us a way for new libraries linked by old clients to
      realize they can't know a proxy's version.
      
      wl_display's version being unqueryable (always returning 0) is
      an acceptable side effect, since it's a special object you can't
      bind specific versions of anyway.
      
      Second half:
      Reviewed-by: Pekka Paalanen's avatarPekka Paalanen <pekka.paalanen@collabora.co.uk>
      Reviewed-by: Jason Ekstrand's avatarJason Ekstrand <jason@jlekstrand.net>
      557032e3
  2. 16 Jan, 2016 10 commits
    • Jonas Ådahl's avatar
      tests: Test that one can fetch the protocol error after EPIPE · c6437817
      Jonas Ådahl authored
      
      
      If a client is terminated due to some reason, it should always be
      possible to retrieve protocol error associated with the termination.
      Test that, while either using the dispatch helpers
      (wl_display_dispatch(_queue)() or the prepare read API, it should be
      possible to retrieve the error after EPIPE.
      Signed-off-by: Jonas Ådahl's avatarJonas Ådahl <jadahl@gmail.com>
      Reviewed-by: Daniel Stone's avatarDaniel Stone <daniels@collabora.com>
      c6437817
    • Jonas Ådahl's avatar
      tests: Pass argument to client main · 046012a6
      Jonas Ådahl authored
      
      
      Change the API to pass an "void *" argument to the client main
      function, allowing the caller to call the same main function with
      different input.
      
      A helper (client_create_noarg) is added for when no argument is passed,
      and the existing test cases are changed to use this function instead.
      Signed-off-by: Jonas Ådahl's avatarJonas Ådahl <jadahl@gmail.com>
      Reviewed-by: Daniel Stone's avatarDaniel Stone <daniels@collabora.com>
      046012a6
    • Jonas Ådahl's avatar
      tests: Synchronize client termination in idle callback · 7efe8fbd
      Jonas Ådahl authored
      
      
      We currently wait for clients in the wl_client destroy signal, which is
      called before the client is destructed and the socket is closed. If test
      clients rely on being closed due to the socket being closed we'd dead
      lock. Avoid this by synchronizing in an idle task that is called after
      the client is fully destroyed.
      Signed-off-by: Jonas Ådahl's avatarJonas Ådahl <jadahl@gmail.com>
      Reviewed-by: Daniel Stone's avatarDaniel Stone <daniels@collabora.com>
      7efe8fbd
    • Jonas Ådahl's avatar
      client: Fully flush during blocking dispatch · 242617c3
      Jonas Ådahl authored
      
      
      wl_display_flush() may fail with EAGAIN which means that not all data
      waiting in the buffer has been flushed. We later block until there is
      data to read, which could mean that we block on input from the
      compositor without having sent out all data from the client. Avoid this
      by fully flushing the socket before starting to wait.
      
      This commit also changes the array length of the struct pollfd array
      from 2 to 1, as only one element was ever used.
      Signed-off-by: Jonas Ådahl's avatarJonas Ådahl <jadahl@gmail.com>
      Reviewed-by: Daniel Stone's avatarDaniel Stone <daniels@collabora.com>
      242617c3
    • Jonas Ådahl's avatar
      client: Use read preparation API in wl_display_dispatch_queue() · 689fff36
      Jonas Ådahl authored
      
      
      Instead of doing things that do the equivalent of using
      wl_display_prepare_read() and friends, just use the public API. The
      only semantical difference is that we will now unlock and lock the mutex
      more times compared to before.
      Signed-off-by: Jonas Ådahl's avatarJonas Ådahl <jadahl@gmail.com>
      Reviewed-by: Daniel Stone's avatarDaniel Stone <daniels@collabora.com>
      689fff36
    • Jonas Ådahl's avatar
      client: Don't make EPIPE fatal if triggered when flushing · c767f35b
      Jonas Ådahl authored
      
      
      If flushing hits EPIPE it should not make it a fatal error since it
      would make it impossible to process the rest of the data available in
      the buffer. Instead, let reading the socket make EPIPE fatal, letting
      the client have the possibility to process the last messages including
      any error causing the termination.
      Signed-off-by: Jonas Ådahl's avatarJonas Ådahl <jadahl@gmail.com>
      Reviewed-by: Daniel Stone's avatarDaniel Stone <daniels@collabora.com>
      c767f35b
    • Jonas Ådahl's avatar
      client: Remove misplaced documentation about main loop intergration · 0b44298a
      Jonas Ådahl authored
      
      
      There was documentation about how to integrate the display server file
      descriptor in the documentation about wl_display_dispatch_pending().
      This is not the right place to put it, and it also had incorrect usage
      of the API (calling wl_display_dispatch_queue() on input on an unrelated
      fd) as an example.
      Signed-off-by: Jonas Ådahl's avatarJonas Ådahl <jadahl@gmail.com>
      Reviewed-by: Pekka Paalanen's avatarPekka Paalanen <pekka.paalanen@collabora.co.uk>
      Reviewed-by: Daniel Stone's avatarDaniel Stone <daniels@collabora.com>
      0b44298a
    • Jonas Ådahl's avatar
      client: Correct documentation regarding thread safeness · 0edeeb9c
      Jonas Ådahl authored
      The current documentation about wl_display_dispatch() states one may not
      mix wl_display_dispatch(_queue)() with wl_display_prepare_read() and
      friends, but this is a misconception about how
      wl_display_dispatch(_queue)() works. The fact is that the dispatch
      functions does the equivalent of what the preparation API does
      internally, and it is safe to use together.
      
      What is not safe is to dispatch using the wl_display_dispatch(_queue)()
      functions while being prepared to read using wl_display_read_events().
      
      This patch rewrites the documentation to correctly state when the
      various API's are thread safe and how they may not be used.
      
      https://bugs.freedesktop.org/show_bug.cgi?id=91767
      
      Signed-off-by: Jonas Ådahl's avatarJonas Ådahl <jadahl@gmail.com>
      Reviewed-by: Daniel Stone's avatarDaniel Stone <daniels@collabora.com>
      0edeeb9c
    • Carlos Garnacho's avatar
      protocol: Add DnD actions · da7b2489
      Carlos Garnacho authored
      
      
      These 2 requests have been added:
      
      - wl_data_source.set_actions: Notifies the compositor of the available
        actions on the data source.
      - wl_data_offer.set_actions: Notifies the compositor of the available
        actions on the destination side, plus the preferred action.
      
      Out of the data from these requests, the compositor can determine the action
      both parts agree on (and let the user play a role through eg. keyboard
      modifiers). The chosen option will be notified to both parties
      through the following two requests:
      
      - wl_data_source.action
      - wl_data_offer.action
      
      In addition, the destination side can peek the source side actions through
      wl_data_offer.source_actions.
      
      Compared to the XDND protocol, there's two notable changes:
      
      - XDND lets the source suggest an action, whereas wl_data_device lets
        the destination prefer a given action. The difference is subtle here,
        it comes off as convenience because it is the drag destination which
        receives the motion events (unlike in X) and can perform action updates.
      
        The drag destination seems also in a better position to update the
        preferred action based on things like the data being transferred, the
        place being dropped, and whether the drag is client-local.
      
      - That same source-side preferred action is used in XDND to convey the
        modifier-induced action to the drag destination, which would then ack
        it, or reply with another action that's accepted (or none), this makes
        the XdndPosition/XdndStatus messaging very verbose, and synchronous
        because the drag source always needs to know the latest status/action
        for every position+action sent.
      
        Here it's the compositor which takes care of modifiers and matching
        available/accepted actions, this allows for the signaling to happen
        only whenever the actions/modifiers change for real.
      
      Roughly based on previous work by Giulio Camuffo <giuliocamuffo@gmail.com>
      
      Changes since v10:
      - Narrow down the situations where wl_data_source/offer.accept requests
        are supposed to happen.
      
      Changes since v9:
      - Deferred the protocol errors to .finish after some IRC chat with Jonas,
        added further errors if actions API is used on selection sources/offers.
      
      Changes since v8:
      - Defined further the expected behavior on "ask", described the protocol
        errors that may happen. Fix more spaces vs tabs issues.
      
      Changes since v7:
      - Misc changes after updating the progress notification patch.
      
      Changes since v6:
      - Further explanations on wl_data_source/offer.set_actions, including a
        description of "ask" actions. Added protocol errors for unknown action
        values.
      
      Changes since v5:
      - Applied rewording suggestions from Jonas Ådahl. Dropped slot reservation
        scheme for actions. Fixed indentation and other minor formatting issues.
      
      Changes since v4:
      - Minor rewording.
      
      Changes since v3:
      - Splitted from DnD progress notification changes.
      - Further rationales in commit log.
      
      Changes since v2:
      - Renamed notify_actions to set_actions on both sides, seems more consistent
        with the rest of the protocol.
      - Spelled out better which events may be triggered on the compositor side
        by the requests, the circumstances in which events are emitted, and
        what are events useful for in clients.
      - Defined a minimal common ground wrt compositor-side action picking and
        keybindings.
      - Acknowledge the possibility of compositor/toolkit defined actions, even
        though none are used at the moment.
      Changes since v1:
      - Added wl_data_offer.source_actions to let know of the actions offered
        by a data source.
      - Renamed wl_data_source.finished to "drag_finished" for clarity
      - Improved wording as suggested by Bryce
      Signed-off-by: Carlos Garnacho's avatarCarlos Garnacho <carlosg@gnome.org>
      Reviewed-by: default avatarMichael Catanzaro <mcatanzaro@igalia.com>
      Reviewed-by: default avatarMike Blumenkrantz <zmike@samsung.com>
      Reviewed-by: Jonas Ådahl's avatarJonas Ådahl <jadahl@gmail.com>
      Reviewed-by: default avatarBryce Harrington <bryce@osg.samsung.com>
      da7b2489
    • Carlos Garnacho's avatar
      protocol: Improve data source notification around DnD progress · 5c4272b8
      Carlos Garnacho authored
      
      
      Currently, there's no means for the DnD origin to know whether the
      destination is actually finished with the DnD transaction, short of
      finalizing it after the first transfer finishes, or leaking it forever.
      
      But this poses other interoperation problems, drag destinations might
      be requesting several mimetypes at once, might be just poking to find
      out the most suitable format, might want to defer the action to a popup,
      might be poking contents early before the selection was dropped...
      
      In addition, data_source.cancelled is suitable for the situations where
      the DnD operation fails (not on a drop target, no matching mimetypes,
      etc..), but seems undocumented for that use (and unused in weston's DnD).
      
      In order to improve the situation, the drag source should be notified
      of all stages of DnD. In addition to documenting the "cancelled" event
      for DnD purposes, The following 2 events have been added:
      
      - wl_data_source.dnd_drop_performed: Happens when the operation has been
        physically finished (eg. the button is released), it could be the right
        place to reset the pointer cursor back and undo any other state resulting
        from the initial button press.
      - wl_data_source.dnd_finished: Happens when the destination side destroys
        the wl_data_offer, at this point the source can just forget all data
        related to the DnD selection as well, plus optionally deleting the data
        on move operations.
      
      Changes since v6:
        - Turned wl_data_offer.finish calls with 0/NULL state/mimetype an
          error, made it explicit that it will only result in
          wl_data_offer.dnd_finished being sent if successful.
      
      Changes since v5:
        - Further rewording of wl_data_offer.finish and wl_data_offer.accept.
          Added error for untimely wl_data_offer.finish requests.
      
      Changes since v4:
        - Applied rewording suggestions from Jonas Ådahl. Added new
          wl_data_offer.finish request to allow explicit finalization on the
          destination side.
      
      Changes since v3:
        - Renamed dnd_performed to a more descriptive dnd_drop_performed,
          documented backwards compatible behavior on wl_data_offer.accept and
          wl_data_source.cancelled.
      
      Changes since v2:
        - Minor rewording.
      
      Changes since v1:
        - Renamed events to have a common "dnd" namespace. Made dnd_performed to
          happen invariably, data_device.cancelled may still happen afterwards.
      Signed-off-by: Carlos Garnacho's avatarCarlos Garnacho <carlosg@gnome.org>
      Reviewed-by: default avatarMichael Catanzaro <mcatanzaro@igalia.com>
      Reviewed-by: Jonas Ådahl's avatarJonas Ådahl <jadahl@gmail.com>
      Reviewed-by: default avatarMike Blumenkrantz <zmike@samsung.com>
      Reviewed-by: default avatarBryce Harrington <bryce@osg.samsung.com>
      5c4272b8
  3. 14 Jan, 2016 3 commits
    • Derek Foreman's avatar
      server: Test for illegally low interface versions in wl_global_create() · 2b4c0539
      Derek Foreman authored
      
      
      Any version lower than 1 is unreasonable.
      Signed-off-by: default avatarDerek Foreman <derekf@osg.samsung.com>
      Reviewed-by: Daniel Stone's avatarDaniel Stone <daniels@collabora.com>
      2b4c0539
    • Derek Foreman's avatar
      server: improve failure log message for wl_global_create() · 16b4cc69
      Derek Foreman authored
      
      
      The gratuitous %m jammed onto the end of the string prints errno
      concatenated with the word "version".
      
      I've removed the %m, and printed some additional information about the
      failure.
      
      Also, reversed the order of the expressions in the conditional to
      make it match the english in the log message.
      Signed-off-by: default avatarDerek Foreman <derekf@osg.samsung.com>
      Reviewed-by: Daniel Stone's avatarDaniel Stone <daniels@collabora.com>
      16b4cc69
    • Peter Hutterer's avatar
      protocol: add wl_pointer.frame, axis_source, axis_stop, and axis_discrete · c5356e90
      Peter Hutterer authored
      
      
      The frame event groups separate pointer events together. The primary use-case
      for this at the moment is diagonal scrolling - a vertical/horizontal scroll
      event can be grouped together to calculate the correct motion vector.
      Frame events group all wl_pointer events. An example sequence of motion events
      followed by a diagonal scroll followed by a button event is:
      wl_pointer.motion
      wl_pointer.frame
      wl_pointer.motion
      wl_pointer.frame
      wl_pointer.axis
      wl_pointer.axis
      wl_pointer.frame
      wl_pointer.button
      wl_pointer.frame
      
      In the future, other extensions may insert additional information about an
      event into the frame. For example, an extension may add information about the
      physical device that generated an event into the frame. For this reason,
      enter/leave events are grouped by a frame event too.
      
      The axis_source event determines how an axis event was generated. That enables
      clients to judge when to use kinetic scrolling. Only one axis_source event is
      allowed per frame and applies to all events in this frame.
      
      The axis_stop event notifies a client about the termination of a scroll
      sequence, likewise needed to calculate kinetic scrolling parameters.
      Multiple axis_stop events within the same frame indicate that scrolling has
      stopped in all these axis at the same time.
      
      The axis_discrete event provides the wheel click count. Previously the axis
      value was some hardcoded number (10), with the discrete steps this enables a
      client to differ between line-based scrolling on a mouse wheel and smooth
      scrolling with a touchpad. The axis_discrete event carries the axis
      information and the discrete value and can occur at any time in the frame
      provided it is ordered before the matching axis event. Specifically, this
      sequence is valid:
      
      wl_pointer.axis_source
      wl_pointer.axis_discrete (vert)
      wl_pointer.axis_discrete (horiz)
      wl_pointer.axis (horiz)
      wl_pointer.axis (vert)
      wl_pointer.frame
      
      Enter and leave event also trigger wl_pointer.frame events, where possible the
      compositor should group leave and subsequent enter into the same frame. This
      indicates to the client that the pointer has moved between surfaces and may
      allow a client to shortcut code otherwise triggerd by the leave or enter
      events.
      Signed-off-by: Peter Hutterer's avatarPeter Hutterer <peter.hutterer@who-t.net>
      Reviewed-by: Carlos Garnacho's avatarCarlos Garnacho <carlosg@gnome.org>
      Reviewed-by: Jonas Ådahl's avatarJonas Ådahl <jadahl@gmail.com>
      Reviewed-by: Daniel Stone's avatarDaniel Stone <daniels@collabora.com>
      Reviewed-by: default avatarBryce Harrington <bryce@osg.samsung.com>
      c5356e90
  4. 13 Jan, 2016 4 commits
  5. 12 Jan, 2016 6 commits
  6. 18 Dec, 2015 1 commit
  7. 07 Dec, 2015 1 commit
  8. 03 Dec, 2015 1 commit
    • Derek Foreman's avatar
      protocol: Add wl_surface.damage_buffer · 3384f69e
      Derek Foreman authored
      wl_surface.damage uses surface local co-ordinates.
      
      Buffer scale and buffer transforms came along, and EGL surfaces
      have no understanding of them.
      
      Theoretically, clients pass damage rectangles - in Y-inverted surface
      co-ordinates) to EGLSwapBuffersWithDamage, and the EGL implementation
      passed them on to wayland.  However, for this to work the EGL
      implementation must be able to flip those rectangles into the space
      the compositor is expecting, but it's unable to do so because it
      doesn't know the height of the transformed buffer.
      
      So, currently, EGLSwapBuffersWithDamage is unusable and EGLSwapBuffers
      has to pass (0,0) - (INT32_MAX, INT32_MAX) damage to function.
      
      wl_surface.damage_buffer allows damage to be registered on a surface
      in buffer co-ordinates, avoiding this problem.
      
      Credit where it's due, these ideas are not entirely my own:
      Over a year ago the idea of changing damage co-ordinates to buffer
      co-ordinates was suggested (by Jason Ekstrand), and it was at least
      partially rejected and abandoned.  At the time it was also suggested
      (by Pekka Paalanen) that adding a new wl_surface.damage_buffer request
      was another option.
      
      This will eventually resolve:
      https://bugs.freedesktop.org/show_bug.cgi?id=78190
      
      
      by making the problem irrelevant.
      Reviewed-by: Pekka Paalanen's avatarPekka Paalanen <pekka.paalanen@collabora.co.uk>
      Reviewed-by: Jason Ekstrand's avatarJason Ekstrand <jason@jlekstrand.net>
      Signed-off-by: default avatarDerek Foreman <derekf@osg.samsung.com>
      Reviewed-by: Jonas Ådahl's avatarJonas Ådahl <jadahl@gmail.com>
      3384f69e
  9. 27 Nov, 2015 1 commit
  10. 24 Nov, 2015 1 commit
  11. 20 Nov, 2015 1 commit
  12. 19 Nov, 2015 2 commits
  13. 17 Nov, 2015 4 commits
  14. 16 Nov, 2015 3 commits
  15. 06 Nov, 2015 1 commit