Script 'mail_helper' called by obssrc
Hello community,
here is the log from the commit of package wayland-protocols for
openSUSE:Factory checked in at 2022-02-11 23:07:12
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Comparing /work/SRC/openSUSE:Factory/wayland-protocols (Old)
and /work/SRC/openSUSE:Factory/.wayland-protocols.new.1956 (New)
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Package is "wayland-protocols"
Fri Feb 11 23:07:12 2022 rev:27 rq:953142 version:1.25
Changes:
--------
--- /work/SRC/openSUSE:Factory/wayland-protocols/wayland-protocols.changes
2021-11-27 00:51:19.514801885 +0100
+++
/work/SRC/openSUSE:Factory/.wayland-protocols.new.1956/wayland-protocols.changes
2022-02-11 23:08:23.870770524 +0100
@@ -1,0 +2,14 @@
+Thu Feb 10 07:52:18 UTC 2022 - Fusion Future <[email protected]>
+
+- Update to 1.25
+ * This release also adds a new staging protocol for session
+ locking, as well as a 'bounds' event to the xdg_toplevel
+ interface.
+ * ext-session-lock-v1: new protocol
+ * xdg-shell: add invalid_resize_edge error value
+ * xdg-shell: Add toplevel "bounds" configure event
+ * build: Bump version to 1.25
+ * xdg-shell: clarify conditions for remapping unmapped surfaces
+ * linux-dmabuf: fix typo in dev_t example code
+
+-------------------------------------------------------------------
Old:
----
wayland-protocols-1.24.tar.xz
wayland-protocols-1.24.tar.xz.sig
New:
----
wayland-protocols-1.25.tar.xz
wayland-protocols-1.25.tar.xz.sig
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Other differences:
------------------
++++++ wayland-protocols.spec ++++++
--- /var/tmp/diff_new_pack.MLU4nL/_old 2022-02-11 23:08:24.318771768 +0100
+++ /var/tmp/diff_new_pack.MLU4nL/_new 2022-02-11 23:08:24.322771779 +0100
@@ -1,7 +1,7 @@
#
# spec file for package wayland-protocols
#
-# Copyright (c) 2021 SUSE LLC
+# Copyright (c) 2022 SUSE LLC
# Copyright (c) 2015 Bj??rn Lie, Bryne, Norway.
#
# All modifications and additions to the file contributed by third parties
@@ -18,7 +18,7 @@
Name: wayland-protocols
-Version: 1.24
+Version: 1.25
Release: 0
Summary: Wayland protocols that add functionality not available in the
core protocol
License: MIT
++++++ wayland-protocols-1.24.tar.xz -> wayland-protocols-1.25.tar.xz ++++++
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/wayland-protocols-1.24/meson.build
new/wayland-protocols-1.25/meson.build
--- old/wayland-protocols-1.24/meson.build 2021-11-23 10:13:33.066573400
+0100
+++ new/wayland-protocols-1.25/meson.build 2022-01-28 17:00:40.729421000
+0100
@@ -1,5 +1,5 @@
project('wayland-protocols',
- version: '1.24',
+ version: '1.25',
meson_version: '>= 0.54.0',
license: 'MIT/Expat',
)
@@ -38,6 +38,7 @@
staging_protocols = {
'xdg-activation': ['v1'],
'drm-lease': ['v1'],
+ 'ext-session-lock': ['v1'],
}
protocol_files = []
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore'
old/wayland-protocols-1.24/stable/xdg-shell/xdg-shell.xml
new/wayland-protocols-1.25/stable/xdg-shell/xdg-shell.xml
--- old/wayland-protocols-1.24/stable/xdg-shell/xdg-shell.xml 2021-11-23
10:13:33.066573400 +0100
+++ new/wayland-protocols-1.25/stable/xdg-shell/xdg-shell.xml 2022-01-28
17:00:40.730420800 +0100
@@ -29,7 +29,7 @@
DEALINGS IN THE SOFTWARE.
</copyright>
- <interface name="xdg_wm_base" version="3">
+ <interface name="xdg_wm_base" version="4">
<description summary="create desktop-style surfaces">
The xdg_wm_base interface is exposed as a global object enabling clients
to turn their wl_surfaces into windows in a desktop environment. It
@@ -117,7 +117,7 @@
</event>
</interface>
- <interface name="xdg_positioner" version="3">
+ <interface name="xdg_positioner" version="4">
<description summary="child surface positioner">
The xdg_positioner provides a collection of rules for the placement of a
child surface relative to a parent surface. Rules can be defined to
ensure
@@ -401,7 +401,7 @@
</request>
</interface>
- <interface name="xdg_surface" version="3">
+ <interface name="xdg_surface" version="4">
<description summary="desktop user interface surface base interface">
An interface that may be implemented by a wl_surface, for
implementations that provide a desktop-style user interface.
@@ -446,7 +446,8 @@
A newly-unmapped surface is considered to have met condition (1) out
of the 3 required conditions for mapping a surface if its role surface
- has not been destroyed.
+ has not been destroyed, i.e. the client must perform the initial commit
+ again before attaching a buffer.
</description>
<enum name="error">
@@ -576,7 +577,7 @@
</interface>
- <interface name="xdg_toplevel" version="3">
+ <interface name="xdg_toplevel" version="4">
<description summary="toplevel surface">
This interface defines an xdg_surface role which allows a surface to,
among other things, set window-like properties such as maximize,
@@ -604,6 +605,11 @@
</description>
</request>
+ <enum name="error">
+ <entry name="invalid_resize_edge" value="0" summary="provided value is
+ not a valid variant of the resize_edge enum"/>
+ </enum>
+
<request name="set_parent">
<description summary="set the parent of this surface">
Set the "parent" of this surface. This surface should be stacked
@@ -753,12 +759,13 @@
guarantee that the device focus will return when the resize is
completed.
- The edges parameter specifies how the surface should be resized,
- and is one of the values of the resize_edge enum. The compositor
- may use this information to update the surface position for
- example when dragging the top left corner. The compositor may also
- use this information to adapt its behavior, e.g. choose an
- appropriate cursor image.
+ The edges parameter specifies how the surface should be resized, and
+ is one of the values of the resize_edge enum. Values not matching
+ a variant of the enum will cause a protocol error. The compositor
+ may use this information to update the surface position for example
+ when dragging the top left corner. The compositor may also use
+ this information to adapt its behavior, e.g. choose an appropriate
+ cursor image.
</description>
<arg name="seat" type="object" interface="wl_seat" summary="the wl_seat
of the user event"/>
<arg name="serial" type="uint" summary="the serial of the user event"/>
@@ -1069,9 +1076,33 @@
a dialog to ask the user to save their data, etc.
</description>
</event>
+
+ <!-- Version 4 additions -->
+
+ <event name="configure_bounds" since="4">
+ <description summary="recommended window geometry bounds">
+ The configure_bounds event may be sent prior to a xdg_toplevel.configure
+ event to communicate the bounds a window geometry size is recommended
+ to constrain to.
+
+ The passed width and height are in surface coordinate space. If width
+ and height are 0, it means bounds is unknown and equivalent to as if no
+ configure_bounds event was ever sent for this surface.
+
+ The bounds can for example correspond to the size of a monitor excluding
+ any panels or other shell components, so that a surface isn't created in
+ a way that it cannot fit.
+
+ The bounds may change at any point, and in such a case, a new
+ xdg_toplevel.configure_bounds will be sent, followed by
+ xdg_toplevel.configure and xdg_surface.configure.
+ </description>
+ <arg name="width" type="int"/>
+ <arg name="height" type="int"/>
+ </event>
</interface>
- <interface name="xdg_popup" version="3">
+ <interface name="xdg_popup" version="4">
<description summary="short-lived, popup surfaces for menus">
A popup surface is a short-lived, temporary surface. It can be used to
implement for example menus, popovers, tooltips and other similar user
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore'
old/wayland-protocols-1.24/staging/ext-session-lock/README
new/wayland-protocols-1.25/staging/ext-session-lock/README
--- old/wayland-protocols-1.24/staging/ext-session-lock/README 1970-01-01
01:00:00.000000000 +0100
+++ new/wayland-protocols-1.25/staging/ext-session-lock/README 2022-01-28
17:00:40.730420800 +0100
@@ -0,0 +1,4 @@
+ext session lock protocol
+
+Maintainers:
+Isaac Freund <[email protected]>
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore'
old/wayland-protocols-1.24/staging/ext-session-lock/ext-session-lock-v1.xml
new/wayland-protocols-1.25/staging/ext-session-lock/ext-session-lock-v1.xml
--- old/wayland-protocols-1.24/staging/ext-session-lock/ext-session-lock-v1.xml
1970-01-01 01:00:00.000000000 +0100
+++ new/wayland-protocols-1.25/staging/ext-session-lock/ext-session-lock-v1.xml
2022-01-28 17:00:40.731421000 +0100
@@ -0,0 +1,282 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<protocol name="ext_session_lock_v1">
+ <copyright>
+ Copyright 2021 Isaac Freund
+
+ Permission to use, copy, modify, and/or distribute this software for any
+ purpose with or without fee is hereby granted, provided that the above
+ copyright notice and this permission notice appear in all copies.
+
+ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ </copyright>
+
+ <description summary="secure session locking with arbitrary graphics">
+ This protocol allows for a privileged Wayland client to lock the session
+ and display arbitrary graphics while the session is locked.
+
+ The compositor may choose to restrict this protocol to a special client
+ launched by the compositor itself or expose it to all privileged clients,
+ this is compositor policy.
+
+ The client is responsible for performing authentication and informing the
+ compositor when the session should be unlocked. If the client dies while
+ the session is locked the session remains locked, possibly permanently
+ depending on compositor policy.
+
+ Warning! The protocol described in this file is currently in the
+ testing phase. Backward compatible changes may be added together with
+ the corresponding interface version bump. Backward incompatible changes
+ can only be done by creating a new major version of the extension.
+ </description>
+
+ <interface name="ext_session_lock_manager_v1" version="1">
+ <description summary="used to lock the session">
+ This interface is used to request that the session be locked.
+ </description>
+
+ <request name="destroy" type="destructor">
+ <description summary="destroy the session lock manager object">
+ This informs the compositor that the session lock manager object will
+ no longer be used. Existing objects created through this interface
+ remain valid.
+ </description>
+ </request>
+
+ <request name="lock">
+ <description summary="attempt to lock the session">
+ This request creates a session lock and asks the compositor to lock the
+ session. The compositor will send either the ext_session_lock_v1.locked
+ or ext_session_lock_v1.finished event on the created object in
+ response to this request.
+ </description>
+ <arg name="id" type="new_id" interface="ext_session_lock_v1"/>
+ </request>
+ </interface>
+
+ <interface name="ext_session_lock_v1" version="1">
+ <description summary="manage lock state and create lock surfaces">
+ On creation of this object either the locked or finished event will
+ immediately be sent.
+
+ The locked event indicates that the session is locked. This means that
+ the compositor should stop rendering and providing input to normal
+ clients. Instead the compositor should blank all outputs with an opaque
+ color such that their normal content is fully hidden.
+
+ The only surfaces that should be rendered while the session is locked
+ are the lock surfaces created through this interface and optionally,
+ at the compositor's discretion, special privileged surfaces such as
+ input methods or portions of desktop shell UIs.
+
+ If the client dies while the session is locked, the compositor should not
+ unlock the session in response. It is acceptable for the session to be
+ permanently locked if this happens. The compositor may choose to continue
+ to display the lock surfaces the client had mapped before it died or
+ alternatively fall back to a solid color, this is compositor policy.
+
+ Compositors may also allow a secure way to recover the session, the
+ details of this are compositor policy. Compositors may allow a new
+ client to create a ext_session_lock_v1 object and take responsibility
+ for unlocking the session, they may even start a new lock client
+ instance automatically.
+ </description>
+
+ <enum name="error">
+ <entry name="invalid_destroy" value="0"
+ summary="attempted to destroy session lock while locked"/>
+ <entry name="invalid_unlock" value="1"
+ summary="unlock requested but locked event was never sent"/>
+ <entry name="role" value="2"
+ summary="given wl_surface already has a role"/>
+ <entry name="duplicate_output" value="3"
+ summary="given output already has a lock surface"/>
+ <entry name="already_constructed" value="4"
+ summary="given wl_surface has a buffer attached or committed"/>
+ </enum>
+
+ <request name="destroy" type="destructor">
+ <description summary="destroy the session lock">
+ This informs the compositor that the lock object will no longer be
+ used. Existing objects created through this interface remain valid.
+
+ After this request is made, lock surfaces created through this object
+ should be destroyed by the client as they will no longer be used by
+ the compositor.
+
+ It is a protocol error to make this request if the locked event was
+ sent, the unlock_and_destroy request must be used instead.
+ </description>
+ </request>
+
+ <event name="locked">
+ <description summary="session successfully locked">
+ This client is now responsible for displaying graphics while the
+ session is locked and deciding when to unlock the session.
+
+ Either this event or the finished event will be sent immediately on
+ creation of this object.
+
+ If this event is sent, making the destroy request is a protocol error,
+ the lock object may only be destroyed using the unlock_and_destroy
+ request.
+ </description>
+ </event>
+
+ <event name="finished">
+ <description summary="the session lock object should be destroyed">
+ The compositor has decided that the session lock should be
+ destroyed. Exactly when this event is sent is compositor policy, but
+ it will never be sent more than once for a given session lock object.
+
+ This might be sent because there is already another ext_session_lock_v1
+ object held by a client, or the compositor has decided to deny the
+ request to lock the session for some other reason. This might also
+ be sent because the compositor implements some alternative, secure
+ way to authenticate and unlock the session.
+
+ Either this event or the locked event will be sent exactly once on
+ creation of this object. If the locked event is sent on creation of
+ this object, the finished event may still be sent at some later time
+ in this object's lifetime, this is compositor policy.
+
+ Upon receiving this event, the client should make either the destroy
+ request or the unlock_and_destroy request, depending on whether or
+ not the locked event was received on this object.
+ </description>
+ </event>
+
+ <request name="get_lock_surface">
+ <description summary="create a lock surface for a given output">
+ The client is expected to create lock surfaces for all outputs
+ currently present and any new outputs as they are advertised. These
+ won't be displayed by the compositor unless the lock is successful
+ and the locked event is sent.
+
+ Providing a wl_surface which already has a role or already has a buffer
+ attached or committed is a protocol error, as is attaching/committing
+ a buffer before the first ext_session_lock_surface_v1.configure event.
+
+ Attempting to create more than one lock surface for a given output
+ is a duplicate_output protocol error.
+ </description>
+ <arg name="id" type="new_id" interface="ext_session_lock_surface_v1"/>
+ <arg name="surface" type="object" interface="wl_surface"/>
+ <arg name="output" type="object" interface="wl_output"/>
+ </request>
+
+ <request name="unlock_and_destroy" type="destructor">
+ <description summary="unlock the session, destroying the object">
+ This request indicates that the session should be unlocked, for
+ example because the user has entered their password and it has been
+ verified by the client.
+
+ This request also informs the compositor that the lock object will
+ no longer be used and may be safely destroyed. Existing objects
+ created through this interface remain valid.
+
+ After this request is made, lock surfaces created through this object
+ should be destroyed by the client as they will no longer be used by
+ the compositor.
+
+ It is a protocol error to make this request if the locked event has
+ not been sent. In that case, the lock object may only be destroyed
+ using the destroy request.
+ </description>
+ </request>
+ </interface>
+
+ <interface name="ext_session_lock_surface_v1" version="1">
+ <description summary="a surface displayed while the session is locked">
+ The client may use lock surfaces to display a screensaver, render a
+ dialog to enter a password and unlock the session, or however else it
+ sees fit.
+
+ On binding this interface the compositor will immediately send the
+ first configure event. After making the ack_configure request in
+ response to this event the client may attach and commit the first
+ buffer. Committing the surface before acking the first configure is a
+ protocol error. Committing the surface with a null buffer at any time
+ is a protocol error.
+
+ The compositor is free to handle keyboard/pointer focus for lock
+ surfaces however it chooses. A reasonable way to do this would be to
+ give the first lock surface created keyboard focus and change keyboard
+ focus if the user clicks on other surfaces.
+ </description>
+
+ <enum name="error">
+ <entry name="commit_before_first_ack" value="0"
+ summary="surface committed before first ack_configure request"/>
+ <entry name="null_buffer" value="1"
+ summary="surface committed with a null buffer"/>
+ <entry name="dimensions_mismatch" value="2"
+ summary="failed to match ack'd width/height"/>
+ <entry name="invalid_serial" value="3"
+ summary="serial provided in ack_configure is invalid"/>
+ </enum>
+
+ <request name="destroy" type="destructor">
+ <description summary="destroy the lock surface object">
+ This informs the compositor that the lock surface object will no
+ longer be used.
+
+ It is recommended for a lock client to destroy lock surfaces if
+ their corresponding wl_output global is removed.
+
+ If a lock surface on an active output is destroyed before the
+ ext_session_lock_v1.unlock_and_destroy event is sent, the compositor
+ must fall back to rendering a solid color.
+ </description>
+ </request>
+
+ <request name="ack_configure">
+ <description summary="ack a configure event">
+ When a configure event is received, if a client commits the surface
+ in response to the configure event, then the client must make an
+ ack_configure request sometime before the commit request, passing
+ along the serial of the configure event.
+
+ If the client receives multiple configure events before it can
+ respond to one, it only has to ack the last configure event.
+
+ A client is not required to commit immediately after sending an
+ ack_configure request - it may even ack_configure several times
+ before its next surface commit.
+
+ A client may send multiple ack_configure requests before committing,
+ but only the last request sent before a commit indicates which
+ configure event the client really is responding to.
+
+ Sending an ack_configure request consumes the configure event
+ referenced by the given serial, as well as all older configure events
+ sent on this object.
+
+ It is a protocol error to issue multiple ack_configure requests
+ referencing the same configure event or to issue an ack_configure
+ request referencing a configure event older than the last configure
+ event acked for a given lock surface.
+ </description>
+ <arg name="serial" type="uint" summary="serial from the configure
event"/>
+ </request>
+
+ <event name="configure">
+ <description summary="the client should resize its surface">
+ This event is sent once on binding the interface and may be sent again
+ at the compositor's discretion, for example if output geometry changes.
+
+ The width and height are in surface-local coordinates and are exact
+ requirements. Failing to match these surface dimensions in the next
+ commit after acking a configure is a protocol error.
+ </description>
+ <arg name="serial" type="uint" summary="serial for use in
ack_configure"/>
+ <arg name="width" type="uint"/>
+ <arg name="height" type="uint"/>
+ </event>
+ </interface>
+</protocol>
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore'
old/wayland-protocols-1.24/unstable/linux-dmabuf/feedback.rst
new/wayland-protocols-1.25/unstable/linux-dmabuf/feedback.rst
--- old/wayland-protocols-1.24/unstable/linux-dmabuf/feedback.rst
2021-11-23 10:13:33.068573500 +0100
+++ new/wayland-protocols-1.25/unstable/linux-dmabuf/feedback.rst
2022-01-28 17:00:40.736420900 +0100
@@ -180,7 +180,7 @@
.. code-block:: c
- struct dev_t dev;
+ dev_t dev;
assert(dev_array->size == sizeof(dev));
memcpy(&dev, dev_array->data, sizeof(dev));
