vte4/auto/

terminal.rs

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

#[cfg(feature = "v0_76")]
#[cfg_attr(docsrs, doc(cfg(feature = "v0_76")))]
use crate::Align;
use crate::{
    ffi, CursorBlinkMode, CursorShape, EraseBinding, Format, Pty, PtyFlags, Regex, TextBlinkMode,
    WriteFlags,
};
use glib::{
    prelude::*,
    signal::{connect_raw, SignalHandlerId},
    translate::*,
};
use std::boxed::Box as Box_;

glib::wrapper! {
    ///
    ///
    /// ## Properties
    ///
    ///
    /// #### `allow-bold`
    ///  Controls whether or not the terminal will attempt to draw bold text,
    /// by using a bold font variant.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `allow-hyperlink`
    ///  Controls whether or not hyperlinks (OSC 8 escape sequence) are recognized and displayed.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `audible-bell`
    ///  Controls whether or not the terminal will beep when the child outputs the
    /// "bl" sequence.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `backspace-binding`
    ///  Controls what string or control sequence the terminal sends to its child
    /// when the user presses the backspace key.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `bold-is-bright`
    ///  Whether the SGR 1 attribute also switches to the bright counterpart
    /// of the first 8 palette colors, in addition to making them bold (legacy behavior)
    /// or if SGR 1 only enables bold and leaves the color intact.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `cell-height-scale`
    ///  Scale factor for the cell height, to increase line spacing. (The font's height is not affected.)
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `cell-width-scale`
    ///  Scale factor for the cell width, to increase letter spacing. (The font's width is not affected.)
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `cjk-ambiguous-width`
    ///  This setting controls whether ambiguous-width characters are narrow or wide.
    /// (Note that when using a non-UTF-8 encoding set via vte_terminal_set_encoding(),
    /// the width of ambiguous-width characters is fixed and determined by the encoding
    /// itself.)
    ///
    /// This setting only takes effect the next time the terminal is reset, either
    /// via escape sequence or with vte_terminal_reset().
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `context-menu`
    ///  The menu used for context menus. Note that context menu model set with the
    /// #VteTerminal::context-menu-model property or vte_terminal_set_context_menu_model()
    /// takes precedence over this.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `context-menu-model`
    ///  The menu model used for context menus. If non-[`None`], the context menu is
    /// generated from this model, and overrides a context menu set with the
    /// #VteTerminal::context-menu property or vte_terminal_set_context_menu().
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `current-container-name`
    ///  The name of the current container, or [`None`] if unset.
    ///
    /// Readable
    ///
    ///
    /// #### `current-container-runtime`
    ///  The name of the runtime toolset used to set up the current
    /// container, or [`None`] if unset.
    ///
    /// Readable
    ///
    ///
    /// #### `current-directory-uri`
    ///  The current directory URI, or [`None`] if unset.
    ///
    /// Readable
    ///
    ///
    /// #### `current-file-uri`
    ///  The current file URI, or [`None`] if unset.
    ///
    /// Readable
    ///
    ///
    /// #### `cursor-blink-mode`
    ///  Sets whether or not the cursor will blink. Using [`CursorBlinkMode::System`][crate::CursorBlinkMode::System]
    /// will use the #GtkSettings:gtk-cursor-blink setting.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `cursor-shape`
    ///  Controls the shape of the cursor.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `delete-binding`
    ///  Controls what string or control sequence the terminal sends to its child
    /// when the user presses the delete key.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `enable-a11y`
    ///  Controls whether or not a11y is enabled for the widget.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `enable-bidi`
    ///  Controls whether or not the terminal will perform bidirectional text rendering.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `enable-fallback-scrolling`
    ///  Readable | Writeable
    ///
    ///
    /// #### `enable-shaping`
    ///  Controls whether or not the terminal will shape Arabic text.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `enable-sixel`
    ///  Controls whether SIXEL image support is enabled.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `encoding`
    ///  Controls the encoding the terminal will expect data from the child to
    /// be encoded with.  For certain terminal types, applications executing in the
    /// terminal can change the encoding.  The default is defined by the
    /// application's locale settings.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `font-desc`
    ///  Specifies the font used for rendering all text displayed by the terminal,
    /// overriding any fonts set using gtk_widget_modify_font().  The terminal
    /// will immediately attempt to load the desired font, retrieve its
    /// metrics, and attempt to resize itself to keep the same number of rows
    /// and columns.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `font-options`
    ///  The terminal's font options, or [`None`] to use the default font options.
    ///
    /// Note that on GTK4, the terminal by default uses font options
    /// with `CAIRO_HINT_METRICS_ON` set; to override that, use this
    /// function to set a #cairo_font_options_t that has
    /// `CAIRO_HINT_METRICS_OFF` set.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `font-scale`
    ///  The terminal's font scale.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `hyperlink-hover-uri`
    ///  The currently hovered hyperlink URI, or [`None`] if unset.
    ///
    /// Readable
    ///
    ///
    /// #### `icon-title`
    ///  Readable
    ///
    ///
    /// #### `input-enabled`
    ///  Controls whether the terminal allows user input. When user input is disabled,
    /// key press and mouse button press and motion events are not sent to the
    /// terminal's child.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `pointer-autohide`
    ///  Controls the value of the terminal's mouse autohide setting.  When autohiding
    /// is enabled, the mouse cursor will be hidden when the user presses a key and
    /// shown when the user moves the mouse.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `pty`
    ///  The PTY object for the terminal.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `rewrap-on-resize`
    ///  Controls whether or not the terminal will rewrap its contents, including
    /// the scrollback buffer, whenever the terminal's width changes.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `scroll-on-insert`
    ///  Controls whether or not the terminal will forcibly scroll to the bottom of
    /// the viewable history when the text is inserted (e.g. by a paste).
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `scroll-on-keystroke`
    ///  Controls whether or not the terminal will forcibly scroll to the bottom of
    /// the viewable history when the user presses a key.  Modifier keys do not
    /// trigger this behavior.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `scroll-on-output`
    ///  Controls whether or not the terminal will forcibly scroll to the bottom of
    /// the viewable history when the new data is received from the child.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `scroll-unit-is-pixels`
    ///  Controls whether the terminal's GtkAdjustment values unit is lines
    /// or pixels. This can be enabled when the terminal is the child of a
    /// GtkScrolledWindow to fix some bugs with its kinetic scrolling.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `scrollback-lines`
    ///  The length of the scrollback buffer used by the terminal.  The size of
    /// the scrollback buffer will be set to the larger of this value and the number
    /// of visible rows the widget can display, so 0 can safely be used to disable
    /// scrollback.  Note that this setting only affects the normal screen buffer.
    /// For terminal types which have an alternate screen buffer, no scrollback is
    /// allowed on the alternate screen buffer.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `text-blink-mode`
    ///  Controls whether or not the terminal will allow blinking text.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `window-title`
    ///  The terminal's title.
    ///
    /// Readable
    ///
    ///
    /// #### `word-char-exceptions`
    ///  The set of characters which will be considered parts of a word
    /// when doing word-wise selection, in addition to the default which only
    /// considers alphanumeric characters part of a word.
    ///
    /// If [`None`], a built-in set is used.
    ///
    /// Readable
    ///
    ///
    /// #### `xalign`
    ///  The horizontal alignment of @terminal within its allocation.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `xfill`
    ///  The horizontal fillment of @terminal within its allocation.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `yalign`
    ///  The vertical alignment of @terminal within its allocation
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `yfill`
    ///  The vertical fillment of @terminal within its allocation.
    /// Note that #VteTerminal:yfill=[`true`] is only supported with
    /// #VteTerminal:yalign=[`Align::Start`][crate::Align::Start], and is ignored for
    /// all other yalign values.
    ///
    /// Readable | Writeable
    /// <details><summary><h4>Widget</h4></summary>
    ///
    ///
    /// #### `can-focus`
    ///  Whether the widget or any of its descendents can accept
    /// the input focus.
    ///
    /// This property is meant to be set by widget implementations,
    /// typically in their instance init function.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `can-target`
    ///  Whether the widget can receive pointer events.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `css-classes`
    ///  A list of css classes applied to this widget.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `css-name`
    ///  The name of this widget in the CSS tree.
    ///
    /// This property is meant to be set by widget implementations,
    /// typically in their instance init function.
    ///
    /// Readable | Writeable | Construct Only
    ///
    ///
    /// #### `cursor`
    ///  The cursor used by @widget.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `focus-on-click`
    ///  Whether the widget should grab focus when it is clicked with the mouse.
    ///
    /// This property is only relevant for widgets that can take focus.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `focusable`
    ///  Whether this widget itself will accept the input focus.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `halign`
    ///  How to distribute horizontal space if widget gets extra space.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `has-default`
    ///  Whether the widget is the default widget.
    ///
    /// Readable
    ///
    ///
    /// #### `has-focus`
    ///  Whether the widget has the input focus.
    ///
    /// Readable
    ///
    ///
    /// #### `has-tooltip`
    ///  Enables or disables the emission of the ::query-tooltip signal on @widget.
    ///
    /// A value of [`true`] indicates that @widget can have a tooltip, in this case
    /// the widget will be queried using [`query-tooltip`][struct@crate::gtk::Widget#query-tooltip] to
    /// determine whether it will provide a tooltip or not.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `height-request`
    ///  Override for height request of the widget.
    ///
    /// If this is -1, the natural request will be used.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `hexpand`
    ///  Whether to expand horizontally.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `hexpand-set`
    ///  Whether to use the `hexpand` property.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `layout-manager`
    ///  The `GtkLayoutManager` instance to use to compute the preferred size
    /// of the widget, and allocate its children.
    ///
    /// This property is meant to be set by widget implementations,
    /// typically in their instance init function.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `margin-bottom`
    ///  Margin on bottom side of widget.
    ///
    /// This property adds margin outside of the widget's normal size
    /// request, the margin will be added in addition to the size from
    /// [`WidgetExtManual::set_size_request()`][crate::gtk::prelude::WidgetExtManual::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
    /// [`WidgetExtManual::set_size_request()`][crate::gtk::prelude::WidgetExtManual::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
    /// [`WidgetExtManual::set_size_request()`][crate::gtk::prelude::WidgetExtManual::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
    /// [`WidgetExtManual::set_size_request()`][crate::gtk::prelude::WidgetExtManual::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 `GtkRoot` widget of the widget tree containing this widget.
    ///
    /// This will be [`None`] if the widget is not contained in a root widget.
    ///
    /// Readable
    ///
    ///
    /// #### `scale-factor`
    ///  The scale factor of the widget.
    ///
    /// Readable
    ///
    ///
    /// #### `sensitive`
    ///  Whether the widget responds to input.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `tooltip-markup`
    ///  Sets the text of tooltip to be the given string, which is marked up
    /// with Pango markup.
    ///
    /// Also see `Gtk::Tooltip::set_markup()`.
    ///
    /// This is a convenience property which will take care of getting the
    /// tooltip shown if the given string is not [`None`]:
    /// [`has-tooltip`][struct@crate::gtk::Widget#has-tooltip] will automatically be set to [`true`]
    /// and there will be taken care of [`query-tooltip`][struct@crate::gtk::Widget#query-tooltip] in
    /// the default signal handler.
    ///
    /// Note that if both [`tooltip-text`][struct@crate::gtk::Widget#tooltip-text] and
    /// [`tooltip-markup`][struct@crate::gtk::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 `Gtk::Tooltip::set_text()`.
    ///
    /// This is a convenience property which will take care of getting the
    /// tooltip shown if the given string is not [`None`]:
    /// [`has-tooltip`][struct@crate::gtk::Widget#has-tooltip] will automatically be set to [`true`]
    /// and there will be taken care of [`query-tooltip`][struct@crate::gtk::Widget#query-tooltip] in
    /// the default signal handler.
    ///
    /// Note that if both [`tooltip-text`][struct@crate::gtk::Widget#tooltip-text] and
    /// [`tooltip-markup`][struct@crate::gtk::Widget#tooltip-markup] are set, the last one wins.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `valign`
    ///  How to distribute vertical space if widget gets extra space.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `vexpand`
    ///  Whether to expand vertically.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `vexpand-set`
    ///  Whether to use the `vexpand` property.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `visible`
    ///  Whether the widget is visible.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `width-request`
    ///  Override for width request of the widget.
    ///
    /// If this is -1, the natural request will be used.
    ///
    /// Readable | Writeable
    /// </details>
    /// <details><summary><h4>Accessible</h4></summary>
    ///
    ///
    /// #### `accessible-role`
    ///  The accessible role of the given [`gtk::Accessible`][crate::gtk::Accessible] implementation.
    ///
    /// The accessible role cannot be changed once set.
    ///
    /// Readable | Writeable
    /// </details>
    /// <details><summary><h4>Scrollable</h4></summary>
    ///
    ///
    /// #### `hadjustment`
    ///  Horizontal `GtkAdjustment` 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 `GtkAdjustment` 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
    ///
    ///
    /// #### `bell`
    ///  This signal is emitted when the a child sends a bell request to the
    /// terminal.
    ///
    ///
    ///
    ///
    /// #### `char-size-changed`
    ///  Emitted whenever the cell size changes, e.g. due to a change in
    /// font, font-scale or cell-width/height-scale.
    ///
    /// Note that this signal should rather be called "cell-size-changed".
    ///
    ///
    ///
    ///
    /// #### `child-exited`
    ///  This signal is emitted when the terminal detects that a child
    /// watched using vte_terminal_watch_child() has exited.
    ///
    ///
    ///
    ///
    /// #### `commit`
    ///  Emitted whenever the terminal receives input from the user and
    /// prepares to send it to the child process.
    ///
    ///
    ///
    ///
    /// #### `contents-changed`
    ///  Emitted whenever the visible appearance of the terminal has changed.
    /// Used primarily by #VteTerminalAccessible.
    ///
    ///
    ///
    ///
    /// #### `copy-clipboard`
    ///  Emitted whenever vte_terminal_copy_clipboard() is called.
    ///
    /// Action
    ///
    ///
    /// #### `current-directory-uri-changed`
    ///  Emitted when the current directory URI is modified.
    ///
    ///
    ///
    ///
    /// #### `current-file-uri-changed`
    ///  Emitted when the current file URI is modified.
    ///
    ///
    ///
    ///
    /// #### `cursor-moved`
    ///  Emitted whenever the cursor moves to a new character cell.  Used
    /// primarily by #VteTerminalAccessible.
    ///
    ///
    ///
    ///
    /// #### `decrease-font-size`
    ///  Emitted when the user hits the '-' key while holding the Control key.
    ///
    ///
    ///
    ///
    /// #### `deiconify-window`
    ///  Never emitted.
    ///
    ///
    ///
    ///
    /// #### `encoding-changed`
    ///  Emitted whenever the terminal's current encoding has changed.
    ///
    /// Note: support for non-UTF-8 is deprecated.
    ///
    ///
    ///
    ///
    /// #### `eof`
    ///  Emitted when the terminal receives an end-of-file from a child which
    /// is running in the terminal.  This signal is frequently (but not
    /// always) emitted with a #VteTerminal::child-exited signal.
    ///
    ///
    ///
    ///
    /// #### `hyperlink-hover-uri-changed`
    ///  Emitted when the hovered hyperlink changes.
    ///
    /// @uri and @bbox are owned by VTE, must not be modified, and might
    /// change after the signal handlers returns.
    ///
    /// The signal is not re-emitted when the bounding box changes for the
    /// same hyperlink. This might change in a future VTE version without notice.
    ///
    ///
    ///
    ///
    /// #### `icon-title-changed`
    ///
    ///
    ///
    /// #### `iconify-window`
    ///  Never emitted.
    ///
    ///
    ///
    ///
    /// #### `increase-font-size`
    ///  Emitted when the user hits the '+' key while holding the Control key.
    ///
    ///
    ///
    ///
    /// #### `lower-window`
    ///  Never emitted.
    ///
    ///
    ///
    ///
    /// #### `maximize-window`
    ///  Never emitted.
    ///
    ///
    ///
    ///
    /// #### `move-window`
    ///  Never emitted.
    ///
    ///
    ///
    ///
    /// #### `notification-received`
    ///  Emitted when a process running in the terminal wants to
    /// send a notification to the desktop environment.
    ///
    ///
    ///
    ///
    /// #### `paste-clipboard`
    ///  Emitted whenever vte_terminal_paste_clipboard() is called.
    ///
    /// Action
    ///
    ///
    /// #### `raise-window`
    ///  Never emitted.
    ///
    ///
    ///
    ///
    /// #### `refresh-window`
    ///  Never emitted.
    ///
    ///
    ///
    ///
    /// #### `resize-window`
    ///  Emitted at the child application's request.
    ///
    ///
    ///
    ///
    /// #### `restore-window`
    ///  Never emitted.
    ///
    ///
    ///
    ///
    /// #### `selection-changed`
    ///  Emitted whenever the contents of terminal's selection changes.
    ///
    ///
    ///
    ///
    /// #### `setup-context-menu`
    ///  Emitted with non-[`None`] context before @terminal shows a context menu.
    /// The handler may set either a menu model using
    /// vte_terminal_set_context_menu_model(), or a menu using
    /// vte_terminal_set_context_menu(), which will then be used as context
    /// menu.
    /// If neither a menu model nor a menu are set, a context menu
    /// will not be shown.
    ///
    /// Note that @context is only valid during the signal emission; you may
    /// not retain it to call methods on it afterwards.
    ///
    /// Also emitted with [`None`] context after the context menu has been dismissed.
    ///
    ///
    ///
    ///
    /// #### `shell-precmd`
    ///  Emitted right before an interactive shell shows a
    /// first-level prompt.
    ///
    ///
    ///
    ///
    /// #### `shell-preexec`
    ///  Emitted when the interactive shell has read in a complete
    /// command and is about to execute it.
    ///
    ///
    ///
    ///
    /// #### `window-title-changed`
    ///  Emitted when the #VteTerminal:window-title property is modified.
    ///
    ///
    /// <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 [`WidgetExtManual::keynav_failed()`][crate::gtk::prelude::WidgetExtManual::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::gtk::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::gtk::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::gtk::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 `GdkSurface`.
    ///
    /// This means that [`WidgetExtManual::realize()`][crate::gtk::prelude::WidgetExtManual::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 [`WidgetExtManual::state_flags()`][crate::gtk::prelude::WidgetExtManual::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 `GdkSurface` associated with @widget is destroyed.
    ///
    /// This means that [`WidgetExtManual::unrealize()`][crate::gtk::prelude::WidgetExtManual::unrealize()] has been called
    /// or the widget has been unmapped (that is, it is going to be hidden).
    ///
    ///
    /// </details>
    ///
    /// # Implements
    ///
    /// [`TerminalExt`][trait@crate::prelude::TerminalExt], [`trait@gtk::prelude::WidgetExt`], [`trait@gtk::prelude::AccessibleExt`], [`trait@gtk::prelude::BuildableExt`], [`trait@gtk::prelude::ConstraintTargetExt`], [`trait@gtk::prelude::ScrollableExt`]
    #[doc(alias = "VteTerminal")]
    pub struct Terminal(Object<ffi::VteTerminal, ffi::VteTerminalClass>) @extends gtk::Widget, @implements gtk::Accessible, gtk::Buildable, gtk::ConstraintTarget, gtk::Scrollable;

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

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

    /// Creates a new terminal widget.
    ///
    /// # Returns
    ///
    /// a new #VteTerminal object
    #[doc(alias = "vte_terminal_new")]
    pub fn new() -> Terminal {
        assert_initialized_main_thread!();
        unsafe { from_glib_none(ffi::vte_terminal_new()) }
    }

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

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

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

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

    /// Controls whether or not hyperlinks (OSC 8 escape sequence) are recognized and displayed.
    pub fn allow_hyperlink(self, allow_hyperlink: bool) -> Self {
        Self {
            builder: self.builder.property("allow-hyperlink", allow_hyperlink),
        }
    }

    /// Controls whether or not the terminal will beep when the child outputs the
    /// "bl" sequence.
    pub fn audible_bell(self, audible_bell: bool) -> Self {
        Self {
            builder: self.builder.property("audible-bell", audible_bell),
        }
    }

    /// Controls what string or control sequence the terminal sends to its child
    /// when the user presses the backspace key.
    pub fn backspace_binding(self, backspace_binding: EraseBinding) -> Self {
        Self {
            builder: self
                .builder
                .property("backspace-binding", backspace_binding),
        }
    }

    /// Whether the SGR 1 attribute also switches to the bright counterpart
    /// of the first 8 palette colors, in addition to making them bold (legacy behavior)
    /// or if SGR 1 only enables bold and leaves the color intact.
    pub fn bold_is_bright(self, bold_is_bright: bool) -> Self {
        Self {
            builder: self.builder.property("bold-is-bright", bold_is_bright),
        }
    }

    /// Scale factor for the cell height, to increase line spacing. (The font's height is not affected.)
    pub fn cell_height_scale(self, cell_height_scale: f64) -> Self {
        Self {
            builder: self
                .builder
                .property("cell-height-scale", cell_height_scale),
        }
    }

    /// Scale factor for the cell width, to increase letter spacing. (The font's width is not affected.)
    pub fn cell_width_scale(self, cell_width_scale: f64) -> Self {
        Self {
            builder: self.builder.property("cell-width-scale", cell_width_scale),
        }
    }

    /// This setting controls whether ambiguous-width characters are narrow or wide.
    /// (Note that when using a non-UTF-8 encoding set via vte_terminal_set_encoding(),
    /// the width of ambiguous-width characters is fixed and determined by the encoding
    /// itself.)
    ///
    /// This setting only takes effect the next time the terminal is reset, either
    /// via escape sequence or with vte_terminal_reset().
    pub fn cjk_ambiguous_width(self, cjk_ambiguous_width: i32) -> Self {
        Self {
            builder: self
                .builder
                .property("cjk-ambiguous-width", cjk_ambiguous_width),
        }
    }

    /// The menu used for context menus. Note that context menu model set with the
    /// #VteTerminal::context-menu-model property or vte_terminal_set_context_menu_model()
    /// takes precedence over this.
    #[cfg(feature = "v0_76")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v0_76")))]
    pub fn context_menu(self, context_menu: &impl IsA<gtk::Popover>) -> Self {
        Self {
            builder: self
                .builder
                .property("context-menu", context_menu.clone().upcast()),
        }
    }

    /// The menu model used for context menus. If non-[`None`], the context menu is
    /// generated from this model, and overrides a context menu set with the
    /// #VteTerminal::context-menu property or vte_terminal_set_context_menu().
    #[cfg(feature = "v0_76")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v0_76")))]
    pub fn context_menu_model(self, context_menu_model: &impl IsA<gio::MenuModel>) -> Self {
        Self {
            builder: self
                .builder
                .property("context-menu-model", context_menu_model.clone().upcast()),
        }
    }

    /// Sets whether or not the cursor will blink. Using [`CursorBlinkMode::System`][crate::CursorBlinkMode::System]
    /// will use the #GtkSettings:gtk-cursor-blink setting.
    pub fn cursor_blink_mode(self, cursor_blink_mode: CursorBlinkMode) -> Self {
        Self {
            builder: self
                .builder
                .property("cursor-blink-mode", cursor_blink_mode),
        }
    }

    /// Controls the shape of the cursor.
    pub fn cursor_shape(self, cursor_shape: CursorShape) -> Self {
        Self {
            builder: self.builder.property("cursor-shape", cursor_shape),
        }
    }

    /// Controls what string or control sequence the terminal sends to its child
    /// when the user presses the delete key.
    pub fn delete_binding(self, delete_binding: EraseBinding) -> Self {
        Self {
            builder: self.builder.property("delete-binding", delete_binding),
        }
    }

    /// Controls whether or not a11y is enabled for the widget.
    #[cfg(feature = "v0_78")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v0_78")))]
    pub fn enable_a11y(self, enable_a11y: bool) -> Self {
        Self {
            builder: self.builder.property("enable-a11y", enable_a11y),
        }
    }

    /// Controls whether or not the terminal will perform bidirectional text rendering.
    pub fn enable_bidi(self, enable_bidi: bool) -> Self {
        Self {
            builder: self.builder.property("enable-bidi", enable_bidi),
        }
    }

    pub fn enable_fallback_scrolling(self, enable_fallback_scrolling: bool) -> Self {
        Self {
            builder: self
                .builder
                .property("enable-fallback-scrolling", enable_fallback_scrolling),
        }
    }

    /// Controls whether or not the terminal will shape Arabic text.
    pub fn enable_shaping(self, enable_shaping: bool) -> Self {
        Self {
            builder: self.builder.property("enable-shaping", enable_shaping),
        }
    }

    /// Controls whether SIXEL image support is enabled.
    pub fn enable_sixel(self, enable_sixel: bool) -> Self {
        Self {
            builder: self.builder.property("enable-sixel", enable_sixel),
        }
    }

    /// Specifies the font used for rendering all text displayed by the terminal,
    /// overriding any fonts set using gtk_widget_modify_font().  The terminal
    /// will immediately attempt to load the desired font, retrieve its
    /// metrics, and attempt to resize itself to keep the same number of rows
    /// and columns.
    pub fn font_desc(self, font_desc: &pango::FontDescription) -> Self {
        Self {
            builder: self.builder.property("font-desc", font_desc),
        }
    }

    /// The terminal's font options, or [`None`] to use the default font options.
    ///
    /// Note that on GTK4, the terminal by default uses font options
    /// with `CAIRO_HINT_METRICS_ON` set; to override that, use this
    /// function to set a #cairo_font_options_t that has
    /// `CAIRO_HINT_METRICS_OFF` set.
    #[cfg(feature = "v0_74")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v0_74")))]
    pub fn font_options(self, font_options: &cairo::FontOptions) -> Self {
        Self {
            builder: self.builder.property("font-options", font_options),
        }
    }

    /// The terminal's font scale.
    pub fn font_scale(self, font_scale: f64) -> Self {
        Self {
            builder: self.builder.property("font-scale", font_scale),
        }
    }

    /// Controls whether the terminal allows user input. When user input is disabled,
    /// key press and mouse button press and motion events are not sent to the
    /// terminal's child.
    pub fn input_enabled(self, input_enabled: bool) -> Self {
        Self {
            builder: self.builder.property("input-enabled", input_enabled),
        }
    }

    /// Controls the value of the terminal's mouse autohide setting.  When autohiding
    /// is enabled, the mouse cursor will be hidden when the user presses a key and
    /// shown when the user moves the mouse.
    pub fn pointer_autohide(self, pointer_autohide: bool) -> Self {
        Self {
            builder: self.builder.property("pointer-autohide", pointer_autohide),
        }
    }

    /// The PTY object for the terminal.
    pub fn pty(self, pty: &Pty) -> Self {
        Self {
            builder: self.builder.property("pty", pty.clone()),
        }
    }

    /// Controls whether or not the terminal will forcibly scroll to the bottom of
    /// the viewable history when the text is inserted (e.g. by a paste).
    #[cfg(feature = "v0_76")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v0_76")))]
    pub fn scroll_on_insert(self, scroll_on_insert: bool) -> Self {
        Self {
            builder: self.builder.property("scroll-on-insert", scroll_on_insert),
        }
    }

    /// Controls whether or not the terminal will forcibly scroll to the bottom of
    /// the viewable history when the user presses a key.  Modifier keys do not
    /// trigger this behavior.
    pub fn scroll_on_keystroke(self, scroll_on_keystroke: bool) -> Self {
        Self {
            builder: self
                .builder
                .property("scroll-on-keystroke", scroll_on_keystroke),
        }
    }

    /// Controls whether or not the terminal will forcibly scroll to the bottom of
    /// the viewable history when the new data is received from the child.
    pub fn scroll_on_output(self, scroll_on_output: bool) -> Self {
        Self {
            builder: self.builder.property("scroll-on-output", scroll_on_output),
        }
    }

    /// Controls whether the terminal's GtkAdjustment values unit is lines
    /// or pixels. This can be enabled when the terminal is the child of a
    /// GtkScrolledWindow to fix some bugs with its kinetic scrolling.
    pub fn scroll_unit_is_pixels(self, scroll_unit_is_pixels: bool) -> Self {
        Self {
            builder: self
                .builder
                .property("scroll-unit-is-pixels", scroll_unit_is_pixels),
        }
    }

    /// The length of the scrollback buffer used by the terminal.  The size of
    /// the scrollback buffer will be set to the larger of this value and the number
    /// of visible rows the widget can display, so 0 can safely be used to disable
    /// scrollback.  Note that this setting only affects the normal screen buffer.
    /// For terminal types which have an alternate screen buffer, no scrollback is
    /// allowed on the alternate screen buffer.
    pub fn scrollback_lines(self, scrollback_lines: u32) -> Self {
        Self {
            builder: self.builder.property("scrollback-lines", scrollback_lines),
        }
    }

    /// Controls whether or not the terminal will allow blinking text.
    pub fn text_blink_mode(self, text_blink_mode: TextBlinkMode) -> Self {
        Self {
            builder: self.builder.property("text-blink-mode", text_blink_mode),
        }
    }

    /// The horizontal alignment of @terminal within its allocation.
    #[cfg(feature = "v0_76")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v0_76")))]
    pub fn xalign(self, xalign: Align) -> Self {
        Self {
            builder: self.builder.property("xalign", xalign),
        }
    }

    /// The horizontal fillment of @terminal within its allocation.
    #[cfg(feature = "v0_76")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v0_76")))]
    pub fn xfill(self, xfill: bool) -> Self {
        Self {
            builder: self.builder.property("xfill", xfill),
        }
    }

    /// The vertical alignment of @terminal within its allocation
    #[cfg(feature = "v0_76")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v0_76")))]
    pub fn yalign(self, yalign: Align) -> Self {
        Self {
            builder: self.builder.property("yalign", yalign),
        }
    }

    /// The vertical fillment of @terminal within its allocation.
    /// Note that #VteTerminal:yfill=[`true`] is only supported with
    /// #VteTerminal:yalign=[`Align::Start`][crate::Align::Start], and is ignored for
    /// all other yalign values.
    #[cfg(feature = "v0_76")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v0_76")))]
    pub fn yfill(self, yfill: bool) -> Self {
        Self {
            builder: self.builder.property("yfill", yfill),
        }
    }

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

    //pub fn cursor(self, cursor: /*Ignored*/&gdk::Cursor) -> Self {
    //    Self { builder: self.builder.property("cursor", cursor), }
    //}

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

    //pub fn halign(self, halign: /*Ignored*/gtk::Align) -> Self {
    //    Self { builder: self.builder.property("halign", halign), }
    //}

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

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

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

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

    //pub fn layout_manager(self, layout_manager: &impl IsA</*Ignored*/gtk::LayoutManager>) -> Self {
    //    Self { builder: self.builder.property("layout-manager", layout_manager.clone().upcast()), }
    //}

    /// Margin on bottom side of widget.
    ///
    /// This property adds margin outside of the widget's normal size
    /// request, the margin will be added in addition to the size from
    /// [`WidgetExtManual::set_size_request()`][crate::gtk::prelude::WidgetExtManual::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
    /// [`WidgetExtManual::set_size_request()`][crate::gtk::prelude::WidgetExtManual::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
    /// [`WidgetExtManual::set_size_request()`][crate::gtk::prelude::WidgetExtManual::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
    /// [`WidgetExtManual::set_size_request()`][crate::gtk::prelude::WidgetExtManual::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),
        }
    }

    //pub fn overflow(self, overflow: /*Ignored*/gtk::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 `Gtk::Tooltip::set_markup()`.
    ///
    /// This is a convenience property which will take care of getting the
    /// tooltip shown if the given string is not [`None`]:
    /// [`has-tooltip`][struct@crate::gtk::Widget#has-tooltip] will automatically be set to [`true`]
    /// and there will be taken care of [`query-tooltip`][struct@crate::gtk::Widget#query-tooltip] in
    /// the default signal handler.
    ///
    /// Note that if both [`tooltip-text`][struct@crate::gtk::Widget#tooltip-text] and
    /// [`tooltip-markup`][struct@crate::gtk::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 `Gtk::Tooltip::set_text()`.
    ///
    /// This is a convenience property which will take care of getting the
    /// tooltip shown if the given string is not [`None`]:
    /// [`has-tooltip`][struct@crate::gtk::Widget#has-tooltip] will automatically be set to [`true`]
    /// and there will be taken care of [`query-tooltip`][struct@crate::gtk::Widget#query-tooltip] in
    /// the default signal handler.
    ///
    /// Note that if both [`tooltip-text`][struct@crate::gtk::Widget#tooltip-text] and
    /// [`tooltip-markup`][struct@crate::gtk::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()),
        }
    }

    //pub fn valign(self, valign: /*Ignored*/gtk::Align) -> Self {
    //    Self { builder: self.builder.property("valign", valign), }
    //}

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

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

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

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

    //pub fn accessible_role(self, accessible_role: /*Ignored*/gtk::AccessibleRole) -> Self {
    //    Self { builder: self.builder.property("accessible-role", accessible_role), }
    //}

    //pub fn hadjustment(self, hadjustment: &impl IsA</*Ignored*/gtk::Adjustment>) -> Self {
    //    Self { builder: self.builder.property("hadjustment", hadjustment.clone().upcast()), }
    //}

    //pub fn hscroll_policy(self, hscroll_policy: /*Ignored*/gtk::ScrollablePolicy) -> Self {
    //    Self { builder: self.builder.property("hscroll-policy", hscroll_policy), }
    //}

    //pub fn vadjustment(self, vadjustment: &impl IsA</*Ignored*/gtk::Adjustment>) -> Self {
    //    Self { builder: self.builder.property("vadjustment", vadjustment.clone().upcast()), }
    //}

    //pub fn vscroll_policy(self, vscroll_policy: /*Ignored*/gtk::ScrollablePolicy) -> Self {
    //    Self { builder: self.builder.property("vscroll-policy", vscroll_policy), }
    //}

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

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

/// Trait containing all [`struct@Terminal`] methods.
///
/// # Implementors
///
/// [`Terminal`][struct@crate::Terminal]
pub trait TerminalExt: IsA<Terminal> + sealed::Sealed + 'static {
    /// Returns a nonempty string: the target of the explicit hyperlink (printed using the OSC 8
    /// escape sequence) at the position (x, y), or [`None`].
    ///
    /// Proper use of the escape sequence should result in URI-encoded URIs with a proper scheme
    /// like "http://", "https://", "file://", "mailto:" etc. This is, however, not enforced by VTE.
    /// The caller must tolerate the returned string potentially not being a valid URI.
    ///
    /// # Returns
    ///
    /// a newly allocated string containing the target of the hyperlink,
    ///  or [`None`]
    #[cfg(feature = "v0_70")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v0_70")))]
    #[doc(alias = "vte_terminal_check_hyperlink_at")]
    fn check_hyperlink_at(&self, x: f64, y: f64) -> Option<glib::GString> {
        unsafe {
            from_glib_full(ffi::vte_terminal_check_hyperlink_at(
                self.as_ref().to_glib_none().0,
                x,
                y,
            ))
        }
    }

    /// Checks if the text in and around the position (x, y) matches any of the
    /// regular expressions previously set using vte_terminal_match_add().  If a
    /// match exists, the text string is returned and if @tag is not [`None`], the number
    /// associated with the matched regular expression will be stored in @tag.
    ///
    /// If more than one regular expression has been set with
    /// vte_terminal_match_add(), then expressions are checked in the order in
    /// which they were added.
    ///
    /// # Returns
    ///
    /// a newly allocated string which matches one of the previously
    ///   set regular expressions, or [`None`] if there is no match
    ///
    /// ## `tag`
    /// a location to store the tag, or [`None`]
    #[cfg(feature = "v0_70")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v0_70")))]
    #[doc(alias = "vte_terminal_check_match_at")]
    fn check_match_at(&self, x: f64, y: f64) -> (Option<glib::GString>, i32) {
        unsafe {
            let mut tag = std::mem::MaybeUninit::uninit();
            let ret = from_glib_full(ffi::vte_terminal_check_match_at(
                self.as_ref().to_glib_none().0,
                x,
                y,
                tag.as_mut_ptr(),
            ));
            (ret, tag.assume_init())
        }
    }

    /// Places the selected text in the terminal in the #GDK_SELECTION_CLIPBOARD
    /// selection in the form specified by @format.
    ///
    /// For all formats, the selection data (see #GtkSelectionData) will include the
    /// text targets (see gtk_target_list_add_text_targets() and
    /// gtk_selection_data_targets_includes_text()). For [`Format::Html`][crate::Format::Html],
    /// the selection will also include the "text/html" target, which when requested,
    /// returns the HTML data in UTF-16 with a U+FEFF BYTE ORDER MARK character at
    /// the start.
    /// ## `format`
    /// a #VteFormat
    #[doc(alias = "vte_terminal_copy_clipboard_format")]
    fn copy_clipboard_format(&self, format: Format) {
        unsafe {
            ffi::vte_terminal_copy_clipboard_format(
                self.as_ref().to_glib_none().0,
                format.into_glib(),
            );
        }
    }

    /// Places the selected text in the terminal in the #GDK_SELECTION_PRIMARY
    /// selection.
    #[doc(alias = "vte_terminal_copy_primary")]
    fn copy_primary(&self) {
        unsafe {
            ffi::vte_terminal_copy_primary(self.as_ref().to_glib_none().0);
        }
    }

    /// Interprets @data as if it were data received from a child process.
    /// ## `data`
    /// a string in the terminal's current encoding
    #[doc(alias = "vte_terminal_feed")]
    fn feed(&self, data: &[u8]) {
        let length = data.len() as _;
        unsafe {
            ffi::vte_terminal_feed(
                self.as_ref().to_glib_none().0,
                data.to_glib_none().0,
                length,
            );
        }
    }

    /// Sends a block of UTF-8 text to the child as if it were entered by the user
    /// at the keyboard.
    /// ## `text`
    /// data to send to the child
    #[doc(alias = "vte_terminal_feed_child")]
    fn feed_child(&self, text: &[u8]) {
        let length = text.len() as _;
        unsafe {
            ffi::vte_terminal_feed_child(
                self.as_ref().to_glib_none().0,
                text.to_glib_none().0,
                length,
            );
        }
    }

    /// Checks whether or not hyperlinks (OSC 8 escape sequence) are allowed.
    ///
    /// # Returns
    ///
    /// [`true`] if hyperlinks are enabled, [`false`] if not
    #[doc(alias = "vte_terminal_get_allow_hyperlink")]
    #[doc(alias = "get_allow_hyperlink")]
    #[doc(alias = "allow-hyperlink")]
    fn allows_hyperlink(&self) -> bool {
        unsafe {
            from_glib(ffi::vte_terminal_get_allow_hyperlink(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Checks whether or not the terminal will beep when the child outputs the
    /// "bl" sequence.
    ///
    /// # Returns
    ///
    /// [`true`] if audible bell is enabled, [`false`] if not
    #[doc(alias = "vte_terminal_get_audible_bell")]
    #[doc(alias = "get_audible_bell")]
    #[doc(alias = "audible-bell")]
    fn is_audible_bell(&self) -> bool {
        unsafe {
            from_glib(ffi::vte_terminal_get_audible_bell(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Checks whether the SGR 1 attribute also switches to the bright counterpart
    /// of the first 8 palette colors, in addition to making them bold (legacy behavior)
    /// or if SGR 1 only enables bold and leaves the color intact.
    ///
    /// # Returns
    ///
    /// [`true`] if bold also enables bright, [`false`] if not
    #[doc(alias = "vte_terminal_get_bold_is_bright")]
    #[doc(alias = "get_bold_is_bright")]
    #[doc(alias = "bold-is-bright")]
    fn is_bold_is_bright(&self) -> bool {
        unsafe {
            from_glib(ffi::vte_terminal_get_bold_is_bright(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    ///
    /// # Returns
    ///
    /// the terminal's cell height scale
    #[doc(alias = "vte_terminal_get_cell_height_scale")]
    #[doc(alias = "get_cell_height_scale")]
    #[doc(alias = "cell-height-scale")]
    fn cell_height_scale(&self) -> f64 {
        unsafe { ffi::vte_terminal_get_cell_height_scale(self.as_ref().to_glib_none().0) }
    }

    ///
    /// # Returns
    ///
    /// the terminal's cell width scale
    #[doc(alias = "vte_terminal_get_cell_width_scale")]
    #[doc(alias = "get_cell_width_scale")]
    #[doc(alias = "cell-width-scale")]
    fn cell_width_scale(&self) -> f64 {
        unsafe { ffi::vte_terminal_get_cell_width_scale(self.as_ref().to_glib_none().0) }
    }

    ///
    /// # Returns
    ///
    /// the height of a character cell
    ///
    /// Note that this method should rather be called vte_terminal_get_cell_height,
    /// because the return value takes cell-height-scale into account.
    #[doc(alias = "vte_terminal_get_char_height")]
    #[doc(alias = "get_char_height")]
    fn char_height(&self) -> libc::c_long {
        unsafe { ffi::vte_terminal_get_char_height(self.as_ref().to_glib_none().0) }
    }

    ///
    /// # Returns
    ///
    /// the width of a character cell
    ///
    /// Note that this method should rather be called vte_terminal_get_cell_width,
    /// because the return value takes cell-width-scale into account.
    #[doc(alias = "vte_terminal_get_char_width")]
    #[doc(alias = "get_char_width")]
    fn char_width(&self) -> libc::c_long {
        unsafe { ffi::vte_terminal_get_char_width(self.as_ref().to_glib_none().0) }
    }

    /// Returns whether ambiguous-width characters are narrow or wide.
    /// (Note that when using a non-UTF-8 encoding set via vte_terminal_set_encoding(),
    /// the width of ambiguous-width characters is fixed and determined by the encoding
    /// itself.)
    ///
    /// # Returns
    ///
    /// 1 if ambiguous-width characters are narrow, or 2 if they are wide
    #[doc(alias = "vte_terminal_get_cjk_ambiguous_width")]
    #[doc(alias = "get_cjk_ambiguous_width")]
    #[doc(alias = "cjk-ambiguous-width")]
    fn cjk_ambiguous_width(&self) -> i32 {
        unsafe { ffi::vte_terminal_get_cjk_ambiguous_width(self.as_ref().to_glib_none().0) }
    }

    /// Returns the background colour, as used by @self when
    /// drawing the background, which may be different from
    /// the color set by vte_terminal_set_color_background().
    ///
    /// Note: you must only call this function while handling the
    /// GtkWidget::draw signal.
    ///
    /// This function is rarely useful. One use for it is if you disable
    /// drawing the background (see vte_terminal_set_clear_background())
    /// and then need to draw the background yourself.
    ///
    /// # Returns
    ///
    ///
    /// ## `color`
    /// a location to store a #GdkRGBA color
    #[doc(alias = "vte_terminal_get_color_background_for_draw")]
    #[doc(alias = "get_color_background_for_draw")]
    fn color_background_for_draw(&self) -> gdk::RGBA {
        unsafe {
            let mut color = gdk::RGBA::uninitialized();
            ffi::vte_terminal_get_color_background_for_draw(
                self.as_ref().to_glib_none().0,
                color.to_glib_none_mut().0,
            );
            color
        }
    }

    ///
    /// # Returns
    ///
    /// the number of columns
    #[doc(alias = "vte_terminal_get_column_count")]
    #[doc(alias = "get_column_count")]
    fn column_count(&self) -> libc::c_long {
        unsafe { ffi::vte_terminal_get_column_count(self.as_ref().to_glib_none().0) }
    }

    ///
    /// # Returns
    ///
    /// the context menu, or [`None`]
    #[cfg(feature = "v0_76")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v0_76")))]
    #[doc(alias = "vte_terminal_get_context_menu")]
    #[doc(alias = "get_context_menu")]
    #[doc(alias = "context-menu")]
    fn context_menu(&self) -> Option<gtk::Widget> {
        unsafe {
            from_glib_none(ffi::vte_terminal_get_context_menu(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    ///
    /// # Returns
    ///
    /// the context menu model, or [`None`]
    #[cfg(feature = "v0_76")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v0_76")))]
    #[doc(alias = "vte_terminal_get_context_menu_model")]
    #[doc(alias = "get_context_menu_model")]
    #[doc(alias = "context-menu-model")]
    fn context_menu_model(&self) -> Option<gio::MenuModel> {
        unsafe {
            from_glib_none(ffi::vte_terminal_get_context_menu_model(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    ///
    /// # Returns
    ///
    /// the name of the current
    ///   container, or [`None`]
    #[doc(alias = "vte_terminal_get_current_container_name")]
    #[doc(alias = "get_current_container_name")]
    #[doc(alias = "current-container-name")]
    fn current_container_name(&self) -> Option<glib::GString> {
        unsafe {
            from_glib_none(ffi::vte_terminal_get_current_container_name(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    ///
    /// # Returns
    ///
    /// the name of the runtime
    ///   toolset used to set up the current container, or [`None`]
    #[doc(alias = "vte_terminal_get_current_container_runtime")]
    #[doc(alias = "get_current_container_runtime")]
    #[doc(alias = "current-container-runtime")]
    fn current_container_runtime(&self) -> Option<glib::GString> {
        unsafe {
            from_glib_none(ffi::vte_terminal_get_current_container_runtime(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    ///
    /// # Returns
    ///
    /// the URI of the current directory of the
    ///   process running in the terminal, or [`None`]
    #[doc(alias = "vte_terminal_get_current_directory_uri")]
    #[doc(alias = "get_current_directory_uri")]
    #[doc(alias = "current-directory-uri")]
    fn current_directory_uri(&self) -> Option<glib::GString> {
        unsafe {
            from_glib_none(ffi::vte_terminal_get_current_directory_uri(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    ///
    /// # Returns
    ///
    /// the URI of the current file the
    ///   process running in the terminal is operating on, or [`None`] if
    ///   not set
    #[doc(alias = "vte_terminal_get_current_file_uri")]
    #[doc(alias = "get_current_file_uri")]
    #[doc(alias = "current-file-uri")]
    fn current_file_uri(&self) -> Option<glib::GString> {
        unsafe {
            from_glib_none(ffi::vte_terminal_get_current_file_uri(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Returns the currently set cursor blink mode.
    ///
    /// # Returns
    ///
    /// cursor blink mode.
    #[doc(alias = "vte_terminal_get_cursor_blink_mode")]
    #[doc(alias = "get_cursor_blink_mode")]
    #[doc(alias = "cursor-blink-mode")]
    fn cursor_blink_mode(&self) -> CursorBlinkMode {
        unsafe {
            from_glib(ffi::vte_terminal_get_cursor_blink_mode(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Reads the location of the insertion cursor and returns it.  The row
    /// coordinate is absolute.
    ///
    /// This method is unaware of BiDi. The returned column is logical column.
    ///
    /// # Returns
    ///
    ///
    /// ## `column`
    /// a location to store the column, or [`None`]
    ///
    /// ## `row`
    /// a location to store the row, or [`None`]
    #[doc(alias = "vte_terminal_get_cursor_position")]
    #[doc(alias = "get_cursor_position")]
    fn cursor_position(&self) -> (libc::c_long, libc::c_long) {
        unsafe {
            let mut column = std::mem::MaybeUninit::uninit();
            let mut row = std::mem::MaybeUninit::uninit();
            ffi::vte_terminal_get_cursor_position(
                self.as_ref().to_glib_none().0,
                column.as_mut_ptr(),
                row.as_mut_ptr(),
            );
            (column.assume_init(), row.assume_init())
        }
    }

    /// Returns the currently set cursor shape.
    ///
    /// # Returns
    ///
    /// cursor shape.
    #[doc(alias = "vte_terminal_get_cursor_shape")]
    #[doc(alias = "get_cursor_shape")]
    #[doc(alias = "cursor-shape")]
    fn cursor_shape(&self) -> CursorShape {
        unsafe {
            from_glib(ffi::vte_terminal_get_cursor_shape(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Checks whether the terminal communicates with a11y backends
    ///
    /// # Returns
    ///
    /// [`true`] if a11y is enabled, [`false`] if not
    #[cfg(feature = "v0_78")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v0_78")))]
    #[doc(alias = "vte_terminal_get_enable_a11y")]
    #[doc(alias = "get_enable_a11y")]
    #[doc(alias = "enable-a11y")]
    fn enables_a11y(&self) -> bool {
        unsafe {
            from_glib(ffi::vte_terminal_get_enable_a11y(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Checks whether the terminal performs bidirectional text rendering.
    ///
    /// # Returns
    ///
    /// [`true`] if BiDi is enabled, [`false`] if not
    #[doc(alias = "vte_terminal_get_enable_bidi")]
    #[doc(alias = "get_enable_bidi")]
    #[doc(alias = "enable-bidi")]
    fn enables_bidi(&self) -> bool {
        unsafe {
            from_glib(ffi::vte_terminal_get_enable_bidi(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    ///
    /// # Returns
    ///
    /// [`true`] if fallback scrolling is enabled
    #[doc(alias = "vte_terminal_get_enable_fallback_scrolling")]
    #[doc(alias = "get_enable_fallback_scrolling")]
    #[doc(alias = "enable-fallback-scrolling")]
    fn enables_fallback_scrolling(&self) -> bool {
        unsafe {
            from_glib(ffi::vte_terminal_get_enable_fallback_scrolling(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Checks whether the terminal shapes Arabic text.
    ///
    /// # Returns
    ///
    /// [`true`] if Arabic shaping is enabled, [`false`] if not
    #[doc(alias = "vte_terminal_get_enable_shaping")]
    #[doc(alias = "get_enable_shaping")]
    #[doc(alias = "enable-shaping")]
    fn enables_shaping(&self) -> bool {
        unsafe {
            from_glib(ffi::vte_terminal_get_enable_shaping(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    ///
    /// # Returns
    ///
    /// [`false`]
    #[doc(alias = "vte_terminal_get_enable_sixel")]
    #[doc(alias = "get_enable_sixel")]
    #[doc(alias = "enable-sixel")]
    fn enables_sixel(&self) -> bool {
        unsafe {
            from_glib(ffi::vte_terminal_get_enable_sixel(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Queries the terminal for information about the fonts which will be
    /// used to draw text in the terminal.  The actual font takes the font scale
    /// into account, this is not reflected in the return value, the unscaled
    /// font is returned.
    ///
    /// # Returns
    ///
    /// a #PangoFontDescription describing the font the
    /// terminal uses to render text at the default font scale of 1.0.
    #[doc(alias = "vte_terminal_get_font")]
    #[doc(alias = "get_font")]
    fn font(&self) -> Option<pango::FontDescription> {
        unsafe { from_glib_none(ffi::vte_terminal_get_font(self.as_ref().to_glib_none().0)) }
    }

    ///
    /// # Returns
    ///
    /// the terminal's font options, or [`None`]
    #[cfg(feature = "v0_74")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v0_74")))]
    #[doc(alias = "vte_terminal_get_font_options")]
    #[doc(alias = "get_font_options")]
    #[doc(alias = "font-options")]
    fn font_options(&self) -> Option<cairo::FontOptions> {
        unsafe {
            from_glib_none(ffi::vte_terminal_get_font_options(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    ///
    /// # Returns
    ///
    /// the terminal's font scale
    #[doc(alias = "vte_terminal_get_font_scale")]
    #[doc(alias = "get_font_scale")]
    #[doc(alias = "font-scale")]
    fn font_scale(&self) -> f64 {
        unsafe { ffi::vte_terminal_get_font_scale(self.as_ref().to_glib_none().0) }
    }

    /// Checks if the terminal currently contains selected text.  Note that this
    /// is different from determining if the terminal is the owner of any
    /// #GtkClipboard items.
    ///
    /// # Returns
    ///
    /// [`true`] if part of the text in the terminal is selected.
    #[doc(alias = "vte_terminal_get_has_selection")]
    #[doc(alias = "get_has_selection")]
    fn has_selection(&self) -> bool {
        unsafe {
            from_glib(ffi::vte_terminal_get_has_selection(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Returns whether the terminal allow user input.
    #[doc(alias = "vte_terminal_get_input_enabled")]
    #[doc(alias = "get_input_enabled")]
    #[doc(alias = "input-enabled")]
    fn is_input_enabled(&self) -> bool {
        unsafe {
            from_glib(ffi::vte_terminal_get_input_enabled(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Determines the value of the terminal's mouse autohide setting.  When
    /// autohiding is enabled, the mouse cursor will be hidden when the user presses
    /// a key and shown when the user moves the mouse.  This setting can be changed
    /// using vte_terminal_set_mouse_autohide().
    ///
    /// # Returns
    ///
    /// [`true`] if autohiding is enabled, [`false`] if not
    #[doc(alias = "vte_terminal_get_mouse_autohide")]
    #[doc(alias = "get_mouse_autohide")]
    fn is_mouse_autohide(&self) -> bool {
        unsafe {
            from_glib(ffi::vte_terminal_get_mouse_autohide(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Returns the #VtePty of @self.
    ///
    /// # Returns
    ///
    /// a #VtePty, or [`None`]
    #[doc(alias = "vte_terminal_get_pty")]
    #[doc(alias = "get_pty")]
    fn pty(&self) -> Option<Pty> {
        unsafe { from_glib_none(ffi::vte_terminal_get_pty(self.as_ref().to_glib_none().0)) }
    }

    ///
    /// # Returns
    ///
    /// the number of rows
    #[doc(alias = "vte_terminal_get_row_count")]
    #[doc(alias = "get_row_count")]
    fn row_count(&self) -> libc::c_long {
        unsafe { ffi::vte_terminal_get_row_count(self.as_ref().to_glib_none().0) }
    }

    ///
    /// # Returns
    ///
    /// whether or not the terminal will forcibly scroll to the bottom of
    /// the viewable history when the new data is received from the child.
    #[cfg(feature = "v0_76")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v0_76")))]
    #[doc(alias = "vte_terminal_get_scroll_on_insert")]
    #[doc(alias = "get_scroll_on_insert")]
    #[doc(alias = "scroll-on-insert")]
    fn is_scroll_on_insert(&self) -> bool {
        unsafe {
            from_glib(ffi::vte_terminal_get_scroll_on_insert(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    ///
    /// # Returns
    ///
    /// whether or not the terminal will forcibly scroll to the bottom of
    /// the viewable history when the user presses a key.  Modifier keys do not
    /// trigger this behavior.
    #[doc(alias = "vte_terminal_get_scroll_on_keystroke")]
    #[doc(alias = "get_scroll_on_keystroke")]
    #[doc(alias = "scroll-on-keystroke")]
    fn is_scroll_on_keystroke(&self) -> bool {
        unsafe {
            from_glib(ffi::vte_terminal_get_scroll_on_keystroke(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    ///
    /// # Returns
    ///
    /// whether or not the terminal will forcibly scroll to the bottom of
    /// the viewable history when the new data is received from the child.
    #[doc(alias = "vte_terminal_get_scroll_on_output")]
    #[doc(alias = "get_scroll_on_output")]
    #[doc(alias = "scroll-on-output")]
    fn is_scroll_on_output(&self) -> bool {
        unsafe {
            from_glib(ffi::vte_terminal_get_scroll_on_output(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    ///
    /// # Returns
    ///
    /// [`true`] if the scroll unit is pixels; or [`false`] if the unit is lines
    #[doc(alias = "vte_terminal_get_scroll_unit_is_pixels")]
    #[doc(alias = "get_scroll_unit_is_pixels")]
    #[doc(alias = "scroll-unit-is-pixels")]
    fn is_scroll_unit_is_pixels(&self) -> bool {
        unsafe {
            from_glib(ffi::vte_terminal_get_scroll_unit_is_pixels(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    ///
    /// # Returns
    ///
    /// length of the scrollback buffer used by the terminal.
    /// A negative value means "infinite scrollback".
    #[doc(alias = "vte_terminal_get_scrollback_lines")]
    #[doc(alias = "get_scrollback_lines")]
    #[doc(alias = "scrollback-lines")]
    fn scrollback_lines(&self) -> libc::c_long {
        unsafe { ffi::vte_terminal_get_scrollback_lines(self.as_ref().to_glib_none().0) }
    }

    //#[cfg_attr(feature = "v0_76", deprecated = "Since 0.76")]
    //#[allow(deprecated)]
    //#[doc(alias = "vte_terminal_get_text")]
    //#[doc(alias = "get_text")]
    //fn text(&self, is_selected: Option<&mut dyn (FnMut(&Terminal, libc::c_long, libc::c_long) -> bool)>, attributes: /*Unknown conversion*//*Unimplemented*/Array TypeId { ns_id: 1, id: 1 }) -> Option<glib::GString> {
    //    unsafe { TODO: call ffi:vte_terminal_get_text() }
    //}

    /// Checks whether or not the terminal will allow blinking text.
    ///
    /// # Returns
    ///
    /// the blinking setting
    #[doc(alias = "vte_terminal_get_text_blink_mode")]
    #[doc(alias = "get_text_blink_mode")]
    #[doc(alias = "text-blink-mode")]
    fn text_blink_mode(&self) -> TextBlinkMode {
        unsafe {
            from_glib(ffi::vte_terminal_get_text_blink_mode(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Returns text from the visible part of the terminal in the specified format.
    ///
    /// This method is unaware of BiDi. The columns returned in @attributes are
    /// logical columns.
    /// ## `format`
    /// the #VteFormat to use
    ///
    /// # Returns
    ///
    /// a newly allocated text string, or [`None`].
    #[cfg(feature = "v0_76")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v0_76")))]
    #[doc(alias = "vte_terminal_get_text_format")]
    #[doc(alias = "get_text_format")]
    fn text_format(&self, format: Format) -> Option<glib::GString> {
        unsafe {
            from_glib_full(ffi::vte_terminal_get_text_format(
                self.as_ref().to_glib_none().0,
                format.into_glib(),
            ))
        }
    }

    //#[cfg_attr(feature = "v0_76", deprecated = "Since 0.76")]
    //#[allow(deprecated)]
    //#[doc(alias = "vte_terminal_get_text_range")]
    //#[doc(alias = "get_text_range")]
    //fn text_range(&self, start_row: libc::c_long, start_col: libc::c_long, end_row: libc::c_long, end_col: libc::c_long, is_selected: Option<&mut dyn (FnMut(&Terminal, libc::c_long, libc::c_long) -> bool)>, attributes: /*Unknown conversion*//*Unimplemented*/Array TypeId { ns_id: 1, id: 1 }) -> Option<glib::GString> {
    //    unsafe { TODO: call ffi:vte_terminal_get_text_range() }
    //}

    /// Returns the specified range of text in the specified format.
    /// ## `format`
    /// the #VteFormat to use
    /// ## `start_row`
    /// the first row of the range
    /// ## `start_col`
    /// the first column of the range
    /// ## `end_row`
    /// the last row of the range
    /// ## `end_col`
    /// the last column of the range
    ///
    /// # Returns
    ///
    /// a newly allocated string, or [`None`].
    ///
    /// ## `length`
    /// a pointer to a #gsize to store the string length
    #[cfg(feature = "v0_72")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v0_72")))]
    #[doc(alias = "vte_terminal_get_text_range_format")]
    #[doc(alias = "get_text_range_format")]
    fn text_range_format(
        &self,
        format: Format,
        start_row: libc::c_long,
        start_col: libc::c_long,
        end_row: libc::c_long,
        end_col: libc::c_long,
    ) -> (Option<glib::GString>, usize) {
        unsafe {
            let mut length = std::mem::MaybeUninit::uninit();
            let ret = from_glib_full(ffi::vte_terminal_get_text_range_format(
                self.as_ref().to_glib_none().0,
                format.into_glib(),
                start_row,
                start_col,
                end_row,
                end_col,
                length.as_mut_ptr(),
            ));
            (ret, length.assume_init())
        }
    }

    /// Gets the currently selected text in the format specified by @format.
    /// Since 0.72, this function also supports [`Format::Html`][crate::Format::Html] format.
    /// ## `format`
    /// the #VteFormat to use
    ///
    /// # Returns
    ///
    /// a newly allocated string containing the selected text, or [`None`] if there is no selection or the format is not supported
    #[cfg(feature = "v0_70")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v0_70")))]
    #[doc(alias = "vte_terminal_get_text_selected")]
    #[doc(alias = "get_text_selected")]
    fn text_selected(&self, format: Format) -> Option<glib::GString> {
        unsafe {
            from_glib_full(ffi::vte_terminal_get_text_selected(
                self.as_ref().to_glib_none().0,
                format.into_glib(),
            ))
        }
    }

    /// Gets the currently selected text in the format specified by @format.
    /// ## `format`
    /// the #VteFormat to use
    ///
    /// # Returns
    ///
    /// a newly allocated string containing the selected text, or [`None`] if there is no selection or the format is not supported
    ///
    /// ## `length`
    /// a pointer to a #gsize to store the string length
    #[cfg(feature = "v0_72")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v0_72")))]
    #[doc(alias = "vte_terminal_get_text_selected_full")]
    #[doc(alias = "get_text_selected_full")]
    fn text_selected_full(&self, format: Format) -> (Option<glib::GString>, usize) {
        unsafe {
            let mut length = std::mem::MaybeUninit::uninit();
            let ret = from_glib_full(ffi::vte_terminal_get_text_selected_full(
                self.as_ref().to_glib_none().0,
                format.into_glib(),
                length.as_mut_ptr(),
            ));
            (ret, length.assume_init())
        }
    }

    ///
    /// # Returns
    ///
    /// the window title, or [`None`]
    #[doc(alias = "vte_terminal_get_window_title")]
    #[doc(alias = "get_window_title")]
    #[doc(alias = "window-title")]
    fn window_title(&self) -> Option<glib::GString> {
        unsafe {
            from_glib_none(ffi::vte_terminal_get_window_title(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Returns the set of characters which will be considered parts of a word
    /// when doing word-wise selection, in addition to the default which only
    /// considers alphanumeric characters part of a word.
    ///
    /// If [`None`], a built-in set is used.
    ///
    /// # Returns
    ///
    /// a string, or [`None`]
    #[doc(alias = "vte_terminal_get_word_char_exceptions")]
    #[doc(alias = "get_word_char_exceptions")]
    #[doc(alias = "word-char-exceptions")]
    fn word_char_exceptions(&self) -> Option<glib::GString> {
        unsafe {
            from_glib_none(ffi::vte_terminal_get_word_char_exceptions(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    ///
    /// # Returns
    ///
    /// the horizontal alignment of @self within its allocation
    #[cfg(feature = "v0_76")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v0_76")))]
    #[doc(alias = "vte_terminal_get_xalign")]
    #[doc(alias = "get_xalign")]
    fn xalign(&self) -> Align {
        unsafe { from_glib(ffi::vte_terminal_get_xalign(self.as_ref().to_glib_none().0)) }
    }

    ///
    /// # Returns
    ///
    /// the horizontal fillment of @self within its allocation
    #[cfg(feature = "v0_76")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v0_76")))]
    #[doc(alias = "vte_terminal_get_xfill")]
    #[doc(alias = "get_xfill")]
    #[doc(alias = "xfill")]
    fn is_xfill(&self) -> bool {
        unsafe { from_glib(ffi::vte_terminal_get_xfill(self.as_ref().to_glib_none().0)) }
    }

    ///
    /// # Returns
    ///
    /// the vertical alignment of @self within its allocation
    #[cfg(feature = "v0_76")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v0_76")))]
    #[doc(alias = "vte_terminal_get_yalign")]
    #[doc(alias = "get_yalign")]
    fn yalign(&self) -> Align {
        unsafe { from_glib(ffi::vte_terminal_get_yalign(self.as_ref().to_glib_none().0)) }
    }

    ///
    /// # Returns
    ///
    /// the vertical fillment of @self within its allocation
    #[cfg(feature = "v0_76")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v0_76")))]
    #[doc(alias = "vte_terminal_get_yfill")]
    #[doc(alias = "get_yfill")]
    #[doc(alias = "yfill")]
    fn is_yfill(&self) -> bool {
        unsafe { from_glib(ffi::vte_terminal_get_yfill(self.as_ref().to_glib_none().0)) }
    }

    /// Adds the regular expression @regex to the list of matching expressions.  When the
    /// user moves the mouse cursor over a section of displayed text which matches
    /// this expression, the text will be highlighted.
    ///
    /// Note that @regex should have been created using the <literal>PCRE2_MULTILINE</literal>
    /// flag.
    /// ## `regex`
    /// a #VteRegex
    /// ## `flags`
    /// PCRE2 match flags, or 0
    ///
    /// # Returns
    ///
    /// an integer associated with this expression
    #[doc(alias = "vte_terminal_match_add_regex")]
    fn match_add_regex(&self, regex: &Regex, flags: u32) -> i32 {
        unsafe {
            ffi::vte_terminal_match_add_regex(
                self.as_ref().to_glib_none().0,
                regex.to_glib_none().0,
                flags,
            )
        }
    }

    /// Removes the regular expression which is associated with the given @tag from
    /// the list of expressions which the terminal will highlight when the user
    /// moves the mouse cursor over matching text.
    /// ## `tag`
    /// the tag of the regex to remove
    #[doc(alias = "vte_terminal_match_remove")]
    fn match_remove(&self, tag: i32) {
        unsafe {
            ffi::vte_terminal_match_remove(self.as_ref().to_glib_none().0, tag);
        }
    }

    /// Clears the list of regular expressions the terminal uses to highlight text
    /// when the user moves the mouse cursor.
    #[doc(alias = "vte_terminal_match_remove_all")]
    fn match_remove_all(&self) {
        unsafe {
            ffi::vte_terminal_match_remove_all(self.as_ref().to_glib_none().0);
        }
    }

    /// Sets which cursor the terminal will use if the pointer is over the pattern
    /// specified by @tag.
    /// ## `tag`
    /// the tag of the regex which should use the specified cursor
    /// ## `cursor_name`
    /// the name of the cursor
    #[doc(alias = "vte_terminal_match_set_cursor_name")]
    fn match_set_cursor_name(&self, tag: i32, cursor_name: &str) {
        unsafe {
            ffi::vte_terminal_match_set_cursor_name(
                self.as_ref().to_glib_none().0,
                tag,
                cursor_name.to_glib_none().0,
            );
        }
    }

    /// Sends the contents of the #GDK_SELECTION_CLIPBOARD selection to the
    /// terminal's child. It's called on paste menu item, or when
    /// user presses Shift+Insert.
    #[doc(alias = "vte_terminal_paste_clipboard")]
    fn paste_clipboard(&self) {
        unsafe {
            ffi::vte_terminal_paste_clipboard(self.as_ref().to_glib_none().0);
        }
    }

    /// Sends the contents of the #GDK_SELECTION_PRIMARY selection to the terminal's
    /// child. The terminal will call also paste the
    /// #GDK_SELECTION_PRIMARY selection when the user clicks with the the second
    /// mouse button.
    #[doc(alias = "vte_terminal_paste_primary")]
    fn paste_primary(&self) {
        unsafe {
            ffi::vte_terminal_paste_primary(self.as_ref().to_glib_none().0);
        }
    }

    /// Sends @text to the terminal's child as if retrived from the clipboard,
    /// this differs from vte_terminal_feed_child() in that it may process
    /// @text before passing it to the child (e.g. apply bracketed mode)
    /// ## `text`
    /// a string to paste
    #[doc(alias = "vte_terminal_paste_text")]
    fn paste_text(&self, text: &str) {
        unsafe {
            ffi::vte_terminal_paste_text(self.as_ref().to_glib_none().0, text.to_glib_none().0);
        }
    }

    /// Creates a new #VtePty, sets the emulation property
    /// from #VteTerminal:emulation, and sets the size using
    /// @self's size.
    ///
    /// See vte_pty_new() for more information.
    /// ## `flags`
    /// flags from #VtePtyFlags
    /// ## `cancellable`
    /// a #GCancellable, or [`None`]
    ///
    /// # Returns
    ///
    /// a new #VtePty
    #[doc(alias = "vte_terminal_pty_new_sync")]
    fn pty_new_sync(
        &self,
        flags: PtyFlags,
        cancellable: Option<&impl IsA<gio::Cancellable>>,
    ) -> Result<Pty, glib::Error> {
        unsafe {
            let mut error = std::ptr::null_mut();
            let ret = ffi::vte_terminal_pty_new_sync(
                self.as_ref().to_glib_none().0,
                flags.into_glib(),
                cancellable.map(|p| p.as_ref()).to_glib_none().0,
                &mut error,
            );
            if error.is_null() {
                Ok(from_glib_full(ret))
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    /// Resets as much of the terminal's internal state as possible, discarding any
    /// unprocessed input data, resetting character attributes, cursor state,
    /// national character set state, status line, terminal modes (insert/delete),
    /// selection state, and encoding.
    /// ## `clear_tabstops`
    /// whether to reset tabstops
    /// ## `clear_history`
    /// whether to empty the terminal's scrollback buffer
    #[doc(alias = "vte_terminal_reset")]
    fn reset(&self, clear_tabstops: bool, clear_history: bool) {
        unsafe {
            ffi::vte_terminal_reset(
                self.as_ref().to_glib_none().0,
                clear_tabstops.into_glib(),
                clear_history.into_glib(),
            );
        }
    }

    /// Searches the next string matching the search regex set with
    /// vte_terminal_search_set_regex().
    ///
    /// # Returns
    ///
    /// [`true`] if a match was found
    #[doc(alias = "vte_terminal_search_find_next")]
    fn search_find_next(&self) -> bool {
        unsafe {
            from_glib(ffi::vte_terminal_search_find_next(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Searches the previous string matching the search regex set with
    /// vte_terminal_search_set_regex().
    ///
    /// # Returns
    ///
    /// [`true`] if a match was found
    #[doc(alias = "vte_terminal_search_find_previous")]
    fn search_find_previous(&self) -> bool {
        unsafe {
            from_glib(ffi::vte_terminal_search_find_previous(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    ///
    /// # Returns
    ///
    /// the search #VteRegex regex set in @self, or [`None`]
    #[doc(alias = "vte_terminal_search_get_regex")]
    fn search_get_regex(&self) -> Option<Regex> {
        unsafe {
            from_glib_none(ffi::vte_terminal_search_get_regex(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    ///
    /// # Returns
    ///
    /// whether searching will wrap around
    #[doc(alias = "vte_terminal_search_get_wrap_around")]
    fn search_get_wrap_around(&self) -> bool {
        unsafe {
            from_glib(ffi::vte_terminal_search_get_wrap_around(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Sets the regex to search for. Unsets the search regex when passed [`None`].
    ///
    /// Note that @regex should have been created using the
    /// <literal>PCRE2_MULTILINE</literal> flag.
    /// ## `regex`
    /// a #VteRegex, or [`None`]
    /// ## `flags`
    /// PCRE2 match flags, or 0
    #[doc(alias = "vte_terminal_search_set_regex")]
    fn search_set_regex(&self, regex: Option<&Regex>, flags: u32) {
        unsafe {
            ffi::vte_terminal_search_set_regex(
                self.as_ref().to_glib_none().0,
                regex.to_glib_none().0,
                flags,
            );
        }
    }

    /// Sets whether search should wrap around to the beginning of the
    /// terminal content when reaching its end.
    /// ## `wrap_around`
    /// whether search should wrap
    #[doc(alias = "vte_terminal_search_set_wrap_around")]
    fn search_set_wrap_around(&self, wrap_around: bool) {
        unsafe {
            ffi::vte_terminal_search_set_wrap_around(
                self.as_ref().to_glib_none().0,
                wrap_around.into_glib(),
            );
        }
    }

    /// Selects all text within the terminal (not including the scrollback buffer).
    #[doc(alias = "vte_terminal_select_all")]
    fn select_all(&self) {
        unsafe {
            ffi::vte_terminal_select_all(self.as_ref().to_glib_none().0);
        }
    }

    /// Controls whether or not hyperlinks (OSC 8 escape sequence) are allowed.
    /// ## `allow_hyperlink`
    /// [`true`] if the terminal should allow hyperlinks
    #[doc(alias = "vte_terminal_set_allow_hyperlink")]
    #[doc(alias = "allow-hyperlink")]
    fn set_allow_hyperlink(&self, allow_hyperlink: bool) {
        unsafe {
            ffi::vte_terminal_set_allow_hyperlink(
                self.as_ref().to_glib_none().0,
                allow_hyperlink.into_glib(),
            );
        }
    }

    /// Controls whether or not the terminal will beep when the child outputs the
    /// "bl" sequence.
    /// ## `is_audible`
    /// [`true`] if the terminal should beep
    #[doc(alias = "vte_terminal_set_audible_bell")]
    #[doc(alias = "audible-bell")]
    fn set_audible_bell(&self, is_audible: bool) {
        unsafe {
            ffi::vte_terminal_set_audible_bell(
                self.as_ref().to_glib_none().0,
                is_audible.into_glib(),
            );
        }
    }

    /// Modifies the terminal's backspace key binding, which controls what
    /// string or control sequence the terminal sends to its child when the user
    /// presses the backspace key.
    /// ## `binding`
    /// a #VteEraseBinding for the backspace key
    #[doc(alias = "vte_terminal_set_backspace_binding")]
    #[doc(alias = "backspace-binding")]
    fn set_backspace_binding(&self, binding: EraseBinding) {
        unsafe {
            ffi::vte_terminal_set_backspace_binding(
                self.as_ref().to_glib_none().0,
                binding.into_glib(),
            );
        }
    }

    /// Sets whether the SGR 1 attribute also switches to the bright counterpart
    /// of the first 8 palette colors, in addition to making them bold (legacy behavior)
    /// or if SGR 1 only enables bold and leaves the color intact.
    /// ## `bold_is_bright`
    /// [`true`] if bold should also enable bright
    #[doc(alias = "vte_terminal_set_bold_is_bright")]
    #[doc(alias = "bold-is-bright")]
    fn set_bold_is_bright(&self, bold_is_bright: bool) {
        unsafe {
            ffi::vte_terminal_set_bold_is_bright(
                self.as_ref().to_glib_none().0,
                bold_is_bright.into_glib(),
            );
        }
    }

    /// Sets the terminal's cell height scale to @scale.
    ///
    /// This can be used to increase the line spacing. (The font's height is not affected.)
    /// Valid values go from 1.0 (default) to 2.0 ("double spacing").
    /// ## `scale`
    /// the cell height scale
    #[doc(alias = "vte_terminal_set_cell_height_scale")]
    #[doc(alias = "cell-height-scale")]
    fn set_cell_height_scale(&self, scale: f64) {
        unsafe {
            ffi::vte_terminal_set_cell_height_scale(self.as_ref().to_glib_none().0, scale);
        }
    }

    /// Sets the terminal's cell width scale to @scale.
    ///
    /// This can be used to increase the letter spacing. (The font's width is not affected.)
    /// Valid values go from 1.0 (default) to 2.0.
    /// ## `scale`
    /// the cell width scale
    #[doc(alias = "vte_terminal_set_cell_width_scale")]
    #[doc(alias = "cell-width-scale")]
    fn set_cell_width_scale(&self, scale: f64) {
        unsafe {
            ffi::vte_terminal_set_cell_width_scale(self.as_ref().to_glib_none().0, scale);
        }
    }

    /// This setting controls whether ambiguous-width characters are narrow or wide.
    /// (Note that when using a non-UTF-8 encoding set via vte_terminal_set_encoding(),
    /// the width of ambiguous-width characters is fixed and determined by the encoding
    /// itself.)
    /// ## `width`
    /// either 1 (narrow) or 2 (wide)
    #[doc(alias = "vte_terminal_set_cjk_ambiguous_width")]
    #[doc(alias = "cjk-ambiguous-width")]
    fn set_cjk_ambiguous_width(&self, width: i32) {
        unsafe {
            ffi::vte_terminal_set_cjk_ambiguous_width(self.as_ref().to_glib_none().0, width);
        }
    }

    /// Sets whether to paint the background with the background colour.
    /// The default is [`true`].
    ///
    /// This function is rarely useful. One use for it is to add a background
    /// image to the terminal.
    /// ## `setting`
    /// whether to clear the background
    #[doc(alias = "vte_terminal_set_clear_background")]
    fn set_clear_background(&self, setting: bool) {
        unsafe {
            ffi::vte_terminal_set_clear_background(
                self.as_ref().to_glib_none().0,
                setting.into_glib(),
            );
        }
    }

    /// Sets the background color for text which does not have a specific background
    /// color assigned.  Only has effect when no background image is set and when
    /// the terminal is not transparent.
    /// ## `background`
    /// the new background color
    #[doc(alias = "vte_terminal_set_color_background")]
    fn set_color_background(&self, background: &gdk::RGBA) {
        unsafe {
            ffi::vte_terminal_set_color_background(
                self.as_ref().to_glib_none().0,
                background.to_glib_none().0,
            );
        }
    }

    /// Sets the color used to draw bold text in the default foreground color.
    /// If @bold is [`None`] then the default color is used.
    /// ## `bold`
    /// the new bold color or [`None`]
    #[doc(alias = "vte_terminal_set_color_bold")]
    fn set_color_bold(&self, bold: Option<&gdk::RGBA>) {
        unsafe {
            ffi::vte_terminal_set_color_bold(self.as_ref().to_glib_none().0, bold.to_glib_none().0);
        }
    }

    /// Sets the background color for text which is under the cursor.  If [`None`], text
    /// under the cursor will be drawn with foreground and background colors
    /// reversed.
    /// ## `cursor_background`
    /// the new color to use for the text cursor, or [`None`]
    #[doc(alias = "vte_terminal_set_color_cursor")]
    fn set_color_cursor(&self, cursor_background: Option<&gdk::RGBA>) {
        unsafe {
            ffi::vte_terminal_set_color_cursor(
                self.as_ref().to_glib_none().0,
                cursor_background.to_glib_none().0,
            );
        }
    }

    /// Sets the foreground color for text which is under the cursor.  If [`None`], text
    /// under the cursor will be drawn with foreground and background colors
    /// reversed.
    /// ## `cursor_foreground`
    /// the new color to use for the text cursor, or [`None`]
    #[doc(alias = "vte_terminal_set_color_cursor_foreground")]
    fn set_color_cursor_foreground(&self, cursor_foreground: Option<&gdk::RGBA>) {
        unsafe {
            ffi::vte_terminal_set_color_cursor_foreground(
                self.as_ref().to_glib_none().0,
                cursor_foreground.to_glib_none().0,
            );
        }
    }

    /// Sets the foreground color used to draw normal text.
    /// ## `foreground`
    /// the new foreground color
    #[doc(alias = "vte_terminal_set_color_foreground")]
    fn set_color_foreground(&self, foreground: &gdk::RGBA) {
        unsafe {
            ffi::vte_terminal_set_color_foreground(
                self.as_ref().to_glib_none().0,
                foreground.to_glib_none().0,
            );
        }
    }

    /// Sets the background color for text which is highlighted.  If [`None`],
    /// it is unset.  If neither highlight background nor highlight foreground are set,
    /// highlighted text (which is usually highlighted because it is selected) will
    /// be drawn with foreground and background colors reversed.
    /// ## `highlight_background`
    /// the new color to use for highlighted text, or [`None`]
    #[doc(alias = "vte_terminal_set_color_highlight")]
    fn set_color_highlight(&self, highlight_background: Option<&gdk::RGBA>) {
        unsafe {
            ffi::vte_terminal_set_color_highlight(
                self.as_ref().to_glib_none().0,
                highlight_background.to_glib_none().0,
            );
        }
    }

    /// Sets the foreground color for text which is highlighted.  If [`None`],
    /// it is unset.  If neither highlight background nor highlight foreground are set,
    /// highlighted text (which is usually highlighted because it is selected) will
    /// be drawn with foreground and background colors reversed.
    /// ## `highlight_foreground`
    /// the new color to use for highlighted text, or [`None`]
    #[doc(alias = "vte_terminal_set_color_highlight_foreground")]
    fn set_color_highlight_foreground(&self, highlight_foreground: Option<&gdk::RGBA>) {
        unsafe {
            ffi::vte_terminal_set_color_highlight_foreground(
                self.as_ref().to_glib_none().0,
                highlight_foreground.to_glib_none().0,
            );
        }
    }

    /// Sets @menu as the context menu in @self.
    /// Use [`None`] to unset the current menu.
    ///
    /// Note that a menu model set with vte_terminal_set_context_menu_model()
    /// takes precedence over a menu set using this function.
    /// ## `menu`
    /// a menu
    #[cfg(feature = "v0_76")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v0_76")))]
    #[doc(alias = "vte_terminal_set_context_menu")]
    #[doc(alias = "context-menu")]
    fn set_context_menu(&self, menu: Option<&impl IsA<gtk::Widget>>) {
        unsafe {
            ffi::vte_terminal_set_context_menu(
                self.as_ref().to_glib_none().0,
                menu.map(|p| p.as_ref()).to_glib_none().0,
            );
        }
    }

    /// Sets @model as the context menu model in @self.
    /// Use [`None`] to unset the current menu model.
    /// ## `model`
    /// a #GMenuModel
    #[cfg(feature = "v0_76")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v0_76")))]
    #[doc(alias = "vte_terminal_set_context_menu_model")]
    #[doc(alias = "context-menu-model")]
    fn set_context_menu_model(&self, model: Option<&impl IsA<gio::MenuModel>>) {
        unsafe {
            ffi::vte_terminal_set_context_menu_model(
                self.as_ref().to_glib_none().0,
                model.map(|p| p.as_ref()).to_glib_none().0,
            );
        }
    }

    /// Sets whether or not the cursor will blink. Using [`CursorBlinkMode::System`][crate::CursorBlinkMode::System]
    /// will use the #GtkSettings::gtk-cursor-blink setting.
    /// ## `mode`
    /// the #VteCursorBlinkMode to use
    #[doc(alias = "vte_terminal_set_cursor_blink_mode")]
    #[doc(alias = "cursor-blink-mode")]
    fn set_cursor_blink_mode(&self, mode: CursorBlinkMode) {
        unsafe {
            ffi::vte_terminal_set_cursor_blink_mode(
                self.as_ref().to_glib_none().0,
                mode.into_glib(),
            );
        }
    }

    /// Sets the shape of the cursor drawn.
    /// ## `shape`
    /// the #VteCursorShape to use
    #[doc(alias = "vte_terminal_set_cursor_shape")]
    #[doc(alias = "cursor-shape")]
    fn set_cursor_shape(&self, shape: CursorShape) {
        unsafe {
            ffi::vte_terminal_set_cursor_shape(self.as_ref().to_glib_none().0, shape.into_glib());
        }
    }

    /// Reset the terminal palette to reasonable compiled-in default color.
    #[doc(alias = "vte_terminal_set_default_colors")]
    fn set_default_colors(&self) {
        unsafe {
            ffi::vte_terminal_set_default_colors(self.as_ref().to_glib_none().0);
        }
    }

    /// Modifies the terminal's delete key binding, which controls what
    /// string or control sequence the terminal sends to its child when the user
    /// presses the delete key.
    /// ## `binding`
    /// a #VteEraseBinding for the delete key
    #[doc(alias = "vte_terminal_set_delete_binding")]
    #[doc(alias = "delete-binding")]
    fn set_delete_binding(&self, binding: EraseBinding) {
        unsafe {
            ffi::vte_terminal_set_delete_binding(
                self.as_ref().to_glib_none().0,
                binding.into_glib(),
            );
        }
    }

    /// Controls whether or not the terminal will communicate with a11y backends.
    /// ## `enable_a11y`
    /// [`true`] to enable a11y support
    #[cfg(feature = "v0_78")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v0_78")))]
    #[doc(alias = "vte_terminal_set_enable_a11y")]
    #[doc(alias = "enable-a11y")]
    fn set_enable_a11y(&self, enable_a11y: bool) {
        unsafe {
            ffi::vte_terminal_set_enable_a11y(
                self.as_ref().to_glib_none().0,
                enable_a11y.into_glib(),
            );
        }
    }

    /// Controls whether or not the terminal will perform bidirectional text rendering.
    /// ## `enable_bidi`
    /// [`true`] to enable BiDi support
    #[doc(alias = "vte_terminal_set_enable_bidi")]
    #[doc(alias = "enable-bidi")]
    fn set_enable_bidi(&self, enable_bidi: bool) {
        unsafe {
            ffi::vte_terminal_set_enable_bidi(
                self.as_ref().to_glib_none().0,
                enable_bidi.into_glib(),
            );
        }
    }

    /// Controls whether the terminal uses scroll events to scroll the history
    /// if the event was not otherwise consumed by it.
    ///
    /// This function is rarely useful, except when the terminal is added to a
    /// #GtkScrolledWindow, to perform kinetic scrolling (while vte itself does
    /// not, yet, implement kinetic scrolling by itself).
    /// ## `enable`
    /// whether to enable fallback scrolling
    #[doc(alias = "vte_terminal_set_enable_fallback_scrolling")]
    #[doc(alias = "enable-fallback-scrolling")]
    fn set_enable_fallback_scrolling(&self, enable: bool) {
        unsafe {
            ffi::vte_terminal_set_enable_fallback_scrolling(
                self.as_ref().to_glib_none().0,
                enable.into_glib(),
            );
        }
    }

    /// Controls whether or not the terminal will shape Arabic text.
    /// ## `enable_shaping`
    /// [`true`] to enable Arabic shaping
    #[doc(alias = "vte_terminal_set_enable_shaping")]
    #[doc(alias = "enable-shaping")]
    fn set_enable_shaping(&self, enable_shaping: bool) {
        unsafe {
            ffi::vte_terminal_set_enable_shaping(
                self.as_ref().to_glib_none().0,
                enable_shaping.into_glib(),
            );
        }
    }

    /// Set whether to enable SIXEL images.
    /// ## `enabled`
    /// whether to enable SIXEL images
    #[doc(alias = "vte_terminal_set_enable_sixel")]
    #[doc(alias = "enable-sixel")]
    fn set_enable_sixel(&self, enabled: bool) {
        unsafe {
            ffi::vte_terminal_set_enable_sixel(self.as_ref().to_glib_none().0, enabled.into_glib());
        }
    }

    /// Sets the font used for rendering all text displayed by the terminal,
    /// overriding any fonts set using gtk_widget_modify_font().  The terminal
    /// will immediately attempt to load the desired font, retrieve its
    /// metrics, and attempt to resize itself to keep the same number of rows
    /// and columns.  The font scale is applied to the specified font.
    /// ## `font_desc`
    /// a #PangoFontDescription for the desired font, or [`None`]
    #[doc(alias = "vte_terminal_set_font")]
    fn set_font(&self, font_desc: Option<&pango::FontDescription>) {
        unsafe {
            ffi::vte_terminal_set_font(self.as_ref().to_glib_none().0, font_desc.to_glib_none().0);
        }
    }

    /// Sets the terminal's font options to @options.
    ///
    /// Note that on GTK4, the terminal by default uses font options
    /// with `CAIRO_HINT_METRICS_ON` set; to override that, use this
    /// function to set a #cairo_font_options_t that has
    /// `CAIRO_HINT_METRICS_OFF` set.
    /// ## `font_options`
    /// the font options, or [`None`]
    #[cfg(feature = "v0_74")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v0_74")))]
    #[doc(alias = "vte_terminal_set_font_options")]
    #[doc(alias = "font-options")]
    fn set_font_options(&self, font_options: Option<&cairo::FontOptions>) {
        unsafe {
            ffi::vte_terminal_set_font_options(
                self.as_ref().to_glib_none().0,
                font_options.to_glib_none().0,
            );
        }
    }

    /// Sets the terminal's font scale to @scale.
    /// ## `scale`
    /// the font scale
    #[doc(alias = "vte_terminal_set_font_scale")]
    #[doc(alias = "font-scale")]
    fn set_font_scale(&self, scale: f64) {
        unsafe {
            ffi::vte_terminal_set_font_scale(self.as_ref().to_glib_none().0, scale);
        }
    }

    /// Enables or disables user input. When user input is disabled,
    /// the terminal's child will not receive any key press, or mouse button
    /// press or motion events sent to it.
    /// ## `enabled`
    /// whether to enable user input
    #[doc(alias = "vte_terminal_set_input_enabled")]
    #[doc(alias = "input-enabled")]
    fn set_input_enabled(&self, enabled: bool) {
        unsafe {
            ffi::vte_terminal_set_input_enabled(
                self.as_ref().to_glib_none().0,
                enabled.into_glib(),
            );
        }
    }

    /// Changes the value of the terminal's mouse autohide setting.  When autohiding
    /// is enabled, the mouse cursor will be hidden when the user presses a key and
    /// shown when the user moves the mouse.  This setting can be read using
    /// vte_terminal_get_mouse_autohide().
    /// ## `setting`
    /// whether the mouse pointer should autohide
    #[doc(alias = "vte_terminal_set_mouse_autohide")]
    fn set_mouse_autohide(&self, setting: bool) {
        unsafe {
            ffi::vte_terminal_set_mouse_autohide(
                self.as_ref().to_glib_none().0,
                setting.into_glib(),
            );
        }
    }

    /// Sets @pty as the PTY to use in @self.
    /// Use [`None`] to unset the PTY.
    /// ## `pty`
    /// a #VtePty, or [`None`]
    #[doc(alias = "vte_terminal_set_pty")]
    #[doc(alias = "pty")]
    fn set_pty(&self, pty: Option<&Pty>) {
        unsafe {
            ffi::vte_terminal_set_pty(self.as_ref().to_glib_none().0, pty.to_glib_none().0);
        }
    }

    /// Controls whether or not the terminal will forcibly scroll to the bottom of
    /// the viewable history when text is inserted, e.g. by a paste.
    /// ## `scroll`
    /// whether the terminal should scroll on insert
    #[cfg(feature = "v0_76")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v0_76")))]
    #[doc(alias = "vte_terminal_set_scroll_on_insert")]
    #[doc(alias = "scroll-on-insert")]
    fn set_scroll_on_insert(&self, scroll: bool) {
        unsafe {
            ffi::vte_terminal_set_scroll_on_insert(
                self.as_ref().to_glib_none().0,
                scroll.into_glib(),
            );
        }
    }

    /// Controls whether or not the terminal will forcibly scroll to the bottom of
    /// the viewable history when the user presses a key.  Modifier keys do not
    /// trigger this behavior.
    /// ## `scroll`
    /// whether the terminal should scroll on keystrokes
    #[doc(alias = "vte_terminal_set_scroll_on_keystroke")]
    #[doc(alias = "scroll-on-keystroke")]
    fn set_scroll_on_keystroke(&self, scroll: bool) {
        unsafe {
            ffi::vte_terminal_set_scroll_on_keystroke(
                self.as_ref().to_glib_none().0,
                scroll.into_glib(),
            );
        }
    }

    /// Controls whether or not the terminal will forcibly scroll to the bottom of
    /// the viewable history when the new data is received from the child.
    /// ## `scroll`
    /// whether the terminal should scroll on output
    #[doc(alias = "vte_terminal_set_scroll_on_output")]
    #[doc(alias = "scroll-on-output")]
    fn set_scroll_on_output(&self, scroll: bool) {
        unsafe {
            ffi::vte_terminal_set_scroll_on_output(
                self.as_ref().to_glib_none().0,
                scroll.into_glib(),
            );
        }
    }

    /// Controls whether the terminal's scroll unit is lines or pixels.
    ///
    /// This function is rarely useful, except when the terminal is added to a
    /// #GtkScrolledWindow.
    /// ## `enable`
    /// whether to use pixels as scroll unit
    #[doc(alias = "vte_terminal_set_scroll_unit_is_pixels")]
    #[doc(alias = "scroll-unit-is-pixels")]
    fn set_scroll_unit_is_pixels(&self, enable: bool) {
        unsafe {
            ffi::vte_terminal_set_scroll_unit_is_pixels(
                self.as_ref().to_glib_none().0,
                enable.into_glib(),
            );
        }
    }

    /// Sets the length of the scrollback buffer used by the terminal.  The size of
    /// the scrollback buffer will be set to the larger of this value and the number
    /// of visible rows the widget can display, so 0 can safely be used to disable
    /// scrollback.
    ///
    /// A negative value means "infinite scrollback".
    ///
    /// Using a large scrollback buffer (roughly 1M+ lines) may lead to performance
    /// degradation or exhaustion of system resources, and is therefore not recommended.
    ///
    /// Note that this setting only affects the normal screen buffer.
    /// No scrollback is allowed on the alternate screen buffer.
    /// ## `lines`
    /// the length of the history buffer
    #[doc(alias = "vte_terminal_set_scrollback_lines")]
    #[doc(alias = "scrollback-lines")]
    fn set_scrollback_lines(&self, lines: libc::c_long) {
        unsafe {
            ffi::vte_terminal_set_scrollback_lines(self.as_ref().to_glib_none().0, lines);
        }
    }

    /// Attempts to change the terminal's size in terms of rows and columns.  If
    /// the attempt succeeds, the widget will resize itself to the proper size.
    /// ## `columns`
    /// the desired number of columns
    /// ## `rows`
    /// the desired number of rows
    #[doc(alias = "vte_terminal_set_size")]
    fn set_size(&self, columns: libc::c_long, rows: libc::c_long) {
        unsafe {
            ffi::vte_terminal_set_size(self.as_ref().to_glib_none().0, columns, rows);
        }
    }

    /// Controls whether or not the terminal will allow blinking text.
    /// ## `text_blink_mode`
    /// the #VteTextBlinkMode to use
    #[doc(alias = "vte_terminal_set_text_blink_mode")]
    #[doc(alias = "text-blink-mode")]
    fn set_text_blink_mode(&self, text_blink_mode: TextBlinkMode) {
        unsafe {
            ffi::vte_terminal_set_text_blink_mode(
                self.as_ref().to_glib_none().0,
                text_blink_mode.into_glib(),
            );
        }
    }

    /// With this function you can provide a set of characters which will
    /// be considered parts of a word when doing word-wise selection, in
    /// addition to the default which only considers alphanumeric characters
    /// part of a word.
    ///
    /// The characters in @exceptions must be non-alphanumeric, each character
    /// must occur only once, and if @exceptions contains the character
    /// U+002D HYPHEN-MINUS, it must be at the start of the string.
    ///
    /// Use [`None`] to reset the set of exception characters to the default.
    /// ## `exceptions`
    /// a string of ASCII punctuation characters, or [`None`]
    #[doc(alias = "vte_terminal_set_word_char_exceptions")]
    fn set_word_char_exceptions(&self, exceptions: &str) {
        unsafe {
            ffi::vte_terminal_set_word_char_exceptions(
                self.as_ref().to_glib_none().0,
                exceptions.to_glib_none().0,
            );
        }
    }

    /// Sets the horizontal alignment of @self within its allocation.
    ///
    /// Note: `VTE_ALIGN_START_FILL` is not supported, and will be treated
    ///   like [`Align::Start`][crate::Align::Start].
    /// ## `align`
    /// alignment value from #VteAlign
    #[cfg(feature = "v0_76")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v0_76")))]
    #[doc(alias = "vte_terminal_set_xalign")]
    #[doc(alias = "xalign")]
    fn set_xalign(&self, align: Align) {
        unsafe {
            ffi::vte_terminal_set_xalign(self.as_ref().to_glib_none().0, align.into_glib());
        }
    }

    /// Sets the horizontal fillment of @self within its allocation.
    ///
    /// Note: `VTE_FILL_START_FILL` is not supported, and will be treated
    ///   like `VTE_FILL_START`.
    /// ## `fill`
    /// fillment value from #VteFill
    #[cfg(feature = "v0_76")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v0_76")))]
    #[doc(alias = "vte_terminal_set_xfill")]
    #[doc(alias = "xfill")]
    fn set_xfill(&self, fill: bool) {
        unsafe {
            ffi::vte_terminal_set_xfill(self.as_ref().to_glib_none().0, fill.into_glib());
        }
    }

    /// Sets the vertical alignment of @self within its allocation.
    /// ## `align`
    /// alignment value from #VteAlign
    #[cfg(feature = "v0_76")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v0_76")))]
    #[doc(alias = "vte_terminal_set_yalign")]
    #[doc(alias = "yalign")]
    fn set_yalign(&self, align: Align) {
        unsafe {
            ffi::vte_terminal_set_yalign(self.as_ref().to_glib_none().0, align.into_glib());
        }
    }

    /// Sets the vertical fillment of @self within its allocation.
    /// Note that yfill is only supported with yalign set to
    /// [`Align::Start`][crate::Align::Start], and is ignored for all other yalign values.
    /// ## `fill`
    /// fillment value from #VteFill
    #[cfg(feature = "v0_76")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v0_76")))]
    #[doc(alias = "vte_terminal_set_yfill")]
    #[doc(alias = "yfill")]
    fn set_yfill(&self, fill: bool) {
        unsafe {
            ffi::vte_terminal_set_yfill(self.as_ref().to_glib_none().0, fill.into_glib());
        }
    }

    /// Clears the current selection.
    #[doc(alias = "vte_terminal_unselect_all")]
    fn unselect_all(&self) {
        unsafe {
            ffi::vte_terminal_unselect_all(self.as_ref().to_glib_none().0);
        }
    }

    /// Write contents of the current contents of @self (including any
    /// scrollback history) to @stream according to @flags.
    ///
    /// If @cancellable is not [`None`], then the operation can be cancelled by triggering
    /// the cancellable object from another thread. If the operation was cancelled,
    /// the error `G_IO_ERROR_CANCELLED` will be returned in @error.
    ///
    /// This is a synchronous operation and will make the widget (and input
    /// processing) during the write operation, which may take a long time
    /// depending on scrollback history and @stream availability for writing.
    /// ## `stream`
    /// a #GOutputStream to write to
    /// ## `flags`
    /// a set of #VteWriteFlags
    /// ## `cancellable`
    /// a #GCancellable object, or [`None`]
    ///
    /// # Returns
    ///
    /// [`true`] on success, [`false`] if there was an error
    #[doc(alias = "vte_terminal_write_contents_sync")]
    fn write_contents_sync(
        &self,
        stream: &impl IsA<gio::OutputStream>,
        flags: WriteFlags,
        cancellable: Option<&impl IsA<gio::Cancellable>>,
    ) -> Result<(), glib::Error> {
        unsafe {
            let mut error = std::ptr::null_mut();
            let is_ok = ffi::vte_terminal_write_contents_sync(
                self.as_ref().to_glib_none().0,
                stream.as_ref().to_glib_none().0,
                flags.into_glib(),
                cancellable.map(|p| p.as_ref()).to_glib_none().0,
                &mut error,
            );
            debug_assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
            if error.is_null() {
                Ok(())
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    /// Controls what string or control sequence the terminal sends to its child
    /// when the user presses the backspace key.
    #[doc(alias = "backspace-binding")]
    fn backspace_binding(&self) -> EraseBinding {
        ObjectExt::property(self.as_ref(), "backspace-binding")
    }

    /// Controls what string or control sequence the terminal sends to its child
    /// when the user presses the delete key.
    #[doc(alias = "delete-binding")]
    fn delete_binding(&self) -> EraseBinding {
        ObjectExt::property(self.as_ref(), "delete-binding")
    }

    /// Specifies the font used for rendering all text displayed by the terminal,
    /// overriding any fonts set using gtk_widget_modify_font().  The terminal
    /// will immediately attempt to load the desired font, retrieve its
    /// metrics, and attempt to resize itself to keep the same number of rows
    /// and columns.
    #[doc(alias = "font-desc")]
    fn font_desc(&self) -> Option<pango::FontDescription> {
        ObjectExt::property(self.as_ref(), "font-desc")
    }

    /// Specifies the font used for rendering all text displayed by the terminal,
    /// overriding any fonts set using gtk_widget_modify_font().  The terminal
    /// will immediately attempt to load the desired font, retrieve its
    /// metrics, and attempt to resize itself to keep the same number of rows
    /// and columns.
    #[doc(alias = "font-desc")]
    fn set_font_desc(&self, font_desc: Option<&pango::FontDescription>) {
        ObjectExt::set_property(self.as_ref(), "font-desc", font_desc)
    }

    /// The currently hovered hyperlink URI, or [`None`] if unset.
    #[doc(alias = "hyperlink-hover-uri")]
    fn hyperlink_hover_uri(&self) -> Option<glib::GString> {
        ObjectExt::property(self.as_ref(), "hyperlink-hover-uri")
    }

    /// Controls the value of the terminal's mouse autohide setting.  When autohiding
    /// is enabled, the mouse cursor will be hidden when the user presses a key and
    /// shown when the user moves the mouse.
    #[doc(alias = "pointer-autohide")]
    fn is_pointer_autohide(&self) -> bool {
        ObjectExt::property(self.as_ref(), "pointer-autohide")
    }

    /// Controls the value of the terminal's mouse autohide setting.  When autohiding
    /// is enabled, the mouse cursor will be hidden when the user presses a key and
    /// shown when the user moves the mouse.
    #[doc(alias = "pointer-autohide")]
    fn set_pointer_autohide(&self, pointer_autohide: bool) {
        ObjectExt::set_property(self.as_ref(), "pointer-autohide", pointer_autohide)
    }

    /// This signal is emitted when the a child sends a bell request to the
    /// terminal.
    #[doc(alias = "bell")]
    fn connect_bell<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn bell_trampoline<P: IsA<Terminal>, F: Fn(&P) + 'static>(
            this: *mut ffi::VteTerminal,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(Terminal::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"bell\0".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    bell_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    /// Emitted whenever the cell size changes, e.g. due to a change in
    /// font, font-scale or cell-width/height-scale.
    ///
    /// Note that this signal should rather be called "cell-size-changed".
    /// ## `width`
    /// the new character cell width
    /// ## `height`
    /// the new character cell height
    #[doc(alias = "char-size-changed")]
    fn connect_char_size_changed<F: Fn(&Self, u32, u32) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn char_size_changed_trampoline<
            P: IsA<Terminal>,
            F: Fn(&P, u32, u32) + 'static,
        >(
            this: *mut ffi::VteTerminal,
            width: libc::c_uint,
            height: libc::c_uint,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(
                Terminal::from_glib_borrow(this).unsafe_cast_ref(),
                width,
                height,
            )
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"char-size-changed\0".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    char_size_changed_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    /// This signal is emitted when the terminal detects that a child
    /// watched using vte_terminal_watch_child() has exited.
    /// ## `status`
    /// the child's exit status
    #[doc(alias = "child-exited")]
    fn connect_child_exited<F: Fn(&Self, i32) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn child_exited_trampoline<P: IsA<Terminal>, F: Fn(&P, i32) + 'static>(
            this: *mut ffi::VteTerminal,
            status: libc::c_int,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(Terminal::from_glib_borrow(this).unsafe_cast_ref(), status)
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"child-exited\0".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    child_exited_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    /// Emitted whenever the terminal receives input from the user and
    /// prepares to send it to the child process.
    /// ## `text`
    /// a string of text
    /// ## `size`
    /// the length of that string of text
    #[doc(alias = "commit")]
    fn connect_commit<F: Fn(&Self, &str, u32) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn commit_trampoline<P: IsA<Terminal>, F: Fn(&P, &str, u32) + 'static>(
            this: *mut ffi::VteTerminal,
            text: *mut libc::c_char,
            size: libc::c_uint,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(
                Terminal::from_glib_borrow(this).unsafe_cast_ref(),
                &glib::GString::from_glib_borrow(text),
                size,
            )
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"commit\0".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    commit_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    /// Emitted whenever the visible appearance of the terminal has changed.
    /// Used primarily by #VteTerminalAccessible.
    #[doc(alias = "contents-changed")]
    fn connect_contents_changed<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn contents_changed_trampoline<P: IsA<Terminal>, F: Fn(&P) + 'static>(
            this: *mut ffi::VteTerminal,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(Terminal::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"contents-changed\0".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    contents_changed_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    /// Emitted whenever vte_terminal_copy_clipboard() is called.
    #[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<Terminal>, F: Fn(&P) + 'static>(
            this: *mut ffi::VteTerminal,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(Terminal::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"copy-clipboard\0".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", &[]);
    }

    /// Emitted when the current directory URI is modified.
    #[doc(alias = "current-directory-uri-changed")]
    fn connect_current_directory_uri_changed<F: Fn(&Self) + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn current_directory_uri_changed_trampoline<
            P: IsA<Terminal>,
            F: Fn(&P) + 'static,
        >(
            this: *mut ffi::VteTerminal,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(Terminal::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"current-directory-uri-changed\0".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    current_directory_uri_changed_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    /// Emitted when the current file URI is modified.
    #[doc(alias = "current-file-uri-changed")]
    fn connect_current_file_uri_changed<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn current_file_uri_changed_trampoline<
            P: IsA<Terminal>,
            F: Fn(&P) + 'static,
        >(
            this: *mut ffi::VteTerminal,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(Terminal::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"current-file-uri-changed\0".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    current_file_uri_changed_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    /// Emitted whenever the cursor moves to a new character cell.  Used
    /// primarily by #VteTerminalAccessible.
    #[doc(alias = "cursor-moved")]
    fn connect_cursor_moved<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn cursor_moved_trampoline<P: IsA<Terminal>, F: Fn(&P) + 'static>(
            this: *mut ffi::VteTerminal,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(Terminal::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"cursor-moved\0".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    cursor_moved_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    /// Emitted when the user hits the '-' key while holding the Control key.
    #[doc(alias = "decrease-font-size")]
    fn connect_decrease_font_size<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn decrease_font_size_trampoline<
            P: IsA<Terminal>,
            F: Fn(&P) + 'static,
        >(
            this: *mut ffi::VteTerminal,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(Terminal::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"decrease-font-size\0".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    decrease_font_size_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    /// Emitted whenever the terminal's current encoding has changed.
    ///
    /// Note: support for non-UTF-8 is deprecated.
    #[doc(alias = "encoding-changed")]
    fn connect_encoding_changed<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn encoding_changed_trampoline<P: IsA<Terminal>, F: Fn(&P) + 'static>(
            this: *mut ffi::VteTerminal,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(Terminal::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"encoding-changed\0".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    encoding_changed_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    /// Emitted when the terminal receives an end-of-file from a child which
    /// is running in the terminal.  This signal is frequently (but not
    /// always) emitted with a #VteTerminal::child-exited signal.
    #[doc(alias = "eof")]
    fn connect_eof<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn eof_trampoline<P: IsA<Terminal>, F: Fn(&P) + 'static>(
            this: *mut ffi::VteTerminal,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(Terminal::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"eof\0".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    eof_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    //#[doc(alias = "hyperlink-hover-uri-changed")]
    //fn connect_hyperlink_hover_uri_changed<Unsupported or ignored types>(&self, f: F) -> SignalHandlerId {
    //    Ignored bbox: Gdk.Rectangle
    //}

    /// Emitted when the user hits the '+' key while holding the Control key.
    #[doc(alias = "increase-font-size")]
    fn connect_increase_font_size<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn increase_font_size_trampoline<
            P: IsA<Terminal>,
            F: Fn(&P) + 'static,
        >(
            this: *mut ffi::VteTerminal,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(Terminal::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"increase-font-size\0".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    increase_font_size_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    /// Emitted when a process running in the terminal wants to
    /// send a notification to the desktop environment.
    /// ## `summary`
    /// The summary
    /// ## `body`
    /// Extra optional text
    #[doc(alias = "notification-received")]
    fn connect_notification_received<F: Fn(&Self, &str, Option<&str>) + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn notification_received_trampoline<
            P: IsA<Terminal>,
            F: Fn(&P, &str, Option<&str>) + 'static,
        >(
            this: *mut ffi::VteTerminal,
            summary: *mut libc::c_char,
            body: *mut libc::c_char,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(
                Terminal::from_glib_borrow(this).unsafe_cast_ref(),
                &glib::GString::from_glib_borrow(summary),
                Option::<glib::GString>::from_glib_borrow(body)
                    .as_ref()
                    .as_ref()
                    .map(|s| s.as_str()),
            )
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"notification-received\0".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notification_received_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    /// Emitted whenever vte_terminal_paste_clipboard() is called.
    #[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<Terminal>, F: Fn(&P) + 'static>(
            this: *mut ffi::VteTerminal,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(Terminal::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"paste-clipboard\0".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 at the child application's request.
    /// ## `width`
    /// the desired number of columns
    /// ## `height`
    /// the desired number of rows
    #[doc(alias = "resize-window")]
    fn connect_resize_window<F: Fn(&Self, u32, u32) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn resize_window_trampoline<
            P: IsA<Terminal>,
            F: Fn(&P, u32, u32) + 'static,
        >(
            this: *mut ffi::VteTerminal,
            width: libc::c_uint,
            height: libc::c_uint,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(
                Terminal::from_glib_borrow(this).unsafe_cast_ref(),
                width,
                height,
            )
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"resize-window\0".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    resize_window_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    /// Emitted whenever the contents of terminal's selection changes.
    #[doc(alias = "selection-changed")]
    fn connect_selection_changed<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn selection_changed_trampoline<P: IsA<Terminal>, F: Fn(&P) + 'static>(
            this: *mut ffi::VteTerminal,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(Terminal::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"selection-changed\0".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    selection_changed_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    //#[doc(alias = "setup-context-menu")]
    //fn connect_setup_context_menu<Unsupported or ignored types>(&self, f: F) -> SignalHandlerId {
    //    Ignored context: Vte.EventContext
    //}

    /// Emitted right before an interactive shell shows a
    /// first-level prompt.
    #[doc(alias = "shell-precmd")]
    fn connect_shell_precmd<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn shell_precmd_trampoline<P: IsA<Terminal>, F: Fn(&P) + 'static>(
            this: *mut ffi::VteTerminal,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(Terminal::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"shell-precmd\0".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    shell_precmd_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    /// Emitted when the interactive shell has read in a complete
    /// command and is about to execute it.
    #[doc(alias = "shell-preexec")]
    fn connect_shell_preexec<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn shell_preexec_trampoline<P: IsA<Terminal>, F: Fn(&P) + 'static>(
            this: *mut ffi::VteTerminal,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(Terminal::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"shell-preexec\0".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    shell_preexec_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    /// Emitted when the #VteTerminal:window-title property is modified.
    #[doc(alias = "window-title-changed")]
    fn connect_window_title_changed<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn window_title_changed_trampoline<
            P: IsA<Terminal>,
            F: Fn(&P) + 'static,
        >(
            this: *mut ffi::VteTerminal,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(Terminal::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"window-title-changed\0".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    window_title_changed_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

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

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

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

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

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

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

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

    #[cfg(feature = "v0_76")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v0_76")))]
    #[doc(alias = "context-menu")]
    fn connect_context_menu_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_context_menu_trampoline<
            P: IsA<Terminal>,
            F: Fn(&P) + 'static,
        >(
            this: *mut ffi::VteTerminal,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(Terminal::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"notify::context-menu\0".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_context_menu_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[cfg(feature = "v0_76")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v0_76")))]
    #[doc(alias = "context-menu-model")]
    fn connect_context_menu_model_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_context_menu_model_trampoline<
            P: IsA<Terminal>,
            F: Fn(&P) + 'static,
        >(
            this: *mut ffi::VteTerminal,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(Terminal::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"notify::context-menu-model\0".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_context_menu_model_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

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

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

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

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

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

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

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

    #[cfg(feature = "v0_78")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v0_78")))]
    #[doc(alias = "enable-a11y")]
    fn connect_enable_a11y_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_enable_a11y_trampoline<
            P: IsA<Terminal>,
            F: Fn(&P) + 'static,
        >(
            this: *mut ffi::VteTerminal,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(Terminal::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"notify::enable-a11y\0".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_enable_a11y_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

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

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

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

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

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

    #[cfg(feature = "v0_74")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v0_74")))]
    #[doc(alias = "font-options")]
    fn connect_font_options_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_font_options_trampoline<
            P: IsA<Terminal>,
            F: Fn(&P) + 'static,
        >(
            this: *mut ffi::VteTerminal,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(Terminal::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"notify::font-options\0".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_font_options_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

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

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

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

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

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

    #[cfg(feature = "v0_76")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v0_76")))]
    #[doc(alias = "scroll-on-insert")]
    fn connect_scroll_on_insert_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_scroll_on_insert_trampoline<
            P: IsA<Terminal>,
            F: Fn(&P) + 'static,
        >(
            this: *mut ffi::VteTerminal,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(Terminal::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"notify::scroll-on-insert\0".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_scroll_on_insert_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

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

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

    #[doc(alias = "scroll-unit-is-pixels")]
    fn connect_scroll_unit_is_pixels_notify<F: Fn(&Self) + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn notify_scroll_unit_is_pixels_trampoline<
            P: IsA<Terminal>,
            F: Fn(&P) + 'static,
        >(
            this: *mut ffi::VteTerminal,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(Terminal::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"notify::scroll-unit-is-pixels\0".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_scroll_unit_is_pixels_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

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

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

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

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

    #[cfg(feature = "v0_76")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v0_76")))]
    #[doc(alias = "xalign")]
    fn connect_xalign_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_xalign_trampoline<P: IsA<Terminal>, F: Fn(&P) + 'static>(
            this: *mut ffi::VteTerminal,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(Terminal::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"notify::xalign\0".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_xalign_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[cfg(feature = "v0_76")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v0_76")))]
    #[doc(alias = "xfill")]
    fn connect_xfill_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_xfill_trampoline<P: IsA<Terminal>, F: Fn(&P) + 'static>(
            this: *mut ffi::VteTerminal,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(Terminal::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"notify::xfill\0".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_xfill_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[cfg(feature = "v0_76")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v0_76")))]
    #[doc(alias = "yalign")]
    fn connect_yalign_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_yalign_trampoline<P: IsA<Terminal>, F: Fn(&P) + 'static>(
            this: *mut ffi::VteTerminal,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(Terminal::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"notify::yalign\0".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_yalign_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[cfg(feature = "v0_76")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v0_76")))]
    #[doc(alias = "yfill")]
    fn connect_yfill_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_yfill_trampoline<P: IsA<Terminal>, F: Fn(&P) + 'static>(
            this: *mut ffi::VteTerminal,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(Terminal::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"notify::yfill\0".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_yfill_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }
}

impl<O: IsA<Terminal>> TerminalExt for O {}