wlr-layer-shell-unstable-v1-protocol.h (21534B)
1 /* Generated by wayland-scanner 1.22.0 */ 2 3 #ifndef WLR_LAYER_SHELL_UNSTABLE_V1_SERVER_PROTOCOL_H 4 #define WLR_LAYER_SHELL_UNSTABLE_V1_SERVER_PROTOCOL_H 5 6 #include <stdint.h> 7 #include <stddef.h> 8 #include "wayland-server.h" 9 10 #ifdef __cplusplus 11 extern "C" { 12 #endif 13 14 struct wl_client; 15 struct wl_resource; 16 17 /** 18 * @page page_wlr_layer_shell_unstable_v1 The wlr_layer_shell_unstable_v1 protocol 19 * @section page_ifaces_wlr_layer_shell_unstable_v1 Interfaces 20 * - @subpage page_iface_zwlr_layer_shell_v1 - create surfaces that are layers of the desktop 21 * - @subpage page_iface_zwlr_layer_surface_v1 - layer metadata interface 22 * @section page_copyright_wlr_layer_shell_unstable_v1 Copyright 23 * <pre> 24 * 25 * Copyright © 2017 Drew DeVault 26 * 27 * Permission to use, copy, modify, distribute, and sell this 28 * software and its documentation for any purpose is hereby granted 29 * without fee, provided that the above copyright notice appear in 30 * all copies and that both that copyright notice and this permission 31 * notice appear in supporting documentation, and that the name of 32 * the copyright holders not be used in advertising or publicity 33 * pertaining to distribution of the software without specific, 34 * written prior permission. The copyright holders make no 35 * representations about the suitability of this software for any 36 * purpose. It is provided "as is" without express or implied 37 * warranty. 38 * 39 * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS 40 * SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND 41 * FITNESS, IN NO EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY 42 * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES 43 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN 44 * AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, 45 * ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF 46 * THIS SOFTWARE. 47 * </pre> 48 */ 49 struct wl_output; 50 struct wl_surface; 51 struct xdg_popup; 52 struct zwlr_layer_shell_v1; 53 struct zwlr_layer_surface_v1; 54 55 #ifndef ZWLR_LAYER_SHELL_V1_INTERFACE 56 #define ZWLR_LAYER_SHELL_V1_INTERFACE 57 /** 58 * @page page_iface_zwlr_layer_shell_v1 zwlr_layer_shell_v1 59 * @section page_iface_zwlr_layer_shell_v1_desc Description 60 * 61 * Clients can use this interface to assign the surface_layer role to 62 * wl_surfaces. Such surfaces are assigned to a "layer" of the output and 63 * rendered with a defined z-depth respective to each other. They may also be 64 * anchored to the edges and corners of a screen and specify input handling 65 * semantics. This interface should be suitable for the implementation of 66 * many desktop shell components, and a broad number of other applications 67 * that interact with the desktop. 68 * @section page_iface_zwlr_layer_shell_v1_api API 69 * See @ref iface_zwlr_layer_shell_v1. 70 */ 71 /** 72 * @defgroup iface_zwlr_layer_shell_v1 The zwlr_layer_shell_v1 interface 73 * 74 * Clients can use this interface to assign the surface_layer role to 75 * wl_surfaces. Such surfaces are assigned to a "layer" of the output and 76 * rendered with a defined z-depth respective to each other. They may also be 77 * anchored to the edges and corners of a screen and specify input handling 78 * semantics. This interface should be suitable for the implementation of 79 * many desktop shell components, and a broad number of other applications 80 * that interact with the desktop. 81 */ 82 extern const struct wl_interface zwlr_layer_shell_v1_interface; 83 #endif 84 #ifndef ZWLR_LAYER_SURFACE_V1_INTERFACE 85 #define ZWLR_LAYER_SURFACE_V1_INTERFACE 86 /** 87 * @page page_iface_zwlr_layer_surface_v1 zwlr_layer_surface_v1 88 * @section page_iface_zwlr_layer_surface_v1_desc Description 89 * 90 * An interface that may be implemented by a wl_surface, for surfaces that 91 * are designed to be rendered as a layer of a stacked desktop-like 92 * environment. 93 * 94 * Layer surface state (layer, size, anchor, exclusive zone, 95 * margin, interactivity) is double-buffered, and will be applied at the 96 * time wl_surface.commit of the corresponding wl_surface is called. 97 * 98 * Attaching a null buffer to a layer surface unmaps it. 99 * 100 * Unmapping a layer_surface means that the surface cannot be shown by the 101 * compositor until it is explicitly mapped again. The layer_surface 102 * returns to the state it had right after layer_shell.get_layer_surface. 103 * The client can re-map the surface by performing a commit without any 104 * buffer attached, waiting for a configure event and handling it as usual. 105 * @section page_iface_zwlr_layer_surface_v1_api API 106 * See @ref iface_zwlr_layer_surface_v1. 107 */ 108 /** 109 * @defgroup iface_zwlr_layer_surface_v1 The zwlr_layer_surface_v1 interface 110 * 111 * An interface that may be implemented by a wl_surface, for surfaces that 112 * are designed to be rendered as a layer of a stacked desktop-like 113 * environment. 114 * 115 * Layer surface state (layer, size, anchor, exclusive zone, 116 * margin, interactivity) is double-buffered, and will be applied at the 117 * time wl_surface.commit of the corresponding wl_surface is called. 118 * 119 * Attaching a null buffer to a layer surface unmaps it. 120 * 121 * Unmapping a layer_surface means that the surface cannot be shown by the 122 * compositor until it is explicitly mapped again. The layer_surface 123 * returns to the state it had right after layer_shell.get_layer_surface. 124 * The client can re-map the surface by performing a commit without any 125 * buffer attached, waiting for a configure event and handling it as usual. 126 */ 127 extern const struct wl_interface zwlr_layer_surface_v1_interface; 128 #endif 129 130 #ifndef ZWLR_LAYER_SHELL_V1_ERROR_ENUM 131 #define ZWLR_LAYER_SHELL_V1_ERROR_ENUM 132 enum zwlr_layer_shell_v1_error { 133 /** 134 * wl_surface has another role 135 */ 136 ZWLR_LAYER_SHELL_V1_ERROR_ROLE = 0, 137 /** 138 * layer value is invalid 139 */ 140 ZWLR_LAYER_SHELL_V1_ERROR_INVALID_LAYER = 1, 141 /** 142 * wl_surface has a buffer attached or committed 143 */ 144 ZWLR_LAYER_SHELL_V1_ERROR_ALREADY_CONSTRUCTED = 2, 145 }; 146 #endif /* ZWLR_LAYER_SHELL_V1_ERROR_ENUM */ 147 148 #ifndef ZWLR_LAYER_SHELL_V1_LAYER_ENUM 149 #define ZWLR_LAYER_SHELL_V1_LAYER_ENUM 150 /** 151 * @ingroup iface_zwlr_layer_shell_v1 152 * available layers for surfaces 153 * 154 * These values indicate which layers a surface can be rendered in. They 155 * are ordered by z depth, bottom-most first. Traditional shell surfaces 156 * will typically be rendered between the bottom and top layers. 157 * Fullscreen shell surfaces are typically rendered at the top layer. 158 * Multiple surfaces can share a single layer, and ordering within a 159 * single layer is undefined. 160 */ 161 enum zwlr_layer_shell_v1_layer { 162 ZWLR_LAYER_SHELL_V1_LAYER_BACKGROUND = 0, 163 ZWLR_LAYER_SHELL_V1_LAYER_BOTTOM = 1, 164 ZWLR_LAYER_SHELL_V1_LAYER_TOP = 2, 165 ZWLR_LAYER_SHELL_V1_LAYER_OVERLAY = 3, 166 }; 167 #endif /* ZWLR_LAYER_SHELL_V1_LAYER_ENUM */ 168 169 /** 170 * @ingroup iface_zwlr_layer_shell_v1 171 * @struct zwlr_layer_shell_v1_interface 172 */ 173 struct zwlr_layer_shell_v1_interface { 174 /** 175 * create a layer_surface from a surface 176 * 177 * Create a layer surface for an existing surface. This assigns 178 * the role of layer_surface, or raises a protocol error if another 179 * role is already assigned. 180 * 181 * Creating a layer surface from a wl_surface which has a buffer 182 * attached or committed is a client error, and any attempts by a 183 * client to attach or manipulate a buffer prior to the first 184 * layer_surface.configure call must also be treated as errors. 185 * 186 * After creating a layer_surface object and setting it up, the 187 * client must perform an initial commit without any buffer 188 * attached. The compositor will reply with a 189 * layer_surface.configure event. The client must acknowledge it 190 * and is then allowed to attach a buffer to map the surface. 191 * 192 * You may pass NULL for output to allow the compositor to decide 193 * which output to use. Generally this will be the one that the 194 * user most recently interacted with. 195 * 196 * Clients can specify a namespace that defines the purpose of the 197 * layer surface. 198 * @param layer layer to add this surface to 199 * @param namespace namespace for the layer surface 200 */ 201 void (*get_layer_surface)(struct wl_client *client, 202 struct wl_resource *resource, 203 uint32_t id, 204 struct wl_resource *surface, 205 struct wl_resource *output, 206 uint32_t layer, 207 const char *namespace); 208 /** 209 * destroy the layer_shell object 210 * 211 * This request indicates that the client will not use the 212 * layer_shell object any more. Objects that have been created 213 * through this instance are not affected. 214 * @since 3 215 */ 216 void (*destroy)(struct wl_client *client, 217 struct wl_resource *resource); 218 }; 219 220 221 /** 222 * @ingroup iface_zwlr_layer_shell_v1 223 */ 224 #define ZWLR_LAYER_SHELL_V1_GET_LAYER_SURFACE_SINCE_VERSION 1 225 /** 226 * @ingroup iface_zwlr_layer_shell_v1 227 */ 228 #define ZWLR_LAYER_SHELL_V1_DESTROY_SINCE_VERSION 3 229 230 #ifndef ZWLR_LAYER_SURFACE_V1_KEYBOARD_INTERACTIVITY_ENUM 231 #define ZWLR_LAYER_SURFACE_V1_KEYBOARD_INTERACTIVITY_ENUM 232 /** 233 * @ingroup iface_zwlr_layer_surface_v1 234 * types of keyboard interaction possible for a layer shell surface 235 * 236 * Types of keyboard interaction possible for layer shell surfaces. The 237 * rationale for this is twofold: (1) some applications are not interested 238 * in keyboard events and not allowing them to be focused can improve the 239 * desktop experience; (2) some applications will want to take exclusive 240 * keyboard focus. 241 */ 242 enum zwlr_layer_surface_v1_keyboard_interactivity { 243 /** 244 * no keyboard focus is possible 245 * 246 * This value indicates that this surface is not interested in 247 * keyboard events and the compositor should never assign it the 248 * keyboard focus. 249 * 250 * This is the default value, set for newly created layer shell 251 * surfaces. 252 * 253 * This is useful for e.g. desktop widgets that display information 254 * or only have interaction with non-keyboard input devices. 255 */ 256 ZWLR_LAYER_SURFACE_V1_KEYBOARD_INTERACTIVITY_NONE = 0, 257 /** 258 * request exclusive keyboard focus 259 * 260 * Request exclusive keyboard focus if this surface is above the 261 * shell surface layer. 262 * 263 * For the top and overlay layers, the seat will always give 264 * exclusive keyboard focus to the top-most layer which has 265 * keyboard interactivity set to exclusive. If this layer contains 266 * multiple surfaces with keyboard interactivity set to exclusive, 267 * the compositor determines the one receiving keyboard events in 268 * an implementation- defined manner. In this case, no guarantee is 269 * made when this surface will receive keyboard focus (if ever). 270 * 271 * For the bottom and background layers, the compositor is allowed 272 * to use normal focus semantics. 273 * 274 * This setting is mainly intended for applications that need to 275 * ensure they receive all keyboard events, such as a lock screen 276 * or a password prompt. 277 */ 278 ZWLR_LAYER_SURFACE_V1_KEYBOARD_INTERACTIVITY_EXCLUSIVE = 1, 279 /** 280 * request regular keyboard focus semantics 281 * 282 * This requests the compositor to allow this surface to be 283 * focused and unfocused by the user in an implementation-defined 284 * manner. The user should be able to unfocus this surface even 285 * regardless of the layer it is on. 286 * 287 * Typically, the compositor will want to use its normal mechanism 288 * to manage keyboard focus between layer shell surfaces with this 289 * setting and regular toplevels on the desktop layer (e.g. click 290 * to focus). Nevertheless, it is possible for a compositor to 291 * require a special interaction to focus or unfocus layer shell 292 * surfaces (e.g. requiring a click even if focus follows the mouse 293 * normally, or providing a keybinding to switch focus between 294 * layers). 295 * 296 * This setting is mainly intended for desktop shell components 297 * (e.g. panels) that allow keyboard interaction. Using this option 298 * can allow implementing a desktop shell that can be fully usable 299 * without the mouse. 300 * @since 4 301 */ 302 ZWLR_LAYER_SURFACE_V1_KEYBOARD_INTERACTIVITY_ON_DEMAND = 2, 303 }; 304 /** 305 * @ingroup iface_zwlr_layer_surface_v1 306 */ 307 #define ZWLR_LAYER_SURFACE_V1_KEYBOARD_INTERACTIVITY_ON_DEMAND_SINCE_VERSION 4 308 #endif /* ZWLR_LAYER_SURFACE_V1_KEYBOARD_INTERACTIVITY_ENUM */ 309 310 #ifndef ZWLR_LAYER_SURFACE_V1_ERROR_ENUM 311 #define ZWLR_LAYER_SURFACE_V1_ERROR_ENUM 312 enum zwlr_layer_surface_v1_error { 313 /** 314 * provided surface state is invalid 315 */ 316 ZWLR_LAYER_SURFACE_V1_ERROR_INVALID_SURFACE_STATE = 0, 317 /** 318 * size is invalid 319 */ 320 ZWLR_LAYER_SURFACE_V1_ERROR_INVALID_SIZE = 1, 321 /** 322 * anchor bitfield is invalid 323 */ 324 ZWLR_LAYER_SURFACE_V1_ERROR_INVALID_ANCHOR = 2, 325 /** 326 * keyboard interactivity is invalid 327 */ 328 ZWLR_LAYER_SURFACE_V1_ERROR_INVALID_KEYBOARD_INTERACTIVITY = 3, 329 }; 330 #endif /* ZWLR_LAYER_SURFACE_V1_ERROR_ENUM */ 331 332 #ifndef ZWLR_LAYER_SURFACE_V1_ANCHOR_ENUM 333 #define ZWLR_LAYER_SURFACE_V1_ANCHOR_ENUM 334 enum zwlr_layer_surface_v1_anchor { 335 /** 336 * the top edge of the anchor rectangle 337 */ 338 ZWLR_LAYER_SURFACE_V1_ANCHOR_TOP = 1, 339 /** 340 * the bottom edge of the anchor rectangle 341 */ 342 ZWLR_LAYER_SURFACE_V1_ANCHOR_BOTTOM = 2, 343 /** 344 * the left edge of the anchor rectangle 345 */ 346 ZWLR_LAYER_SURFACE_V1_ANCHOR_LEFT = 4, 347 /** 348 * the right edge of the anchor rectangle 349 */ 350 ZWLR_LAYER_SURFACE_V1_ANCHOR_RIGHT = 8, 351 }; 352 #endif /* ZWLR_LAYER_SURFACE_V1_ANCHOR_ENUM */ 353 354 /** 355 * @ingroup iface_zwlr_layer_surface_v1 356 * @struct zwlr_layer_surface_v1_interface 357 */ 358 struct zwlr_layer_surface_v1_interface { 359 /** 360 * sets the size of the surface 361 * 362 * Sets the size of the surface in surface-local coordinates. The 363 * compositor will display the surface centered with respect to its 364 * anchors. 365 * 366 * If you pass 0 for either value, the compositor will assign it 367 * and inform you of the assignment in the configure event. You 368 * must set your anchor to opposite edges in the dimensions you 369 * omit; not doing so is a protocol error. Both values are 0 by 370 * default. 371 * 372 * Size is double-buffered, see wl_surface.commit. 373 */ 374 void (*set_size)(struct wl_client *client, 375 struct wl_resource *resource, 376 uint32_t width, 377 uint32_t height); 378 /** 379 * configures the anchor point of the surface 380 * 381 * Requests that the compositor anchor the surface to the 382 * specified edges and corners. If two orthogonal edges are 383 * specified (e.g. 'top' and 'left'), then the anchor point will be 384 * the intersection of the edges (e.g. the top left corner of the 385 * output); otherwise the anchor point will be centered on that 386 * edge, or in the center if none is specified. 387 * 388 * Anchor is double-buffered, see wl_surface.commit. 389 */ 390 void (*set_anchor)(struct wl_client *client, 391 struct wl_resource *resource, 392 uint32_t anchor); 393 /** 394 * configures the exclusive geometry of this surface 395 * 396 * Requests that the compositor avoids occluding an area with 397 * other surfaces. The compositor's use of this information is 398 * implementation-dependent - do not assume that this region will 399 * not actually be occluded. 400 * 401 * A positive value is only meaningful if the surface is anchored 402 * to one edge or an edge and both perpendicular edges. If the 403 * surface is not anchored, anchored to only two perpendicular 404 * edges (a corner), anchored to only two parallel edges or 405 * anchored to all edges, a positive value will be treated the same 406 * as zero. 407 * 408 * A positive zone is the distance from the edge in surface-local 409 * coordinates to consider exclusive. 410 * 411 * Surfaces that do not wish to have an exclusive zone may instead 412 * specify how they should interact with surfaces that do. If set 413 * to zero, the surface indicates that it would like to be moved to 414 * avoid occluding surfaces with a positive exclusive zone. If set 415 * to -1, the surface indicates that it would not like to be moved 416 * to accommodate for other surfaces, and the compositor should 417 * extend it all the way to the edges it is anchored to. 418 * 419 * For example, a panel might set its exclusive zone to 10, so that 420 * maximized shell surfaces are not shown on top of it. A 421 * notification might set its exclusive zone to 0, so that it is 422 * moved to avoid occluding the panel, but shell surfaces are shown 423 * underneath it. A wallpaper or lock screen might set their 424 * exclusive zone to -1, so that they stretch below or over the 425 * panel. 426 * 427 * The default value is 0. 428 * 429 * Exclusive zone is double-buffered, see wl_surface.commit. 430 */ 431 void (*set_exclusive_zone)(struct wl_client *client, 432 struct wl_resource *resource, 433 int32_t zone); 434 /** 435 * sets a margin from the anchor point 436 * 437 * Requests that the surface be placed some distance away from 438 * the anchor point on the output, in surface-local coordinates. 439 * Setting this value for edges you are not anchored to has no 440 * effect. 441 * 442 * The exclusive zone includes the margin. 443 * 444 * Margin is double-buffered, see wl_surface.commit. 445 */ 446 void (*set_margin)(struct wl_client *client, 447 struct wl_resource *resource, 448 int32_t top, 449 int32_t right, 450 int32_t bottom, 451 int32_t left); 452 /** 453 * requests keyboard events 454 * 455 * Set how keyboard events are delivered to this surface. By 456 * default, layer shell surfaces do not receive keyboard events; 457 * this request can be used to change this. 458 * 459 * This setting is inherited by child surfaces set by the get_popup 460 * request. 461 * 462 * Layer surfaces receive pointer, touch, and tablet events 463 * normally. If you do not want to receive them, set the input 464 * region on your surface to an empty region. 465 * 466 * Keyboard interactivity is double-buffered, see 467 * wl_surface.commit. 468 */ 469 void (*set_keyboard_interactivity)(struct wl_client *client, 470 struct wl_resource *resource, 471 uint32_t keyboard_interactivity); 472 /** 473 * assign this layer_surface as an xdg_popup parent 474 * 475 * This assigns an xdg_popup's parent to this layer_surface. This 476 * popup should have been created via xdg_surface::get_popup with 477 * the parent set to NULL, and this request must be invoked before 478 * committing the popup's initial state. 479 * 480 * See the documentation of xdg_popup for more details about what 481 * an xdg_popup is and how it is used. 482 */ 483 void (*get_popup)(struct wl_client *client, 484 struct wl_resource *resource, 485 struct wl_resource *popup); 486 /** 487 * ack a configure event 488 * 489 * When a configure event is received, if a client commits the 490 * surface in response to the configure event, then the client must 491 * make an ack_configure request sometime before the commit 492 * request, passing along the serial of the configure event. 493 * 494 * If the client receives multiple configure events before it can 495 * respond to one, it only has to ack the last configure event. 496 * 497 * A client is not required to commit immediately after sending an 498 * ack_configure request - it may even ack_configure several times 499 * before its next surface commit. 500 * 501 * A client may send multiple ack_configure requests before 502 * committing, but only the last request sent before a commit 503 * indicates which configure event the client really is responding 504 * to. 505 * @param serial the serial from the configure event 506 */ 507 void (*ack_configure)(struct wl_client *client, 508 struct wl_resource *resource, 509 uint32_t serial); 510 /** 511 * destroy the layer_surface 512 * 513 * This request destroys the layer surface. 514 */ 515 void (*destroy)(struct wl_client *client, 516 struct wl_resource *resource); 517 /** 518 * change the layer of the surface 519 * 520 * Change the layer that the surface is rendered on. 521 * 522 * Layer is double-buffered, see wl_surface.commit. 523 * @param layer layer to move this surface to 524 * @since 2 525 */ 526 void (*set_layer)(struct wl_client *client, 527 struct wl_resource *resource, 528 uint32_t layer); 529 }; 530 531 #define ZWLR_LAYER_SURFACE_V1_CONFIGURE 0 532 #define ZWLR_LAYER_SURFACE_V1_CLOSED 1 533 534 /** 535 * @ingroup iface_zwlr_layer_surface_v1 536 */ 537 #define ZWLR_LAYER_SURFACE_V1_CONFIGURE_SINCE_VERSION 1 538 /** 539 * @ingroup iface_zwlr_layer_surface_v1 540 */ 541 #define ZWLR_LAYER_SURFACE_V1_CLOSED_SINCE_VERSION 1 542 543 /** 544 * @ingroup iface_zwlr_layer_surface_v1 545 */ 546 #define ZWLR_LAYER_SURFACE_V1_SET_SIZE_SINCE_VERSION 1 547 /** 548 * @ingroup iface_zwlr_layer_surface_v1 549 */ 550 #define ZWLR_LAYER_SURFACE_V1_SET_ANCHOR_SINCE_VERSION 1 551 /** 552 * @ingroup iface_zwlr_layer_surface_v1 553 */ 554 #define ZWLR_LAYER_SURFACE_V1_SET_EXCLUSIVE_ZONE_SINCE_VERSION 1 555 /** 556 * @ingroup iface_zwlr_layer_surface_v1 557 */ 558 #define ZWLR_LAYER_SURFACE_V1_SET_MARGIN_SINCE_VERSION 1 559 /** 560 * @ingroup iface_zwlr_layer_surface_v1 561 */ 562 #define ZWLR_LAYER_SURFACE_V1_SET_KEYBOARD_INTERACTIVITY_SINCE_VERSION 1 563 /** 564 * @ingroup iface_zwlr_layer_surface_v1 565 */ 566 #define ZWLR_LAYER_SURFACE_V1_GET_POPUP_SINCE_VERSION 1 567 /** 568 * @ingroup iface_zwlr_layer_surface_v1 569 */ 570 #define ZWLR_LAYER_SURFACE_V1_ACK_CONFIGURE_SINCE_VERSION 1 571 /** 572 * @ingroup iface_zwlr_layer_surface_v1 573 */ 574 #define ZWLR_LAYER_SURFACE_V1_DESTROY_SINCE_VERSION 1 575 /** 576 * @ingroup iface_zwlr_layer_surface_v1 577 */ 578 #define ZWLR_LAYER_SURFACE_V1_SET_LAYER_SINCE_VERSION 2 579 580 /** 581 * @ingroup iface_zwlr_layer_surface_v1 582 * Sends an configure event to the client owning the resource. 583 * @param resource_ The client's resource 584 */ 585 static inline void 586 zwlr_layer_surface_v1_send_configure(struct wl_resource *resource_, uint32_t serial, uint32_t width, uint32_t height) 587 { 588 wl_resource_post_event(resource_, ZWLR_LAYER_SURFACE_V1_CONFIGURE, serial, width, height); 589 } 590 591 /** 592 * @ingroup iface_zwlr_layer_surface_v1 593 * Sends an closed event to the client owning the resource. 594 * @param resource_ The client's resource 595 */ 596 static inline void 597 zwlr_layer_surface_v1_send_closed(struct wl_resource *resource_) 598 { 599 wl_resource_post_event(resource_, ZWLR_LAYER_SURFACE_V1_CLOSED); 600 } 601 602 #ifdef __cplusplus 603 } 604 #endif 605 606 #endif