---
name: "wayland_surface_t"
section: "3"
platform: "linux"
package: "waylandpp-dev"
version: "1.0.0-6+b2"
release: "Debian 13 (Trixie)"
platforms: ["linux"]
url: "https://new.carta.tech/wayland_surface_t"
---

# wayland\_surface\_t(3)

an onscreen surface

## NAME

wayland::surface\_t - an onscreen surface

## SYNOPSIS

`#include <wayland-client-protocol.hpp>`

Inherits **wayland::proxy\_t**.

### Public Types

enum class **wrapper\_type** { **standard**, **display**, **foreign**, **proxy\_wrapper** }\

### 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

A surface is 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**, and **shm.cpp**.

Definition at line **2004** 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* **116** *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. Destroying the wl\_buffer before wl\_buffer.release is allowed as long as the underlying buffer storage isn't re-used (this can happen e.g. on client process termination). However, if the client destroys the wl\_buffer before receiving the wl\_buffer.release event and mutates the underlying buffer storage, the surface contents become undefined immediately.*

*If wl\_surface.attach is sent with a NULL wl\_buffer, the following wl\_surface.commit will remove the surface content.*

**Examples** **egl.cpp***, and* **shm.cpp***.*

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

### wl\_proxy \* wayland::proxy\_t::c\_ptr () const` [inherited]`

*Get a pointer to the underlying C struct.*

**Returns**

*The underlying wl\_proxy wrapped by this* **proxy\_t** *if it exists, otherwise an exception is thrown*

### bool surface\_t::can\_damage\_buffer () const

*Check whether the* **damage\_buffer** *function is 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

*Check whether the* **offset** *function is 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

*Check whether the* **set\_buffer\_scale** *function is available with the currently bound version of the protocol.*

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

### bool surface\_t::can\_set\_buffer\_transform () const

*Check whether the* **set\_buffer\_transform** *function is 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 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. This means that all coordinates in double-buffered state are relative to the new wl\_buffer coming into use, except for wl\_surface.attach itself. 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.*

**Examples** **egl.cpp***, and* **shm.cpp***.*

*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.*

*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.*

**Examples** **egl.cpp***, and* **shm.cpp***.*

*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.*

*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.*

*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.*

*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.*

*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.*

*The callback\_data passed in the callback is the current time, in milliseconds, with an undefined base.*

**Examples** **egl.cpp***, and* **shm.cpp***.*

*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.*

**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* **302** *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 the 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.*

*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.*

*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.*

*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*

### bool wayland::proxy\_t::operator!= (const proxy\_t & right) const` [inherited]`

*Check whether two wrappers refer to different objects.*

### bool wayland::proxy\_t::operator== (const proxy\_t & right) const` [inherited]`

*Check whether two wrappers refer to the same object.*

### bool wayland::proxy\_t::proxy\_has\_object () const` [inherited]`

*Check whether this wrapper actually wraps an object.*

**Returns**

*true if there is an underlying object, false if this wrapper is empty*

### void wayland::proxy\_t::proxy\_release ()` [inherited]`

*Release the wrapped object (if any), making this an empty wrapper. Note that* **display\_t** *instances cannot be released this way. Attempts to do so are ignored.*

**Examples** **foreign\_display.cpp***.*

### void surface\_t::set\_buffer\_scale (int32\_t scale)

*sets the buffer scaling factor*

**Parameters**

*scale positive scale 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.*

*wl\_surface.set\_buffer\_scale changes the pending buffer scale. wl\_surface.commit copies the pending buffer scale to the current one. Otherwise, the pending and current values are never changed.*

*The purpose of this request is to allow clients to supply higher resolution buffer data for use on high resolution outputs. It is intended that you pick the same buffer scale as the scale of the output that the surface is displayed on. This means the compositor can avoid scaling when rendering the surface on that output.*

*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.*

*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*

**Parameters**

*transform 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.*

*wl\_surface.set\_buffer\_transform changes the pending buffer transformation. wl\_surface.commit copies the pending buffer transformation to the current one. Otherwise, the pending and current values are never changed.*

*The purpose of this request is to allow clients to render content according to the output transform, thus permitting the compositor to use certain optimizations even if the display is rotated. Using hardware overlays and scanning out a client buffer for fullscreen surfaces are examples of such optimizations. Those optimizations are highly dependent on the compositor implementation, so the use of this request should be considered on a case-by-case basis.*

*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.*

*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)

*set input region*

**Parameters**

*region 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. That means 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 to infinite.*

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

### void surface\_t::set\_opaque\_region (region\_t const & region)

*set opaque region*

**Parameters**

*region 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.*

*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]`

*Assign a proxy to an event queue.*

**Parameters**

*queue The event queue that will handle this proxy*

*Assign proxy to event queue. Events coming from 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

### constexpr std::uint32\_t wayland::surface\_t::attach\_since\_version = 1` [static]`, ` [constexpr]`

*Minimum protocol version required for the* **attach** *function.*

*Definition at line* **2095** *of file* **wayland-client-protocol.hpp***.*

### constexpr std::uint32\_t wayland::surface\_t::commit\_since\_version = 1` [static]`, ` [constexpr]`

*Minimum protocol version required for the* **commit** *function.*

*Definition at line* **2268** *of file* **wayland-client-protocol.hpp***.*

### constexpr 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* **2398** *of file* **wayland-client-protocol.hpp***.*

### constexpr std::uint32\_t wayland::surface\_t::damage\_since\_version = 1` [static]`, ` [constexpr]`

*Minimum protocol version required for the* **damage** *function.*

*Definition at line* **2130** *of file* **wayland-client-protocol.hpp***.*

### constexpr std::uint32\_t wayland::surface\_t::frame\_since\_version = 1` [static]`, ` [constexpr]`

*Minimum protocol version required for the* **frame** *function.*

*Definition at line* **2173** *of file* **wayland-client-protocol.hpp***.*

### constexpr std::uint32\_t wayland::surface\_t::offset\_since\_version = 5` [static]`, ` [constexpr]`

*Minimum protocol version required for the* **offset** *function.*

*Definition at line* **2427** *of file* **wayland-client-protocol.hpp***.*

### constexpr 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* **2347** *of file* **wayland-client-protocol.hpp***.*

### constexpr 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* **2308** *of file* **wayland-client-protocol.hpp***.*

### constexpr 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* **2241** *of file* **wayland-client-protocol.hpp***.*

### constexpr 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* **2208** *of file* **wayland-client-protocol.hpp***.*

## Author

*Generated automatically by Doxygen for Wayland++ from the source code.*