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 <qydwhotm...@gmail.com>
+
+- 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 <m...@isaacfreund.com>
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));
 

Reply via email to