### ----------------------------------------------------
### -- Gnome::Gtk3
### -- Licenses: Artistic-2.0
### -- Authors: Marcel Timmerman
### -- File: lib/Gnome/Gtk3/Entry.rakumod
### ----------------------------------------------------
### -- Chunk 2 of 5
layout_index; byte index into the entry layout text
=end pod

method layout-index-to-text-index ( Int() $layout_index --> Int ) {
  gtk_entry_layout_index_to_text_index( self._f('GtkEntry'), $layout_index)
}

sub gtk_entry_layout_index_to_text_index (
  N-GObject $entry, gint $layout_index --> gint
) is native(&gtk-lib)
  { * }
}}

#-------------------------------------------------------------------------------
#TM:0:progress-pulse:
=begin pod
=head2 progress-pulse

Indicates that some progress is made, but you don’t know how much. Causes the entry’s progress indicator to enter “activity mode,” where a block bounces back and forth. Each call to C<progress_pulse()> causes the block to move by a little bit (the amount of movement per pulse is determined by C<set_progress_pulse_step()>).

  method progress-pulse ( )

=end pod

method progress-pulse ( ) {
  gtk_entry_progress_pulse( self._f('GtkEntry'));
}

sub gtk_entry_progress_pulse (
  N-GObject $entry
) is native(&gtk-lib)
  { * }

#-------------------------------------------------------------------------------
#TM:0:reset-im-context:
=begin pod
=head2 reset-im-context

Reset the input method context of the entry if needed.

This can be necessary in the case where modifying the buffer would confuse on-going input method behavior.

  method reset-im-context ( )

=end pod

method reset-im-context ( ) {
  gtk_entry_reset_im_context( self._f('GtkEntry'));
}

sub gtk_entry_reset_im_context (
  N-GObject $entry
) is native(&gtk-lib)
  { * }

#-------------------------------------------------------------------------------
#TM:0:set-activates-default:
=begin pod
=head2 set-activates-default

If I<setting> is C<True>, pressing Enter in the I<entry> will activate the default widget for the window containing the entry. This usually means that the dialog box containing the entry will be closed, since the default widget is usually one of the dialog buttons.

(For experts: if I<setting> is C<True>, the entry calls C<gtk_window_activate_default()> on the window containing the entry, in the default handler for the I<activate> signal.)

  method set-activates-default ( Bool $setting )

=item $setting; C<True> to activate window’s default widget on Enter keypress
=end pod

method set-activates-default ( Bool $setting ) {
  gtk_entry_set_activates_default( self._f('GtkEntry'), $setting);
}

sub gtk_entry_set_activates_default (
  N-GObject $entry, gboolean $setting
) is native(&gtk-lib)
  { * }

#-------------------------------------------------------------------------------
#TM:0:set-alignment:
=begin pod
=head2 set-alignment

Sets the alignment for the contents of the entry. This controls the horizontal positioning of the contents when the displayed text is shorter than the width of the entry.

  method set-alignment ( Num() $xalign )

=item $xalign; The horizontal alignment, from 0 (left) to 1 (right). Reversed for RTL layouts
=end pod

method set-alignment ( Num() $xalign ) {
  gtk_entry_set_alignment( self._f('GtkEntry'), $xalign);
}

sub gtk_entry_set_alignment (
  N-GObject $entry, gfloat $xalign
) is native(&gtk-lib)
  { * }

#`{{
#-------------------------------------------------------------------------------
#TM:0:set-attributes:
=begin pod
=head2 set-attributes

Sets a B<PangoAttrList>; the attributes in the list are applied to the entry text.

  method set-attributes ( PangoAttrList $attrs )

=item $attrs; a B<PangoAttrList>
=end pod

method set-attributes ( PangoAttrList $attrs ) {
  gtk_entry_set_attributes( self._f('GtkEntry'), $attrs);
}

sub gtk_entry_set_attributes (
  N-GObject $entry, PangoAttrList $attrs
) is native(&gtk-lib)
  { * }
}}

#-------------------------------------------------------------------------------
#TM:0:set-buffer:
=begin pod
=head2 set-buffer

Set the B<Gnome::Gtk3::EntryBuffer> object which holds the text for this widget.

  method set-buffer ( N-GObject() $buffer )

=item $buffer; a B<Gnome::Gtk3::EntryBuffer>
=end pod

method set-buffer ( N-GObject() $buffer ) {
  gtk_entry_set_buffer( self._f('GtkEntry'), $buffer);
}

sub gtk_entry_set_buffer (
  N-GObject $entry, N-GObject $buffer
) is native(&gtk-lib)
  { * }

#-------------------------------------------------------------------------------
#TM:0:set-completion:
=begin pod
=head2 set-completion

Sets I<completion> to be the auxiliary completion object to use with I<entry>. All further configuration of the completion mechanism is done on I<completion> using the B<Gnome::Gtk3::EntryCompletion> API. Completion is disabled if I<completion> is set to C<undefined>.

  method set-completion ( N-GObject() $completion )

=item $completion; The B<Gnome::Gtk3::EntryCompletion> or C<undefined>
=end pod

method set-completion ( N-GObject() $completion ) {
  gtk_entry_set_completion( self._f('GtkEntry'), $completion);
}

sub gtk_entry_set_completion (
  N-GObject $entry, N-GObject $completion
) is native(&gtk-lib)
  { * }

#-------------------------------------------------------------------------------
#TM:0:set-cursor-hadjustment:
=begin pod
=head2 set-cursor-hadjustment

Hooks up an adjustment to the cursor position in an entry, so that when the cursor is moved, the adjustment is scrolled to show that position. See C<gtk_scrolled_window_get_hadjustment()> for a typical way of obtaining the adjustment.

The adjustment has to be in pixel units and in the same coordinate system as the entry.

  method set-cursor-hadjustment ( N-GObject() $adjustment )

=item $adjustment; an adjustment which should be adjusted when the cursor is moved, or C<undefined>
=end pod

method set-cursor-hadjustment ( N-GObject() $adjustment ) {
  gtk_entry_set_cursor_hadjustment( self._f('GtkEntry'), $adjustment);
}

sub gtk_entry_set_cursor_hadjustment (
  N-GObject $entry, N-GObject $adjustment
) is native(&gtk-lib)
  { * }

#-------------------------------------------------------------------------------
#TM:0:set-has-frame:
=begin pod
=head2 set-has-frame

Sets whether the entry has a beveled frame around it.

  method set-has-frame ( Bool $setting )

=item $setting; new value
=end pod

method set-has-frame ( Bool $setting ) {
  gtk_entry_set_has_frame( self._f('GtkEntry'), $setting);
}

sub gtk_entry_set_has_frame (
  N-GObject $entry, gboolean $setting
) is native(&gtk-lib)
  { * }

#-------------------------------------------------------------------------------
#TM:0:set-icon-activatable:
=begin pod
=head2 set-icon-activatable

Sets whether the icon is activatable.

  method set-icon-activatable ( GtkEntryIconPosition $icon_pos, Bool $activatable )

=item $icon_pos; Icon position
=item $activatable; C<True> if the icon should be activatable
=end pod

method set-icon-activatable ( GtkEntryIconPosition $icon_pos, Bool $activatable ) {
  gtk_entry_set_icon_activatable( self._f('GtkEntry'), $icon_pos, $activatable);
}

sub gtk_entry_set_icon_activatable (
  N-GObject $entry, GEnum $icon_pos, gboolean $activatable
) is native(&gtk-lib)
  { * }

#-------------------------------------------------------------------------------
#TM:0:set-icon-drag-source:
=begin pod
=head2 set-icon-drag-source

Sets up the icon at the given position so that GTK+ will start a drag operation when the user clicks and drags the icon.

To handle the drag operation, you need to connect to the usual I<drag-data-get from Gnome::Gtk3::Widget> (or possibly I<drag-data-delete from Gnome::Gtk3::Widget>) signal, and use C<get_current_icon_drag_source()> in your signal handler to find out if the drag was started from an icon.

By default, GTK+ uses the icon as the drag icon. You can use the I<drag-begin from Gnome::Gtk3::Widget> signal to set a different icon. Note that you have to use C<g_signal_connect_after()> to ensure that your signal handler gets executed after the default handler.

  method set-icon-drag-source ( GtkEntryIconPosition $icon_pos, N-GtkTargetList $target_list, GdkDragAction $actions )

=item $icon_pos; icon position
=item $target_list; the targets (data formats) in which the data can be provided
=item $actions; a bitmask of the allowed drag actions
=end pod

method set-icon-drag-source ( GtkEntryIconPosition $icon_pos, N-GtkTargetList $target_list, GdkDragAction $actions ) {
  gtk_entry_set_icon_drag_source(
    self._f('GtkEntry'), $icon_pos, $target_list, $actions
  );
}

sub gtk_entry_set_icon_drag_source (
  N-GObject $entry, GEnum $icon_pos, N-GtkTargetList $target_list, GEnum $actions
) is native(&gtk-lib)
  { * }

#-------------------------------------------------------------------------------
#TM:0:set-icon-from-gicon:
=begin pod
=head2 set-icon-from-gicon

Sets the icon shown in the entry at the specified position from the current icon theme. If the icon isn’t known, a “broken image” icon will be displayed instead.

If I<icon> is C<undefined>, no icon will be shown in the specified position.

  method set-icon-from-gicon ( GtkEntryIconPosition $icon_pos, N-GObject() $icon )

=item $icon_pos; The position at which to set the icon
=item $icon; The icon to set, or C<undefined>
=end pod

method set-icon-from-gicon ( GtkEntryIconPosition $icon_pos, N-GObject() $icon ) {
  gtk_entry_set_icon_from_gicon( self._f('GtkEntry'), $icon_pos, $icon);
}

sub gtk_entry_set_icon_from_gicon (
  N-GObject $entry, GEnum $icon_pos, N-GObject $icon
) is native(&gtk-lib)
  { * }

#-------------------------------------------------------------------------------
#TM:0:set-icon-from-icon-name:
=begin pod
=head2 set-icon-from-icon-name

Sets the icon shown in the entry at the specified position from the current icon theme.

If the icon name isn’t known, a “broken image” icon will be displayed instead.

If I<icon_name> is C<undefined>, no icon will be shown in the specified position.

  method set-icon-from-icon-name ( GtkEntryIconPosition $icon_pos, Str $icon_name )

=item $icon_pos; The position at which to set the icon
=item $icon_name; An icon name, or C<undefined>
=end pod

method set-icon-from-icon-name ( GtkEntryIconPosition $icon_pos, Str $icon_name ) {
  gtk_entry_set_icon_from_icon_name( self._f('GtkEntry'), $icon_pos, $icon_name);
}

sub gtk_entry_set_icon_from_icon_name (
  N-GObject $entry, GEnum $icon_pos, gchar-ptr $icon_name
) is native(&gtk-lib)
  { * }

#-------------------------------------------------------------------------------
#TM:0:set-icon-from-pixbuf:
=begin pod
=head2 set-icon-from-pixbuf

Sets the icon shown in the specified position using a pixbuf.

If I<pixbuf> is C<undefined>, no icon will be shown in the specified position.

  method set-icon-from-pixbuf ( GtkEntryIconPosition $icon_pos, N-GObject() $pixbuf )

=item $icon_pos; Icon position
=item $pixbuf; A B<Gnome::Gdk3::Pixbuf>, or C<undefined>
=end pod

method set-icon-from-pixbuf ( GtkEntryIconPosition $icon_pos, N-GObject() $pixbuf ) {
  gtk_entry_set_icon_from_pixbuf( self._f('GtkEntry'), $icon_pos, $pixbuf);
}

sub gtk_entry_set_icon_from_pixbuf (
  N-GObject $entry, GEnum $icon_pos, N-GObject $pixbuf
) is native(&gtk-lib)
  { * }

#-------------------------------------------------------------------------------
#TM:0:set-icon-sensitive:
=begin pod
=head2 set-icon-sensitive

Sets the sensitivity for the specified icon.

  method set-icon-sensitive ( GtkEntryIconPosition $icon_pos, Bool $sensitive )

=item $icon_pos; Icon position
=item $sensitive; Specifies whether the icon should appear sensitive or insensitive
=end pod

method set-icon-sensitive ( GtkEntryIconPosition $icon_pos, Bool $sensitive ) {
  gtk_entry_set_icon_sensitive( self._f('GtkEntry'), $icon_pos, $sensitive);
}

sub gtk_entry_set_icon_sensitive (
  N-GObject $entry, GEnum $icon_pos, gboolean $sensitive
) is native(&gtk-lib)
  { * }

#`{{
#-------------------------------------------------------------------------------
#TM:0:set-icon-tooltip-markup:
=begin pod
=head2 set-icon-tooltip-markup

Sets I<tooltip> as the contents of the tooltip for the icon at the specified position. I<tooltip> is assumed to be marked up with the [Pango text markup language][PangoMarkupFormat].

Use C<undefined> for I<tooltip> to remove an existing tooltip.

See also C<gtk_widget_set_tooltip_markup()> and C<set_icon_tooltip_text()>.

  method set-icon-tooltip-markup ( GtkEntryIconPosition $icon_pos, Str $tooltip )

=item $icon_pos; the icon position
=item $tooltip; the contents of the tooltip for the icon, or C<undefined>
=end pod

method set-icon-tooltip-markup ( GtkEntryIconPosition $icon_pos, Str $tooltip ) {
  gtk_entry_set_icon_tooltip_markup( self._f('GtkEntry'), $icon_pos, $tooltip);
}

sub gtk_entry_set_icon_tooltip_markup (
  N-GObject $entry, GEnum $icon_pos, gchar-ptr $tooltip
) is native(&gtk-lib)
  { * }
}}

#-------------------------------------------------------------------------------
#TM:0:set-icon-tooltip-text:
=begin pod
=head2 set-icon-tooltip-text

Sets I<tooltip> as the contents of the tooltip for the icon at the specified position.

Use C<undefined> for I<tooltip> to remove an existing tooltip.

See also C<gtk_widget_set_tooltip_text()> and C<set_icon_tooltip_markup()>.

If you unset the widget tooltip via C<gtk_widget_set_tooltip_text()> or C<gtk_widget_set_tooltip_markup()>, this sets GtkWidget:has-tooltip to C<False>, which suppresses icon tooltips too. You can resolve this by then calling C<gtk_widget_set_has_tooltip()> to set GtkWidget:has-tooltip back to C<True>, or setting at least one non-empty tooltip on any icon achieves the same result.

  method set-icon-tooltip-text ( GtkEntryIconPosition $icon_pos, Str $tooltip )

=item $icon_pos; the icon position
=item $tooltip; the contents of the tooltip for the icon, or C<undefined>
=end pod

method set-icon-tooltip-text ( GtkEntryIconPosition $icon_pos, Str $tooltip ) {
  gtk_entry_set_icon_tooltip_text( self._f('GtkEntry'), $icon_pos, $tooltip);
}

sub gtk_entry_set_icon_tooltip_text (
  N-GObject $entry, GEnum $icon_pos, gchar-ptr $tooltip
) is native(&gtk-lib)
  { * }

#-------------------------------------------------------------------------------
#TM:0:set-input-hints:
=begin pod
=head2 set-input-hints

Sets the I<input-hints> property, which allows input methods to fine-tune their behaviour.

  method set-input-hints ( GtkInputHints $hints )

=item $hints; the hints
=end pod

method set-input-hints ( GtkInputHints $hints ) {
  gtk_entry_set_input_hints( self._f('GtkEntry'), $hints);
}

sub gtk_entry_set_input_hints (
  N-GObject $entry, GEnum $hints
) is native(&gtk-lib)
  { * }

#-------------------------------------------------------------------------------
#TM:0:set-input-purpose:
=begin pod
=head2 set-input-purpose

Sets the I<input-purpose> property which can be used by on-screen keyboards and other input methods to adjust their behaviour.

  method set-input-purpose ( GtkInputPurpose $purpose )

=item $purpose; the purpose
=end pod

method set-input-purpose ( GtkInputPurpose $purpose ) {
  gtk_entry_set_input_purpose( self._f('GtkEntry'), $purpose);
}

sub gtk_entry_set_input_purpose (
  N-GObject $entry, GEnum $purpose
) is native(&gtk-lib)
  { * }

#-------------------------------------------------------------------------------
#TM:0:set-invisible-char:
=begin pod
=head2 set-invisible-char

Sets the character to use in place of the actual text when C<set_visibility()> has been called to set text visibility to C<False>. i.e. this is the character used in “password mode” to show the user how many characters have been typed. By default, GTK+ picks the best invisible char available in the current font. If you set the invisible char to 0, then the user will get no feedback at all; there will be no text on the screen as they type.

  method set-invisible-char ( gunichar $ch )

=item $ch; a Unicode character
=end pod

method set-invisible-char ( gunichar $ch ) {
  gtk_entry_set_invisible_char( self._f('GtkEntry'), $ch);
}

sub gtk_entry_set_invisible_char (
  N-GObject $entry, gunichar $ch
) is native(&gtk-lib)
  { * }

#-------------------------------------------------------------------------------
#TM:0:set-max-length:
=begin pod
=head2 set-max-length

Sets the maximum allowed length of the contents of the widget. If the current contents are longer than the given length, then they will be truncated to fit.

This is equivalent to getting I<entry>'s B<Gnome::Gtk3::EntryBuffer> and calling C<buffer_set_max_length()> on it. ]|

  method set-max-length ( Int() $max )

=item $max; the maximum length of the entry, or 0 for no maximum. (other than the maximum length of entries.) The value passed in will be clamped to the range 0-65536.
=end pod

method set-max-length ( Int() $max ) {
  gtk_entry_set_max_length( self._f('GtkEntry'), $max);
}

sub gtk_entry_set_max_length (
  N-GObject $entry, gint $max
) is native(&gtk-lib)
  { * }

#-------------------------------------------------------------------------------
#TM:0:set-max-width-chars:
=begin pod
=head2 set-max-width-chars

Sets the desired maximum width in characters of I<entry>.

  method set-max-width-chars ( Int() $n_chars )

=item $n_chars; the new desired maximum width, in characters
=end pod

method set-max-width-chars ( Int() $n_chars ) {
  gtk_entry_set_max_width_chars( self._f('GtkEntry'), $n_chars);
}

sub gtk_entry_set_max_width_chars (
  N-GObject $entry, gint $n_chars
) is native(&gtk-lib)
  { * }

#-------------------------------------------------------------------------------
#TM:0:set-overwrite-mode:
=begin pod
=head2 set-overwrite-mode

Sets whether the text is overwritten when typing in the B<Gnome::Gtk3::Entry>.

  method set-overwrite-mode ( Bool $overwrite )

=item $overwrite; new value
=end pod

method set-overwrite-mode ( Bool $overwrite ) {
  gtk_entry_set_overwrite_mode( self._f('GtkEntry'), $overwrite);
}

sub gtk_entry_set_overwrite_mode (
  N-GObject $entry, gboolean $overwrite
) is native(&gtk-lib)
  { * }

#-------------------------------------------------------------------------------
#TM:0:set-placeholder-text:
=begin pod
=head2 set-placeholder-text

Sets text to be displayed in I<entry> when it is empty and unfocused. This can be used to give a visual hint of the expected contents of the B<Gnome::Gtk3::Entry>.

Note that since the placeholder text gets removed when the entry received focus, using this feature is a bit problematic if the entry is given the initial focus in a window. Sometimes this can be worked around by delaying the initial focus setting until the first key event arrives.

  method set-placeholder-text ( Str $text )

=item $text; a string to be displayed when I<entry> is empty and unfocused, or C<undefined>
=end pod

method set-placeholder-text ( Str $text ) {
  gtk_entry_set_placeholder_text( self._f('GtkEntry'), $text);
}

sub gtk_entry_set_placeholder_text (
  N-GObject $entry, gchar-ptr $text
) is native(&gtk-lib)
  { * }

#-------------------------------------------------------------------------------
#TM:0:set-progress-fraction:
=begin pod
=head2 set-progress-fraction

Causes the entry’s progress indicator to “fill in” the given fraction of the bar. The fraction should be between 0.0 and 1.0, inclusive.

  method set-progress-fraction ( Num() $fraction )

=item $fraction; fraction of the task that’s been completed
=end pod

method set-progress-fraction ( Num() $fraction ) {
  gtk_entry_set_progress_fraction( self._f('GtkEntry'), $fraction);
}

sub gtk_entry_set_progress_fraction (
  N-GObject $entry, gdouble $fraction
) is native(&gtk-lib)
  { * }

#-------------------------------------------------------------------------------
#TM:0:set-progress-pulse-step:
=begin pod
=head2 set-progress-pulse-step

Sets the fraction of total entry width to move the progress bouncing block for each call to C<progress_pulse()>.

  method set-progress-pulse-step ( Num() $fraction )

=item $fraction; fraction between 0.0 and 1.0
=end pod

method set-progress-pulse-step ( Num() $fraction ) {
  gtk_entry_set_progress_pulse_step( self._f('GtkEntry'), $fraction);
}

sub gtk_entry_set_progress_pulse_step (
  N-GObject $entry, gdouble $fraction
) is native(&gtk-lib)
  { * }

#`{{
#-------------------------------------------------------------------------------
#TM:0:set-tabs:
=begin pod
=head2 set-tabs

Sets a B<PangoTabArray>; the tabstops in the array are applied to the entry text.

  method set-tabs ( PangoTabArray $tabs )

=item $tabs; a B<PangoTabArray>
=end pod

method set-tabs ( PangoTabArray $tabs ) {
  gtk_entry_set_tabs( self._f('GtkEntry'), $tabs);
}

sub gtk_entry_set_tabs (
  N-GObject $entry, PangoTabArray $tabs
) is native(&gtk-lib)
  { * }
}}

#-------------------------------------------------------------------------------
#TM:1:set-text:
=begin pod
=head2 set-text

Sets the text in the widget to the given value, replacing the current contents.

See C<buffer_set_text()>.

  method set-text ( Str $text )

=item $text; the new text
=end pod

method set-text ( Str $text ) {
  gtk_entry_set_text( self._f('GtkEntry'), $text);
}

sub gtk_entry_set_text (
  N-GObject $entry, gchar-ptr $text
) is native(&gtk-lib)
  { * }

#-------------------------------------------------------------------------------
#TM:0:set-visibility:
=begin pod
=head2 set-visibility

Sets whether the contents of the entry are visible or not. When visibility is set to C<False>, characters are displayed as the invisible char, and will also appear that way when the text in the entry widget is copied elsewhere.

By default, GTK+ picks the best invisible character available in the current font, but it can be changed with C<set_invisible_char()>.

Note that you probably want to set I<input-purpose> to C<GTK_INPUT_PURPOSE_PASSWORD> or C<GTK_INPUT_PURPOSE_PIN> to inform input methods about the purpose of this entry, in addition to setting visibility to C<False>.

  method set-visibility ( Bool $visible )

=item $visible; C<True> if the contents of the entry are displayed as plaintext
=end pod

method set-visibility ( Bool $visible ) {
  gtk_entry_set_visibility( self._f('GtkEntry'), $visible);
}

sub gtk_entry_set_visibility (
  N-GObject $entry, gboolean $visible
) is native(&gtk-lib)
  { * }

#-------------------------------------------------------------------------------
#TM:0:set-width-chars:
=begin pod
=head2 set-width-chars

Changes the size request of the entry to be about the right size for I<n_chars> characters. Note that it changes the size request, the size can still be affected by how you pack the widget into containers. If I<n_chars> is -1, the size reverts to the default entry size.

  method set-width-chars ( Int() $n_chars )

=item $n_chars; width in chars
=end pod

method set-width-chars ( Int() $n_chars ) {
  gtk_entry_set_width_chars( self._f('GtkEntry'), $n_chars);
}

sub gtk_entry_set_width_chars (
  N-GObject $entry, gint $n_chars
) is native(&gtk-lib)
  { * }

#`{{
#-------------------------------------------------------------------------------
#TM:0:text-index-to-layout-index:
=begin pod
=head2 text-index-to-layout-index

Converts from a position in the entry contents (returned by C<get_text()>) to a position in the entry’s B<PangoLayout> (returned by C<get_layout()>, with text retrieved via C<pango_layout_get_text()>).

Returns: byte index into the entry layout text

  method text-index-to-layout-index ( Int() $text_index --> Int )

=item $text_index; byte index into the entry contents
=end pod

method text-index-to-layout-index ( Int() $text_index --> Int ) {
  gtk_entry_text_index_to_layout_index( self._f('GtkEntry'), $text_index)
}

sub gtk_entry_text_index_to_layout_index (
  N-GObject $entry, gint $text_index --> gint
) is native(&gtk-lib)
  { * }
}}

#-------------------------------------------------------------------------------
#TM:0:unset-invisible-char:
=begin pod
=head2 unset-invisible-char

Unsets the invisible char previously set with C<set_invisible_char()>. So that the default invisible char is used again.

  method unset-invisible-char ( )

=end pod

method unset-invisible-char ( ) {
  gtk_entry_unset_invisible_char( self._f('GtkEntry'));
}

sub gtk_entry_unset_invisible_char (
  N-GObject $entry
) is native(&gtk-lib)
  { * }

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

Creates a new entry.

Returns: a new B<Gnome::Gtk3::Entry>.

  method _gtk_entry_new ( --> N-GObject )

=end pod
}}

sub _gtk_entry_new (  --> N-GObject )
  is native(&gtk-lib)
  is symbol('gtk_entry_new')
  { * }

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

Creates a new entry with the specified text buffer.

Returns: a new B<Gnome::Gtk3::Entry>

  method _gtk_entry_new_with_buffer ( N-GObject() $buffer --> N-GObject )

=item $buffer; The buffer to use for the new B<Gnome::Gtk3::Entry>.
=end pod
}}

sub _gtk_entry_new_with_buffer ( N-GObject $buffer --> N-GObject )
  is native(&gtk-lib)
  is symbol('gtk_entry_new_with_buffer')
  { * }

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


=comment -----------------------------------------------------------------------
=comment #TS:0:activate:
=head2 activate

The I<activate> signal is emitted when the user hits
the Enter key.

While this signal is used as a
[keybinding signal][GtkBindingSignal],
it is also commonly used by applications to intercept
activation of entries.

The default bindings for this signal are all forms of the Enter key.

  method handler (
    Int :$_handler-id,
    N-GObject :$_native-object,
    *%user-options
  )

=item $_handler-id; The handler id which is returned from the registration
=item $_native-object; The native object provided by the caller wrapped in the Raku object which registered the signal.
=item %user-options; A list of named arguments provided at the C<register-signal()> method

=comment -----------------------------------------------------------------------
=comment #TS:0:backspace:
=head2 backspace

The I<backspace> signal is a
[keybinding signal][GtkBindingSignal]
which gets emitted when the user asks for it.

The default bindings for this signal are
Backspace and Shift-Backspace.

  method handler (
    Int :$_handler-id,
    N-GObject :$_native-object,
    *%user-options
  )

=item $_handler-id; The handler id which is returned from the registration
=item $_native-object; The native object provided by the caller wrapped in the Raku object which registered the signal.
=item %user-options; A list of named arguments provided at the C<register-signal()> method

=comment -----------------------------------------------------------------------
=comment #TS:0:copy-clipboard:
=head2 copy-clipboard

The I<copy-clipboard> signal is a
[keybinding signal][GtkBindingSignal]
which gets emitted to copy the selection to the clipboard.

The default bindings for this signal are
Ctrl-c and Ctrl-Insert.

  method handler (
    Int :$_handler-id,
    N-GObject :$_native-object,
    *%user-options
  )

=item $_handler-id; The handler id which is returned from the registration
=item $_native-object; The native object provided by the caller wrapped in the Raku object which registered the signal.
=item %user-options; A list of named arguments provided at the C<register-signal()> method

=comment -----------------------------------------------------------------------
=comment #TS:0:cut-clipboard:
=head2 cut-clipboard

The I<cut-clipboard> signal is a
[keybinding signal][GtkBindingSignal]
which gets emitted to cut the selection to the clipboard.

The default bindings for this signal are
Ctrl-x and Shift-Delete.

  method handler (
    Int :$_handler-id,
    N-GObject :$_native-object,
    *%user-options
  )

=item $_handler-id; The handler id which is returned from the registration
=item $_native-object; The native object provided by the caller wrapped in the Raku object which registered the signal.
=item %user-options; A list of named arguments provided at the C<register-signal()> method

=comment -----------------------------------------------------------------------
=comment #TS:0:delete-from-cursor:
=head2 delete-from-cursor

The I<delete-from-cursor> signal is a
[keybinding signal][GtkBindingSignal]
which gets emitted when the user initiates a text deletion.

If the I<type> is C<GTK_DELETE_CHARS>, GTK+ deletes the selection
if there is one, otherwise it deletes the requested number
of characters.

The default bindings for this signal are
Delete for deleting a character and Ctrl-Delete for
deleting a word.

  method handler (
    Unknown type: GTK_TYPE_DELETE_TYPE $type,
    Int $count,
    Int :$_handler-id,
    N-GObject :$_native-object,
    *%user-options
  )

=item $type; the granularity of the deletion, as a B<Gnome::Gtk3::DeleteType>
=item $count; the number of I<type> units to delete
=item $_handler-id; The handler id which is returned from the registration
=item $_native-object; The native object provided by the caller wrapped in the Raku object which registered the signal.
=item %user-options; A list of named arguments provided at the C<register-signal()> method

=comment -----------------------------------------------------------------------
=comment #TS:0:icon-press:
=head2 icon-press

The I<icon-press> signal is emitted when an activatable icon
is clicked.

  method handler (
    Unknown type: GTK_TYPE_ENTRY_ICON_POSITION $icon_pos,
    Unknown type: GDK_TYPE_EVENT | G_SIGNAL_TYPE_STATIC_SCOPE $event,
    Int :$_handler-id,
    N-GObject :$_native-object,
    *%user-options
  )

=item $icon_pos; The position of the clicked icon
=item $event; the button press event
=item $_handler-id; The handler id which is returned from the registration
=item $_native-object; The native object provided by the caller wrapped in the Raku object which registered the signal.
=item %user-options; A list of named arguments provided at the C<register-signal()> method

=comment -----------------------------------------------------------------------
=comment #TS:0:icon-release:
=head2 icon-release

The I<icon-release> signal is emitted on the button release from a
mouse click over an activatable icon.

  method handler (
    Unknown type: GTK_TYPE_ENTRY_ICON_POSITION $icon_pos,
    Unknown type: GDK_TYPE_EVENT | G_SIGNAL_TYPE_STATIC_SCOPE $event,
    Int :$_handler-id,
    N-GObject :$_native-object,
    *%user-options
  )

=item $icon_pos; The position of the clicked icon
=item $event; the button release event
=item $_handler-id; The handler id which is returned from the registration
=item $_native-object; The native object provided by the caller wrapped in the Raku object which registered the signal.
=item %user-options; A list of named arguments provided at the C<register-signal()> method

=comment -----------------------------------------------------------------------
=comment #TS:0:insert-at-cursor:
=head2 insert-at-cursor

The I<insert-at-cursor> signal is a
[keybinding signal][GtkBindingSignal]
which gets emitted when the user initiates the insertion of a
fixed string at the cursor.

This signal has no default bindings.

  method handler (
    Str $string,
    Int :$_handler-id,
    N-GObject :$_native-object,
    *%user-options
  )

=item $string; the string to insert
=item $_handler-id; The handler id which is returned from the registration
=item $_native-object; The native object provided by the caller wrapped in the Raku object which registered the signal.
=item %user-options; A list of named arguments provided at the C<register-signal()> method

=comment -----------------------------------------------------------------------
=comment #TS:0:insert-emoji:
=head2 insert-emoji

The I<insert-emoji> signal is a
[keybinding signal][GtkBindingSignal]
which gets emitted to present the Emoji chooser for the I<entry>.

The default bindings for this signal are Ctrl-. and Ctrl-;.27

  method handler (
    Int :$_handler-id,
    N-GObject :$_native-object,
    *%user-options
  )

=item $_handler-id; The handler id which is returned from the registration
=item $_native-object; The native object provided by the caller wrapped in the Raku object which registered the signal.
=item %user-options; A list of named arguments provided at the C<register-signal()> method

=comment -----------------------------------------------------------------------
=comment #TS:0:move-cursor:
=head2 move-cursor

The I<move-cursor> signal is a
[keybinding signal][GtkBindingSignal]
which gets emitted when the user initiates a cursor movement.
If the cursor is not visible in I<entry>, this signal causes
the viewport to be moved instead.

Applications should not connect to it, but may emit it with
C<g_signal_emit_by_name()> if they need to control the cursor
programmatically.

The default bindings for this signal come in two variants,
the variant with the Shift modifier extends the selection,
the variant without the Shift modifer does not.
There are too many key combinations to list them all here.
- Arrow keys move by individual characters/lines
- Ctrl-arrow key combinations move by words/paragraphs
- Home/End keys move to the ends of the buffer

  method handler (
    Unknown type: GTK_TYPE_MOVEMENT_STEP $step,
    Int $count,
    Bool $extend_selection,
    Int :$_handler-id,
    N-GObject :$_native-object,
    *%user-options
  )

=item $step; the granularity of the move, as a B<Gnome::Gtk3::MovementStep>
=item $count; the number of I<step> units to move
=item $extend_selection; C<True> if the move should extend the selection
=item $_handler-id; The handler id which is returned from the registration
=item $_native-object; The native object provided by the caller wrapped in the Raku object which registered the signal.
=item %user-options; A list of named arguments provided at the C<register-signal()> method

=comment -----------------------------------------------------------------------
=comment #TS:0:paste-clipboard:
=head2 paste-clipboard

The I<paste-clipboard> signal is a
[keybinding signal][GtkBindingSignal]
which gets emitted to paste the contents of the clipboard
into the text view.

The default bindings for this signal are
Ctrl-v and Shift-Insert.

  method handler (
    Int :$_handler-id,
    N-GObject :$_native-object,
    *%user-options
  )

=item $_handler-id; The handler id which is returned from the registration
=item $_native-object; The native object provided by the caller wrapped in the Raku object which registered the signal.
=item %user-options; A list of named arguments provided at the C<register-signal()> method

=comment -----------------------------------------------------------------------
=comment #TS:0:populate-popup:
=head2 populate-popup

The I<populate-popup> signal gets emitted before showing the
context menu of the entry.

If you need to add items to the context menu, connect
to this signal and append your items to the I<widget>, which
will be a B<Gnome::Gtk3::Menu> in this case.

If I<populate-all> is C<True>, this signal will
also be emitted to populate touch popups. In this case,
I<widget> will be a different container, e.g. a B<Gnome::