github.com/rajveermalviya/gamen@v0.1.2-0.20220930195403-9be15877c1aa/internal/wayland/xdg-shell-client-protocol.go

// Code generated by internal/wayland/wl/gen; DO NOT EDIT.
// XML file : ./protocols/xdg-shell.xml

//go:build linux && !android

package wayland

/*

#include "xdg-shell-client-protocol.h"

*/
import "C"
import "unsafe"

type enum_xdg_wm_base_error C.uint32_t

const (
	// given wl_surface has another role
	XDG_WM_BASE_ERROR_ROLE enum_xdg_wm_base_error = 0
	// xdg_wm_base was destroyed before children
	XDG_WM_BASE_ERROR_DEFUNCT_SURFACES enum_xdg_wm_base_error = 1
	// the client tried to map or destroy a non-topmost popup
	XDG_WM_BASE_ERROR_NOT_THE_TOPMOST_POPUP enum_xdg_wm_base_error = 2
	// the client specified an invalid popup parent surface
	XDG_WM_BASE_ERROR_INVALID_POPUP_PARENT enum_xdg_wm_base_error = 3
	// the client provided an invalid surface state
	XDG_WM_BASE_ERROR_INVALID_SURFACE_STATE enum_xdg_wm_base_error = 4
	// the client provided an invalid positioner
	XDG_WM_BASE_ERROR_INVALID_POSITIONER enum_xdg_wm_base_error = 5
)

func (l *wl_library) xdg_wm_base_add_listener(xdg_wm_base *C.struct_xdg_wm_base, listener *C.struct_xdg_wm_base_listener, data unsafe.Pointer) C.int {
	return C.gamen_xdg_wm_base_add_listener(l.wl_proxy_add_listener_handle, xdg_wm_base, listener, data)
}

// destroy xdg_wm_base
//
// Destroy this xdg_wm_base object.
//
// Destroying a bound xdg_wm_base object while there are surfaces
// still alive created by this xdg_wm_base object instance is illegal
// and will result in a protocol error.
func (l *wl_library) xdg_wm_base_destroy(xdg_wm_base *C.struct_xdg_wm_base) {
	C.gamen_xdg_wm_base_destroy(l.wl_proxy_marshal_flags, l.wl_proxy_get_version, xdg_wm_base)
}

// create a positioner object
//
// Create a positioner object. A positioner object is used to position
// surfaces relative to some parent surface. See the interface description
// and xdg_surface.get_popup for details.
func (l *wl_library) xdg_wm_base_create_positioner(xdg_wm_base *C.struct_xdg_wm_base) *C.struct_xdg_positioner {
	return C.gamen_xdg_wm_base_create_positioner(l.wl_proxy_marshal_flags, l.wl_proxy_get_version, xdg_wm_base)
}

// create a shell surface from a surface
//
// This creates an xdg_surface for the given surface. While xdg_surface
// itself is not a role, the corresponding surface may only be assigned
// a role extending xdg_surface, such as xdg_toplevel or xdg_popup. It is
// illegal to create an xdg_surface for a wl_surface which already has an
// assigned role and this will result in a protocol error.
//
// This creates an xdg_surface for the given surface. An xdg_surface is
// used as basis to define a role to a given surface, such as xdg_toplevel
// or xdg_popup. It also manages functionality shared between xdg_surface
// based surface roles.
//
// See the documentation of xdg_surface for more details about what an
// xdg_surface is and how it is used.
func (l *wl_library) xdg_wm_base_get_xdg_surface(xdg_wm_base *C.struct_xdg_wm_base, surface *C.struct_wl_surface) *C.struct_xdg_surface {
	return C.gamen_xdg_wm_base_get_xdg_surface(l.wl_proxy_marshal_flags, l.wl_proxy_get_version, xdg_wm_base, surface)
}

// respond to a ping event
//
// A client must respond to a ping event with a pong request or
// the client may be deemed unresponsive. See xdg_wm_base.ping.
func (l *wl_library) xdg_wm_base_pong(xdg_wm_base *C.struct_xdg_wm_base, serial C.uint32_t) {
	C.gamen_xdg_wm_base_pong(l.wl_proxy_marshal_flags, l.wl_proxy_get_version, xdg_wm_base, serial)
}

type enum_xdg_positioner_error C.uint32_t

const (
	// invalid input provided
	XDG_POSITIONER_ERROR_INVALID_INPUT enum_xdg_positioner_error = 0
)

type enum_xdg_positioner_anchor C.uint32_t

const (
	XDG_POSITIONER_ANCHOR_NONE         enum_xdg_positioner_anchor = 0
	XDG_POSITIONER_ANCHOR_TOP          enum_xdg_positioner_anchor = 1
	XDG_POSITIONER_ANCHOR_BOTTOM       enum_xdg_positioner_anchor = 2
	XDG_POSITIONER_ANCHOR_LEFT         enum_xdg_positioner_anchor = 3
	XDG_POSITIONER_ANCHOR_RIGHT        enum_xdg_positioner_anchor = 4
	XDG_POSITIONER_ANCHOR_TOP_LEFT     enum_xdg_positioner_anchor = 5
	XDG_POSITIONER_ANCHOR_BOTTOM_LEFT  enum_xdg_positioner_anchor = 6
	XDG_POSITIONER_ANCHOR_TOP_RIGHT    enum_xdg_positioner_anchor = 7
	XDG_POSITIONER_ANCHOR_BOTTOM_RIGHT enum_xdg_positioner_anchor = 8
)

type enum_xdg_positioner_gravity C.uint32_t

const (
	XDG_POSITIONER_GRAVITY_NONE         enum_xdg_positioner_gravity = 0
	XDG_POSITIONER_GRAVITY_TOP          enum_xdg_positioner_gravity = 1
	XDG_POSITIONER_GRAVITY_BOTTOM       enum_xdg_positioner_gravity = 2
	XDG_POSITIONER_GRAVITY_LEFT         enum_xdg_positioner_gravity = 3
	XDG_POSITIONER_GRAVITY_RIGHT        enum_xdg_positioner_gravity = 4
	XDG_POSITIONER_GRAVITY_TOP_LEFT     enum_xdg_positioner_gravity = 5
	XDG_POSITIONER_GRAVITY_BOTTOM_LEFT  enum_xdg_positioner_gravity = 6
	XDG_POSITIONER_GRAVITY_TOP_RIGHT    enum_xdg_positioner_gravity = 7
	XDG_POSITIONER_GRAVITY_BOTTOM_RIGHT enum_xdg_positioner_gravity = 8
)

// The constraint adjustment value define ways the compositor will adjust
// the position of the surface, if the unadjusted position would result
// in the surface being partly constrained.
//
// Whether a surface is considered 'constrained' is left to the compositor
// to determine. For example, the surface may be partly outside the
// compositor's defined 'work area', thus necessitating the child surface's
// position be adjusted until it is entirely inside the work area.
//
// The adjustments can be combined, according to a defined precedence: 1)
// Flip, 2) Slide, 3) Resize.
type enum_xdg_positioner_constraint_adjustment C.uint32_t

const (
	XDG_POSITIONER_CONSTRAINT_ADJUSTMENT_NONE     enum_xdg_positioner_constraint_adjustment = 0
	XDG_POSITIONER_CONSTRAINT_ADJUSTMENT_SLIDE_X  enum_xdg_positioner_constraint_adjustment = 1
	XDG_POSITIONER_CONSTRAINT_ADJUSTMENT_SLIDE_Y  enum_xdg_positioner_constraint_adjustment = 2
	XDG_POSITIONER_CONSTRAINT_ADJUSTMENT_FLIP_X   enum_xdg_positioner_constraint_adjustment = 4
	XDG_POSITIONER_CONSTRAINT_ADJUSTMENT_FLIP_Y   enum_xdg_positioner_constraint_adjustment = 8
	XDG_POSITIONER_CONSTRAINT_ADJUSTMENT_RESIZE_X enum_xdg_positioner_constraint_adjustment = 16
	XDG_POSITIONER_CONSTRAINT_ADJUSTMENT_RESIZE_Y enum_xdg_positioner_constraint_adjustment = 32
)

// destroy the xdg_positioner object
//
// Notify the compositor that the xdg_positioner will no longer be used.
func (l *wl_library) xdg_positioner_destroy(xdg_positioner *C.struct_xdg_positioner) {
	C.gamen_xdg_positioner_destroy(l.wl_proxy_marshal_flags, l.wl_proxy_get_version, xdg_positioner)
}

// set the size of the to-be positioned rectangle
//
// Set the size of the surface that is to be positioned with the positioner
// object. The size is in surface-local coordinates and corresponds to the
// window geometry. See xdg_surface.set_window_geometry.
//
// If a zero or negative size is set the invalid_input error is raised.
func (l *wl_library) xdg_positioner_set_size(xdg_positioner *C.struct_xdg_positioner, width, height C.int32_t) {
	C.gamen_xdg_positioner_set_size(l.wl_proxy_marshal_flags, l.wl_proxy_get_version, xdg_positioner, width, height)
}

// set the anchor rectangle within the parent surface
//
// Specify the anchor rectangle within the parent surface that the child
// surface will be placed relative to. The rectangle is relative to the
// window geometry as defined by xdg_surface.set_window_geometry of the
// parent surface.
//
// When the xdg_positioner object is used to position a child surface, the
// anchor rectangle may not extend outside the window geometry of the
// positioned child's parent surface.
//
// If a negative size is set the invalid_input error is raised.
func (l *wl_library) xdg_positioner_set_anchor_rect(xdg_positioner *C.struct_xdg_positioner, x, y, width, height C.int32_t) {
	C.gamen_xdg_positioner_set_anchor_rect(l.wl_proxy_marshal_flags, l.wl_proxy_get_version, xdg_positioner, x, y, width, height)
}

// set anchor rectangle anchor
//
// Defines the anchor point for the anchor rectangle. The specified anchor
// is used derive an anchor point that the child surface will be
// positioned relative to. If a corner anchor is set (e.g. 'top_left' or
// 'bottom_right'), the anchor point will be at the specified corner;
// otherwise, the derived anchor point will be centered on the specified
// edge, or in the center of the anchor rectangle if no edge is specified.
func (l *wl_library) xdg_positioner_set_anchor(xdg_positioner *C.struct_xdg_positioner, anchor enum_xdg_positioner_anchor) {
	C.gamen_xdg_positioner_set_anchor(l.wl_proxy_marshal_flags, l.wl_proxy_get_version, xdg_positioner, C.uint32_t(anchor))
}

// set child surface gravity
//
// Defines in what direction a surface should be positioned, relative to
// the anchor point of the parent surface. If a corner gravity is
// specified (e.g. 'bottom_right' or 'top_left'), then the child surface
// will be placed towards the specified gravity; otherwise, the child
// surface will be centered over the anchor point on any axis that had no
// gravity specified.
func (l *wl_library) xdg_positioner_set_gravity(xdg_positioner *C.struct_xdg_positioner, gravity enum_xdg_positioner_gravity) {
	C.gamen_xdg_positioner_set_gravity(l.wl_proxy_marshal_flags, l.wl_proxy_get_version, xdg_positioner, C.uint32_t(gravity))
}

// set the adjustment to be done when constrained
//
// Specify how the window should be positioned if the originally intended
// position caused the surface to be constrained, meaning at least
// partially outside positioning boundaries set by the compositor. The
// adjustment is set by constructing a bitmask describing the adjustment to
// be made when the surface is constrained on that axis.
//
// If no bit for one axis is set, the compositor will assume that the child
// surface should not change its position on that axis when constrained.
//
// If more than one bit for one axis is set, the order of how adjustments
// are applied is specified in the corresponding adjustment descriptions.
//
// The default adjustment is none.
func (l *wl_library) xdg_positioner_set_constraint_adjustment(xdg_positioner *C.struct_xdg_positioner, constraint_adjustment C.uint32_t) {
	C.gamen_xdg_positioner_set_constraint_adjustment(l.wl_proxy_marshal_flags, l.wl_proxy_get_version, xdg_positioner, constraint_adjustment)
}

// set surface position offset
//
// Specify the surface position offset relative to the position of the
// anchor on the anchor rectangle and the anchor on the surface. For
// example if the anchor of the anchor rectangle is at (x, y), the surface
// has the gravity bottom|right, and the offset is (ox, oy), the calculated
// surface position will be (x + ox, y + oy). The offset position of the
// surface is the one used for constraint testing. See
// set_constraint_adjustment.
//
// An example use case is placing a popup menu on top of a user interface
// element, while aligning the user interface element of the parent surface
// with some user interface element placed somewhere in the popup surface.
func (l *wl_library) xdg_positioner_set_offset(xdg_positioner *C.struct_xdg_positioner, x, y C.int32_t) {
	C.gamen_xdg_positioner_set_offset(l.wl_proxy_marshal_flags, l.wl_proxy_get_version, xdg_positioner, x, y)
}

// continuously reconstrain the surface
//
// When set reactive, the surface is reconstrained if the conditions used
// for constraining changed, e.g. the parent window moved.
//
// If the conditions changed and the popup was reconstrained, an
// xdg_popup.configure event is sent with updated geometry, followed by an
// xdg_surface.configure event.
func (l *wl_library) xdg_positioner_set_reactive(xdg_positioner *C.struct_xdg_positioner) {
	C.gamen_xdg_positioner_set_reactive(l.wl_proxy_marshal_flags, l.wl_proxy_get_version, xdg_positioner)
}

// Set the parent window geometry the compositor should use when
// positioning the popup. The compositor may use this information to
// determine the future state the popup should be constrained using. If
// this doesn't match the dimension of the parent the popup is eventually
// positioned against, the behavior is undefined.
//
// The arguments are given in the surface-local coordinate space.
func (l *wl_library) xdg_positioner_set_parent_size(xdg_positioner *C.struct_xdg_positioner, parent_width, parent_height C.int32_t) {
	C.gamen_xdg_positioner_set_parent_size(l.wl_proxy_marshal_flags, l.wl_proxy_get_version, xdg_positioner, parent_width, parent_height)
}

// set parent configure this is a response to
//
// Set the serial of an xdg_surface.configure event this positioner will be
// used in response to. The compositor may use this information together
// with set_parent_size to determine what future state the popup should be
// constrained using.
func (l *wl_library) xdg_positioner_set_parent_configure(xdg_positioner *C.struct_xdg_positioner, serial C.uint32_t) {
	C.gamen_xdg_positioner_set_parent_configure(l.wl_proxy_marshal_flags, l.wl_proxy_get_version, xdg_positioner, serial)
}

type enum_xdg_surface_error C.uint32_t

const (
	XDG_SURFACE_ERROR_NOT_CONSTRUCTED     enum_xdg_surface_error = 1
	XDG_SURFACE_ERROR_ALREADY_CONSTRUCTED enum_xdg_surface_error = 2
	XDG_SURFACE_ERROR_UNCONFIGURED_BUFFER enum_xdg_surface_error = 3
)

func (l *wl_library) xdg_surface_add_listener(xdg_surface *C.struct_xdg_surface, listener *C.struct_xdg_surface_listener, data unsafe.Pointer) C.int {
	return C.gamen_xdg_surface_add_listener(l.wl_proxy_add_listener_handle, xdg_surface, listener, data)
}

// destroy the xdg_surface
//
// Destroy the xdg_surface object. An xdg_surface must only be destroyed
// after its role object has been destroyed.
func (l *wl_library) xdg_surface_destroy(xdg_surface *C.struct_xdg_surface) {
	C.gamen_xdg_surface_destroy(l.wl_proxy_marshal_flags, l.wl_proxy_get_version, xdg_surface)
}

// assign the xdg_toplevel surface role
//
// This creates an xdg_toplevel object for the given xdg_surface and gives
// the associated wl_surface the xdg_toplevel role.
//
// See the documentation of xdg_toplevel for more details about what an
// xdg_toplevel is and how it is used.
func (l *wl_library) xdg_surface_get_toplevel(xdg_surface *C.struct_xdg_surface) *C.struct_xdg_toplevel {
	return C.gamen_xdg_surface_get_toplevel(l.wl_proxy_marshal_flags, l.wl_proxy_get_version, xdg_surface)
}

// assign the xdg_popup surface role
//
// This creates an xdg_popup object for the given xdg_surface and gives
// the associated wl_surface the xdg_popup role.
//
// If null is passed as a parent, a parent surface must be specified using
// some other protocol, before committing the initial state.
//
// See the documentation of xdg_popup for more details about what an
// xdg_popup is and how it is used.
func (l *wl_library) xdg_surface_get_popup(xdg_surface, parent *C.struct_xdg_surface, positioner *C.struct_xdg_positioner) *C.struct_xdg_popup {
	return C.gamen_xdg_surface_get_popup(l.wl_proxy_marshal_flags, l.wl_proxy_get_version, xdg_surface, parent, positioner)
}

// set the new window geometry
//
// The window geometry of a surface is its "visible bounds" from the
// user's perspective. Client-side decorations often have invisible
// portions like drop-shadows which should be ignored for the
// purposes of aligning, placing and constraining windows.
//
// The window geometry is double buffered, and will be applied at the
// time wl_surface.commit of the corresponding wl_surface is called.
//
// When maintaining a position, the compositor should treat the (x, y)
// coordinate of the window geometry as the top left corner of the window.
// A client changing the (x, y) window geometry coordinate should in
// general not alter the position of the window.
//
// Once the window geometry of the surface is set, it is not possible to
// unset it, and it will remain the same until set_window_geometry is
// called again, even if a new subsurface or buffer is attached.
//
// If never set, the value is the full bounds of the surface,
// including any subsurfaces. This updates dynamically on every
// commit. This unset is meant for extremely simple clients.
//
// The arguments are given in the surface-local coordinate space of
// the wl_surface associated with this xdg_surface.
//
// The width and height must be greater than zero. Setting an invalid size
// will raise an error. When applied, the effective window geometry will be
// the set window geometry clamped to the bounding rectangle of the
// combined geometry of the surface of the xdg_surface and the associated
// subsurfaces.
func (l *wl_library) xdg_surface_set_window_geometry(xdg_surface *C.struct_xdg_surface, x, y, width, height C.int32_t) {
	C.gamen_xdg_surface_set_window_geometry(l.wl_proxy_marshal_flags, l.wl_proxy_get_version, xdg_surface, x, y, width, height)
}

// 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.
//
// For instance, for toplevel surfaces the compositor might use this
// information to move a surface to the top left only when the client has
// drawn itself for the maximized or fullscreen state.
//
// 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.
func (l *wl_library) xdg_surface_ack_configure(xdg_surface *C.struct_xdg_surface, serial C.uint32_t) {
	C.gamen_xdg_surface_ack_configure(l.wl_proxy_marshal_flags, l.wl_proxy_get_version, xdg_surface, serial)
}

type enum_xdg_toplevel_error C.uint32_t

const (
	// provided value is
	// not a valid variant of the resize_edge enum
	XDG_TOPLEVEL_ERROR_INVALID_RESIZE_EDGE enum_xdg_toplevel_error = 0
)

// These values are used to indicate which edge of a surface
// is being dragged in a resize operation.
type enum_xdg_toplevel_resize_edge C.uint32_t

const (
	XDG_TOPLEVEL_RESIZE_EDGE_NONE         enum_xdg_toplevel_resize_edge = 0
	XDG_TOPLEVEL_RESIZE_EDGE_TOP          enum_xdg_toplevel_resize_edge = 1
	XDG_TOPLEVEL_RESIZE_EDGE_BOTTOM       enum_xdg_toplevel_resize_edge = 2
	XDG_TOPLEVEL_RESIZE_EDGE_LEFT         enum_xdg_toplevel_resize_edge = 4
	XDG_TOPLEVEL_RESIZE_EDGE_TOP_LEFT     enum_xdg_toplevel_resize_edge = 5
	XDG_TOPLEVEL_RESIZE_EDGE_BOTTOM_LEFT  enum_xdg_toplevel_resize_edge = 6
	XDG_TOPLEVEL_RESIZE_EDGE_RIGHT        enum_xdg_toplevel_resize_edge = 8
	XDG_TOPLEVEL_RESIZE_EDGE_TOP_RIGHT    enum_xdg_toplevel_resize_edge = 9
	XDG_TOPLEVEL_RESIZE_EDGE_BOTTOM_RIGHT enum_xdg_toplevel_resize_edge = 10
)

// The different state values used on the surface. This is designed for
// state values like maximized, fullscreen. It is paired with the
// configure event to ensure that both the client and the compositor
// setting the state can be synchronized.
//
// States set in this way are double-buffered. They will get applied on
// the next commit.
type enum_xdg_toplevel_state C.uint32_t

const (
	// the surface is maximized
	XDG_TOPLEVEL_STATE_MAXIMIZED enum_xdg_toplevel_state = 1
	// the surface is fullscreen
	XDG_TOPLEVEL_STATE_FULLSCREEN enum_xdg_toplevel_state = 2
	// the surface is being resized
	XDG_TOPLEVEL_STATE_RESIZING enum_xdg_toplevel_state = 3
	// the surface is now activated
	XDG_TOPLEVEL_STATE_ACTIVATED    enum_xdg_toplevel_state = 4
	XDG_TOPLEVEL_STATE_TILED_LEFT   enum_xdg_toplevel_state = 5
	XDG_TOPLEVEL_STATE_TILED_RIGHT  enum_xdg_toplevel_state = 6
	XDG_TOPLEVEL_STATE_TILED_TOP    enum_xdg_toplevel_state = 7
	XDG_TOPLEVEL_STATE_TILED_BOTTOM enum_xdg_toplevel_state = 8
)

type enum_xdg_toplevel_wm_capabilities C.uint32_t

const (
	// show_window_menu is available
	XDG_TOPLEVEL_WM_CAPABILITIES_WINDOW_MENU enum_xdg_toplevel_wm_capabilities = 1
	// set_maximized and unset_maximized are available
	XDG_TOPLEVEL_WM_CAPABILITIES_MAXIMIZE enum_xdg_toplevel_wm_capabilities = 2
	// set_fullscreen and unset_fullscreen are available
	XDG_TOPLEVEL_WM_CAPABILITIES_FULLSCREEN enum_xdg_toplevel_wm_capabilities = 3
	// set_minimized is available
	XDG_TOPLEVEL_WM_CAPABILITIES_MINIMIZE enum_xdg_toplevel_wm_capabilities = 4
)

func (l *wl_library) xdg_toplevel_add_listener(xdg_toplevel *C.struct_xdg_toplevel, listener *C.struct_xdg_toplevel_listener, data unsafe.Pointer) C.int {
	return C.gamen_xdg_toplevel_add_listener(l.wl_proxy_add_listener_handle, xdg_toplevel, listener, data)
}

// destroy the xdg_toplevel
//
// This request destroys the role surface and unmaps the surface;
// see "Unmapping" behavior in interface section for details.
func (l *wl_library) xdg_toplevel_destroy(xdg_toplevel *C.struct_xdg_toplevel) {
	C.gamen_xdg_toplevel_destroy(l.wl_proxy_marshal_flags, l.wl_proxy_get_version, xdg_toplevel)
}

// set the parent of this surface
//
// Set the "parent" of this surface. This surface should be stacked
// above the parent surface and all other ancestor surfaces.
//
// Parent surfaces should be set on dialogs, toolboxes, or other
// "auxiliary" surfaces, so that the parent is raised when the dialog
// is raised.
//
// Setting a null parent for a child surface unsets its parent. Setting
// a null parent for a surface which currently has no parent is a no-op.
//
// Only mapped surfaces can have child surfaces. Setting a parent which
// is not mapped is equivalent to setting a null parent. If a surface
// becomes unmapped, its children's parent is set to the parent of
// the now-unmapped surface. If the now-unmapped surface has no parent,
// its children's parent is unset. If the now-unmapped surface becomes
// mapped again, its parent-child relationship is not restored.
func (l *wl_library) xdg_toplevel_set_parent(xdg_toplevel, parent *C.struct_xdg_toplevel) {
	C.gamen_xdg_toplevel_set_parent(l.wl_proxy_marshal_flags, l.wl_proxy_get_version, xdg_toplevel, parent)
}

// set surface title
//
// Set a short title for the surface.
//
// This string may be used to identify the surface in a task bar,
// window list, or other user interface elements provided by the
// compositor.
//
// The string must be encoded in UTF-8.
func (l *wl_library) xdg_toplevel_set_title(xdg_toplevel *C.struct_xdg_toplevel, title *C.char) {
	C.gamen_xdg_toplevel_set_title(l.wl_proxy_marshal_flags, l.wl_proxy_get_version, xdg_toplevel, title)
}

// set application ID
//
// Set an application identifier for the surface.
//
// The app ID identifies the general class of applications to which
// the surface belongs. The compositor can use this to group multiple
// surfaces together, or to determine how to launch a new application.
//
// For D-Bus activatable applications, the app ID is used as the D-Bus
// service name.
//
// The compositor shell will try to group application surfaces together
// by their app ID. As a best practice, it is suggested to select app
// ID's that match the basename of the application's .desktop file.
// For example, "org.freedesktop.FooViewer" where the .desktop file is
// "org.freedesktop.FooViewer.desktop".
//
// Like other properties, a set_app_id request can be sent after the
// xdg_toplevel has been mapped to update the property.
//
// See the desktop-entry specification [0] for more details on
// application identifiers and how they relate to well-known D-Bus
// names and .desktop files.
//
// [0] http://standards.freedesktop.org/desktop-entry-spec/
func (l *wl_library) xdg_toplevel_set_app_id(xdg_toplevel *C.struct_xdg_toplevel, app_id *C.char) {
	C.gamen_xdg_toplevel_set_app_id(l.wl_proxy_marshal_flags, l.wl_proxy_get_version, xdg_toplevel, app_id)
}

// show the window menu
//
// Clients implementing client-side decorations might want to show
// a context menu when right-clicking on the decorations, giving the
// user a menu that they can use to maximize or minimize the window.
//
// This request asks the compositor to pop up such a window menu at
// the given position, relative to the local surface coordinates of
// the parent surface. There are no guarantees as to what menu items
// the window menu contains.
//
// This request must be used in response to some sort of user action
// like a button press, key press, or touch down event.
func (l *wl_library) xdg_toplevel_show_window_menu(xdg_toplevel *C.struct_xdg_toplevel, seat *C.struct_wl_seat, serial C.uint32_t, x, y C.int32_t) {
	C.gamen_xdg_toplevel_show_window_menu(l.wl_proxy_marshal_flags, l.wl_proxy_get_version, xdg_toplevel, seat, serial, x, y)
}

// start an interactive move
//
// Start an interactive, user-driven move of the surface.
//
// This request must be used in response to some sort of user action
// like a button press, key press, or touch down event. The passed
// serial is used to determine the type of interactive move (touch,
// pointer, etc).
//
// The server may ignore move requests depending on the state of
// the surface (e.g. fullscreen or maximized), or if the passed serial
// is no longer valid.
//
// If triggered, the surface will lose the focus of the device
// (wl_pointer, wl_touch, etc) used for the move. It is up to the
// compositor to visually indicate that the move is taking place, such as
// updating a pointer cursor, during the move. There is no guarantee
// that the device focus will return when the move is completed.
func (l *wl_library) xdg_toplevel_move(xdg_toplevel *C.struct_xdg_toplevel, seat *C.struct_wl_seat, serial C.uint32_t) {
	C.gamen_xdg_toplevel_move(l.wl_proxy_marshal_flags, l.wl_proxy_get_version, xdg_toplevel, seat, serial)
}

// start an interactive resize
//
// Start a user-driven, interactive resize of the surface.
//
// This request must be used in response to some sort of user action
// like a button press, key press, or touch down event. The passed
// serial is used to determine the type of interactive resize (touch,
// pointer, etc).
//
// The server may ignore resize requests depending on the state of
// the surface (e.g. fullscreen or maximized).
//
// If triggered, the client will receive configure events with the
// "resize" state enum value and the expected sizes. See the "resize"
// enum value for more details about what is required. The client
// must also acknowledge configure events using "ack_configure". After
// the resize is completed, the client will receive another "configure"
// event without the resize state.
//
// If triggered, the surface also will lose the focus of the device
// (wl_pointer, wl_touch, etc) used for the resize. It is up to the
// compositor to visually indicate that the resize is taking place,
// such as updating a pointer cursor, during the resize. There is no
// 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. 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.
func (l *wl_library) xdg_toplevel_resize(xdg_toplevel *C.struct_xdg_toplevel, seat *C.struct_wl_seat, serial C.uint32_t, edges enum_xdg_toplevel_resize_edge) {
	C.gamen_xdg_toplevel_resize(l.wl_proxy_marshal_flags, l.wl_proxy_get_version, xdg_toplevel, seat, serial, C.uint32_t(edges))
}

// set the maximum size
//
// Set a maximum size for the window.
//
// The client can specify a maximum size so that the compositor does
// not try to configure the window beyond this size.
//
// The width and height arguments are in window geometry coordinates.
// See xdg_surface.set_window_geometry.
//
// Values set in this way are double-buffered. They will get applied
// on the next commit.
//
// The compositor can use this information to allow or disallow
// different states like maximize or fullscreen and draw accurate
// animations.
//
// Similarly, a tiling window manager may use this information to
// place and resize client windows in a more effective way.
//
// The client should not rely on the compositor to obey the maximum
// size. The compositor may decide to ignore the values set by the
// client and request a larger size.
//
// If never set, or a value of zero in the request, means that the
// client has no expected maximum size in the given dimension.
// As a result, a client wishing to reset the maximum size
// to an unspecified state can use zero for width and height in the
// request.
//
// Requesting a maximum size to be smaller than the minimum size of
// a surface is illegal and will result in a protocol error.
//
// The width and height must be greater than or equal to zero. Using
// strictly negative values for width and height will result in a
// protocol error.
func (l *wl_library) xdg_toplevel_set_max_size(xdg_toplevel *C.struct_xdg_toplevel, width, height C.int32_t) {
	C.gamen_xdg_toplevel_set_max_size(l.wl_proxy_marshal_flags, l.wl_proxy_get_version, xdg_toplevel, width, height)
}

// set the minimum size
//
// Set a minimum size for the window.
//
// The client can specify a minimum size so that the compositor does
// not try to configure the window below this size.
//
// The width and height arguments are in window geometry coordinates.
// See xdg_surface.set_window_geometry.
//
// Values set in this way are double-buffered. They will get applied
// on the next commit.
//
// The compositor can use this information to allow or disallow
// different states like maximize or fullscreen and draw accurate
// animations.
//
// Similarly, a tiling window manager may use this information to
// place and resize client windows in a more effective way.
//
// The client should not rely on the compositor to obey the minimum
// size. The compositor may decide to ignore the values set by the
// client and request a smaller size.
//
// If never set, or a value of zero in the request, means that the
// client has no expected minimum size in the given dimension.
// As a result, a client wishing to reset the minimum size
// to an unspecified state can use zero for width and height in the
// request.
//
// Requesting a minimum size to be larger than the maximum size of
// a surface is illegal and will result in a protocol error.
//
// The width and height must be greater than or equal to zero. Using
// strictly negative values for width and height will result in a
// protocol error.
func (l *wl_library) xdg_toplevel_set_min_size(xdg_toplevel *C.struct_xdg_toplevel, width, height C.int32_t) {
	C.gamen_xdg_toplevel_set_min_size(l.wl_proxy_marshal_flags, l.wl_proxy_get_version, xdg_toplevel, width, height)
}

// maximize the window
//
// Maximize the surface.
//
// After requesting that the surface should be maximized, the compositor
// will respond by emitting a configure event. Whether this configure
// actually sets the window maximized is subject to compositor policies.
// The client must then update its content, drawing in the configured
// state. The client must also acknowledge the configure when committing
// the new content (see ack_configure).
//
// It is up to the compositor to decide how and where to maximize the
// surface, for example which output and what region of the screen should
// be used.
//
// If the surface was already maximized, the compositor will still emit
// a configure event with the "maximized" state.
//
// If the surface is in a fullscreen state, this request has no direct
// effect. It may alter the state the surface is returned to when
// unmaximized unless overridden by the compositor.
func (l *wl_library) xdg_toplevel_set_maximized(xdg_toplevel *C.struct_xdg_toplevel) {
	C.gamen_xdg_toplevel_set_maximized(l.wl_proxy_marshal_flags, l.wl_proxy_get_version, xdg_toplevel)
}

// unmaximize the window
//
// Unmaximize the surface.
//
// After requesting that the surface should be unmaximized, the compositor
// will respond by emitting a configure event. Whether this actually
// un-maximizes the window is subject to compositor policies.
// If available and applicable, the compositor will include the window
// geometry dimensions the window had prior to being maximized in the
// configure event. The client must then update its content, drawing it in
// the configured state. The client must also acknowledge the configure
// when committing the new content (see ack_configure).
//
// It is up to the compositor to position the surface after it was
// unmaximized; usually the position the surface had before maximizing, if
// applicable.
//
// If the surface was already not maximized, the compositor will still
// emit a configure event without the "maximized" state.
//
// If the surface is in a fullscreen state, this request has no direct
// effect. It may alter the state the surface is returned to when
// unmaximized unless overridden by the compositor.
func (l *wl_library) xdg_toplevel_unset_maximized(xdg_toplevel *C.struct_xdg_toplevel) {
	C.gamen_xdg_toplevel_unset_maximized(l.wl_proxy_marshal_flags, l.wl_proxy_get_version, xdg_toplevel)
}

// set the window as fullscreen on an output
//
// Make the surface fullscreen.
//
// After requesting that the surface should be fullscreened, the
// compositor will respond by emitting a configure event. Whether the
// client is actually put into a fullscreen state is subject to compositor
// policies. The client must also acknowledge the configure when
// committing the new content (see ack_configure).
//
// The output passed by the request indicates the client's preference as
// to which display it should be set fullscreen on. If this value is NULL,
// it's up to the compositor to choose which display will be used to map
// this surface.
//
// If the surface doesn't cover the whole output, the compositor will
// position the surface in the center of the output and compensate with
// with border fill covering the rest of the output. The content of the
// border fill is undefined, but should be assumed to be in some way that
// attempts to blend into the surrounding area (e.g. solid black).
//
// If the fullscreened surface is not opaque, the compositor must make
// sure that other screen content not part of the same surface tree (made
// up of subsurfaces, popups or similarly coupled surfaces) are not
// visible below the fullscreened surface.
func (l *wl_library) xdg_toplevel_set_fullscreen(xdg_toplevel *C.struct_xdg_toplevel, output *C.struct_wl_output) {
	C.gamen_xdg_toplevel_set_fullscreen(l.wl_proxy_marshal_flags, l.wl_proxy_get_version, xdg_toplevel, output)
}

// unset the window as fullscreen
//
// Make the surface no longer fullscreen.
//
// After requesting that the surface should be unfullscreened, the
// compositor will respond by emitting a configure event.
// Whether this actually removes the fullscreen state of the client is
// subject to compositor policies.
//
// Making a surface unfullscreen sets states for the surface based on the following:
// * the state(s) it may have had before becoming fullscreen
// * any state(s) decided by the compositor
// * any state(s) requested by the client while the surface was fullscreen
//
// The compositor may include the previous window geometry dimensions in
// the configure event, if applicable.
//
// The client must also acknowledge the configure when committing the new
// content (see ack_configure).
func (l *wl_library) xdg_toplevel_unset_fullscreen(xdg_toplevel *C.struct_xdg_toplevel) {
	C.gamen_xdg_toplevel_unset_fullscreen(l.wl_proxy_marshal_flags, l.wl_proxy_get_version, xdg_toplevel)
}

// set the window as minimized
//
// Request that the compositor minimize your surface. There is no
// way to know if the surface is currently minimized, nor is there
// any way to unset minimization on this surface.
//
// If you are looking to throttle redrawing when minimized, please
// instead use the wl_surface.frame event for this, as this will
// also work with live previews on windows in Alt-Tab, Expose or
// similar compositor features.
func (l *wl_library) xdg_toplevel_set_minimized(xdg_toplevel *C.struct_xdg_toplevel) {
	C.gamen_xdg_toplevel_set_minimized(l.wl_proxy_marshal_flags, l.wl_proxy_get_version, xdg_toplevel)
}

type enum_xdg_popup_error C.uint32_t

const (
	// tried to grab after being mapped
	XDG_POPUP_ERROR_INVALID_GRAB enum_xdg_popup_error = 0
)

func (l *wl_library) xdg_popup_add_listener(xdg_popup *C.struct_xdg_popup, listener *C.struct_xdg_popup_listener, data unsafe.Pointer) C.int {
	return C.gamen_xdg_popup_add_listener(l.wl_proxy_add_listener_handle, xdg_popup, listener, data)
}

// remove xdg_popup interface
//
// This destroys the popup. Explicitly destroying the xdg_popup
// object will also dismiss the popup, and unmap the surface.
//
// If this xdg_popup is not the "topmost" popup, a protocol error
// will be sent.
func (l *wl_library) xdg_popup_destroy(xdg_popup *C.struct_xdg_popup) {
	C.gamen_xdg_popup_destroy(l.wl_proxy_marshal_flags, l.wl_proxy_get_version, xdg_popup)
}

// make the popup take an explicit grab
//
// This request makes the created popup take an explicit grab. An explicit
// grab will be dismissed when the user dismisses the popup, or when the
// client destroys the xdg_popup. This can be done by the user clicking
// outside the surface, using the keyboard, or even locking the screen
// through closing the lid or a timeout.
//
// If the compositor denies the grab, the popup will be immediately
// dismissed.
//
// This request must be used in response to some sort of user action like a
// button press, key press, or touch down event. The serial number of the
// event should be passed as 'serial'.
//
// The parent of a grabbing popup must either be an xdg_toplevel surface or
// another xdg_popup with an explicit grab. If the parent is another
// xdg_popup it means that the popups are nested, with this popup now being
// the topmost popup.
//
// Nested popups must be destroyed in the reverse order they were created
// in, e.g. the only popup you are allowed to destroy at all times is the
// topmost one.
//
// When compositors choose to dismiss a popup, they may dismiss every
// nested grabbing popup as well. When a compositor dismisses popups, it
// will follow the same dismissing order as required from the client.
//
// If the topmost grabbing popup is destroyed, the grab will be returned to
// the parent of the popup, if that parent previously had an explicit grab.
//
// If the parent is a grabbing popup which has already been dismissed, this
// popup will be immediately dismissed. If the parent is a popup that did
// not take an explicit grab, an error will be raised.
//
// During a popup grab, the client owning the grab will receive pointer
// and touch events for all their surfaces as normal (similar to an
// "owner-events" grab in X11 parlance), while the top most grabbing popup
// will always have keyboard focus.
func (l *wl_library) xdg_popup_grab(xdg_popup *C.struct_xdg_popup, seat *C.struct_wl_seat, serial C.uint32_t) {
	C.gamen_xdg_popup_grab(l.wl_proxy_marshal_flags, l.wl_proxy_get_version, xdg_popup, seat, serial)
}

// recalculate the popup's location
//
// Reposition an already-mapped popup. The popup will be placed given the
// details in the passed xdg_positioner object, and a
// xdg_popup.repositioned followed by xdg_popup.configure and
// xdg_surface.configure will be emitted in response. Any parameters set
// by the previous positioner will be discarded.
//
// The passed token will be sent in the corresponding
// xdg_popup.repositioned event. The new popup position will not take
// effect until the corresponding configure event is acknowledged by the
// client. See xdg_popup.repositioned for details. The token itself is
// opaque, and has no other special meaning.
//
// If multiple reposition requests are sent, the compositor may skip all
// but the last one.
//
// If the popup is repositioned in response to a configure event for its
// parent, the client should send an xdg_positioner.set_parent_configure
// and possibly an xdg_positioner.set_parent_size request to allow the
// compositor to properly constrain the popup.
//
// If the popup is repositioned together with a parent that is being
// resized, but not in response to a configure event, the client should
// send an xdg_positioner.set_parent_size request.
func (l *wl_library) xdg_popup_reposition(xdg_popup *C.struct_xdg_popup, positioner *C.struct_xdg_positioner, token C.uint32_t) {
	C.gamen_xdg_popup_reposition(l.wl_proxy_marshal_flags, l.wl_proxy_get_version, xdg_popup, positioner, token)
}