### ----------------------------------------------------
### -- Gnome::Gtk3
### -- Licenses: Artistic-2.0
### -- Authors: Marcel Timmerman
### -- File: lib/Gnome/Gtk3/TreeView.rakumod
### ----------------------------------------------------
### -- Chunk 3 of 3
_mode

Enables or disables the fixed height mode of I<tree_view>.
Fixed height mode speeds up B<Gnome::Gtk3::TreeView> by assuming that all
rows have the same height.
Only enable this option if all rows are the same height and all
columns are of type C<GTK_TREE_VIEW_COLUMN_FIXED>.


  method gtk_tree_view_set_fixed_height_mode ( Int $enable )

=item Int $enable; C<1> to enable fixed height mode

=end pod

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

#-------------------------------------------------------------------------------
#TM:0:gtk_tree_view_get_fixed_height_mode:
=begin pod
=head2 [[gtk_] tree_view_] get_fixed_height_mode

Returns whether fixed height mode is turned on for I<tree_view>.

Returns: C<1> if I<tree_view> is in fixed height mode


  method gtk_tree_view_get_fixed_height_mode ( --> Int  )


=end pod

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

#-------------------------------------------------------------------------------
#TM:0:gtk_tree_view_set_hover_selection:
=begin pod
=head2 [[gtk_] tree_view_] set_hover_selection

Enables or disables the hover selection mode of I<tree_view>.
Hover selection makes the selected row follow the pointer.
Currently, this works only for the selection modes
C<GTK_SELECTION_SINGLE> and C<GTK_SELECTION_BROWSE>.


  method gtk_tree_view_set_hover_selection ( Int $hover )

=item Int $hover; C<1> to enable hover selection mode

=end pod

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

#-------------------------------------------------------------------------------
#TM:0:gtk_tree_view_get_hover_selection:
=begin pod
=head2 [[gtk_] tree_view_] get_hover_selection

Returns whether hover selection mode is turned on for I<tree_view>.

Returns: C<1> if I<tree_view> is in hover selection mode


  method gtk_tree_view_get_hover_selection ( --> Int  )


=end pod

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

#-------------------------------------------------------------------------------
#TM:0:gtk_tree_view_set_hover_expand:
=begin pod
=head2 [[gtk_] tree_view_] set_hover_expand

Enables or disables the hover expansion mode of I<tree_view>.
Hover expansion makes rows expand or collapse if the pointer
moves over them.


  method gtk_tree_view_set_hover_expand ( Int $expand )

=item Int $expand; C<1> to enable hover selection mode

=end pod

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

#-------------------------------------------------------------------------------
#TM:0:gtk_tree_view_get_hover_expand:
=begin pod
=head2 [[gtk_] tree_view_] get_hover_expand

Returns whether hover expansion mode is turned on for I<tree_view>.

Returns: C<1> if I<tree_view> is in hover expansion mode


  method gtk_tree_view_get_hover_expand ( --> Int  )


=end pod

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

#-------------------------------------------------------------------------------
#TM:0:gtk_tree_view_set_rubber_banding:
=begin pod
=head2 [[gtk_] tree_view_] set_rubber_banding

Enables or disables rubber banding in I<tree_view>.  If the selection mode
is B<GTK_SELECTION_MULTIPLE>, rubber banding will allow the user to select
multiple rows by dragging the mouse.


  method gtk_tree_view_set_rubber_banding ( Int $enable )

=item Int $enable; C<1> to enable rubber banding

=end pod

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

#-------------------------------------------------------------------------------
#TM:0:gtk_tree_view_get_rubber_banding:
=begin pod
=head2 [[gtk_] tree_view_] get_rubber_banding

Returns whether rubber banding is turned on for I<tree_view>.  If the
selection mode is B<GTK_SELECTION_MULTIPLE>, rubber banding will allow the
user to select multiple rows by dragging the mouse.

Returns: C<1> if rubber banding in I<tree_view> is enabled.


  method gtk_tree_view_get_rubber_banding ( --> Int  )


=end pod

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

#-------------------------------------------------------------------------------
#TM:0:gtk_tree_view_is_rubber_banding_active:
=begin pod
=head2 [[gtk_] tree_view_] is_rubber_banding_active

Returns whether a rubber banding operation is currently being done
in I<tree_view>.

Returns: C<1> if a rubber banding operation is currently being
done in I<tree_view>.


  method gtk_tree_view_is_rubber_banding_active ( --> Int  )


=end pod

sub gtk_tree_view_is_rubber_banding_active ( N-GObject $tree_view --> int32 )
  is native(&gtk-lib)
  { * }
#`{{
#-------------------------------------------------------------------------------
#TM:0:gtk_tree_view_get_row_separator_func:
=begin pod
=head2 [[gtk_] tree_view_] get_row_separator_func

Returns the current row separator function.

Returns: the current row separator function.


  method gtk_tree_view_get_row_separator_func ( --> GtkTreeViewRowSeparatorFunc  )


=end pod

sub gtk_tree_view_get_row_separator_func ( N-GObject $tree_view --> GtkTreeViewRowSeparatorFunc )
  is native(&gtk-lib)
  { * }
}}
#`{{
#-------------------------------------------------------------------------------
#TM:0:gtk_tree_view_set_row_separator_func:
=begin pod
=head2 [[gtk_] tree_view_] set_row_separator_func

Sets the row separator function, which is used to determine
whether a row should be drawn as a separator. If the row separator
function is C<Any>, no separators are drawn. This is the default value.


  method gtk_tree_view_set_row_separator_func ( GtkTreeViewRowSeparatorFunc $func, Pointer $data, GDestroyNotify $destroy )

=item GtkTreeViewRowSeparatorFunc $func; (allow-none): a B<Gnome::Gtk3::TreeViewRowSeparatorFunc>
=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_row_separator_func ( N-GObject $tree_view, GtkTreeViewRowSeparatorFunc $func, Pointer $data, GDestroyNotify $destroy )
  is native(&gtk-lib)
  { * }
}}
#`{{
#-------------------------------------------------------------------------------
#TM:0:gtk_tree_view_get_grid_lines:
=begin pod
=head2 [[gtk_] tree_view_] get_grid_lines

Returns which grid lines are enabled in I<tree_view>.

Returns: a B<Gnome::Gtk3::TreeViewGridLines> value indicating which grid lines
are enabled.


  method gtk_tree_view_get_grid_lines ( --> GtkTreeViewGridLines  )


=end pod

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

#-------------------------------------------------------------------------------
#TM:0:gtk_tree_view_set_grid_lines:
=begin pod
=head2 [[gtk_] tree_view_] set_grid_lines

Sets which grid lines to draw in I<tree_view>.


  method gtk_tree_view_set_grid_lines ( GtkTreeViewGridLines $grid_lines )

=item GtkTreeViewGridLines $grid_lines; a B<Gnome::Gtk3::TreeViewGridLines> value indicating which grid lines to enable.

=end pod

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

#-------------------------------------------------------------------------------
#TM:0:gtk_tree_view_get_enable_tree_lines:
=begin pod
=head2 [[gtk_] tree_view_] get_enable_tree_lines

Returns whether or not tree lines are drawn in I<tree_view>.

Returns: C<1> if tree lines are drawn in I<tree_view>, C<0>
otherwise.


  method gtk_tree_view_get_enable_tree_lines ( --> Int  )


=end pod

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

#-------------------------------------------------------------------------------
#TM:0:gtk_tree_view_set_enable_tree_lines:
=begin pod
=head2 [[gtk_] tree_view_] set_enable_tree_lines

Sets whether to draw lines interconnecting the expanders in I<tree_view>.
This does not have any visible effects for lists.


  method gtk_tree_view_set_enable_tree_lines ( Int $enabled )

=item Int $enabled; C<1> to enable tree line drawing, C<0> otherwise.

=end pod

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

#-------------------------------------------------------------------------------
#TM:0:gtk_tree_view_set_show_expanders:
=begin pod
=head2 [[gtk_] tree_view_] set_show_expanders

Sets whether to draw and enable expanders and indent child rows in
I<tree_view>.  When disabled there will be no expanders visible in trees
and there will be no way to expand and collapse rows by default.  Also
note that hiding the expanders will disable the default indentation.  You
can set a custom indentation in this case using
C<gtk_tree_view_set_level_indentation()>.
This does not have any visible effects for lists.


  method gtk_tree_view_set_show_expanders ( Int $enabled )

=item Int $enabled; C<1> to enable expander drawing, C<0> otherwise.

=end pod

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

#-------------------------------------------------------------------------------
#TM:0:gtk_tree_view_get_show_expanders:
=begin pod
=head2 [[gtk_] tree_view_] get_show_expanders

Returns whether or not expanders are drawn in I<tree_view>.

Returns: C<1> if expanders are drawn in I<tree_view>, C<0>
otherwise.


  method gtk_tree_view_get_show_expanders ( --> Int  )


=end pod

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

#-------------------------------------------------------------------------------
#TM:0:gtk_tree_view_set_level_indentation:
=begin pod
=head2 [[gtk_] tree_view_] set_level_indentation

Sets the amount of extra indentation for child levels to use in I<tree_view>
in addition to the default indentation.  The value should be specified in
pixels, a value of 0 disables this feature and in this case only the default
indentation will be used.
This does not have any visible effects for lists.


  method gtk_tree_view_set_level_indentation ( Int $indentation )

=item Int $indentation; the amount, in pixels, of extra indentation in I<tree_view>.

=end pod

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

#-------------------------------------------------------------------------------
#TM:0:gtk_tree_view_get_level_indentation:
=begin pod
=head2 [[gtk_] tree_view_] get_level_indentation

Returns the amount, in pixels, of extra indentation for child levels
in I<tree_view>.

Returns: the amount of extra indentation for child levels in
I<tree_view>.  A return value of 0 means that this feature is disabled.


  method gtk_tree_view_get_level_indentation ( --> Int  )


=end pod

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

#-------------------------------------------------------------------------------
#TM:0:gtk_tree_view_set_tooltip_row:
=begin pod
=head2 [[gtk_] tree_view_] set_tooltip_row

Sets the tip area of I<tooltip> to be the area covered by the row at I<path>. See also C<gtk_tree_view_set_tooltip_column()> for a simpler alternative. See also C<gtk_tooltip_set_tip_area()>.

  method gtk_tree_view_set_tooltip_row ( N-GObject $tooltip, N-GtkTreePath $path )

=item N-GObject $tooltip; a B<Gnome::Gtk3::Tooltip>
=item N-GtkTreePath $path; a B<Gnome::Gtk3::TreePath>

=end pod

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

#-------------------------------------------------------------------------------
#TM:2:gtk_tree_view_set_tooltip_cell:xt/ex-liststore-3.raku
=begin pod
=head2 [[gtk_] tree_view_] set_tooltip_cell

Sets the tip area of I<$tooltip> to the area I<$path>, I<$column> and I<$cell> have in common.  For example if I<$path> is undefined and I<$column> is set, the tip area will be set to the full area covered by I<$column>.  See also C<gtk_tooltip_set_tip_area()>.

Note that if I<$path> is not specified and I<$cell> is set and part of a column containing the expander, the tooltip might not show and hide at the correct position.  In such cases I<path> must be set to the current node under the mouse cursor for this function to operate correctly.

See also C<gtk_tree_view_set_tooltip_column()> for a simpler alternative.

  method gtk_tree_view_set_tooltip_cell (
    N-GObject $tooltip, N-GtkTreePath $path,
    N-GObject $column, N-GObject $cell
  )

=item N-GObject $tooltip; a B<Gnome::Gtk3::Tooltip>
=item N-GtkTreePath $path; a B<Gnome::Gtk3::TreePath> or C<Any>
=item N-GObject $column; a B<Gnome::Gtk3::TreeViewColumn> or C<Any>
=item N-GObject $cell; a B<Gnome::Gtk3::CellRenderer> or C<Any>

=end pod

sub gtk_tree_view_set_tooltip_cell (
  N-GObject $tree_view, N-GObject $tooltip, N-GtkTreePath $path,
  N-GObject $column, N-GObject $cell
) is native(&gtk-lib)
  { * }

#`{{
#-------------------------------------------------------------------------------
#TM:0:gtk_tree_view_get_tooltip_context:
=begin pod
=head2 [[gtk_] tree_view_] get_tooltip_context

This function is supposed to be used in a  I<query-tooltip>
signal handler for B<Gnome::Gtk3::TreeView>.  The I<x>, I<y> and I<keyboard_tip> values
which are received in the signal handler, should be passed to this
function without modification.

The return value indicates whether there is a tree view row at the given
coordinates (C<1>) or not (C<0>) for mouse tooltips.  For keyboard
tooltips the row returned will be the cursor row.  When C<1>, then any of
I<model>, I<path> and I<iter> which have been provided will be set to point to
that row and the corresponding model.  I<x> and I<y> will always be converted
to be relative to I<tree_view>’s bin_window if I<keyboard_tooltip> is C<0>.

Returns: whether or not the given tooltip context points to a row.


  method gtk_tree_view_get_tooltip_context ( Int $x, Int $y, Int $keyboard_tip, N-GObject $model, N-GtkTreePath $path, GtkTreeIter $iter --> Int  )

=item Int $x; (inout): the x coordinate (relative to widget coordinates)
=item Int $y; (inout): the y coordinate (relative to widget coordinates)
=item Int $keyboard_tip; whether this is a keyboard tooltip or not
=item N-GObject $model; (out) (optional) (nullable) (transfer none): a pointer to receive a B<Gnome::Gtk3::TreeModel> or C<Any>
=item N-GtkTreePath $path; (out) (optional): a pointer to receive a B<Gnome::Gtk3::TreePath> or C<Any>
=item GtkTreeIter $iter; (out) (optional): a pointer to receive a B<Gnome::Gtk3::TreeIter> or C<Any>

=end pod

sub gtk_tree_view_get_tooltip_context ( N-GObject $tree_view, int32 $x, int32 $y, int32 $keyboard_tip, N-GObject $model, N-GtkTreePath $path, GtkTreeIter $iter --> int32 )
  is native(&gtk-lib)
  { * }
}}

#-------------------------------------------------------------------------------
#TM:0:gtk_tree_view_set_tooltip_column:
=begin pod
=head2 [[gtk_] tree_view_] set_tooltip_column

If you only plan to have simple (text-only) tooltips on full rows, you
can use this function to have B<Gnome::Gtk3::TreeView> handle these automatically
for you. I<column> should be set to the column in I<tree_view>’s model
containing the tooltip texts, or -1 to disable this feature.

When enabled,  I<has-tooltip> will be set to C<1> and
I<tree_view> will connect a  I<query-tooltip> signal handler.

Note that the signal handler sets the text with C<gtk_tooltip_set_markup()>,
so &, <, etc have to be escaped in the text.


  method gtk_tree_view_set_tooltip_column ( Int $column )

=item Int $column; an integer, which is a valid column number for I<tree_view>’s model

=end pod

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

#-------------------------------------------------------------------------------
#TM:0:gtk_tree_view_get_tooltip_column:
=begin pod
=head2 [[gtk_] tree_view_] get_tooltip_column

Returns the column of I<tree_view>’s model which is being used for
displaying tooltips on I<tree_view>’s rows.

Returns: the index of the tooltip column that is currently being
used, or -1 if this is disabled.

  method gtk_tree_view_get_tooltip_column ( --> Int  )

=end pod

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

#-------------------------------------------------------------------------------
=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<g_signal_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 ( N-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, N-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<g_signal_connect_object()> are using the signatures of the handler routines to setup the native call interface.

=head2 Supported signals


=comment #TS:0:row-activated:
=head3 row-activated

The "row-activated" signal is emitted when the method C<gtk_tree_view_row_activated()> is called, when the user double clicks a treeview row with the "activate-on-single-click" property set to C<0>, or when the user single clicks a row when the "activate-on-single-click" property set to C<1>. It is also emitted when a non-editable row is selected and one of the keys: Space, Shift+Space, Return or Enter is pressed.

For selection handling refer to the [tree widget conceptual overview][TreeWidget] as well as B<Gnome::Gtk3::TreeSelection>.

  method handler (
    N-GtkTreePath $path,
    N-GObject $column,
    Int :$_handler_id,
    Gnome::GObject::Object :_widget($tree_view),
    *%user-options
  );

=item $tree_view; the object on which the signal is emitted
=item $path; the native B<Gnome::Gtk3::TreePath> for the activated row
=item $column; the native B<Gnome::Gtk3::TreeViewColumn> in which the activation occurred


=comment #TS:0:test-expand-row:
=head3 test-expand-row

The given row is about to be expanded (show its children nodes). Use this
signal if you need to control the expandability of individual rows.

Returns: C<0> to allow expansion, C<1> to reject

  method handler (
    N-GtkTreeIter $iter,
    N-GtkTreePath $path,
    Int :$_handler_id,
    Gnome::GObject::Object :_widget($tree_view),
    *%user-options
    --> Int
  );

=item $tree_view; the object on which the signal is emitted
=item N-GtkTreeIter $iter; the native B<Gnome::Gtk3::TreeIter> of the row to expand
=item N-GtkTreePath $path; the native B<Gnome::Gtk3::TreePath> that points to the row

=comment #TS:0:test-collapse-row:
=head3 test-collapse-row

The given row is about to be collapsed (hide its children nodes). Use this
signal if you need to control the collapsibility of individual rows.

Returns: C<0> to allow collapsing, C<1> to reject

  method handler (
    N-GtkTreeIter $iter,
    N-GtkTreePath $path,
    Int :$_handler_id,
    Gnome::GObject::Object :_widget($tree_view),
    *%user-options
    --> Int
  );

=item $tree_view; the object on which the signal is emitted
=item $iter; the tree iter of the row to collapse
=item $path; a tree path that points to the row


=comment #TS:0:row-expanded:
=head3 row-expanded

The given row has been expanded (child nodes are shown).

  method handler (
    N-GtkTreeIter $iter,
    N-GtkTreePath $path,
    Int :$_handler_id,
    Gnome::GObject::Object :_widget($tree_view),
    *%user-options
  );

=item $tree_view; the object on which the signal is emitted
=item $iter; the tree iter of the expanded row
=item $path; a tree path that points to the row


=comment #TS:0:row-collapsed:
=head3 row-collapsed

The given row has been collapsed (child nodes are hidden).

  method handler (
    N-GtkTreeIter $iter,
    N-GtkTreePath $path,
    Int :$_handler_id,
    Gnome::GObject::Object :_widget($tree_view),
    *%user-options
  );

=item $tree_view; the object on which the signal is emitted
=item $iter; the tree iter of the collapsed row
=item $path; a tree path that points to the row


=comment #TS:0:columns-changed:
=head3 columns-changed

The number of columns of the treeview has changed.

  method handler (
    Int :$_handler_id,
    Gnome::GObject::Object :_widget($tree_view),
    *%user-options
  );

=item $tree_view; the object on which the signal is emitted


=comment #TS:0:cursor-changed:
=head3 cursor-changed

The position of the cursor (focused cell) has changed.

  method handler (
    Int :$_handler_id,
    Gnome::GObject::Object :_widget($tree_view),
    *%user-options
  );

=item $tree_view; the object on which the signal is emitted

=begin comment
=comment #TS:0:move-cursor:
=head3 move-cursor

The  I<move-cursor> signal is a [keybinding
signal][B<Gnome::Gtk3::BindingSignal>] which gets emitted when the user
presses one of the cursor keys.

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. In contrast to C<gtk_tree_view_set_cursor()> and
C<gtk_tree_view_set_cursor_on_cell()> when moving horizontally
 I<move-cursor> does not reset the current selection.

Returns: C<1> if I<step> is supported, C<0> otherwise.

  method handler (
    Unknown type GTK_TYPE_MOVEMENT_STEP $step,
    Int $direction,
    Int :$_handler_id,
    Gnome::GObject::Object :_widget($tree_view),
    *%user-options
    --> Int
  );

=item $tree_view; the object on which the signal is emitted.

=item $step; the granularity of the move, as a

=item $direction; the direction to move: +1 to move forwards;
=end comment

=begin comment
=comment #TS:0:select-all:
=head3 select-all

  method handler (
    Int :$_handler_id,
    Gnome::GObject::Object :_widget($treeview),
    *%user-options
    --> Int
  );

=item $treeview;

=comment #TS:0:unselect-all:
=head3 unselect-all

  method handler (
    Int :$_handler_id,
    Gnome::GObject::Object :_widget($treeview),
    *%user-options
    --> Int
  );

=item $treeview;

=comment #TS:0:select-cursor-row:
=head3 select-cursor-row

  method handler (
    Int $int,
    Int :$_handler_id,
    Gnome::GObject::Object :_widget($treeview),
    *%user-options
    --> Int
  );

=item $treeview;
=item $int;

=comment #TS:0:toggle-cursor-row:
=head3 toggle-cursor-row

  method handler (
    Int :$_handler_id,
    Gnome::GObject::Object :_widget($treeview),
    *%user-options
    --> Int
  );

=item $treeview;

=comment #TS:0:expand-collapse-cursor-row:
=head3 expand-collapse-cursor-row

  method handler (
    Int $int,
    Int $int,
    Int $int,
    Int :$_handler_id,
    Gnome::GObject::Object :_widget($treeview),
    *%user-options
    --> Int
  );

=item $treeview;
=item $int;
=item $int;
=item $int;

=comment #TS:0:select-cursor-parent:
=head3 select-cursor-parent

  method handler (
    Int :$_handler_id,
    Gnome::GObject::Object :_widget($treeview),
    *%user-options
    --> Int
  );

=item $treeview;

=comment #TS:0:start-interactive-search:
=head3 start-interactive-search

  method handler (
    Int :$_handler_id,
    Gnome::GObject::Object :_widget($treeview),
    *%user-options
    --> Int
  );

=item $treeview;
=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<gtk_label_set_text('my text label')>.

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

=head2 Supported properties

=comment #TP:0:model:
=head3 TreeView Model

The model for the tree view
Widget type: GTK_TYPE_TREE_MODEL


The B<Gnome::GObject::Value> type of property I<model> is C<G_TYPE_OBJECT>.

=comment #TP:0:headers-visible:
=head3 Headers Visible

Show the column header buttons
Default value: True


The B<Gnome::GObject::Value> type of property I<headers-visible> is C<G_TYPE_BOOLEAN>.

=comment #TP:0:headers-clickable:
=head3 Headers Clickable

Column headers respond to click events
Default value: True


The B<Gnome::GObject::Value> type of property I<headers-clickable> is C<G_TYPE_BOOLEAN>.

=comment #TP:0:expander-column:
=head3 Expander Column

Set the column for the expander column
Widget type: GTK_TYPE_TREE_VIEW_COLUMN


The B<Gnome::GObject::Value> type of property I<expander-column> is C<G_TYPE_OBJECT>.

=comment #TP:0:reorderable:
=head3 Reorderable

View is reorderable
Default value: False


The B<Gnome::GObject::Value> type of property I<reorderable> is C<G_TYPE_BOOLEAN>.

=comment #TP:0:enable-search:
=head3 Enable Search

View allows user to search through columns interactively
Default value: True


The B<Gnome::GObject::Value> type of property I<enable-search> is C<G_TYPE_BOOLEAN>.

=comment #TP:0:search-column:
=head3 Search Column



The B<Gnome::GObject::Value> type of property I<search-column> is C<G_TYPE_INT>.

=comment #TP:0:fixed-height-mode:
=head3 Fixed Height Mode


Setting the I<fixed-height-mode> property to C<1> speeds up
B<Gnome::Gtk3::TreeView> by assuming that all rows have the same height.
Only enable this option if all rows are the same height.
Please see C<gtk_tree_view_set_fixed_height_mode()> for more
information on this option.

The B<Gnome::GObject::Value> type of property I<fixed-height-mode> is C<G_TYPE_BOOLEAN>.

=comment #TP:0:hover-selection:
=head3 Hover Selection


Enables or disables the hover selection mode of I<tree_view>.
Hover selection makes the selected row follow the pointer.
Currently, this works only for the selection modes
C<GTK_SELECTION_SINGLE> and C<GTK_SELECTION_BROWSE>.
This mode is primarily intended for treeviews in popups, e.g.
in B<Gnome::Gtk3::ComboBox> or B<Gnome::Gtk3::EntryCompletion>.

The B<Gnome::GObject::Value> type of property I<hover-selection> is C<G_TYPE_BOOLEAN>.

=comment #TP:0:hover-expand:
=head3 Hover Expand


Enables or disables the hover expansion mode of I<tree_view>.
Hover expansion makes rows expand or collapse if the pointer moves
over them.
This mode is primarily intended for treeviews in popups, e.g.
in B<Gnome::Gtk3::ComboBox> or B<Gnome::Gtk3::EntryCompletion>.

The B<Gnome::GObject::Value> type of property I<hover-expand> is C<G_TYPE_BOOLEAN>.

=comment #TP:0:show-expanders:
=head3 Show Expanders


C<1> if the view has expanders.

The B<Gnome::GObject::Value> type of property I<show-expanders> is C<G_TYPE_BOOLEAN>.

=comment #TP:0:level-indentation:
=head3 Level Indentation


Extra indentation for each level.

The B<Gnome::GObject::Value> type of property I<level-indentation> is C<G_TYPE_INT>.

=comment #TP:0:rubber-banding:
=head3 Rubber Banding

Whether to enable selection of multiple items by dragging the mouse pointer
Default value: False


The B<Gnome::GObject::Value> type of property I<rubber-banding> is C<G_TYPE_BOOLEAN>.

=comment #TP:0:enable-grid-lines:
=head3 Enable Grid Lines

Whether grid lines should be drawn in the tree view
Default value: False


The B<Gnome::GObject::Value> type of property I<enable-grid-lines> is C<G_TYPE_ENUM>.

=comment #TP:0:enable-tree-lines:
=head3 Enable Tree Lines

Whether tree lines should be drawn in the tree view
Default value: False


The B<Gnome::GObject::Value> type of property I<enable-tree-lines> is C<G_TYPE_BOOLEAN>.

=comment #TP:0:tooltip-column:
=head3 Tooltip Column



The B<Gnome::GObject::Value> type of property I<tooltip-column> is C<G_TYPE_INT>.

=comment #TP:0:activate-on-single-click:
=head3 Activate on Single Click

The activate-on-single-click property specifies whether the "row-activated" signal will be emitted after a single click.

The B<Gnome::GObject::Value> type of property I<activate-on-single-click> is C<G_TYPE_BOOLEAN>.
=end pod


