gtk4/auto/

text_view.rs

// 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

#[cfg(feature = "v4_14")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
use crate::AccessibleText;
use crate::{
    ffi, Accessible, AccessibleRole, Adjustment, Align, Buildable, ConstraintTarget, DeleteType,
    InputHints, InputPurpose, Justification, LayoutManager, MovementStep, Overflow, ScrollStep,
    Scrollable, ScrollablePolicy, TextBuffer, TextChildAnchor, TextExtendSelection, TextIter,
    TextMark, TextWindowType, Widget, WrapMode,
};
use glib::{
    object::ObjectType as _,
    prelude::*,
    signal::{connect_raw, SignalHandlerId},
    translate::*,
};
use std::boxed::Box as Box_;

#[cfg(feature = "v4_14")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
glib::wrapper! {
    /// Displays the contents of a [`TextBuffer`][crate::TextBuffer].
    ///
    /// <picture>
    ///   <source srcset="multiline-text-dark.png" media="(prefers-color-scheme: dark)">
    ///   <img alt="An example GtkTextView" src="multiline-text.png">
    /// </picture>
    ///
    /// You may wish to begin by reading the [conceptual overview](section-text-widget.html),
    /// which gives an overview of all the objects and data types related to the
    /// text widget and how they work together.
    ///
    /// ## Shortcuts and Gestures
    ///
    /// [`TextView`][crate::TextView] supports the following keyboard shortcuts:
    ///
    /// - <kbd>Shift</kbd>+<kbd>F10</kbd> or <kbd>Menu</kbd> opens the context menu.
    /// - <kbd>Ctrl</kbd>+<kbd>Z</kbd> undoes the last modification.
    /// - <kbd>Ctrl</kbd>+<kbd>Y</kbd> or <kbd>Ctrl</kbd>+<kbd>Shift</kbd>+<kbd>Z</kbd>
    ///   redoes the last undone modification.
    ///
    /// Additionally, the following signals have default keybindings:
    ///
    /// - [`backspace`][struct@crate::TextView#backspace]
    /// - [`copy-clipboard`][struct@crate::TextView#copy-clipboard]
    /// - [`cut-clipboard`][struct@crate::TextView#cut-clipboard]
    /// - [`delete-from-cursor`][struct@crate::TextView#delete-from-cursor]
    /// - [`insert-emoji`][struct@crate::TextView#insert-emoji]
    /// - [`move-cursor`][struct@crate::TextView#move-cursor]
    /// - [`paste-clipboard`][struct@crate::TextView#paste-clipboard]
    /// - [`select-all`][struct@crate::TextView#select-all]
    /// - [`toggle-cursor-visible`][struct@crate::TextView#toggle-cursor-visible]
    /// - [`toggle-overwrite`][struct@crate::TextView#toggle-overwrite]
    ///
    /// ## Actions
    ///
    /// [`TextView`][crate::TextView] defines a set of built-in actions:
    ///
    /// - `clipboard.copy` copies the contents to the clipboard.
    /// - `clipboard.cut` copies the contents to the clipboard and deletes it from
    ///   the widget.
    /// - `clipboard.paste` inserts the contents of the clipboard into the widget.
    /// - `menu.popup` opens the context menu.
    /// - `misc.insert-emoji` opens the Emoji chooser.
    /// - `selection.delete` deletes the current selection.
    /// - `selection.select-all` selects all of the widgets content.
    /// - `text.redo` redoes the last change to the contents.
    /// - `text.undo` undoes the last change to the contents.
    ///
    /// ## CSS nodes
    ///
    /// ```text
    /// textview.view
    /// ├── border.top
    /// ├── border.left
    /// ├── text
    /// │   ╰── [selection]
    /// ├── border.right
    /// ├── border.bottom
    /// ╰── [window.popup]
    /// ```
    ///
    /// [`TextView`][crate::TextView] has a main css node with name textview and style class .view,
    /// and subnodes for each of the border windows, and the main text area,
    /// with names border and text, respectively. The border nodes each get
    /// one of the style classes .left, .right, .top or .bottom.
    ///
    /// A node representing the selection will appear below the text node.
    ///
    /// If a context menu is opened, the window node will appear as a subnode
    /// of the main node.
    ///
    /// ## Accessibility
    ///
    /// [`TextView`][crate::TextView] uses the [enum@Gtk.AccessibleRole.text_box] role.
    ///
    /// ## Properties
    ///
    ///
    /// #### `accepts-tab`
    ///  Whether Tab will result in a tab character being entered.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `bottom-margin`
    ///  The bottom margin for text in the text view.
    ///
    /// Note that this property is confusingly named. In CSS terms,
    /// the value set here is padding, and it is applied in addition
    /// to the padding from the theme.
    ///
    /// Don't confuse this property with [`margin-bottom`][struct@crate::Widget#margin-bottom].
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `buffer`
    ///  The buffer which is displayed.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `cursor-visible`
    ///  If the insertion cursor is shown.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `editable`
    ///  Whether the text can be modified by the user.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `extra-menu`
    ///  A menu model whose contents will be appended to the context menu.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `im-module`
    ///  Which IM (input method) module should be used for this text_view.
    ///
    /// See [`IMMulticontext`][crate::IMMulticontext].
    ///
    /// Setting this to a non-[`None`] value overrides the system-wide IM module
    /// setting. See the GtkSettings [`gtk-im-module`][struct@crate::Settings#gtk-im-module] property.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `indent`
    ///  Amount to indent the paragraph, in pixels.
    ///
    /// A negative value of indent will produce a hanging indentation.
    /// That is, the first line will have the full width, and subsequent
    /// lines will be indented by the absolute value of indent.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `input-hints`
    ///  Additional hints (beyond [`input-purpose`][struct@crate::TextView#input-purpose])
    /// that allow input methods to fine-tune their behaviour.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `input-purpose`
    ///  The purpose of this text field.
    ///
    /// This property can be used by on-screen keyboards and other input
    /// methods to adjust their behaviour.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `justification`
    ///  Left, right, or center justification.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `left-margin`
    ///  The default left margin for text in the text view.
    ///
    /// Tags in the buffer may override the default.
    ///
    /// Note that this property is confusingly named. In CSS terms,
    /// the value set here is padding, and it is applied in addition
    /// to the padding from the theme.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `monospace`
    ///  Whether text should be displayed in a monospace font.
    ///
    /// If [`true`], set the .monospace style class on the
    /// text view to indicate that a monospace font is desired.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `overwrite`
    ///  Whether entered text overwrites existing contents.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `pixels-above-lines`
    ///  Pixels of blank space above paragraphs.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `pixels-below-lines`
    ///  Pixels of blank space below paragraphs.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `pixels-inside-wrap`
    ///  Pixels of blank space between wrapped lines in a paragraph.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `right-margin`
    ///  The default right margin for text in the text view.
    ///
    /// Tags in the buffer may override the default.
    ///
    /// Note that this property is confusingly named. In CSS terms,
    /// the value set here is padding, and it is applied in addition
    /// to the padding from the theme.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `tabs`
    ///  Custom tabs for this text.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `top-margin`
    ///  The top margin for text in the text view.
    ///
    /// Note that this property is confusingly named. In CSS terms,
    /// the value set here is padding, and it is applied in addition
    /// to the padding from the theme.
    ///
    /// Don't confuse this property with [`margin-top`][struct@crate::Widget#margin-top].
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `wrap-mode`
    ///  Whether to wrap lines never, at word boundaries, or at character boundaries.
    ///
    /// 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`][struct@crate::Widget#query-tooltip]
    /// signal on @widget.
    ///
    /// A true value 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`
    ///  Overrides 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
    ///
    ///
    /// #### `limit-events`
    ///  Makes this widget act like a modal dialog, with respect to
    /// event delivery.
    ///
    /// Global event controllers will not handle events with targets
    /// inside the widget, unless they are set up to ignore propagation
    /// limits. See [`EventControllerExt::set_propagation_limit()`][crate::prelude::EventControllerExt::set_propagation_limit()].
    ///
    /// 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 `NULL` 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 `NULL`:
    /// [`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 `NULL`:
    /// [`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`
    ///  Overrides 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
    ///
    ///
    /// #### `backspace`
    ///  Gets emitted when the user asks for it.
    ///
    /// The ::backspace signal is a [keybinding signal](class.SignalAction.html).
    ///
    /// The default bindings for this signal are
    /// <kbd>Backspace</kbd> and <kbd>Shift</kbd>+<kbd>Backspace</kbd>.
    ///
    /// Action
    ///
    ///
    /// #### `copy-clipboard`
    ///  Gets emitted to copy the selection to the clipboard.
    ///
    /// The ::copy-clipboard signal is a [keybinding signal](class.SignalAction.html).
    ///
    /// The default bindings for this signal are
    /// <kbd>Ctrl</kbd>+<kbd>c</kbd> and
    /// <kbd>Ctrl</kbd>+<kbd>Insert</kbd>.
    ///
    /// Action
    ///
    ///
    /// #### `cut-clipboard`
    ///  Gets emitted to cut the selection to the clipboard.
    ///
    /// The ::cut-clipboard signal is a [keybinding signal](class.SignalAction.html).
    ///
    /// The default bindings for this signal are
    /// <kbd>Ctrl</kbd>+<kbd>x</kbd> and
    /// <kbd>Shift</kbd>+<kbd>Delete</kbd>.
    ///
    /// Action
    ///
    ///
    /// #### `delete-from-cursor`
    ///  Gets emitted when the user initiates a text deletion.
    ///
    /// The ::delete-from-cursor signal is a [keybinding signal](class.SignalAction.html).
    ///
    /// If the @type_ is [`DeleteType::Chars`][crate::DeleteType::Chars], GTK deletes the selection
    /// if there is one, otherwise it deletes the requested number
    /// of characters.
    ///
    /// The default bindings for this signal are <kbd>Delete</kbd> for
    /// deleting a character, <kbd>Ctrl</kbd>+<kbd>Delete</kbd> for
    /// deleting a word and <kbd>Ctrl</kbd>+<kbd>Backspace</kbd> for
    /// deleting a word backwards.
    ///
    /// Action
    ///
    ///
    /// #### `extend-selection`
    ///  Emitted when the selection needs to be extended at @location.
    ///
    ///
    ///
    ///
    /// #### `insert-at-cursor`
    ///  Gets emitted when the user initiates the insertion of a
    /// fixed string at the cursor.
    ///
    /// The ::insert-at-cursor signal is a [keybinding signal](class.SignalAction.html).
    ///
    /// This signal has no default bindings.
    ///
    /// Action
    ///
    ///
    /// #### `insert-emoji`
    ///  Gets emitted to present the Emoji chooser for the @text_view.
    ///
    /// The ::insert-emoji signal is a [keybinding signal](class.SignalAction.html).
    ///
    /// The default bindings for this signal are
    /// <kbd>Ctrl</kbd>+<kbd>.</kbd> and
    /// <kbd>Ctrl</kbd>+<kbd>;</kbd>
    ///
    /// Action
    ///
    ///
    /// #### `move-cursor`
    ///  Gets emitted when the user initiates a cursor movement.
    ///
    /// The ::move-cursor signal is a [keybinding signal](class.SignalAction.html).
    /// If the cursor is not visible in @text_view, this signal causes
    /// the viewport to be moved instead.
    ///
    /// Applications should not connect to it, but may emit it with
    /// g_signal_emit_by_name() if they need to control the cursor
    /// programmatically.
    ///
    ///
    /// The default bindings for this signal come in two variants,
    /// the variant with the <kbd>Shift</kbd> modifier extends the
    /// selection, the variant without it does not.
    /// There are too many key combinations to list them all here.
    ///
    /// - <kbd>←</kbd>, <kbd>→</kbd>, <kbd>↑</kbd>, <kbd>↓</kbd>
    ///   move by individual characters/lines
    /// - <kbd>Ctrl</kbd>+<kbd>←</kbd>, etc. move by words/paragraphs
    /// - <kbd>Home</kbd> and <kbd>End</kbd> move to the ends of the buffer
    /// - <kbd>PgUp</kbd> and <kbd>PgDn</kbd> move vertically by pages
    /// - <kbd>Ctrl</kbd>+<kbd>PgUp</kbd> and <kbd>Ctrl</kbd>+<kbd>PgDn</kbd>
    ///   move horizontally by pages
    ///
    /// Action
    ///
    ///
    /// #### `move-viewport`
    ///  Gets emitted to move the viewport.
    ///
    /// The ::move-viewport signal is a [keybinding signal](class.SignalAction.html),
    /// which can be bound to key combinations to allow the user to move the viewport,
    /// i.e. change what part of the text view is visible in a containing scrolled
    /// window.
    ///
    /// There are no default bindings for this signal.
    ///
    /// Action
    ///
    ///
    /// #### `paste-clipboard`
    ///  Gets emitted to paste the contents of the clipboard
    /// into the text view.
    ///
    /// The ::paste-clipboard signal is a [keybinding signal](class.SignalAction.html).
    ///
    /// The default bindings for this signal are
    /// <kbd>Ctrl</kbd>+<kbd>v</kbd> and
    /// <kbd>Shift</kbd>+<kbd>Insert</kbd>.
    ///
    /// Action
    ///
    ///
    /// #### `preedit-changed`
    ///  Emitted when preedit text of the active IM changes.
    ///
    /// If an input method is used, the typed text will not immediately
    /// be committed to the buffer. So if you are interested in the text,
    /// connect to this signal.
    ///
    /// This signal is only emitted if the text at the given position
    /// is actually editable.
    ///
    /// Action
    ///
    ///
    /// #### `select-all`
    ///  Gets emitted to select or unselect the complete contents of the text view.
    ///
    /// The ::select-all signal is a [keybinding signal](class.SignalAction.html).
    ///
    /// The default bindings for this signal are
    /// <kbd>Ctrl</kbd>+<kbd>a</kbd> and
    /// <kbd>Ctrl</kbd>+<kbd>/</kbd> for selecting and
    /// <kbd>Shift</kbd>+<kbd>Ctrl</kbd>+<kbd>a</kbd> and
    /// <kbd>Ctrl</kbd>+<kbd>\</kbd> for unselecting.
    ///
    /// Action
    ///
    ///
    /// #### `set-anchor`
    ///  Gets emitted when the user initiates settings the "anchor" mark.
    ///
    /// The ::set-anchor signal is a [keybinding signal](class.SignalAction.html)
    /// which gets emitted when the user initiates setting the "anchor"
    /// mark. The "anchor" mark gets placed at the same position as the
    /// "insert" mark.
    ///
    /// This signal has no default bindings.
    ///
    /// Action
    ///
    ///
    /// #### `toggle-cursor-visible`
    ///  Gets emitted to toggle the `cursor-visible` property.
    ///
    /// The ::toggle-cursor-visible signal is a
    /// [keybinding signal](class.SignalAction.html).
    ///
    /// The default binding for this signal is <kbd>F7</kbd>.
    ///
    /// Action
    ///
    ///
    /// #### `toggle-overwrite`
    ///  Gets emitted to toggle the overwrite mode of the text view.
    ///
    /// The ::toggle-overwrite signal is a [keybinding signal](class.SignalAction.html).
    ///
    /// The default binding for this signal is <kbd>Insert</kbd>.
    ///
    /// 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
    ///
    /// [`TextViewExt`][trait@crate::prelude::TextViewExt], [`WidgetExt`][trait@crate::prelude::WidgetExt], [`trait@glib::ObjectExt`], [`AccessibleExt`][trait@crate::prelude::AccessibleExt], [`BuildableExt`][trait@crate::prelude::BuildableExt], [`ConstraintTargetExt`][trait@crate::prelude::ConstraintTargetExt], [`AccessibleTextExt`][trait@crate::prelude::AccessibleTextExt], [`ScrollableExt`][trait@crate::prelude::ScrollableExt], [`WidgetExtManual`][trait@crate::prelude::WidgetExtManual], [`AccessibleExtManual`][trait@crate::prelude::AccessibleExtManual]
    #[doc(alias = "GtkTextView")]
    pub struct TextView(Object<ffi::GtkTextView, ffi::GtkTextViewClass>) @extends Widget, @implements Accessible, Buildable, ConstraintTarget, AccessibleText, Scrollable;

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

#[cfg(not(any(feature = "v4_14")))]
glib::wrapper! {
    #[doc(alias = "GtkTextView")]
    pub struct TextView(Object<ffi::GtkTextView, ffi::GtkTextViewClass>) @extends Widget, @implements Accessible, Buildable, ConstraintTarget, Scrollable;

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

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

    /// Creates a new [`TextView`][crate::TextView].
    ///
    /// If you don’t call [`TextViewExt::set_buffer()`][crate::prelude::TextViewExt::set_buffer()] before using the
    /// text view, an empty default buffer will be created for you. Get the
    /// buffer with [`TextViewExt::buffer()`][crate::prelude::TextViewExt::buffer()]. If you want to specify
    /// your own buffer, consider [`with_buffer()`][Self::with_buffer()].
    ///
    /// # Returns
    ///
    /// a new [`TextView`][crate::TextView]
    #[doc(alias = "gtk_text_view_new")]
    pub fn new() -> TextView {
        assert_initialized_main_thread!();
        unsafe { Widget::from_glib_none(ffi::gtk_text_view_new()).unsafe_cast() }
    }

    /// Creates a new [`TextView`][crate::TextView] widget displaying the buffer @buffer.
    ///
    /// One buffer can be shared among many widgets. @buffer may be [`None`]
    /// to create a default buffer, in which case this function is equivalent
    /// to [`new()`][Self::new()]. The text view adds its own reference count
    /// to the buffer; it does not take over an existing reference.
    /// ## `buffer`
    /// a [`TextBuffer`][crate::TextBuffer]
    ///
    /// # Returns
    ///
    /// a new [`TextView`][crate::TextView].
    #[doc(alias = "gtk_text_view_new_with_buffer")]
    #[doc(alias = "new_with_buffer")]
    pub fn with_buffer(buffer: &impl IsA<TextBuffer>) -> TextView {
        skip_assert_initialized!();
        unsafe {
            Widget::from_glib_none(ffi::gtk_text_view_new_with_buffer(
                buffer.as_ref().to_glib_none().0,
            ))
            .unsafe_cast()
        }
    }

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

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

// rustdoc-stripper-ignore-next
/// A [builder-pattern] type to construct [`TextView`] 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 TextViewBuilder {
    builder: glib::object::ObjectBuilder<'static, TextView>,
}

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

    /// Whether Tab will result in a tab character being entered.
    pub fn accepts_tab(self, accepts_tab: bool) -> Self {
        Self {
            builder: self.builder.property("accepts-tab", accepts_tab),
        }
    }

    /// The bottom margin for text in the text view.
    ///
    /// Note that this property is confusingly named. In CSS terms,
    /// the value set here is padding, and it is applied in addition
    /// to the padding from the theme.
    ///
    /// Don't confuse this property with [`margin-bottom`][struct@crate::Widget#margin-bottom].
    pub fn bottom_margin(self, bottom_margin: i32) -> Self {
        Self {
            builder: self.builder.property("bottom-margin", bottom_margin),
        }
    }

    /// The buffer which is displayed.
    pub fn buffer(self, buffer: &impl IsA<TextBuffer>) -> Self {
        Self {
            builder: self.builder.property("buffer", buffer.clone().upcast()),
        }
    }

    /// If the insertion cursor is shown.
    pub fn cursor_visible(self, cursor_visible: bool) -> Self {
        Self {
            builder: self.builder.property("cursor-visible", cursor_visible),
        }
    }

    /// Whether the text can be modified by the user.
    pub fn editable(self, editable: bool) -> Self {
        Self {
            builder: self.builder.property("editable", editable),
        }
    }

    /// A menu model whose contents will be appended to the context menu.
    pub fn extra_menu(self, extra_menu: &impl IsA<gio::MenuModel>) -> Self {
        Self {
            builder: self
                .builder
                .property("extra-menu", extra_menu.clone().upcast()),
        }
    }

    /// Which IM (input method) module should be used for this text_view.
    ///
    /// See [`IMMulticontext`][crate::IMMulticontext].
    ///
    /// Setting this to a non-[`None`] value overrides the system-wide IM module
    /// setting. See the GtkSettings [`gtk-im-module`][struct@crate::Settings#gtk-im-module] property.
    pub fn im_module(self, im_module: impl Into<glib::GString>) -> Self {
        Self {
            builder: self.builder.property("im-module", im_module.into()),
        }
    }

    /// Amount to indent the paragraph, in pixels.
    ///
    /// A negative value of indent will produce a hanging indentation.
    /// That is, the first line will have the full width, and subsequent
    /// lines will be indented by the absolute value of indent.
    pub fn indent(self, indent: i32) -> Self {
        Self {
            builder: self.builder.property("indent", indent),
        }
    }

    /// Additional hints (beyond [`input-purpose`][struct@crate::TextView#input-purpose])
    /// that allow input methods to fine-tune their behaviour.
    pub fn input_hints(self, input_hints: InputHints) -> Self {
        Self {
            builder: self.builder.property("input-hints", input_hints),
        }
    }

    /// The purpose of this text field.
    ///
    /// This property can be used by on-screen keyboards and other input
    /// methods to adjust their behaviour.
    pub fn input_purpose(self, input_purpose: InputPurpose) -> Self {
        Self {
            builder: self.builder.property("input-purpose", input_purpose),
        }
    }

    /// Left, right, or center justification.
    pub fn justification(self, justification: Justification) -> Self {
        Self {
            builder: self.builder.property("justification", justification),
        }
    }

    /// The default left margin for text in the text view.
    ///
    /// Tags in the buffer may override the default.
    ///
    /// Note that this property is confusingly named. In CSS terms,
    /// the value set here is padding, and it is applied in addition
    /// to the padding from the theme.
    pub fn left_margin(self, left_margin: i32) -> Self {
        Self {
            builder: self.builder.property("left-margin", left_margin),
        }
    }

    /// Whether text should be displayed in a monospace font.
    ///
    /// If [`true`], set the .monospace style class on the
    /// text view to indicate that a monospace font is desired.
    pub fn monospace(self, monospace: bool) -> Self {
        Self {
            builder: self.builder.property("monospace", monospace),
        }
    }

    /// Whether entered text overwrites existing contents.
    pub fn overwrite(self, overwrite: bool) -> Self {
        Self {
            builder: self.builder.property("overwrite", overwrite),
        }
    }

    /// Pixels of blank space above paragraphs.
    pub fn pixels_above_lines(self, pixels_above_lines: i32) -> Self {
        Self {
            builder: self
                .builder
                .property("pixels-above-lines", pixels_above_lines),
        }
    }

    /// Pixels of blank space below paragraphs.
    pub fn pixels_below_lines(self, pixels_below_lines: i32) -> Self {
        Self {
            builder: self
                .builder
                .property("pixels-below-lines", pixels_below_lines),
        }
    }

    /// Pixels of blank space between wrapped lines in a paragraph.
    pub fn pixels_inside_wrap(self, pixels_inside_wrap: i32) -> Self {
        Self {
            builder: self
                .builder
                .property("pixels-inside-wrap", pixels_inside_wrap),
        }
    }

    /// The default right margin for text in the text view.
    ///
    /// Tags in the buffer may override the default.
    ///
    /// Note that this property is confusingly named. In CSS terms,
    /// the value set here is padding, and it is applied in addition
    /// to the padding from the theme.
    pub fn right_margin(self, right_margin: i32) -> Self {
        Self {
            builder: self.builder.property("right-margin", right_margin),
        }
    }

    /// Custom tabs for this text.
    pub fn tabs(self, tabs: &pango::TabArray) -> Self {
        Self {
            builder: self.builder.property("tabs", tabs),
        }
    }

    /// The top margin for text in the text view.
    ///
    /// Note that this property is confusingly named. In CSS terms,
    /// the value set here is padding, and it is applied in addition
    /// to the padding from the theme.
    ///
    /// Don't confuse this property with [`margin-top`][struct@crate::Widget#margin-top].
    pub fn top_margin(self, top_margin: i32) -> Self {
        Self {
            builder: self.builder.property("top-margin", top_margin),
        }
    }

    /// Whether to wrap lines never, at word boundaries, or at character boundaries.
    pub fn wrap_mode(self, wrap_mode: WrapMode) -> Self {
        Self {
            builder: self.builder.property("wrap-mode", wrap_mode),
        }
    }

    /// 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`][struct@crate::Widget#query-tooltip]
    /// signal on @widget.
    ///
    /// A true value 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),
        }
    }

    /// Overrides 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()),
        }
    }

    /// Makes this widget act like a modal dialog, with respect to
    /// event delivery.
    ///
    /// Global event controllers will not handle events with targets
    /// inside the widget, unless they are set up to ignore propagation
    /// limits. See [`EventControllerExt::set_propagation_limit()`][crate::prelude::EventControllerExt::set_propagation_limit()].
    #[cfg(feature = "v4_18")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v4_18")))]
    pub fn limit_events(self, limit_events: bool) -> Self {
        Self {
            builder: self.builder.property("limit-events", limit_events),
        }
    }

    /// 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 `NULL`:
    /// [`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 `NULL`:
    /// [`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),
        }
    }

    /// Overrides 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 [`TextView`].
    #[must_use = "Building the object from the builder is usually expensive and is not expected to have side effects"]
    pub fn build(self) -> TextView {
        assert_initialized_main_thread!();
        self.builder.build()
    }
}

/// Trait containing all [`struct@TextView`] methods.
///
/// # Implementors
///
/// [`TextView`][struct@crate::TextView]
pub trait TextViewExt: IsA<TextView> + 'static {
    /// Adds a child widget in the text buffer, at the given @anchor.
    /// ## `child`
    /// a [`Widget`][crate::Widget]
    /// ## `anchor`
    /// a [`TextChildAnchor`][crate::TextChildAnchor] in the [`TextBuffer`][crate::TextBuffer] for @self
    #[doc(alias = "gtk_text_view_add_child_at_anchor")]
    fn add_child_at_anchor(&self, child: &impl IsA<Widget>, anchor: &impl IsA<TextChildAnchor>) {
        unsafe {
            ffi::gtk_text_view_add_child_at_anchor(
                self.as_ref().to_glib_none().0,
                child.as_ref().to_glib_none().0,
                anchor.as_ref().to_glib_none().0,
            );
        }
    }

    /// Adds @child at a fixed coordinate in the [`TextView`][crate::TextView]'s text window.
    ///
    /// The @xpos and @ypos must be in buffer coordinates (see
    /// [`iter_location()`][Self::iter_location()] to convert to
    /// buffer coordinates).
    ///
    /// @child will scroll with the text view.
    ///
    /// If instead you want a widget that will not move with the
    /// [`TextView`][crate::TextView] contents see [`Overlay`][crate::Overlay].
    /// ## `child`
    /// a [`Widget`][crate::Widget]
    /// ## `xpos`
    /// X position of child in window coordinates
    /// ## `ypos`
    /// Y position of child in window coordinates
    #[doc(alias = "gtk_text_view_add_overlay")]
    fn add_overlay(&self, child: &impl IsA<Widget>, xpos: i32, ypos: i32) {
        unsafe {
            ffi::gtk_text_view_add_overlay(
                self.as_ref().to_glib_none().0,
                child.as_ref().to_glib_none().0,
                xpos,
                ypos,
            );
        }
    }

    /// Moves the given @iter backward by one display (wrapped) line.
    ///
    /// A display line is different from a paragraph. Paragraphs are
    /// separated by newlines or other paragraph separator characters.
    /// Display lines are created by line-wrapping a paragraph. If
    /// wrapping is turned off, display lines and paragraphs will be the
    /// same. Display lines are divided differently for each view, since
    /// they depend on the view’s width; paragraphs are the same in all
    /// views, since they depend on the contents of the [`TextBuffer`][crate::TextBuffer].
    /// ## `iter`
    /// a [`TextIter`][crate::TextIter]
    ///
    /// # Returns
    ///
    /// [`true`] if @iter was moved and is not on the end iterator
    #[doc(alias = "gtk_text_view_backward_display_line")]
    fn backward_display_line(&self, iter: &mut TextIter) -> bool {
        unsafe {
            from_glib(ffi::gtk_text_view_backward_display_line(
                self.as_ref().to_glib_none().0,
                iter.to_glib_none_mut().0,
            ))
        }
    }

    /// Moves the given @iter backward to the next display line start.
    ///
    /// A display line is different from a paragraph. Paragraphs are
    /// separated by newlines or other paragraph separator characters.
    /// Display lines are created by line-wrapping a paragraph. If
    /// wrapping is turned off, display lines and paragraphs will be the
    /// same. Display lines are divided differently for each view, since
    /// they depend on the view’s width; paragraphs are the same in all
    /// views, since they depend on the contents of the [`TextBuffer`][crate::TextBuffer].
    /// ## `iter`
    /// a [`TextIter`][crate::TextIter]
    ///
    /// # Returns
    ///
    /// [`true`] if @iter was moved and is not on the end iterator
    #[doc(alias = "gtk_text_view_backward_display_line_start")]
    fn backward_display_line_start(&self, iter: &mut TextIter) -> bool {
        unsafe {
            from_glib(ffi::gtk_text_view_backward_display_line_start(
                self.as_ref().to_glib_none().0,
                iter.to_glib_none_mut().0,
            ))
        }
    }

    /// Converts buffer coordinates to window coordinates.
    /// ## `win`
    /// a [`TextWindowType`][crate::TextWindowType]
    /// ## `buffer_x`
    /// buffer x coordinate
    /// ## `buffer_y`
    /// buffer y coordinate
    ///
    /// # Returns
    ///
    ///
    /// ## `window_x`
    /// window x coordinate return location
    ///
    /// ## `window_y`
    /// window y coordinate return location
    #[doc(alias = "gtk_text_view_buffer_to_window_coords")]
    fn buffer_to_window_coords(
        &self,
        win: TextWindowType,
        buffer_x: i32,
        buffer_y: i32,
    ) -> (i32, i32) {
        unsafe {
            let mut window_x = std::mem::MaybeUninit::uninit();
            let mut window_y = std::mem::MaybeUninit::uninit();
            ffi::gtk_text_view_buffer_to_window_coords(
                self.as_ref().to_glib_none().0,
                win.into_glib(),
                buffer_x,
                buffer_y,
                window_x.as_mut_ptr(),
                window_y.as_mut_ptr(),
            );
            (window_x.assume_init(), window_y.assume_init())
        }
    }

    /// Moves the given @iter forward by one display (wrapped) line.
    ///
    /// A display line is different from a paragraph. Paragraphs are
    /// separated by newlines or other paragraph separator characters.
    /// Display lines are created by line-wrapping a paragraph. If
    /// wrapping is turned off, display lines and paragraphs will be the
    /// same. Display lines are divided differently for each view, since
    /// they depend on the view’s width; paragraphs are the same in all
    /// views, since they depend on the contents of the [`TextBuffer`][crate::TextBuffer].
    /// ## `iter`
    /// a [`TextIter`][crate::TextIter]
    ///
    /// # Returns
    ///
    /// [`true`] if @iter was moved and is not on the end iterator
    #[doc(alias = "gtk_text_view_forward_display_line")]
    fn forward_display_line(&self, iter: &mut TextIter) -> bool {
        unsafe {
            from_glib(ffi::gtk_text_view_forward_display_line(
                self.as_ref().to_glib_none().0,
                iter.to_glib_none_mut().0,
            ))
        }
    }

    /// Moves the given @iter forward to the next display line end.
    ///
    /// A display line is different from a paragraph. Paragraphs are
    /// separated by newlines or other paragraph separator characters.
    /// Display lines are created by line-wrapping a paragraph. If
    /// wrapping is turned off, display lines and paragraphs will be the
    /// same. Display lines are divided differently for each view, since
    /// they depend on the view’s width; paragraphs are the same in all
    /// views, since they depend on the contents of the [`TextBuffer`][crate::TextBuffer].
    /// ## `iter`
    /// a [`TextIter`][crate::TextIter]
    ///
    /// # Returns
    ///
    /// [`true`] if @iter was moved and is not on the end iterator
    #[doc(alias = "gtk_text_view_forward_display_line_end")]
    fn forward_display_line_end(&self, iter: &mut TextIter) -> bool {
        unsafe {
            from_glib(ffi::gtk_text_view_forward_display_line_end(
                self.as_ref().to_glib_none().0,
                iter.to_glib_none_mut().0,
            ))
        }
    }

    /// Returns whether pressing the <kbd>Tab</kbd> key inserts a tab characters.
    ///
    /// See [`set_accepts_tab()`][Self::set_accepts_tab()].
    ///
    /// # Returns
    ///
    /// [`true`] if pressing the Tab key inserts a tab character,
    ///   [`false`] if pressing the Tab key moves the keyboard focus.
    #[doc(alias = "gtk_text_view_get_accepts_tab")]
    #[doc(alias = "get_accepts_tab")]
    #[doc(alias = "accepts-tab")]
    fn accepts_tab(&self) -> bool {
        unsafe {
            from_glib(ffi::gtk_text_view_get_accepts_tab(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Gets the bottom margin for text in the @self.
    ///
    /// # Returns
    ///
    /// bottom margin in pixels
    #[doc(alias = "gtk_text_view_get_bottom_margin")]
    #[doc(alias = "get_bottom_margin")]
    #[doc(alias = "bottom-margin")]
    fn bottom_margin(&self) -> i32 {
        unsafe { ffi::gtk_text_view_get_bottom_margin(self.as_ref().to_glib_none().0) }
    }

    /// Returns the [`TextBuffer`][crate::TextBuffer] being displayed by this text view.
    ///
    /// The reference count on the buffer is not incremented; the caller
    /// of this function won’t own a new reference.
    ///
    /// # Returns
    ///
    /// a [`TextBuffer`][crate::TextBuffer]
    #[doc(alias = "gtk_text_view_get_buffer")]
    #[doc(alias = "get_buffer")]
    fn buffer(&self) -> TextBuffer {
        unsafe {
            from_glib_none(ffi::gtk_text_view_get_buffer(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Determine the positions of the strong and weak cursors if the
    /// insertion point is at @iter.
    ///
    /// The position of each cursor is stored as a zero-width rectangle.
    /// The strong cursor location is the location where characters of
    /// the directionality equal to the base direction of the paragraph
    /// are inserted. The weak cursor location is the location where
    /// characters of the directionality opposite to the base direction
    /// of the paragraph are inserted.
    ///
    /// If @iter is [`None`], the actual cursor position is used.
    ///
    /// Note that if @iter happens to be the actual cursor position, and
    /// there is currently an IM preedit sequence being entered, the
    /// returned locations will be adjusted to account for the preedit
    /// cursor’s offset within the preedit sequence.
    ///
    /// The rectangle position is in buffer coordinates; use
    /// [`buffer_to_window_coords()`][Self::buffer_to_window_coords()] to convert these
    /// coordinates to coordinates for one of the windows in the text view.
    /// ## `iter`
    /// a [`TextIter`][crate::TextIter]
    ///
    /// # Returns
    ///
    ///
    /// ## `strong`
    /// location to store the strong cursor position
    ///
    /// ## `weak`
    /// location to store the weak cursor position
    #[doc(alias = "gtk_text_view_get_cursor_locations")]
    #[doc(alias = "get_cursor_locations")]
    fn cursor_locations(&self, iter: Option<&TextIter>) -> (gdk::Rectangle, gdk::Rectangle) {
        unsafe {
            let mut strong = gdk::Rectangle::uninitialized();
            let mut weak = gdk::Rectangle::uninitialized();
            ffi::gtk_text_view_get_cursor_locations(
                self.as_ref().to_glib_none().0,
                iter.to_glib_none().0,
                strong.to_glib_none_mut().0,
                weak.to_glib_none_mut().0,
            );
            (strong, weak)
        }
    }

    /// Find out whether the cursor should be displayed.
    ///
    /// # Returns
    ///
    /// whether the insertion mark is visible
    #[doc(alias = "gtk_text_view_get_cursor_visible")]
    #[doc(alias = "get_cursor_visible")]
    #[doc(alias = "cursor-visible")]
    fn is_cursor_visible(&self) -> bool {
        unsafe {
            from_glib(ffi::gtk_text_view_get_cursor_visible(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Returns the default editability of the [`TextView`][crate::TextView].
    ///
    /// Tags in the buffer may override this setting for some ranges of text.
    ///
    /// # Returns
    ///
    /// whether text is editable by default
    #[doc(alias = "gtk_text_view_get_editable")]
    #[doc(alias = "get_editable")]
    #[doc(alias = "editable")]
    fn is_editable(&self) -> bool {
        unsafe {
            from_glib(ffi::gtk_text_view_get_editable(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Gets the menu model that gets added to the context menu
    /// or [`None`] if none has been set.
    ///
    /// # Returns
    ///
    /// the menu model
    #[doc(alias = "gtk_text_view_get_extra_menu")]
    #[doc(alias = "get_extra_menu")]
    #[doc(alias = "extra-menu")]
    fn extra_menu(&self) -> gio::MenuModel {
        unsafe {
            from_glib_none(ffi::gtk_text_view_get_extra_menu(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Gets a [`Widget`][crate::Widget] that has previously been set as gutter.
    ///
    /// See [`set_gutter()`][Self::set_gutter()].
    ///
    /// @win must be one of [`TextWindowType::Left`][crate::TextWindowType::Left], [`TextWindowType::Right`][crate::TextWindowType::Right],
    /// [`TextWindowType::Top`][crate::TextWindowType::Top], or [`TextWindowType::Bottom`][crate::TextWindowType::Bottom].
    /// ## `win`
    /// a [`TextWindowType`][crate::TextWindowType]
    ///
    /// # Returns
    ///
    /// a [`Widget`][crate::Widget]
    #[doc(alias = "gtk_text_view_get_gutter")]
    #[doc(alias = "get_gutter")]
    fn gutter(&self, win: TextWindowType) -> Option<Widget> {
        unsafe {
            from_glib_none(ffi::gtk_text_view_get_gutter(
                self.as_ref().to_glib_none().0,
                win.into_glib(),
            ))
        }
    }

    /// Gets the default indentation of paragraphs in @self.
    ///
    /// Tags in the view’s buffer may override the default.
    /// The indentation may be negative.
    ///
    /// # Returns
    ///
    /// number of pixels of indentation
    #[doc(alias = "gtk_text_view_get_indent")]
    #[doc(alias = "get_indent")]
    fn indent(&self) -> i32 {
        unsafe { ffi::gtk_text_view_get_indent(self.as_ref().to_glib_none().0) }
    }

    /// Gets the `input-hints` of the [`TextView`][crate::TextView].
    ///
    /// # Returns
    ///
    /// the input hints
    #[doc(alias = "gtk_text_view_get_input_hints")]
    #[doc(alias = "get_input_hints")]
    #[doc(alias = "input-hints")]
    fn input_hints(&self) -> InputHints {
        unsafe {
            from_glib(ffi::gtk_text_view_get_input_hints(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Gets the `input-purpose` of the [`TextView`][crate::TextView].
    ///
    /// # Returns
    ///
    /// the input purpose
    #[doc(alias = "gtk_text_view_get_input_purpose")]
    #[doc(alias = "get_input_purpose")]
    #[doc(alias = "input-purpose")]
    fn input_purpose(&self) -> InputPurpose {
        unsafe {
            from_glib(ffi::gtk_text_view_get_input_purpose(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Retrieves the iterator at buffer coordinates @x and @y.
    ///
    /// Buffer coordinates are coordinates for the entire buffer, not just
    /// the currently-displayed portion. If you have coordinates from an
    /// event, you have to convert those to buffer coordinates with
    /// [`window_to_buffer_coords()`][Self::window_to_buffer_coords()].
    /// ## `x`
    /// x position, in buffer coordinates
    /// ## `y`
    /// y position, in buffer coordinates
    ///
    /// # Returns
    ///
    /// [`true`] if the position is over text
    ///
    /// ## `iter`
    /// a [`TextIter`][crate::TextIter]
    #[doc(alias = "gtk_text_view_get_iter_at_location")]
    #[doc(alias = "get_iter_at_location")]
    fn iter_at_location(&self, x: i32, y: i32) -> Option<TextIter> {
        unsafe {
            let mut iter = TextIter::uninitialized();
            let ret = from_glib(ffi::gtk_text_view_get_iter_at_location(
                self.as_ref().to_glib_none().0,
                iter.to_glib_none_mut().0,
                x,
                y,
            ));
            if ret {
                Some(iter)
            } else {
                None
            }
        }
    }

    /// Retrieves the iterator pointing to the character at buffer
    /// coordinates @x and @y.
    ///
    /// Buffer coordinates are coordinates for the entire buffer, not just
    /// the currently-displayed portion. If you have coordinates from an event,
    /// you have to convert those to buffer coordinates with
    /// [`window_to_buffer_coords()`][Self::window_to_buffer_coords()].
    ///
    /// Note that this is different from [`iter_at_location()`][Self::iter_at_location()],
    /// which returns cursor locations, i.e. positions between characters.
    /// ## `x`
    /// x position, in buffer coordinates
    /// ## `y`
    /// y position, in buffer coordinates
    ///
    /// # Returns
    ///
    /// [`true`] if the position is over text
    ///
    /// ## `iter`
    /// a [`TextIter`][crate::TextIter]
    ///
    /// ## `trailing`
    /// if non-[`None`], location to store
    ///    an integer indicating where in the grapheme the user clicked.
    ///    It will either be zero, or the number of characters in the grapheme.
    ///    0 represents the trailing edge of the grapheme.
    #[doc(alias = "gtk_text_view_get_iter_at_position")]
    #[doc(alias = "get_iter_at_position")]
    fn iter_at_position(&self, x: i32, y: i32) -> Option<(TextIter, i32)> {
        unsafe {
            let mut iter = TextIter::uninitialized();
            let mut trailing = std::mem::MaybeUninit::uninit();
            let ret = from_glib(ffi::gtk_text_view_get_iter_at_position(
                self.as_ref().to_glib_none().0,
                iter.to_glib_none_mut().0,
                trailing.as_mut_ptr(),
                x,
                y,
            ));
            if ret {
                Some((iter, trailing.assume_init()))
            } else {
                None
            }
        }
    }

    /// Gets a rectangle which roughly contains the character at @iter.
    ///
    /// The rectangle position is in buffer coordinates; use
    /// [`buffer_to_window_coords()`][Self::buffer_to_window_coords()] to convert these
    /// coordinates to coordinates for one of the windows in the text view.
    /// ## `iter`
    /// a [`TextIter`][crate::TextIter]
    ///
    /// # Returns
    ///
    ///
    /// ## `location`
    /// bounds of the character at @iter
    #[doc(alias = "gtk_text_view_get_iter_location")]
    #[doc(alias = "get_iter_location")]
    fn iter_location(&self, iter: &TextIter) -> gdk::Rectangle {
        unsafe {
            let mut location = gdk::Rectangle::uninitialized();
            ffi::gtk_text_view_get_iter_location(
                self.as_ref().to_glib_none().0,
                iter.to_glib_none().0,
                location.to_glib_none_mut().0,
            );
            location
        }
    }

    /// Gets the default justification of paragraphs in @self.
    ///
    /// Tags in the buffer may override the default.
    ///
    /// # Returns
    ///
    /// default justification
    #[doc(alias = "gtk_text_view_get_justification")]
    #[doc(alias = "get_justification")]
    fn justification(&self) -> Justification {
        unsafe {
            from_glib(ffi::gtk_text_view_get_justification(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Gets the default left margin size of paragraphs in the @self.
    ///
    /// Tags in the buffer may override the default.
    ///
    /// # Returns
    ///
    /// left margin in pixels
    #[doc(alias = "gtk_text_view_get_left_margin")]
    #[doc(alias = "get_left_margin")]
    #[doc(alias = "left-margin")]
    fn left_margin(&self) -> i32 {
        unsafe { ffi::gtk_text_view_get_left_margin(self.as_ref().to_glib_none().0) }
    }

    /// Gets the [`TextIter`][crate::TextIter] at the start of the line containing
    /// the coordinate @y.
    ///
    /// @y is in buffer coordinates, convert from window coordinates with
    /// [`window_to_buffer_coords()`][Self::window_to_buffer_coords()]. If non-[`None`],
    /// @line_top will be filled with the coordinate of the top edge
    /// of the line.
    /// ## `y`
    /// a y coordinate
    ///
    /// # Returns
    ///
    ///
    /// ## `target_iter`
    /// a [`TextIter`][crate::TextIter]
    ///
    /// ## `line_top`
    /// return location for top coordinate of the line
    #[doc(alias = "gtk_text_view_get_line_at_y")]
    #[doc(alias = "get_line_at_y")]
    fn line_at_y(&self, y: i32) -> (TextIter, i32) {
        unsafe {
            let mut target_iter = TextIter::uninitialized();
            let mut line_top = std::mem::MaybeUninit::uninit();
            ffi::gtk_text_view_get_line_at_y(
                self.as_ref().to_glib_none().0,
                target_iter.to_glib_none_mut().0,
                y,
                line_top.as_mut_ptr(),
            );
            (target_iter, line_top.assume_init())
        }
    }

    /// Gets the y coordinate of the top of the line containing @iter,
    /// and the height of the line.
    ///
    /// The coordinate is a buffer coordinate; convert to window
    /// coordinates with [`buffer_to_window_coords()`][Self::buffer_to_window_coords()].
    /// ## `iter`
    /// a [`TextIter`][crate::TextIter]
    ///
    /// # Returns
    ///
    ///
    /// ## `y`
    /// return location for a y coordinate
    ///
    /// ## `height`
    /// return location for a height
    #[doc(alias = "gtk_text_view_get_line_yrange")]
    #[doc(alias = "get_line_yrange")]
    fn line_yrange(&self, iter: &TextIter) -> (i32, i32) {
        unsafe {
            let mut y = std::mem::MaybeUninit::uninit();
            let mut height = std::mem::MaybeUninit::uninit();
            ffi::gtk_text_view_get_line_yrange(
                self.as_ref().to_glib_none().0,
                iter.to_glib_none().0,
                y.as_mut_ptr(),
                height.as_mut_ptr(),
            );
            (y.assume_init(), height.assume_init())
        }
    }

    /// Gets the [`pango::Context`][crate::pango::Context] that is used for rendering LTR directed
    /// text layouts.
    ///
    /// The context may be replaced when CSS changes occur.
    ///
    /// # Returns
    ///
    /// a [`pango::Context`][crate::pango::Context]
    #[cfg(feature = "v4_4")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v4_4")))]
    #[doc(alias = "gtk_text_view_get_ltr_context")]
    #[doc(alias = "get_ltr_context")]
    fn ltr_context(&self) -> pango::Context {
        unsafe {
            from_glib_none(ffi::gtk_text_view_get_ltr_context(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Gets whether the [`TextView`][crate::TextView] uses monospace styling.
    ///
    /// # Returns
    ///
    /// [`true`] if monospace fonts are desired
    #[doc(alias = "gtk_text_view_get_monospace")]
    #[doc(alias = "get_monospace")]
    #[doc(alias = "monospace")]
    fn is_monospace(&self) -> bool {
        unsafe {
            from_glib(ffi::gtk_text_view_get_monospace(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Returns whether the [`TextView`][crate::TextView] is in overwrite mode or not.
    ///
    /// # Returns
    ///
    /// whether @self is in overwrite mode or not.
    #[doc(alias = "gtk_text_view_get_overwrite")]
    #[doc(alias = "get_overwrite")]
    #[doc(alias = "overwrite")]
    fn overwrites(&self) -> bool {
        unsafe {
            from_glib(ffi::gtk_text_view_get_overwrite(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Gets the default number of pixels to put above paragraphs.
    ///
    /// Adding this function with [`pixels_below_lines()`][Self::pixels_below_lines()]
    /// is equal to the line space between each paragraph.
    ///
    /// # Returns
    ///
    /// default number of pixels above paragraphs
    #[doc(alias = "gtk_text_view_get_pixels_above_lines")]
    #[doc(alias = "get_pixels_above_lines")]
    #[doc(alias = "pixels-above-lines")]
    fn pixels_above_lines(&self) -> i32 {
        unsafe { ffi::gtk_text_view_get_pixels_above_lines(self.as_ref().to_glib_none().0) }
    }

    /// Gets the default number of pixels to put below paragraphs.
    ///
    /// The line space is the sum of the value returned by this function and
    /// the value returned by [`pixels_above_lines()`][Self::pixels_above_lines()].
    ///
    /// # Returns
    ///
    /// default number of blank pixels below paragraphs
    #[doc(alias = "gtk_text_view_get_pixels_below_lines")]
    #[doc(alias = "get_pixels_below_lines")]
    #[doc(alias = "pixels-below-lines")]
    fn pixels_below_lines(&self) -> i32 {
        unsafe { ffi::gtk_text_view_get_pixels_below_lines(self.as_ref().to_glib_none().0) }
    }

    /// Gets the default number of pixels to put between wrapped lines
    /// inside a paragraph.
    ///
    /// # Returns
    ///
    /// default number of pixels of blank space between wrapped lines
    #[doc(alias = "gtk_text_view_get_pixels_inside_wrap")]
    #[doc(alias = "get_pixels_inside_wrap")]
    #[doc(alias = "pixels-inside-wrap")]
    fn pixels_inside_wrap(&self) -> i32 {
        unsafe { ffi::gtk_text_view_get_pixels_inside_wrap(self.as_ref().to_glib_none().0) }
    }

    /// Gets the default right margin for text in @self.
    ///
    /// Tags in the buffer may override the default.
    ///
    /// # Returns
    ///
    /// right margin in pixels
    #[doc(alias = "gtk_text_view_get_right_margin")]
    #[doc(alias = "get_right_margin")]
    #[doc(alias = "right-margin")]
    fn right_margin(&self) -> i32 {
        unsafe { ffi::gtk_text_view_get_right_margin(self.as_ref().to_glib_none().0) }
    }

    /// Gets the [`pango::Context`][crate::pango::Context] that is used for rendering RTL directed
    /// text layouts.
    ///
    /// The context may be replaced when CSS changes occur.
    ///
    /// # Returns
    ///
    /// a [`pango::Context`][crate::pango::Context]
    #[cfg(feature = "v4_4")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v4_4")))]
    #[doc(alias = "gtk_text_view_get_rtl_context")]
    #[doc(alias = "get_rtl_context")]
    fn rtl_context(&self) -> pango::Context {
        unsafe {
            from_glib_none(ffi::gtk_text_view_get_rtl_context(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Gets the default tabs for @self.
    ///
    /// Tags in the buffer may override the defaults. The returned array
    /// will be [`None`] if “standard” (8-space) tabs are used. Free the
    /// return value with `Pango::TabArray::free()`.
    ///
    /// # Returns
    ///
    /// copy of default tab array,
    ///   or [`None`] if standard tabs are used; must be freed with
    ///   `Pango::TabArray::free()`.
    #[doc(alias = "gtk_text_view_get_tabs")]
    #[doc(alias = "get_tabs")]
    fn tabs(&self) -> Option<pango::TabArray> {
        unsafe { from_glib_full(ffi::gtk_text_view_get_tabs(self.as_ref().to_glib_none().0)) }
    }

    /// Gets the top margin for text in the @self.
    ///
    /// # Returns
    ///
    /// top margin in pixels
    #[doc(alias = "gtk_text_view_get_top_margin")]
    #[doc(alias = "get_top_margin")]
    #[doc(alias = "top-margin")]
    fn top_margin(&self) -> i32 {
        unsafe { ffi::gtk_text_view_get_top_margin(self.as_ref().to_glib_none().0) }
    }

    /// Gets the X,Y offset in buffer coordinates of the top-left corner of
    /// the textview's text contents.
    ///
    /// This allows for more-precise positioning than what is provided by
    /// [`visible_rect()`][Self::visible_rect()]()] as you can discover what
    /// device pixel is being quantized for text positioning.
    ///
    /// You might want this when making ulterior widgets align with quantized
    /// device pixels of the textview contents such as line numbers.
    ///
    /// # Returns
    ///
    ///
    /// ## `x_offset`
    /// a location for the X offset
    ///
    /// ## `y_offset`
    /// a location for the Y offset
    #[cfg(feature = "v4_18")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v4_18")))]
    #[doc(alias = "gtk_text_view_get_visible_offset")]
    #[doc(alias = "get_visible_offset")]
    fn visible_offset(&self) -> (f64, f64) {
        unsafe {
            let mut x_offset = std::mem::MaybeUninit::uninit();
            let mut y_offset = std::mem::MaybeUninit::uninit();
            ffi::gtk_text_view_get_visible_offset(
                self.as_ref().to_glib_none().0,
                x_offset.as_mut_ptr(),
                y_offset.as_mut_ptr(),
            );
            (x_offset.assume_init(), y_offset.assume_init())
        }
    }

    /// Fills @visible_rect with the currently-visible
    /// region of the buffer, in buffer coordinates.
    ///
    /// Convert to window coordinates with
    /// [`buffer_to_window_coords()`][Self::buffer_to_window_coords()].
    ///
    /// # Returns
    ///
    ///
    /// ## `visible_rect`
    /// rectangle to fill
    #[doc(alias = "gtk_text_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_text_view_get_visible_rect(
                self.as_ref().to_glib_none().0,
                visible_rect.to_glib_none_mut().0,
            );
            visible_rect
        }
    }

    /// Gets the line wrapping for the view.
    ///
    /// # Returns
    ///
    /// the line wrap setting
    #[doc(alias = "gtk_text_view_get_wrap_mode")]
    #[doc(alias = "get_wrap_mode")]
    #[doc(alias = "wrap-mode")]
    fn wrap_mode(&self) -> WrapMode {
        unsafe {
            from_glib(ffi::gtk_text_view_get_wrap_mode(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Allow the [`TextView`][crate::TextView] input method to internally handle key press
    /// and release events.
    ///
    /// If this function returns [`true`], then no further processing should be
    /// done for this key event. See [`IMContextExt::filter_keypress()`][crate::prelude::IMContextExt::filter_keypress()].
    ///
    /// Note that you are expected to call this function from your handler
    /// when overriding key event handling. This is needed in the case when
    /// you need to insert your own key handling between the input method
    /// and the default key event handling of the [`TextView`][crate::TextView].
    ///
    /// **⚠️ The following code is in c ⚠️**
    ///
    /// ```c
    /// static gboolean
    /// gtk_foo_bar_key_press_event (GtkWidget *widget,
    ///                              GdkEvent  *event)
    /// {
    ///   guint keyval;
    ///
    ///   gdk_event_get_keyval ((GdkEvent*)event, &keyval);
    ///
    ///   if (keyval == GDK_KEY_Return || keyval == GDK_KEY_KP_Enter)
    ///     {
    ///       if (gtk_text_view_im_context_filter_keypress (GTK_TEXT_VIEW (widget), event))
    ///         return TRUE;
    ///     }
    ///
    ///   // Do some stuff
    ///
    ///   return GTK_WIDGET_CLASS (gtk_foo_bar_parent_class)->key_press_event (widget, event);
    /// }
    /// ```
    /// ## `event`
    /// the key event
    ///
    /// # Returns
    ///
    /// [`true`] if the input method handled the key event.
    #[doc(alias = "gtk_text_view_im_context_filter_keypress")]
    fn im_context_filter_keypress(&self, event: impl AsRef<gdk::Event>) -> bool {
        unsafe {
            from_glib(ffi::gtk_text_view_im_context_filter_keypress(
                self.as_ref().to_glib_none().0,
                event.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Moves a mark within the buffer so that it's
    /// located within the currently-visible text area.
    /// ## `mark`
    /// a [`TextMark`][crate::TextMark]
    ///
    /// # Returns
    ///
    /// [`true`] if the mark moved (wasn’t already onscreen)
    #[doc(alias = "gtk_text_view_move_mark_onscreen")]
    fn move_mark_onscreen(&self, mark: &impl IsA<TextMark>) -> bool {
        unsafe {
            from_glib(ffi::gtk_text_view_move_mark_onscreen(
                self.as_ref().to_glib_none().0,
                mark.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Updates the position of a child.
    ///
    /// See [`add_overlay()`][Self::add_overlay()].
    /// ## `child`
    /// a widget already added with [`add_overlay()`][Self::add_overlay()]
    /// ## `xpos`
    /// new X position in buffer coordinates
    /// ## `ypos`
    /// new Y position in buffer coordinates
    #[doc(alias = "gtk_text_view_move_overlay")]
    fn move_overlay(&self, child: &impl IsA<Widget>, xpos: i32, ypos: i32) {
        unsafe {
            ffi::gtk_text_view_move_overlay(
                self.as_ref().to_glib_none().0,
                child.as_ref().to_glib_none().0,
                xpos,
                ypos,
            );
        }
    }

    /// Move the iterator a given number of characters visually, treating
    /// it as the strong cursor position.
    ///
    /// If @count is positive, then the new strong cursor position will
    /// be @count positions to the right of the old cursor position.
    /// If @count is negative then the new strong cursor position will
    /// be @count positions to the left of the old cursor position.
    ///
    /// In the presence of bi-directional text, the correspondence
    /// between logical and visual order will depend on the direction
    /// of the current run, and there may be jumps when the cursor
    /// is moved off of the end of a run.
    /// ## `iter`
    /// a [`TextIter`][crate::TextIter]
    /// ## `count`
    /// number of characters to move (negative moves left,
    ///    positive moves right)
    ///
    /// # Returns
    ///
    /// [`true`] if @iter moved and is not on the end iterator
    #[doc(alias = "gtk_text_view_move_visually")]
    fn move_visually(&self, iter: &mut TextIter, count: i32) -> bool {
        unsafe {
            from_glib(ffi::gtk_text_view_move_visually(
                self.as_ref().to_glib_none().0,
                iter.to_glib_none_mut().0,
                count,
            ))
        }
    }

    /// Moves the cursor to the currently visible region of the
    /// buffer.
    ///
    /// # Returns
    ///
    /// [`true`] if the cursor had to be moved.
    #[doc(alias = "gtk_text_view_place_cursor_onscreen")]
    fn place_cursor_onscreen(&self) -> bool {
        unsafe {
            from_glib(ffi::gtk_text_view_place_cursor_onscreen(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Removes a child widget from @self.
    /// ## `child`
    /// the child to remove
    #[doc(alias = "gtk_text_view_remove")]
    fn remove(&self, child: &impl IsA<Widget>) {
        unsafe {
            ffi::gtk_text_view_remove(
                self.as_ref().to_glib_none().0,
                child.as_ref().to_glib_none().0,
            );
        }
    }

    /// Ensures that the cursor is shown.
    ///
    /// This also resets the time that it will stay blinking (or
    /// visible, in case blinking is disabled).
    ///
    /// This function should be called in response to user input
    /// (e.g. from derived classes that override the textview's
    /// event handlers).
    #[doc(alias = "gtk_text_view_reset_cursor_blink")]
    fn reset_cursor_blink(&self) {
        unsafe {
            ffi::gtk_text_view_reset_cursor_blink(self.as_ref().to_glib_none().0);
        }
    }

    /// Reset the input method context of the text view if needed.
    ///
    /// This can be necessary in the case where modifying the buffer
    /// would confuse on-going input method behavior.
    #[doc(alias = "gtk_text_view_reset_im_context")]
    fn reset_im_context(&self) {
        unsafe {
            ffi::gtk_text_view_reset_im_context(self.as_ref().to_glib_none().0);
        }
    }

    /// Scrolls @self the minimum distance such that @mark is contained
    /// within the visible area of the widget.
    /// ## `mark`
    /// a mark in the buffer for @self
    #[doc(alias = "gtk_text_view_scroll_mark_onscreen")]
    fn scroll_mark_onscreen(&self, mark: &impl IsA<TextMark>) {
        unsafe {
            ffi::gtk_text_view_scroll_mark_onscreen(
                self.as_ref().to_glib_none().0,
                mark.as_ref().to_glib_none().0,
            );
        }
    }

    /// Scrolls @self so that @iter is on the screen in the position
    /// indicated by @xalign and @yalign.
    ///
    /// An alignment of 0.0 indicates left or top, 1.0 indicates right or
    /// bottom, 0.5 means center. If @use_align is [`false`], the text scrolls
    /// the minimal distance to get the mark onscreen, possibly not scrolling
    /// at all. The effective screen for purposes of this function is reduced
    /// by a margin of size @within_margin.
    ///
    /// Note that this function uses the currently-computed height of the
    /// lines in the text buffer. Line heights are computed in an idle
    /// handler; so this function may not have the desired effect if it’s
    /// called before the height computations. To avoid oddness, consider
    /// using [`scroll_to_mark()`][Self::scroll_to_mark()] which saves a point to be
    /// scrolled to after line validation.
    /// ## `iter`
    /// a [`TextIter`][crate::TextIter]
    /// ## `within_margin`
    /// margin as a [0.0,0.5) fraction of screen size
    /// ## `use_align`
    /// whether to use alignment arguments (if [`false`],
    ///    just get the mark onscreen)
    /// ## `xalign`
    /// horizontal alignment of mark within visible area
    /// ## `yalign`
    /// vertical alignment of mark within visible area
    ///
    /// # Returns
    ///
    /// [`true`] if scrolling occurred
    #[doc(alias = "gtk_text_view_scroll_to_iter")]
    fn scroll_to_iter(
        &self,
        iter: &mut TextIter,
        within_margin: f64,
        use_align: bool,
        xalign: f64,
        yalign: f64,
    ) -> bool {
        unsafe {
            from_glib(ffi::gtk_text_view_scroll_to_iter(
                self.as_ref().to_glib_none().0,
                iter.to_glib_none_mut().0,
                within_margin,
                use_align.into_glib(),
                xalign,
                yalign,
            ))
        }
    }

    /// Scrolls @self so that @mark is on the screen in the position
    /// indicated by @xalign and @yalign.
    ///
    /// An alignment of 0.0 indicates left or top, 1.0 indicates right or
    /// bottom, 0.5 means center. If @use_align is [`false`], the text scrolls
    /// the minimal distance to get the mark onscreen, possibly not scrolling
    /// at all. The effective screen for purposes of this function is reduced
    /// by a margin of size @within_margin.
    /// ## `mark`
    /// a [`TextMark`][crate::TextMark]
    /// ## `within_margin`
    /// margin as a [0.0,0.5) fraction of screen size
    /// ## `use_align`
    /// whether to use alignment arguments (if [`false`], just
    ///    get the mark onscreen)
    /// ## `xalign`
    /// horizontal alignment of mark within visible area
    /// ## `yalign`
    /// vertical alignment of mark within visible area
    #[doc(alias = "gtk_text_view_scroll_to_mark")]
    fn scroll_to_mark(
        &self,
        mark: &impl IsA<TextMark>,
        within_margin: f64,
        use_align: bool,
        xalign: f64,
        yalign: f64,
    ) {
        unsafe {
            ffi::gtk_text_view_scroll_to_mark(
                self.as_ref().to_glib_none().0,
                mark.as_ref().to_glib_none().0,
                within_margin,
                use_align.into_glib(),
                xalign,
                yalign,
            );
        }
    }

    /// Sets the behavior of the text widget when the <kbd>Tab</kbd> key is pressed.
    ///
    /// If @accepts_tab is [`true`], a tab character is inserted. If @accepts_tab
    /// is [`false`] the keyboard focus is moved to the next widget in the focus
    /// chain.
    ///
    /// Focus can always be moved using <kbd>Ctrl</kbd>+<kbd>Tab</kbd>.
    /// ## `accepts_tab`
    /// [`true`] if pressing the Tab key should insert a tab
    ///    character, [`false`], if pressing the Tab key should move the
    ///    keyboard focus.
    #[doc(alias = "gtk_text_view_set_accepts_tab")]
    #[doc(alias = "accepts-tab")]
    fn set_accepts_tab(&self, accepts_tab: bool) {
        unsafe {
            ffi::gtk_text_view_set_accepts_tab(
                self.as_ref().to_glib_none().0,
                accepts_tab.into_glib(),
            );
        }
    }

    /// Sets the bottom margin for text in @self.
    ///
    /// Note that this function is confusingly named.
    /// In CSS terms, the value set here is padding.
    /// ## `bottom_margin`
    /// bottom margin in pixels
    #[doc(alias = "gtk_text_view_set_bottom_margin")]
    #[doc(alias = "bottom-margin")]
    fn set_bottom_margin(&self, bottom_margin: i32) {
        unsafe {
            ffi::gtk_text_view_set_bottom_margin(self.as_ref().to_glib_none().0, bottom_margin);
        }
    }

    /// Sets @buffer as the buffer being displayed by @self.
    ///
    /// The previous buffer displayed by the text view is unreferenced, and
    /// a reference is added to @buffer. If you owned a reference to @buffer
    /// before passing it to this function, you must remove that reference
    /// yourself; [`TextView`][crate::TextView] will not “adopt” it.
    /// ## `buffer`
    /// a [`TextBuffer`][crate::TextBuffer]
    #[doc(alias = "gtk_text_view_set_buffer")]
    #[doc(alias = "buffer")]
    fn set_buffer(&self, buffer: Option<&impl IsA<TextBuffer>>) {
        unsafe {
            ffi::gtk_text_view_set_buffer(
                self.as_ref().to_glib_none().0,
                buffer.map(|p| p.as_ref()).to_glib_none().0,
            );
        }
    }

    /// Toggles whether the insertion point should be displayed.
    ///
    /// A buffer with no editable text probably shouldn’t have a visible
    /// cursor, so you may want to turn the cursor off.
    ///
    /// Note that this property may be overridden by the
    /// [`gtk-keynav-use-caret`][struct@crate::Settings#gtk-keynav-use-caret] setting.
    /// ## `setting`
    /// whether to show the insertion cursor
    #[doc(alias = "gtk_text_view_set_cursor_visible")]
    #[doc(alias = "cursor-visible")]
    fn set_cursor_visible(&self, setting: bool) {
        unsafe {
            ffi::gtk_text_view_set_cursor_visible(
                self.as_ref().to_glib_none().0,
                setting.into_glib(),
            );
        }
    }

    /// Sets the default editability of the [`TextView`][crate::TextView].
    ///
    /// You can override this default setting with tags in the buffer,
    /// using the “editable” attribute of tags.
    /// ## `setting`
    /// whether it’s editable
    #[doc(alias = "gtk_text_view_set_editable")]
    #[doc(alias = "editable")]
    fn set_editable(&self, setting: bool) {
        unsafe {
            ffi::gtk_text_view_set_editable(self.as_ref().to_glib_none().0, setting.into_glib());
        }
    }

    /// Sets a menu model to add when constructing the context
    /// menu for @self.
    ///
    /// You can pass [`None`] to remove a previously set extra menu.
    /// ## `model`
    /// a `GMenuModel`
    #[doc(alias = "gtk_text_view_set_extra_menu")]
    #[doc(alias = "extra-menu")]
    fn set_extra_menu(&self, model: Option<&impl IsA<gio::MenuModel>>) {
        unsafe {
            ffi::gtk_text_view_set_extra_menu(
                self.as_ref().to_glib_none().0,
                model.map(|p| p.as_ref()).to_glib_none().0,
            );
        }
    }

    /// Places @widget into the gutter specified by @win.
    ///
    /// @win must be one of [`TextWindowType::Left`][crate::TextWindowType::Left], [`TextWindowType::Right`][crate::TextWindowType::Right],
    /// [`TextWindowType::Top`][crate::TextWindowType::Top], or [`TextWindowType::Bottom`][crate::TextWindowType::Bottom].
    /// ## `win`
    /// a [`TextWindowType`][crate::TextWindowType]
    /// ## `widget`
    /// a [`Widget`][crate::Widget]
    #[doc(alias = "gtk_text_view_set_gutter")]
    fn set_gutter(&self, win: TextWindowType, widget: Option<&impl IsA<Widget>>) {
        unsafe {
            ffi::gtk_text_view_set_gutter(
                self.as_ref().to_glib_none().0,
                win.into_glib(),
                widget.map(|p| p.as_ref()).to_glib_none().0,
            );
        }
    }

    /// Sets the default indentation for paragraphs in @self.
    ///
    /// Tags in the buffer may override the default.
    /// ## `indent`
    /// indentation in pixels
    #[doc(alias = "gtk_text_view_set_indent")]
    #[doc(alias = "indent")]
    fn set_indent(&self, indent: i32) {
        unsafe {
            ffi::gtk_text_view_set_indent(self.as_ref().to_glib_none().0, indent);
        }
    }

    /// Sets the `input-hints` of the [`TextView`][crate::TextView].
    ///
    /// The `input-hints` allow input methods to fine-tune
    /// their behaviour.
    /// ## `hints`
    /// the hints
    #[doc(alias = "gtk_text_view_set_input_hints")]
    #[doc(alias = "input-hints")]
    fn set_input_hints(&self, hints: InputHints) {
        unsafe {
            ffi::gtk_text_view_set_input_hints(self.as_ref().to_glib_none().0, hints.into_glib());
        }
    }

    /// Sets the `input-purpose` of the [`TextView`][crate::TextView].
    ///
    /// The `input-purpose` can be used by on-screen keyboards
    /// and other input methods to adjust their behaviour.
    /// ## `purpose`
    /// the purpose
    #[doc(alias = "gtk_text_view_set_input_purpose")]
    #[doc(alias = "input-purpose")]
    fn set_input_purpose(&self, purpose: InputPurpose) {
        unsafe {
            ffi::gtk_text_view_set_input_purpose(
                self.as_ref().to_glib_none().0,
                purpose.into_glib(),
            );
        }
    }

    /// Sets the default justification of text in @self.
    ///
    /// Tags in the view’s buffer may override the default.
    /// ## `justification`
    /// justification
    #[doc(alias = "gtk_text_view_set_justification")]
    #[doc(alias = "justification")]
    fn set_justification(&self, justification: Justification) {
        unsafe {
            ffi::gtk_text_view_set_justification(
                self.as_ref().to_glib_none().0,
                justification.into_glib(),
            );
        }
    }

    /// Sets the default left margin for text in @self.
    ///
    /// Tags in the buffer may override the default.
    ///
    /// Note that this function is confusingly named.
    /// In CSS terms, the value set here is padding.
    /// ## `left_margin`
    /// left margin in pixels
    #[doc(alias = "gtk_text_view_set_left_margin")]
    #[doc(alias = "left-margin")]
    fn set_left_margin(&self, left_margin: i32) {
        unsafe {
            ffi::gtk_text_view_set_left_margin(self.as_ref().to_glib_none().0, left_margin);
        }
    }

    /// Sets whether the [`TextView`][crate::TextView] should display text in
    /// monospace styling.
    /// ## `monospace`
    /// [`true`] to request monospace styling
    #[doc(alias = "gtk_text_view_set_monospace")]
    #[doc(alias = "monospace")]
    fn set_monospace(&self, monospace: bool) {
        unsafe {
            ffi::gtk_text_view_set_monospace(self.as_ref().to_glib_none().0, monospace.into_glib());
        }
    }

    /// Changes the [`TextView`][crate::TextView] overwrite mode.
    /// ## `overwrite`
    /// [`true`] to turn on overwrite mode, [`false`] to turn it off
    #[doc(alias = "gtk_text_view_set_overwrite")]
    #[doc(alias = "overwrite")]
    fn set_overwrite(&self, overwrite: bool) {
        unsafe {
            ffi::gtk_text_view_set_overwrite(self.as_ref().to_glib_none().0, overwrite.into_glib());
        }
    }

    /// Sets the default number of blank pixels above paragraphs in @self.
    ///
    /// Tags in the buffer for @self may override the defaults.
    /// ## `pixels_above_lines`
    /// pixels above paragraphs
    #[doc(alias = "gtk_text_view_set_pixels_above_lines")]
    #[doc(alias = "pixels-above-lines")]
    fn set_pixels_above_lines(&self, pixels_above_lines: i32) {
        unsafe {
            ffi::gtk_text_view_set_pixels_above_lines(
                self.as_ref().to_glib_none().0,
                pixels_above_lines,
            );
        }
    }

    /// Sets the default number of pixels of blank space
    /// to put below paragraphs in @self.
    ///
    /// May be overridden by tags applied to @self’s buffer.
    /// ## `pixels_below_lines`
    /// pixels below paragraphs
    #[doc(alias = "gtk_text_view_set_pixels_below_lines")]
    #[doc(alias = "pixels-below-lines")]
    fn set_pixels_below_lines(&self, pixels_below_lines: i32) {
        unsafe {
            ffi::gtk_text_view_set_pixels_below_lines(
                self.as_ref().to_glib_none().0,
                pixels_below_lines,
            );
        }
    }

    /// Sets the default number of pixels of blank space to leave between
    /// display/wrapped lines within a paragraph.
    ///
    /// May be overridden by tags in @self’s buffer.
    /// ## `pixels_inside_wrap`
    /// default number of pixels between wrapped lines
    #[doc(alias = "gtk_text_view_set_pixels_inside_wrap")]
    #[doc(alias = "pixels-inside-wrap")]
    fn set_pixels_inside_wrap(&self, pixels_inside_wrap: i32) {
        unsafe {
            ffi::gtk_text_view_set_pixels_inside_wrap(
                self.as_ref().to_glib_none().0,
                pixels_inside_wrap,
            );
        }
    }

    /// Sets the default right margin for text in the text view.
    ///
    /// Tags in the buffer may override the default.
    ///
    /// Note that this function is confusingly named.
    /// In CSS terms, the value set here is padding.
    /// ## `right_margin`
    /// right margin in pixels
    #[doc(alias = "gtk_text_view_set_right_margin")]
    #[doc(alias = "right-margin")]
    fn set_right_margin(&self, right_margin: i32) {
        unsafe {
            ffi::gtk_text_view_set_right_margin(self.as_ref().to_glib_none().0, right_margin);
        }
    }

    /// Sets the default tab stops for paragraphs in @self.
    ///
    /// Tags in the buffer may override the default.
    /// ## `tabs`
    /// tabs as a [`pango::TabArray`][crate::pango::TabArray]
    #[doc(alias = "gtk_text_view_set_tabs")]
    #[doc(alias = "tabs")]
    fn set_tabs(&self, tabs: &pango::TabArray) {
        unsafe {
            ffi::gtk_text_view_set_tabs(
                self.as_ref().to_glib_none().0,
                mut_override(tabs.to_glib_none().0),
            );
        }
    }

    /// Sets the top margin for text in @self.
    ///
    /// Note that this function is confusingly named.
    /// In CSS terms, the value set here is padding.
    /// ## `top_margin`
    /// top margin in pixels
    #[doc(alias = "gtk_text_view_set_top_margin")]
    #[doc(alias = "top-margin")]
    fn set_top_margin(&self, top_margin: i32) {
        unsafe {
            ffi::gtk_text_view_set_top_margin(self.as_ref().to_glib_none().0, top_margin);
        }
    }

    /// Sets the line wrapping for the view.
    /// ## `wrap_mode`
    /// a [`WrapMode`][crate::WrapMode]
    #[doc(alias = "gtk_text_view_set_wrap_mode")]
    #[doc(alias = "wrap-mode")]
    fn set_wrap_mode(&self, wrap_mode: WrapMode) {
        unsafe {
            ffi::gtk_text_view_set_wrap_mode(self.as_ref().to_glib_none().0, wrap_mode.into_glib());
        }
    }

    /// Determines whether @iter is at the start of a display line.
    ///
    /// See [`forward_display_line()`][Self::forward_display_line()] for an
    /// explanation of display lines vs. paragraphs.
    /// ## `iter`
    /// a [`TextIter`][crate::TextIter]
    ///
    /// # Returns
    ///
    /// [`true`] if @iter begins a wrapped line
    #[doc(alias = "gtk_text_view_starts_display_line")]
    fn starts_display_line(&self, iter: &TextIter) -> bool {
        unsafe {
            from_glib(ffi::gtk_text_view_starts_display_line(
                self.as_ref().to_glib_none().0,
                iter.to_glib_none().0,
            ))
        }
    }

    /// Converts coordinates on the window identified by @win to buffer
    /// coordinates.
    /// ## `win`
    /// a [`TextWindowType`][crate::TextWindowType]
    /// ## `window_x`
    /// window x coordinate
    /// ## `window_y`
    /// window y coordinate
    ///
    /// # Returns
    ///
    ///
    /// ## `buffer_x`
    /// buffer x coordinate return location
    ///
    /// ## `buffer_y`
    /// buffer y coordinate return location
    #[doc(alias = "gtk_text_view_window_to_buffer_coords")]
    fn window_to_buffer_coords(
        &self,
        win: TextWindowType,
        window_x: i32,
        window_y: i32,
    ) -> (i32, i32) {
        unsafe {
            let mut buffer_x = std::mem::MaybeUninit::uninit();
            let mut buffer_y = std::mem::MaybeUninit::uninit();
            ffi::gtk_text_view_window_to_buffer_coords(
                self.as_ref().to_glib_none().0,
                win.into_glib(),
                window_x,
                window_y,
                buffer_x.as_mut_ptr(),
                buffer_y.as_mut_ptr(),
            );
            (buffer_x.assume_init(), buffer_y.assume_init())
        }
    }

    /// Which IM (input method) module should be used for this text_view.
    ///
    /// See [`IMMulticontext`][crate::IMMulticontext].
    ///
    /// Setting this to a non-[`None`] value overrides the system-wide IM module
    /// setting. See the GtkSettings [`gtk-im-module`][struct@crate::Settings#gtk-im-module] property.
    #[doc(alias = "im-module")]
    fn im_module(&self) -> Option<glib::GString> {
        ObjectExt::property(self.as_ref(), "im-module")
    }

    /// Which IM (input method) module should be used for this text_view.
    ///
    /// See [`IMMulticontext`][crate::IMMulticontext].
    ///
    /// Setting this to a non-[`None`] value overrides the system-wide IM module
    /// setting. See the GtkSettings [`gtk-im-module`][struct@crate::Settings#gtk-im-module] property.
    #[doc(alias = "im-module")]
    fn set_im_module(&self, im_module: Option<&str>) {
        ObjectExt::set_property(self.as_ref(), "im-module", im_module)
    }

    /// Gets emitted when the user asks for it.
    ///
    /// The ::backspace signal is a [keybinding signal](class.SignalAction.html).
    ///
    /// The default bindings for this signal are
    /// <kbd>Backspace</kbd> and <kbd>Shift</kbd>+<kbd>Backspace</kbd>.
    #[doc(alias = "backspace")]
    fn connect_backspace<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn backspace_trampoline<P: IsA<TextView>, F: Fn(&P) + 'static>(
            this: *mut ffi::GtkTextView,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(TextView::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"backspace".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    backspace_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    fn emit_backspace(&self) {
        self.emit_by_name::<()>("backspace", &[]);
    }

    /// Gets emitted to copy the selection to the clipboard.
    ///
    /// The ::copy-clipboard signal is a [keybinding signal](class.SignalAction.html).
    ///
    /// The default bindings for this signal are
    /// <kbd>Ctrl</kbd>+<kbd>c</kbd> and
    /// <kbd>Ctrl</kbd>+<kbd>Insert</kbd>.
    #[doc(alias = "copy-clipboard")]
    fn connect_copy_clipboard<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn copy_clipboard_trampoline<P: IsA<TextView>, F: Fn(&P) + 'static>(
            this: *mut ffi::GtkTextView,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(TextView::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"copy-clipboard".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    copy_clipboard_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    fn emit_copy_clipboard(&self) {
        self.emit_by_name::<()>("copy-clipboard", &[]);
    }

    /// Gets emitted to cut the selection to the clipboard.
    ///
    /// The ::cut-clipboard signal is a [keybinding signal](class.SignalAction.html).
    ///
    /// The default bindings for this signal are
    /// <kbd>Ctrl</kbd>+<kbd>x</kbd> and
    /// <kbd>Shift</kbd>+<kbd>Delete</kbd>.
    #[doc(alias = "cut-clipboard")]
    fn connect_cut_clipboard<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn cut_clipboard_trampoline<P: IsA<TextView>, F: Fn(&P) + 'static>(
            this: *mut ffi::GtkTextView,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(TextView::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"cut-clipboard".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    cut_clipboard_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    fn emit_cut_clipboard(&self) {
        self.emit_by_name::<()>("cut-clipboard", &[]);
    }

    /// Gets emitted when the user initiates a text deletion.
    ///
    /// The ::delete-from-cursor signal is a [keybinding signal](class.SignalAction.html).
    ///
    /// If the @type_ is [`DeleteType::Chars`][crate::DeleteType::Chars], GTK deletes the selection
    /// if there is one, otherwise it deletes the requested number
    /// of characters.
    ///
    /// The default bindings for this signal are <kbd>Delete</kbd> for
    /// deleting a character, <kbd>Ctrl</kbd>+<kbd>Delete</kbd> for
    /// deleting a word and <kbd>Ctrl</kbd>+<kbd>Backspace</kbd> for
    /// deleting a word backwards.
    /// ## `type_`
    /// the granularity of the deletion, as a [`DeleteType`][crate::DeleteType]
    /// ## `count`
    /// the number of @type_ units to delete
    #[doc(alias = "delete-from-cursor")]
    fn connect_delete_from_cursor<F: Fn(&Self, DeleteType, i32) + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn delete_from_cursor_trampoline<
            P: IsA<TextView>,
            F: Fn(&P, DeleteType, i32) + 'static,
        >(
            this: *mut ffi::GtkTextView,
            type_: ffi::GtkDeleteType,
            count: std::ffi::c_int,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(
                TextView::from_glib_borrow(this).unsafe_cast_ref(),
                from_glib(type_),
                count,
            )
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"delete-from-cursor".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    delete_from_cursor_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    fn emit_delete_from_cursor(&self, type_: DeleteType, count: i32) {
        self.emit_by_name::<()>("delete-from-cursor", &[&type_, &count]);
    }

    /// Emitted when the selection needs to be extended at @location.
    /// ## `granularity`
    /// the granularity type
    /// ## `location`
    /// the location where to extend the selection
    /// ## `start`
    /// where the selection should start
    /// ## `end`
    /// where the selection should end
    ///
    /// # Returns
    ///
    /// `GDK_EVENT_STOP` to stop other handlers from being invoked for the
    ///   event. `GDK_EVENT_PROPAGATE` to propagate the event further.
    #[doc(alias = "extend-selection")]
    fn connect_extend_selection<
        F: Fn(&Self, TextExtendSelection, &TextIter, &TextIter, &TextIter) -> glib::Propagation
            + 'static,
    >(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn extend_selection_trampoline<
            P: IsA<TextView>,
            F: Fn(&P, TextExtendSelection, &TextIter, &TextIter, &TextIter) -> glib::Propagation
                + 'static,
        >(
            this: *mut ffi::GtkTextView,
            granularity: ffi::GtkTextExtendSelection,
            location: *mut ffi::GtkTextIter,
            start: *mut ffi::GtkTextIter,
            end: *mut ffi::GtkTextIter,
            f: glib::ffi::gpointer,
        ) -> glib::ffi::gboolean {
            let f: &F = &*(f as *const F);
            f(
                TextView::from_glib_borrow(this).unsafe_cast_ref(),
                from_glib(granularity),
                &from_glib_borrow(location),
                &from_glib_borrow(start),
                &from_glib_borrow(end),
            )
            .into_glib()
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"extend-selection".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    extend_selection_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    /// Gets emitted when the user initiates the insertion of a
    /// fixed string at the cursor.
    ///
    /// The ::insert-at-cursor signal is a [keybinding signal](class.SignalAction.html).
    ///
    /// This signal has no default bindings.
    /// ## `string`
    /// the string to insert
    #[doc(alias = "insert-at-cursor")]
    fn connect_insert_at_cursor<F: Fn(&Self, &str) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn insert_at_cursor_trampoline<
            P: IsA<TextView>,
            F: Fn(&P, &str) + 'static,
        >(
            this: *mut ffi::GtkTextView,
            string: *mut std::ffi::c_char,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(
                TextView::from_glib_borrow(this).unsafe_cast_ref(),
                &glib::GString::from_glib_borrow(string),
            )
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"insert-at-cursor".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    insert_at_cursor_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    fn emit_insert_at_cursor(&self, string: &str) {
        self.emit_by_name::<()>("insert-at-cursor", &[&string]);
    }

    /// Gets emitted to present the Emoji chooser for the @text_view.
    ///
    /// The ::insert-emoji signal is a [keybinding signal](class.SignalAction.html).
    ///
    /// The default bindings for this signal are
    /// <kbd>Ctrl</kbd>+<kbd>.</kbd> and
    /// <kbd>Ctrl</kbd>+<kbd>;</kbd>
    #[doc(alias = "insert-emoji")]
    fn connect_insert_emoji<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn insert_emoji_trampoline<P: IsA<TextView>, F: Fn(&P) + 'static>(
            this: *mut ffi::GtkTextView,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(TextView::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"insert-emoji".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    insert_emoji_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    fn emit_insert_emoji(&self) {
        self.emit_by_name::<()>("insert-emoji", &[]);
    }

    /// Gets emitted when the user initiates a cursor movement.
    ///
    /// The ::move-cursor signal is a [keybinding signal](class.SignalAction.html).
    /// If the cursor is not visible in @text_view, this signal causes
    /// the viewport to be moved instead.
    ///
    /// Applications should not connect to it, but may emit it with
    /// g_signal_emit_by_name() if they need to control the cursor
    /// programmatically.
    ///
    ///
    /// The default bindings for this signal come in two variants,
    /// the variant with the <kbd>Shift</kbd> modifier extends the
    /// selection, the variant without it does not.
    /// There are too many key combinations to list them all here.
    ///
    /// - <kbd>←</kbd>, <kbd>→</kbd>, <kbd>↑</kbd>, <kbd>↓</kbd>
    ///   move by individual characters/lines
    /// - <kbd>Ctrl</kbd>+<kbd>←</kbd>, etc. move by words/paragraphs
    /// - <kbd>Home</kbd> and <kbd>End</kbd> move to the ends of the buffer
    /// - <kbd>PgUp</kbd> and <kbd>PgDn</kbd> move vertically by pages
    /// - <kbd>Ctrl</kbd>+<kbd>PgUp</kbd> and <kbd>Ctrl</kbd>+<kbd>PgDn</kbd>
    ///   move horizontally by pages
    /// ## `step`
    /// the granularity of the move, as a [`MovementStep`][crate::MovementStep]
    /// ## `count`
    /// the number of @step units to move
    /// ## `extend_selection`
    /// [`true`] if the move should extend the selection
    #[doc(alias = "move-cursor")]
    fn connect_move_cursor<F: Fn(&Self, MovementStep, i32, bool) + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn move_cursor_trampoline<
            P: IsA<TextView>,
            F: Fn(&P, MovementStep, i32, bool) + 'static,
        >(
            this: *mut ffi::GtkTextView,
            step: ffi::GtkMovementStep,
            count: std::ffi::c_int,
            extend_selection: glib::ffi::gboolean,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(
                TextView::from_glib_borrow(this).unsafe_cast_ref(),
                from_glib(step),
                count,
                from_glib(extend_selection),
            )
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"move-cursor".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    move_cursor_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    fn emit_move_cursor(&self, step: MovementStep, count: i32, extend_selection: bool) {
        self.emit_by_name::<()>("move-cursor", &[&step, &count, &extend_selection]);
    }

    /// Gets emitted to move the viewport.
    ///
    /// The ::move-viewport signal is a [keybinding signal](class.SignalAction.html),
    /// which can be bound to key combinations to allow the user to move the viewport,
    /// i.e. change what part of the text view is visible in a containing scrolled
    /// window.
    ///
    /// There are no default bindings for this signal.
    /// ## `step`
    /// the granularity of the movement, as a [`ScrollStep`][crate::ScrollStep]
    /// ## `count`
    /// the number of @step units to move
    #[doc(alias = "move-viewport")]
    fn connect_move_viewport<F: Fn(&Self, ScrollStep, i32) + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn move_viewport_trampoline<
            P: IsA<TextView>,
            F: Fn(&P, ScrollStep, i32) + 'static,
        >(
            this: *mut ffi::GtkTextView,
            step: ffi::GtkScrollStep,
            count: std::ffi::c_int,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(
                TextView::from_glib_borrow(this).unsafe_cast_ref(),
                from_glib(step),
                count,
            )
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"move-viewport".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    move_viewport_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    fn emit_move_viewport(&self, step: ScrollStep, count: i32) {
        self.emit_by_name::<()>("move-viewport", &[&step, &count]);
    }

    /// Gets emitted to paste the contents of the clipboard
    /// into the text view.
    ///
    /// The ::paste-clipboard signal is a [keybinding signal](class.SignalAction.html).
    ///
    /// The default bindings for this signal are
    /// <kbd>Ctrl</kbd>+<kbd>v</kbd> and
    /// <kbd>Shift</kbd>+<kbd>Insert</kbd>.
    #[doc(alias = "paste-clipboard")]
    fn connect_paste_clipboard<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn paste_clipboard_trampoline<P: IsA<TextView>, F: Fn(&P) + 'static>(
            this: *mut ffi::GtkTextView,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(TextView::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"paste-clipboard".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    paste_clipboard_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    fn emit_paste_clipboard(&self) {
        self.emit_by_name::<()>("paste-clipboard", &[]);
    }

    /// Emitted when preedit text of the active IM changes.
    ///
    /// If an input method is used, the typed text will not immediately
    /// be committed to the buffer. So if you are interested in the text,
    /// connect to this signal.
    ///
    /// This signal is only emitted if the text at the given position
    /// is actually editable.
    /// ## `preedit`
    /// the current preedit string
    #[doc(alias = "preedit-changed")]
    fn connect_preedit_changed<F: Fn(&Self, &str) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn preedit_changed_trampoline<
            P: IsA<TextView>,
            F: Fn(&P, &str) + 'static,
        >(
            this: *mut ffi::GtkTextView,
            preedit: *mut std::ffi::c_char,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(
                TextView::from_glib_borrow(this).unsafe_cast_ref(),
                &glib::GString::from_glib_borrow(preedit),
            )
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"preedit-changed".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    preedit_changed_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    fn emit_preedit_changed(&self, preedit: &str) {
        self.emit_by_name::<()>("preedit-changed", &[&preedit]);
    }

    /// Gets emitted to select or unselect the complete contents of the text view.
    ///
    /// The ::select-all signal is a [keybinding signal](class.SignalAction.html).
    ///
    /// The default bindings for this signal are
    /// <kbd>Ctrl</kbd>+<kbd>a</kbd> and
    /// <kbd>Ctrl</kbd>+<kbd>/</kbd> for selecting and
    /// <kbd>Shift</kbd>+<kbd>Ctrl</kbd>+<kbd>a</kbd> and
    /// <kbd>Ctrl</kbd>+<kbd>\</kbd> for unselecting.
    /// ## `select`
    /// [`true`] to select, [`false`] to unselect
    #[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<TextView>, F: Fn(&P, bool) + 'static>(
            this: *mut ffi::GtkTextView,
            select: glib::ffi::gboolean,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(
                TextView::from_glib_borrow(this).unsafe_cast_ref(),
                from_glib(select),
            )
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"select-all".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    select_all_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

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

    /// Gets emitted when the user initiates settings the "anchor" mark.
    ///
    /// The ::set-anchor signal is a [keybinding signal](class.SignalAction.html)
    /// which gets emitted when the user initiates setting the "anchor"
    /// mark. The "anchor" mark gets placed at the same position as the
    /// "insert" mark.
    ///
    /// This signal has no default bindings.
    #[doc(alias = "set-anchor")]
    fn connect_set_anchor<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn set_anchor_trampoline<P: IsA<TextView>, F: Fn(&P) + 'static>(
            this: *mut ffi::GtkTextView,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(TextView::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"set-anchor".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    set_anchor_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    fn emit_set_anchor(&self) {
        self.emit_by_name::<()>("set-anchor", &[]);
    }

    /// Gets emitted to toggle the `cursor-visible` property.
    ///
    /// The ::toggle-cursor-visible signal is a
    /// [keybinding signal](class.SignalAction.html).
    ///
    /// The default binding for this signal is <kbd>F7</kbd>.
    #[doc(alias = "toggle-cursor-visible")]
    fn connect_toggle_cursor_visible<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn toggle_cursor_visible_trampoline<
            P: IsA<TextView>,
            F: Fn(&P) + 'static,
        >(
            this: *mut ffi::GtkTextView,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(TextView::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"toggle-cursor-visible".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    toggle_cursor_visible_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    fn emit_toggle_cursor_visible(&self) {
        self.emit_by_name::<()>("toggle-cursor-visible", &[]);
    }

    /// Gets emitted to toggle the overwrite mode of the text view.
    ///
    /// The ::toggle-overwrite signal is a [keybinding signal](class.SignalAction.html).
    ///
    /// The default binding for this signal is <kbd>Insert</kbd>.
    #[doc(alias = "toggle-overwrite")]
    fn connect_toggle_overwrite<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn toggle_overwrite_trampoline<P: IsA<TextView>, F: Fn(&P) + 'static>(
            this: *mut ffi::GtkTextView,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(TextView::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"toggle-overwrite".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    toggle_overwrite_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    fn emit_toggle_overwrite(&self) {
        self.emit_by_name::<()>("toggle-overwrite", &[]);
    }

    #[doc(alias = "accepts-tab")]
    fn connect_accepts_tab_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_accepts_tab_trampoline<
            P: IsA<TextView>,
            F: Fn(&P) + 'static,
        >(
            this: *mut ffi::GtkTextView,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(TextView::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::accepts-tab".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_accepts_tab_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "bottom-margin")]
    fn connect_bottom_margin_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_bottom_margin_trampoline<
            P: IsA<TextView>,
            F: Fn(&P) + 'static,
        >(
            this: *mut ffi::GtkTextView,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(TextView::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::bottom-margin".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_bottom_margin_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "buffer")]
    fn connect_buffer_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_buffer_trampoline<P: IsA<TextView>, F: Fn(&P) + 'static>(
            this: *mut ffi::GtkTextView,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(TextView::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::buffer".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_buffer_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "cursor-visible")]
    fn connect_cursor_visible_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_cursor_visible_trampoline<
            P: IsA<TextView>,
            F: Fn(&P) + 'static,
        >(
            this: *mut ffi::GtkTextView,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(TextView::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::cursor-visible".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_cursor_visible_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "editable")]
    fn connect_editable_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_editable_trampoline<P: IsA<TextView>, F: Fn(&P) + 'static>(
            this: *mut ffi::GtkTextView,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(TextView::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::editable".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_editable_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "extra-menu")]
    fn connect_extra_menu_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_extra_menu_trampoline<P: IsA<TextView>, F: Fn(&P) + 'static>(
            this: *mut ffi::GtkTextView,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(TextView::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::extra-menu".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_extra_menu_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "im-module")]
    fn connect_im_module_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_im_module_trampoline<P: IsA<TextView>, F: Fn(&P) + 'static>(
            this: *mut ffi::GtkTextView,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(TextView::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::im-module".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_im_module_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "indent")]
    fn connect_indent_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_indent_trampoline<P: IsA<TextView>, F: Fn(&P) + 'static>(
            this: *mut ffi::GtkTextView,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(TextView::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::indent".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_indent_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "input-hints")]
    fn connect_input_hints_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_input_hints_trampoline<
            P: IsA<TextView>,
            F: Fn(&P) + 'static,
        >(
            this: *mut ffi::GtkTextView,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(TextView::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::input-hints".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_input_hints_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "input-purpose")]
    fn connect_input_purpose_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_input_purpose_trampoline<
            P: IsA<TextView>,
            F: Fn(&P) + 'static,
        >(
            this: *mut ffi::GtkTextView,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(TextView::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::input-purpose".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_input_purpose_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "justification")]
    fn connect_justification_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_justification_trampoline<
            P: IsA<TextView>,
            F: Fn(&P) + 'static,
        >(
            this: *mut ffi::GtkTextView,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(TextView::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::justification".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_justification_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "left-margin")]
    fn connect_left_margin_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_left_margin_trampoline<
            P: IsA<TextView>,
            F: Fn(&P) + 'static,
        >(
            this: *mut ffi::GtkTextView,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(TextView::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::left-margin".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_left_margin_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "monospace")]
    fn connect_monospace_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_monospace_trampoline<P: IsA<TextView>, F: Fn(&P) + 'static>(
            this: *mut ffi::GtkTextView,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(TextView::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::monospace".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_monospace_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "overwrite")]
    fn connect_overwrite_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_overwrite_trampoline<P: IsA<TextView>, F: Fn(&P) + 'static>(
            this: *mut ffi::GtkTextView,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(TextView::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::overwrite".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_overwrite_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "pixels-above-lines")]
    fn connect_pixels_above_lines_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_pixels_above_lines_trampoline<
            P: IsA<TextView>,
            F: Fn(&P) + 'static,
        >(
            this: *mut ffi::GtkTextView,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(TextView::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::pixels-above-lines".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_pixels_above_lines_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "pixels-below-lines")]
    fn connect_pixels_below_lines_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_pixels_below_lines_trampoline<
            P: IsA<TextView>,
            F: Fn(&P) + 'static,
        >(
            this: *mut ffi::GtkTextView,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(TextView::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::pixels-below-lines".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_pixels_below_lines_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "pixels-inside-wrap")]
    fn connect_pixels_inside_wrap_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_pixels_inside_wrap_trampoline<
            P: IsA<TextView>,
            F: Fn(&P) + 'static,
        >(
            this: *mut ffi::GtkTextView,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(TextView::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::pixels-inside-wrap".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_pixels_inside_wrap_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "right-margin")]
    fn connect_right_margin_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_right_margin_trampoline<
            P: IsA<TextView>,
            F: Fn(&P) + 'static,
        >(
            this: *mut ffi::GtkTextView,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(TextView::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::right-margin".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_right_margin_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "tabs")]
    fn connect_tabs_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_tabs_trampoline<P: IsA<TextView>, F: Fn(&P) + 'static>(
            this: *mut ffi::GtkTextView,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(TextView::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::tabs".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_tabs_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "top-margin")]
    fn connect_top_margin_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_top_margin_trampoline<P: IsA<TextView>, F: Fn(&P) + 'static>(
            this: *mut ffi::GtkTextView,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(TextView::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::top-margin".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_top_margin_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "wrap-mode")]
    fn connect_wrap_mode_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_wrap_mode_trampoline<P: IsA<TextView>, F: Fn(&P) + 'static>(
            this: *mut ffi::GtkTextView,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(TextView::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::wrap-mode".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_wrap_mode_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }
}

impl<O: IsA<TextView>> TextViewExt for O {}