### ----------------------------------------------------
### -- Gnome::Gtk3
### -- Licenses: Artistic-2.0
### -- Authors: Marcel Timmerman
### -- File: docs/content-docs/reference/Gtk3/Window.md
### ----------------------------------------------------
### -- Chunk 2 of 3
()` in contrast gets the position from the most recent configure event.

Note: If *window* is not a toplevel, it is much better to call `get_position()`, `get_width()` and `get_height()` instead, because it avoids the roundtrip to the X server and because these functions support the full 32-bit coordinate space, whereas `get_geometry()` is restricted to the 16-bit coordinates of X11.

    method get-geometry ( --> List )

The List returns

  * Int; X coordinate of window (relative to its parent)

  * Int; Y coordinate of window (relative to its parent)

  * Int; width of window

  * Int; height of window

get-group
---------

Returns the group leader window for *window*. See `set_group()`.

Returns: the group leader window for *window*

    method get-group ( --> N-GObject )

get-height
----------

Returns the height of the given *window*.

On the X11 platform the returned size is the size reported in the most-recently-processed configure event, rather than the current size on the X server.

Returns: The height of *window*

    method get-height ( --> Int )

get-modal-hint
--------------

Determines whether or not the window manager is hinted that *window* has modal behaviour.

Returns: whether or not the window has the modal hint set.

    method get-modal-hint ( --> Bool )

get-origin
----------

Obtains the position of a window in root window coordinates. (Compare with `get_position()` and `get_geometry()` which return the position of a window relative to its parent window.)

Returns: not meaningful, ignore

    method get-origin ( --> Int )

  * $x; return location for X coordinate

  * $y; return location for Y coordinate

get-parent
----------

Obtains the parent of *window*, as known to GDK. Does not query the X server; thus this returns the parent as passed to `new()`, not the actual parent. This should never matter unless you’re using Xlib calls mixed with GDK calls on the X11 platform. It may also matter for toplevel windows, because the window manager may choose to reparent them.

Note that you should use `get_effective_parent()` when writing generic code that walks up a window hierarchy, because `get_parent()` will most likely not do what you expect if there are offscreen windows in the hierarchy.

Returns: parent of *window*

    method get-parent ( --> N-GObject )

get-pass-through
----------------

Returns whether input to the window is passed through to the window below.

See `set_pass_through()` for details

    method get-pass-through ( --> Bool )

get-position
------------

Obtains the position of the window as reported in the most-recently-processed **Gnome::Gdk3::EventConfigure**. Contrast with `get_geometry()` which queries the X server for the current window position, regardless of which events have been received or processed.

The position coordinates are relative to the window’s parent window.

    method get-position ( )

  * $x; X coordinate of window

  * $y; Y coordinate of window

get-root-coords
---------------

Obtains the position of a window position in root window coordinates. This is similar to `get_origin()` but allows you to pass in any position in the window, not just the origin.

    method get-root-coords ( Int() $x, Int() $y )

  * $x; X coordinate in window

  * $y; Y coordinate in window

  * $root_x; return location for X coordinate

  * $root_y; return location for Y coordinate

get-root-origin
---------------

Obtains the top-left corner of the window manager frame in root window coordinates.

    method get-root-origin ( )

  * $x; return location for X position of window frame

  * $y; return location for Y position of window frame

get-scale-factor
----------------

Returns the internal scale factor that maps from window coordiantes to the actual device pixels. On traditional systems this is 1, but on very high density outputs this can be a higher value (often 2).

A higher value means that drawing is automatically scaled up to a higher resolution, so any code doing drawing will automatically look nicer. However, if you are supplying pixel-based data the scale value can be used to determine whether to use a pixel resource with higher resolution data.

The scale of a window may change during runtime, if this happens a configure event will be sent to the toplevel window.

Returns: the scale factor

    method get-scale-factor ( --> Int )

get-screen
----------

Gets the **Gnome::Gdk3::Screen** associated with a **Gnome::Gdk3::Window**.

Returns: the **Gnome::Gdk3::Screen** associated with *window*

    method get-screen ( --> N-GObject )

get-state
---------

Gets the bitwise OR of the currently active window state flags, from the **Gnome::Gdk3::WindowState** enumeration.

Returns: window state bitfield

    method get-state ( --> GdkWindowState )

get-support-multidevice
-----------------------

Returns `True` if the window is aware of the existence of multiple devices.

Returns: `True` if the window handles multidevice features.

    method get-support-multidevice ( --> Bool )

get-toplevel
------------

Gets the toplevel window that’s an ancestor of *window*.

Any window type but `GDK_WINDOW_CHILD` is considered a toplevel window, as is a `GDK_WINDOW_CHILD` window that has a root window as parent.

Note that you should use `get_effective_toplevel()` when you want to get to a window’s toplevel as seen on screen, because `get_toplevel()` will most likely not do what you expect if there are offscreen windows in the hierarchy.

Returns: the toplevel window containing *window*

    method get-toplevel ( --> N-GObject )

get-type-hint
-------------

This function returns the type hint set for a window.

Returns: The type hint set for *window*

    method get-type-hint ( --> GdkWindowTypeHint )

get-user-data
-------------

Retrieves the user data for *window*, which is normally the widget that *window* belongs to. See `set_user_data()`.

    method get-user-data ( Pointer $data )

  * $data; return location for user data

get-visual
----------

Gets the **Gnome::Gdk3::Visual** describing the pixel format of *window*.

Returns: a native **Gnome::Gdk3::Visual**

    method get-visual ( --> N-GObject )

get-width
---------

Returns the width of the given *window*.

On the X11 platform the returned size is the size reported in the most-recently-processed configure event, rather than the current size on the X server.

Returns: The width of *window*

    method get-width ( --> Int )

get-window-type
---------------

Gets the type of the window. See **Gnome::Gdk3::WindowType**.

Returns: type of window

    method get-window-type ( --> GdkWindowType )

has-native
----------

Checks whether the window has a native window or not. Note that you can use `ensure_native()` if a native window is needed.

Returns: `True` if the *window* has a native window, `False` otherwise.

    method has-native ( --> Bool )

hide
----

For toplevel windows, withdraws them, so they will no longer be known to the window manager; for all windows, unmaps them, so they won’t be displayed. Normally done automatically as part of `gtk_widget_hide()`.

    method hide ( )

iconify
-------

Asks to iconify (minimize) *window*. The window manager may choose to ignore the request, but normally will honor it. Using `gtk_window_iconify()` is preferred, if you have a **Gnome::Gdk3::Window** widget.

This function only makes sense when *window* is a toplevel window.

    method iconify ( )

invalidate-rect
---------------

A convenience wrapper around `invalidate_region()` which invalidates a rectangular region. See `invalidate_region()` for details.

    method invalidate-rect ( N-GObject() $rect, Bool $invalidate_children )

  * $rect; rectangle to invalidate or `undefined` to invalidate the whole window

  * $invalidate_children; whether to also invalidate child windows

is-destroyed
------------

Check to see if a window is destroyed..

Returns: `True` if the window is destroyed

    method is-destroyed ( --> Bool )

is-input-only
-------------

Determines whether or not the window is an input only window.

Returns: `True` if *window* is input only

    method is-input-only ( --> Bool )

is-shaped
---------

Determines whether or not the window is shaped.

Returns: `True` if *window* is shaped

    method is-shaped ( --> Bool )

is-viewable
-----------

Check if the window and all ancestors of the window are mapped. (This is not necessarily "viewable" in the X sense, since we only check as far as we have GDK window parents, not to the root window.)

Returns: `True` if the window is viewable

    method is-viewable ( --> Bool )

is-visible
----------

Checks whether the window has been mapped (with `show()` or `show_unraised()`).

Returns: `True` if the window is mapped

    method is-visible ( --> Bool )

lower
-----

Lowers *window* to the bottom of the Z-order (stacking order), so that other windows with the same parent window appear above *window*. This is true whether or not the other windows are visible.

If *window* is a toplevel, the window manager may choose to deny the request to move the window in the Z-order, `lower()` only requests the restack, does not guarantee it.

Note that `show()` raises the window again, so don’t call this function before `show()`. (Try `show_unraised()`.)

    method lower ( )

mark-paint-from-clip
--------------------

If you call this during a paint (e.g. between `begin_paint_region()` and `end_paint()` then GDK will mark the current clip region of the window as being drawn. This is required when mixing GL rendering via `gdk_cairo_draw_from_gl()` and cairo rendering, as otherwise GDK has no way of knowing when something paints over the GL-drawn regions.

This is typically called automatically by GTK+ and you don't need to care about this.

    method mark-paint-from-clip ( cairo_t $cr )

  * $cr; a **cairo_t**

maximize
--------

Maximizes the window. If the window was already maximized, then this function does nothing.

On X11, asks the window manager to maximize *window*, if the window manager supports this operation. Not all window managers support this, and some deliberately ignore it or don’t have a concept of “maximized”; so you can’t rely on the maximization actually happening. But it will happen with most standard window managers, and GDK makes a best effort to get it to happen.

On Windows, reliably maximizes the window.

    method maximize ( )

merge-child-input-shapes
------------------------

Merges the input shape masks for any child windows into the input shape mask for *window*. i.e. the union of all input masks for *window* and its children will become the new input mask for *window*. See `input_shape_combine_region()`.

This function is distinct from `set_child_input_shapes()` because it includes *window*’s input shape mask in the set of shapes to be merged.

    method merge-child-input-shapes ( )

merge-child-shapes
------------------

Merges the shape masks for any child windows into the shape mask for *window*. i.e. the union of all masks for *window* and its children will become the new mask for *window*. See `shape_combine_region()`.

This function is distinct from `set_child_shapes()` because it includes *window*’s shape mask in the set of shapes to be merged.

    method merge-child-shapes ( )

move
----

Repositions a window relative to its parent window. For toplevel windows, window managers may ignore or modify the move; you should probably use `gtk_window_move()` on a **Gnome::Gdk3::Window** widget anyway, instead of using GDK functions. For child windows, the move will reliably succeed.

If you’re also planning to resize the window, use `move_resize()` to both move and resize simultaneously, for a nicer visual effect.

    method move ( Int() $x, Int() $y )

  * $x; X coordinate relative to window’s parent

  * $y; Y coordinate relative to window’s parent

move-resize
-----------

Equivalent to calling `move()` and `resize()`, except that both operations are performed at once, avoiding strange visual effects. (i.e. the user may be able to see the window first move, then resize, if you don’t use `move_resize()`.)

    method move-resize ( Int() $x, Int() $y, Int() $width, Int() $height )

  * $x; new X position relative to window’s parent

  * $y; new Y position relative to window’s parent

  * $width; new width

  * $height; new height

move-to-rect
------------

Moves *window* to *rect*, aligning their anchor points.

*rect* is relative to the top-left corner of the window that *window* is transient for. *rect_anchor* and *window_anchor* determine anchor points on *rect* and *window* to pin together. *rect*'s anchor point can optionally be offset by *rect_anchor_dx* and *rect_anchor_dy*, which is equivalent to offsetting the position of *window*.

*anchor_hints* determines how *window* will be moved if the anchor points cause it to move off-screen. For example, `GDK_ANCHOR_FLIP_X` will replace `GDK_GRAVITY_NORTH_WEST` with `GDK_GRAVITY_NORTH_EAST` and vice versa if *window* extends beyond the left or right edges of the monitor.

Connect to the *moved-to-rect* signal to find out how it was actually positioned.

    method move-to-rect (
      N-GdkRectangle $rect, GdkGravity $rect_anchor,
      GdkGravity $window_anchor, GdkAnchorHints $anchor_hints,
      Int() $rect_anchor_dx, Int() $rect_anchor_dy
    )

  * $rect; the destination rectangle to align *window* with

  * $rect_anchor; the point on *rect* to align with *window*'s anchor point

  * $window_anchor; the point on *window* to align with *rect*'s anchor point

  * $anchor_hints; positioning hints to use when limited on space

  * $rect_anchor_dx; horizontal offset to shift *window*, i.e. *rect*'s anchor point

  * $rect_anchor_dy; vertical offset to shift *window*, i.e. *rect*'s anchor point

offscreen-window-get-embedder
-----------------------------

Gets the window that window is embedded in.

    method gdk-offscreen-window-get-embedder ( --> N-GObject )

offscreen-window-get-surface
----------------------------

Gets the offscreen surface that an offscreen window renders into. If you need to keep this around over window resizes, you need to add a reference to it.

    method offscreen-window-get-surface ( --> cairo_surface_t )

offscreen-window-set-embedder
-----------------------------

Sets window to be embedded in embedder.

To fully embed an offscreen window, in addition to calling this function, it is also necessary to handle the “pick-embedded-child” signal on the embedder and the “to-embedder” and “from-embedder” signals on window .

    method offscreen-window-set-embedder ( N-GObject() $embedder )

  * $embedder;

peek-children
-------------

Like `get_children()`, but does not copy the list of children, so the list does not need to be freed.

Returns: (element-type GdkWindow): a reference to the list of child windows in *window*

    method peek-children ( --> N-GList )

raise
-----

Raises *window* to the top of the Z-order (stacking order), so that other windows with the same parent window appear below *window*. This is true whether or not the windows are visible.

If *window* is a toplevel, the window manager may choose to deny the request to move the window in the Z-order, `raise()` only requests the restack, does not guarantee it.

    method raise ( )

register-dnd
------------

Registers a window as a potential drop destination.

    method register-dnd ( )

reparent
--------

Reparents *window* into the given *new_parent*. The window being reparented will be unmapped as a side effect.

    method reparent ( N-GObject() $new_parent, Int() $x, Int() $y )

  * $new_parent; new parent to move *window* into

  * $x; X location inside the new parent

  * $y; Y location inside the new parent

resize
------

Resizes *window*; for toplevel windows, asks the window manager to resize the window. The window manager may not allow the resize. When using GTK+, use `gtk_window_resize()` instead of this low-level GDK function.

Windows may not be resized below 1x1.

If you’re also planning to move the window, use `move_resize()` to both move and resize simultaneously, for a nicer visual effect.

    method resize ( Int() $width, Int() $height )

  * $width; new width of the window

  * $height; new height of the window

restack
-------

Changes the position of *window* in the Z-order (stacking order), so that it is above *sibling* (if *above* is `True`) or below *sibling* (if *above* is `False`).

If *sibling* is `undefined`, then this either raises (if *above* is `True`) or lowers the window.

If *window* is a toplevel, the window manager may choose to deny the request to move the window in the Z-order, `restack()` only requests the restack, does not guarantee it.

    method restack ( N-GObject() $sibling, Bool $above )

  * $sibling; a **Gnome::Gdk3::Window** that is a sibling of *window*, or `undefined`

  * $above; a boolean

scroll
------

Scroll the contents of *window*, both pixels and children, by the given amount. *window* itself does not move. Portions of the window that the scroll operation brings in from offscreen areas are invalidated. The invalidated region may be bigger than what would strictly be necessary.

For X11, a minimum area will be invalidated if the window has no subwindows, or if the edges of the window’s parent do not extend beyond the edges of the window. In other cases, a multi-step process is used to scroll the window which may produce temporary visual artifacts and unnecessary invalidations.

    method scroll ( Int() $dx, Int() $dy )

  * $dx; Amount to scroll in the X direction

  * $dy; Amount to scroll in the Y direction

set-accept-focus
----------------

Setting *accept_focus* to `False` hints the desktop environment that the window doesn’t want to receive input focus.

On X, it is the responsibility of the window manager to interpret this hint. ICCCM-compliant window manager usually respect it.

    method set-accept-focus ( Bool $accept_focus )

  * $accept_focus; `True` if the window should receive input focus

set-child-input-shapes
----------------------

Sets the input shape mask of *window* to the union of input shape masks for all children of *window*, ignoring the input shape mask of *window* itself. Contrast with `merge_child_input_shapes()` which includes the input shape mask of *window* in the masks to be merged.

    method set-child-input-shapes ( )

set-child-shapes
----------------

Sets the shape mask of *window* to the union of shape masks for all children of *window*, ignoring the shape mask of *window* itself. Contrast with `merge_child_shapes()` which includes the shape mask of *window* in the masks to be merged.

    method set-child-shapes ( )

set-decorations
---------------

“Decorations” are the features the window manager adds to a toplevel **Gnome::Gdk3::Window**. This function sets the traditional Motif window manager hints that tell the window manager which decorations you would like your window to have. Usually you should use `Gnome::Gtk3::Window.set_decorated()` on a **Gnome::Gdk3::Window** instead of using the GDK function directly.

The *$decorations* argument is the logical OR of the fields in the `GdkWMDecoration` enumeration. If `GDK_DECOR_ALL` is included in the mask, the other bits indicate which decorations should be turned off. If `GDK_DECOR_ALL` is not included, then the other bits indicate which decorations should be turned on.

Most window managers honor a decorations hint of 0 to disable all decorations, but very few honor all possible combinations of bits.

    method set-decorations ( Int $decorations )

  * $decorations; decoration hint mask

set-device-events
-----------------

Sets the event mask for a given device (Normally a floating device, not attached to any visible pointer) to *window*. For example, an event mask including **Gnome::Gdk3::DK_BUTTON_PRESS_MASK** means the window should report button press events. The event mask is the bitwise OR of values from the **Gnome::Gdk3::EventMask** enumeration.

See the [input handling overview][event-masks] for details.

    method set-device-events ( N-GObject() $device, GdkEventMask $event_mask )

  * $device; **Gnome::Gdk3::Device** to enable events for.

  * $event_mask; event mask for *window*

set-event-compression
---------------------

Determines whether or not extra unprocessed motion events in the event queue can be discarded. If `True` only the most recent event will be delivered.

Some types of applications, e.g. paint programs, need to see all motion events and will benefit from turning off event compression.

By default, event compression is enabled.

    method set-event-compression ( Bool $event_compression )

  * $event_compression; `True` if motion events should be compressed

set-events
----------

The event mask for a window determines which events will be reported for that window from all master input devices. For example, an event mask including **Gnome::Gdk3::DK_BUTTON_PRESS_MASK** means the window should report button press events. The event mask is the bitwise OR of values from the **Gnome::Gdk3::EventMask** enumeration.

See the [input handling overview][event-masks] for details.

    method set-events ( GdkEventMask $event_mask )

  * $event_mask; event mask for *window*

set-focus-on-map
----------------

Setting *focus_on_map* to `False` hints the desktop environment that the window doesn’t want to receive input focus when it is mapped. focus_on_map should be turned off for windows that aren’t triggered interactively (such as popups from network activity).

On X, it is the responsibility of the window manager to interpret this hint. Window managers following the freedesktop.org window manager extension specification should respect it.

    method set-focus-on-map ( Bool $focus_on_map )

  * $focus_on_map; `True` if the window should receive input focus when mapped

set-fullscreen-mode
-------------------

Specifies whether the *window* should span over all monitors (in a multi-head setup) or only the current monitor when in fullscreen mode.

The *mode* argument is from the **Gnome::Gdk3::FullscreenMode** enumeration. If **Gnome::Gdk3::DK_FULLSCREEN_ON_ALL_MONITORS** is specified, the fullscreen *window* will span over all monitors from the **Gnome::Gdk3::Screen**.

On X11, searches through the list of monitors from the **Gnome::Gdk3::Screen** the ones which delimit the 4 edges of the entire **Gnome::Gdk3::Screen** and will ask the window manager to span the *window* over these monitors.

If the XINERAMA extension is not available or not usable, this function has no effect.

Not all window managers support this, so you can’t rely on the fullscreen window to span over the multiple monitors when **Gnome::Gdk3::DK_FULLSCREEN_ON_ALL_MONITORS** is specified.

    method set-fullscreen-mode ( GdkFullscreenMode $mode )

  * $mode; fullscreen mode

set-geometry-hints
------------------

Sets the geometry hints for *window*. Hints flagged in *geom_mask* are set, hints not flagged in *geom_mask* are unset. To unset all hints, use a *geom_mask* of 0 and a *geometry* of `undefined`.

This function provides hints to the windowing system about acceptable sizes for a toplevel window. The purpose of this is to constrain user resizing, but the windowing system will typically (but is not required to) also constrain the current size of the window to the provided values and constrain programatic resizing via `resize()` or `move_resize()`.

Note that on X11, this effect has no effect on windows of type `GDK_WINDOW_TEMP` or windows where override redirect has been turned on via `set_override_redirect()` since these windows are not resizable by the user.

Since you can’t count on the windowing system doing the constraints for programmatic resizes, you should generally call `constrain_size()` yourself to determine appropriate sizes.

    method set-geometry-hints (
      N-GdkGeometry $geometry, GdkWindowHints $geom_mask
    )

  * $geometry; geometry hints

  * $geom_mask; bitmask indicating fields of *geometry* to pay attention to

set-group
---------

Sets the group leader window for *window*. By default, GDK sets the group leader for all toplevel windows to a global window implicitly created by GDK. With this function you can override this default.

The group leader window allows the window manager to distinguish all windows that belong to a single application. It may for example allow users to minimize/unminimize all windows belonging to an application at once. You should only set a non-default group window if your application pretends to be multiple applications.

    method set-group ( N-GObject() $leader )

  * $leader; group leader window, or `undefined` to restore the default group leader window

set-icon-list
-------------

Sets a list of icons for the window. One of these will be used to represent the window when it has been iconified. The icon is usually shown in an icon box or some sort of task bar. Which icon size is shown depends on the window manager. The window manager can scale the icon but setting several size icons can give better image quality since the window manager may only need to scale the icon by a small amount or not at all.

Note that some platforms don't support window icons.

    method set-icon-list ( N-GList $pixbufs )

  * $pixbufs; (element-type GdkPixbuf): A list of pixbufs, of different sizes.

set-icon-name
-------------

Windows may have a name used while minimized, distinct from the name they display in their titlebar. Most of the time this is a bad idea from a user interface standpoint. But you can set such a name with this function, if you like.

After calling this with a non-`undefined` *name*, calls to `set_title()` will not update the icon title.

Using `undefined` for *name* unsets the icon title; further calls to `set_title()` will again update the icon title as well.

Note that some platforms don't support window icons.

    method set-icon-name ( Str $name )

  * $name; name of window while iconified (minimized)

set-keep-above
--------------

Set if *window* must be kept above other windows. If the window was already above, then this function does nothing.

On X11, asks the window manager to keep *window* above, if the window manager supports this operation. Not all window managers support this, and some deliberately ignore it or don’t have a concept of “keep above”; so you can’t rely on the window being kept above. But it will happen with most standard window managers, and GDK makes a best effort to get it to happen.

    method set-keep-above ( Bool $setting )

  * $setting; whether to keep *window* above other windows

set-keep-below
--------------

Set if *window* must be kept below other windows. If the window was already below, then this function does nothing.

On X11, asks the window manager to keep *window* below, if the window manager supports this operation. Not all window managers support this, and some deliberately ignore it or don’t have a concept of “keep below”; so you can’t rely on the window being kept below. But it will happen with most standard window managers, and GDK makes a best effort to get it to happen.

    method set-keep-below ( Bool $setting )

  * $setting; whether to keep *window* below other windows

set-modal-hint
--------------

The application can use this hint to tell the window manager that a certain window has modal behaviour. The window manager can use this information to handle modal windows in a special way.

You should only use this on windows for which you have previously called `set_transient_for()`

    method set-modal-hint ( Bool $modal )

  * $modal; `True` if the window is modal, `False` otherwise.

set-opacity
-----------

Set *window* to render as partially transparent, with opacity 0 being fully transparent and 1 fully opaque. (Values of the opacity parameter are clamped to the [0,1] range.)

For toplevel windows this depends on support from the windowing system that may not always be there. For instance, On X11, this works only on X screens with a compositing manager running. On Wayland, there is no per-window opacity value that the compositor would apply. Instead, use `set_opaque_region (window, NULL)` to tell the compositor that the entire window is (potentially) non-opaque, and draw your content with alpha, or use `gtk_widget_set_opacity()` to set an overall opacity for your widgets.

For child windows this function only works for non-native windows.

For setting up per-pixel alpha topelevels, see `gdk_screen_get_rgba_visual()`, and for non-toplevels, see `set_composited()`.

Support for non-toplevel windows was added in 3.8.

    method set-opacity ( Num() $opacity )

  * $opacity; opacity

set-override-redirect
---------------------

An override redirect window is not under the control of the window manager. This means it won’t have a titlebar, won’t be minimizable, etc. - it will be entirely under the control of the application. The window manager can’t see the override redirect window at all.

Override redirect should only be used for short-lived temporary windows, such as popup menus. **Gnome::Gdk3::Menu** uses an override redirect window in its implementation, for example.

    method set-override-redirect ( Bool $override_redirect )

  * $override_redirect; `True` if window should be override redirect

set-pass-through
----------------

Sets whether input to the window is passed through to the window below.

The default value of this is `False`, which means that pointer events that happen inside the window are send first to the window, but if the event is not selected by the event mask then the event is sent to the parent window, and so on up the hierarchy.

If *pass_through* is `True` then such pointer events happen as if the window wasn't there at all, and thus will be sent first to any windows below *window*. This is useful if the window is used in a transparent fashion. In the terminology of the web this would be called "pointer-events: none".

Note that a window with *pass_through* `True` can still have a subwindow without pass through, so you can get events on a subset of a window. And in that cases you would get the in-between related events such as the pointer enter/leave events on its way to the destination window.

    method set-pass-through ( Bool $pass_through )

  * $pass_through; a boolean

set-role
--------

When using GTK+, typically you should use `gtk_window_set_role()` instead of this low-level function.

The window manager and session manager use a window’s role to distinguish it from other kinds of window in the same application. When an application is restarted after being saved in a previous session, all windows with the same title and role are treated as interchangeable. So if you have two windows with the same title that should be distinguished for session management purposes, you should set the role on those windows. It doesn’t matter what string you use for the role, as long as you have a different role for each non-interchangeable kind of window.

    method set-role ( Str $role )

  * $role; a string indicating its role

set-shadow-width
----------------

Newer GTK+ windows using client-side decorations use extra geometry around their frames for effects like shadows and invisible borders. Window managers that want to maximize windows or snap to edges need to know where the extents of the actual frame lie, so that users don’t feel like windows are snapping against random invisible edges.

Note that this property is automatically updated by GTK+, so this function should only be used by applications which do not use GTK+ to create toplevel windows.

    method set-shadow-width (
      Int() $left, Int() $right, Int() $top, Int() $bottom
    )

  * $left; The left extent

  * $right; The right extent

  * $top; The top extent

  * $bottom; The bottom extent

set-skip-pager-hint
-------------------

Toggles whether a window should appear in a pager (workspace switcher, or other desktop utility program that displays a small thumbnail representation of the windows on the desktop). If a window’s semantic type as specified with `set_type_hint()` already fully describes the window, this function should not be called in addition, instead you should allow the window to be treated according to standard policy for its semantic type.

    method set-skip-pager-hint ( Bool $skips_pager )

  * $skips_pager; `True` to skip the pager

set-skip-taskbar-hint
---------------------

Toggles whether a window should appear in a task list or window list. If a window’s semantic type as specified with `set_type_hint()` already fully describes the window, this function should not be called in addition, instead you should allow the window to be treated according to standard policy for its semantic type.

    method set-skip-taskbar-hint ( Bool $skips_taskbar )

  * $skips_taskbar; `True` to skip the taskbar

set-source-events
-----------------

Sets the event mask for any floating device (i.e. not attached to any visible pointer) that has the source defined as *source*. This event mask will be applied both to currently existing, newly added devices after this call, and devices being attached/detached.

    method set-source-events ( GdkInputSource $source, GdkEventMask $event_mask )

  * $source; a **Gnome::Gdk3::InputSource** to define the source class.

  * $event_mask; event mask for *window*

set-startup-id
--------------

When using GTK+, typically you should use `gtk_window_set_startup_id()` instead of this low-level function.

    method set-startup-id ( Str $startup_id )

  * $startup_id; a string with startup-notification identifier

set-support-multidevice
-----------------------

This function will enable multidevice features in *window*.

Multidevice aware windows will need to handle properly multiple, per device enter/leave events, device grabs and grab ownerships.

    method set-support-multidevice ( Bool $support_multidevice )

  * $support_multidevice; `True` to enable multidevice support in *window*.

set-title
---------

Sets the title of a toplevel window, to be displayed in the titlebar. If you haven’t explicitly set the icon name for the window (using `set_icon_name()`), the icon name will be set to *title* as well. *title* must be in UTF-8 encoding (as with all user-readable strings in GDK/GTK+). *title* may not be `undefined`.

    method set-title ( Str $title )

  * $title; title of *window*

set-transient-for
-----------------

Indicates to the window manager that *window* is a transient dialog associated with the application window *parent*. This allows the window manager to do things like center *window* on *parent* and keep *window* above *parent*.

See `gtk_window_set_transient_for()` if you’re using **Gnome::Gdk3::Window** or **Gnome::Gdk3::Dialog**.

    method set-transient-for ( N-GObject() $parent )

  * $parent; another toplevel **Gnome::Gdk3::Window**

set-type-hint
-------------

The application can use this call to provide a hint to the window manager about the functionality of a window. The window manager can use this information when determining the decoration and behaviour of the window.

The hint must be set before the window is mapped.

    method set-type-hint ( GdkWindowTypeHint $hint )

  * $hint; A hint of the function this window will have

set-urgency-hint
----------------

Toggles whether a window needs the user's urgent attention.

    method set-urgency-hint ( Bool $urgent )

  * $urgent; `True` if the window is urgent

set-user-data
-------------

For most purposes this function is deprecated in favor of `g_object_set