gtk/auto/

text_buffer.rs

// This file was generated by gir (https://github.com/gtk-rs/gir)
// from gir-files (https://github.com/gtk-rs/gir-files)
// DO NOT EDIT

use crate::{
    Clipboard, TargetList, TextChildAnchor, TextIter, TextMark, TextTag, TextTagTable, ffi,
};
use glib::{
    object::ObjectType as _,
    prelude::*,
    signal::{SignalHandlerId, connect_raw},
    translate::*,
};
use std::boxed::Box as Box_;

glib::wrapper! {
    /// You may wish to begin by reading the
    /// [text widget conceptual overview](TextWidget.html)
    /// which gives an overview of all the objects and data
    /// types related to the text widget and how they work together.
    ///
    /// ## Properties
    ///
    ///
    /// #### `copy-target-list`
    ///  The list of targets this buffer supports for clipboard copying
    /// and as DND source.
    ///
    /// Readable
    ///
    ///
    /// #### `cursor-position`
    ///  The position of the insert mark (as offset from the beginning
    /// of the buffer). It is useful for getting notified when the
    /// cursor moves.
    ///
    /// Readable
    ///
    ///
    /// #### `has-selection`
    ///  Whether the buffer has some text currently selected.
    ///
    /// Readable
    ///
    ///
    /// #### `paste-target-list`
    ///  The list of targets this buffer supports for clipboard pasting
    /// and as DND destination.
    ///
    /// Readable
    ///
    ///
    /// #### `tag-table`
    ///  Readable | Writable | Construct Only
    ///
    ///
    /// #### `text`
    ///  The text content of the buffer. Without child widgets and images,
    /// see [`TextBufferExt::text()`][crate::prelude::TextBufferExt::text()] for more information.
    ///
    /// Readable | Writable
    ///
    /// ## Signals
    ///
    ///
    /// #### `apply-tag`
    ///  The ::apply-tag signal is emitted to apply a tag to a
    /// range of text in a [`TextBuffer`][crate::TextBuffer].
    /// Applying actually occurs in the default handler.
    ///
    /// Note that if your handler runs before the default handler it must not
    /// invalidate the `start` and `end` iters (or has to revalidate them).
    ///
    /// See also:
    /// [`TextBufferExt::apply_tag()`][crate::prelude::TextBufferExt::apply_tag()],
    /// `gtk_text_buffer_insert_with_tags()`,
    /// [`TextBufferExt::insert_range()`][crate::prelude::TextBufferExt::insert_range()].
    ///
    ///
    ///
    ///
    /// #### `begin-user-action`
    ///  The ::begin-user-action signal is emitted at the beginning of a single
    /// user-visible operation on a [`TextBuffer`][crate::TextBuffer].
    ///
    /// See also:
    /// [`TextBufferExt::begin_user_action()`][crate::prelude::TextBufferExt::begin_user_action()],
    /// [`TextBufferExt::insert_interactive()`][crate::prelude::TextBufferExt::insert_interactive()],
    /// [`TextBufferExt::insert_range_interactive()`][crate::prelude::TextBufferExt::insert_range_interactive()],
    /// [`TextBufferExt::delete_interactive()`][crate::prelude::TextBufferExt::delete_interactive()],
    /// [`TextBufferExt::backspace()`][crate::prelude::TextBufferExt::backspace()],
    /// [`TextBufferExt::delete_selection()`][crate::prelude::TextBufferExt::delete_selection()].
    ///
    ///
    ///
    ///
    /// #### `changed`
    ///  The ::changed signal is emitted when the content of a [`TextBuffer`][crate::TextBuffer]
    /// has changed.
    ///
    ///
    ///
    ///
    /// #### `delete-range`
    ///  The ::delete-range signal is emitted to delete a range
    /// from a [`TextBuffer`][crate::TextBuffer].
    ///
    /// Note that if your handler runs before the default handler it must not
    /// invalidate the `start` and `end` iters (or has to revalidate them).
    /// The default signal handler revalidates the `start` and `end` iters to
    /// both point to the location where text was deleted. Handlers
    /// which run after the default handler (see `g_signal_connect_after()`)
    /// do not have access to the deleted text.
    ///
    /// See also: [`TextBufferExt::delete()`][crate::prelude::TextBufferExt::delete()].
    ///
    ///
    ///
    ///
    /// #### `end-user-action`
    ///  The ::end-user-action signal is emitted at the end of a single
    /// user-visible operation on the [`TextBuffer`][crate::TextBuffer].
    ///
    /// See also:
    /// [`TextBufferExt::end_user_action()`][crate::prelude::TextBufferExt::end_user_action()],
    /// [`TextBufferExt::insert_interactive()`][crate::prelude::TextBufferExt::insert_interactive()],
    /// [`TextBufferExt::insert_range_interactive()`][crate::prelude::TextBufferExt::insert_range_interactive()],
    /// [`TextBufferExt::delete_interactive()`][crate::prelude::TextBufferExt::delete_interactive()],
    /// [`TextBufferExt::backspace()`][crate::prelude::TextBufferExt::backspace()],
    /// [`TextBufferExt::delete_selection()`][crate::prelude::TextBufferExt::delete_selection()],
    /// [`TextBufferExt::backspace()`][crate::prelude::TextBufferExt::backspace()].
    ///
    ///
    ///
    ///
    /// #### `insert-child-anchor`
    ///  The ::insert-child-anchor signal is emitted to insert a
    /// [`TextChildAnchor`][crate::TextChildAnchor] in a [`TextBuffer`][crate::TextBuffer].
    /// Insertion actually occurs in the default handler.
    ///
    /// Note that if your handler runs before the default handler it must
    /// not invalidate the `location` iter (or has to revalidate it).
    /// The default signal handler revalidates it to be placed after the
    /// inserted `anchor`.
    ///
    /// See also: [`TextBufferExt::insert_child_anchor()`][crate::prelude::TextBufferExt::insert_child_anchor()].
    ///
    ///
    ///
    ///
    /// #### `insert-pixbuf`
    ///  The ::insert-pixbuf signal is emitted to insert a [`gdk_pixbuf::Pixbuf`][crate::gdk_pixbuf::Pixbuf]
    /// in a [`TextBuffer`][crate::TextBuffer]. Insertion actually occurs in the default handler.
    ///
    /// Note that if your handler runs before the default handler it must not
    /// invalidate the `location` iter (or has to revalidate it).
    /// The default signal handler revalidates it to be placed after the
    /// inserted `pixbuf`.
    ///
    /// See also: [`TextBufferExt::insert_pixbuf()`][crate::prelude::TextBufferExt::insert_pixbuf()].
    ///
    ///
    ///
    ///
    /// #### `insert-text`
    ///  The ::insert-text signal is emitted to insert text in a [`TextBuffer`][crate::TextBuffer].
    /// Insertion actually occurs in the default handler.
    ///
    /// Note that if your handler runs before the default handler it must not
    /// invalidate the `location` iter (or has to revalidate it).
    /// The default signal handler revalidates it to point to the end of the
    /// inserted text.
    ///
    /// See also:
    /// [`TextBufferExt::insert()`][crate::prelude::TextBufferExt::insert()],
    /// [`TextBufferExt::insert_range()`][crate::prelude::TextBufferExt::insert_range()].
    ///
    ///
    ///
    ///
    /// #### `mark-deleted`
    ///  The ::mark-deleted signal is emitted as notification
    /// after a [`TextMark`][crate::TextMark] is deleted.
    ///
    /// See also:
    /// [`TextBufferExt::delete_mark()`][crate::prelude::TextBufferExt::delete_mark()].
    ///
    ///
    ///
    ///
    /// #### `mark-set`
    ///  The ::mark-set signal is emitted as notification
    /// after a [`TextMark`][crate::TextMark] is set.
    ///
    /// See also:
    /// [`TextBufferExt::create_mark()`][crate::prelude::TextBufferExt::create_mark()],
    /// [`TextBufferExt::move_mark()`][crate::prelude::TextBufferExt::move_mark()].
    ///
    ///
    ///
    ///
    /// #### `modified-changed`
    ///  The ::modified-changed signal is emitted when the modified bit of a
    /// [`TextBuffer`][crate::TextBuffer] flips.
    ///
    /// See also:
    /// [`TextBufferExt::set_modified()`][crate::prelude::TextBufferExt::set_modified()].
    ///
    ///
    ///
    ///
    /// #### `paste-done`
    ///  The paste-done signal is emitted after paste operation has been completed.
    /// This is useful to properly scroll the view to the end of the pasted text.
    /// See [`TextBufferExt::paste_clipboard()`][crate::prelude::TextBufferExt::paste_clipboard()] for more details.
    ///
    ///
    ///
    ///
    /// #### `remove-tag`
    ///  The ::remove-tag signal is emitted to remove all occurrences of `tag` from
    /// a range of text in a [`TextBuffer`][crate::TextBuffer].
    /// Removal actually occurs in the default handler.
    ///
    /// Note that if your handler runs before the default handler it must not
    /// invalidate the `start` and `end` iters (or has to revalidate them).
    ///
    /// See also:
    /// [`TextBufferExt::remove_tag()`][crate::prelude::TextBufferExt::remove_tag()].
    ///
    ///
    ///
    /// # Implements
    ///
    /// [`TextBufferExt`][trait@crate::prelude::TextBufferExt], [`trait@glib::ObjectExt`], [`TextBufferExtManual`][trait@crate::prelude::TextBufferExtManual]
    #[doc(alias = "GtkTextBuffer")]
    pub struct TextBuffer(Object<ffi::GtkTextBuffer, ffi::GtkTextBufferClass>);

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

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

    /// Creates a new text buffer.
    /// ## `table`
    /// a tag table, or [`None`] to create a new one
    ///
    /// # Returns
    ///
    /// a new text buffer
    #[doc(alias = "gtk_text_buffer_new")]
    pub fn new(table: Option<&impl IsA<TextTagTable>>) -> TextBuffer {
        assert_initialized_main_thread!();
        unsafe {
            from_glib_full(ffi::gtk_text_buffer_new(
                table.map(|p| p.as_ref()).to_glib_none().0,
            ))
        }
    }

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

impl Default for TextBuffer {
    fn default() -> Self {
        glib::object::Object::new::<Self>()
    }
}

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

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

    pub fn tag_table(self, tag_table: &impl IsA<TextTagTable>) -> Self {
        Self {
            builder: self
                .builder
                .property("tag-table", tag_table.clone().upcast()),
        }
    }

    /// The text content of the buffer. Without child widgets and images,
    /// see [`TextBufferExt::text()`][crate::prelude::TextBufferExt::text()] for more information.
    pub fn text(self, text: impl Into<glib::GString>) -> Self {
        Self {
            builder: self.builder.property("text", text.into()),
        }
    }

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

/// Trait containing all [`struct@TextBuffer`] methods.
///
/// # Implementors
///
/// [`TextBuffer`][struct@crate::TextBuffer]
pub trait TextBufferExt: IsA<TextBuffer> + 'static {
    /// Adds the mark at position `where_`. The mark must not be added to
    /// another buffer, and if its name is not [`None`] then there must not
    /// be another mark in the buffer with the same name.
    ///
    /// Emits the [`mark-set`][struct@crate::TextBuffer#mark-set] signal as notification of the mark's
    /// initial placement.
    /// ## `mark`
    /// the mark to add
    /// ## `where_`
    /// location to place mark
    #[doc(alias = "gtk_text_buffer_add_mark")]
    fn add_mark(&self, mark: &impl IsA<TextMark>, where_: &TextIter) {
        unsafe {
            ffi::gtk_text_buffer_add_mark(
                self.as_ref().to_glib_none().0,
                mark.as_ref().to_glib_none().0,
                where_.to_glib_none().0,
            );
        }
    }

    /// Adds `clipboard` to the list of clipboards in which the selection
    /// contents of `self` are available. In most cases, `clipboard` will be
    /// the [`Clipboard`][crate::Clipboard] of type `GDK_SELECTION_PRIMARY` for a view of `self`.
    /// ## `clipboard`
    /// a [`Clipboard`][crate::Clipboard]
    #[doc(alias = "gtk_text_buffer_add_selection_clipboard")]
    fn add_selection_clipboard(&self, clipboard: &Clipboard) {
        unsafe {
            ffi::gtk_text_buffer_add_selection_clipboard(
                self.as_ref().to_glib_none().0,
                clipboard.to_glib_none().0,
            );
        }
    }

    /// Emits the “apply-tag” signal on `self`. The default
    /// handler for the signal applies `tag` to the given range.
    /// `start` and `end` do not have to be in order.
    /// ## `tag`
    /// a [`TextTag`][crate::TextTag]
    /// ## `start`
    /// one bound of range to be tagged
    /// ## `end`
    /// other bound of range to be tagged
    #[doc(alias = "gtk_text_buffer_apply_tag")]
    fn apply_tag(&self, tag: &impl IsA<TextTag>, start: &TextIter, end: &TextIter) {
        unsafe {
            ffi::gtk_text_buffer_apply_tag(
                self.as_ref().to_glib_none().0,
                tag.as_ref().to_glib_none().0,
                start.to_glib_none().0,
                end.to_glib_none().0,
            );
        }
    }

    /// Calls [`TextTagTableExt::lookup()`][crate::prelude::TextTagTableExt::lookup()] on the buffer’s tag table to
    /// get a [`TextTag`][crate::TextTag], then calls [`apply_tag()`][Self::apply_tag()].
    /// ## `name`
    /// name of a named [`TextTag`][crate::TextTag]
    /// ## `start`
    /// one bound of range to be tagged
    /// ## `end`
    /// other bound of range to be tagged
    #[doc(alias = "gtk_text_buffer_apply_tag_by_name")]
    fn apply_tag_by_name(&self, name: &str, start: &TextIter, end: &TextIter) {
        unsafe {
            ffi::gtk_text_buffer_apply_tag_by_name(
                self.as_ref().to_glib_none().0,
                name.to_glib_none().0,
                start.to_glib_none().0,
                end.to_glib_none().0,
            );
        }
    }

    /// Performs the appropriate action as if the user hit the delete
    /// key with the cursor at the position specified by `iter`. In the
    /// normal case a single character will be deleted, but when
    /// combining accents are involved, more than one character can
    /// be deleted, and when precomposed character and accent combinations
    /// are involved, less than one character will be deleted.
    ///
    /// Because the buffer is modified, all outstanding iterators become
    /// invalid after calling this function; however, the `iter` will be
    /// re-initialized to point to the location where text was deleted.
    /// ## `iter`
    /// a position in `self`
    /// ## `interactive`
    /// whether the deletion is caused by user interaction
    /// ## `default_editable`
    /// whether the buffer is editable by default
    ///
    /// # Returns
    ///
    /// [`true`] if the buffer was modified
    #[doc(alias = "gtk_text_buffer_backspace")]
    fn backspace(&self, iter: &mut TextIter, interactive: bool, default_editable: bool) -> bool {
        unsafe {
            from_glib(ffi::gtk_text_buffer_backspace(
                self.as_ref().to_glib_none().0,
                iter.to_glib_none_mut().0,
                interactive.into_glib(),
                default_editable.into_glib(),
            ))
        }
    }

    /// Called to indicate that the buffer operations between here and a
    /// call to [`end_user_action()`][Self::end_user_action()] are part of a single
    /// user-visible operation. The operations between
    /// [`begin_user_action()`][Self::begin_user_action()] and
    /// [`end_user_action()`][Self::end_user_action()] can then be grouped when creating
    /// an undo stack. [`TextBuffer`][crate::TextBuffer] maintains a count of calls to
    /// [`begin_user_action()`][Self::begin_user_action()] that have not been closed with
    /// a call to [`end_user_action()`][Self::end_user_action()], and emits the
    /// “begin-user-action” and “end-user-action” signals only for the
    /// outermost pair of calls. This allows you to build user actions
    /// from other user actions.
    ///
    /// The “interactive” buffer mutation functions, such as
    /// [`insert_interactive()`][Self::insert_interactive()], automatically call begin/end
    /// user action around the buffer operations they perform, so there's
    /// no need to add extra calls if you user action consists solely of a
    /// single call to one of those functions.
    #[doc(alias = "gtk_text_buffer_begin_user_action")]
    fn begin_user_action(&self) {
        unsafe {
            ffi::gtk_text_buffer_begin_user_action(self.as_ref().to_glib_none().0);
        }
    }

    /// Copies the currently-selected text to a clipboard.
    /// ## `clipboard`
    /// the [`Clipboard`][crate::Clipboard] object to copy to
    #[doc(alias = "gtk_text_buffer_copy_clipboard")]
    fn copy_clipboard(&self, clipboard: &Clipboard) {
        unsafe {
            ffi::gtk_text_buffer_copy_clipboard(
                self.as_ref().to_glib_none().0,
                clipboard.to_glib_none().0,
            );
        }
    }

    /// This is a convenience function which simply creates a child anchor
    /// with [`TextChildAnchor::new()`][crate::TextChildAnchor::new()] and inserts it into the buffer
    /// with [`insert_child_anchor()`][Self::insert_child_anchor()]. The new anchor is
    /// owned by the buffer; no reference count is returned to
    /// the caller of [`create_child_anchor()`][Self::create_child_anchor()].
    /// ## `iter`
    /// location in the buffer
    ///
    /// # Returns
    ///
    /// the created child anchor
    #[doc(alias = "gtk_text_buffer_create_child_anchor")]
    fn create_child_anchor(&self, iter: &mut TextIter) -> Option<TextChildAnchor> {
        unsafe {
            from_glib_none(ffi::gtk_text_buffer_create_child_anchor(
                self.as_ref().to_glib_none().0,
                iter.to_glib_none_mut().0,
            ))
        }
    }

    /// Creates a mark at position `where_`. If `mark_name` is [`None`], the mark
    /// is anonymous; otherwise, the mark can be retrieved by name using
    /// [`mark()`][Self::mark()]. If a mark has left gravity, and text is
    /// inserted at the mark’s current location, the mark will be moved to
    /// the left of the newly-inserted text. If the mark has right gravity
    /// (`left_gravity` = [`false`]), the mark will end up on the right of
    /// newly-inserted text. The standard left-to-right cursor is a mark
    /// with right gravity (when you type, the cursor stays on the right
    /// side of the text you’re typing).
    ///
    /// The caller of this function does not own a
    /// reference to the returned [`TextMark`][crate::TextMark], so you can ignore the
    /// return value if you like. Marks are owned by the buffer and go
    /// away when the buffer does.
    ///
    /// Emits the [`mark-set`][struct@crate::TextBuffer#mark-set] signal as notification of the mark's
    /// initial placement.
    /// ## `mark_name`
    /// name for mark, or [`None`]
    /// ## `where_`
    /// location to place mark
    /// ## `left_gravity`
    /// whether the mark has left gravity
    ///
    /// # Returns
    ///
    /// the new [`TextMark`][crate::TextMark] object
    #[doc(alias = "gtk_text_buffer_create_mark")]
    fn create_mark(
        &self,
        mark_name: Option<&str>,
        where_: &TextIter,
        left_gravity: bool,
    ) -> Option<TextMark> {
        unsafe {
            from_glib_none(ffi::gtk_text_buffer_create_mark(
                self.as_ref().to_glib_none().0,
                mark_name.to_glib_none().0,
                where_.to_glib_none().0,
                left_gravity.into_glib(),
            ))
        }
    }

    /// Copies the currently-selected text to a clipboard, then deletes
    /// said text if it’s editable.
    /// ## `clipboard`
    /// the [`Clipboard`][crate::Clipboard] object to cut to
    /// ## `default_editable`
    /// default editability of the buffer
    #[doc(alias = "gtk_text_buffer_cut_clipboard")]
    fn cut_clipboard(&self, clipboard: &Clipboard, default_editable: bool) {
        unsafe {
            ffi::gtk_text_buffer_cut_clipboard(
                self.as_ref().to_glib_none().0,
                clipboard.to_glib_none().0,
                default_editable.into_glib(),
            );
        }
    }

    /// Deletes text between `start` and `end`. The order of `start` and `end`
    /// is not actually relevant; [`delete()`][Self::delete()] will reorder
    /// them. This function actually emits the “delete-range” signal, and
    /// the default handler of that signal deletes the text. Because the
    /// buffer is modified, all outstanding iterators become invalid after
    /// calling this function; however, the `start` and `end` will be
    /// re-initialized to point to the location where text was deleted.
    /// ## `start`
    /// a position in `self`
    /// ## `end`
    /// another position in `self`
    #[doc(alias = "gtk_text_buffer_delete")]
    fn delete(&self, start: &mut TextIter, end: &mut TextIter) {
        unsafe {
            ffi::gtk_text_buffer_delete(
                self.as_ref().to_glib_none().0,
                start.to_glib_none_mut().0,
                end.to_glib_none_mut().0,
            );
        }
    }

    /// Deletes all editable text in the given range.
    /// Calls [`delete()`][Self::delete()] for each editable sub-range of
    /// [`start`,`end`). `start` and `end` are revalidated to point to
    /// the location of the last deleted range, or left untouched if
    /// no text was deleted.
    /// ## `start_iter`
    /// start of range to delete
    /// ## `end_iter`
    /// end of range
    /// ## `default_editable`
    /// whether the buffer is editable by default
    ///
    /// # Returns
    ///
    /// whether some text was actually deleted
    #[doc(alias = "gtk_text_buffer_delete_interactive")]
    fn delete_interactive(
        &self,
        start_iter: &mut TextIter,
        end_iter: &mut TextIter,
        default_editable: bool,
    ) -> bool {
        unsafe {
            from_glib(ffi::gtk_text_buffer_delete_interactive(
                self.as_ref().to_glib_none().0,
                start_iter.to_glib_none_mut().0,
                end_iter.to_glib_none_mut().0,
                default_editable.into_glib(),
            ))
        }
    }

    /// Deletes `mark`, so that it’s no longer located anywhere in the
    /// buffer. Removes the reference the buffer holds to the mark, so if
    /// you haven’t called `g_object_ref()` on the mark, it will be freed. Even
    /// if the mark isn’t freed, most operations on `mark` become
    /// invalid, until it gets added to a buffer again with
    /// [`add_mark()`][Self::add_mark()]. Use [`TextMarkExt::is_deleted()`][crate::prelude::TextMarkExt::is_deleted()] to
    /// find out if a mark has been removed from its buffer.
    /// The [`mark-deleted`][struct@crate::TextBuffer#mark-deleted] signal will be emitted as notification after
    /// the mark is deleted.
    /// ## `mark`
    /// a [`TextMark`][crate::TextMark] in `self`
    #[doc(alias = "gtk_text_buffer_delete_mark")]
    fn delete_mark(&self, mark: &impl IsA<TextMark>) {
        unsafe {
            ffi::gtk_text_buffer_delete_mark(
                self.as_ref().to_glib_none().0,
                mark.as_ref().to_glib_none().0,
            );
        }
    }

    /// Deletes the mark named `name`; the mark must exist. See
    /// [`delete_mark()`][Self::delete_mark()] for details.
    /// ## `name`
    /// name of a mark in `self`
    #[doc(alias = "gtk_text_buffer_delete_mark_by_name")]
    fn delete_mark_by_name(&self, name: &str) {
        unsafe {
            ffi::gtk_text_buffer_delete_mark_by_name(
                self.as_ref().to_glib_none().0,
                name.to_glib_none().0,
            );
        }
    }

    /// Deletes the range between the “insert” and “selection_bound” marks,
    /// that is, the currently-selected text. If `interactive` is [`true`],
    /// the editability of the selection will be considered (users can’t delete
    /// uneditable text).
    /// ## `interactive`
    /// whether the deletion is caused by user interaction
    /// ## `default_editable`
    /// whether the buffer is editable by default
    ///
    /// # Returns
    ///
    /// whether there was a non-empty selection to delete
    #[doc(alias = "gtk_text_buffer_delete_selection")]
    fn delete_selection(&self, interactive: bool, default_editable: bool) -> bool {
        unsafe {
            from_glib(ffi::gtk_text_buffer_delete_selection(
                self.as_ref().to_glib_none().0,
                interactive.into_glib(),
                default_editable.into_glib(),
            ))
        }
    }

    /// This function deserializes rich text in format `format` and inserts
    /// it at `iter`.
    ///
    /// `formats` to be used must be registered using
    /// `gtk_text_buffer_register_deserialize_format()` or
    /// [`register_deserialize_tagset()`][Self::register_deserialize_tagset()] beforehand.
    /// ## `content_buffer`
    /// the [`TextBuffer`][crate::TextBuffer] to deserialize into
    /// ## `format`
    /// the rich text format to use for deserializing
    /// ## `iter`
    /// insertion point for the deserialized text
    /// ## `data`
    /// data to deserialize
    ///
    /// # Returns
    ///
    /// [`true`] on success, [`false`] otherwise.
    #[doc(alias = "gtk_text_buffer_deserialize")]
    fn deserialize(
        &self,
        content_buffer: &impl IsA<TextBuffer>,
        format: &gdk::Atom,
        iter: &mut TextIter,
        data: &[u8],
    ) -> Result<(), glib::Error> {
        let length = data.len() as _;
        unsafe {
            let mut error = std::ptr::null_mut();
            let is_ok = ffi::gtk_text_buffer_deserialize(
                self.as_ref().to_glib_none().0,
                content_buffer.as_ref().to_glib_none().0,
                format.to_glib_none().0,
                iter.to_glib_none_mut().0,
                data.to_glib_none().0,
                length,
                &mut error,
            );
            debug_assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
            if error.is_null() {
                Ok(())
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    /// This functions returns the value set with
    /// [`deserialize_set_can_create_tags()`][Self::deserialize_set_can_create_tags()]
    /// ## `format`
    /// a [`gdk::Atom`][crate::gdk::Atom] representing a registered rich text format
    ///
    /// # Returns
    ///
    /// whether deserializing this format may create tags
    #[doc(alias = "gtk_text_buffer_deserialize_get_can_create_tags")]
    fn deserialize_get_can_create_tags(&self, format: &gdk::Atom) -> bool {
        unsafe {
            from_glib(ffi::gtk_text_buffer_deserialize_get_can_create_tags(
                self.as_ref().to_glib_none().0,
                format.to_glib_none().0,
            ))
        }
    }

    /// Use this function to allow a rich text deserialization function to
    /// create new tags in the receiving buffer. Note that using this
    /// function is almost always a bad idea, because the rich text
    /// functions you register should know how to map the rich text format
    /// they handler to your text buffers set of tags.
    ///
    /// The ability of creating new (arbitrary!) tags in the receiving buffer
    /// is meant for special rich text formats like the internal one that
    /// is registered using [`register_deserialize_tagset()`][Self::register_deserialize_tagset()],
    /// because that format is essentially a dump of the internal structure
    /// of the source buffer, including its tag names.
    ///
    /// You should allow creation of tags only if you know what you are
    /// doing, e.g. if you defined a tagset name for your application
    /// suite’s text buffers and you know that it’s fine to receive new
    /// tags from these buffers, because you know that your application can
    /// handle the newly created tags.
    /// ## `format`
    /// a [`gdk::Atom`][crate::gdk::Atom] representing a registered rich text format
    /// ## `can_create_tags`
    /// whether deserializing this format may create tags
    #[doc(alias = "gtk_text_buffer_deserialize_set_can_create_tags")]
    fn deserialize_set_can_create_tags(&self, format: &gdk::Atom, can_create_tags: bool) {
        unsafe {
            ffi::gtk_text_buffer_deserialize_set_can_create_tags(
                self.as_ref().to_glib_none().0,
                format.to_glib_none().0,
                can_create_tags.into_glib(),
            );
        }
    }

    /// Should be paired with a call to [`begin_user_action()`][Self::begin_user_action()].
    /// See that function for a full explanation.
    #[doc(alias = "gtk_text_buffer_end_user_action")]
    fn end_user_action(&self) {
        unsafe {
            ffi::gtk_text_buffer_end_user_action(self.as_ref().to_glib_none().0);
        }
    }

    /// Retrieves the first and last iterators in the buffer, i.e. the
    /// entire buffer lies within the range [`start`,`end`).
    ///
    /// # Returns
    ///
    ///
    /// ## `start`
    /// iterator to initialize with first position in the buffer
    ///
    /// ## `end`
    /// iterator to initialize with the end iterator
    #[doc(alias = "gtk_text_buffer_get_bounds")]
    #[doc(alias = "get_bounds")]
    fn bounds(&self) -> (TextIter, TextIter) {
        unsafe {
            let mut start = TextIter::uninitialized();
            let mut end = TextIter::uninitialized();
            ffi::gtk_text_buffer_get_bounds(
                self.as_ref().to_glib_none().0,
                start.to_glib_none_mut().0,
                end.to_glib_none_mut().0,
            );
            (start, end)
        }
    }

    /// Gets the number of characters in the buffer; note that characters
    /// and bytes are not the same, you can’t e.g. expect the contents of
    /// the buffer in string form to be this many bytes long. The character
    /// count is cached, so this function is very fast.
    ///
    /// # Returns
    ///
    /// number of characters in the buffer
    #[doc(alias = "gtk_text_buffer_get_char_count")]
    #[doc(alias = "get_char_count")]
    fn char_count(&self) -> i32 {
        unsafe { ffi::gtk_text_buffer_get_char_count(self.as_ref().to_glib_none().0) }
    }

    /// This function returns the list of targets this text buffer can
    /// provide for copying and as DND source. The targets in the list are
    /// added with `info` values from the `GtkTextBufferTargetInfo` enum,
    /// using [`TargetList::add_rich_text_targets()`][crate::TargetList::add_rich_text_targets()] and
    /// [`TargetList::add_text_targets()`][crate::TargetList::add_text_targets()].
    ///
    /// # Returns
    ///
    /// the [`TargetList`][crate::TargetList]
    #[doc(alias = "gtk_text_buffer_get_copy_target_list")]
    #[doc(alias = "get_copy_target_list")]
    #[doc(alias = "copy-target-list")]
    fn copy_target_list(&self) -> Option<TargetList> {
        unsafe {
            from_glib_none(ffi::gtk_text_buffer_get_copy_target_list(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// This function returns the rich text deserialize formats registered
    /// with `self` using `gtk_text_buffer_register_deserialize_format()` or
    /// [`register_deserialize_tagset()`][Self::register_deserialize_tagset()]
    ///
    /// # Returns
    ///
    /// an array of
    ///  `GdkAtoms` representing the registered formats.
    #[doc(alias = "gtk_text_buffer_get_deserialize_formats")]
    #[doc(alias = "get_deserialize_formats")]
    fn deserialize_formats(&self) -> Vec<gdk::Atom> {
        unsafe {
            let mut n_formats = std::mem::MaybeUninit::uninit();
            let ret = FromGlibContainer::from_glib_container_num(
                ffi::gtk_text_buffer_get_deserialize_formats(
                    self.as_ref().to_glib_none().0,
                    n_formats.as_mut_ptr(),
                ),
                n_formats.assume_init() as _,
            );
            ret
        }
    }

    /// Initializes `iter` with the “end iterator,” one past the last valid
    /// character in the text buffer. If dereferenced with
    /// [`TextIter::char()`][crate::TextIter::char()], the end iterator has a character value of 0.
    /// The entire buffer lies in the range from the first position in
    /// the buffer (call [`start_iter()`][Self::start_iter()] to get
    /// character position 0) to the end iterator.
    ///
    /// # Returns
    ///
    ///
    /// ## `iter`
    /// iterator to initialize
    #[doc(alias = "gtk_text_buffer_get_end_iter")]
    #[doc(alias = "get_end_iter")]
    fn end_iter(&self) -> TextIter {
        unsafe {
            let mut iter = TextIter::uninitialized();
            ffi::gtk_text_buffer_get_end_iter(
                self.as_ref().to_glib_none().0,
                iter.to_glib_none_mut().0,
            );
            iter
        }
    }

    /// Indicates whether the buffer has some text currently selected.
    ///
    /// # Returns
    ///
    /// [`true`] if the there is text selected
    #[doc(alias = "gtk_text_buffer_get_has_selection")]
    #[doc(alias = "get_has_selection")]
    #[doc(alias = "has-selection")]
    fn has_selection(&self) -> bool {
        unsafe {
            from_glib(ffi::gtk_text_buffer_get_has_selection(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Returns the mark that represents the cursor (insertion point).
    /// Equivalent to calling [`mark()`][Self::mark()] to get the mark
    /// named “insert”, but very slightly more efficient, and involves less
    /// typing.
    ///
    /// # Returns
    ///
    /// insertion point mark
    #[doc(alias = "gtk_text_buffer_get_insert")]
    fn get_insert(&self) -> Option<TextMark> {
        unsafe {
            from_glib_none(ffi::gtk_text_buffer_get_insert(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Obtains the location of `anchor` within `self`.
    /// ## `anchor`
    /// a child anchor that appears in `self`
    ///
    /// # Returns
    ///
    ///
    /// ## `iter`
    /// an iterator to be initialized
    #[doc(alias = "gtk_text_buffer_get_iter_at_child_anchor")]
    #[doc(alias = "get_iter_at_child_anchor")]
    fn iter_at_child_anchor(&self, anchor: &impl IsA<TextChildAnchor>) -> TextIter {
        unsafe {
            let mut iter = TextIter::uninitialized();
            ffi::gtk_text_buffer_get_iter_at_child_anchor(
                self.as_ref().to_glib_none().0,
                iter.to_glib_none_mut().0,
                anchor.as_ref().to_glib_none().0,
            );
            iter
        }
    }

    /// Initializes `iter` to the start of the given line. If `line_number` is greater
    /// than the number of lines in the `self`, the end iterator is returned.
    /// ## `line_number`
    /// line number counting from 0
    ///
    /// # Returns
    ///
    ///
    /// ## `iter`
    /// iterator to initialize
    #[doc(alias = "gtk_text_buffer_get_iter_at_line")]
    #[doc(alias = "get_iter_at_line")]
    fn iter_at_line(&self, line_number: i32) -> TextIter {
        unsafe {
            let mut iter = TextIter::uninitialized();
            ffi::gtk_text_buffer_get_iter_at_line(
                self.as_ref().to_glib_none().0,
                iter.to_glib_none_mut().0,
                line_number,
            );
            iter
        }
    }

    /// Obtains an iterator pointing to `byte_index` within the given line.
    /// `byte_index` must be the start of a UTF-8 character. Note bytes, not
    /// characters; UTF-8 may encode one character as multiple bytes.
    ///
    /// Before the 3.20 version, it was not allowed to pass an invalid location.
    ///
    /// Since the 3.20 version, if `line_number` is greater than the number of lines
    /// in the `self`, the end iterator is returned. And if `byte_index` is off the
    /// end of the line, the iterator at the end of the line is returned.
    /// ## `line_number`
    /// line number counting from 0
    /// ## `byte_index`
    /// byte index from start of line
    ///
    /// # Returns
    ///
    ///
    /// ## `iter`
    /// iterator to initialize
    #[doc(alias = "gtk_text_buffer_get_iter_at_line_index")]
    #[doc(alias = "get_iter_at_line_index")]
    fn iter_at_line_index(&self, line_number: i32, byte_index: i32) -> TextIter {
        unsafe {
            let mut iter = TextIter::uninitialized();
            ffi::gtk_text_buffer_get_iter_at_line_index(
                self.as_ref().to_glib_none().0,
                iter.to_glib_none_mut().0,
                line_number,
                byte_index,
            );
            iter
        }
    }

    /// Obtains an iterator pointing to `char_offset` within the given line. Note
    /// characters, not bytes; UTF-8 may encode one character as multiple bytes.
    ///
    /// Before the 3.20 version, it was not allowed to pass an invalid location.
    ///
    /// Since the 3.20 version, if `line_number` is greater than the number of lines
    /// in the `self`, the end iterator is returned. And if `char_offset` is off the
    /// end of the line, the iterator at the end of the line is returned.
    /// ## `line_number`
    /// line number counting from 0
    /// ## `char_offset`
    /// char offset from start of line
    ///
    /// # Returns
    ///
    ///
    /// ## `iter`
    /// iterator to initialize
    #[doc(alias = "gtk_text_buffer_get_iter_at_line_offset")]
    #[doc(alias = "get_iter_at_line_offset")]
    fn iter_at_line_offset(&self, line_number: i32, char_offset: i32) -> TextIter {
        unsafe {
            let mut iter = TextIter::uninitialized();
            ffi::gtk_text_buffer_get_iter_at_line_offset(
                self.as_ref().to_glib_none().0,
                iter.to_glib_none_mut().0,
                line_number,
                char_offset,
            );
            iter
        }
    }

    /// Initializes `iter` with the current position of `mark`.
    /// ## `mark`
    /// a [`TextMark`][crate::TextMark] in `self`
    ///
    /// # Returns
    ///
    ///
    /// ## `iter`
    /// iterator to initialize
    #[doc(alias = "gtk_text_buffer_get_iter_at_mark")]
    #[doc(alias = "get_iter_at_mark")]
    fn iter_at_mark(&self, mark: &impl IsA<TextMark>) -> TextIter {
        unsafe {
            let mut iter = TextIter::uninitialized();
            ffi::gtk_text_buffer_get_iter_at_mark(
                self.as_ref().to_glib_none().0,
                iter.to_glib_none_mut().0,
                mark.as_ref().to_glib_none().0,
            );
            iter
        }
    }

    /// Initializes `iter` to a position `char_offset` chars from the start
    /// of the entire buffer. If `char_offset` is -1 or greater than the number
    /// of characters in the buffer, `iter` is initialized to the end iterator,
    /// the iterator one past the last valid character in the buffer.
    /// ## `char_offset`
    /// char offset from start of buffer, counting from 0, or -1
    ///
    /// # Returns
    ///
    ///
    /// ## `iter`
    /// iterator to initialize
    #[doc(alias = "gtk_text_buffer_get_iter_at_offset")]
    #[doc(alias = "get_iter_at_offset")]
    fn iter_at_offset(&self, char_offset: i32) -> TextIter {
        unsafe {
            let mut iter = TextIter::uninitialized();
            ffi::gtk_text_buffer_get_iter_at_offset(
                self.as_ref().to_glib_none().0,
                iter.to_glib_none_mut().0,
                char_offset,
            );
            iter
        }
    }

    /// Obtains the number of lines in the buffer. This value is cached, so
    /// the function is very fast.
    ///
    /// # Returns
    ///
    /// number of lines in the buffer
    #[doc(alias = "gtk_text_buffer_get_line_count")]
    #[doc(alias = "get_line_count")]
    fn line_count(&self) -> i32 {
        unsafe { ffi::gtk_text_buffer_get_line_count(self.as_ref().to_glib_none().0) }
    }

    /// Returns the mark named `name` in buffer `self`, or [`None`] if no such
    /// mark exists in the buffer.
    /// ## `name`
    /// a mark name
    ///
    /// # Returns
    ///
    /// a [`TextMark`][crate::TextMark], or [`None`]
    #[doc(alias = "gtk_text_buffer_get_mark")]
    #[doc(alias = "get_mark")]
    fn mark(&self, name: &str) -> Option<TextMark> {
        unsafe {
            from_glib_none(ffi::gtk_text_buffer_get_mark(
                self.as_ref().to_glib_none().0,
                name.to_glib_none().0,
            ))
        }
    }

    /// Indicates whether the buffer has been modified since the last call
    /// to [`set_modified()`][Self::set_modified()] set the modification flag to
    /// [`false`]. Used for example to enable a “save” function in a text
    /// editor.
    ///
    /// # Returns
    ///
    /// [`true`] if the buffer has been modified
    #[doc(alias = "gtk_text_buffer_get_modified")]
    #[doc(alias = "get_modified")]
    fn is_modified(&self) -> bool {
        unsafe {
            from_glib(ffi::gtk_text_buffer_get_modified(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// This function returns the list of targets this text buffer supports
    /// for pasting and as DND destination. The targets in the list are
    /// added with `info` values from the `GtkTextBufferTargetInfo` enum,
    /// using [`TargetList::add_rich_text_targets()`][crate::TargetList::add_rich_text_targets()] and
    /// [`TargetList::add_text_targets()`][crate::TargetList::add_text_targets()].
    ///
    /// # Returns
    ///
    /// the [`TargetList`][crate::TargetList]
    #[doc(alias = "gtk_text_buffer_get_paste_target_list")]
    #[doc(alias = "get_paste_target_list")]
    #[doc(alias = "paste-target-list")]
    fn paste_target_list(&self) -> Option<TargetList> {
        unsafe {
            from_glib_none(ffi::gtk_text_buffer_get_paste_target_list(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Returns the mark that represents the selection bound. Equivalent
    /// to calling [`mark()`][Self::mark()] to get the mark named
    /// “selection_bound”, but very slightly more efficient, and involves
    /// less typing.
    ///
    /// The currently-selected text in `self` is the region between the
    /// “selection_bound” and “insert” marks. If “selection_bound” and
    /// “insert” are in the same place, then there is no current selection.
    /// [`selection_bounds()`][Self::selection_bounds()] is another convenient function
    /// for handling the selection, if you just want to know whether there’s a
    /// selection and what its bounds are.
    ///
    /// # Returns
    ///
    /// selection bound mark
    #[doc(alias = "gtk_text_buffer_get_selection_bound")]
    #[doc(alias = "get_selection_bound")]
    fn selection_bound(&self) -> Option<TextMark> {
        unsafe {
            from_glib_none(ffi::gtk_text_buffer_get_selection_bound(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Returns [`true`] if some text is selected; places the bounds
    /// of the selection in `start` and `end` (if the selection has length 0,
    /// then `start` and `end` are filled in with the same value).
    /// `start` and `end` will be in ascending order. If `start` and `end` are
    /// NULL, then they are not filled in, but the return value still indicates
    /// whether text is selected.
    ///
    /// # Returns
    ///
    /// whether the selection has nonzero length
    ///
    /// ## `start`
    /// iterator to initialize with selection start
    ///
    /// ## `end`
    /// iterator to initialize with selection end
    #[doc(alias = "gtk_text_buffer_get_selection_bounds")]
    #[doc(alias = "get_selection_bounds")]
    fn selection_bounds(&self) -> Option<(TextIter, TextIter)> {
        unsafe {
            let mut start = TextIter::uninitialized();
            let mut end = TextIter::uninitialized();
            let ret = from_glib(ffi::gtk_text_buffer_get_selection_bounds(
                self.as_ref().to_glib_none().0,
                start.to_glib_none_mut().0,
                end.to_glib_none_mut().0,
            ));
            if ret { Some((start, end)) } else { None }
        }
    }

    /// This function returns the rich text serialize formats registered
    /// with `self` using `gtk_text_buffer_register_serialize_format()` or
    /// [`register_serialize_tagset()`][Self::register_serialize_tagset()]
    ///
    /// # Returns
    ///
    /// an array of
    ///  `GdkAtoms` representing the registered formats.
    #[doc(alias = "gtk_text_buffer_get_serialize_formats")]
    #[doc(alias = "get_serialize_formats")]
    fn serialize_formats(&self) -> Vec<gdk::Atom> {
        unsafe {
            let mut n_formats = std::mem::MaybeUninit::uninit();
            let ret = FromGlibContainer::from_glib_container_num(
                ffi::gtk_text_buffer_get_serialize_formats(
                    self.as_ref().to_glib_none().0,
                    n_formats.as_mut_ptr(),
                ),
                n_formats.assume_init() as _,
            );
            ret
        }
    }

    /// Returns the text in the range [`start`,`end`). Excludes undisplayed
    /// text (text marked with tags that set the invisibility attribute) if
    /// `include_hidden_chars` is [`false`]. The returned string includes a
    /// 0xFFFC character whenever the buffer contains
    /// embedded images, so byte and character indexes into
    /// the returned string do correspond to byte
    /// and character indexes into the buffer. Contrast with
    /// [`text()`][Self::text()]. Note that 0xFFFC can occur in normal
    /// text as well, so it is not a reliable indicator that a pixbuf or
    /// widget is in the buffer.
    /// ## `start`
    /// start of a range
    /// ## `end`
    /// end of a range
    /// ## `include_hidden_chars`
    /// whether to include invisible text
    ///
    /// # Returns
    ///
    /// an allocated UTF-8 string
    #[doc(alias = "gtk_text_buffer_get_slice")]
    #[doc(alias = "get_slice")]
    fn slice(
        &self,
        start: &TextIter,
        end: &TextIter,
        include_hidden_chars: bool,
    ) -> Option<glib::GString> {
        unsafe {
            from_glib_full(ffi::gtk_text_buffer_get_slice(
                self.as_ref().to_glib_none().0,
                start.to_glib_none().0,
                end.to_glib_none().0,
                include_hidden_chars.into_glib(),
            ))
        }
    }

    /// Initialized `iter` with the first position in the text buffer. This
    /// is the same as using [`iter_at_offset()`][Self::iter_at_offset()] to get
    /// the iter at character offset 0.
    ///
    /// # Returns
    ///
    ///
    /// ## `iter`
    /// iterator to initialize
    #[doc(alias = "gtk_text_buffer_get_start_iter")]
    #[doc(alias = "get_start_iter")]
    fn start_iter(&self) -> TextIter {
        unsafe {
            let mut iter = TextIter::uninitialized();
            ffi::gtk_text_buffer_get_start_iter(
                self.as_ref().to_glib_none().0,
                iter.to_glib_none_mut().0,
            );
            iter
        }
    }

    /// Get the [`TextTagTable`][crate::TextTagTable] associated with this buffer.
    ///
    /// # Returns
    ///
    /// the buffer’s tag table
    #[doc(alias = "gtk_text_buffer_get_tag_table")]
    #[doc(alias = "get_tag_table")]
    #[doc(alias = "tag-table")]
    fn tag_table(&self) -> Option<TextTagTable> {
        unsafe {
            from_glib_none(ffi::gtk_text_buffer_get_tag_table(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Returns the text in the range [`start`,`end`). Excludes undisplayed
    /// text (text marked with tags that set the invisibility attribute) if
    /// `include_hidden_chars` is [`false`]. Does not include characters
    /// representing embedded images, so byte and character indexes into
    /// the returned string do not correspond to byte
    /// and character indexes into the buffer. Contrast with
    /// [`slice()`][Self::slice()].
    /// ## `start`
    /// start of a range
    /// ## `end`
    /// end of a range
    /// ## `include_hidden_chars`
    /// whether to include invisible text
    ///
    /// # Returns
    ///
    /// an allocated UTF-8 string
    #[doc(alias = "gtk_text_buffer_get_text")]
    #[doc(alias = "get_text")]
    fn text(
        &self,
        start: &TextIter,
        end: &TextIter,
        include_hidden_chars: bool,
    ) -> Option<glib::GString> {
        unsafe {
            from_glib_full(ffi::gtk_text_buffer_get_text(
                self.as_ref().to_glib_none().0,
                start.to_glib_none().0,
                end.to_glib_none().0,
                include_hidden_chars.into_glib(),
            ))
        }
    }

    /// Inserts `len` bytes of `text` at position `iter`. If `len` is -1,
    /// `text` must be nul-terminated and will be inserted in its
    /// entirety. Emits the “insert-text” signal; insertion actually occurs
    /// in the default handler for the signal. `iter` is invalidated when
    /// insertion occurs (because the buffer contents change), but the
    /// default signal handler revalidates it to point to the end of the
    /// inserted text.
    /// ## `iter`
    /// a position in the buffer
    /// ## `text`
    /// text in UTF-8 format
    /// ## `len`
    /// length of text in bytes, or -1
    #[doc(alias = "gtk_text_buffer_insert")]
    fn insert(&self, iter: &mut TextIter, text: &str) {
        let len = text.len() as _;
        unsafe {
            ffi::gtk_text_buffer_insert(
                self.as_ref().to_glib_none().0,
                iter.to_glib_none_mut().0,
                text.to_glib_none().0,
                len,
            );
        }
    }

    /// Simply calls [`insert()`][Self::insert()], using the current
    /// cursor position as the insertion point.
    /// ## `text`
    /// text in UTF-8 format
    /// ## `len`
    /// length of text, in bytes
    #[doc(alias = "gtk_text_buffer_insert_at_cursor")]
    fn insert_at_cursor(&self, text: &str) {
        let len = text.len() as _;
        unsafe {
            ffi::gtk_text_buffer_insert_at_cursor(
                self.as_ref().to_glib_none().0,
                text.to_glib_none().0,
                len,
            );
        }
    }

    /// Inserts a child widget anchor into the text buffer at `iter`. The
    /// anchor will be counted as one character in character counts, and
    /// when obtaining the buffer contents as a string, will be represented
    /// by the Unicode “object replacement character” 0xFFFC. Note that the
    /// “slice” variants for obtaining portions of the buffer as a string
    /// include this character for child anchors, but the “text” variants do
    /// not. E.g. see [`slice()`][Self::slice()] and
    /// [`text()`][Self::text()]. Consider
    /// [`create_child_anchor()`][Self::create_child_anchor()] as a more convenient
    /// alternative to this function. The buffer will add a reference to
    /// the anchor, so you can unref it after insertion.
    /// ## `iter`
    /// location to insert the anchor
    /// ## `anchor`
    /// a [`TextChildAnchor`][crate::TextChildAnchor]
    #[doc(alias = "gtk_text_buffer_insert_child_anchor")]
    fn insert_child_anchor(&self, iter: &mut TextIter, anchor: &impl IsA<TextChildAnchor>) {
        unsafe {
            ffi::gtk_text_buffer_insert_child_anchor(
                self.as_ref().to_glib_none().0,
                iter.to_glib_none_mut().0,
                anchor.as_ref().to_glib_none().0,
            );
        }
    }

    /// Like [`insert()`][Self::insert()], but the insertion will not occur if
    /// `iter` is at a non-editable location in the buffer. Usually you
    /// want to prevent insertions at ineditable locations if the insertion
    /// results from a user action (is interactive).
    ///
    /// `default_editable` indicates the editability of text that doesn't
    /// have a tag affecting editability applied to it. Typically the
    /// result of [`TextViewExt::is_editable()`][crate::prelude::TextViewExt::is_editable()] is appropriate here.
    /// ## `iter`
    /// a position in `self`
    /// ## `text`
    /// some UTF-8 text
    /// ## `len`
    /// length of text in bytes, or -1
    /// ## `default_editable`
    /// default editability of buffer
    ///
    /// # Returns
    ///
    /// whether text was actually inserted
    #[doc(alias = "gtk_text_buffer_insert_interactive")]
    fn insert_interactive(&self, iter: &mut TextIter, text: &str, default_editable: bool) -> bool {
        let len = text.len() as _;
        unsafe {
            from_glib(ffi::gtk_text_buffer_insert_interactive(
                self.as_ref().to_glib_none().0,
                iter.to_glib_none_mut().0,
                text.to_glib_none().0,
                len,
                default_editable.into_glib(),
            ))
        }
    }

    /// Calls [`insert_interactive()`][Self::insert_interactive()] at the cursor
    /// position.
    ///
    /// `default_editable` indicates the editability of text that doesn't
    /// have a tag affecting editability applied to it. Typically the
    /// result of [`TextViewExt::is_editable()`][crate::prelude::TextViewExt::is_editable()] is appropriate here.
    /// ## `text`
    /// text in UTF-8 format
    /// ## `len`
    /// length of text in bytes, or -1
    /// ## `default_editable`
    /// default editability of buffer
    ///
    /// # Returns
    ///
    /// whether text was actually inserted
    #[doc(alias = "gtk_text_buffer_insert_interactive_at_cursor")]
    fn insert_interactive_at_cursor(&self, text: &str, default_editable: bool) -> bool {
        let len = text.len() as _;
        unsafe {
            from_glib(ffi::gtk_text_buffer_insert_interactive_at_cursor(
                self.as_ref().to_glib_none().0,
                text.to_glib_none().0,
                len,
                default_editable.into_glib(),
            ))
        }
    }

    /// Inserts the text in `markup` at position `iter`. `markup` will be inserted
    /// in its entirety and must be nul-terminated and valid UTF-8. Emits the
    /// [`insert-text`][struct@crate::TextBuffer#insert-text] signal, possibly multiple times; insertion
    /// actually occurs in the default handler for the signal. `iter` will point
    /// to the end of the inserted text on return.
    /// ## `iter`
    /// location to insert the markup
    /// ## `markup`
    /// a nul-terminated UTF-8 string containing [Pango markup][PangoMarkupFormat]
    /// ## `len`
    /// length of `markup` in bytes, or -1
    #[doc(alias = "gtk_text_buffer_insert_markup")]
    fn insert_markup(&self, iter: &mut TextIter, markup: &str) {
        let len = markup.len() as _;
        unsafe {
            ffi::gtk_text_buffer_insert_markup(
                self.as_ref().to_glib_none().0,
                iter.to_glib_none_mut().0,
                markup.to_glib_none().0,
                len,
            );
        }
    }

    /// Inserts an image into the text buffer at `iter`. The image will be
    /// counted as one character in character counts, and when obtaining
    /// the buffer contents as a string, will be represented by the Unicode
    /// “object replacement character” 0xFFFC. Note that the “slice”
    /// variants for obtaining portions of the buffer as a string include
    /// this character for pixbufs, but the “text” variants do
    /// not. e.g. see [`slice()`][Self::slice()] and
    /// [`text()`][Self::text()].
    /// ## `iter`
    /// location to insert the pixbuf
    /// ## `pixbuf`
    /// a [`gdk_pixbuf::Pixbuf`][crate::gdk_pixbuf::Pixbuf]
    #[doc(alias = "gtk_text_buffer_insert_pixbuf")]
    fn insert_pixbuf(&self, iter: &mut TextIter, pixbuf: &gdk_pixbuf::Pixbuf) {
        unsafe {
            ffi::gtk_text_buffer_insert_pixbuf(
                self.as_ref().to_glib_none().0,
                iter.to_glib_none_mut().0,
                pixbuf.to_glib_none().0,
            );
        }
    }

    /// Copies text, tags, and pixbufs between `start` and `end` (the order
    /// of `start` and `end` doesn’t matter) and inserts the copy at `iter`.
    /// Used instead of simply getting/inserting text because it preserves
    /// images and tags. If `start` and `end` are in a different buffer from
    /// `self`, the two buffers must share the same tag table.
    ///
    /// Implemented via emissions of the insert_text and apply_tag signals,
    /// so expect those.
    /// ## `iter`
    /// a position in `self`
    /// ## `start`
    /// a position in a [`TextBuffer`][crate::TextBuffer]
    /// ## `end`
    /// another position in the same buffer as `start`
    #[doc(alias = "gtk_text_buffer_insert_range")]
    fn insert_range(&self, iter: &mut TextIter, start: &TextIter, end: &TextIter) {
        unsafe {
            ffi::gtk_text_buffer_insert_range(
                self.as_ref().to_glib_none().0,
                iter.to_glib_none_mut().0,
                start.to_glib_none().0,
                end.to_glib_none().0,
            );
        }
    }

    /// Same as [`insert_range()`][Self::insert_range()], but does nothing if the
    /// insertion point isn’t editable. The `default_editable` parameter
    /// indicates whether the text is editable at `iter` if no tags
    /// enclosing `iter` affect editability. Typically the result of
    /// [`TextViewExt::is_editable()`][crate::prelude::TextViewExt::is_editable()] is appropriate here.
    /// ## `iter`
    /// a position in `self`
    /// ## `start`
    /// a position in a [`TextBuffer`][crate::TextBuffer]
    /// ## `end`
    /// another position in the same buffer as `start`
    /// ## `default_editable`
    /// default editability of the buffer
    ///
    /// # Returns
    ///
    /// whether an insertion was possible at `iter`
    #[doc(alias = "gtk_text_buffer_insert_range_interactive")]
    fn insert_range_interactive(
        &self,
        iter: &mut TextIter,
        start: &TextIter,
        end: &TextIter,
        default_editable: bool,
    ) -> bool {
        unsafe {
            from_glib(ffi::gtk_text_buffer_insert_range_interactive(
                self.as_ref().to_glib_none().0,
                iter.to_glib_none_mut().0,
                start.to_glib_none().0,
                end.to_glib_none().0,
                default_editable.into_glib(),
            ))
        }
    }

    //#[doc(alias = "gtk_text_buffer_insert_with_tags_by_name")]
    //fn insert_with_tags_by_name(&self, iter: &mut TextIter, text: &str, first_tag_name: &str, : /*Unknown conversion*//*Unimplemented*/Basic: VarArgs) {
    //    unsafe { TODO: call ffi:gtk_text_buffer_insert_with_tags_by_name() }
    //}

    /// Moves `mark` to the new location `where_`. Emits the [`mark-set`][struct@crate::TextBuffer#mark-set]
    /// signal as notification of the move.
    /// ## `mark`
    /// a [`TextMark`][crate::TextMark]
    /// ## `where_`
    /// new location for `mark` in `self`
    #[doc(alias = "gtk_text_buffer_move_mark")]
    fn move_mark(&self, mark: &impl IsA<TextMark>, where_: &TextIter) {
        unsafe {
            ffi::gtk_text_buffer_move_mark(
                self.as_ref().to_glib_none().0,
                mark.as_ref().to_glib_none().0,
                where_.to_glib_none().0,
            );
        }
    }

    /// Moves the mark named `name` (which must exist) to location `where_`.
    /// See [`move_mark()`][Self::move_mark()] for details.
    /// ## `name`
    /// name of a mark
    /// ## `where_`
    /// new location for mark
    #[doc(alias = "gtk_text_buffer_move_mark_by_name")]
    fn move_mark_by_name(&self, name: &str, where_: &TextIter) {
        unsafe {
            ffi::gtk_text_buffer_move_mark_by_name(
                self.as_ref().to_glib_none().0,
                name.to_glib_none().0,
                where_.to_glib_none().0,
            );
        }
    }

    /// Pastes the contents of a clipboard. If `override_location` is [`None`], the
    /// pasted text will be inserted at the cursor position, or the buffer selection
    /// will be replaced if the selection is non-empty.
    ///
    /// Note: pasting is asynchronous, that is, we’ll ask for the paste data and
    /// return, and at some point later after the main loop runs, the paste data will
    /// be inserted.
    /// ## `clipboard`
    /// the [`Clipboard`][crate::Clipboard] to paste from
    /// ## `override_location`
    /// location to insert pasted text, or [`None`]
    /// ## `default_editable`
    /// whether the buffer is editable by default
    #[doc(alias = "gtk_text_buffer_paste_clipboard")]
    fn paste_clipboard(
        &self,
        clipboard: &Clipboard,
        override_location: Option<&TextIter>,
        default_editable: bool,
    ) {
        unsafe {
            ffi::gtk_text_buffer_paste_clipboard(
                self.as_ref().to_glib_none().0,
                clipboard.to_glib_none().0,
                mut_override(override_location.to_glib_none().0),
                default_editable.into_glib(),
            );
        }
    }

    /// This function moves the “insert” and “selection_bound” marks
    /// simultaneously. If you move them to the same place in two steps
    /// with [`move_mark()`][Self::move_mark()], you will temporarily select a
    /// region in between their old and new locations, which can be pretty
    /// inefficient since the temporarily-selected region will force stuff
    /// to be recalculated. This function moves them as a unit, which can
    /// be optimized.
    /// ## `where_`
    /// where to put the cursor
    #[doc(alias = "gtk_text_buffer_place_cursor")]
    fn place_cursor(&self, where_: &TextIter) {
        unsafe {
            ffi::gtk_text_buffer_place_cursor(
                self.as_ref().to_glib_none().0,
                where_.to_glib_none().0,
            );
        }
    }

    /// This function registers GTK+’s internal rich text serialization
    /// format with the passed `self`. See
    /// [`register_serialize_tagset()`][Self::register_serialize_tagset()] for details.
    /// ## `tagset_name`
    /// an optional tagset name, on [`None`]
    ///
    /// # Returns
    ///
    /// the [`gdk::Atom`][crate::gdk::Atom] that corresponds to the
    ///  newly registered format’s mime-type.
    #[doc(alias = "gtk_text_buffer_register_deserialize_tagset")]
    fn register_deserialize_tagset(&self, tagset_name: Option<&str>) -> gdk::Atom {
        unsafe {
            from_glib_none(ffi::gtk_text_buffer_register_deserialize_tagset(
                self.as_ref().to_glib_none().0,
                tagset_name.to_glib_none().0,
            ))
        }
    }

    /// This function registers GTK+’s internal rich text serialization
    /// format with the passed `self`. The internal format does not comply
    /// to any standard rich text format and only works between [`TextBuffer`][crate::TextBuffer]
    /// instances. It is capable of serializing all of a text buffer’s tags
    /// and embedded pixbufs.
    ///
    /// This function is just a wrapper around
    /// `gtk_text_buffer_register_serialize_format()`. The mime type used
    /// for registering is “application/x-gtk-text-buffer-rich-text”, or
    /// “application/x-gtk-text-buffer-rich-text;format=`tagset_name`” if a
    /// `tagset_name` was passed.
    ///
    /// The `tagset_name` can be used to restrict the transfer of rich text
    /// to buffers with compatible sets of tags, in order to avoid unknown
    /// tags from being pasted. It is probably the common case to pass an
    /// identifier != [`None`] here, since the [`None`] tagset requires the
    /// receiving buffer to deal with with pasting of arbitrary tags.
    /// ## `tagset_name`
    /// an optional tagset name, on [`None`]
    ///
    /// # Returns
    ///
    /// the [`gdk::Atom`][crate::gdk::Atom] that corresponds to the
    ///  newly registered format’s mime-type.
    #[doc(alias = "gtk_text_buffer_register_serialize_tagset")]
    fn register_serialize_tagset(&self, tagset_name: Option<&str>) -> gdk::Atom {
        unsafe {
            from_glib_none(ffi::gtk_text_buffer_register_serialize_tagset(
                self.as_ref().to_glib_none().0,
                tagset_name.to_glib_none().0,
            ))
        }
    }

    /// Removes all tags in the range between `start` and `end`. Be careful
    /// with this function; it could remove tags added in code unrelated to
    /// the code you’re currently writing. That is, using this function is
    /// probably a bad idea if you have two or more unrelated code sections
    /// that add tags.
    /// ## `start`
    /// one bound of range to be untagged
    /// ## `end`
    /// other bound of range to be untagged
    #[doc(alias = "gtk_text_buffer_remove_all_tags")]
    fn remove_all_tags(&self, start: &TextIter, end: &TextIter) {
        unsafe {
            ffi::gtk_text_buffer_remove_all_tags(
                self.as_ref().to_glib_none().0,
                start.to_glib_none().0,
                end.to_glib_none().0,
            );
        }
    }

    /// Removes a [`Clipboard`][crate::Clipboard] added with
    /// [`add_selection_clipboard()`][Self::add_selection_clipboard()].
    /// ## `clipboard`
    /// a [`Clipboard`][crate::Clipboard] added to `self` by
    ///  [`add_selection_clipboard()`][Self::add_selection_clipboard()]
    #[doc(alias = "gtk_text_buffer_remove_selection_clipboard")]
    fn remove_selection_clipboard(&self, clipboard: &Clipboard) {
        unsafe {
            ffi::gtk_text_buffer_remove_selection_clipboard(
                self.as_ref().to_glib_none().0,
                clipboard.to_glib_none().0,
            );
        }
    }

    /// Emits the “remove-tag” signal. The default handler for the signal
    /// removes all occurrences of `tag` from the given range. `start` and
    /// `end` don’t have to be in order.
    /// ## `tag`
    /// a [`TextTag`][crate::TextTag]
    /// ## `start`
    /// one bound of range to be untagged
    /// ## `end`
    /// other bound of range to be untagged
    #[doc(alias = "gtk_text_buffer_remove_tag")]
    fn remove_tag(&self, tag: &impl IsA<TextTag>, start: &TextIter, end: &TextIter) {
        unsafe {
            ffi::gtk_text_buffer_remove_tag(
                self.as_ref().to_glib_none().0,
                tag.as_ref().to_glib_none().0,
                start.to_glib_none().0,
                end.to_glib_none().0,
            );
        }
    }

    /// Calls [`TextTagTableExt::lookup()`][crate::prelude::TextTagTableExt::lookup()] on the buffer’s tag table to
    /// get a [`TextTag`][crate::TextTag], then calls [`remove_tag()`][Self::remove_tag()].
    /// ## `name`
    /// name of a [`TextTag`][crate::TextTag]
    /// ## `start`
    /// one bound of range to be untagged
    /// ## `end`
    /// other bound of range to be untagged
    #[doc(alias = "gtk_text_buffer_remove_tag_by_name")]
    fn remove_tag_by_name(&self, name: &str, start: &TextIter, end: &TextIter) {
        unsafe {
            ffi::gtk_text_buffer_remove_tag_by_name(
                self.as_ref().to_glib_none().0,
                name.to_glib_none().0,
                start.to_glib_none().0,
                end.to_glib_none().0,
            );
        }
    }

    /// This function moves the “insert” and “selection_bound” marks
    /// simultaneously. If you move them in two steps
    /// with [`move_mark()`][Self::move_mark()], you will temporarily select a
    /// region in between their old and new locations, which can be pretty
    /// inefficient since the temporarily-selected region will force stuff
    /// to be recalculated. This function moves them as a unit, which can
    /// be optimized.
    /// ## `ins`
    /// where to put the “insert” mark
    /// ## `bound`
    /// where to put the “selection_bound” mark
    #[doc(alias = "gtk_text_buffer_select_range")]
    fn select_range(&self, ins: &TextIter, bound: &TextIter) {
        unsafe {
            ffi::gtk_text_buffer_select_range(
                self.as_ref().to_glib_none().0,
                ins.to_glib_none().0,
                bound.to_glib_none().0,
            );
        }
    }

    /// This function serializes the portion of text between `start`
    /// and `end` in the rich text format represented by `format`.
    ///
    /// `formats` to be used must be registered using
    /// `gtk_text_buffer_register_serialize_format()` or
    /// [`register_serialize_tagset()`][Self::register_serialize_tagset()] beforehand.
    /// ## `content_buffer`
    /// the [`TextBuffer`][crate::TextBuffer] to serialize
    /// ## `format`
    /// the rich text format to use for serializing
    /// ## `start`
    /// start of block of text to serialize
    /// ## `end`
    /// end of block of test to serialize
    ///
    /// # Returns
    ///
    /// the serialized
    ///  data, encoded as `format`
    #[doc(alias = "gtk_text_buffer_serialize")]
    fn serialize(
        &self,
        content_buffer: &impl IsA<TextBuffer>,
        format: &gdk::Atom,
        start: &TextIter,
        end: &TextIter,
    ) -> Vec<u8> {
        unsafe {
            let mut length = std::mem::MaybeUninit::uninit();
            let ret = FromGlibContainer::from_glib_full_num(
                ffi::gtk_text_buffer_serialize(
                    self.as_ref().to_glib_none().0,
                    content_buffer.as_ref().to_glib_none().0,
                    format.to_glib_none().0,
                    start.to_glib_none().0,
                    end.to_glib_none().0,
                    length.as_mut_ptr(),
                ),
                length.assume_init() as _,
            );
            ret
        }
    }

    /// Used to keep track of whether the buffer has been modified since the
    /// last time it was saved. Whenever the buffer is saved to disk, call
    /// gtk_text_buffer_set_modified (`self`, FALSE). When the buffer is modified,
    /// it will automatically toggled on the modified bit again. When the modified
    /// bit flips, the buffer emits the [`modified-changed`][struct@crate::TextBuffer#modified-changed] signal.
    /// ## `setting`
    /// modification flag setting
    #[doc(alias = "gtk_text_buffer_set_modified")]
    fn set_modified(&self, setting: bool) {
        unsafe {
            ffi::gtk_text_buffer_set_modified(self.as_ref().to_glib_none().0, setting.into_glib());
        }
    }

    /// Deletes current contents of `self`, and inserts `text` instead. If
    /// `len` is -1, `text` must be nul-terminated. `text` must be valid UTF-8.
    /// ## `text`
    /// UTF-8 text to insert
    /// ## `len`
    /// length of `text` in bytes
    #[doc(alias = "gtk_text_buffer_set_text")]
    #[doc(alias = "text")]
    fn set_text(&self, text: &str) {
        let len = text.len() as _;
        unsafe {
            ffi::gtk_text_buffer_set_text(
                self.as_ref().to_glib_none().0,
                text.to_glib_none().0,
                len,
            );
        }
    }

    /// This function unregisters a rich text format that was previously
    /// registered using `gtk_text_buffer_register_deserialize_format()` or
    /// [`register_deserialize_tagset()`][Self::register_deserialize_tagset()].
    /// ## `format`
    /// a [`gdk::Atom`][crate::gdk::Atom] representing a registered rich text format.
    #[doc(alias = "gtk_text_buffer_unregister_deserialize_format")]
    fn unregister_deserialize_format(&self, format: &gdk::Atom) {
        unsafe {
            ffi::gtk_text_buffer_unregister_deserialize_format(
                self.as_ref().to_glib_none().0,
                format.to_glib_none().0,
            );
        }
    }

    /// This function unregisters a rich text format that was previously
    /// registered using `gtk_text_buffer_register_serialize_format()` or
    /// [`register_serialize_tagset()`][Self::register_serialize_tagset()]
    /// ## `format`
    /// a [`gdk::Atom`][crate::gdk::Atom] representing a registered rich text format.
    #[doc(alias = "gtk_text_buffer_unregister_serialize_format")]
    fn unregister_serialize_format(&self, format: &gdk::Atom) {
        unsafe {
            ffi::gtk_text_buffer_unregister_serialize_format(
                self.as_ref().to_glib_none().0,
                format.to_glib_none().0,
            );
        }
    }

    /// The position of the insert mark (as offset from the beginning
    /// of the buffer). It is useful for getting notified when the
    /// cursor moves.
    #[doc(alias = "cursor-position")]
    fn cursor_position(&self) -> i32 {
        ObjectExt::property(self.as_ref(), "cursor-position")
    }

    /// The ::begin-user-action signal is emitted at the beginning of a single
    /// user-visible operation on a [`TextBuffer`][crate::TextBuffer].
    ///
    /// See also:
    /// [`begin_user_action()`][Self::begin_user_action()],
    /// [`insert_interactive()`][Self::insert_interactive()],
    /// [`insert_range_interactive()`][Self::insert_range_interactive()],
    /// [`delete_interactive()`][Self::delete_interactive()],
    /// [`backspace()`][Self::backspace()],
    /// [`delete_selection()`][Self::delete_selection()].
    #[doc(alias = "begin-user-action")]
    fn connect_begin_user_action<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn begin_user_action_trampoline<
            P: IsA<TextBuffer>,
            F: Fn(&P) + 'static,
        >(
            this: *mut ffi::GtkTextBuffer,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(TextBuffer::from_glib_borrow(this).unsafe_cast_ref())
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"begin-user-action".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    begin_user_action_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    /// The ::changed signal is emitted when the content of a [`TextBuffer`][crate::TextBuffer]
    /// has changed.
    #[doc(alias = "changed")]
    fn connect_changed<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn changed_trampoline<P: IsA<TextBuffer>, F: Fn(&P) + 'static>(
            this: *mut ffi::GtkTextBuffer,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(TextBuffer::from_glib_borrow(this).unsafe_cast_ref())
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"changed".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    changed_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    /// The ::end-user-action signal is emitted at the end of a single
    /// user-visible operation on the [`TextBuffer`][crate::TextBuffer].
    ///
    /// See also:
    /// [`end_user_action()`][Self::end_user_action()],
    /// [`insert_interactive()`][Self::insert_interactive()],
    /// [`insert_range_interactive()`][Self::insert_range_interactive()],
    /// [`delete_interactive()`][Self::delete_interactive()],
    /// [`backspace()`][Self::backspace()],
    /// [`delete_selection()`][Self::delete_selection()],
    /// [`backspace()`][Self::backspace()].
    #[doc(alias = "end-user-action")]
    fn connect_end_user_action<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn end_user_action_trampoline<P: IsA<TextBuffer>, F: Fn(&P) + 'static>(
            this: *mut ffi::GtkTextBuffer,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(TextBuffer::from_glib_borrow(this).unsafe_cast_ref())
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"end-user-action".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    end_user_action_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    /// The ::mark-deleted signal is emitted as notification
    /// after a [`TextMark`][crate::TextMark] is deleted.
    ///
    /// See also:
    /// [`delete_mark()`][Self::delete_mark()].
    /// ## `mark`
    /// The mark that was deleted
    #[doc(alias = "mark-deleted")]
    fn connect_mark_deleted<F: Fn(&Self, &TextMark) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn mark_deleted_trampoline<
            P: IsA<TextBuffer>,
            F: Fn(&P, &TextMark) + 'static,
        >(
            this: *mut ffi::GtkTextBuffer,
            mark: *mut ffi::GtkTextMark,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(
                    TextBuffer::from_glib_borrow(this).unsafe_cast_ref(),
                    &from_glib_borrow(mark),
                )
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"mark-deleted".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    mark_deleted_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    /// The ::mark-set signal is emitted as notification
    /// after a [`TextMark`][crate::TextMark] is set.
    ///
    /// See also:
    /// [`create_mark()`][Self::create_mark()],
    /// [`move_mark()`][Self::move_mark()].
    /// ## `location`
    /// The location of `mark` in `textbuffer`
    /// ## `mark`
    /// The mark that is set
    #[doc(alias = "mark-set")]
    fn connect_mark_set<F: Fn(&Self, &TextIter, &TextMark) + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn mark_set_trampoline<
            P: IsA<TextBuffer>,
            F: Fn(&P, &TextIter, &TextMark) + 'static,
        >(
            this: *mut ffi::GtkTextBuffer,
            location: *mut ffi::GtkTextIter,
            mark: *mut ffi::GtkTextMark,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(
                    TextBuffer::from_glib_borrow(this).unsafe_cast_ref(),
                    &from_glib_borrow(location),
                    &from_glib_borrow(mark),
                )
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"mark-set".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    mark_set_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    /// The ::modified-changed signal is emitted when the modified bit of a
    /// [`TextBuffer`][crate::TextBuffer] flips.
    ///
    /// See also:
    /// [`set_modified()`][Self::set_modified()].
    #[doc(alias = "modified-changed")]
    fn connect_modified_changed<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn modified_changed_trampoline<
            P: IsA<TextBuffer>,
            F: Fn(&P) + 'static,
        >(
            this: *mut ffi::GtkTextBuffer,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(TextBuffer::from_glib_borrow(this).unsafe_cast_ref())
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"modified-changed".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    modified_changed_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    /// The paste-done signal is emitted after paste operation has been completed.
    /// This is useful to properly scroll the view to the end of the pasted text.
    /// See [`paste_clipboard()`][Self::paste_clipboard()] for more details.
    /// ## `clipboard`
    /// the [`Clipboard`][crate::Clipboard] pasted from
    #[doc(alias = "paste-done")]
    fn connect_paste_done<F: Fn(&Self, &Clipboard) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn paste_done_trampoline<
            P: IsA<TextBuffer>,
            F: Fn(&P, &Clipboard) + 'static,
        >(
            this: *mut ffi::GtkTextBuffer,
            clipboard: *mut ffi::GtkClipboard,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(
                    TextBuffer::from_glib_borrow(this).unsafe_cast_ref(),
                    &from_glib_borrow(clipboard),
                )
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"paste-done".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    paste_done_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

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

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

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

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

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

impl<O: IsA<TextBuffer>> TextBufferExt for O {}