### ----------------------------------------------------
### -- Gnome::Gdk3
### -- Licenses: Artistic-2.0
### -- Authors: Marcel Timmerman
### -- File: lib/Gnome/Gdk3/Window.rakumod
### ----------------------------------------------------
### -- Chunk 5 of 5
  gdk_window_set_shadow_width(
    self._get-native-object-no-reffing, $left, $right, $top, $bottom
  );
}

sub gdk_window_set_shadow_width (
  N-GObject $window, gint $left, gint $right, gint $top, gint $bottom
) is native(&gdk-lib)
  { * }

#-------------------------------------------------------------------------------
#TM:0:set-skip-pager-hint:
=begin pod
=head2 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 C<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 )

=item $skips_pager; C<True> to skip the pager
=end pod

method set-skip-pager-hint ( Bool $skips_pager ) {
  gdk_window_set_skip_pager_hint(
    self._get-native-object-no-reffing, $skips_pager
  );
}

sub gdk_window_set_skip_pager_hint (
  N-GObject $window, gboolean $skips_pager
) is native(&gdk-lib)
  { * }

#-------------------------------------------------------------------------------
#TM:0:set-skip-taskbar-hint:
=begin pod
=head2 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 C<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 )

=item $skips_taskbar; C<True> to skip the taskbar
=end pod

method set-skip-taskbar-hint ( Bool $skips_taskbar ) {
  gdk_window_set_skip_taskbar_hint(
    self._get-native-object-no-reffing, $skips_taskbar
  );
}

sub gdk_window_set_skip_taskbar_hint (
  N-GObject $window, gboolean $skips_taskbar
) is native(&gdk-lib)
  { * }

#-------------------------------------------------------------------------------
#TM:0:set-source-events:
=begin pod
=head2 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 I<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 )

=item $source; a B<Gnome::Gdk3::InputSource> to define the source class.
=item $event_mask; event mask for I<window>
=end pod

method set-source-events ( GdkInputSource $source, GdkEventMask $event_mask ) {
  gdk_window_set_source_events(
    self._get-native-object-no-reffing, $source, $event_mask
  );
}

sub gdk_window_set_source_events (
  N-GObject $window, GEnum $source, GEnum $event_mask
) is native(&gdk-lib)
  { * }

#-------------------------------------------------------------------------------
#TM:0:set-startup-id:
=begin pod
=head2 set-startup-id

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

  method set-startup-id ( Str $startup_id )

=item $startup_id; a string with startup-notification identifier
=end pod

method set-startup-id ( Str $startup_id ) {
  gdk_window_set_startup_id(
    self._get-native-object-no-reffing, $startup_id
  );
}

sub gdk_window_set_startup_id (
  N-GObject $window, gchar-ptr $startup_id
) is native(&gdk-lib)
  { * }

#-------------------------------------------------------------------------------
#TM:0:set-support-multidevice:
=begin pod
=head2 set-support-multidevice

This function will enable multidevice features in I<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 )

=item $support_multidevice; C<True> to enable multidevice support in I<window>.
=end pod

method set-support-multidevice ( Bool $support_multidevice ) {
  gdk_window_set_support_multidevice(
    self._get-native-object-no-reffing, $support_multidevice
  );
}

sub gdk_window_set_support_multidevice (
  N-GObject $window, gboolean $support_multidevice
) is native(&gdk-lib)
  { * }

#-------------------------------------------------------------------------------
#TM:0:set-title:
=begin pod
=head2 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 C<set_icon_name()>), the icon name will be set to I<title> as well. I<title> must be in UTF-8 encoding (as with all user-readable strings in GDK/GTK+). I<title> may not be C<undefined>.

  method set-title ( Str $title )

=item $title; title of I<window>
=end pod

method set-title ( Str $title ) {
  gdk_window_set_title( self._get-native-object-no-reffing, $title);
}

sub gdk_window_set_title (
  N-GObject $window, gchar-ptr $title
) is native(&gdk-lib)
  { * }

#-------------------------------------------------------------------------------
#TM:0:set-transient-for:
=begin pod
=head2 set-transient-for

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

See C<gtk_window_set_transient_for()> if you’re using B<Gnome::Gdk3::Window> or B<Gnome::Gdk3::Dialog>.

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

=item $parent; another toplevel B<Gnome::Gdk3::Window>
=end pod

method set-transient-for ( N-GObject() $parent ) {
  gdk_window_set_transient_for( self._get-native-object-no-reffing, $parent);
}

sub gdk_window_set_transient_for (
  N-GObject $window, N-GObject $parent
) is native(&gdk-lib)
  { * }

#-------------------------------------------------------------------------------
#TM:0:set-type-hint:
=begin pod
=head2 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 )

=item $hint; A hint of the function this window will have
=end pod

method set-type-hint ( GdkWindowTypeHint $hint ) {
  gdk_window_set_type_hint( self._get-native-object-no-reffing, $hint);
}

sub gdk_window_set_type_hint (
  N-GObject $window, GEnum $hint
) is native(&gdk-lib)
  { * }

#-------------------------------------------------------------------------------
#TM:0:set-urgency-hint:
=begin pod
=head2 set-urgency-hint

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

  method set-urgency-hint ( Bool $urgent )

=item $urgent; C<True> if the window is urgent
=end pod

method set-urgency-hint ( Bool $urgent ) {
  gdk_window_set_urgency_hint( self._get-native-object-no-reffing, $urgent);
}

sub gdk_window_set_urgency_hint (
  N-GObject $window, gboolean $urgent
) is native(&gdk-lib)
  { * }

#-------------------------------------------------------------------------------
#TM:0:set-user-data:
=begin pod
=head2 set-user-data

For most purposes this function is deprecated in favor of C<g_object_set_data()>. However, for historical reasons GTK+ stores the B<Gnome::Gdk3::Widget> that owns a B<Gnome::Gdk3::Window> as user data on the B<Gnome::Gdk3::Window>. So, custom widget implementations should use this function for that. If GTK+ receives an event for a B<Gnome::Gdk3::Window>, and the user data for the window is non-C<undefined>, GTK+ will assume the user data is a B<Gnome::Gdk3::Widget>, and forward the event to that widget.

  method set-user-data ( Pointer $user_data )

=item $user_data;  (type GObject.Object): user data
=end pod

method set-user-data ( Pointer $user_data ) {
  gdk_window_set_user_data( self._get-native-object-no-reffing, $user_data);
}

sub gdk_window_set_user_data (
  N-GObject $window, gpointer $user_data
) is native(&gdk-lib)
  { * }

#`{{
#-------------------------------------------------------------------------------
#TM:0:shape-combine-region:
=begin pod
=head2 shape-combine-region

Makes pixels in I<window> outside I<shape_region> be transparent, so that the window may be nonrectangular.

If I<shape_region> is C<undefined>, the shape will be unset, so the whole window will be opaque again. I<offset_x> and I<offset_y> are ignored if I<shape_region> is C<undefined>.

On the X11 platform, this uses an X server extension which is widely available on most common platforms, but not available on very old X servers, and occasionally the implementation will be buggy. On servers without the shape extension, this function will do nothing.

This function works on both toplevel and child windows.

  method shape-combine-region ( cairo_region_t $shape_region, Int() $offset_x, Int() $offset_y )

=item $shape_region; region of window to be non-transparent
=item $offset_x; X position of I<shape_region> in I<window> coordinates
=item $offset_y; Y position of I<shape_region> in I<window> coordinates
=end pod

method shape-combine-region ( cairo_region_t $shape_region, Int() $offset_x, Int() $offset_y ) {

  gdk_window_shape_combine_region(
    self._get-native-object-no-reffing, $shape_region, $offset_x, $offset_y
  );
}

sub gdk_window_shape_combine_region (
  N-GObject $window, cairo_region_t $shape_region, gint $offset_x, gint $offset_y
) is native(&gdk-lib)
  { * }
}}

#-------------------------------------------------------------------------------
#TM:0:show:
=begin pod
=head2 show

Like C<show_unraised()>, but also raises the window to the top of the window stack (moves the window to the front of the Z-order).

This function maps a window so it’s visible onscreen. Its opposite is C<hide()>.

When implementing a B<Gnome::Gdk3::Widget>, you should call this function on the widget's B<Gnome::Gdk3::Window> as part of the “map” method.

  method show ( )

=end pod

method show ( ) {
  gdk_window_show( self._get-native-object-no-reffing);
}

sub gdk_window_show (
  N-GObject $window
) is native(&gdk-lib)
  { * }

#-------------------------------------------------------------------------------
#TM:0:show-unraised:
=begin pod
=head2 show-unraised

Shows a B<Gnome::Gdk3::Window> onscreen, but does not modify its stacking order. In contrast, C<show()> will raise the window to the top of the window stack.

On the X11 platform, in Xlib terms, this function calls C<XMapWindow()> (it also updates some internal GDK state, which means that you can’t really use C<XMapWindow()> directly on a GDK window).

  method show-unraised ( )

=end pod

method show-unraised ( ) {
  gdk_window_show_unraised(self._get-native-object-no-reffing);
}

sub gdk_window_show_unraised (
  N-GObject $window
) is native(&gdk-lib)
  { * }

#-------------------------------------------------------------------------------
#TM:0:show-window-menu:
=begin pod
=head2 show-window-menu

Asks the windowing system to show the window menu. The window menu is the menu shown when right-clicking the titlebar on traditional windows managed by the window manager. This is useful for windows using client-side decorations, activating it with a right-click on the window decorations.

Returns: C<True> if the window menu was shown and C<False> otherwise.

  method show-window-menu ( GdkEvent $event --> Bool )

=item $event; a B<Gnome::Gdk3::Event> to show the menu for
=end pod

method show-window-menu ( GdkEvent $event --> Bool ) {
  gdk_window_show_window_menu( self._get-native-object-no-reffing, $event).Bool
}

sub gdk_window_show_window_menu (
  N-GObject $window, GdkEvent $event --> gboolean
) is native(&gdk-lib)
  { * }

#-------------------------------------------------------------------------------
#TM:0:stick:
=begin pod
=head2 stick

“Pins” a window such that it’s on all workspaces and does not scroll with viewports, for window managers that have scrollable viewports. (When using B<Gnome::Gdk3::Window>, C<gtk_window_stick()> may be more useful.)

On the X11 platform, this function depends on window manager support, so may have no effect with many window managers. However, GDK will do the best it can to convince the window manager to stick the window. For window managers that don’t support this operation, there’s nothing you can do to force it to happen.

  method stick ( )

=end pod

method stick ( ) {
  gdk_window_stick(self._get-native-object-no-reffing);
}

sub gdk_window_stick (
  N-GObject $window
) is native(&gdk-lib)
  { * }

#-------------------------------------------------------------------------------
#TM:0:test-render-sync:
=begin pod
=head2 test-render-sync

Retrieves a pixel from window to force the windowing system to carry out any pending rendering commands.

This function is intended to be used to synchronize with rendering pipelines, to benchmark windowing system rendering operations.

  method test-render-sync ( )

=end pod

method test-render-sync ( ) {
  gdk_test_render_sync(self._get-native-object-no-reffing);
}

sub gdk_test_render_sync (
  N-GObject $window
) is native(&gdk-lib)
  { * }

#-------------------------------------------------------------------------------
#TM:0:test-simulate-button:
=begin pod
=head2 test-simulate-button

This function is intended to be used in GTK+ test programs. It will warp the mouse pointer to the given (x ,y ) coordinates within window and simulate a button press or release event. Because the mouse pointer needs to be warped to the target location, use of this function outside of test programs that run in their own virtual windowing system (e.g. Xvfb) is not recommended.

Also, gdk_test_simulate_button() is a fairly low level function, for most testing purposes, gtk_test_widget_click() is the right function to call which will generate a button press event followed by its accompanying button release event.

  method test-simulate-button (
    Int() $x, Int() $y, UInt() $button,
    GdkModifierType modifiers, GdkEventType $button_pressrelease
    --> Bool
  )

=item $x; x coordinate within window for the button event
=item $y; y coordinate within window for the button event
=item $button; Number of the pointer button for the event, usually 1, 2 or 3
=item modifiers; Keyboard modifiers the event is setup with
=item $button_pressrelease; either GDK_BUTTON_PRESS or GDK_BUTTON_RELEASE
=end pod

method test-simulate-button (
  Int() $x, Int() $y, UInt $button,
  GdkModifierType $modifiers, GdkEventType $button_pressrelease
  --> Bool
) {
  gdk_test_simulate_button(
    self._get-native-object-no-reffing, $x, $y, $button,
    $modifiers, $button_pressrelease
  ).Bool
}

sub gdk_test_simulate_button (
  N-GObject $window, gint $x, gint $y, guint $button,
  GEnum $modifiers, GEnum $button_pressrelease --> gboolean
) is native(&gdk-lib)
  { * }

#-------------------------------------------------------------------------------
#TM:0:test-simulate-key:
=begin pod
=head2 test-simulate-key

This function is intended to be used in GTK+ test programs. If (x ,y ) are > (-1,-1), it will warp the mouse pointer to the given (x ,y ) coordinates within window and simulate a key press or release event.

When the mouse pointer is warped to the target location, use of this function outside of test programs that run in their own virtual windowing system (e.g. Xvfb) is not recommended. If (x ,y ) are passed as (-1,-1), the mouse pointer will not be warped and window origin will be used as mouse pointer location for the event.

Also, gdk_test_simulate_key() is a fairly low level function, for most testing purposes, gtk_test_widget_send_key() is the right function to call which will generate a key press event followed by its accompanying key release event.

  method test-simulate-key (
    Int() $x, Int() $y, UInt $keyval,
    GdkModifierType $modifiers, GdkEventType $key_pressrelease
    --> Bool
  )

=item $x; x coordinate within window for the key event
=item $y; y coordinate within window for the key event
=item $keyval; A GDK keyboard value from B<Gnome::Gdk3::Keysyms>
=item $modifiers; Keyboard modifiers the event is setup with
=item $key_pressrelease; either GDK_KEY_PRESS or GDK_KEY_RELEASE
=end pod

method test-simulate-key (
  Int() $x, Int() $y, UInt $keyval,
  GdkModifierType $modifiers, GdkEventType $key_pressrelease
  --> Bool
) {
  gdk_test_simulate_key(
    self._get-native-object-no-reffing, $x, $y, $keyval,
    $modifiers, $key_pressrelease
  ).Bool
}

sub gdk_test_simulate_key (
  N-GObject $window, gint $x, gint $y, guint $keyval, GEnum $modifiers, GEnum $key_pressrelease --> gboolean
) is native(&gdk-lib)
  { * }

#-------------------------------------------------------------------------------
#TM:0:thaw-updates:
=begin pod
=head2 thaw-updates

Thaws a window frozen with C<freeze_updates()>.

  method thaw-updates ( )

=end pod

method thaw-updates ( ) {
  gdk_window_thaw_updates( self._get-native-object-no-reffing);
}

sub gdk_window_thaw_updates (
  N-GObject $window
) is native(&gdk-lib)
  { * }

#-------------------------------------------------------------------------------
#TM:1:unfullscreen:
=begin pod
=head2 unfullscreen

Moves the window out of fullscreen mode. If the window was not fullscreen, does nothing.

On X11, asks the window manager to move I<window> out of the fullscreen state, 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 “fullscreen”; so you can’t rely on the unfullscreenification actually happening. But it will happen with most standard window managers, and GDK makes a best effort to get it to happen.

  method unfullscreen ( )

=end pod

method unfullscreen ( ) {
  gdk_window_unfullscreen(self._get-native-object-no-reffing);
}

sub gdk_window_unfullscreen (
  N-GObject $window
) is native(&gdk-lib)
  { * }

#-------------------------------------------------------------------------------
#TM:0:unmaximize:
=begin pod
=head2 unmaximize

Unmaximizes the window. If the window wasn’t maximized, then this function does nothing.

On X11, asks the window manager to unmaximize I<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 unmaximization 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 unmaximizes the window.

  method unmaximize ( )

=end pod

method unmaximize ( ) {
  gdk_window_unmaximize(self._get-native-object-no-reffing);
}

sub gdk_window_unmaximize (
  N-GObject $window
) is native(&gdk-lib)
  { * }

#-------------------------------------------------------------------------------
#TM:0:unstick:
=begin pod
=head2 unstick

Reverse operation for C<stick()>; see C<stick()>, and C<gtk_window_unstick()>.

  method unstick ( )

=end pod

method unstick ( ) {
  gdk_window_unstick(self._get-native-object-no-reffing);
}

sub gdk_window_unstick (
  N-GObject $window
) is native(&gdk-lib)
  { * }

#-------------------------------------------------------------------------------
#TM:0:withdraw:
=begin pod
=head2 withdraw

Withdraws a window (unmaps it and asks the window manager to forget about it). This function is not really useful as C<hide()> automatically withdraws toplevel windows before hiding them.

  method withdraw ( )

=end pod

method withdraw ( ) {
  gdk_window_withdraw(self._get-native-object-no-reffing);
}

sub gdk_window_withdraw (
  N-GObject $window
) is native(&gdk-lib)
  { * }

#-------------------------------------------------------------------------------
#TM:1:_gdk_window_new:
#`{{
=begin pod
=head2 _gdk_window_new

Creates a new B<Gnome::Gdk3::Window> using the attributes from I<attributes>. See B<Gnome::Gdk3::WindowAttr> and B<Gnome::Gdk3::WindowAttributesType> for more details. Note: to use this on displays other than the default display, I<parent> must be specified.

Returns: the new B<Gnome::Gdk3::Window>

  method _gdk_window_new (
    N-GdkWindowAttr $attributes, Int() $attributes_mask --> N-GObject
  )

=item $attributes; attributes of the new window
=item $attributes_mask; (type N-GdkWindowAttributesType): mask indicating which fields in I<attributes> are valid
=end pod
}}

sub _gdk_window_new ( N-GObject $parent, N-GdkWindowAttr $attributes, gint $attributes_mask --> N-GObject )
  is native(&gdk-lib)
  is symbol('gdk_window_new')
  { * }

#-------------------------------------------------------------------------------
=begin pod
=head1 Signals

There are two ways to connect to a signal. The first option you have is to use C<register-signal()> from B<Gnome::GObject::Object>. The second option is to use C<connect-object()> directly from B<Gnome::GObject::Signal>.

=head2 First method

The positional arguments of the signal handler are all obligatory as well as their types. The named attributes C<:$widget> and user data are optional.

  # handler method
  method mouse-event ( GdkEvent $event, :$widget ) { ... }

  # connect a signal on window object
  my Gnome::Gtk3::Window $w .= new( ... );
  $w.register-signal( self, 'mouse-event', 'button-press-event');

=head2 Second method

  my Gnome::Gtk3::Window $w .= new( ... );
  my Callable $handler = sub (
    N-GObject $native, GdkEvent $event, OpaquePointer $data
  ) {
    ...
  }

  $w.connect-object( 'button-press-event', $handler);

Also here, the types of positional arguments in the signal handler are important. This is because both methods C<register-signal()> and C<connect-object()> are using the signatures of the handler routines to setup the native call interface.

=head2 Supported signals


=comment -----------------------------------------------------------------------
=comment #TS:0:create-surface:
=head3 create-surface

The I<create-surface> signal is emitted when an offscreen window needs its surface (re)created, which happens either when the window is first drawn to, or when the window is being resized. The first signal handler that returns a non-C<undefined> surface will stop any further signal emission, and its surface will be used.

Note that it is not possible to access the window's previous surface from within any callback of this signal. Calling C<gdk_offscreen_window_get_surface()> will lead to a crash.

Returns: the newly created B<cairo_surface_t> for the offscreen window

  method handler (
    Int $width,
    Int $height,
    Int :$_handle_id,
    Gnome::GObject::Object :_widget($window),
    *%user-options
    --> Unknown type CAIRO_GOBJECT_TYPE_SURFACE
  );

=item $window; the offscreen window on which the signal is emitted

=item $width; the width of the offscreen surface to create

=item $height; the height of the offscreen surface to create

=item $_handle_id; the registered event handler id

=begin comment
=comment -----------------------------------------------------------------------
=comment #TS:0:from-embedder:
=head3 from-embedder

The I<from-embedder> signal is emitted to translate coordinates in the embedder of an offscreen window to the offscreen window.

See also  I<to-embedder>.


  method handler (
    num64 #`{ use NativeCall } $embedder_x,
    num64 #`{ use NativeCall } $embedder_y,
    Unknown type G_TYPE_POINTER $offscreen_x,
    Unknown type G_TYPE_POINTER $offscreen_y,
    Int :$_handle_id,
    Gnome::GObject::Object :_widget($window),
    *%user-options
  );

=item $window; the offscreen window on which the signal is emitted

=item $embedder_x; x coordinate in the embedder window

=item $embedder_y; y coordinate in the embedder window

=item $offscreen_x; (out) (type double): return location for the x
coordinate in the offscreen window
=item $offscreen_y; (out) (type double): return location for the y
coordinate in the offscreen window
=item $_handle_id; the registered event handler id
=end comment

=begin comment
=comment -----------------------------------------------------------------------
=comment #TS:0:moved-to-rect:
=head3 moved-to-rect

Emitted when the position of I<window> is finalized after being moved to a
destination rectangle.

I<window> might be flipped over the destination rectangle in order to keep
it on-screen, in which case I<flipped_x> and I<flipped_y> will be set to C<True>
accordingly.

I<flipped_rect> is the ideal position of I<window> after any possible
flipping, but before any possible sliding. I<final_rect> is I<flipped_rect>,
but possibly translated in the case that flipping is still ineffective in
keeping I<window> on-screen.

Stability: Private

  method handler (
    Unknown type G_TYPE_POINTER $flipped_rect,
    Unknown type G_TYPE_POINTER $final_rect,
    Int $flipped_x,
    Int $flipped_y,
    Int :$_handle_id,
    Gnome::GObject::Object :_widget($window),
    *%user-options
  );

=item $window; the B<Gnome::Gdk3::Window> that moved

=item $flipped_rect; (nullable): the position of I<window> after any possible
flipping or C<undefined> if the backend can't obtain it
=item $final_rect; (nullable): the final position of I<window> or C<undefined> if the
backend can't obtain it
=item $flipped_x; C<True> if the anchors were flipped horizontally

=item $flipped_y; C<True> if the anchors were flipped vertically

=item $_handle_id; the registered event handler id
=end comment

=begin comment
=comment -----------------------------------------------------------------------
=comment #TS:0:pick-embedded-child:
=head3 pick-embedded-child

The I<pick-embedded-child> signal is emitted to find an embedded
child at the given position.

Returns: (nullable) (transfer none): the B<Gnome::Gdk3::Window> of the
embedded child at I<x>, I<y>, or C<undefined>


  method handler (
    num64 #`{ use NativeCall } $x,
    num64 #`{ use NativeCall } $y,
    Int :$_handle_id,
    Gnome::GObject::Object :_widget($window),
    *%user-options
    --> Unknown type GDK_TYPE_WINDOW
  );

=item $window; the window on which the signal is emitted

=item $x; x coordinate in the window

=item $y; y coordinate in the window

=item $_handle_id; the registered event handler id
=end comment

=begin comment
=comment -----------------------------------------------------------------------
=comment #TS:0:to-embedder:
=head3 to-embedder

The I<to-embedder> signal is emitted to translate coordinates
in an offscreen window to its embedder.

See also  I<from-embedder>.


  method handler (
    num64 #`{ use NativeCall } $offscreen_x,
    num64 #`{ use NativeCall } $offscreen_y,
    Unknown type G_TYPE_POINTER $embedder_x,
    Unknown type G_TYPE_POINTER $embedder_y,
    Int :$_handle_id,
    Gnome::GObject::Object :_widget($window),
    *%user-options
  );

=item $window; the offscreen window on which the signal is emitted

=item $offscreen_x; x coordinate in the offscreen window

=item $offscreen_y; y coordinate in the offscreen window

=item $embedder_x; (out) (type double): return location for the x
coordinate in the embedder window
=item $embedder_y; (out) (type double): return location for the y
coordinate in the embedder window
=item $_handle_id; the registered event handler id

=end comment
=end pod


#-------------------------------------------------------------------------------
=begin pod
=head1 Properties

An example of using a string type property of a B<Gnome::Gtk3::Label> object. This is just showing how to set/read a property, not that it is the best way to do it. This is because a) The class initialization often provides some options to set some of the properties and b) the classes provide many methods to modify just those properties. In the case below one can use B<new(:label('my text label'))> or B<.set-text('my text label')>.

  my Gnome::Gtk3::Label $label .= new;
  my Gnome::GObject::Value $gv .= new(:init(G_TYPE_STRING));
  $label.get-property( 'label', $gv);
  $gv.set-string('my text label');

=head2 Supported properties

=comment -----------------------------------------------------------------------
=comment #TP:0:cursor:
=head3 Cursor: cursor


The mouse pointer for a B<Gnome::Gdk3::Window>. See C<set_cursor()> and
C<get_cursor()> for details.

   Widget type: GDK_TYPE_CURSOR

The B<Gnome::GObject::Value> type of property I<cursor> is C<G_TYPE_OBJECT>.
=end pod


