// This file was generated by gir (https://github.com/gtk-rs/gir)
// from gir-files (https://github.com/gtk-rs/gir-files)
// DO NOT EDIT
#![allow(deprecated)]

use crate::{
    Accessible, AccessibleRole, Adjustment, Align, Buildable, CellRenderer, ConstraintTarget,
    Editable, LayoutManager, MovementStep, Overflow, Scrollable, ScrollablePolicy, Tooltip,
    TreeIter, TreeModel, TreePath, TreeSelection, TreeViewColumn, TreeViewDropPosition,
    TreeViewGridLines, Widget,
};
use glib::{
    prelude::*,
    signal::{connect_raw, SignalHandlerId},
    translate::*,
};
use std::{boxed::Box as Box_, fmt, mem, mem::transmute, ptr};

glib::wrapper! {
    /// Use [`ListView`][crate::ListView] for lists, and [`ColumnView`][crate::ColumnView]
    ///   for tabular lists
    /// A widget for displaying both trees and lists
    ///
    /// Widget that displays any object that implements the [`TreeModel`][crate::TreeModel] interface.
    ///
    /// Please refer to the [tree widget conceptual overview](section-tree-widget.html)
    /// for an overview of all the objects and data types related to the tree
    /// widget and how they work together.
    ///
    /// ## Coordinate systems in GtkTreeView API
    ///
    /// Several different coordinate systems are exposed in the [`TreeView`][crate::TreeView] API.
    /// These are:
    ///
    /// ![](tree-view-coordinates.png)
    ///
    /// - Widget coordinates: Coordinates relative to the widget (usually `widget->window`).
    ///
    /// - Bin window coordinates: Coordinates relative to the window that GtkTreeView renders to.
    ///
    /// - Tree coordinates: Coordinates relative to the entire scrollable area of GtkTreeView. These
    ///   coordinates start at (0, 0) for row 0 of the tree.
    ///
    /// Several functions are available for converting between the different
    /// coordinate systems.  The most common translations are between widget and bin
    /// window coordinates and between bin window and tree coordinates. For the
    /// former you can use [`TreeViewExt::convert_widget_to_bin_window_coords()`][crate::prelude::TreeViewExt::convert_widget_to_bin_window_coords()]
    /// (and vice versa), for the latter [`TreeViewExt::convert_bin_window_to_tree_coords()`][crate::prelude::TreeViewExt::convert_bin_window_to_tree_coords()]
    /// (and vice versa).
    ///
    /// ## [`TreeView`][crate::TreeView] as [`Buildable`][crate::Buildable]
    ///
    /// The [`TreeView`][crate::TreeView] implementation of the [`Buildable`][crate::Buildable] interface accepts
    /// [`TreeViewColumn`][crate::TreeViewColumn] objects as `<child>` elements and exposes the
    /// internal [`TreeSelection`][crate::TreeSelection] in UI definitions.
    ///
    /// An example of a UI definition fragment with [`TreeView`][crate::TreeView]:
    ///
    /// ```xml
    /// <object class="GtkTreeView" id="treeview">
    ///   <property name="model">liststore1</property>
    ///   <child>
    ///     <object class="GtkTreeViewColumn" id="test-column">
    ///       <property name="title">Test</property>
    ///       <child>
    ///         <object class="GtkCellRendererText" id="test-renderer"/>
    ///         <attributes>
    ///           <attribute name="text">1</attribute>
    ///         </attributes>
    ///       </child>
    ///     </object>
    ///   </child>
    ///   <child internal-child="selection">
    ///     <object class="GtkTreeSelection" id="selection">
    ///       <signal name="changed" handler="on_treeview_selection_changed"/>
    ///     </object>
    ///   </child>
    /// </object>
    /// ```
    ///
    /// ## CSS nodes
    ///
    /// ```text
    /// treeview.view
    /// ├── header
    /// │   ├── button
    /// │   │   ╰── [sort-indicator]
    /// ┊   ┊
    /// │   ╰── button
    /// │       ╰── [sort-indicator]
    /// │
    /// ├── [rubberband]
    /// ╰── [dndtarget]
    /// ```
    ///
    /// [`TreeView`][crate::TreeView] has a main CSS node with name `treeview` and style class `.view`.
    /// It has a subnode with name `header`, which is the parent for all the column
    /// header widgets' CSS nodes.
    ///
    /// Each column header consists of a `button`, which among other content, has a
    /// child with name `sort-indicator`, which carries the `.ascending` or `.descending`
    /// style classes when the column header should show a sort indicator. The CSS
    /// is expected to provide a suitable image using the `-gtk-icon-source` property.
    ///
    /// For rubberband selection, a subnode with name `rubberband` is used.
    ///
    /// For the drop target location during DND, a subnode with name `dndtarget` is used.
    ///
    /// ## Properties
    ///
    ///
    /// #### `activate-on-single-click`
    ///  The activate-on-single-click property specifies whether the "row-activated" signal
    /// will be emitted after a single click.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `enable-grid-lines`
    ///  Readable | Writeable
    ///
    ///
    /// #### `enable-search`
    ///  Readable | Writeable
    ///
    ///
    /// #### `enable-tree-lines`
    ///  Readable | Writeable
    ///
    ///
    /// #### `expander-column`
    ///  Readable | Writeable
    ///
    ///
    /// #### `fixed-height-mode`
    ///  Setting the ::fixed-height-mode property to [`true`] speeds up
    /// [`TreeView`][crate::TreeView] by assuming that all rows have the same height.
    /// Only enable this option if all rows are the same height.
    /// Please see gtk_tree_view_set_fixed_height_mode() for more
    /// information on this option.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `headers-clickable`
    ///  Readable | Writeable
    ///
    ///
    /// #### `headers-visible`
    ///  Readable | Writeable
    ///
    ///
    /// #### `hover-expand`
    ///  Enables or disables the hover expansion mode of @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 [`ComboBox`][crate::ComboBox] or [`EntryCompletion`][crate::EntryCompletion].
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `hover-selection`
    ///  Enables or disables the hover selection mode of @tree_view.
    /// Hover selection makes the selected row follow the pointer.
    /// Currently, this works only for the selection modes
    /// [`SelectionMode::Single`][crate::SelectionMode::Single] and [`SelectionMode::Browse`][crate::SelectionMode::Browse].
    ///
    /// This mode is primarily intended for treeviews in popups, e.g.
    /// in [`ComboBox`][crate::ComboBox] or [`EntryCompletion`][crate::EntryCompletion].
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `level-indentation`
    ///  Extra indentation for each level.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `model`
    ///  Readable | Writeable
    ///
    ///
    /// #### `reorderable`
    ///  Readable | Writeable
    ///
    ///
    /// #### `rubber-banding`
    ///  Readable | Writeable
    ///
    ///
    /// #### `search-column`
    ///  Readable | Writeable
    ///
    ///
    /// #### `show-expanders`
    ///  [`true`] if the view has expanders.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `tooltip-column`
    ///  Readable | Writeable
    /// <details><summary><h4>Widget</h4></summary>
    ///
    ///
    /// #### `can-focus`
    ///  Whether the widget or any of its descendents can accept
    /// the input focus.
    ///
    /// This property is meant to be set by widget implementations,
    /// typically in their instance init function.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `can-target`
    ///  Whether the widget can receive pointer events.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `css-classes`
    ///  A list of css classes applied to this widget.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `css-name`
    ///  The name of this widget in the CSS tree.
    ///
    /// This property is meant to be set by widget implementations,
    /// typically in their instance init function.
    ///
    /// Readable | Writeable | Construct Only
    ///
    ///
    /// #### `cursor`
    ///  The cursor used by @widget.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `focus-on-click`
    ///  Whether the widget should grab focus when it is clicked with the mouse.
    ///
    /// This property is only relevant for widgets that can take focus.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `focusable`
    ///  Whether this widget itself will accept the input focus.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `halign`
    ///  How to distribute horizontal space if widget gets extra space.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `has-default`
    ///  Whether the widget is the default widget.
    ///
    /// Readable
    ///
    ///
    /// #### `has-focus`
    ///  Whether the widget has the input focus.
    ///
    /// Readable
    ///
    ///
    /// #### `has-tooltip`
    ///  Enables or disables the emission of the ::query-tooltip signal on @widget.
    ///
    /// A value of [`true`] indicates that @widget can have a tooltip, in this case
    /// the widget will be queried using [`query-tooltip`][struct@crate::Widget#query-tooltip] to
    /// determine whether it will provide a tooltip or not.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `height-request`
    ///  Override for height request of the widget.
    ///
    /// If this is -1, the natural request will be used.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `hexpand`
    ///  Whether to expand horizontally.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `hexpand-set`
    ///  Whether to use the `hexpand` property.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `layout-manager`
    ///  The [`LayoutManager`][crate::LayoutManager] instance to use to compute the preferred size
    /// of the widget, and allocate its children.
    ///
    /// This property is meant to be set by widget implementations,
    /// typically in their instance init function.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `margin-bottom`
    ///  Margin on bottom side of widget.
    ///
    /// This property adds margin outside of the widget's normal size
    /// request, the margin will be added in addition to the size from
    /// [`WidgetExt::set_size_request()`][crate::prelude::WidgetExt::set_size_request()] for example.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `margin-end`
    ///  Margin on end of widget, horizontally.
    ///
    /// This property supports left-to-right and right-to-left text
    /// directions.
    ///
    /// This property adds margin outside of the widget's normal size
    /// request, the margin will be added in addition to the size from
    /// [`WidgetExt::set_size_request()`][crate::prelude::WidgetExt::set_size_request()] for example.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `margin-start`
    ///  Margin on start of widget, horizontally.
    ///
    /// This property supports left-to-right and right-to-left text
    /// directions.
    ///
    /// This property adds margin outside of the widget's normal size
    /// request, the margin will be added in addition to the size from
    /// [`WidgetExt::set_size_request()`][crate::prelude::WidgetExt::set_size_request()] for example.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `margin-top`
    ///  Margin on top side of widget.
    ///
    /// This property adds margin outside of the widget's normal size
    /// request, the margin will be added in addition to the size from
    /// [`WidgetExt::set_size_request()`][crate::prelude::WidgetExt::set_size_request()] for example.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `name`
    ///  The name of the widget.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `opacity`
    ///  The requested opacity of the widget.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `overflow`
    ///  How content outside the widget's content area is treated.
    ///
    /// This property is meant to be set by widget implementations,
    /// typically in their instance init function.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `parent`
    ///  The parent widget of this widget.
    ///
    /// Readable
    ///
    ///
    /// #### `receives-default`
    ///  Whether the widget will receive the default action when it is focused.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `root`
    ///  The [`Root`][crate::Root] widget of the widget tree containing this widget.
    ///
    /// This will be [`None`] if the widget is not contained in a root widget.
    ///
    /// Readable
    ///
    ///
    /// #### `scale-factor`
    ///  The scale factor of the widget.
    ///
    /// Readable
    ///
    ///
    /// #### `sensitive`
    ///  Whether the widget responds to input.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `tooltip-markup`
    ///  Sets the text of tooltip to be the given string, which is marked up
    /// with Pango markup.
    ///
    /// Also see [`Tooltip::set_markup()`][crate::Tooltip::set_markup()].
    ///
    /// This is a convenience property which will take care of getting the
    /// tooltip shown if the given string is not [`None`]:
    /// [`has-tooltip`][struct@crate::Widget#has-tooltip] will automatically be set to [`true`]
    /// and there will be taken care of [`query-tooltip`][struct@crate::Widget#query-tooltip] in
    /// the default signal handler.
    ///
    /// Note that if both [`tooltip-text`][struct@crate::Widget#tooltip-text] and
    /// [`tooltip-markup`][struct@crate::Widget#tooltip-markup] are set, the last one wins.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `tooltip-text`
    ///  Sets the text of tooltip to be the given string.
    ///
    /// Also see [`Tooltip::set_text()`][crate::Tooltip::set_text()].
    ///
    /// This is a convenience property which will take care of getting the
    /// tooltip shown if the given string is not [`None`]:
    /// [`has-tooltip`][struct@crate::Widget#has-tooltip] will automatically be set to [`true`]
    /// and there will be taken care of [`query-tooltip`][struct@crate::Widget#query-tooltip] in
    /// the default signal handler.
    ///
    /// Note that if both [`tooltip-text`][struct@crate::Widget#tooltip-text] and
    /// [`tooltip-markup`][struct@crate::Widget#tooltip-markup] are set, the last one wins.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `valign`
    ///  How to distribute vertical space if widget gets extra space.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `vexpand`
    ///  Whether to expand vertically.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `vexpand-set`
    ///  Whether to use the `vexpand` property.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `visible`
    ///  Whether the widget is visible.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `width-request`
    ///  Override for width request of the widget.
    ///
    /// If this is -1, the natural request will be used.
    ///
    /// Readable | Writeable
    /// </details>
    /// <details><summary><h4>Accessible</h4></summary>
    ///
    ///
    /// #### `accessible-role`
    ///  The accessible role of the given [`Accessible`][crate::Accessible] implementation.
    ///
    /// The accessible role cannot be changed once set.
    ///
    /// Readable | Writeable
    /// </details>
    /// <details><summary><h4>Scrollable</h4></summary>
    ///
    ///
    /// #### `hadjustment`
    ///  Horizontal [`Adjustment`][crate::Adjustment] of the scrollable widget.
    ///
    /// This adjustment is shared between the scrollable widget and its parent.
    ///
    /// Readable | Writeable | Construct
    ///
    ///
    /// #### `hscroll-policy`
    ///  Determines when horizontal scrolling should start.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `vadjustment`
    ///  Vertical [`Adjustment`][crate::Adjustment] of the scrollable widget.
    ///
    /// This adjustment is shared between the scrollable widget and its parent.
    ///
    /// Readable | Writeable | Construct
    ///
    ///
    /// #### `vscroll-policy`
    ///  Determines when vertical scrolling should start.
    ///
    /// Readable | Writeable
    /// </details>
    ///
    /// ## Signals
    ///
    ///
    /// #### `columns-changed`
    ///  The number of columns of the treeview has changed.
    ///
    ///
    ///
    ///
    /// #### `cursor-changed`
    ///  The position of the cursor (focused cell) has changed.
    ///
    ///
    ///
    ///
    /// #### `expand-collapse-cursor-row`
    ///  Action
    ///
    ///
    /// #### `move-cursor`
    ///  The [`TreeView`][crate::TreeView]::move-cursor signal is a [keybinding
    /// signal][`SignalAction`][crate::SignalAction] which gets emitted when the user
    /// presses one of the cursor keys.
    ///
    /// Applications should not connect to it, but may emit it with
    /// g_signal_emit_by_name() if they need to control the cursor
    /// programmatically. In contrast to gtk_tree_view_set_cursor() and
    /// gtk_tree_view_set_cursor_on_cell() when moving horizontally
    /// [`TreeView`][crate::TreeView]::move-cursor does not reset the current selection.
    ///
    /// Action
    ///
    ///
    /// #### `row-activated`
    ///  The "row-activated" signal is emitted when the method
    /// [`TreeViewExt::row_activated()`][crate::prelude::TreeViewExt::row_activated()] is called.
    ///
    /// This signal is emitted when the user double-clicks a treeview row with the
    /// [`activate-on-single-click`][struct@crate::TreeView#activate-on-single-click] property set to [`false`],
    /// or when the user single-clicks a row when that property set to [`true`].
    ///
    /// This signal is also emitted when a non-editable row is selected and one
    /// of the keys: <kbd>Space</kbd>, <kbd>Shift</kbd>+<kbd>Space</kbd>,
    /// <kbd>Return</kbd> or <kbd>Enter</kbd> is pressed.
    ///
    /// For selection handling refer to the
    /// [tree widget conceptual overview](section-tree-widget.html)
    /// as well as [`TreeSelection`][crate::TreeSelection].
    ///
    /// Action
    ///
    ///
    /// #### `row-collapsed`
    ///  The given row has been collapsed (child nodes are hidden).
    ///
    ///
    ///
    ///
    /// #### `row-expanded`
    ///  The given row has been expanded (child nodes are shown).
    ///
    ///
    ///
    ///
    /// #### `select-all`
    ///  Action
    ///
    ///
    /// #### `select-cursor-parent`
    ///  Action
    ///
    ///
    /// #### `select-cursor-row`
    ///  Action
    ///
    ///
    /// #### `start-interactive-search`
    ///  Action
    ///
    ///
    /// #### `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.
    ///
    ///
    ///
    ///
    /// #### `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.
    ///
    ///
    ///
    ///
    /// #### `toggle-cursor-row`
    ///  Action
    ///
    ///
    /// #### `unselect-all`
    ///  Action
    /// <details><summary><h4>Widget</h4></summary>
    ///
    ///
    /// #### `destroy`
    ///  Signals that all holders of a reference to the widget should release
    /// the reference that they hold.
    ///
    /// May result in finalization of the widget if all references are released.
    ///
    /// This signal is not suitable for saving widget state.
    ///
    ///
    ///
    ///
    /// #### `direction-changed`
    ///  Emitted when the text direction of a widget changes.
    ///
    ///
    ///
    ///
    /// #### `hide`
    ///  Emitted when @widget is hidden.
    ///
    ///
    ///
    ///
    /// #### `keynav-failed`
    ///  Emitted if keyboard navigation fails.
    ///
    /// See [`WidgetExt::keynav_failed()`][crate::prelude::WidgetExt::keynav_failed()] for details.
    ///
    ///
    ///
    ///
    /// #### `map`
    ///  Emitted when @widget is going to be mapped.
    ///
    /// A widget is mapped when the widget is visible (which is controlled with
    /// [`visible`][struct@crate::Widget#visible]) and all its parents up to the toplevel widget
    /// are also visible.
    ///
    /// The ::map signal can be used to determine whether a widget will be drawn,
    /// for instance it can resume an animation that was stopped during the
    /// emission of [`unmap`][struct@crate::Widget#unmap].
    ///
    ///
    ///
    ///
    /// #### `mnemonic-activate`
    ///  Emitted when a widget is activated via a mnemonic.
    ///
    /// The default handler for this signal activates @widget if @group_cycling
    /// is [`false`], or just makes @widget grab focus if @group_cycling is [`true`].
    ///
    ///
    ///
    ///
    /// #### `move-focus`
    ///  Emitted when the focus is moved.
    ///
    /// The ::move-focus signal is a [keybinding signal](class.SignalAction.html).
    ///
    /// The default bindings for this signal are <kbd>Tab</kbd> to move forward,
    /// and <kbd>Shift</kbd>+<kbd>Tab</kbd> to move backward.
    ///
    /// Action
    ///
    ///
    /// #### `query-tooltip`
    ///  Emitted when the widget’s tooltip is about to be shown.
    ///
    /// This happens when the [`has-tooltip`][struct@crate::Widget#has-tooltip] property
    /// is [`true`] and the hover timeout has expired with the cursor hovering
    /// "above" @widget; or emitted when @widget got focus in keyboard mode.
    ///
    /// Using the given coordinates, the signal handler should determine
    /// whether a tooltip should be shown for @widget. If this is the case
    /// [`true`] should be returned, [`false`] otherwise.  Note that if
    /// @keyboard_mode is [`true`], the values of @x and @y are undefined and
    /// should not be used.
    ///
    /// The signal handler is free to manipulate @tooltip with the therefore
    /// destined function calls.
    ///
    ///
    ///
    ///
    /// #### `realize`
    ///  Emitted when @widget is associated with a [`gdk::Surface`][crate::gdk::Surface].
    ///
    /// This means that [`WidgetExt::realize()`][crate::prelude::WidgetExt::realize()] has been called
    /// or the widget has been mapped (that is, it is going to be drawn).
    ///
    ///
    ///
    ///
    /// #### `show`
    ///  Emitted when @widget is shown.
    ///
    ///
    ///
    ///
    /// #### `state-flags-changed`
    ///  Emitted when the widget state changes.
    ///
    /// See [`WidgetExt::state_flags()`][crate::prelude::WidgetExt::state_flags()].
    ///
    ///
    ///
    ///
    /// #### `unmap`
    ///  Emitted when @widget is going to be unmapped.
    ///
    /// A widget is unmapped when either it or any of its parents up to the
    /// toplevel widget have been set as hidden.
    ///
    /// As ::unmap indicates that a widget will not be shown any longer,
    /// it can be used to, for example, stop an animation on the widget.
    ///
    ///
    ///
    ///
    /// #### `unrealize`
    ///  Emitted when the [`gdk::Surface`][crate::gdk::Surface] associated with @widget is destroyed.
    ///
    /// This means that [`WidgetExt::unrealize()`][crate::prelude::WidgetExt::unrealize()] has been called
    /// or the widget has been unmapped (that is, it is going to be hidden).
    ///
    ///
    /// </details>
    ///
    /// # Implements
    ///
    /// [`TreeViewExt`][trait@crate::prelude::TreeViewExt], [`WidgetExt`][trait@crate::prelude::WidgetExt], [`trait@glib::ObjectExt`], [`AccessibleExt`][trait@crate::prelude::AccessibleExt], [`BuildableExt`][trait@crate::prelude::BuildableExt], [`ConstraintTargetExt`][trait@crate::prelude::ConstraintTargetExt], [`ScrollableExt`][trait@crate::prelude::ScrollableExt], [`TreeViewExtManual`][trait@crate::prelude::TreeViewExtManual], [`WidgetExtManual`][trait@crate::prelude::WidgetExtManual], [`AccessibleExtManual`][trait@crate::prelude::AccessibleExtManual]
    #[doc(alias = "GtkTreeView")]
    pub struct TreeView(Object<ffi::GtkTreeView, ffi::GtkTreeViewClass>) @extends Widget, @implements Accessible, Buildable, ConstraintTarget, Scrollable;

    match fn {
        type_ => || ffi::gtk_tree_view_get_type(),
    }
}

impl TreeView {
    pub const NONE: Option<&'static TreeView> = None;

    /// Creates a new [`TreeView`][crate::TreeView] widget.
    ///
    /// # Deprecated since 4.10
    ///
    /// Use [`ListView`][crate::ListView] or [`ColumnView`][crate::ColumnView] instead
    ///
    /// # Returns
    ///
    /// A newly created [`TreeView`][crate::TreeView] widget.
    #[cfg_attr(feature = "v4_10", deprecated = "Since 4.10")]
    #[allow(deprecated)]
    #[doc(alias = "gtk_tree_view_new")]
    pub fn new() -> TreeView {
        assert_initialized_main_thread!();
        unsafe { Widget::from_glib_none(ffi::gtk_tree_view_new()).unsafe_cast() }
    }

    /// Creates a new [`TreeView`][crate::TreeView] widget with the model initialized to @model.
    ///
    /// # Deprecated since 4.10
    ///
    /// Use [`ListView`][crate::ListView] or [`ColumnView`][crate::ColumnView] instead
    /// ## `model`
    /// the model.
    ///
    /// # Returns
    ///
    /// A newly created [`TreeView`][crate::TreeView] widget.
    #[cfg_attr(feature = "v4_10", deprecated = "Since 4.10")]
    #[allow(deprecated)]
    #[doc(alias = "gtk_tree_view_new_with_model")]
    #[doc(alias = "new_with_model")]
    pub fn with_model(model: &impl IsA<TreeModel>) -> TreeView {
        skip_assert_initialized!();
        unsafe {
            Widget::from_glib_none(ffi::gtk_tree_view_new_with_model(
                model.as_ref().to_glib_none().0,
            ))
            .unsafe_cast()
        }
    }

    // rustdoc-stripper-ignore-next
    /// Creates a new builder-pattern struct instance to construct [`TreeView`] objects.
    ///
    /// This method returns an instance of [`TreeViewBuilder`](crate::builders::TreeViewBuilder) which can be used to create [`TreeView`] objects.
    pub fn builder() -> TreeViewBuilder {
        TreeViewBuilder::new()
    }
}

impl Default for TreeView {
    fn default() -> Self {
        Self::new()
    }
}

// rustdoc-stripper-ignore-next
/// A [builder-pattern] type to construct [`TreeView`] objects.
///
/// [builder-pattern]: https://doc.rust-lang.org/1.0.0/style/ownership/builders.html
#[must_use = "The builder must be built to be used"]
pub struct TreeViewBuilder {
    builder: glib::object::ObjectBuilder<'static, TreeView>,
}

impl TreeViewBuilder {
    fn new() -> Self {
        Self {
            builder: glib::object::Object::builder(),
        }
    }

    /// The activate-on-single-click property specifies whether the "row-activated" signal
    /// will be emitted after a single click.
    pub fn activate_on_single_click(self, activate_on_single_click: bool) -> Self {
        Self {
            builder: self
                .builder
                .property("activate-on-single-click", activate_on_single_click),
        }
    }

    pub fn enable_grid_lines(self, enable_grid_lines: TreeViewGridLines) -> Self {
        Self {
            builder: self
                .builder
                .property("enable-grid-lines", enable_grid_lines),
        }
    }

    pub fn enable_search(self, enable_search: bool) -> Self {
        Self {
            builder: self.builder.property("enable-search", enable_search),
        }
    }

    pub fn enable_tree_lines(self, enable_tree_lines: bool) -> Self {
        Self {
            builder: self
                .builder
                .property("enable-tree-lines", enable_tree_lines),
        }
    }

    pub fn expander_column(self, expander_column: &TreeViewColumn) -> Self {
        Self {
            builder: self
                .builder
                .property("expander-column", expander_column.clone()),
        }
    }

    /// Setting the ::fixed-height-mode property to [`true`] speeds up
    /// [`TreeView`][crate::TreeView] by assuming that all rows have the same height.
    /// Only enable this option if all rows are the same height.
    /// Please see gtk_tree_view_set_fixed_height_mode() for more
    /// information on this option.
    pub fn fixed_height_mode(self, fixed_height_mode: bool) -> Self {
        Self {
            builder: self
                .builder
                .property("fixed-height-mode", fixed_height_mode),
        }
    }

    pub fn headers_clickable(self, headers_clickable: bool) -> Self {
        Self {
            builder: self
                .builder
                .property("headers-clickable", headers_clickable),
        }
    }

    pub fn headers_visible(self, headers_visible: bool) -> Self {
        Self {
            builder: self.builder.property("headers-visible", headers_visible),
        }
    }

    /// Enables or disables the hover expansion mode of @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 [`ComboBox`][crate::ComboBox] or [`EntryCompletion`][crate::EntryCompletion].
    pub fn hover_expand(self, hover_expand: bool) -> Self {
        Self {
            builder: self.builder.property("hover-expand", hover_expand),
        }
    }

    /// Enables or disables the hover selection mode of @tree_view.
    /// Hover selection makes the selected row follow the pointer.
    /// Currently, this works only for the selection modes
    /// [`SelectionMode::Single`][crate::SelectionMode::Single] and [`SelectionMode::Browse`][crate::SelectionMode::Browse].
    ///
    /// This mode is primarily intended for treeviews in popups, e.g.
    /// in [`ComboBox`][crate::ComboBox] or [`EntryCompletion`][crate::EntryCompletion].
    pub fn hover_selection(self, hover_selection: bool) -> Self {
        Self {
            builder: self.builder.property("hover-selection", hover_selection),
        }
    }

    /// Extra indentation for each level.
    pub fn level_indentation(self, level_indentation: i32) -> Self {
        Self {
            builder: self
                .builder
                .property("level-indentation", level_indentation),
        }
    }

    pub fn model(self, model: &impl IsA<TreeModel>) -> Self {
        Self {
            builder: self.builder.property("model", model.clone().upcast()),
        }
    }

    pub fn reorderable(self, reorderable: bool) -> Self {
        Self {
            builder: self.builder.property("reorderable", reorderable),
        }
    }

    pub fn rubber_banding(self, rubber_banding: bool) -> Self {
        Self {
            builder: self.builder.property("rubber-banding", rubber_banding),
        }
    }

    pub fn search_column(self, search_column: i32) -> Self {
        Self {
            builder: self.builder.property("search-column", search_column),
        }
    }

    /// [`true`] if the view has expanders.
    pub fn show_expanders(self, show_expanders: bool) -> Self {
        Self {
            builder: self.builder.property("show-expanders", show_expanders),
        }
    }

    pub fn tooltip_column(self, tooltip_column: i32) -> Self {
        Self {
            builder: self.builder.property("tooltip-column", tooltip_column),
        }
    }

    /// Whether the widget or any of its descendents can accept
    /// the input focus.
    ///
    /// This property is meant to be set by widget implementations,
    /// typically in their instance init function.
    pub fn can_focus(self, can_focus: bool) -> Self {
        Self {
            builder: self.builder.property("can-focus", can_focus),
        }
    }

    /// Whether the widget can receive pointer events.
    pub fn can_target(self, can_target: bool) -> Self {
        Self {
            builder: self.builder.property("can-target", can_target),
        }
    }

    /// A list of css classes applied to this widget.
    pub fn css_classes(self, css_classes: impl Into<glib::StrV>) -> Self {
        Self {
            builder: self.builder.property("css-classes", css_classes.into()),
        }
    }

    /// The name of this widget in the CSS tree.
    ///
    /// This property is meant to be set by widget implementations,
    /// typically in their instance init function.
    pub fn css_name(self, css_name: impl Into<glib::GString>) -> Self {
        Self {
            builder: self.builder.property("css-name", css_name.into()),
        }
    }

    /// The cursor used by @widget.
    pub fn cursor(self, cursor: &gdk::Cursor) -> Self {
        Self {
            builder: self.builder.property("cursor", cursor.clone()),
        }
    }

    /// Whether the widget should grab focus when it is clicked with the mouse.
    ///
    /// This property is only relevant for widgets that can take focus.
    pub fn focus_on_click(self, focus_on_click: bool) -> Self {
        Self {
            builder: self.builder.property("focus-on-click", focus_on_click),
        }
    }

    /// Whether this widget itself will accept the input focus.
    pub fn focusable(self, focusable: bool) -> Self {
        Self {
            builder: self.builder.property("focusable", focusable),
        }
    }

    /// How to distribute horizontal space if widget gets extra space.
    pub fn halign(self, halign: Align) -> Self {
        Self {
            builder: self.builder.property("halign", halign),
        }
    }

    /// Enables or disables the emission of the ::query-tooltip signal on @widget.
    ///
    /// A value of [`true`] indicates that @widget can have a tooltip, in this case
    /// the widget will be queried using [`query-tooltip`][struct@crate::Widget#query-tooltip] to
    /// determine whether it will provide a tooltip or not.
    pub fn has_tooltip(self, has_tooltip: bool) -> Self {
        Self {
            builder: self.builder.property("has-tooltip", has_tooltip),
        }
    }

    /// Override for height request of the widget.
    ///
    /// If this is -1, the natural request will be used.
    pub fn height_request(self, height_request: i32) -> Self {
        Self {
            builder: self.builder.property("height-request", height_request),
        }
    }

    /// Whether to expand horizontally.
    pub fn hexpand(self, hexpand: bool) -> Self {
        Self {
            builder: self.builder.property("hexpand", hexpand),
        }
    }

    /// Whether to use the `hexpand` property.
    pub fn hexpand_set(self, hexpand_set: bool) -> Self {
        Self {
            builder: self.builder.property("hexpand-set", hexpand_set),
        }
    }

    /// The [`LayoutManager`][crate::LayoutManager] instance to use to compute the preferred size
    /// of the widget, and allocate its children.
    ///
    /// This property is meant to be set by widget implementations,
    /// typically in their instance init function.
    pub fn layout_manager(self, layout_manager: &impl IsA<LayoutManager>) -> Self {
        Self {
            builder: self
                .builder
                .property("layout-manager", layout_manager.clone().upcast()),
        }
    }

    /// Margin on bottom side of widget.
    ///
    /// This property adds margin outside of the widget's normal size
    /// request, the margin will be added in addition to the size from
    /// [`WidgetExt::set_size_request()`][crate::prelude::WidgetExt::set_size_request()] for example.
    pub fn margin_bottom(self, margin_bottom: i32) -> Self {
        Self {
            builder: self.builder.property("margin-bottom", margin_bottom),
        }
    }

    /// Margin on end of widget, horizontally.
    ///
    /// This property supports left-to-right and right-to-left text
    /// directions.
    ///
    /// This property adds margin outside of the widget's normal size
    /// request, the margin will be added in addition to the size from
    /// [`WidgetExt::set_size_request()`][crate::prelude::WidgetExt::set_size_request()] for example.
    pub fn margin_end(self, margin_end: i32) -> Self {
        Self {
            builder: self.builder.property("margin-end", margin_end),
        }
    }

    /// Margin on start of widget, horizontally.
    ///
    /// This property supports left-to-right and right-to-left text
    /// directions.
    ///
    /// This property adds margin outside of the widget's normal size
    /// request, the margin will be added in addition to the size from
    /// [`WidgetExt::set_size_request()`][crate::prelude::WidgetExt::set_size_request()] for example.
    pub fn margin_start(self, margin_start: i32) -> Self {
        Self {
            builder: self.builder.property("margin-start", margin_start),
        }
    }

    /// Margin on top side of widget.
    ///
    /// This property adds margin outside of the widget's normal size
    /// request, the margin will be added in addition to the size from
    /// [`WidgetExt::set_size_request()`][crate::prelude::WidgetExt::set_size_request()] for example.
    pub fn margin_top(self, margin_top: i32) -> Self {
        Self {
            builder: self.builder.property("margin-top", margin_top),
        }
    }

    /// The name of the widget.
    pub fn name(self, name: impl Into<glib::GString>) -> Self {
        Self {
            builder: self.builder.property("name", name.into()),
        }
    }

    /// The requested opacity of the widget.
    pub fn opacity(self, opacity: f64) -> Self {
        Self {
            builder: self.builder.property("opacity", opacity),
        }
    }

    /// How content outside the widget's content area is treated.
    ///
    /// This property is meant to be set by widget implementations,
    /// typically in their instance init function.
    pub fn overflow(self, overflow: Overflow) -> Self {
        Self {
            builder: self.builder.property("overflow", overflow),
        }
    }

    /// Whether the widget will receive the default action when it is focused.
    pub fn receives_default(self, receives_default: bool) -> Self {
        Self {
            builder: self.builder.property("receives-default", receives_default),
        }
    }

    /// Whether the widget responds to input.
    pub fn sensitive(self, sensitive: bool) -> Self {
        Self {
            builder: self.builder.property("sensitive", sensitive),
        }
    }

    /// Sets the text of tooltip to be the given string, which is marked up
    /// with Pango markup.
    ///
    /// Also see [`Tooltip::set_markup()`][crate::Tooltip::set_markup()].
    ///
    /// This is a convenience property which will take care of getting the
    /// tooltip shown if the given string is not [`None`]:
    /// [`has-tooltip`][struct@crate::Widget#has-tooltip] will automatically be set to [`true`]
    /// and there will be taken care of [`query-tooltip`][struct@crate::Widget#query-tooltip] in
    /// the default signal handler.
    ///
    /// Note that if both [`tooltip-text`][struct@crate::Widget#tooltip-text] and
    /// [`tooltip-markup`][struct@crate::Widget#tooltip-markup] are set, the last one wins.
    pub fn tooltip_markup(self, tooltip_markup: impl Into<glib::GString>) -> Self {
        Self {
            builder: self
                .builder
                .property("tooltip-markup", tooltip_markup.into()),
        }
    }

    /// Sets the text of tooltip to be the given string.
    ///
    /// Also see [`Tooltip::set_text()`][crate::Tooltip::set_text()].
    ///
    /// This is a convenience property which will take care of getting the
    /// tooltip shown if the given string is not [`None`]:
    /// [`has-tooltip`][struct@crate::Widget#has-tooltip] will automatically be set to [`true`]
    /// and there will be taken care of [`query-tooltip`][struct@crate::Widget#query-tooltip] in
    /// the default signal handler.
    ///
    /// Note that if both [`tooltip-text`][struct@crate::Widget#tooltip-text] and
    /// [`tooltip-markup`][struct@crate::Widget#tooltip-markup] are set, the last one wins.
    pub fn tooltip_text(self, tooltip_text: impl Into<glib::GString>) -> Self {
        Self {
            builder: self.builder.property("tooltip-text", tooltip_text.into()),
        }
    }

    /// How to distribute vertical space if widget gets extra space.
    pub fn valign(self, valign: Align) -> Self {
        Self {
            builder: self.builder.property("valign", valign),
        }
    }

    /// Whether to expand vertically.
    pub fn vexpand(self, vexpand: bool) -> Self {
        Self {
            builder: self.builder.property("vexpand", vexpand),
        }
    }

    /// Whether to use the `vexpand` property.
    pub fn vexpand_set(self, vexpand_set: bool) -> Self {
        Self {
            builder: self.builder.property("vexpand-set", vexpand_set),
        }
    }

    /// Whether the widget is visible.
    pub fn visible(self, visible: bool) -> Self {
        Self {
            builder: self.builder.property("visible", visible),
        }
    }

    /// Override for width request of the widget.
    ///
    /// If this is -1, the natural request will be used.
    pub fn width_request(self, width_request: i32) -> Self {
        Self {
            builder: self.builder.property("width-request", width_request),
        }
    }

    /// The accessible role of the given [`Accessible`][crate::Accessible] implementation.
    ///
    /// The accessible role cannot be changed once set.
    pub fn accessible_role(self, accessible_role: AccessibleRole) -> Self {
        Self {
            builder: self.builder.property("accessible-role", accessible_role),
        }
    }

    /// Horizontal [`Adjustment`][crate::Adjustment] of the scrollable widget.
    ///
    /// This adjustment is shared between the scrollable widget and its parent.
    pub fn hadjustment(self, hadjustment: &impl IsA<Adjustment>) -> Self {
        Self {
            builder: self
                .builder
                .property("hadjustment", hadjustment.clone().upcast()),
        }
    }

    /// Determines when horizontal scrolling should start.
    pub fn hscroll_policy(self, hscroll_policy: ScrollablePolicy) -> Self {
        Self {
            builder: self.builder.property("hscroll-policy", hscroll_policy),
        }
    }

    /// Vertical [`Adjustment`][crate::Adjustment] of the scrollable widget.
    ///
    /// This adjustment is shared between the scrollable widget and its parent.
    pub fn vadjustment(self, vadjustment: &impl IsA<Adjustment>) -> Self {
        Self {
            builder: self
                .builder
                .property("vadjustment", vadjustment.clone().upcast()),
        }
    }

    /// Determines when vertical scrolling should start.
    pub fn vscroll_policy(self, vscroll_policy: ScrollablePolicy) -> Self {
        Self {
            builder: self.builder.property("vscroll-policy", vscroll_policy),
        }
    }

    // rustdoc-stripper-ignore-next
    /// Build the [`TreeView`].
    #[must_use = "Building the object from the builder is usually expensive and is not expected to have side effects"]
    pub fn build(self) -> TreeView {
        self.builder.build()
    }
}

mod sealed {
    pub trait Sealed {}
    impl<T: super::IsA<super::TreeView>> Sealed for T {}
}

/// Trait containing all [`struct@TreeView`] methods.
///
/// # Implementors
///
/// [`TreeView`][struct@crate::TreeView]
pub trait TreeViewExt: IsA<TreeView> + sealed::Sealed + 'static {
    /// Appends @column to the list of columns. If @self has “fixed_height”
    /// mode enabled, then @column must have its “sizing” property set to be
    /// GTK_TREE_VIEW_COLUMN_FIXED.
    ///
    /// # Deprecated since 4.10
    ///
    /// Use [`ListView`][crate::ListView] or [`ColumnView`][crate::ColumnView] instead
    /// ## `column`
    /// The [`TreeViewColumn`][crate::TreeViewColumn] to add.
    ///
    /// # Returns
    ///
    /// The number of columns in @self after appending.
    #[cfg_attr(feature = "v4_10", deprecated = "Since 4.10")]
    #[allow(deprecated)]
    #[doc(alias = "gtk_tree_view_append_column")]
    fn append_column(&self, column: &TreeViewColumn) -> i32 {
        unsafe {
            ffi::gtk_tree_view_append_column(
                self.as_ref().to_glib_none().0,
                column.to_glib_none().0,
            )
        }
    }

    /// Recursively collapses all visible, expanded nodes in @self.
    ///
    /// # Deprecated since 4.10
    ///
    /// Use [`ListView`][crate::ListView] or [`ColumnView`][crate::ColumnView] instead
    #[cfg_attr(feature = "v4_10", deprecated = "Since 4.10")]
    #[allow(deprecated)]
    #[doc(alias = "gtk_tree_view_collapse_all")]
    fn collapse_all(&self) {
        unsafe {
            ffi::gtk_tree_view_collapse_all(self.as_ref().to_glib_none().0);
        }
    }

    /// Collapses a row (hides its child rows, if they exist).
    ///
    /// # Deprecated since 4.10
    ///
    /// Use [`ListView`][crate::ListView] or [`ColumnView`][crate::ColumnView] instead
    /// ## `path`
    /// path to a row in the @self
    ///
    /// # Returns
    ///
    /// [`true`] if the row was collapsed.
    #[cfg_attr(feature = "v4_10", deprecated = "Since 4.10")]
    #[allow(deprecated)]
    #[doc(alias = "gtk_tree_view_collapse_row")]
    fn collapse_row(&self, path: &TreePath) -> bool {
        unsafe {
            from_glib(ffi::gtk_tree_view_collapse_row(
                self.as_ref().to_glib_none().0,
                mut_override(path.to_glib_none().0),
            ))
        }
    }

    /// Resizes all columns to their optimal width. Only works after the
    /// treeview has been realized.
    ///
    /// # Deprecated since 4.10
    ///
    /// Use [`ListView`][crate::ListView] or [`ColumnView`][crate::ColumnView] instead
    #[cfg_attr(feature = "v4_10", deprecated = "Since 4.10")]
    #[allow(deprecated)]
    #[doc(alias = "gtk_tree_view_columns_autosize")]
    fn columns_autosize(&self) {
        unsafe {
            ffi::gtk_tree_view_columns_autosize(self.as_ref().to_glib_none().0);
        }
    }

    /// Converts bin_window coordinates to coordinates for the
    /// tree (the full scrollable area of the tree).
    ///
    /// # Deprecated since 4.10
    ///
    /// Use [`ListView`][crate::ListView] or [`ColumnView`][crate::ColumnView] instead
    /// ## `bx`
    /// X coordinate relative to bin_window
    /// ## `by`
    /// Y coordinate relative to bin_window
    ///
    /// # Returns
    ///
    ///
    /// ## `tx`
    /// return location for tree X coordinate
    ///
    /// ## `ty`
    /// return location for tree Y coordinate
    #[cfg_attr(feature = "v4_10", deprecated = "Since 4.10")]
    #[allow(deprecated)]
    #[doc(alias = "gtk_tree_view_convert_bin_window_to_tree_coords")]
    fn convert_bin_window_to_tree_coords(&self, bx: i32, by: i32) -> (i32, i32) {
        unsafe {
            let mut tx = mem::MaybeUninit::uninit();
            let mut ty = mem::MaybeUninit::uninit();
            ffi::gtk_tree_view_convert_bin_window_to_tree_coords(
                self.as_ref().to_glib_none().0,
                bx,
                by,
                tx.as_mut_ptr(),
                ty.as_mut_ptr(),
            );
            (tx.assume_init(), ty.assume_init())
        }
    }

    /// Converts bin_window coordinates to widget relative coordinates.
    ///
    /// # Deprecated since 4.10
    ///
    /// Use [`ListView`][crate::ListView] or [`ColumnView`][crate::ColumnView] instead
    /// ## `bx`
    /// bin_window X coordinate
    /// ## `by`
    /// bin_window Y coordinate
    ///
    /// # Returns
    ///
    ///
    /// ## `wx`
    /// return location for widget X coordinate
    ///
    /// ## `wy`
    /// return location for widget Y coordinate
    #[cfg_attr(feature = "v4_10", deprecated = "Since 4.10")]
    #[allow(deprecated)]
    #[doc(alias = "gtk_tree_view_convert_bin_window_to_widget_coords")]
    fn convert_bin_window_to_widget_coords(&self, bx: i32, by: i32) -> (i32, i32) {
        unsafe {
            let mut wx = mem::MaybeUninit::uninit();
            let mut wy = mem::MaybeUninit::uninit();
            ffi::gtk_tree_view_convert_bin_window_to_widget_coords(
                self.as_ref().to_glib_none().0,
                bx,
                by,
                wx.as_mut_ptr(),
                wy.as_mut_ptr(),
            );
            (wx.assume_init(), wy.assume_init())
        }
    }

    /// Converts tree coordinates (coordinates in full scrollable area of the tree)
    /// to bin_window coordinates.
    ///
    /// # Deprecated since 4.10
    ///
    /// Use [`ListView`][crate::ListView] or [`ColumnView`][crate::ColumnView] instead
    /// ## `tx`
    /// tree X coordinate
    /// ## `ty`
    /// tree Y coordinate
    ///
    /// # Returns
    ///
    ///
    /// ## `bx`
    /// return location for X coordinate relative to bin_window
    ///
    /// ## `by`
    /// return location for Y coordinate relative to bin_window
    #[cfg_attr(feature = "v4_10", deprecated = "Since 4.10")]
    #[allow(deprecated)]
    #[doc(alias = "gtk_tree_view_convert_tree_to_bin_window_coords")]
    fn convert_tree_to_bin_window_coords(&self, tx: i32, ty: i32) -> (i32, i32) {
        unsafe {
            let mut bx = mem::MaybeUninit::uninit();
            let mut by = mem::MaybeUninit::uninit();
            ffi::gtk_tree_view_convert_tree_to_bin_window_coords(
                self.as_ref().to_glib_none().0,
                tx,
                ty,
                bx.as_mut_ptr(),
                by.as_mut_ptr(),
            );
            (bx.assume_init(), by.assume_init())
        }
    }

    /// Converts tree coordinates (coordinates in full scrollable area of the tree)
    /// to widget coordinates.
    ///
    /// # Deprecated since 4.10
    ///
    /// Use [`ListView`][crate::ListView] or [`ColumnView`][crate::ColumnView] instead
    /// ## `tx`
    /// X coordinate relative to the tree
    /// ## `ty`
    /// Y coordinate relative to the tree
    ///
    /// # Returns
    ///
    ///
    /// ## `wx`
    /// return location for widget X coordinate
    ///
    /// ## `wy`
    /// return location for widget Y coordinate
    #[cfg_attr(feature = "v4_10", deprecated = "Since 4.10")]
    #[allow(deprecated)]
    #[doc(alias = "gtk_tree_view_convert_tree_to_widget_coords")]
    fn convert_tree_to_widget_coords(&self, tx: i32, ty: i32) -> (i32, i32) {
        unsafe {
            let mut wx = mem::MaybeUninit::uninit();
            let mut wy = mem::MaybeUninit::uninit();
            ffi::gtk_tree_view_convert_tree_to_widget_coords(
                self.as_ref().to_glib_none().0,
                tx,
                ty,
                wx.as_mut_ptr(),
                wy.as_mut_ptr(),
            );
            (wx.assume_init(), wy.assume_init())
        }
    }

    /// Converts widget coordinates to coordinates for the bin_window.
    ///
    /// # Deprecated since 4.10
    ///
    /// Use [`ListView`][crate::ListView] or [`ColumnView`][crate::ColumnView] instead
    /// ## `wx`
    /// X coordinate relative to the widget
    /// ## `wy`
    /// Y coordinate relative to the widget
    ///
    /// # Returns
    ///
    ///
    /// ## `bx`
    /// return location for bin_window X coordinate
    ///
    /// ## `by`
    /// return location for bin_window Y coordinate
    #[cfg_attr(feature = "v4_10", deprecated = "Since 4.10")]
    #[allow(deprecated)]
    #[doc(alias = "gtk_tree_view_convert_widget_to_bin_window_coords")]
    fn convert_widget_to_bin_window_coords(&self, wx: i32, wy: i32) -> (i32, i32) {
        unsafe {
            let mut bx = mem::MaybeUninit::uninit();
            let mut by = mem::MaybeUninit::uninit();
            ffi::gtk_tree_view_convert_widget_to_bin_window_coords(
                self.as_ref().to_glib_none().0,
                wx,
                wy,
                bx.as_mut_ptr(),
                by.as_mut_ptr(),
            );
            (bx.assume_init(), by.assume_init())
        }
    }

    /// Converts widget coordinates to coordinates for the
    /// tree (the full scrollable area of the tree).
    ///
    /// # Deprecated since 4.10
    ///
    /// Use [`ListView`][crate::ListView] or [`ColumnView`][crate::ColumnView] instead
    /// ## `wx`
    /// X coordinate relative to the widget
    /// ## `wy`
    /// Y coordinate relative to the widget
    ///
    /// # Returns
    ///
    ///
    /// ## `tx`
    /// return location for tree X coordinate
    ///
    /// ## `ty`
    /// return location for tree Y coordinate
    #[cfg_attr(feature = "v4_10", deprecated = "Since 4.10")]
    #[allow(deprecated)]
    #[doc(alias = "gtk_tree_view_convert_widget_to_tree_coords")]
    fn convert_widget_to_tree_coords(&self, wx: i32, wy: i32) -> (i32, i32) {
        unsafe {
            let mut tx = mem::MaybeUninit::uninit();
            let mut ty = mem::MaybeUninit::uninit();
            ffi::gtk_tree_view_convert_widget_to_tree_coords(
                self.as_ref().to_glib_none().0,
                wx,
                wy,
                tx.as_mut_ptr(),
                ty.as_mut_ptr(),
            );
            (tx.assume_init(), ty.assume_init())
        }
    }

    /// Creates a [`cairo::Surface`][crate::cairo::Surface] representation of the row at @path.
    /// This image is used for a drag icon.
    ///
    /// # Deprecated since 4.10
    ///
    /// Use [`ListView`][crate::ListView] or [`ColumnView`][crate::ColumnView] instead
    /// ## `path`
    /// a [`TreePath`][crate::TreePath] in @self
    ///
    /// # Returns
    ///
    /// a newly-allocated surface of the drag icon.
    #[cfg_attr(feature = "v4_10", deprecated = "Since 4.10")]
    #[allow(deprecated)]
    #[doc(alias = "gtk_tree_view_create_row_drag_icon")]
    fn create_row_drag_icon(&self, path: &TreePath) -> Option<gdk::Paintable> {
        unsafe {
            from_glib_full(ffi::gtk_tree_view_create_row_drag_icon(
                self.as_ref().to_glib_none().0,
                mut_override(path.to_glib_none().0),
            ))
        }
    }

    /// Turns @self into a drop destination for automatic DND. Calling
    /// this method sets [`TreeView`][crate::TreeView]:reorderable to [`false`].
    ///
    /// # Deprecated since 4.10
    ///
    /// Use [`ListView`][crate::ListView] or [`ColumnView`][crate::ColumnView] instead
    /// ## `formats`
    /// the target formats that the drag will support
    /// ## `actions`
    /// the bitmask of possible actions for a drag from this
    ///    widget
    #[cfg_attr(feature = "v4_10", deprecated = "Since 4.10")]
    #[allow(deprecated)]
    #[doc(alias = "gtk_tree_view_enable_model_drag_dest")]
    fn enable_model_drag_dest(&self, formats: &gdk::ContentFormats, actions: gdk::DragAction) {
        unsafe {
            ffi::gtk_tree_view_enable_model_drag_dest(
                self.as_ref().to_glib_none().0,
                formats.to_glib_none().0,
                actions.into_glib(),
            );
        }
    }

    /// Turns @self into a drag source for automatic DND. Calling this
    /// method sets [`TreeView`][crate::TreeView]:reorderable to [`false`].
    ///
    /// # Deprecated since 4.10
    ///
    /// Use [`ListView`][crate::ListView] or [`ColumnView`][crate::ColumnView] instead
    /// ## `start_button_mask`
    /// Mask of allowed buttons to start drag
    /// ## `formats`
    /// the target formats that the drag will support
    /// ## `actions`
    /// the bitmask of possible actions for a drag from this
    ///    widget
    #[cfg_attr(feature = "v4_10", deprecated = "Since 4.10")]
    #[allow(deprecated)]
    #[doc(alias = "gtk_tree_view_enable_model_drag_source")]
    fn enable_model_drag_source(
        &self,
        start_button_mask: gdk::ModifierType,
        formats: &gdk::ContentFormats,
        actions: gdk::DragAction,
    ) {
        unsafe {
            ffi::gtk_tree_view_enable_model_drag_source(
                self.as_ref().to_glib_none().0,
                start_button_mask.into_glib(),
                formats.to_glib_none().0,
                actions.into_glib(),
            );
        }
    }

    /// Recursively expands all nodes in the @self.
    ///
    /// # Deprecated since 4.10
    ///
    /// Use [`ListView`][crate::ListView] or [`ColumnView`][crate::ColumnView] instead
    #[cfg_attr(feature = "v4_10", deprecated = "Since 4.10")]
    #[allow(deprecated)]
    #[doc(alias = "gtk_tree_view_expand_all")]
    fn expand_all(&self) {
        unsafe {
            ffi::gtk_tree_view_expand_all(self.as_ref().to_glib_none().0);
        }
    }

    /// Opens the row so its children are visible.
    ///
    /// # Deprecated since 4.10
    ///
    /// Use [`ListView`][crate::ListView] or [`ColumnView`][crate::ColumnView] instead
    /// ## `path`
    /// path to a row
    /// ## `open_all`
    /// whether to recursively expand, or just expand immediate children
    ///
    /// # Returns
    ///
    /// [`true`] if the row existed and had children
    #[cfg_attr(feature = "v4_10", deprecated = "Since 4.10")]
    #[allow(deprecated)]
    #[doc(alias = "gtk_tree_view_expand_row")]
    fn expand_row(&self, path: &TreePath, open_all: bool) -> bool {
        unsafe {
            from_glib(ffi::gtk_tree_view_expand_row(
                self.as_ref().to_glib_none().0,
                mut_override(path.to_glib_none().0),
                open_all.into_glib(),
            ))
        }
    }

    /// Expands the row at @path. This will also expand all parent rows of
    /// @path as necessary.
    ///
    /// # Deprecated since 4.10
    ///
    /// Use [`ListView`][crate::ListView] or [`ColumnView`][crate::ColumnView] instead
    /// ## `path`
    /// path to a row.
    #[cfg_attr(feature = "v4_10", deprecated = "Since 4.10")]
    #[allow(deprecated)]
    #[doc(alias = "gtk_tree_view_expand_to_path")]
    fn expand_to_path(&self, path: &TreePath) {
        unsafe {
            ffi::gtk_tree_view_expand_to_path(
                self.as_ref().to_glib_none().0,
                mut_override(path.to_glib_none().0),
            );
        }
    }

    /// Gets the setting set by gtk_tree_view_set_activate_on_single_click().
    ///
    /// # Deprecated since 4.10
    ///
    /// Use [`ListView`][crate::ListView] or [`ColumnView`][crate::ColumnView] instead
    ///
    /// # Returns
    ///
    /// [`true`] if row-activated will be emitted on a single click
    #[cfg_attr(feature = "v4_10", deprecated = "Since 4.10")]
    #[allow(deprecated)]
    #[doc(alias = "gtk_tree_view_get_activate_on_single_click")]
    #[doc(alias = "get_activate_on_single_click")]
    fn activates_on_single_click(&self) -> bool {
        unsafe {
            from_glib(ffi::gtk_tree_view_get_activate_on_single_click(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Fills the bounding rectangle in bin_window coordinates for the cell at the
    /// row specified by @path and the column specified by @column.  If @path is
    /// [`None`], or points to a node not found in the tree, the @y and @height fields of
    /// the rectangle will be filled with 0. If @column is [`None`], the @x and @width
    /// fields will be filled with 0.  The returned rectangle is equivalent to the
    /// @background_area passed to gtk_cell_renderer_render().  These background
    /// areas tile to cover the entire bin window.  Contrast with the @cell_area,
    /// returned by gtk_tree_view_get_cell_area(), which returns only the cell
    /// itself, excluding surrounding borders and the tree expander area.
    ///
    /// # Deprecated since 4.10
    ///
    /// Use [`ListView`][crate::ListView] or [`ColumnView`][crate::ColumnView] instead
    /// ## `path`
    /// a [`TreePath`][crate::TreePath] for the row, or [`None`] to get only horizontal coordinates
    /// ## `column`
    /// a [`TreeViewColumn`][crate::TreeViewColumn] for the column, or [`None`] to get only vertical coordinates
    ///
    /// # Returns
    ///
    ///
    /// ## `rect`
    /// rectangle to fill with cell background rect
    #[cfg_attr(feature = "v4_10", deprecated = "Since 4.10")]
    #[allow(deprecated)]
    #[doc(alias = "gtk_tree_view_get_background_area")]
    #[doc(alias = "get_background_area")]
    fn background_area(
        &self,
        path: Option<&TreePath>,
        column: Option<&TreeViewColumn>,
    ) -> gdk::Rectangle {
        unsafe {
            let mut rect = gdk::Rectangle::uninitialized();
            ffi::gtk_tree_view_get_background_area(
                self.as_ref().to_glib_none().0,
                mut_override(path.to_glib_none().0),
                column.to_glib_none().0,
                rect.to_glib_none_mut().0,
            );
            rect
        }
    }

    /// Fills the bounding rectangle in bin_window coordinates for the cell at the
    /// row specified by @path and the column specified by @column.  If @path is
    /// [`None`], or points to a path not currently displayed, the @y and @height fields
    /// of the rectangle will be filled with 0. If @column is [`None`], the @x and @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 @cell_area passed to
    /// gtk_cell_renderer_render().  This function is only valid if @self is
    /// realized.
    ///
    /// # Deprecated since 4.10
    ///
    /// Use [`ListView`][crate::ListView] or [`ColumnView`][crate::ColumnView] instead
    /// ## `path`
    /// a [`TreePath`][crate::TreePath] for the row, or [`None`] to get only horizontal coordinates
    /// ## `column`
    /// a [`TreeViewColumn`][crate::TreeViewColumn] for the column, or [`None`] to get only vertical coordinates
    ///
    /// # Returns
    ///
    ///
    /// ## `rect`
    /// rectangle to fill with cell rect
    #[cfg_attr(feature = "v4_10", deprecated = "Since 4.10")]
    #[allow(deprecated)]
    #[doc(alias = "gtk_tree_view_get_cell_area")]
    #[doc(alias = "get_cell_area")]
    fn cell_area(
        &self,
        path: Option<&TreePath>,
        column: Option<&TreeViewColumn>,
    ) -> gdk::Rectangle {
        unsafe {
            let mut rect = gdk::Rectangle::uninitialized();
            ffi::gtk_tree_view_get_cell_area(
                self.as_ref().to_glib_none().0,
                mut_override(path.to_glib_none().0),
                column.to_glib_none().0,
                rect.to_glib_none_mut().0,
            );
            rect
        }
    }

    /// Gets the [`TreeViewColumn`][crate::TreeViewColumn] at the given position in the #tree_view.
    ///
    /// # Deprecated since 4.10
    ///
    /// Use [`ListView`][crate::ListView] or [`ColumnView`][crate::ColumnView] instead
    /// ## `n`
    /// The position of the column, counting from 0.
    ///
    /// # Returns
    ///
    /// The [`TreeViewColumn`][crate::TreeViewColumn], or [`None`] if the
    /// position is outside the range of columns.
    #[cfg_attr(feature = "v4_10", deprecated = "Since 4.10")]
    #[allow(deprecated)]
    #[doc(alias = "gtk_tree_view_get_column")]
    #[doc(alias = "get_column")]
    fn column(&self, n: i32) -> Option<TreeViewColumn> {
        unsafe {
            from_glib_none(ffi::gtk_tree_view_get_column(
                self.as_ref().to_glib_none().0,
                n,
            ))
        }
    }

    /// Returns a `GList` of all the [`TreeViewColumn`][crate::TreeViewColumn]s currently in @self.
    /// The returned list must be freed with g_list_free ().
    ///
    /// # Deprecated since 4.10
    ///
    /// Use [`ListView`][crate::ListView] or [`ColumnView`][crate::ColumnView] instead
    ///
    /// # Returns
    ///
    /// A list of [`TreeViewColumn`][crate::TreeViewColumn]s
    #[cfg_attr(feature = "v4_10", deprecated = "Since 4.10")]
    #[allow(deprecated)]
    #[doc(alias = "gtk_tree_view_get_columns")]
    #[doc(alias = "get_columns")]
    fn columns(&self) -> Vec<TreeViewColumn> {
        unsafe {
            FromGlibPtrContainer::from_glib_container(ffi::gtk_tree_view_get_columns(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Fills in @path and @focus_column with the current path and focus column.  If
    /// the cursor isn’t currently set, then *@path will be [`None`].  If no column
    /// currently has focus, then *@focus_column will be [`None`].
    ///
    /// The returned [`TreePath`][crate::TreePath] must be freed with gtk_tree_path_free() when
    /// you are done with it.
    ///
    /// # Deprecated since 4.10
    ///
    /// Use [`ListView`][crate::ListView] or [`ColumnView`][crate::ColumnView] instead
    ///
    /// # Returns
    ///
    ///
    /// ## `path`
    /// A pointer to be
    ///   filled with the current cursor path
    ///
    /// ## `focus_column`
    /// A
    ///   pointer to be filled with the current focus column
    #[cfg_attr(feature = "v4_10", deprecated = "Since 4.10")]
    #[allow(deprecated)]
    #[doc(alias = "gtk_tree_view_get_cursor")]
    #[doc(alias = "get_cursor")]
    fn cursor(&self) -> (Option<TreePath>, Option<TreeViewColumn>) {
        unsafe {
            let mut path = ptr::null_mut();
            let mut focus_column = ptr::null_mut();
            ffi::gtk_tree_view_get_cursor(
                self.as_ref().to_glib_none().0,
                &mut path,
                &mut focus_column,
            );
            (from_glib_full(path), from_glib_none(focus_column))
        }
    }

    /// Determines the destination row for a given position.  @drag_x and
    /// @drag_y are expected to be in widget coordinates.  This function is only
    /// meaningful if @self is realized.  Therefore this function will always
    /// return [`false`] if @self is not realized or does not have a model.
    ///
    /// # Deprecated since 4.10
    ///
    /// Use [`ListView`][crate::ListView] or [`ColumnView`][crate::ColumnView] instead
    /// ## `drag_x`
    /// the position to determine the destination row for
    /// ## `drag_y`
    /// the position to determine the destination row for
    ///
    /// # Returns
    ///
    /// whether there is a row at the given position, [`true`] if this
    /// is indeed the case.
    ///
    /// ## `path`
    /// Return location for the path of
    ///   the highlighted row
    ///
    /// ## `pos`
    /// Return location for the drop position, or
    ///   [`None`]
    #[cfg_attr(feature = "v4_10", deprecated = "Since 4.10")]
    #[allow(deprecated)]
    #[doc(alias = "gtk_tree_view_get_dest_row_at_pos")]
    #[doc(alias = "get_dest_row_at_pos")]
    fn dest_row_at_pos(
        &self,
        drag_x: i32,
        drag_y: i32,
    ) -> Option<(Option<TreePath>, TreeViewDropPosition)> {
        unsafe {
            let mut path = ptr::null_mut();
            let mut pos = mem::MaybeUninit::uninit();
            let ret = from_glib(ffi::gtk_tree_view_get_dest_row_at_pos(
                self.as_ref().to_glib_none().0,
                drag_x,
                drag_y,
                &mut path,
                pos.as_mut_ptr(),
            ));
            if ret {
                Some((from_glib_full(path), from_glib(pos.assume_init())))
            } else {
                None
            }
        }
    }

    /// Gets information about the row that is highlighted for feedback.
    ///
    /// # Deprecated since 4.10
    ///
    /// Use [`ListView`][crate::ListView] or [`ColumnView`][crate::ColumnView] instead
    ///
    /// # Returns
    ///
    ///
    /// ## `path`
    /// Return location for the path of the highlighted row
    ///
    /// ## `pos`
    /// Return location for the drop position
    #[cfg_attr(feature = "v4_10", deprecated = "Since 4.10")]
    #[allow(deprecated)]
    #[doc(alias = "gtk_tree_view_get_drag_dest_row")]
    #[doc(alias = "get_drag_dest_row")]
    fn drag_dest_row(&self) -> (Option<TreePath>, TreeViewDropPosition) {
        unsafe {
            let mut path = ptr::null_mut();
            let mut pos = mem::MaybeUninit::uninit();
            ffi::gtk_tree_view_get_drag_dest_row(
                self.as_ref().to_glib_none().0,
                &mut path,
                pos.as_mut_ptr(),
            );
            (from_glib_full(path), from_glib(pos.assume_init()))
        }
    }

    /// Returns whether or not the tree allows to start interactive searching
    /// by typing in text.
    ///
    /// # Deprecated since 4.10
    ///
    /// Use [`ListView`][crate::ListView] or [`ColumnView`][crate::ColumnView] instead
    ///
    /// # Returns
    ///
    /// whether or not to let the user search interactively
    #[cfg_attr(feature = "v4_10", deprecated = "Since 4.10")]
    #[allow(deprecated)]
    #[doc(alias = "gtk_tree_view_get_enable_search")]
    #[doc(alias = "get_enable_search")]
    fn enables_search(&self) -> bool {
        unsafe {
            from_glib(ffi::gtk_tree_view_get_enable_search(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Returns whether or not tree lines are drawn in @self.
    ///
    /// # Deprecated since 4.10
    ///
    /// Use [`ListView`][crate::ListView] or [`ColumnView`][crate::ColumnView] instead
    ///
    /// # Returns
    ///
    /// [`true`] if tree lines are drawn in @self, [`false`]
    /// otherwise.
    #[cfg_attr(feature = "v4_10", deprecated = "Since 4.10")]
    #[allow(deprecated)]
    #[doc(alias = "gtk_tree_view_get_enable_tree_lines")]
    #[doc(alias = "get_enable_tree_lines")]
    fn enables_tree_lines(&self) -> bool {
        unsafe {
            from_glib(ffi::gtk_tree_view_get_enable_tree_lines(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Returns the column that is the current expander column,
    /// or [`None`] if none has been set.
    /// This column has the expander arrow drawn next to it.
    ///
    /// # Deprecated since 4.10
    ///
    /// Use [`ListView`][crate::ListView] or [`ColumnView`][crate::ColumnView] instead
    ///
    /// # Returns
    ///
    /// The expander column.
    #[cfg_attr(feature = "v4_10", deprecated = "Since 4.10")]
    #[allow(deprecated)]
    #[doc(alias = "gtk_tree_view_get_expander_column")]
    #[doc(alias = "get_expander_column")]
    fn expander_column(&self) -> Option<TreeViewColumn> {
        unsafe {
            from_glib_none(ffi::gtk_tree_view_get_expander_column(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Returns whether fixed height mode is turned on for @self.
    ///
    /// # Deprecated since 4.10
    ///
    /// Use [`ListView`][crate::ListView] or [`ColumnView`][crate::ColumnView] instead
    ///
    /// # Returns
    ///
    /// [`true`] if @self is in fixed height mode
    #[cfg_attr(feature = "v4_10", deprecated = "Since 4.10")]
    #[allow(deprecated)]
    #[doc(alias = "gtk_tree_view_get_fixed_height_mode")]
    #[doc(alias = "get_fixed_height_mode")]
    fn is_fixed_height_mode(&self) -> bool {
        unsafe {
            from_glib(ffi::gtk_tree_view_get_fixed_height_mode(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Returns which grid lines are enabled in @self.
    ///
    /// # Deprecated since 4.10
    ///
    /// Use [`ListView`][crate::ListView] or [`ColumnView`][crate::ColumnView] instead
    ///
    /// # Returns
    ///
    /// a [`TreeView`][crate::TreeView]GridLines value indicating which grid lines
    /// are enabled.
    #[cfg_attr(feature = "v4_10", deprecated = "Since 4.10")]
    #[allow(deprecated)]
    #[doc(alias = "gtk_tree_view_get_grid_lines")]
    #[doc(alias = "get_grid_lines")]
    fn grid_lines(&self) -> TreeViewGridLines {
        unsafe {
            from_glib(ffi::gtk_tree_view_get_grid_lines(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Returns whether all header columns are clickable.
    ///
    /// # Deprecated since 4.10
    ///
    /// Use [`ListView`][crate::ListView] or [`ColumnView`][crate::ColumnView] instead
    ///
    /// # Returns
    ///
    /// [`true`] if all header columns are clickable, otherwise [`false`]
    #[cfg_attr(feature = "v4_10", deprecated = "Since 4.10")]
    #[allow(deprecated)]
    #[doc(alias = "gtk_tree_view_get_headers_clickable")]
    #[doc(alias = "get_headers_clickable")]
    fn is_headers_clickable(&self) -> bool {
        unsafe {
            from_glib(ffi::gtk_tree_view_get_headers_clickable(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Returns [`true`] if the headers on the @self are visible.
    ///
    /// # Deprecated since 4.10
    ///
    /// Use [`ListView`][crate::ListView] or [`ColumnView`][crate::ColumnView] instead
    ///
    /// # Returns
    ///
    /// Whether the headers are visible or not.
    #[cfg_attr(feature = "v4_10", deprecated = "Since 4.10")]
    #[allow(deprecated)]
    #[doc(alias = "gtk_tree_view_get_headers_visible")]
    #[doc(alias = "get_headers_visible")]
    fn is_headers_visible(&self) -> bool {
        unsafe {
            from_glib(ffi::gtk_tree_view_get_headers_visible(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Returns whether hover expansion mode is turned on for @self.
    ///
    /// # Deprecated since 4.10
    ///
    /// Use [`ListView`][crate::ListView] or [`ColumnView`][crate::ColumnView] instead
    ///
    /// # Returns
    ///
    /// [`true`] if @self is in hover expansion mode
    #[cfg_attr(feature = "v4_10", deprecated = "Since 4.10")]
    #[allow(deprecated)]
    #[doc(alias = "gtk_tree_view_get_hover_expand")]
    #[doc(alias = "get_hover_expand")]
    fn hover_expands(&self) -> bool {
        unsafe {
            from_glib(ffi::gtk_tree_view_get_hover_expand(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Returns whether hover selection mode is turned on for @self.
    ///
    /// # Deprecated since 4.10
    ///
    /// Use [`ListView`][crate::ListView] or [`ColumnView`][crate::ColumnView] instead
    ///
    /// # Returns
    ///
    /// [`true`] if @self is in hover selection mode
    #[cfg_attr(feature = "v4_10", deprecated = "Since 4.10")]
    #[allow(deprecated)]
    #[doc(alias = "gtk_tree_view_get_hover_selection")]
    #[doc(alias = "get_hover_selection")]
    fn is_hover_selection(&self) -> bool {
        unsafe {
            from_glib(ffi::gtk_tree_view_get_hover_selection(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Returns the amount, in pixels, of extra indentation for child levels
    /// in @self.
    ///
    /// # Deprecated since 4.10
    ///
    /// Use [`ListView`][crate::ListView] or [`ColumnView`][crate::ColumnView] instead
    ///
    /// # Returns
    ///
    /// the amount of extra indentation for child levels in
    /// @self.  A return value of 0 means that this feature is disabled.
    #[cfg_attr(feature = "v4_10", deprecated = "Since 4.10")]
    #[allow(deprecated)]
    #[doc(alias = "gtk_tree_view_get_level_indentation")]
    #[doc(alias = "get_level_indentation")]
    fn level_indentation(&self) -> i32 {
        unsafe { ffi::gtk_tree_view_get_level_indentation(self.as_ref().to_glib_none().0) }
    }

    /// Returns the model the [`TreeView`][crate::TreeView] is based on.  Returns [`None`] if the
    /// model is unset.
    ///
    /// # Deprecated since 4.10
    ///
    /// Use [`ListView`][crate::ListView] or [`ColumnView`][crate::ColumnView] instead
    ///
    /// # Returns
    ///
    /// A [`TreeModel`][crate::TreeModel]
    #[cfg_attr(feature = "v4_10", deprecated = "Since 4.10")]
    #[allow(deprecated)]
    #[doc(alias = "gtk_tree_view_get_model")]
    #[doc(alias = "get_model")]
    fn model(&self) -> Option<TreeModel> {
        unsafe { from_glib_none(ffi::gtk_tree_view_get_model(self.as_ref().to_glib_none().0)) }
    }

    /// Queries the number of columns in the given @self.
    ///
    /// # Deprecated since 4.10
    ///
    /// Use [`ListView`][crate::ListView] or [`ColumnView`][crate::ColumnView] instead
    ///
    /// # Returns
    ///
    /// The number of columns in the @self
    #[cfg_attr(feature = "v4_10", deprecated = "Since 4.10")]
    #[allow(deprecated)]
    #[doc(alias = "gtk_tree_view_get_n_columns")]
    #[doc(alias = "get_n_columns")]
    fn n_columns(&self) -> u32 {
        unsafe { ffi::gtk_tree_view_get_n_columns(self.as_ref().to_glib_none().0) }
    }

    /// Finds the path at the point (@x, @y), relative to bin_window coordinates.
    /// That is, @x and @y are relative to an events coordinates. Widget-relative
    /// coordinates must be converted using
    /// gtk_tree_view_convert_widget_to_bin_window_coords(). It is primarily for
    /// things like popup menus. If @path is non-[`None`], then it will be filled
    /// with the [`TreePath`][crate::TreePath] at that point.  This path should be freed with
    /// gtk_tree_path_free().  If @column is non-[`None`], then it will be filled
    /// with the column at that point.  @cell_x and @cell_y return the coordinates
    /// relative to the cell background (i.e. the @background_area passed to
    /// gtk_cell_renderer_render()).  This function is only meaningful if
    /// @self is realized.  Therefore this function will always return [`false`]
    /// if @self is not realized or does not have a model.
    ///
    /// For converting widget coordinates (eg. the ones you get from
    /// GtkWidget::query-tooltip), please see
    /// gtk_tree_view_convert_widget_to_bin_window_coords().
    ///
    /// # Deprecated since 4.10
    ///
    /// Use [`ListView`][crate::ListView] or [`ColumnView`][crate::ColumnView] instead
    /// ## `x`
    /// The x position to be identified (relative to bin_window).
    /// ## `y`
    /// The y position to be identified (relative to bin_window).
    ///
    /// # Returns
    ///
    /// [`true`] if a row exists at that coordinate.
    ///
    /// ## `path`
    /// A pointer to a [`TreePath`][crate::TreePath]
    ///   pointer to be filled in
    ///
    /// ## `column`
    /// A pointer to
    ///   a [`TreeViewColumn`][crate::TreeViewColumn] pointer to be filled in
    ///
    /// ## `cell_x`
    /// A pointer where the X coordinate
    ///   relative to the cell can be placed
    ///
    /// ## `cell_y`
    /// A pointer where the Y coordinate
    ///   relative to the cell can be placed
    #[cfg_attr(feature = "v4_10", deprecated = "Since 4.10")]
    #[allow(deprecated)]
    #[doc(alias = "gtk_tree_view_get_path_at_pos")]
    #[doc(alias = "get_path_at_pos")]
    fn path_at_pos(
        &self,
        x: i32,
        y: i32,
    ) -> Option<(Option<TreePath>, Option<TreeViewColumn>, i32, i32)> {
        unsafe {
            let mut path = ptr::null_mut();
            let mut column = ptr::null_mut();
            let mut cell_x = mem::MaybeUninit::uninit();
            let mut cell_y = mem::MaybeUninit::uninit();
            let ret = from_glib(ffi::gtk_tree_view_get_path_at_pos(
                self.as_ref().to_glib_none().0,
                x,
                y,
                &mut path,
                &mut column,
                cell_x.as_mut_ptr(),
                cell_y.as_mut_ptr(),
            ));
            if ret {
                Some((
                    from_glib_full(path),
                    from_glib_none(column),
                    cell_x.assume_init(),
                    cell_y.assume_init(),
                ))
            } else {
                None
            }
        }
    }

    /// Retrieves whether the user can reorder the tree via drag-and-drop. See
    /// gtk_tree_view_set_reorderable().
    ///
    /// # Deprecated since 4.10
    ///
    /// Use [`ListView`][crate::ListView] or [`ColumnView`][crate::ColumnView] instead
    ///
    /// # Returns
    ///
    /// [`true`] if the tree can be reordered.
    #[cfg_attr(feature = "v4_10", deprecated = "Since 4.10")]
    #[allow(deprecated)]
    #[doc(alias = "gtk_tree_view_get_reorderable")]
    #[doc(alias = "get_reorderable")]
    fn is_reorderable(&self) -> bool {
        unsafe {
            from_glib(ffi::gtk_tree_view_get_reorderable(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Returns whether rubber banding is turned on for @self.  If the
    /// selection mode is [`SelectionMode::Multiple`][crate::SelectionMode::Multiple], rubber banding will allow the
    /// user to select multiple rows by dragging the mouse.
    ///
    /// # Deprecated since 4.10
    ///
    /// Use [`ListView`][crate::ListView] or [`ColumnView`][crate::ColumnView] instead
    ///
    /// # Returns
    ///
    /// [`true`] if rubber banding in @self is enabled.
    #[cfg_attr(feature = "v4_10", deprecated = "Since 4.10")]
    #[allow(deprecated)]
    #[doc(alias = "gtk_tree_view_get_rubber_banding")]
    #[doc(alias = "get_rubber_banding")]
    fn is_rubber_banding(&self) -> bool {
        unsafe {
            from_glib(ffi::gtk_tree_view_get_rubber_banding(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Gets the column searched on by the interactive search code.
    ///
    /// # Deprecated since 4.10
    ///
    /// Use [`ListView`][crate::ListView] or [`ColumnView`][crate::ColumnView] instead
    ///
    /// # Returns
    ///
    /// the column the interactive search code searches in.
    #[cfg_attr(feature = "v4_10", deprecated = "Since 4.10")]
    #[allow(deprecated)]
    #[doc(alias = "gtk_tree_view_get_search_column")]
    #[doc(alias = "get_search_column")]
    fn search_column(&self) -> i32 {
        unsafe { ffi::gtk_tree_view_get_search_column(self.as_ref().to_glib_none().0) }
    }

    /// Returns the [`Entry`][crate::Entry] which is currently in use as interactive search
    /// entry for @self.  In case the built-in entry is being used, [`None`]
    /// will be returned.
    ///
    /// # Deprecated since 4.10
    ///
    /// Use [`ListView`][crate::ListView] or [`ColumnView`][crate::ColumnView] instead
    ///
    /// # Returns
    ///
    /// the entry currently in use as search entry.
    #[cfg_attr(feature = "v4_10", deprecated = "Since 4.10")]
    #[allow(deprecated)]
    #[doc(alias = "gtk_tree_view_get_search_entry")]
    #[doc(alias = "get_search_entry")]
    fn search_entry(&self) -> Option<Editable> {
        unsafe {
            from_glib_none(ffi::gtk_tree_view_get_search_entry(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Gets the [`TreeSelection`][crate::TreeSelection] associated with @self.
    ///
    /// # Deprecated since 4.10
    ///
    /// Use [`ListView`][crate::ListView] or [`ColumnView`][crate::ColumnView] instead
    ///
    /// # Returns
    ///
    /// A [`TreeSelection`][crate::TreeSelection] object.
    #[cfg_attr(feature = "v4_10", deprecated = "Since 4.10")]
    #[allow(deprecated)]
    #[doc(alias = "gtk_tree_view_get_selection")]
    #[doc(alias = "get_selection")]
    fn selection(&self) -> TreeSelection {
        unsafe {
            from_glib_none(ffi::gtk_tree_view_get_selection(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Returns whether or not expanders are drawn in @self.
    ///
    /// # Deprecated since 4.10
    ///
    /// Use [`ListView`][crate::ListView] or [`ColumnView`][crate::ColumnView] instead
    ///
    /// # Returns
    ///
    /// [`true`] if expanders are drawn in @self, [`false`]
    /// otherwise.
    #[cfg_attr(feature = "v4_10", deprecated = "Since 4.10")]
    #[allow(deprecated)]
    #[doc(alias = "gtk_tree_view_get_show_expanders")]
    #[doc(alias = "get_show_expanders")]
    fn shows_expanders(&self) -> bool {
        unsafe {
            from_glib(ffi::gtk_tree_view_get_show_expanders(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Returns the column of @self’s model which is being used for
    /// displaying tooltips on @self’s rows.
    ///
    /// # Deprecated since 4.10
    ///
    /// Use [`ListView`][crate::ListView] or [`ColumnView`][crate::ColumnView] instead
    ///
    /// # Returns
    ///
    /// the index of the tooltip column that is currently being
    /// used, or -1 if this is disabled.
    #[cfg_attr(feature = "v4_10", deprecated = "Since 4.10")]
    #[allow(deprecated)]
    #[doc(alias = "gtk_tree_view_get_tooltip_column")]
    #[doc(alias = "get_tooltip_column")]
    fn tooltip_column(&self) -> i32 {
        unsafe { ffi::gtk_tree_view_get_tooltip_column(self.as_ref().to_glib_none().0) }
    }

    /// This function is supposed to be used in a ::query-tooltip
    /// signal handler for [`TreeView`][crate::TreeView]. The @x, @y and @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 ([`true`]) or not ([`false`]) for mouse tooltips. For keyboard
    /// tooltips the row returned will be the cursor row. When [`true`], then any of
    /// @model, @path and @iter which have been provided will be set to point to
    /// that row and the corresponding model. @x and @y will always be converted
    /// to be relative to @self’s bin_window if @keyboard_tooltip is [`false`].
    ///
    /// # Deprecated since 4.10
    ///
    /// Use [`ListView`][crate::ListView] or [`ColumnView`][crate::ColumnView] instead
    /// ## `x`
    /// the x coordinate (relative to widget coordinates)
    /// ## `y`
    /// the y coordinate (relative to widget coordinates)
    /// ## `keyboard_tip`
    /// whether this is a keyboard tooltip or not
    ///
    /// # Returns
    ///
    /// whether or not the given tooltip context points to a row
    ///
    /// ## `model`
    /// a pointer to
    ///   receive a [`TreeModel`][crate::TreeModel]
    ///
    /// ## `path`
    /// a pointer to receive a [`TreePath`][crate::TreePath]
    ///
    /// ## `iter`
    /// a pointer to receive a [`TreeIter`][crate::TreeIter]
    #[cfg_attr(feature = "v4_10", deprecated = "Since 4.10")]
    #[allow(deprecated)]
    #[doc(alias = "gtk_tree_view_get_tooltip_context")]
    #[doc(alias = "get_tooltip_context")]
    fn tooltip_context(
        &self,
        x: i32,
        y: i32,
        keyboard_tip: bool,
    ) -> Option<(Option<TreeModel>, TreePath, TreeIter)> {
        unsafe {
            let mut model = ptr::null_mut();
            let mut path = ptr::null_mut();
            let mut iter = TreeIter::uninitialized();
            let ret = from_glib(ffi::gtk_tree_view_get_tooltip_context(
                self.as_ref().to_glib_none().0,
                x,
                y,
                keyboard_tip.into_glib(),
                &mut model,
                &mut path,
                iter.to_glib_none_mut().0,
            ));
            if ret {
                Some((from_glib_none(model), from_glib_full(path), iter))
            } else {
                None
            }
        }
    }

    /// Sets @start_path and @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 gtk_tree_path_free() after use.
    ///
    /// # Deprecated since 4.10
    ///
    /// Use [`ListView`][crate::ListView] or [`ColumnView`][crate::ColumnView] instead
    ///
    /// # Returns
    ///
    /// [`true`], if valid paths were placed in @start_path and @end_path.
    ///
    /// ## `start_path`
    /// Return location for start of region
    ///
    /// ## `end_path`
    /// Return location for end of region
    #[cfg_attr(feature = "v4_10", deprecated = "Since 4.10")]
    #[allow(deprecated)]
    #[doc(alias = "gtk_tree_view_get_visible_range")]
    #[doc(alias = "get_visible_range")]
    fn visible_range(&self) -> Option<(TreePath, TreePath)> {
        unsafe {
            let mut start_path = ptr::null_mut();
            let mut end_path = ptr::null_mut();
            let ret = from_glib(ffi::gtk_tree_view_get_visible_range(
                self.as_ref().to_glib_none().0,
                &mut start_path,
                &mut end_path,
            ));
            if ret {
                Some((from_glib_full(start_path), from_glib_full(end_path)))
            } else {
                None
            }
        }
    }

    /// Fills @visible_rect with the currently-visible region of the
    /// buffer, in tree coordinates. Convert to bin_window coordinates with
    /// 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.
    ///
    /// # Deprecated since 4.10
    ///
    /// Use [`ListView`][crate::ListView] or [`ColumnView`][crate::ColumnView] instead
    ///
    /// # Returns
    ///
    ///
    /// ## `visible_rect`
    /// rectangle to fill
    #[cfg_attr(feature = "v4_10", deprecated = "Since 4.10")]
    #[allow(deprecated)]
    #[doc(alias = "gtk_tree_view_get_visible_rect")]
    #[doc(alias = "get_visible_rect")]
    fn visible_rect(&self) -> gdk::Rectangle {
        unsafe {
            let mut visible_rect = gdk::Rectangle::uninitialized();
            ffi::gtk_tree_view_get_visible_rect(
                self.as_ref().to_glib_none().0,
                visible_rect.to_glib_none_mut().0,
            );
            visible_rect
        }
    }

    /// This inserts the @column into the @self at @position.  If @position is
    /// -1, then the column is inserted at the end. If @self has
    /// “fixed_height” mode enabled, then @column must have its “sizing” property
    /// set to be GTK_TREE_VIEW_COLUMN_FIXED.
    ///
    /// # Deprecated since 4.10
    ///
    /// Use [`ListView`][crate::ListView] or [`ColumnView`][crate::ColumnView] instead
    /// ## `column`
    /// The [`TreeViewColumn`][crate::TreeViewColumn] to be inserted.
    /// ## `position`
    /// The position to insert @column in.
    ///
    /// # Returns
    ///
    /// The number of columns in @self after insertion.
    #[cfg_attr(feature = "v4_10", deprecated = "Since 4.10")]
    #[allow(deprecated)]
    #[doc(alias = "gtk_tree_view_insert_column")]
    fn insert_column(&self, column: &TreeViewColumn, position: i32) -> i32 {
        unsafe {
            ffi::gtk_tree_view_insert_column(
                self.as_ref().to_glib_none().0,
                column.to_glib_none().0,
                position,
            )
        }
    }

    /// Convenience function that inserts a new column into the [`TreeView`][crate::TreeView]
    /// with the given cell renderer and a `GtkTreeCellDataFunc` to set cell renderer
    /// attributes (normally using data from the model). See also
    /// gtk_tree_view_column_set_cell_data_func(), gtk_tree_view_column_pack_start().
    /// If @self has “fixed_height” mode enabled, then the new column will have its
    /// “sizing” property set to be GTK_TREE_VIEW_COLUMN_FIXED.
    ///
    /// # Deprecated since 4.10
    ///
    /// Use [`ListView`][crate::ListView] or [`ColumnView`][crate::ColumnView] instead
    /// ## `position`
    /// Position to insert, -1 for append
    /// ## `title`
    /// column title
    /// ## `cell`
    /// cell renderer for column
    /// ## `func`
    /// function to set attributes of cell renderer
    ///
    /// # Returns
    ///
    /// number of columns in the tree view post-insert
    #[cfg_attr(feature = "v4_10", deprecated = "Since 4.10")]
    #[allow(deprecated)]
    #[doc(alias = "gtk_tree_view_insert_column_with_data_func")]
    fn insert_column_with_data_func<
        P: Fn(&TreeViewColumn, &CellRenderer, &TreeModel, &TreeIter) + 'static,
    >(
        &self,
        position: i32,
        title: &str,
        cell: &impl IsA<CellRenderer>,
        func: P,
    ) -> i32 {
        let func_data: Box_<P> = Box_::new(func);
        unsafe extern "C" fn func_func<
            P: Fn(&TreeViewColumn, &CellRenderer, &TreeModel, &TreeIter) + 'static,
        >(
            tree_column: *mut ffi::GtkTreeViewColumn,
            cell: *mut ffi::GtkCellRenderer,
            tree_model: *mut ffi::GtkTreeModel,
            iter: *mut ffi::GtkTreeIter,
            data: glib::ffi::gpointer,
        ) {
            let tree_column = from_glib_borrow(tree_column);
            let cell = from_glib_borrow(cell);
            let tree_model = from_glib_borrow(tree_model);
            let iter = from_glib_borrow(iter);
            let callback: &P = &*(data as *mut _);
            (*callback)(&tree_column, &cell, &tree_model, &iter)
        }
        let func = Some(func_func::<P> as _);
        unsafe extern "C" fn dnotify_func<
            P: Fn(&TreeViewColumn, &CellRenderer, &TreeModel, &TreeIter) + 'static,
        >(
            data: glib::ffi::gpointer,
        ) {
            let _callback: Box_<P> = Box_::from_raw(data as *mut _);
        }
        let destroy_call6 = Some(dnotify_func::<P> as _);
        let super_callback0: Box_<P> = func_data;
        unsafe {
            ffi::gtk_tree_view_insert_column_with_data_func(
                self.as_ref().to_glib_none().0,
                position,
                title.to_glib_none().0,
                cell.as_ref().to_glib_none().0,
                func,
                Box_::into_raw(super_callback0) as *mut _,
                destroy_call6,
            )
        }
    }

    /// Determine whether the point (@x, @y) in @self 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 @x and @y coordinate that are provided must be relative to bin_window
    /// coordinates.  Widget-relative coordinates must be converted using
    /// gtk_tree_view_convert_widget_to_bin_window_coords().
    ///
    /// For converting widget coordinates (eg. the ones you get from
    /// GtkWidget::query-tooltip), please see
    /// gtk_tree_view_convert_widget_to_bin_window_coords().
    ///
    /// The @path, @column, @cell_x and @cell_y arguments will be filled in
    /// likewise as for gtk_tree_view_get_path_at_pos().  Please see
    /// gtk_tree_view_get_path_at_pos() for more information.
    ///
    /// # Deprecated since 4.10
    ///
    /// Use [`ListView`][crate::ListView] or [`ColumnView`][crate::ColumnView] instead
    /// ## `x`
    /// The x position to be identified (relative to bin_window)
    /// ## `y`
    /// The y position to be identified (relative to bin_window)
    ///
    /// # Returns
    ///
    /// [`true`] if the area at the given coordinates is blank,
    /// [`false`] otherwise.
    ///
    /// ## `path`
    /// A pointer to a [`TreePath`][crate::TreePath] pointer to
    ///   be filled in
    ///
    /// ## `column`
    /// A pointer to a
    ///   [`TreeViewColumn`][crate::TreeViewColumn] pointer to be filled in
    ///
    /// ## `cell_x`
    /// A pointer where the X coordinate relative to the
    ///   cell can be placed
    ///
    /// ## `cell_y`
    /// A pointer where the Y coordinate relative to the
    ///   cell can be placed
    #[cfg_attr(feature = "v4_10", deprecated = "Since 4.10")]
    #[allow(deprecated)]
    #[doc(alias = "gtk_tree_view_is_blank_at_pos")]
    fn is_blank_at_pos(
        &self,
        x: i32,
        y: i32,
    ) -> Option<(Option<TreePath>, Option<TreeViewColumn>, i32, i32)> {
        unsafe {
            let mut path = ptr::null_mut();
            let mut column = ptr::null_mut();
            let mut cell_x = mem::MaybeUninit::uninit();
            let mut cell_y = mem::MaybeUninit::uninit();
            let ret = from_glib(ffi::gtk_tree_view_is_blank_at_pos(
                self.as_ref().to_glib_none().0,
                x,
                y,
                &mut path,
                &mut column,
                cell_x.as_mut_ptr(),
                cell_y.as_mut_ptr(),
            ));
            if ret {
                Some((
                    from_glib_full(path),
                    from_glib_none(column),
                    cell_x.assume_init(),
                    cell_y.assume_init(),
                ))
            } else {
                None
            }
        }
    }

    /// Returns whether a rubber banding operation is currently being done
    /// in @self.
    ///
    /// # Deprecated since 4.10
    ///
    /// Use [`ListView`][crate::ListView] or [`ColumnView`][crate::ColumnView] instead
    ///
    /// # Returns
    ///
    /// [`true`] if a rubber banding operation is currently being
    /// done in @self.
    #[cfg_attr(feature = "v4_10", deprecated = "Since 4.10")]
    #[allow(deprecated)]
    #[doc(alias = "gtk_tree_view_is_rubber_banding_active")]
    fn is_rubber_banding_active(&self) -> bool {
        unsafe {
            from_glib(ffi::gtk_tree_view_is_rubber_banding_active(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Calls @func on all expanded rows.
    ///
    /// # Deprecated since 4.10
    ///
    /// Use [`ListView`][crate::ListView] or [`ColumnView`][crate::ColumnView] instead
    /// ## `func`
    /// A function to be called
    #[cfg_attr(feature = "v4_10", deprecated = "Since 4.10")]
    #[allow(deprecated)]
    #[doc(alias = "gtk_tree_view_map_expanded_rows")]
    fn map_expanded_rows<P: FnMut(&TreeView, &TreePath)>(&self, func: P) {
        let func_data: P = func;
        unsafe extern "C" fn func_func<P: FnMut(&TreeView, &TreePath)>(
            tree_view: *mut ffi::GtkTreeView,
            path: *mut ffi::GtkTreePath,
            user_data: glib::ffi::gpointer,
        ) {
            let tree_view = from_glib_borrow(tree_view);
            let path = from_glib_borrow(path);
            let callback: *mut P = user_data as *const _ as usize as *mut P;
            (*callback)(&tree_view, &path)
        }
        let func = Some(func_func::<P> as _);
        let super_callback0: &P = &func_data;
        unsafe {
            ffi::gtk_tree_view_map_expanded_rows(
                self.as_ref().to_glib_none().0,
                func,
                super_callback0 as *const _ as usize as *mut _,
            );
        }
    }

    /// Moves @column to be after to @base_column.  If @base_column is [`None`], then
    /// @column is placed in the first position.
    ///
    /// # Deprecated since 4.10
    ///
    /// Use [`ListView`][crate::ListView] or [`ColumnView`][crate::ColumnView] instead
    /// ## `column`
    /// The [`TreeViewColumn`][crate::TreeViewColumn] to be moved.
    /// ## `base_column`
    /// The [`TreeViewColumn`][crate::TreeViewColumn] to be moved relative to
    #[cfg_attr(feature = "v4_10", deprecated = "Since 4.10")]
    #[allow(deprecated)]
    #[doc(alias = "gtk_tree_view_move_column_after")]
    fn move_column_after(&self, column: &TreeViewColumn, base_column: Option<&TreeViewColumn>) {
        unsafe {
            ffi::gtk_tree_view_move_column_after(
                self.as_ref().to_glib_none().0,
                column.to_glib_none().0,
                base_column.to_glib_none().0,
            );
        }
    }

    /// Removes @column from @self.
    ///
    /// # Deprecated since 4.10
    ///
    /// Use [`ListView`][crate::ListView] or [`ColumnView`][crate::ColumnView] instead
    /// ## `column`
    /// The [`TreeViewColumn`][crate::TreeViewColumn] to remove.
    ///
    /// # Returns
    ///
    /// The number of columns in @self after removing.
    #[cfg_attr(feature = "v4_10", deprecated = "Since 4.10")]
    #[allow(deprecated)]
    #[doc(alias = "gtk_tree_view_remove_column")]
    fn remove_column(&self, column: &TreeViewColumn) -> i32 {
        unsafe {
            ffi::gtk_tree_view_remove_column(
                self.as_ref().to_glib_none().0,
                column.to_glib_none().0,
            )
        }
    }

    /// Activates the cell determined by @path and @column.
    ///
    /// # Deprecated since 4.10
    ///
    /// Use [`ListView`][crate::ListView] or [`ColumnView`][crate::ColumnView] instead
    /// ## `path`
    /// The [`TreePath`][crate::TreePath] to be activated.
    /// ## `column`
    /// The [`TreeViewColumn`][crate::TreeViewColumn] to be activated.
    #[cfg_attr(feature = "v4_10", deprecated = "Since 4.10")]
    #[allow(deprecated)]
    #[doc(alias = "gtk_tree_view_row_activated")]
    fn row_activated(&self, path: &TreePath, column: Option<&TreeViewColumn>) {
        unsafe {
            ffi::gtk_tree_view_row_activated(
                self.as_ref().to_glib_none().0,
                mut_override(path.to_glib_none().0),
                column.to_glib_none().0,
            );
        }
    }

    /// Returns [`true`] if the node pointed to by @path is expanded in @self.
    ///
    /// # Deprecated since 4.10
    ///
    /// Use [`ListView`][crate::ListView] or [`ColumnView`][crate::ColumnView] instead
    /// ## `path`
    /// A [`TreePath`][crate::TreePath] to test expansion state.
    ///
    /// # Returns
    ///
    /// [`true`] if #path is expanded.
    #[cfg_attr(feature = "v4_10", deprecated = "Since 4.10")]
    #[allow(deprecated)]
    #[doc(alias = "gtk_tree_view_row_expanded")]
    fn row_expanded(&self, path: &TreePath) -> bool {
        unsafe {
            from_glib(ffi::gtk_tree_view_row_expanded(
                self.as_ref().to_glib_none().0,
                mut_override(path.to_glib_none().0),
            ))
        }
    }

    /// Moves the alignments of @self to the position specified by @column and
    /// @path.  If @column is [`None`], then no horizontal scrolling occurs.  Likewise,
    /// if @path is [`None`] no vertical scrolling occurs.  At a minimum, one of @column
    /// or @path need to be non-[`None`].  @row_align determines where the row is
    /// placed, and @col_align determines where @column is placed.  Both are expected
    /// to be between 0.0 and 1.0. 0.0 means left/top alignment, 1.0 means
    /// right/bottom alignment, 0.5 means center.
    ///
    /// If @use_align is [`false`], then the alignment arguments are ignored, and the
    /// tree does the minimum amount of work to scroll the cell onto the screen.
    /// This means that the cell will be scrolled to the edge closest to its current
    /// position.  If the cell is currently visible on the screen, nothing is done.
    ///
    /// This function only works if the model is set, and @path is a valid row on the
    /// model.  If the model changes before the @self is realized, the centered
    /// path will be modified to reflect this change.
    ///
    /// # Deprecated since 4.10
    ///
    /// Use [`ListView`][crate::ListView] or [`ColumnView`][crate::ColumnView] instead
    /// ## `path`
    /// The path of the row to move to
    /// ## `column`
    /// The [`TreeViewColumn`][crate::TreeViewColumn] to move horizontally to
    /// ## `use_align`
    /// whether to use alignment arguments, or [`false`].
    /// ## `row_align`
    /// The vertical alignment of the row specified by @path.
    /// ## `col_align`
    /// The horizontal alignment of the column specified by @column.
    #[cfg_attr(feature = "v4_10", deprecated = "Since 4.10")]
    #[allow(deprecated)]
    #[doc(alias = "gtk_tree_view_scroll_to_cell")]
    fn scroll_to_cell(
        &self,
        path: Option<&TreePath>,
        column: Option<&TreeViewColumn>,
        use_align: bool,
        row_align: f32,
        col_align: f32,
    ) {
        unsafe {
            ffi::gtk_tree_view_scroll_to_cell(
                self.as_ref().to_glib_none().0,
                mut_override(path.to_glib_none().0),
                column.to_glib_none().0,
                use_align.into_glib(),
                row_align,
                col_align,
            );
        }
    }

    /// Scrolls the tree view such that the top-left corner of the visible
    /// area is @tree_x, @tree_y, where @tree_x and @tree_y are specified
    /// in tree coordinates.  The @self must be realized before
    /// this function is called.  If it isn't, you probably want to be
    /// using gtk_tree_view_scroll_to_cell().
    ///
    /// If either @tree_x or @tree_y are -1, then that direction isn’t scrolled.
    ///
    /// # Deprecated since 4.10
    ///
    /// Use [`ListView`][crate::ListView] or [`ColumnView`][crate::ColumnView] instead
    /// ## `tree_x`
    /// X coordinate of new top-left pixel of visible area, or -1
    /// ## `tree_y`
    /// Y coordinate of new top-left pixel of visible area, or -1
    #[cfg_attr(feature = "v4_10", deprecated = "Since 4.10")]
    #[allow(deprecated)]
    #[doc(alias = "gtk_tree_view_scroll_to_point")]
    fn scroll_to_point(&self, tree_x: i32, tree_y: i32) {
        unsafe {
            ffi::gtk_tree_view_scroll_to_point(self.as_ref().to_glib_none().0, tree_x, tree_y);
        }
    }

    /// Cause the [`TreeView`][crate::TreeView]::row-activated signal to be emitted
    /// on a single click instead of a double click.
    ///
    /// # Deprecated since 4.10
    ///
    /// Use [`ListView`][crate::ListView] or [`ColumnView`][crate::ColumnView] instead
    /// ## `single`
    /// [`true`] to emit row-activated on a single click
    #[cfg_attr(feature = "v4_10", deprecated = "Since 4.10")]
    #[allow(deprecated)]
    #[doc(alias = "gtk_tree_view_set_activate_on_single_click")]
    fn set_activate_on_single_click(&self, single: bool) {
        unsafe {
            ffi::gtk_tree_view_set_activate_on_single_click(
                self.as_ref().to_glib_none().0,
                single.into_glib(),
            );
        }
    }

    /// Sets a user function for determining where a column may be dropped when
    /// dragged.  This function is called on every column pair in turn at the
    /// beginning of a column drag to determine where a drop can take place.  The
    /// arguments passed to @func are: the @self, the [`TreeViewColumn`][crate::TreeViewColumn] being
    /// dragged, the two [`TreeViewColumn`][crate::TreeViewColumn]s determining the drop spot, and
    /// @user_data.  If either of the [`TreeViewColumn`][crate::TreeViewColumn] arguments for the drop spot
    /// are [`None`], then they indicate an edge.  If @func is set to be [`None`], then
    /// @self reverts to the default behavior of allowing all columns to be
    /// dropped everywhere.
    ///
    /// # Deprecated since 4.10
    ///
    /// Use [`ListView`][crate::ListView] or [`ColumnView`][crate::ColumnView] instead
    /// ## `func`
    /// A function to determine which columns are reorderable
    #[cfg_attr(feature = "v4_10", deprecated = "Since 4.10")]
    #[allow(deprecated)]
    #[doc(alias = "gtk_tree_view_set_column_drag_function")]
    fn set_column_drag_function(
        &self,
        func: Option<
            Box_<
                dyn Fn(&TreeView, &TreeViewColumn, &TreeViewColumn, &TreeViewColumn) -> bool
                    + 'static,
            >,
        >,
    ) {
        let func_data: Box_<
            Option<
                Box_<
                    dyn Fn(&TreeView, &TreeViewColumn, &TreeViewColumn, &TreeViewColumn) -> bool
                        + 'static,
                >,
            >,
        > = Box_::new(func);
        unsafe extern "C" fn func_func(
            tree_view: *mut ffi::GtkTreeView,
            column: *mut ffi::GtkTreeViewColumn,
            prev_column: *mut ffi::GtkTreeViewColumn,
            next_column: *mut ffi::GtkTreeViewColumn,
            data: glib::ffi::gpointer,
        ) -> glib::ffi::gboolean {
            let tree_view = from_glib_borrow(tree_view);
            let column = from_glib_borrow(column);
            let prev_column = from_glib_borrow(prev_column);
            let next_column = from_glib_borrow(next_column);
            let callback: &Option<
                Box_<
                    dyn Fn(&TreeView, &TreeViewColumn, &TreeViewColumn, &TreeViewColumn) -> bool
                        + 'static,
                >,
            > = &*(data as *mut _);
            if let Some(ref callback) = *callback {
                callback(&tree_view, &column, &prev_column, &next_column)
            } else {
                panic!("cannot get closure...")
            }
            .into_glib()
        }
        let func = if func_data.is_some() {
            Some(func_func as _)
        } else {
            None
        };
        unsafe extern "C" fn destroy_func(data: glib::ffi::gpointer) {
            let _callback: Box_<
                Option<
                    Box_<
                        dyn Fn(&TreeView, &TreeViewColumn, &TreeViewColumn, &TreeViewColumn) -> bool
                            + 'static,
                    >,
                >,
            > = Box_::from_raw(data as *mut _);
        }
        let destroy_call3 = Some(destroy_func as _);
        let super_callback0: Box_<
            Option<
                Box_<
                    dyn Fn(&TreeView, &TreeViewColumn, &TreeViewColumn, &TreeViewColumn) -> bool
                        + 'static,
                >,
            >,
        > = func_data;
        unsafe {
            ffi::gtk_tree_view_set_column_drag_function(
                self.as_ref().to_glib_none().0,
                func,
                Box_::into_raw(super_callback0) as *mut _,
                destroy_call3,
            );
        }
    }

    /// Sets the current keyboard focus to be at @path, and selects it.  This is
    /// useful when you want to focus the user’s attention on a particular row.  If
    /// @focus_column is not [`None`], then focus is given to the column specified by
    /// it. Additionally, if @focus_column is specified, and @start_editing is
    /// [`true`], then editing should be started in the specified cell.
    /// This function is often followed by @gtk_widget_grab_focus (@self)
    /// in order to give keyboard focus to the widget.  Please note that editing
    /// can only happen when the widget is realized.
    ///
    /// If @path is invalid for @model, the current cursor (if any) will be unset
    /// and the function will return without failing.
    ///
    /// # Deprecated since 4.10
    ///
    /// Use [`ListView`][crate::ListView] or [`ColumnView`][crate::ColumnView] instead
    /// ## `path`
    /// A [`TreePath`][crate::TreePath]
    /// ## `focus_column`
    /// A [`TreeViewColumn`][crate::TreeViewColumn]
    /// ## `start_editing`
    /// [`true`] if the specified cell should start being edited.
    #[cfg_attr(feature = "v4_10", deprecated = "Since 4.10")]
    #[allow(deprecated)]
    #[doc(alias = "gtk_tree_view_set_cursor")]
    fn set_cursor(
        &self,
        path: &TreePath,
        focus_column: Option<&TreeViewColumn>,
        start_editing: bool,
    ) {
        unsafe {
            ffi::gtk_tree_view_set_cursor(
                self.as_ref().to_glib_none().0,
                mut_override(path.to_glib_none().0),
                focus_column.to_glib_none().0,
                start_editing.into_glib(),
            );
        }
    }

    /// Sets the current keyboard focus to be at @path, and selects it.  This is
    /// useful when you want to focus the user’s attention on a particular row.  If
    /// @focus_column is not [`None`], then focus is given to the column specified by
    /// it. If @focus_column and @focus_cell are not [`None`], and @focus_column
    /// contains 2 or more editable or activatable cells, then focus is given to
    /// the cell specified by @focus_cell. Additionally, if @focus_column is
    /// specified, and @start_editing is [`true`], then editing should be started in
    /// the specified cell.  This function is often followed by
    /// @gtk_widget_grab_focus (@self) in order to give keyboard focus to the
    /// widget.  Please note that editing can only happen when the widget is
    /// realized.
    ///
    /// If @path is invalid for @model, the current cursor (if any) will be unset
    /// and the function will return without failing.
    ///
    /// # Deprecated since 4.10
    ///
    /// Use [`ListView`][crate::ListView] or [`ColumnView`][crate::ColumnView] instead
    /// ## `path`
    /// A [`TreePath`][crate::TreePath]
    /// ## `focus_column`
    /// A [`TreeViewColumn`][crate::TreeViewColumn]
    /// ## `focus_cell`
    /// A [`CellRenderer`][crate::CellRenderer]
    /// ## `start_editing`
    /// [`true`] if the specified cell should start being edited.
    #[cfg_attr(feature = "v4_10", deprecated = "Since 4.10")]
    #[allow(deprecated)]
    #[doc(alias = "gtk_tree_view_set_cursor_on_cell")]
    fn set_cursor_on_cell(
        &self,
        path: &TreePath,
        focus_column: Option<&TreeViewColumn>,
        focus_cell: Option<&impl IsA<CellRenderer>>,
        start_editing: bool,
    ) {
        unsafe {
            ffi::gtk_tree_view_set_cursor_on_cell(
                self.as_ref().to_glib_none().0,
                mut_override(path.to_glib_none().0),
                focus_column.to_glib_none().0,
                focus_cell.map(|p| p.as_ref()).to_glib_none().0,
                start_editing.into_glib(),
            );
        }
    }

    /// Sets the row that is highlighted for feedback.
    /// If @path is [`None`], an existing highlight is removed.
    ///
    /// # Deprecated since 4.10
    ///
    /// Use [`ListView`][crate::ListView] or [`ColumnView`][crate::ColumnView] instead
    /// ## `path`
    /// The path of the row to highlight
    /// ## `pos`
    /// Specifies whether to drop before, after or into the row
    #[cfg_attr(feature = "v4_10", deprecated = "Since 4.10")]
    #[allow(deprecated)]
    #[doc(alias = "gtk_tree_view_set_drag_dest_row")]
    fn set_drag_dest_row(&self, path: Option<&TreePath>, pos: TreeViewDropPosition) {
        unsafe {
            ffi::gtk_tree_view_set_drag_dest_row(
                self.as_ref().to_glib_none().0,
                mut_override(path.to_glib_none().0),
                pos.into_glib(),
            );
        }
    }

    /// If @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 [`false`], the user can still initiate a search
    /// using the “start-interactive-search” key binding.
    ///
    /// # Deprecated since 4.10
    ///
    /// Use [`ListView`][crate::ListView] or [`ColumnView`][crate::ColumnView] instead
    /// ## `enable_search`
    /// [`true`], if the user can search interactively
    #[cfg_attr(feature = "v4_10", deprecated = "Since 4.10")]
    #[allow(deprecated)]
    #[doc(alias = "gtk_tree_view_set_enable_search")]
    fn set_enable_search(&self, enable_search: bool) {
        unsafe {
            ffi::gtk_tree_view_set_enable_search(
                self.as_ref().to_glib_none().0,
                enable_search.into_glib(),
            );
        }
    }

    /// Sets whether to draw lines interconnecting the expanders in @self.
    /// This does not have any visible effects for lists.
    ///
    /// # Deprecated since 4.10
    ///
    /// Use [`ListView`][crate::ListView] or [`ColumnView`][crate::ColumnView] instead
    /// ## `enabled`
    /// [`true`] to enable tree line drawing, [`false`] otherwise.
    #[cfg_attr(feature = "v4_10", deprecated = "Since 4.10")]
    #[allow(deprecated)]
    #[doc(alias = "gtk_tree_view_set_enable_tree_lines")]
    fn set_enable_tree_lines(&self, enabled: bool) {
        unsafe {
            ffi::gtk_tree_view_set_enable_tree_lines(
                self.as_ref().to_glib_none().0,
                enabled.into_glib(),
            );
        }
    }

    /// Sets the column to draw the expander arrow at. It must be in @self.
    /// If @column is [`None`], then the expander arrow is always at the first
    /// visible column.
    ///
    /// If you do not want expander arrow to appear in your tree, set the
    /// expander column to a hidden column.
    ///
    /// # Deprecated since 4.10
    ///
    /// Use [`ListView`][crate::ListView] or [`ColumnView`][crate::ColumnView] instead
    /// ## `column`
    /// [`None`], or the column to draw the expander arrow at.
    #[cfg_attr(feature = "v4_10", deprecated = "Since 4.10")]
    #[allow(deprecated)]
    #[doc(alias = "gtk_tree_view_set_expander_column")]
    fn set_expander_column(&self, column: Option<&TreeViewColumn>) {
        unsafe {
            ffi::gtk_tree_view_set_expander_column(
                self.as_ref().to_glib_none().0,
                column.to_glib_none().0,
            );
        }
    }

    /// Enables or disables the fixed height mode of @self.
    /// Fixed height mode speeds up [`TreeView`][crate::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 [`TreeViewColumnSizing::Fixed`][crate::TreeViewColumnSizing::Fixed].
    ///
    /// # Deprecated since 4.10
    ///
    /// Use [`ListView`][crate::ListView] or [`ColumnView`][crate::ColumnView] instead
    /// ## `enable`
    /// [`true`] to enable fixed height mode
    #[cfg_attr(feature = "v4_10", deprecated = "Since 4.10")]
    #[allow(deprecated)]
    #[doc(alias = "gtk_tree_view_set_fixed_height_mode")]
    fn set_fixed_height_mode(&self, enable: bool) {
        unsafe {
            ffi::gtk_tree_view_set_fixed_height_mode(
                self.as_ref().to_glib_none().0,
                enable.into_glib(),
            );
        }
    }

    /// Sets which grid lines to draw in @self.
    ///
    /// # Deprecated since 4.10
    ///
    /// Use [`ListView`][crate::ListView] or [`ColumnView`][crate::ColumnView] instead
    /// ## `grid_lines`
    /// a [`TreeView`][crate::TreeView]GridLines value indicating which grid lines to
    /// enable.
    #[cfg_attr(feature = "v4_10", deprecated = "Since 4.10")]
    #[allow(deprecated)]
    #[doc(alias = "gtk_tree_view_set_grid_lines")]
    fn set_grid_lines(&self, grid_lines: TreeViewGridLines) {
        unsafe {
            ffi::gtk_tree_view_set_grid_lines(
                self.as_ref().to_glib_none().0,
                grid_lines.into_glib(),
            );
        }
    }

    /// Allow the column title buttons to be clicked.
    ///
    /// # Deprecated since 4.10
    ///
    /// Use [`ListView`][crate::ListView] or [`ColumnView`][crate::ColumnView] instead
    /// ## `setting`
    /// [`true`] if the columns are clickable.
    #[cfg_attr(feature = "v4_10", deprecated = "Since 4.10")]
    #[allow(deprecated)]
    #[doc(alias = "gtk_tree_view_set_headers_clickable")]
    fn set_headers_clickable(&self, setting: bool) {
        unsafe {
            ffi::gtk_tree_view_set_headers_clickable(
                self.as_ref().to_glib_none().0,
                setting.into_glib(),
            );
        }
    }

    /// Sets the visibility state of the headers.
    ///
    /// # Deprecated since 4.10
    ///
    /// Use [`ListView`][crate::ListView] or [`ColumnView`][crate::ColumnView] instead
    /// ## `headers_visible`
    /// [`true`] if the headers are visible
    #[cfg_attr(feature = "v4_10", deprecated = "Since 4.10")]
    #[allow(deprecated)]
    #[doc(alias = "gtk_tree_view_set_headers_visible")]
    fn set_headers_visible(&self, headers_visible: bool) {
        unsafe {
            ffi::gtk_tree_view_set_headers_visible(
                self.as_ref().to_glib_none().0,
                headers_visible.into_glib(),
            );
        }
    }

    /// Enables or disables the hover expansion mode of @self.
    /// Hover expansion makes rows expand or collapse if the pointer
    /// moves over them.
    ///
    /// # Deprecated since 4.10
    ///
    /// Use [`ListView`][crate::ListView] or [`ColumnView`][crate::ColumnView] instead
    /// ## `expand`
    /// [`true`] to enable hover selection mode
    #[cfg_attr(feature = "v4_10", deprecated = "Since 4.10")]
    #[allow(deprecated)]
    #[doc(alias = "gtk_tree_view_set_hover_expand")]
    fn set_hover_expand(&self, expand: bool) {
        unsafe {
            ffi::gtk_tree_view_set_hover_expand(self.as_ref().to_glib_none().0, expand.into_glib());
        }
    }

    /// Enables or disables the hover selection mode of @self.
    /// Hover selection makes the selected row follow the pointer.
    /// Currently, this works only for the selection modes
    /// [`SelectionMode::Single`][crate::SelectionMode::Single] and [`SelectionMode::Browse`][crate::SelectionMode::Browse].
    ///
    /// # Deprecated since 4.10
    ///
    /// Use [`ListView`][crate::ListView] or [`ColumnView`][crate::ColumnView] instead
    /// ## `hover`
    /// [`true`] to enable hover selection mode
    #[cfg_attr(feature = "v4_10", deprecated = "Since 4.10")]
    #[allow(deprecated)]
    #[doc(alias = "gtk_tree_view_set_hover_selection")]
    fn set_hover_selection(&self, hover: bool) {
        unsafe {
            ffi::gtk_tree_view_set_hover_selection(
                self.as_ref().to_glib_none().0,
                hover.into_glib(),
            );
        }
    }

    /// Sets the amount of extra indentation for child levels to use in @self
    /// 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.
    ///
    /// # Deprecated since 4.10
    ///
    /// Use [`ListView`][crate::ListView] or [`ColumnView`][crate::ColumnView] instead
    /// ## `indentation`
    /// the amount, in pixels, of extra indentation in @self.
    #[cfg_attr(feature = "v4_10", deprecated = "Since 4.10")]
    #[allow(deprecated)]
    #[doc(alias = "gtk_tree_view_set_level_indentation")]
    fn set_level_indentation(&self, indentation: i32) {
        unsafe {
            ffi::gtk_tree_view_set_level_indentation(self.as_ref().to_glib_none().0, indentation);
        }
    }

    /// Sets the model for a [`TreeView`][crate::TreeView].  If the @self already has a model
    /// set, it will remove it before setting the new model.  If @model is [`None`],
    /// then it will unset the old model.
    ///
    /// # Deprecated since 4.10
    ///
    /// Use [`ListView`][crate::ListView] or [`ColumnView`][crate::ColumnView] instead
    /// ## `model`
    /// The model.
    #[cfg_attr(feature = "v4_10", deprecated = "Since 4.10")]
    #[allow(deprecated)]
    #[doc(alias = "gtk_tree_view_set_model")]
    fn set_model(&self, model: Option<&impl IsA<TreeModel>>) {
        unsafe {
            ffi::gtk_tree_view_set_model(
                self.as_ref().to_glib_none().0,
                model.map(|p| p.as_ref()).to_glib_none().0,
            );
        }
    }

    /// This function is a convenience function to allow you to reorder
    /// models that support the `GtkTreeDragSourceIface` and the
    /// `GtkTreeDragDestIface`.  Both [`TreeStore`][crate::TreeStore] and [`ListStore`][crate::ListStore] support
    /// these.  If @reorderable is [`true`], then the user can reorder the
    /// model by dragging and dropping rows. The developer can listen to
    /// these changes by connecting to the model’s `GtkTreeModel::row-inserted`
    /// and `GtkTreeModel::row-deleted` signals. The reordering is implemented
    /// by setting up the tree view as a drag source and destination.
    /// Therefore, drag and drop can not be used in a reorderable view for any
    /// other purpose.
    ///
    /// This function does not give you any degree of control over the order -- any
    /// reordering is allowed.  If more control is needed, you should probably
    /// handle drag and drop manually.
    ///
    /// # Deprecated since 4.10
    ///
    /// Use [`ListView`][crate::ListView] or [`ColumnView`][crate::ColumnView] instead
    /// ## `reorderable`
    /// [`true`], if the tree can be reordered.
    #[cfg_attr(feature = "v4_10", deprecated = "Since 4.10")]
    #[allow(deprecated)]
    #[doc(alias = "gtk_tree_view_set_reorderable")]
    fn set_reorderable(&self, reorderable: bool) {
        unsafe {
            ffi::gtk_tree_view_set_reorderable(
                self.as_ref().to_glib_none().0,
                reorderable.into_glib(),
            );
        }
    }

    /// 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 [`None`], no separators are drawn. This is the default value.
    ///
    /// # Deprecated since 4.10
    ///
    /// Use [`ListView`][crate::ListView] or [`ColumnView`][crate::ColumnView] instead
    /// ## `func`
    /// a [`TreeView`][crate::TreeView]RowSeparatorFunc
    #[cfg_attr(feature = "v4_10", deprecated = "Since 4.10")]
    #[allow(deprecated)]
    #[doc(alias = "gtk_tree_view_set_row_separator_func")]
    fn set_row_separator_func<P: Fn(&TreeModel, &TreeIter) -> bool + 'static>(&self, func: P) {
        let func_data: Box_<P> = Box_::new(func);
        unsafe extern "C" fn func_func<P: Fn(&TreeModel, &TreeIter) -> bool + 'static>(
            model: *mut ffi::GtkTreeModel,
            iter: *mut ffi::GtkTreeIter,
            data: glib::ffi::gpointer,
        ) -> glib::ffi::gboolean {
            let model = from_glib_borrow(model);
            let iter = from_glib_borrow(iter);
            let callback: &P = &*(data as *mut _);
            (*callback)(&model, &iter).into_glib()
        }
        let func = Some(func_func::<P> as _);
        unsafe extern "C" fn destroy_func<P: Fn(&TreeModel, &TreeIter) -> bool + 'static>(
            data: glib::ffi::gpointer,
        ) {
            let _callback: Box_<P> = Box_::from_raw(data as *mut _);
        }
        let destroy_call3 = Some(destroy_func::<P> as _);
        let super_callback0: Box_<P> = func_data;
        unsafe {
            ffi::gtk_tree_view_set_row_separator_func(
                self.as_ref().to_glib_none().0,
                func,
                Box_::into_raw(super_callback0) as *mut _,
                destroy_call3,
            );
        }
    }

    /// Enables or disables rubber banding in @self.  If the selection mode
    /// is [`SelectionMode::Multiple`][crate::SelectionMode::Multiple], rubber banding will allow the user to select
    /// multiple rows by dragging the mouse.
    ///
    /// # Deprecated since 4.10
    ///
    /// Use [`ListView`][crate::ListView] or [`ColumnView`][crate::ColumnView] instead
    /// ## `enable`
    /// [`true`] to enable rubber banding
    #[cfg_attr(feature = "v4_10", deprecated = "Since 4.10")]
    #[allow(deprecated)]
    #[doc(alias = "gtk_tree_view_set_rubber_banding")]
    fn set_rubber_banding(&self, enable: bool) {
        unsafe {
            ffi::gtk_tree_view_set_rubber_banding(
                self.as_ref().to_glib_none().0,
                enable.into_glib(),
            );
        }
    }

    /// Sets @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 @column refers to a column of the current model. The search
    /// column is reset to -1 when the model is changed.
    ///
    /// # Deprecated since 4.10
    ///
    /// Use [`ListView`][crate::ListView] or [`ColumnView`][crate::ColumnView] instead
    /// ## `column`
    /// the column of the model to search in, or -1 to disable searching
    #[cfg_attr(feature = "v4_10", deprecated = "Since 4.10")]
    #[allow(deprecated)]
    #[doc(alias = "gtk_tree_view_set_search_column")]
    fn set_search_column(&self, column: i32) {
        unsafe {
            ffi::gtk_tree_view_set_search_column(self.as_ref().to_glib_none().0, column);
        }
    }

    /// Sets the entry which the interactive search code will use for this
    /// @self.  This is useful when you want to provide a search entry
    /// in our interface at all time at a fixed position.  Passing [`None`] for
    /// @entry will make the interactive search code use the built-in popup
    /// entry again.
    ///
    /// # Deprecated since 4.10
    ///
    /// Use [`ListView`][crate::ListView] or [`ColumnView`][crate::ColumnView] instead
    /// ## `entry`
    /// the entry the interactive search code of @self should use
    #[cfg_attr(feature = "v4_10", deprecated = "Since 4.10")]
    #[allow(deprecated)]
    #[doc(alias = "gtk_tree_view_set_search_entry")]
    fn set_search_entry(&self, entry: Option<&impl IsA<Editable>>) {
        unsafe {
            ffi::gtk_tree_view_set_search_entry(
                self.as_ref().to_glib_none().0,
                entry.map(|p| p.as_ref()).to_glib_none().0,
            );
        }
    }

    /// Sets the compare function for the interactive search capabilities; note
    /// that somewhat like strcmp() returning 0 for equality
    /// [`TreeView`][crate::TreeView]SearchEqualFunc returns [`false`] on matches.
    ///
    /// # Deprecated since 4.10
    ///
    /// Use [`ListView`][crate::ListView] or [`ColumnView`][crate::ColumnView] instead
    /// ## `search_equal_func`
    /// the compare function to use during the search
    #[cfg_attr(feature = "v4_10", deprecated = "Since 4.10")]
    #[allow(deprecated)]
    #[doc(alias = "gtk_tree_view_set_search_equal_func")]
    fn set_search_equal_func<P: Fn(&TreeModel, i32, &str, &TreeIter) -> bool + 'static>(
        &self,
        search_equal_func: P,
    ) {
        let search_equal_func_data: Box_<P> = Box_::new(search_equal_func);
        unsafe extern "C" fn search_equal_func_func<
            P: Fn(&TreeModel, i32, &str, &TreeIter) -> bool + 'static,
        >(
            model: *mut ffi::GtkTreeModel,
            column: libc::c_int,
            key: *const libc::c_char,
            iter: *mut ffi::GtkTreeIter,
            search_data: glib::ffi::gpointer,
        ) -> glib::ffi::gboolean {
            let model = from_glib_borrow(model);
            let key: Borrowed<glib::GString> = from_glib_borrow(key);
            let iter = from_glib_borrow(iter);
            let callback: &P = &*(search_data as *mut _);
            (*callback)(&model, column, key.as_str(), &iter).into_glib()
        }
        let search_equal_func = Some(search_equal_func_func::<P> as _);
        unsafe extern "C" fn search_destroy_func<
            P: Fn(&TreeModel, i32, &str, &TreeIter) -> bool + 'static,
        >(
            data: glib::ffi::gpointer,
        ) {
            let _callback: Box_<P> = Box_::from_raw(data as *mut _);
        }
        let destroy_call3 = Some(search_destroy_func::<P> as _);
        let super_callback0: Box_<P> = search_equal_func_data;
        unsafe {
            ffi::gtk_tree_view_set_search_equal_func(
                self.as_ref().to_glib_none().0,
                search_equal_func,
                Box_::into_raw(super_callback0) as *mut _,
                destroy_call3,
            );
        }
    }

    /// Sets whether to draw and enable expanders and indent child rows in
    /// @self.  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
    /// gtk_tree_view_set_level_indentation().
    /// This does not have any visible effects for lists.
    ///
    /// # Deprecated since 4.10
    ///
    /// Use [`ListView`][crate::ListView] or [`ColumnView`][crate::ColumnView] instead
    /// ## `enabled`
    /// [`true`] to enable expander drawing, [`false`] otherwise.
    #[cfg_attr(feature = "v4_10", deprecated = "Since 4.10")]
    #[allow(deprecated)]
    #[doc(alias = "gtk_tree_view_set_show_expanders")]
    fn set_show_expanders(&self, enabled: bool) {
        unsafe {
            ffi::gtk_tree_view_set_show_expanders(
                self.as_ref().to_glib_none().0,
                enabled.into_glib(),
            );
        }
    }

    /// Sets the tip area of @tooltip to the area @path, @column and @cell have
    /// in common.  For example if @path is [`None`] and @column is set, the tip
    /// area will be set to the full area covered by @column.  See also
    /// gtk_tooltip_set_tip_area().
    ///
    /// Note that if @path is not specified and @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 @path must be set to the current node under the
    /// mouse cursor for this function to operate correctly.
    ///
    /// See also gtk_tree_view_set_tooltip_column() for a simpler alternative.
    ///
    /// # Deprecated since 4.10
    ///
    /// Use [`ListView`][crate::ListView] or [`ColumnView`][crate::ColumnView] instead
    /// ## `tooltip`
    /// a [`Tooltip`][crate::Tooltip]
    /// ## `path`
    /// a [`TreePath`][crate::TreePath]
    /// ## `column`
    /// a [`TreeViewColumn`][crate::TreeViewColumn]
    /// ## `cell`
    /// a [`CellRenderer`][crate::CellRenderer]
    #[cfg_attr(feature = "v4_10", deprecated = "Since 4.10")]
    #[allow(deprecated)]
    #[doc(alias = "gtk_tree_view_set_tooltip_cell")]
    fn set_tooltip_cell(
        &self,
        tooltip: &Tooltip,
        path: Option<&TreePath>,
        column: Option<&TreeViewColumn>,
        cell: Option<&impl IsA<CellRenderer>>,
    ) {
        unsafe {
            ffi::gtk_tree_view_set_tooltip_cell(
                self.as_ref().to_glib_none().0,
                tooltip.to_glib_none().0,
                mut_override(path.to_glib_none().0),
                column.to_glib_none().0,
                cell.map(|p| p.as_ref()).to_glib_none().0,
            );
        }
    }

    /// If you only plan to have simple (text-only) tooltips on full rows, you
    /// can use this function to have [`TreeView`][crate::TreeView] handle these automatically
    /// for you. @column should be set to the column in @self’s model
    /// containing the tooltip texts, or -1 to disable this feature.
    ///
    /// When enabled, `GtkWidget:has-tooltip` will be set to [`true`] and
    /// @self will connect a `GtkWidget::query-tooltip` signal handler.
    ///
    /// Note that the signal handler sets the text with gtk_tooltip_set_markup(),
    /// so &, <, etc have to be escaped in the text.
    ///
    /// # Deprecated since 4.10
    ///
    /// Use [`ListView`][crate::ListView] or [`ColumnView`][crate::ColumnView] instead
    /// ## `column`
    /// an integer, which is a valid column number for @self’s model
    #[cfg_attr(feature = "v4_10", deprecated = "Since 4.10")]
    #[allow(deprecated)]
    #[doc(alias = "gtk_tree_view_set_tooltip_column")]
    fn set_tooltip_column(&self, column: i32) {
        unsafe {
            ffi::gtk_tree_view_set_tooltip_column(self.as_ref().to_glib_none().0, column);
        }
    }

    /// Sets the tip area of @tooltip to be the area covered by the row at @path.
    /// See also gtk_tree_view_set_tooltip_column() for a simpler alternative.
    /// See also gtk_tooltip_set_tip_area().
    ///
    /// # Deprecated since 4.10
    ///
    /// Use [`ListView`][crate::ListView] or [`ColumnView`][crate::ColumnView] instead
    /// ## `tooltip`
    /// a [`Tooltip`][crate::Tooltip]
    /// ## `path`
    /// a [`TreePath`][crate::TreePath]
    #[cfg_attr(feature = "v4_10", deprecated = "Since 4.10")]
    #[allow(deprecated)]
    #[doc(alias = "gtk_tree_view_set_tooltip_row")]
    fn set_tooltip_row(&self, tooltip: &Tooltip, path: &TreePath) {
        unsafe {
            ffi::gtk_tree_view_set_tooltip_row(
                self.as_ref().to_glib_none().0,
                tooltip.to_glib_none().0,
                mut_override(path.to_glib_none().0),
            );
        }
    }

    /// Undoes the effect of
    /// gtk_tree_view_enable_model_drag_dest(). Calling this method sets
    /// [`TreeView`][crate::TreeView]:reorderable to [`false`].
    ///
    /// # Deprecated since 4.10
    ///
    /// Use [`ListView`][crate::ListView] or [`ColumnView`][crate::ColumnView] instead
    #[cfg_attr(feature = "v4_10", deprecated = "Since 4.10")]
    #[allow(deprecated)]
    #[doc(alias = "gtk_tree_view_unset_rows_drag_dest")]
    fn unset_rows_drag_dest(&self) {
        unsafe {
            ffi::gtk_tree_view_unset_rows_drag_dest(self.as_ref().to_glib_none().0);
        }
    }

    /// Undoes the effect of
    /// gtk_tree_view_enable_model_drag_source(). Calling this method sets
    /// [`TreeView`][crate::TreeView]:reorderable to [`false`].
    ///
    /// # Deprecated since 4.10
    ///
    /// Use [`ListView`][crate::ListView] or [`ColumnView`][crate::ColumnView] instead
    #[cfg_attr(feature = "v4_10", deprecated = "Since 4.10")]
    #[allow(deprecated)]
    #[doc(alias = "gtk_tree_view_unset_rows_drag_source")]
    fn unset_rows_drag_source(&self) {
        unsafe {
            ffi::gtk_tree_view_unset_rows_drag_source(self.as_ref().to_glib_none().0);
        }
    }

    #[doc(alias = "enable-grid-lines")]
    fn enable_grid_lines(&self) -> TreeViewGridLines {
        ObjectExt::property(self.as_ref(), "enable-grid-lines")
    }

    #[doc(alias = "enable-grid-lines")]
    fn set_enable_grid_lines(&self, enable_grid_lines: TreeViewGridLines) {
        ObjectExt::set_property(self.as_ref(), "enable-grid-lines", enable_grid_lines)
    }

    /// The number of columns of the treeview has changed.
    #[doc(alias = "columns-changed")]
    fn connect_columns_changed<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn columns_changed_trampoline<P: IsA<TreeView>, F: Fn(&P) + 'static>(
            this: *mut ffi::GtkTreeView,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(TreeView::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"columns-changed\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    columns_changed_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    /// The position of the cursor (focused cell) has changed.
    #[doc(alias = "cursor-changed")]
    fn connect_cursor_changed<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn cursor_changed_trampoline<P: IsA<TreeView>, F: Fn(&P) + 'static>(
            this: *mut ffi::GtkTreeView,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(TreeView::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"cursor-changed\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    cursor_changed_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "expand-collapse-cursor-row")]
    fn connect_expand_collapse_cursor_row<F: Fn(&Self, bool, bool, bool) -> bool + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn expand_collapse_cursor_row_trampoline<
            P: IsA<TreeView>,
            F: Fn(&P, bool, bool, bool) -> bool + 'static,
        >(
            this: *mut ffi::GtkTreeView,
            object: glib::ffi::gboolean,
            p0: glib::ffi::gboolean,
            p1: glib::ffi::gboolean,
            f: glib::ffi::gpointer,
        ) -> glib::ffi::gboolean {
            let f: &F = &*(f as *const F);
            f(
                TreeView::from_glib_borrow(this).unsafe_cast_ref(),
                from_glib(object),
                from_glib(p0),
                from_glib(p1),
            )
            .into_glib()
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"expand-collapse-cursor-row\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    expand_collapse_cursor_row_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    fn emit_expand_collapse_cursor_row(&self, object: bool, p0: bool, p1: bool) -> bool {
        self.emit_by_name("expand-collapse-cursor-row", &[&object, &p0, &p1])
    }

    /// The [`TreeView`][crate::TreeView]::move-cursor signal is a [keybinding
    /// signal][`SignalAction`][crate::SignalAction] which gets emitted when the user
    /// presses one of the cursor keys.
    ///
    /// Applications should not connect to it, but may emit it with
    /// g_signal_emit_by_name() if they need to control the cursor
    /// programmatically. In contrast to gtk_tree_view_set_cursor() and
    /// gtk_tree_view_set_cursor_on_cell() when moving horizontally
    /// [`TreeView`][crate::TreeView]::move-cursor does not reset the current selection.
    /// ## `step`
    /// the granularity of the move, as a [`MovementStep`][crate::MovementStep].
    ///     [`MovementStep::LogicalPositions`][crate::MovementStep::LogicalPositions], [`MovementStep::VisualPositions`][crate::MovementStep::VisualPositions],
    ///     [`MovementStep::DisplayLines`][crate::MovementStep::DisplayLines], [`MovementStep::Pages`][crate::MovementStep::Pages] and
    ///     [`MovementStep::BufferEnds`][crate::MovementStep::BufferEnds] are supported.
    ///     [`MovementStep::LogicalPositions`][crate::MovementStep::LogicalPositions] and [`MovementStep::VisualPositions`][crate::MovementStep::VisualPositions]
    ///     are treated identically.
    /// ## `direction`
    /// the direction to move: +1 to move forwards; -1 to move
    ///     backwards. The resulting movement is undefined for all other values.
    /// ## `extend`
    /// whether to extend the selection
    /// ## `modify`
    /// whether to modify the selection
    ///
    /// # Returns
    ///
    /// [`true`] if @step is supported, [`false`] otherwise.
    #[doc(alias = "move-cursor")]
    fn connect_move_cursor<F: Fn(&Self, MovementStep, i32, bool, bool) -> bool + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn move_cursor_trampoline<
            P: IsA<TreeView>,
            F: Fn(&P, MovementStep, i32, bool, bool) -> bool + 'static,
        >(
            this: *mut ffi::GtkTreeView,
            step: ffi::GtkMovementStep,
            direction: libc::c_int,
            extend: glib::ffi::gboolean,
            modify: glib::ffi::gboolean,
            f: glib::ffi::gpointer,
        ) -> glib::ffi::gboolean {
            let f: &F = &*(f as *const F);
            f(
                TreeView::from_glib_borrow(this).unsafe_cast_ref(),
                from_glib(step),
                direction,
                from_glib(extend),
                from_glib(modify),
            )
            .into_glib()
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"move-cursor\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    move_cursor_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    fn emit_move_cursor(
        &self,
        step: MovementStep,
        direction: i32,
        extend: bool,
        modify: bool,
    ) -> bool {
        self.emit_by_name("move-cursor", &[&step, &direction, &extend, &modify])
    }

    /// The "row-activated" signal is emitted when the method
    /// [`row_activated()`][Self::row_activated()] is called.
    ///
    /// This signal is emitted when the user double-clicks a treeview row with the
    /// [`activate-on-single-click`][struct@crate::TreeView#activate-on-single-click] property set to [`false`],
    /// or when the user single-clicks a row when that property set to [`true`].
    ///
    /// This signal is also emitted when a non-editable row is selected and one
    /// of the keys: <kbd>Space</kbd>, <kbd>Shift</kbd>+<kbd>Space</kbd>,
    /// <kbd>Return</kbd> or <kbd>Enter</kbd> is pressed.
    ///
    /// For selection handling refer to the
    /// [tree widget conceptual overview](section-tree-widget.html)
    /// as well as [`TreeSelection`][crate::TreeSelection].
    /// ## `path`
    /// the [`TreePath`][crate::TreePath] for the activated row
    /// ## `column`
    /// the [`TreeViewColumn`][crate::TreeViewColumn] in which the activation occurred
    #[doc(alias = "row-activated")]
    fn connect_row_activated<F: Fn(&Self, &TreePath, Option<&TreeViewColumn>) + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn row_activated_trampoline<
            P: IsA<TreeView>,
            F: Fn(&P, &TreePath, Option<&TreeViewColumn>) + 'static,
        >(
            this: *mut ffi::GtkTreeView,
            path: *mut ffi::GtkTreePath,
            column: *mut ffi::GtkTreeViewColumn,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(
                TreeView::from_glib_borrow(this).unsafe_cast_ref(),
                &from_glib_borrow(path),
                Option::<TreeViewColumn>::from_glib_borrow(column)
                    .as_ref()
                    .as_ref(),
            )
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"row-activated\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    row_activated_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    fn emit_row_activated(&self, path: &TreePath, column: Option<&TreeViewColumn>) {
        self.emit_by_name::<()>("row-activated", &[&path, &column]);
    }

    /// The given row has been collapsed (child nodes are hidden).
    /// ## `iter`
    /// the tree iter of the collapsed row
    /// ## `path`
    /// a tree path that points to the row
    #[doc(alias = "row-collapsed")]
    fn connect_row_collapsed<F: Fn(&Self, &TreeIter, &TreePath) + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn row_collapsed_trampoline<
            P: IsA<TreeView>,
            F: Fn(&P, &TreeIter, &TreePath) + 'static,
        >(
            this: *mut ffi::GtkTreeView,
            iter: *mut ffi::GtkTreeIter,
            path: *mut ffi::GtkTreePath,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(
                TreeView::from_glib_borrow(this).unsafe_cast_ref(),
                &from_glib_borrow(iter),
                &from_glib_borrow(path),
            )
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"row-collapsed\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    row_collapsed_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    /// The given row has been expanded (child nodes are shown).
    /// ## `iter`
    /// the tree iter of the expanded row
    /// ## `path`
    /// a tree path that points to the row
    #[doc(alias = "row-expanded")]
    fn connect_row_expanded<F: Fn(&Self, &TreeIter, &TreePath) + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn row_expanded_trampoline<
            P: IsA<TreeView>,
            F: Fn(&P, &TreeIter, &TreePath) + 'static,
        >(
            this: *mut ffi::GtkTreeView,
            iter: *mut ffi::GtkTreeIter,
            path: *mut ffi::GtkTreePath,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(
                TreeView::from_glib_borrow(this).unsafe_cast_ref(),
                &from_glib_borrow(iter),
                &from_glib_borrow(path),
            )
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"row-expanded\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    row_expanded_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "select-all")]
    fn connect_select_all<F: Fn(&Self) -> bool + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn select_all_trampoline<
            P: IsA<TreeView>,
            F: Fn(&P) -> bool + 'static,
        >(
            this: *mut ffi::GtkTreeView,
            f: glib::ffi::gpointer,
        ) -> glib::ffi::gboolean {
            let f: &F = &*(f as *const F);
            f(TreeView::from_glib_borrow(this).unsafe_cast_ref()).into_glib()
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"select-all\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    select_all_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    fn emit_select_all(&self) -> bool {
        self.emit_by_name("select-all", &[])
    }

    #[doc(alias = "select-cursor-parent")]
    fn connect_select_cursor_parent<F: Fn(&Self) -> bool + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn select_cursor_parent_trampoline<
            P: IsA<TreeView>,
            F: Fn(&P) -> bool + 'static,
        >(
            this: *mut ffi::GtkTreeView,
            f: glib::ffi::gpointer,
        ) -> glib::ffi::gboolean {
            let f: &F = &*(f as *const F);
            f(TreeView::from_glib_borrow(this).unsafe_cast_ref()).into_glib()
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"select-cursor-parent\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    select_cursor_parent_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    fn emit_select_cursor_parent(&self) -> bool {
        self.emit_by_name("select-cursor-parent", &[])
    }

    #[doc(alias = "select-cursor-row")]
    fn connect_select_cursor_row<F: Fn(&Self, bool) -> bool + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn select_cursor_row_trampoline<
            P: IsA<TreeView>,
            F: Fn(&P, bool) -> bool + 'static,
        >(
            this: *mut ffi::GtkTreeView,
            object: glib::ffi::gboolean,
            f: glib::ffi::gpointer,
        ) -> glib::ffi::gboolean {
            let f: &F = &*(f as *const F);
            f(
                TreeView::from_glib_borrow(this).unsafe_cast_ref(),
                from_glib(object),
            )
            .into_glib()
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"select-cursor-row\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    select_cursor_row_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    fn emit_select_cursor_row(&self, object: bool) -> bool {
        self.emit_by_name("select-cursor-row", &[&object])
    }

    #[doc(alias = "start-interactive-search")]
    fn connect_start_interactive_search<F: Fn(&Self) -> bool + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn start_interactive_search_trampoline<
            P: IsA<TreeView>,
            F: Fn(&P) -> bool + 'static,
        >(
            this: *mut ffi::GtkTreeView,
            f: glib::ffi::gpointer,
        ) -> glib::ffi::gboolean {
            let f: &F = &*(f as *const F);
            f(TreeView::from_glib_borrow(this).unsafe_cast_ref()).into_glib()
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"start-interactive-search\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    start_interactive_search_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    fn emit_start_interactive_search(&self) -> bool {
        self.emit_by_name("start-interactive-search", &[])
    }

    /// 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.
    /// ## `iter`
    /// the tree iter of the row to collapse
    /// ## `path`
    /// a tree path that points to the row
    ///
    /// # Returns
    ///
    /// [`false`] to allow collapsing, [`true`] to reject
    #[doc(alias = "test-collapse-row")]
    fn connect_test_collapse_row<
        F: Fn(&Self, &TreeIter, &TreePath) -> glib::Propagation + 'static,
    >(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn test_collapse_row_trampoline<
            P: IsA<TreeView>,
            F: Fn(&P, &TreeIter, &TreePath) -> glib::Propagation + 'static,
        >(
            this: *mut ffi::GtkTreeView,
            iter: *mut ffi::GtkTreeIter,
            path: *mut ffi::GtkTreePath,
            f: glib::ffi::gpointer,
        ) -> glib::ffi::gboolean {
            let f: &F = &*(f as *const F);
            f(
                TreeView::from_glib_borrow(this).unsafe_cast_ref(),
                &from_glib_borrow(iter),
                &from_glib_borrow(path),
            )
            .into_glib()
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"test-collapse-row\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    test_collapse_row_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    /// 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.
    /// ## `iter`
    /// the tree iter of the row to expand
    /// ## `path`
    /// a tree path that points to the row
    ///
    /// # Returns
    ///
    /// [`false`] to allow expansion, [`true`] to reject
    #[doc(alias = "test-expand-row")]
    fn connect_test_expand_row<
        F: Fn(&Self, &TreeIter, &TreePath) -> glib::Propagation + 'static,
    >(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn test_expand_row_trampoline<
            P: IsA<TreeView>,
            F: Fn(&P, &TreeIter, &TreePath) -> glib::Propagation + 'static,
        >(
            this: *mut ffi::GtkTreeView,
            iter: *mut ffi::GtkTreeIter,
            path: *mut ffi::GtkTreePath,
            f: glib::ffi::gpointer,
        ) -> glib::ffi::gboolean {
            let f: &F = &*(f as *const F);
            f(
                TreeView::from_glib_borrow(this).unsafe_cast_ref(),
                &from_glib_borrow(iter),
                &from_glib_borrow(path),
            )
            .into_glib()
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"test-expand-row\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    test_expand_row_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "toggle-cursor-row")]
    fn connect_toggle_cursor_row<F: Fn(&Self) -> bool + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn toggle_cursor_row_trampoline<
            P: IsA<TreeView>,
            F: Fn(&P) -> bool + 'static,
        >(
            this: *mut ffi::GtkTreeView,
            f: glib::ffi::gpointer,
        ) -> glib::ffi::gboolean {
            let f: &F = &*(f as *const F);
            f(TreeView::from_glib_borrow(this).unsafe_cast_ref()).into_glib()
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"toggle-cursor-row\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    toggle_cursor_row_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    fn emit_toggle_cursor_row(&self) -> bool {
        self.emit_by_name("toggle-cursor-row", &[])
    }

    #[doc(alias = "unselect-all")]
    fn connect_unselect_all<F: Fn(&Self) -> bool + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn unselect_all_trampoline<
            P: IsA<TreeView>,
            F: Fn(&P) -> bool + 'static,
        >(
            this: *mut ffi::GtkTreeView,
            f: glib::ffi::gpointer,
        ) -> glib::ffi::gboolean {
            let f: &F = &*(f as *const F);
            f(TreeView::from_glib_borrow(this).unsafe_cast_ref()).into_glib()
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"unselect-all\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    unselect_all_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    fn emit_unselect_all(&self) -> bool {
        self.emit_by_name("unselect-all", &[])
    }

    #[doc(alias = "activate-on-single-click")]
    fn connect_activate_on_single_click_notify<F: Fn(&Self) + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn notify_activate_on_single_click_trampoline<
            P: IsA<TreeView>,
            F: Fn(&P) + 'static,
        >(
            this: *mut ffi::GtkTreeView,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(TreeView::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"notify::activate-on-single-click\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    notify_activate_on_single_click_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "enable-grid-lines")]
    fn connect_enable_grid_lines_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_enable_grid_lines_trampoline<
            P: IsA<TreeView>,
            F: Fn(&P) + 'static,
        >(
            this: *mut ffi::GtkTreeView,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(TreeView::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"notify::enable-grid-lines\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    notify_enable_grid_lines_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "enable-search")]
    fn connect_enable_search_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_enable_search_trampoline<
            P: IsA<TreeView>,
            F: Fn(&P) + 'static,
        >(
            this: *mut ffi::GtkTreeView,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(TreeView::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"notify::enable-search\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    notify_enable_search_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "enable-tree-lines")]
    fn connect_enable_tree_lines_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_enable_tree_lines_trampoline<
            P: IsA<TreeView>,
            F: Fn(&P) + 'static,
        >(
            this: *mut ffi::GtkTreeView,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(TreeView::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"notify::enable-tree-lines\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    notify_enable_tree_lines_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "expander-column")]
    fn connect_expander_column_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_expander_column_trampoline<
            P: IsA<TreeView>,
            F: Fn(&P) + 'static,
        >(
            this: *mut ffi::GtkTreeView,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(TreeView::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"notify::expander-column\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    notify_expander_column_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "fixed-height-mode")]
    fn connect_fixed_height_mode_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_fixed_height_mode_trampoline<
            P: IsA<TreeView>,
            F: Fn(&P) + 'static,
        >(
            this: *mut ffi::GtkTreeView,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(TreeView::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"notify::fixed-height-mode\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    notify_fixed_height_mode_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "headers-clickable")]
    fn connect_headers_clickable_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_headers_clickable_trampoline<
            P: IsA<TreeView>,
            F: Fn(&P) + 'static,
        >(
            this: *mut ffi::GtkTreeView,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(TreeView::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"notify::headers-clickable\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    notify_headers_clickable_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "headers-visible")]
    fn connect_headers_visible_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_headers_visible_trampoline<
            P: IsA<TreeView>,
            F: Fn(&P) + 'static,
        >(
            this: *mut ffi::GtkTreeView,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(TreeView::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"notify::headers-visible\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    notify_headers_visible_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "hover-expand")]
    fn connect_hover_expand_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_hover_expand_trampoline<
            P: IsA<TreeView>,
            F: Fn(&P) + 'static,
        >(
            this: *mut ffi::GtkTreeView,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(TreeView::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"notify::hover-expand\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    notify_hover_expand_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "hover-selection")]
    fn connect_hover_selection_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_hover_selection_trampoline<
            P: IsA<TreeView>,
            F: Fn(&P) + 'static,
        >(
            this: *mut ffi::GtkTreeView,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(TreeView::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"notify::hover-selection\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    notify_hover_selection_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "level-indentation")]
    fn connect_level_indentation_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_level_indentation_trampoline<
            P: IsA<TreeView>,
            F: Fn(&P) + 'static,
        >(
            this: *mut ffi::GtkTreeView,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(TreeView::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"notify::level-indentation\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    notify_level_indentation_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "model")]
    fn connect_model_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_model_trampoline<P: IsA<TreeView>, F: Fn(&P) + 'static>(
            this: *mut ffi::GtkTreeView,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(TreeView::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"notify::model\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    notify_model_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "reorderable")]
    fn connect_reorderable_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_reorderable_trampoline<
            P: IsA<TreeView>,
            F: Fn(&P) + 'static,
        >(
            this: *mut ffi::GtkTreeView,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(TreeView::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"notify::reorderable\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    notify_reorderable_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "rubber-banding")]
    fn connect_rubber_banding_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_rubber_banding_trampoline<
            P: IsA<TreeView>,
            F: Fn(&P) + 'static,
        >(
            this: *mut ffi::GtkTreeView,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(TreeView::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"notify::rubber-banding\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    notify_rubber_banding_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "search-column")]
    fn connect_search_column_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_search_column_trampoline<
            P: IsA<TreeView>,
            F: Fn(&P) + 'static,
        >(
            this: *mut ffi::GtkTreeView,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(TreeView::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"notify::search-column\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    notify_search_column_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "show-expanders")]
    fn connect_show_expanders_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_show_expanders_trampoline<
            P: IsA<TreeView>,
            F: Fn(&P) + 'static,
        >(
            this: *mut ffi::GtkTreeView,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(TreeView::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"notify::show-expanders\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    notify_show_expanders_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "tooltip-column")]
    fn connect_tooltip_column_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_tooltip_column_trampoline<
            P: IsA<TreeView>,
            F: Fn(&P) + 'static,
        >(
            this: *mut ffi::GtkTreeView,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(TreeView::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"notify::tooltip-column\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    notify_tooltip_column_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }
}

impl<O: IsA<TreeView>> TreeViewExt for O {}

impl fmt::Display for TreeView {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        f.write_str("TreeView")
    }
}