wayland::surface_t(3)

📦
version 1.0.1 · 10 versions
, in ubuntu stonking

💅 wayland::surface_t(3) — Wayland++ ✨

okay bestie, welcome to the wayland::surface_t(3) page — this is the Wayland++ manual, and we're getting into the whole onscreen-surface situation. no cap, it's a lot, but we're gonna make it make sense. 🫶

🌸 NAME 🌸

wayland::surface_t — an onscreen surface. that's the whole vibe: it's a surface that shows up onscreen. 👑

✨ SYNOPSIS ✨

#include <wayland-client-protocol.hpp>

Inherits wayland::proxy_t. iconic inheritance moment, honestly.

🎀 Public Types 🎀

  • enum class wrapper_type { standard, display, foreign, proxy_wrapper } — the enum crew. it gets its own full breakdown further down, bestie. 🦋

💖 Public Member Functions 💖

  • void attach (buffer_t const &buffer, int32_t x, int32_t y) — set the surface contents
  • void damage (int32_t x, int32_t y, int32_t width, int32_t height) — mark part of the surface damaged
  • callback_t frame () — request a frame throttling hint
  • void set_opaque_region (region_t const &region) — set opaque region
  • void set_input_region (region_t const &region) — set input region
  • void commit () — commit pending surface state
  • void set_buffer_transform (output_transform const &transform) — sets the buffer transformation
  • bool can_set_buffer_transform () const — Check whether the set_buffer_transform function is available with the currently bound version of the protocol.
  • void set_buffer_scale (int32_t scale) — sets the buffer scaling factor
  • bool can_set_buffer_scale () const — Check whether the set_buffer_scale function is available with the currently bound version of the protocol.
  • void damage_buffer (int32_t x, int32_t y, int32_t width, int32_t height) — mark part of the surface damaged using buffer coordinates
  • bool can_damage_buffer () const — Check whether the damage_buffer function is available with the currently bound version of the protocol.
  • void offset (int32_t x, int32_t y) — set the surface contents offset
  • bool can_offset () const — Check whether the offset function is available with the currently bound version of the protocol.
  • std::function< void(output_t)> & on_enter () — surface enters an output
  • std::function< void(output_t)> & on_leave () — surface leaves an output
  • uint32_t get_id () const — Get the id of a proxy object.
  • std::string get_class () const — Get the interface name (class) of a proxy object.
  • uint32_t get_version () const — Get the protocol object version of a proxy object.
  • wrapper_type get_wrapper_type () const — Get the type of a proxy object.
  • void set_queue (event_queue_t queue) — Assign a proxy to an event queue.
  • wl_proxy * c_ptr () const — Get a pointer to the underlying C struct.
  • bool proxy_has_object () const — Check whether this wrapper actually wraps an object.
  • operator bool () const — Check whether this wrapper actually wraps an object.
  • bool operator== (const proxy_t &right) const — Check whether two wrappers refer to the same object.
  • bool operator!= (const proxy_t &right) const — Check whether two wrappers refer to different objects.
  • void proxy_release () — Release the wrapped object (if any), making this an empty wrapper.

🌟 Static Public Attributes 🌟

  • static constexpr std::uint32_t attach_since_version = 1 — Minimum protocol version required for the attach function.
  • static constexpr std::uint32_t damage_since_version = 1 — Minimum protocol version required for the damage function.
  • static constexpr std::uint32_t frame_since_version = 1 — Minimum protocol version required for the frame function.
  • static constexpr std::uint32_t set_opaque_region_since_version = 1 — Minimum protocol version required for the set_opaque_region function.
  • static constexpr std::uint32_t set_input_region_since_version = 1 — Minimum protocol version required for the set_input_region function.
  • static constexpr std::uint32_t commit_since_version = 1 — Minimum protocol version required for the commit function.
  • static constexpr std::uint32_t set_buffer_transform_since_version = 2 — Minimum protocol version required for the set_buffer_transform function.
  • static constexpr std::uint32_t set_buffer_scale_since_version = 3 — Minimum protocol version required for the set_buffer_scale function.
  • static constexpr std::uint32_t damage_buffer_since_version = 4 — Minimum protocol version required for the damage_buffer function.
  • static constexpr std::uint32_t offset_since_version = 5 — Minimum protocol version required for the offset function.

🔥 Detailed Description 🔥

an onscreen surface — that's the energy.

A surface is literally a rectangular area that may be displayed on zero or more outputs, and shown any number of times at the compositor's discretion. They can present wl_buffers, receive user input, and define a local coordinate system. 🦋

The size of a surface (and relative positions on it) is described in surface-local coordinates, which may differ from the buffer coordinates of the pixel content, in case a buffer_transform or a buffer_scale is used.

A surface without a "role" is fairly useless: a compositor does not know where, when or how to present it. The role is the purpose of a wl_surface. Examples of roles are a cursor for a pointer (as set by wl_pointer.set_cursor), a drag icon (wl_data_device.start_drag), a sub-surface (wl_subcompositor.get_subsurface), and a window as defined by a shell protocol (e.g. wl_shell.get_shell_surface).

A surface can have only one role at a time. Initially a wl_surface does not have a role. Once a wl_surface is given a role, it is set permanently for the whole lifetime of the wl_surface object. Giving the current role again is allowed, unless explicitly forbidden by the relevant interface specification.

Surface roles are given by requests in other interfaces such as wl_pointer.set_cursor. The request should explicitly mention that this request gives a role to a wl_surface. Often, this request also creates a new protocol object that represents the role and adds additional functionality to wl_surface. When a client wants to destroy a wl_surface, they must destroy this 'role object' before the wl_surface.

Destroying the role object does not remove the role from the wl_surface, but it may stop the wl_surface from "playing the role". For instance, if a wl_subsurface object is destroyed, the wl_surface it was created for will be unmapped and forget its position and z-order. It is allowed to create a wl_subsurface for the same wl_surface again, but it is not allowed to use the wl_surface as a cursor (cursor is a different role than sub-surface, and role switching is not allowed).

🌈 Examples 🌈

  • egl.cpp.

Definition at line 2005 of file wayland-client-protocol.hpp.

🧚 Member Enumeration Documentation 🧚

enum class wayland::proxy_t::wrapper_type [strong], [inherited]

Underlying wl_proxy type and properties of a proxy_t that affect construction, destruction, and event handling.

Enumerator:

  • standard — C pointer is a standard type compatible with wl_proxy*. Events are dispatched and it is destructed when the proxy_t is destructed. User data is set.
  • display — C pointer is a wl_display*. No events are dispatched, wl_display_disconnect is called when the proxy_t is destructed. User data is set.
  • foreign — C pointer is a standard type compatible with wl_proxy*, but another library owns it and it should not be touched in a way that could affect the operation of the other library. No events are dispatched, wl_proxy_destroy is not called when the proxy_t is destructed, user data is not touched. Consequently, there is no reference counting for the proxy_t. Lifetime of such wrappers should preferably be short to minimize the chance that the owning library decides to destroy the wl_proxy.
  • proxy_wrapper — C pointer is a wl_proxy* that was constructed with wl_proxy_create_wrapper. No events are dispatched, wl_proxy_wrapper_destroy is called when the proxy_t is destroyed. Reference counting is active. A reference to the proxy_t creating this proxy wrapper is held to extend its lifetime until after the proxy wrapper is destroyed.

Definition at line 117 of file wayland-client.hpp.

💜 Member Function Documentation 💜

void surface_t::attach (buffer_t const & buffer, int32_t x, int32_t y)

set the surface contents

🍓 Parameters 🍓

  • buffer — buffer of surface contents
  • x — surface-local x coordinate
  • y — surface-local y coordinate

Set a buffer as the content of this surface. 🫶

The new size of the surface is calculated based on the buffer size transformed by the inverse buffer_transform and the inverse buffer_scale. This means that at commit time the supplied buffer size must be an integer multiple of the buffer_scale. If that's not the case, an invalid_size error is sent. 😭

The x and y arguments specify the location of the new pending buffer's upper left corner, relative to the current buffer's upper left corner, in surface-local coordinates. In other words, the x and y, combined with the new surface size define in which directions the surface's size changes. Setting anything other than 0 as x and y arguments is discouraged, and should instead be replaced with using the separate wl_surface.offset request.

When the bound wl_surface version is 5 or higher, passing any non-zero x or y is a protocol violation, and will result in an 'invalid_offset' error being raised. To achieve equivalent semantics, use wl_surface.offset.

Surface contents are double-buffered state, see wl_surface.commit.

The initial surface contents are void; there is no content. wl_surface.attach assigns the given wl_buffer as the pending wl_buffer. wl_surface.commit makes the pending wl_buffer the new surface contents, and the size of the surface becomes the size calculated from the wl_buffer, as described above. After commit, there is no pending buffer until the next attach.

Committing a pending wl_buffer allows the compositor to read the pixels in the wl_buffer. The compositor may access the pixels at any time after the wl_surface.commit request. When the compositor will not access the pixels anymore, it will send the wl_buffer.release event. Only after receiving wl_buffer.release, the client may reuse the wl_buffer. A wl_buffer that has been attached and then replaced by another attach instead of committed will not receive a release event, and is not used by the compositor.

If a pending wl_buffer has been committed to more than one wl_surface, the delivery of wl_buffer.release events becomes undefined. A well behaved client should not rely on wl_buffer.release events in this case. Alternatively, a client could create multiple wl_buffer objects from the same backing storage or use wp_linux_buffer_release.

Destroying the wl_buffer after wl_buffer.release? Does not change the surface contents, bestie. Zero drama. Destroying the wl_buffer before wl_buffer.release is allowed too, as long as the underlying buffer storage isn't re-used — and yeah, that can happen, e.g. on client process termination. But the moment you destroy the wl_buffer before receiving the wl_buffer.release event and mutate the underlying buffer storage, your surface contents become undefined immediately 😭 so like… don't do that.

If wl_surface.attach is sent with a NULL wl_buffer, the following wl_surface.commit will remove the surface content. Clean slate energy ✨

Definition at line 2693 of file wayland-client-protocol.cpp.

🫶 wl_proxy * wayland::proxy_t::c_ptr () const [inherited]

Grab a pointer to the underlying C struct, fr.

Returns: the underlying wl_proxy wrapped by this proxy_t if it exists — otherwise an exception gets thrown at you 💀

🦋 bool surface_t::can_damage_buffer () const

Vibe check on the damage_buffer function: is it available with the currently bound version of the protocol?

Definition at line 2757 of file wayland-client-protocol.cpp.

🌸 bool surface_t::can_offset () const

Same deal, but for offset — is it available with the currently bound version of the protocol?

Definition at line 2768 of file wayland-client-protocol.cpp.

🎀 bool surface_t::can_set_buffer_scale () const

Yup, checking on set_buffer_scale this time: available with the currently bound version of the protocol or not?

Definition at line 2746 of file wayland-client-protocol.cpp.

⭐ bool surface_t::can_set_buffer_transform () const

And the set_buffer_transform check — is it available with the currently bound version of the protocol?

Definition at line 2735 of file wayland-client-protocol.cpp.

👑 void surface_t::commit ()

Commit pending surface state. Okay so this one is the main character, pay attention 🔥

Surface state — input, opaque, and damage regions, attached buffers, etc. — is double-buffered. Protocol requests modify the pending state, as opposed to the current state in use by the compositor. A commit request atomically applies all pending state, replacing the current state. After commit, the new pending state is as documented for each related request.

On commit, a pending wl_buffer is applied first, and all other state second. Which means all coordinates in double-buffered state are relative to the new wl_buffer coming into use — except for wl_surface.attach itself, ofc. If there is no pending wl_buffer, the coordinates are relative to the current surface contents.

All requests that need a commit to become effective are documented to affect double-buffered state.

Other interfaces may add further double-buffered surface state. Slay, more state 💅

Definition at line 2724 of file wayland-client-protocol.cpp.

🧚 void surface_t::damage (int32_t x, int32_t y, int32_t width, int32_t height)

Mark part of the surface damaged.

Parameters

  • x — surface-local x coordinate
  • y — surface-local y coordinate
  • width — width of damage rectangle
  • height — height of damage rectangle

This request is used to describe the regions where the pending buffer is different from the current surface contents, and where the surface therefore needs to be repainted. The compositor ignores the parts of the damage that fall outside of the surface, rude but valid 🙈

Damage is double-buffered state, see wl_surface.commit.

The damage rectangle is specified in surface-local coordinates, where x and y specify the upper left corner of the damage rectangle.

The initial value for pending damage is empty: no damage. wl_surface.damage adds pending damage: the new pending damage is the union of old pending damage and the given rectangle.

wl_surface.commit assigns pending damage as the current damage, and clears pending damage. The server will clear the current damage as it repaints the surface.

Note! New clients should not use this request. Instead damage can be posted with wl_surface.damage_buffer, which uses buffer coordinates instead of surface coordinates. It's giving deprecated, iykyk 💀

Definition at line 2699 of file wayland-client-protocol.cpp.

🍓 void surface_t::damage_buffer (int32_t x, int32_t y, int32_t width, int32_t height)

Mark part of the surface damaged using buffer coordinates.

Parameters

  • x — buffer-local x coordinate
  • y — buffer-local y coordinate
  • width — width of damage rectangle
  • height — height of damage rectangle

This request is used to describe the regions where the pending buffer is different from the current surface contents, and where the surface therefore needs to be repainted. The compositor ignores the parts of the damage that fall outside of the surface.

Damage is double-buffered state, see wl_surface.commit.

The damage rectangle is specified in buffer coordinates, where x and y specify the upper left corner of the damage rectangle.

The initial value for pending damage is empty: no damage. wl_surface.damage_buffer adds pending damage: the new pending damage is the union of old pending damage and the given rectangle.

wl_surface.commit assigns pending damage as the current damage, and clears pending damage. The server will clear the current damage as it repaints the surface.

This request differs from wl_surface.damage in only one way — it takes damage in buffer coordinates instead of surface-local coordinates. While this generally is more intuitive than surface coordinates, it is especially desirable when using wp_viewport or when a drawing library (like EGL) is unaware of buffer scale and buffer transform ✨

Note: Because buffer transformation changes and damage requests may be interleaved in the protocol stream, it is impossible to determine the actual mapping between surface and buffer damage until wl_surface.commit time. Therefore, compositors wishing to take both kinds of damage into account will have to accumulate damage from the two requests separately and only transform from one to the other after receiving the wl_surface.commit. Messy, but that's the assignment 🫶

Definition at line 2752 of file wayland-client-protocol.cpp.

🌈 callback_t surface_t::frame ()

Request a frame throttling hint 😌

Returns: callback object for the frame request

Request a notification when it is a good time to start drawing a new frame, by creating a frame callback. This is useful for throttling redrawing operations, and driving animations. Iconic behavior, honestly.

When a client is animating on a wl_surface, it can use the 'frame' request to get notified when it is a good time to draw and commit the next frame of animation. If the client commits an update earlier than that, it is likely that some updates will not make it to the display, and the client is wasting resources by drawing too often — very not slay of you.

The frame request will take effect on the next wl_surface.commit. The notification will only be posted for one frame unless requested again. For a wl_surface, the notifications are posted in the order the frame requests were committed.

The server must send the notifications so that a client will not send excessive updates, while still allowing the highest possible update rate for clients that wait for the reply before drawing again. The server should give some time for the client to draw and commit after sending the frame callback events to let it hit the next output refresh.

A server should avoid signaling the frame callbacks if the surface is not visible in any way, e.g. the surface is off-screen, or completely obscured by other opaque surfaces. If nobody can see it, bestie, why are we even 💀

The object returned by this request will be destroyed by the compositor after the callback is fired and as such the client must not attempt to use it after that point. It's gone. Periodt.

The callback_data passed in the callback is the current time, in milliseconds, with an undefined base.

Definition at line 2705 of file wayland-client-protocol.cpp.

💜 std::string wayland::proxy_t::get_class () const [inherited]

Get the interface name (class) of a proxy object.

Returns: the interface name of the object associated with the proxy

🌟 uint32_t wayland::proxy_t::get_id () const [inherited]

Get the id of a proxy object.

Returns: the id the object associated with the proxy

🎀 uint32_t wayland::proxy_t::get_version () const [inherited]

Get the protocol object version of a proxy object. Gets the protocol object version of a proxy object, or 0 if the proxy was created with unversioned API.

A returned value of 0 means that no version information is available, so the caller must make safe assumptions about the object's real version. No guessing games, please 🙈

display_t will always return version 0.

Returns: the protocol object version of the proxy or 0

🦋 wrapper_type wayland::proxy_t::get_wrapper_type () const [inline], [inherited]

Get the type of a proxy object.

Definition at line 303 of file wayland-client.hpp.

💅 void surface_t::offset (int32_t x, int32_t y)

Set the surface contents offset.

Parameters

  • x — surface-local x coordinate
  • y — surface-local y coordinate

The x and y arguments specify the location of the new pending buffer's upper left corner, relative to the current buffer's upper left corner, in surface-local coordinates. In other words, the x and y, combined with the new surface size, define in which directions the surface's size changes.

Surface location offset is double-buffered state, see wl_surface.commit.

This request is semantically equivalent to and replaces the x and y arguments in the wl_surface.attach request in wl_surface versions prior to 5. See wl_surface.attach for details. Glow-up of the century, honestly 👑

Definition at line 2763 of file wayland-client-protocol.cpp.

✨ std::function< void(output_t)> & surface_t::on_enter ()

Surface enters an output.

Parameters

  • output — output entered by the surface

This is emitted whenever a surface's creation, movement, or resizing results in some part of it being within the scanout region of an output.

Note that a surface may be overlapping with zero or more outputs. Zero! It's giving "it's complicated" 💀

Definition at line 2774 of file wayland-client-protocol.cpp.

🌸 std::function< void(output_t)> & surface_t::on_leave ()

Surface leaves an output.

Parameters

  • output — output left by the surface

This is emitted whenever a surface's creation, movement, or resizing results in it no longer having any part of it within the scanout region of an output.

Clients should not use the number of outputs the surface is on for frame throttling purposes. The surface might be hidden even if no leave event has been sent, and the compositor might expect new surface content updates even if no enter event has been sent. The frame event should be used instead. Okay? Okay 🫶

Definition at line 2779 of file wayland-client-protocol.cpp.

🌈 wayland::proxy_t::operator bool () const [inherited]

Check whether this wrapper actually wraps an object.

Returns: true if there is an underlying object, false if this wrapper is empty. Vibe check on your wrapper 🦋

bool wayland::proxy_t::operator!= (const proxy_t & right) const [inherited]

Okay so this one is literally just the vibe check 💅 — it tells you whether two wrappers are pointing at different objects. That's it. That's the whole function.

bool wayland::proxy_t::operator== (const proxy_t & right) const [inherited]

And this is the matching bestie test ✨ — returns true when two wrappers refer to the same object. Use it, love it, no cap.

bool wayland::proxy_t::proxy_has_object () const [inherited]

The "do you actually have a personality or are you just a shell" check 🫶 — it tells you whether this wrapper actually wraps an object or is just sitting there empty.

Returns

  • true if there's an underlying object hiding in there 🎀
  • false if this wrapper is empty (ngl, kind of sad)

void wayland::proxy_t::proxy_release () [inherited]

Release the wrapped object (if there is one), which turns this thing into an empty wrapper. Poof. Gone. 🦋

Heads up bestie — display_t instances cannot be released this way. If you try? It's just ignored. The function simply looks at you and goes "no 💀".

Examples foreign_display.cpp.

void surface_t::set_buffer_scale (int32_t scale)

Sets the buffer scaling factor 🔍 — iconic for high-res displays.

Parameters

  • scale — the positive scale used for interpreting buffer contents

This request sets an optional scaling factor on how the compositor interprets the contents of the buffer attached to the window.

Buffer scale is double-buffered state, see wl_surface.commit.

A newly created surface has its buffer scale set to 1 (fresh out the box, default vibes ✨).

wl_surface.set_buffer_scale changes the pending buffer scale. wl_surface.commit copies the pending buffer scale to the current one. Otherwise, pending and current values are never changed, periodt.

The whole point of this request? Letting clients supply higher resolution buffer data for use on high resolution outputs 🖥️. The idea is you pick the same buffer scale as the scale of the output that the surface is displayed on — that way the compositor can avoid scaling when rendering the surface on that output. Efficiency slay.

Note that if the scale is larger than 1, then you have to attach a buffer that is larger (by a factor of scale in each dimension) than the desired surface size. Math is math 💅.

If scale is not positive, the invalid_scale protocol error is raised 😭.

Definition at line 2741 of file wayland-client-protocol.cpp.

void surface_t::set_buffer_transform (output_transform const & transform)

Sets the buffer transformation 🌀 — for when things get rotated.

Parameters

  • transform — the transform for interpreting buffer contents

This request sets an optional transformation on how the compositor interprets the contents of the buffer attached to the surface. The accepted values for the transform parameter are the values for wl_output.transform.

Buffer transform is double-buffered state, see wl_surface.commit.

A newly created surface has its buffer transformation set to normal. (Default = normal, as she should 👑.)

wl_surface.set_buffer_transform changes the pending buffer transformation. wl_surface.commit copies the pending buffer transformation to the current one. Otherwise, pending and current values are never changed.

Why does this exist? So clients can render content according to the output transform, which lets the compositor use certain optimizations even if the display is rotated 🔄. Using hardware overlays and scanning out a client buffer for fullscreen surfaces are examples of those optimizations. Those optimizations are highly dependent on the compositor implementation, though — so using this request should be considered on a case-by-case basis. No blanket advice here, iykyk.

Note that if the transform value includes 90 or 270 degree rotation, the width of the buffer will become the surface height and the height of the buffer will become the surface width. Yes, they swap. Keep up 🎀.

If transform is not one of the values from the wl_output.transform enum, the invalid_transform protocol error is raised 😭.

Definition at line 2730 of file wayland-client-protocol.cpp.

void surface_t::set_input_region (region_t const & region)

Sets the input region 🖱️ — aka "where can fingers and cursors actually touch me".

Parameters

  • region — the input region of the surface

This request sets the region of the surface that can receive pointer and touch events.

Input events happening outside of this region will try the next surface in the server surface stack. The compositor ignores the parts of the input region that fall outside of the surface.

The input region is specified in surface-local coordinates.

Input region is double-buffered state, see wl_surface.commit.

wl_surface.set_input_region changes the pending input region. wl_surface.commit copies the pending region to the current region. Otherwise the pending and current regions are never changed — except cursor and icon surfaces are special cases, see wl_pointer.set_cursor and wl_data_device.start_drag 🙈.

The initial value for an input region is infinite — meaning the whole surface will accept input. Setting the pending input region has copy semantics, and the wl_region object can be destroyed immediately. A NULL wl_region causes the input region to be set back to infinite. (Back to "touch me anywhere", love that for you 💖.)

Definition at line 2718 of file wayland-client-protocol.cpp.

void surface_t::set_opaque_region (region_t const & region)

Sets the opaque region 🫥 — a little optimization hint for the compositor.

Parameters

  • region — the opaque region of the surface

This request sets the region of the surface that contains opaque content.

The opaque region is an optimization hint for the compositor that lets it optimize the redrawing of content behind opaque regions. Setting an opaque region is not required for correct behaviour, but marking transparent content as opaque will result in repaint artifacts. So like… don't lie about being opaque, bestie 💀.

The opaque region is specified in surface-local coordinates.

The compositor ignores the parts of the opaque region that fall outside of the surface.

Opaque region is double-buffered state, see wl_surface.commit.

wl_surface.set_opaque_region changes the pending opaque region. wl_surface.commit copies the pending region to the current region. Otherwise, the pending and current regions are never changed.

The initial value for an opaque region is empty. Setting the pending opaque region has copy semantics, and the wl_region object can be destroyed immediately. A NULL wl_region causes the pending opaque region to be set to empty.

Definition at line 2712 of file wayland-client-protocol.cpp.

void wayland::proxy_t::set_queue (event_queue_t queue) [inherited]

Assigns a proxy to an event queue 📬 — very "get in your lane" energy.

Parameters

  • queue — the event queue that will handle this proxy

Assigns the proxy to an event queue. Events coming from the proxy will be queued in queue instead of the display's main queue.

See also: display_t::dispatch_queue().

Examples proxy_wrapper.cpp.

🎀 Member Data Documentation 🎀

Okay these are all constexpr static little constants that say "hey, this function needs at least this protocol version". Version gates, but make it cute. All of them are std::uint32_t, all static, all constexpr, and every single one tells you the minimum protocol version required for its matching function.

  • std::uint32_t wayland::surface_t::attach_since_version = 1 [static], [constexpr] — minimum protocol version required for the attach function. Definition at line 2096 of file wayland-client-protocol.hpp.
  • std::uint32_t wayland::surface_t::commit_since_version = 1 [static], [constexpr] — minimum protocol version required for the commit function. Definition at line 2269 of file wayland-client-protocol.hpp.
  • std::uint32_t wayland::surface_t::damage_buffer_since_version = 4 [static], [constexpr] — minimum protocol version required for the damage_buffer function. Definition at line 2399 of file wayland-client-protocol.hpp.
  • std::uint32_t wayland::surface_t::damage_since_version = 1 [static], [constexpr] — minimum protocol version required for the damage function. Definition at line 2131 of file wayland-client-protocol.hpp.
  • std::uint32_t wayland::surface_t::frame_since_version = 1 [static], [constexpr] — minimum protocol version required for the frame function. Definition at line 2174 of file wayland-client-protocol.hpp.
  • std::uint32_t wayland::surface_t::offset_since_version = 5 [static], [constexpr] — minimum protocol version required for the offset function. Definition at line 2428 of file wayland-client-protocol.hpp.
  • std::uint32_t wayland::surface_t::set_buffer_scale_since_version = 3 [static], [constexpr] — minimum protocol version required for the set_buffer_scale function. Definition at line 2348 of file wayland-client-protocol.hpp.
  • std::uint32_t wayland::surface_t::set_buffer_transform_since_version = 2 [static], [constexpr] — minimum protocol version required for the set_buffer_transform function. Definition at line 2309 of file wayland-client-protocol.hpp.
  • std::uint32_t wayland::surface_t::set_input_region_since_version = 1 [static], [constexpr] — minimum protocol version required for the set_input_region function. Definition at line 2242 of file wayland-client-protocol.hpp.
  • std::uint32_t wayland::surface_t::set_opaque_region_since_version = 1 [static], [constexpr] — minimum protocol version required for the set_opaque_region function. Definition at line 2209 of file wayland-client-protocol.hpp.

🌸 Author 🌸

Generated automatically by Doxygen for Wayland++ from the source code. (Not a human, just a very diligent little robot 🧚.)

And that's a wrap on the whole page, bestie!! 🎉💖 You made it to the very end — genuinely iconic behaviour. This one is Version 1.0.1, dated Fri Mar 27 2026 13:15:00, and it was generated by Doxygen for Wayland++ straight from the source code. Go forth and slay your surfaces 🦋✨💅

📦 where this page comes from