### ----------------------------------------------------
### -- Gnome::Gtk3
### -- Licenses: Artistic-2.0
### -- Authors: Marcel Timmerman
### -- File: lib/Gnome/Gtk3/TreeView.rakumod
### ----------------------------------------------------
### -- Chunk 2 of 3
_get_reorderable ( N-GObject $tree_view --> int32 )
  is native(&gtk-lib)
  { * }

#`{{
#-------------------------------------------------------------------------------
#TM:0:gtk_tree_view_set_cursor:
=begin pod
=head2 [[gtk_] tree_view_] set_cursor

Sets the current keyboard focus to be at I<path>, and selects it.  This is
useful when you want to focus the user’s attention on a particular row.  If
I<focus_column> is not C<Any>, then focus is given to the column specified by
it. Additionally, if I<focus_column> is specified, and I<start_editing> is
C<1>, then editing should be started in the specified cell.
This function is often followed by I<gtk_widget_grab_focus> (I<tree_view>)
in order to give keyboard focus to the widget.  Please note that editing
can only happen when the widget is realized.

If I<path> is invalid for I<model>, the current cursor (if any) will be unset
and the function will return without failing.

  method gtk_tree_view_set_cursor ( N-GtkTreePath $path, N-GObject $focus_column, Int $start_editing )

=item N-GtkTreePath $path; A B<Gnome::Gtk3::TreePath>
=item N-GObject $focus_column; (allow-none): A B<Gnome::Gtk3::TreeViewColumn>, or C<Any>
=item Int $start_editing; C<1> if the specified cell should start being edited.

=end pod

sub gtk_tree_view_set_cursor ( N-GObject $tree_view, N-GtkTreePath $path, N-GObject $focus_column, int32 $start_editing )
  is native(&gtk-lib)
  { * }
}}

#`{{
#-------------------------------------------------------------------------------
#TM:0:gtk_tree_view_set_cursor_on_cell:
=begin pod
=head2 [[gtk_] tree_view_] set_cursor_on_cell

Sets the current keyboard focus to be at I<path>, and selects it.  This is
useful when you want to focus the user’s attention on a particular row.  If
I<focus_column> is not C<Any>, then focus is given to the column specified by
it. If I<focus_column> and I<focus_cell> are not C<Any>, and I<focus_column>
contains 2 or more editable or activatable cells, then focus is given to
the cell specified by I<focus_cell>. Additionally, if I<focus_column> is
specified, and I<start_editing> is C<1>, then editing should be started in
the specified cell.  This function is often followed by
I<gtk_widget_grab_focus> (I<tree_view>) in order to give keyboard focus to the
widget.  Please note that editing can only happen when the widget is
realized.

If I<path> is invalid for I<model>, the current cursor (if any) will be unset
and the function will return without failing.


  method gtk_tree_view_set_cursor_on_cell ( N-GtkTreePath $path, N-GObject $focus_column, N-GObject $focus_cell, Int $start_editing )

=item N-GtkTreePath $path; A B<Gnome::Gtk3::TreePath>
=item N-GObject $focus_column; (allow-none): A B<Gnome::Gtk3::TreeViewColumn>, or C<Any>
=item N-GObject $focus_cell; (allow-none): A B<Gnome::Gtk3::CellRenderer>, or C<Any>
=item Int $start_editing; C<1> if the specified cell should start being edited.

=end pod

sub gtk_tree_view_set_cursor_on_cell ( N-GObject $tree_view, N-GtkTreePath $path, N-GObject $focus_column, N-GObject $focus_cell, int32 $start_editing )
  is native(&gtk-lib)
  { * }
}}
#`{{
#-------------------------------------------------------------------------------
#TM:0:gtk_tree_view_get_cursor:
=begin pod
=head2 [[gtk_] tree_view_] get_cursor

Fills in I<path> and I<focus_column> with the current path and focus column.  If
the cursor isn’t currently set, then *I<path> will be C<Any>.  If no column
currently has focus, then *I<focus_column> will be C<Any>.

The returned B<Gnome::Gtk3::TreePath> must be freed with C<gtk_tree_path_free()> when
you are done with it.

  method gtk_tree_view_get_cursor ( N-GtkTreePath $path, N-GObject $focus_column )

=item N-GtkTreePath $path; (out) (transfer full) (optional) (nullable): A pointer to be filled with the current cursor path, or C<Any>
=item N-GObject $focus_column; (out) (transfer none) (optional) (nullable): A pointer to be filled with the current focus column, or C<Any>

=end pod

sub gtk_tree_view_get_cursor ( N-GObject $tree_view, N-GtkTreePath $path, N-GObject $focus_column )
  is native(&gtk-lib)
  { * }
}}

#-------------------------------------------------------------------------------
#TM:0:gtk_tree_view_get_bin_window:
=begin pod
=head2 [[gtk_] tree_view_] get_bin_window

Returns the window that I<tree_view> renders to. This is used primarily to compare to `event->window` to confirm that the event on I<tree_view> is on the right window.

Returns: A native B<Gnome::Gdk3::Window>, or C<Any> when the I<tree_view> hasn’t been realized yet.

  method gtk_tree_view_get_bin_window ( --> N-GObject )

=end pod

sub gtk_tree_view_get_bin_window ( N-GObject $tree_view --> N-GObject )
  is native(&gtk-lib)
  { * }

#-------------------------------------------------------------------------------
#TM:2:gtk_tree_view_get_path_at_pos:ex-liststore-3.raku
=begin pod
=head2 [[gtk_] tree_view_] get_path_at_pos

Finds the path at the point (I<$x>, I<$y>), relative to bin_window coordinates (please see C<gtk_tree_view_get_bin_window()>). That is, I<$x> and I<$y> are relative to an events coordinates. I<$x> and I<$y> must come from an event on the I<tree_view> only where `event->window == C<gtk_tree_view_get_bin_window()>`. It is primarily for things like popup menus. If I<$path> is non-C<Any>, then it will be set with the B<Gnome::Gtk3::TreePath> at that point.  This path should be freed with C<.clear-object()>.  If I<$column> is defined, then it set with the column at that point.  I<$cell_x> and I<$cell_y> return the coordinates relative to the cell background (i.e. the I<background_area> passed to C<gtk_cell_renderer_render()>).  This function is only meaningful if I<tree_view> is realized.  Therefore this function will always return C<0> if I<tree_view> is not realized or does not have a model.

For converting widget coordinates (eg. the ones you get from B<Gnome::Gtk3::Widget>::query-tooltip), please see C<gtk_tree_view_convert_widget_to_bin_window_coords()>.

  method gtk_tree_view_get_path_at_pos (
    Int $x, Int $y --> List
  )

=item Int $x; The x position to be identified (relative to bin_window).
=item Int $y; The y position to be identified (relative to bin_window).

The returned list holds
=item Bool $exists: C<True> if a row exists at that coordinate.
=item N-GtkTreePath $path; A native B<Gnome::Gtk3::TreePath>, or C<Any>
=item N-GObject $column; A native B<Gnome::Gtk3::TreeViewColumn>, or C<Any>
=item Int $cell_x; X coordinate relative to the cell, or C<Any>
=item Int $cell_y; Y coordinate relative to the cell, or C<Any>

=end pod

sub gtk_tree_view_get_path_at_pos (
  N-GObject $tree_view, int32 $x, int32 $y --> List
) {
  my $np-tp = CArray[N-GtkTreePath].new(N-GtkTreePath);
  my $np-tvc = CArray[N-GObject].new(N-GObject);
  my int32 $cx = 0;
  my int32 $cy = 0;
  my Int $is-path = _gtk_tree_view_get_path_at_pos(
    $tree_view, $x, $y, $np-tp, $np-tvc, $cx, $cy
  );

  ( ?$is-path, Gnome::Gtk3::TreePath.new(:native-object($np-tp[0])),
    Gnome::Gtk3::TreeViewColumn.new(:native-object($np-tvc[0])),
    $cx, $cy
  )
}

sub _gtk_tree_view_get_path_at_pos (
  N-GObject $tree_view, int32 $x, int32 $y,
  CArray[N-GtkTreePath] $path, CArray[N-GObject] $column,
  int32 $cell_x is rw, int32 $cell_y is rw
  --> int32
) is native(&gtk-lib)
  is symbol('gtk_tree_view_get_path_at_pos')
  { * }
#}}

#-------------------------------------------------------------------------------
#TM:0:gtk_tree_view_get_cell_area:
=begin pod
=head2 [[gtk_] tree_view_] get_cell_area

Fills the bounding rectangle in bin_window coordinates for the cell at the row specified by I<$path> and the column specified by I<$column>.  If I<$path> is undefined, or points to a path not currently displayed, the I<y> and I<height> fields of the rectangle will be filled with 0. If I<$column> is undefined, the I<x> and I<width> fields will be filled with 0.  The sum of all cell rects does not cover the entire tree; there are extra pixels in between rows, for example. The returned rectangle is equivalent to the I<cell_area> passed to C<gtk_cell_renderer_render()>.

  method gtk_tree_view_get_cell_area (
    N-GtkTreePath $path, N-GObject $column
    --> N-GdkRectangle
  )

=item N-GtkTreePath $path; a B<Gnome::Gtk3::TreePath> for the row, or C<Any> to get only horizontal coordinates
=item N-GObject $column; a B<Gnome::Gtk3::TreeViewColumn> for the column, or C<Any> to get only vertical coordinates

Returns a N-GdkRectangle rectangle to fill with cell rectangle

=end pod

sub gtk_tree_view_get_cell_area (
  N-GObject $tree_view, N-GtkTreePath $path, N-GObject $column
  --> N-GdkRectangle
) {
  my N-GdkRectangle $rect .= new;
  _gtk_tree_view_get_cell_area( $tree_view, $path, $column, $rect);

  $rect
}

sub _gtk_tree_view_get_cell_area (
  N-GObject $tree_view, N-GtkTreePath $path, N-GObject $column,
  N-GdkRectangle $rect is rw
) is native(&gtk-lib)
  is symbol('gtk_tree_view_get_cell_area')
  { * }

#`{{
#-------------------------------------------------------------------------------
#TM:0:gtk_tree_view_get_background_area:
=begin pod
=head2 [[gtk_] tree_view_] get_background_area

Fills the bounding rectangle in bin_window coordinates for the cell at the
row specified by I<path> and the column specified by I<column>.  If I<path> is
C<Any>, or points to a node not found in the tree, the I<y> and I<height> fields of
the rectangle will be filled with 0. If I<column> is C<Any>, the I<x> and I<width>
fields will be filled with 0.  The returned rectangle is equivalent to the
I<background_area> passed to C<gtk_cell_renderer_render()>.  These background
areas tile to cover the entire bin window.  Contrast with the I<cell_area>,
returned by C<gtk_tree_view_get_cell_area()>, which returns only the cell
itself, excluding surrounding borders and the tree expander area.


  method gtk_tree_view_get_background_area ( N-GtkTreePath $path, N-GObject $column, N-GObject $rect )

=item N-GtkTreePath $path; (allow-none): a B<Gnome::Gtk3::TreePath> for the row, or C<Any> to get only horizontal coordinates
=item N-GObject $column; (allow-none): a B<Gnome::Gtk3::TreeViewColumn> for the column, or C<Any> to get only vertical coordiantes
=item N-GObject $rect; (out): rectangle to fill with cell background rect

=end pod

sub gtk_tree_view_get_background_area ( N-GObject $tree_view, N-GtkTreePath $path, N-GObject $column, N-GObject $rect )
  is native(&gtk-lib)
  { * }
}}
#-------------------------------------------------------------------------------
#TM:0:gtk_tree_view_get_visible_rect:
=begin pod
=head2 [[gtk_] tree_view_] get_visible_rect

Fills I<visible_rect> with the currently-visible region of the
buffer, in tree coordinates. Convert to bin_window coordinates with
C<gtk_tree_view_convert_tree_to_bin_window_coords()>.
Tree coordinates start at 0,0 for row 0 of the tree, and cover the entire
scrollable area of the tree.

  method gtk_tree_view_get_visible_rect ( N-GObject $visible_rect )

=item N-GObject $visible_rect; (out): rectangle to fill

=end pod

sub gtk_tree_view_get_visible_rect ( N-GObject $tree_view, N-GObject $visible_rect )
  is native(&gtk-lib)
  { * }
#`{{
#-------------------------------------------------------------------------------
#TM:0:gtk_tree_view_get_visible_range:
=begin pod
=head2 [[gtk_] tree_view_] get_visible_range

Sets I<start_path> and I<end_path> to be the first and last visible path.
Note that there may be invisible paths in between.

The paths should be freed with C<gtk_tree_path_free()> after use.

Returns: C<1>, if valid paths were placed in I<start_path> and I<end_path>.


  method gtk_tree_view_get_visible_range ( N-GtkTreePath $start_path, N-GtkTreePath $end_path --> Int  )

=item N-GtkTreePath $start_path; (out) (allow-none): Return location for start of region, or C<Any>.
=item N-GtkTreePath $end_path; (out) (allow-none): Return location for end of region, or C<Any>.

=end pod

sub gtk_tree_view_get_visible_range ( N-GObject $tree_view, N-GtkTreePath $start_path, N-GtkTreePath $end_path --> int32 )
  is native(&gtk-lib)
  { * }
}}

#`{{
#-------------------------------------------------------------------------------
#TM:1:gtk_tree_view_is_blank_at_pos:
=begin pod
=head2 [[gtk_] tree_view_] is_blank_at_pos

Determine whether the point (I<x>, I<y>) in I<tree_view> is blank, that is no cell content nor an expander arrow is drawn at the location. If so, the location can be considered as the background. You might wish to take special action on clicks on the background, such as clearing a current selection, having a custom context menu or starting rubber banding.

The I<x> and I<y> coordinate that are provided must be relative to bin_window coordinates.  That is, I<x> and I<y> must come from an event on I<tree_view> where `event->window == C<gtk_tree_view_get_bin_window()>`.

For converting widget coordinates (eg. the ones you get from B<Gnome::Gtk3::Widget>::query-tooltip), please see C<gtk_tree_view_convert_widget_to_bin_window_coords()>.

The I<path>, I<column>, I<cell_x> and I<cell_y> arguments will be filled in likewise as for C<gtk_tree_view_get_path_at_pos()>.  Please see C<gtk_tree_view_get_path_at_pos()> for more information.

Returns: C<1> if the area at the given coordinates is blank,
C<0> otherwise.


  method gtk_tree_view_is_blank_at_pos ( Int $x, Int $y, N-GtkTreePath $path, N-GObject $column, Int $cell_x, Int $cell_y --> Int  )

=item Int $x; The x position to be identified (relative to bin_window)
=item Int $y; The y position to be identified (relative to bin_window)
=item N-GtkTreePath $path; (out) (allow-none): A pointer to a B<Gnome::Gtk3::TreePath> pointer to be filled in, or C<Any>
=item N-GObject $column; (out) (allow-none): A pointer to a B<Gnome::Gtk3::TreeViewColumn> pointer to be filled in, or C<Any>
=item Int $cell_x; (out) (allow-none): A pointer where the X coordinate relative to the cell can be placed, or C<Any>
=item Int $cell_y; (out) (allow-none): A pointer where the Y coordinate relative to the cell can be placed, or C<Any>

=end pod

sub gtk_tree_view_is_blank_at_pos ( N-GObject $tree_view, int32 $x, int32 $y, N-GtkTreePath $path, N-GObject $column, int32 $cell_x, int32 $cell_y --> int32 )
  is native(&gtk-lib)
  { * }
}}
#`{{
#-------------------------------------------------------------------------------
#TM:0:gtk_tree_view_enable_model_drag_source:
=begin pod
=head2 [[gtk_] tree_view_] enable_model_drag_source

Turns I<tree_view> into a drag source for automatic DND. Calling this
method sets  I<reorderable> to C<0>.

  method gtk_tree_view_enable_model_drag_source ( GdkModifierType $start_button_mask, GtkTargetEntry $targets, Int $n_targets, GdkDragAction $actions )

=item GdkModifierType $start_button_mask; Mask of allowed buttons to start drag
=item GtkTargetEntry $targets; (array length=n_targets): the table of targets that the drag will support
=item Int $n_targets; the number of items in I<targets>
=item GdkDragAction $actions; the bitmask of possible actions for a drag from this widget

=end pod

sub gtk_tree_view_enable_model_drag_source ( N-GObject $tree_view, int32 $start_button_mask, GtkTargetEntry $targets, int32 $n_targets, GdkDragAction $actions )
  is native(&gtk-lib)
  { * }

#-------------------------------------------------------------------------------
#TM:0:gtk_tree_view_enable_model_drag_dest:
=begin pod
=head2 [[gtk_] tree_view_] enable_model_drag_dest

Turns I<tree_view> into a drop destination for automatic DND. Calling
this method sets  I<reorderable> to C<0>.

  method gtk_tree_view_enable_model_drag_dest ( GtkTargetEntry $targets, Int $n_targets, GdkDragAction $actions )

=item GtkTargetEntry $targets; (array length=n_targets): the table of targets that the drag will support
=item Int $n_targets; the number of items in I<targets>
=item GdkDragAction $actions; the bitmask of possible actions for a drag from this widget

=end pod

sub gtk_tree_view_enable_model_drag_dest ( N-GObject $tree_view, GtkTargetEntry $targets, int32 $n_targets, GdkDragAction $actions )
  is native(&gtk-lib)
  { * }
}}

#-------------------------------------------------------------------------------
#TM:0:gtk_tree_view_unset_rows_drag_source:
=begin pod
=head2 [[gtk_] tree_view_] unset_rows_drag_source

Undoes the effect of
C<gtk_tree_view_enable_model_drag_source()>. Calling this method sets
 I<reorderable> to C<0>.

  method gtk_tree_view_unset_rows_drag_source ( )


=end pod

sub gtk_tree_view_unset_rows_drag_source ( N-GObject $tree_view )
  is native(&gtk-lib)
  { * }

#-------------------------------------------------------------------------------
#TM:0:gtk_tree_view_unset_rows_drag_dest:
=begin pod
=head2 [[gtk_] tree_view_] unset_rows_drag_dest

Undoes the effect of
C<gtk_tree_view_enable_model_drag_dest()>. Calling this method sets
 I<reorderable> to C<0>.

  method gtk_tree_view_unset_rows_drag_dest ( )


=end pod

sub gtk_tree_view_unset_rows_drag_dest ( N-GObject $tree_view )
  is native(&gtk-lib)
  { * }

#`{{
#-------------------------------------------------------------------------------
#TM:0:gtk_tree_view_set_drag_dest_row:
=begin pod
=head2 [[gtk_] tree_view_] set_drag_dest_row

Sets the row that is highlighted for feedback.
If I<path> is C<Any>, an existing highlight is removed.

  method gtk_tree_view_set_drag_dest_row ( N-GtkTreePath $path, GtkTreeViewDropPosition $pos )

=item N-GtkTreePath $path; (allow-none): The path of the row to highlight, or C<Any>
=item GtkTreeViewDropPosition $pos; Specifies whether to drop before, after or into the row

=end pod

sub gtk_tree_view_set_drag_dest_row ( N-GObject $tree_view, N-GtkTreePath $path, int32 $pos )
  is native(&gtk-lib)
  { * }

#-------------------------------------------------------------------------------
#TM:0:gtk_tree_view_get_drag_dest_row:
=begin pod
=head2 [[gtk_] tree_view_] get_drag_dest_row

Gets information about the row that is highlighted for feedback.

  method gtk_tree_view_get_drag_dest_row ( N-GtkTreePath $path, GtkTreeViewDropPosition $pos )

=item N-GtkTreePath $path; (out) (optional) (nullable): Return location for the path of the highlighted row, or C<Any>.
=item GtkTreeViewDropPosition $pos; (out) (optional): Return location for the drop position, or C<Any>

=end pod

sub gtk_tree_view_get_drag_dest_row ( N-GObject $tree_view, N-GtkTreePath $path, int32 $pos )
  is native(&gtk-lib)
  { * }

#-------------------------------------------------------------------------------
#TM:0:gtk_tree_view_get_dest_row_at_pos:
=begin pod
=head2 [[gtk_] tree_view_] get_dest_row_at_pos

Determines the destination row for a given position.  I<drag_x> and
I<drag_y> are expected to be in widget coordinates.  This function is only
meaningful if I<tree_view> is realized.  Therefore this function will always
return C<0> if I<tree_view> is not realized or does not have a model.

Returns: whether there is a row at the given position, C<1> if this
is indeed the case.

  method gtk_tree_view_get_dest_row_at_pos ( Int $drag_x, Int $drag_y, N-GtkTreePath $path, GtkTreeViewDropPosition $pos --> Int  )

=item Int $drag_x; the position to determine the destination row for
=item Int $drag_y; the position to determine the destination row for
=item N-GtkTreePath $path; (out) (optional) (nullable): Return location for the path of the highlighted row, or C<Any>.
=item GtkTreeViewDropPosition $pos; (out) (optional): Return location for the drop position, or C<Any>

=end pod

sub gtk_tree_view_get_dest_row_at_pos ( N-GObject $tree_view, int32 $drag_x, int32 $drag_y, N-GtkTreePath $path, int32 $pos --> int32 )
  is native(&gtk-lib)
  { * }

#-------------------------------------------------------------------------------
#TM:0:gtk_tree_view_create_row_drag_icon:
=begin pod
=head2 [[gtk_] tree_view_] create_row_drag_icon

Creates a B<cairo_surface_t> representation of the row at I<path>.
This image is used for a drag icon.

Returns: (transfer full): a newly-allocated surface of the drag icon.

  method gtk_tree_view_create_row_drag_icon ( N-GtkTreePath $path --> cairo_surface_t  )

=item N-GtkTreePath $path; a B<Gnome::Gtk3::TreePath> in I<tree_view>

=end pod

sub gtk_tree_view_create_row_drag_icon ( N-GObject $tree_view, N-GtkTreePath $path --> cairo_surface_t )
  is native(&gtk-lib)
  { * }
}}

#-------------------------------------------------------------------------------
#TM:0:gtk_tree_view_set_enable_search:
=begin pod
=head2 [[gtk_] tree_view_] set_enable_search

If I<enable_search> is set, then the user can type in text to search through
the tree interactively (this is sometimes called "typeahead find").

Note that even if this is C<0>, the user can still initiate a search
using the “start-interactive-search” key binding.

  method gtk_tree_view_set_enable_search ( Int $enable_search )

=item Int $enable_search; C<1>, if the user can search interactively

=end pod

sub gtk_tree_view_set_enable_search ( N-GObject $tree_view, int32 $enable_search )
  is native(&gtk-lib)
  { * }

#-------------------------------------------------------------------------------
#TM:0:gtk_tree_view_get_enable_search:
=begin pod
=head2 [[gtk_] tree_view_] get_enable_search

Returns whether or not the tree allows to start interactive searching
by typing in text.

Returns: whether or not to let the user search interactively

  method gtk_tree_view_get_enable_search ( --> Int  )


=end pod

sub gtk_tree_view_get_enable_search ( N-GObject $tree_view --> int32 )
  is native(&gtk-lib)
  { * }

#-------------------------------------------------------------------------------
#TM:0:gtk_tree_view_get_search_column:
=begin pod
=head2 [[gtk_] tree_view_] get_search_column

Gets the column searched on by the interactive search code.

Returns: the column the interactive search code searches in.

  method gtk_tree_view_get_search_column ( --> Int  )


=end pod

sub gtk_tree_view_get_search_column ( N-GObject $tree_view --> int32 )
  is native(&gtk-lib)
  { * }

#-------------------------------------------------------------------------------
#TM:0:gtk_tree_view_set_search_column:
=begin pod
=head2 [[gtk_] tree_view_] set_search_column

Sets I<column> as the column where the interactive search code should
search in for the current model.

If the search column is set, users can use the “start-interactive-search”
key binding to bring up search popup. The enable-search property controls
whether simply typing text will also start an interactive search.

Note that I<column> refers to a column of the current model. The search
column is reset to -1 when the model is changed.

  method gtk_tree_view_set_search_column ( Int $column )

=item Int $column; the column of the model to search in, or -1 to disable searching

=end pod

sub gtk_tree_view_set_search_column ( N-GObject $tree_view, int32 $column )
  is native(&gtk-lib)
  { * }

#`{{
#-------------------------------------------------------------------------------
#TM:0:gtk_tree_view_get_search_equal_func:
=begin pod
=head2 [[gtk_] tree_view_] get_search_equal_func

Returns the compare function currently in use.

Returns: the currently used compare function for the search code.

  method gtk_tree_view_get_search_equal_func ( --> GtkTreeViewSearchEqualFunc  )


=end pod

sub gtk_tree_view_get_search_equal_func ( N-GObject $tree_view --> GtkTreeViewSearchEqualFunc )
  is native(&gtk-lib)
  { * }
}}
#`{{
#-------------------------------------------------------------------------------
#TM:0:gtk_tree_view_set_search_equal_func:
=begin pod
=head2 [[gtk_] tree_view_] set_search_equal_func

Sets the compare function for the interactive search capabilities; note
that somewhat like C<strcmp()> returning 0 for equality
B<Gnome::Gtk3::TreeViewSearchEqualFunc> returns C<0> on matches.

  method gtk_tree_view_set_search_equal_func ( GtkTreeViewSearchEqualFunc $search_equal_func, Pointer $search_user_data, GDestroyNotify $search_destroy )

=item GtkTreeViewSearchEqualFunc $search_equal_func; the compare function to use during the search
=item Pointer $search_user_data; (allow-none): user data to pass to I<search_equal_func>, or C<Any>
=item GDestroyNotify $search_destroy; (allow-none): Destroy notifier for I<search_user_data>, or C<Any>

=end pod

sub gtk_tree_view_set_search_equal_func ( N-GObject $tree_view, GtkTreeViewSearchEqualFunc $search_equal_func, Pointer $search_user_data, GDestroyNotify $search_destroy )
  is native(&gtk-lib)
  { * }
}}
#-------------------------------------------------------------------------------
#TM:0:gtk_tree_view_get_search_entry:
=begin pod
=head2 [[gtk_] tree_view_] get_search_entry

Returns the B<Gnome::Gtk3::Entry> which is currently in use as interactive search
entry for I<tree_view>.  In case the built-in entry is being used, C<Any>
will be returned.

Returns: (transfer none): the entry currently in use as search entry.


  method gtk_tree_view_get_search_entry ( --> N-GObject  )


=end pod

sub gtk_tree_view_get_search_entry ( N-GObject $tree_view --> N-GObject )
  is native(&gtk-lib)
  { * }

#-------------------------------------------------------------------------------
#TM:0:gtk_tree_view_set_search_entry:
=begin pod
=head2 [[gtk_] tree_view_] set_search_entry

Sets the entry which the interactive search code will use for this
I<tree_view>.  This is useful when you want to provide a search entry
in our interface at all time at a fixed position.  Passing C<Any> for
I<entry> will make the interactive search code use the built-in popup
entry again.


  method gtk_tree_view_set_search_entry ( N-GObject $entry )

=item N-GObject $entry; (allow-none): the entry the interactive search code of I<tree_view> should use or C<Any>

=end pod

sub gtk_tree_view_set_search_entry ( N-GObject $tree_view, N-GObject $entry )
  is native(&gtk-lib)
  { * }
#`{{
#-------------------------------------------------------------------------------
#TM:0:gtk_tree_view_get_search_position_func:
=begin pod
=head2 [[gtk_] tree_view_] get_search_position_func

Returns the positioning function currently in use.

Returns: the currently used function for positioning the search dialog.


  method gtk_tree_view_get_search_position_func ( --> GtkTreeViewSearchPositionFunc  )


=end pod

sub gtk_tree_view_get_search_position_func ( N-GObject $tree_view --> GtkTreeViewSearchPositionFunc )
  is native(&gtk-lib)
  { * }
}}
#`{{
#-------------------------------------------------------------------------------
#TM:0:gtk_tree_view_set_search_position_func:
=begin pod
=head2 [[gtk_] tree_view_] set_search_position_func

Sets the function to use when positioning the search dialog.


  method gtk_tree_view_set_search_position_func ( GtkTreeViewSearchPositionFunc $func, Pointer $data, GDestroyNotify $destroy )

=item GtkTreeViewSearchPositionFunc $func; (allow-none): the function to use to position the search dialog, or C<Any> to use the default search position function
=item Pointer $data; (allow-none): user data to pass to I<func>, or C<Any>
=item GDestroyNotify $destroy; (allow-none): Destroy notifier for I<data>, or C<Any>

=end pod

sub gtk_tree_view_set_search_position_func ( N-GObject $tree_view, GtkTreeViewSearchPositionFunc $func, Pointer $data, GDestroyNotify $destroy )
  is native(&gtk-lib)
  { * }
}}

#-------------------------------------------------------------------------------
#TM:0:gtk_tree_view_convert_widget_to_tree_coords:
=begin pod
=head2 [[gtk_] tree_view_] convert_widget_to_tree_coords

Converts widget coordinates to coordinates for the
tree (the full scrollable area of the tree).


  method gtk_tree_view_convert_widget_to_tree_coords ( Int $wx, Int $wy, Int $tx, Int $ty )

=item Int $wx; X coordinate relative to the widget
=item Int $wy; Y coordinate relative to the widget
=item Int $tx; (out): return location for tree X coordinate
=item Int $ty; (out): return location for tree Y coordinate

=end pod

sub gtk_tree_view_convert_widget_to_tree_coords ( N-GObject $tree_view, int32 $wx, int32 $wy, int32 $tx, int32 $ty )
  is native(&gtk-lib)
  { * }

#-------------------------------------------------------------------------------
#TM:0:gtk_tree_view_convert_tree_to_widget_coords:
=begin pod
=head2 [[gtk_] tree_view_] convert_tree_to_widget_coords

Converts tree coordinates (coordinates in full scrollable area of the tree)
to widget coordinates.


  method gtk_tree_view_convert_tree_to_widget_coords ( Int $tx, Int $ty, Int $wx, Int $wy )

=item Int $tx; X coordinate relative to the tree
=item Int $ty; Y coordinate relative to the tree
=item Int $wx; (out): return location for widget X coordinate
=item Int $wy; (out): return location for widget Y coordinate

=end pod

sub gtk_tree_view_convert_tree_to_widget_coords ( N-GObject $tree_view, int32 $tx, int32 $ty, int32 $wx, int32 $wy )
  is native(&gtk-lib)
  { * }

#-------------------------------------------------------------------------------
#TM:2:gtk_tree_view_convert_widget_to_bin_window_coords:ex-liststore-3.raku
=begin pod
=head2 [[gtk_] tree_view_] convert_widget_to_bin_window_coords

Converts widget coordinates to coordinates for the bin_window (see C<gtk_tree_view_get_bin_window()>).

  method gtk_tree_view_convert_widget_to_bin_window_coords (
    Int $wx, Int $wy
    --> List
  )

=item Int $wx; X coordinate relative to the widget
=item Int $wy; Y coordinate relative to the widget

The returned List holds;
=item Int $bx; bin_window X coordinate
=item Int $by; bin_window Y coordinate

=end pod

sub gtk_tree_view_convert_widget_to_bin_window_coords (
  N-GObject $tree_view, int32 $wx, int32 $wy --> List
) {
  _gtk_tree_view_convert_widget_to_bin_window_coords(
    $tree_view, $wx, $wy, my int32 $bx, my int32 $by
  );

  ( $bx, $by)
}

sub _gtk_tree_view_convert_widget_to_bin_window_coords (
  N-GObject $tree_view, int32 $wx, int32 $wy, int32 $bx is rw, int32 $by is rw
) is native(&gtk-lib)
  is symbol('gtk_tree_view_convert_widget_to_bin_window_coords')
  { * }

#-------------------------------------------------------------------------------
#TM:0:gtk_tree_view_convert_bin_window_to_widget_coords:
=begin pod
=head2 [[gtk_] tree_view_] convert_bin_window_to_widget_coords

Converts bin_window coordinates (see C<gtk_tree_view_get_bin_window()>)
to widget relative coordinates.


  method gtk_tree_view_convert_bin_window_to_widget_coords ( Int $bx, Int $by, Int $wx, Int $wy )

=item Int $bx; bin_window X coordinate
=item Int $by; bin_window Y coordinate
=item Int $wx; (out): return location for widget X coordinate
=item Int $wy; (out): return location for widget Y coordinate

=end pod

sub gtk_tree_view_convert_bin_window_to_widget_coords ( N-GObject $tree_view, int32 $bx, int32 $by, int32 $wx, int32 $wy )
  is native(&gtk-lib)
  { * }

#-------------------------------------------------------------------------------
#TM:0:gtk_tree_view_convert_tree_to_bin_window_coords:
=begin pod
=head2 [[gtk_] tree_view_] convert_tree_to_bin_window_coords

Converts tree coordinates (coordinates in full scrollable area of the tree)
to bin_window coordinates.


  method gtk_tree_view_convert_tree_to_bin_window_coords ( Int $tx, Int $ty, Int $bx, Int $by )

=item Int $tx; tree X coordinate
=item Int $ty; tree Y coordinate
=item Int $bx; (out): return location for X coordinate relative to bin_window
=item Int $by; (out): return location for Y coordinate relative to bin_window

=end pod

sub gtk_tree_view_convert_tree_to_bin_window_coords ( N-GObject $tree_view, int32 $tx, int32 $ty, int32 $bx, int32 $by )
  is native(&gtk-lib)
  { * }

#-------------------------------------------------------------------------------
#TM:0:gtk_tree_view_convert_bin_window_to_tree_coords:
=begin pod
=head2 [[gtk_] tree_view_] convert_bin_window_to_tree_coords

Converts bin_window coordinates to coordinates for the
tree (the full scrollable area of the tree).


  method gtk_tree_view_convert_bin_window_to_tree_coords ( Int $bx, Int $by, Int $tx, Int $ty )

=item Int $bx; X coordinate relative to bin_window
=item Int $by; Y coordinate relative to bin_window
=item Int $tx; (out): return location for tree X coordinate
=item Int $ty; (out): return location for tree Y coordinate

=end pod

sub gtk_tree_view_convert_bin_window_to_tree_coords ( N-GObject $tree_view, int32 $bx, int32 $by, int32 $tx, int32 $ty )
  is native(&gtk-lib)
  { * }

#-------------------------------------------------------------------------------
#TM:0:gtk_tree_view_set_fixed_height_mode:
=begin pod
=head2 [[gtk_] tree_view_] set_fixed_height