gtk4/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::{ffi, TextChildAnchor, TextIter, TextMark, TextTag, TextTagTable};
use glib::{
    prelude::*,
    signal::{connect_raw, SignalHandlerId},
    translate::*,
};
use std::boxed::Box as Box_;

glib::wrapper! {
    /// Stores text and attributes for display in a [`TextView`][crate::TextView].
    ///
    /// You may wish to begin by reading the
    /// [text widget conceptual overview](section-text-widget.html),
    /// which gives an overview of all the objects and data types
    /// related to the text widget and how they work together.
    ///
    /// GtkTextBuffer can support undoing changes to the buffer
    /// content, see [`TextBufferExt::set_enable_undo()`][crate::prelude::TextBufferExt::set_enable_undo()].
    ///
    /// ## Properties
    ///
    ///
    /// #### `can-redo`
    ///  Denotes that the buffer can reapply the last undone action.
    ///
    /// Readable
    ///
    ///
    /// #### `can-undo`
    ///  Denotes that the buffer can undo the last applied action.
    ///
    /// Readable
    ///
    ///
    /// #### `cursor-position`
    ///  The position of the insert mark.
    ///
    /// This is an offset from the beginning of the buffer.
    /// It is useful for getting notified when the cursor moves.
    ///
    /// Readable
    ///
    ///
    /// #### `enable-undo`
    ///  Denotes if support for undoing and redoing changes to the buffer is allowed.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `has-selection`
    ///  Whether the buffer has some text currently selected.
    ///
    /// Readable
    ///
    ///
    /// #### `tag-table`
    ///  The GtkTextTagTable for the buffer.
    ///
    /// Readable | Writeable | 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 | Writeable
    ///
    /// ## Signals
    ///
    ///
    /// #### `apply-tag`
    ///  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()],
    /// [`TextBufferExtManual::insert_with_tags()`][crate::prelude::TextBufferExtManual::insert_with_tags()],
    /// [`TextBufferExt::insert_range()`][crate::prelude::TextBufferExt::insert_range()].
    ///
    ///
    ///
    ///
    /// #### `begin-user-action`
    ///  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`
    ///  Emitted when the content of a [`TextBuffer`][crate::TextBuffer] has changed.
    ///
    ///
    ///
    ///
    /// #### `delete-range`
    ///  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`
    ///  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`
    ///  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-paintable`
    ///  Emitted to insert a [`gdk::Paintable`][crate::gdk::Paintable] 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 @paintable.
    ///
    /// See also: [`TextBufferExt::insert_paintable()`][crate::prelude::TextBufferExt::insert_paintable()].
    ///
    ///
    ///
    ///
    /// #### `insert-text`
    ///  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`
    ///  Emitted as notification after a [`TextMark`][crate::TextMark] is deleted.
    ///
    /// See also: [`TextBufferExt::delete_mark()`][crate::prelude::TextBufferExt::delete_mark()].
    ///
    ///
    ///
    ///
    /// #### `mark-set`
    ///  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`
    ///  Emitted when the modified bit of a [`TextBuffer`][crate::TextBuffer] flips.
    ///
    /// See also: [`TextBufferExt::set_modified()`][crate::prelude::TextBufferExt::set_modified()].
    ///
    ///
    ///
    ///
    /// #### `paste-done`
    ///  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.
    ///
    ///
    ///
    ///
    /// #### `redo`
    ///  Emitted when a request has been made to redo the
    /// previously undone operation.
    ///
    ///
    ///
    ///
    /// #### `remove-tag`
    ///  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()].
    ///
    ///
    ///
    ///
    /// #### `undo`
    ///  Emitted when a request has been made to undo the
    /// previous operation or set of operations that have
    /// been grouped together.
    ///
    ///
    ///
    /// # 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<&TextTagTable>) -> TextBuffer {
        assert_initialized_main_thread!();
        unsafe { from_glib_full(ffi::gtk_text_buffer_new(table.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(),
        }
    }

    /// Denotes if support for undoing and redoing changes to the buffer is allowed.
    pub fn enable_undo(self, enable_undo: bool) -> Self {
        Self {
            builder: self.builder.property("enable-undo", enable_undo),
        }
    }

    /// The GtkTextTagTable for the buffer.
    pub fn tag_table(self, tag_table: &TextTagTable) -> Self {
        Self {
            builder: self.builder.property("tag-table", tag_table.clone()),
        }
    }

    /// 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 [`gdk::Clipboard`][crate::gdk::Clipboard] returned by
    /// [`WidgetExt::primary_clipboard()`][crate::prelude::WidgetExt::primary_clipboard()] for a view of @self.
    /// ## `clipboard`
    /// a [`gdk::Clipboard`][crate::gdk::Clipboard]
    #[doc(alias = "gtk_text_buffer_add_selection_clipboard")]
    fn add_selection_clipboard(&self, clipboard: &gdk::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,
            );
        }
    }

    /// Emits the “apply-tag” signal on @self.
    ///
    /// Calls [`TextTagTable::lookup()`][crate::TextTagTable::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(),
            ))
        }
    }

    /// Denotes the beginning of an action that may not be undone.
    ///
    /// This will cause any previous operations in the undo/redo queue
    /// to be cleared.
    ///
    /// This should be paired with a call to
    /// [`end_irreversible_action()`][Self::end_irreversible_action()] after the irreversible
    /// action has completed.
    ///
    /// You may nest calls to gtk_text_buffer_begin_irreversible_action()
    /// and gtk_text_buffer_end_irreversible_action() pairs.
    #[doc(alias = "gtk_text_buffer_begin_irreversible_action")]
    fn begin_irreversible_action(&self) {
        unsafe {
            ffi::gtk_text_buffer_begin_irreversible_action(self.as_ref().to_glib_none().0);
        }
    }

    /// Called to indicate that the buffer operations between here and a
    /// call to gtk_text_buffer_end_user_action() are part of a single
    /// user-visible operation.
    ///
    /// The operations between gtk_text_buffer_begin_user_action() and
    /// gtk_text_buffer_end_user_action() can then be grouped when creating
    /// an undo stack. [`TextBuffer`][crate::TextBuffer] maintains a count of calls to
    /// gtk_text_buffer_begin_user_action() that have not been closed with
    /// a call to gtk_text_buffer_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 [`gdk::Clipboard`][crate::gdk::Clipboard] object to copy to
    #[doc(alias = "gtk_text_buffer_copy_clipboard")]
    fn copy_clipboard(&self, clipboard: &gdk::Clipboard) {
        unsafe {
            ffi::gtk_text_buffer_copy_clipboard(
                self.as_ref().to_glib_none().0,
                clipboard.to_glib_none().0,
            );
        }
    }

    /// Creates and inserts a child anchor.
    ///
    /// 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 this function.
    /// ## `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) -> 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
    /// ## `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,
    ) -> 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 [`gdk::Clipboard`][crate::gdk::Clipboard] object to cut to
    /// ## `default_editable`
    /// default editability of the buffer
    #[doc(alias = "gtk_text_buffer_cut_clipboard")]
    fn cut_clipboard(&self, clipboard: &gdk::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;
    /// gtk_text_buffer_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(),
            ))
        }
    }

    /// Denotes the end of an action that may not be undone.
    ///
    /// This will cause any previous operations in the undo/redo
    /// queue to be cleared.
    ///
    /// This should be called after completing modifications to the
    /// text buffer after [`begin_irreversible_action()`][Self::begin_irreversible_action()]
    /// was called.
    ///
    /// You may nest calls to gtk_text_buffer_begin_irreversible_action()
    /// and gtk_text_buffer_end_irreversible_action() pairs.
    #[doc(alias = "gtk_text_buffer_end_irreversible_action")]
    fn end_irreversible_action(&self) {
        unsafe {
            ffi::gtk_text_buffer_end_irreversible_action(self.as_ref().to_glib_none().0);
        }
    }

    /// Ends a user-visible operation.
    ///
    /// 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 whether there is a redoable action in the history.
    ///
    /// # Returns
    ///
    /// [`true`] if there is a redoable action
    #[doc(alias = "gtk_text_buffer_get_can_redo")]
    #[doc(alias = "get_can_redo")]
    #[doc(alias = "can-redo")]
    fn can_redo(&self) -> bool {
        unsafe {
            from_glib(ffi::gtk_text_buffer_get_can_redo(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Gets whether there is an undoable action in the history.
    ///
    /// # Returns
    ///
    /// [`true`] if there is an undoable action
    #[doc(alias = "gtk_text_buffer_get_can_undo")]
    #[doc(alias = "get_can_undo")]
    #[doc(alias = "can-undo")]
    fn can_undo(&self) -> bool {
        unsafe {
            from_glib(ffi::gtk_text_buffer_get_can_undo(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

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

    /// Gets whether the buffer is saving modifications to the buffer
    /// to allow for undo and redo actions.
    ///
    /// See [`begin_irreversible_action()`][Self::begin_irreversible_action()] and
    /// [`end_irreversible_action()`][Self::end_irreversible_action()] to create
    /// changes to the buffer that cannot be undone.
    ///
    /// # Returns
    ///
    /// [`true`] if undoing and redoing changes to the buffer is allowed.
    #[doc(alias = "gtk_text_buffer_get_enable_undo")]
    #[doc(alias = "get_enable_undo")]
    #[doc(alias = "enable-undo")]
    fn enables_undo(&self) -> bool {
        unsafe {
            from_glib(ffi::gtk_text_buffer_get_enable_undo(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// 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) -> 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 or equal to the number of lines
    /// in the @self, the end iterator is returned.
    /// ## `line_number`
    /// line number counting from 0
    ///
    /// # Returns
    ///
    /// whether the exact position has been found
    ///
    /// ## `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) -> Option<TextIter> {
        unsafe {
            let mut iter = TextIter::uninitialized();
            let ret = from_glib(ffi::gtk_text_buffer_get_iter_at_line(
                self.as_ref().to_glib_none().0,
                iter.to_glib_none_mut().0,
                line_number,
            ));
            if ret {
                Some(iter)
            } else {
                None
            }
        }
    }

    /// 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.
    ///
    /// If @line_number is greater than or equal to 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
    ///
    /// whether the exact position has been found
    ///
    /// ## `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) -> Option<TextIter> {
        unsafe {
            let mut iter = TextIter::uninitialized();
            let ret = from_glib(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,
            ));
            if ret {
                Some(iter)
            } else {
                None
            }
        }
    }

    /// Obtains an iterator pointing to @char_offset within the given line.
    ///
    /// Note characters, not bytes; UTF-8 may encode one character as multiple
    /// bytes.
    ///
    /// If @line_number is greater than or equal to 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
    ///
    /// whether the exact position has been found
    ///
    /// ## `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) -> Option<TextIter> {
        unsafe {
            let mut iter = TextIter::uninitialized();
            let ret = from_glib(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,
            ));
            if ret {
                Some(iter)
            } else {
                None
            }
        }
    }

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

    /// Gets the maximum number of undo levels to perform.
    ///
    /// If 0, unlimited undo actions may be performed. Note that this may
    /// have a memory usage impact as it requires storing an additional
    /// copy of the inserted or removed text within the text buffer.
    ///
    /// # Returns
    ///
    /// The max number of undo levels allowed (0 indicates unlimited).
    #[doc(alias = "gtk_text_buffer_get_max_undo_levels")]
    #[doc(alias = "get_max_undo_levels")]
    fn max_undo_levels(&self) -> u32 {
        unsafe { ffi::gtk_text_buffer_get_max_undo_levels(self.as_ref().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,
            ))
        }
    }

    /// 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) -> 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 [`None`], 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
            }
        }
    }

    /// Get a content provider for this buffer.
    ///
    /// It can be used to make the content of @self available
    /// in a [`gdk::Clipboard`][crate::gdk::Clipboard], see [`Clipboard::set_content()`][crate::gdk::Clipboard::set_content()].
    ///
    /// # Returns
    ///
    /// a new [`gdk::ContentProvider`][crate::gdk::ContentProvider].
    #[doc(alias = "gtk_text_buffer_get_selection_content")]
    #[doc(alias = "get_selection_content")]
    fn selection_content(&self) -> gdk::ContentProvider {
        unsafe {
            from_glib_full(ffi::gtk_text_buffer_get_selection_content(
                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`].
    /// 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 paintable 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) -> 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) -> 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) -> 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,
            );
        }
    }

    /// Inserts @text in @self.
    ///
    /// 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,
            );
        }
    }

    /// Inserts @text in @self.
    ///
    /// 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(),
            ))
        }
    }

    /// Inserts @text in @self.
    ///
    /// 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
    /// ## `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 paintable, but the “text”
    /// variants do not. e.g. see [`slice()`][Self::slice()] and
    /// [`text()`][Self::text()].
    /// ## `iter`
    /// location to insert the paintable
    /// ## `paintable`
    /// a [`gdk::Paintable`][crate::gdk::Paintable]
    #[doc(alias = "gtk_text_buffer_insert_paintable")]
    fn insert_paintable(&self, iter: &mut TextIter, paintable: &impl IsA<gdk::Paintable>) {
        unsafe {
            ffi::gtk_text_buffer_insert_paintable(
                self.as_ref().to_glib_none().0,
                iter.to_glib_none_mut().0,
                paintable.as_ref().to_glib_none().0,
            );
        }
    }

    /// Copies text, tags, and paintables between @start and @end
    /// and inserts the copy at @iter.
    ///
    /// The order of @start and @end doesn’t matter.
    ///
    /// 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,
            );
        }
    }

    /// Copies text, tags, and paintables between @start and @end
    /// and inserts the copy at @iter.
    ///
    /// 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(),
            ))
        }
    }

    /// 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 [`gdk::Clipboard`][crate::gdk::Clipboard] to paste from
    /// ## `override_location`
    /// location to insert pasted text
    /// ## `default_editable`
    /// whether the buffer is editable by default
    #[doc(alias = "gtk_text_buffer_paste_clipboard")]
    fn paste_clipboard(
        &self,
        clipboard: &gdk::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,
            );
        }
    }

    /// Redoes the next redoable action on the buffer, if there is one.
    #[doc(alias = "gtk_text_buffer_redo")]
    fn redo(&self) {
        unsafe {
            ffi::gtk_text_buffer_redo(self.as_ref().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 the `GtkTextBufferCommitNotify` handler previously registered
    /// with [`TextBufferExtManual::add_commit_notify()`][crate::prelude::TextBufferExtManual::add_commit_notify()].
    ///
    /// This may result in the `user_data_destroy` being called that was passed when registering
    /// the commit notify functions.
    /// ## `commit_notify_handler`
    /// the notify handler identifier returned from
    ///   [`TextBufferExtManual::add_commit_notify()`][crate::prelude::TextBufferExtManual::add_commit_notify()].
    #[cfg(feature = "v4_16")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v4_16")))]
    #[doc(alias = "gtk_text_buffer_remove_commit_notify")]
    fn remove_commit_notify(&self, commit_notify_handler: u32) {
        unsafe {
            ffi::gtk_text_buffer_remove_commit_notify(
                self.as_ref().to_glib_none().0,
                commit_notify_handler,
            );
        }
    }

    /// Removes a [`gdk::Clipboard`][crate::gdk::Clipboard] added with
    /// [`add_selection_clipboard()`][Self::add_selection_clipboard()]
    /// ## `clipboard`
    /// a [`gdk::Clipboard`][crate::gdk::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: &gdk::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,
            );
        }
    }

    /// Emits the “remove-tag” signal.
    ///
    /// Calls [`TextTagTable::lookup()`][crate::TextTagTable::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,
            );
        }
    }

    /// Sets whether or not to enable undoable actions in the text buffer.
    ///
    /// Undoable actions in this context are changes to the text content of
    /// the buffer. Changes to tags and marks are not tracked.
    ///
    /// If enabled, the user will be able to undo the last number of actions
    /// up to [`max_undo_levels()`][Self::max_undo_levels()].
    ///
    /// See [`begin_irreversible_action()`][Self::begin_irreversible_action()] and
    /// [`end_irreversible_action()`][Self::end_irreversible_action()] to create
    /// changes to the buffer that cannot be undone.
    /// ## `enable_undo`
    /// [`true`] to enable undo
    #[doc(alias = "gtk_text_buffer_set_enable_undo")]
    #[doc(alias = "enable-undo")]
    fn set_enable_undo(&self, enable_undo: bool) {
        unsafe {
            ffi::gtk_text_buffer_set_enable_undo(
                self.as_ref().to_glib_none().0,
                enable_undo.into_glib(),
            );
        }
    }

    /// Sets the maximum number of undo levels to perform.
    ///
    /// If 0, unlimited undo actions may be performed. Note that this may
    /// have a memory usage impact as it requires storing an additional
    /// copy of the inserted or removed text within the text buffer.
    /// ## `max_undo_levels`
    /// the maximum number of undo actions to perform
    #[doc(alias = "gtk_text_buffer_set_max_undo_levels")]
    fn set_max_undo_levels(&self, max_undo_levels: u32) {
        unsafe {
            ffi::gtk_text_buffer_set_max_undo_levels(
                self.as_ref().to_glib_none().0,
                max_undo_levels,
            );
        }
    }

    /// 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
    /// toggle 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. This is
    /// automatically marked as an irreversible action in the undo stack. If you
    /// wish to mark this action as part of a larger undo operation, call
    /// [`delete()`][Self::delete()] and [`insert()`][Self::insert()] directly 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,
            );
        }
    }

    /// Undoes the last undoable action on the buffer, if there is one.
    #[doc(alias = "gtk_text_buffer_undo")]
    fn undo(&self) {
        unsafe {
            ffi::gtk_text_buffer_undo(self.as_ref().to_glib_none().0);
        }
    }

    /// The position of the insert mark.
    ///
    /// This is an 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")
    }

    /// 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:
    /// [`apply_tag()`][Self::apply_tag()],
    /// [`TextBufferExtManual::insert_with_tags()`][crate::prelude::TextBufferExtManual::insert_with_tags()],
    /// [`insert_range()`][Self::insert_range()].
    /// ## `tag`
    /// the applied tag
    /// ## `start`
    /// the start of the range the tag is applied to
    /// ## `end`
    /// the end of the range the tag is applied to
    #[doc(alias = "apply-tag")]
    fn connect_apply_tag<F: Fn(&Self, &TextTag, &TextIter, &TextIter) + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn apply_tag_trampoline<
            P: IsA<TextBuffer>,
            F: Fn(&P, &TextTag, &TextIter, &TextIter) + 'static,
        >(
            this: *mut ffi::GtkTextBuffer,
            tag: *mut ffi::GtkTextTag,
            start: *mut ffi::GtkTextIter,
            end: *mut ffi::GtkTextIter,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(
                TextBuffer::from_glib_borrow(this).unsafe_cast_ref(),
                &from_glib_borrow(tag),
                &from_glib_borrow(start),
                &from_glib_borrow(end),
            )
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"apply-tag".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    apply_tag_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    /// 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,
        ) {
            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() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    begin_user_action_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    /// 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,
        ) {
            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() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    changed_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    /// 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: [`delete()`][Self::delete()].
    /// ## `start`
    /// the start of the range to be deleted
    /// ## `end`
    /// the end of the range to be deleted
    #[doc(alias = "delete-range")]
    fn connect_delete_range<F: Fn(&Self, &TextIter, &TextIter) + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn delete_range_trampoline<
            P: IsA<TextBuffer>,
            F: Fn(&P, &TextIter, &TextIter) + 'static,
        >(
            this: *mut ffi::GtkTextBuffer,
            start: *mut ffi::GtkTextIter,
            end: *mut ffi::GtkTextIter,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(
                TextBuffer::from_glib_borrow(this).unsafe_cast_ref(),
                &from_glib_borrow(start),
                &from_glib_borrow(end),
            )
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"delete-range".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    delete_range_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    /// 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,
        ) {
            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() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    end_user_action_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    /// 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: [`insert_child_anchor()`][Self::insert_child_anchor()].
    /// ## `location`
    /// position to insert @anchor in @textbuffer
    /// ## `anchor`
    /// the [`TextChildAnchor`][crate::TextChildAnchor] to be inserted
    #[doc(alias = "insert-child-anchor")]
    fn connect_insert_child_anchor<F: Fn(&Self, &TextIter, &TextChildAnchor) + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn insert_child_anchor_trampoline<
            P: IsA<TextBuffer>,
            F: Fn(&P, &TextIter, &TextChildAnchor) + 'static,
        >(
            this: *mut ffi::GtkTextBuffer,
            location: *mut ffi::GtkTextIter,
            anchor: *mut ffi::GtkTextChildAnchor,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(
                TextBuffer::from_glib_borrow(this).unsafe_cast_ref(),
                &from_glib_borrow(location),
                &from_glib_borrow(anchor),
            )
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"insert-child-anchor".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    insert_child_anchor_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    /// Emitted to insert a [`gdk::Paintable`][crate::gdk::Paintable] 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 @paintable.
    ///
    /// See also: [`insert_paintable()`][Self::insert_paintable()].
    /// ## `location`
    /// position to insert @paintable in @textbuffer
    /// ## `paintable`
    /// the [`gdk::Paintable`][crate::gdk::Paintable] to be inserted
    #[doc(alias = "insert-paintable")]
    fn connect_insert_paintable<F: Fn(&Self, &TextIter, &gdk::Paintable) + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn insert_paintable_trampoline<
            P: IsA<TextBuffer>,
            F: Fn(&P, &TextIter, &gdk::Paintable) + 'static,
        >(
            this: *mut ffi::GtkTextBuffer,
            location: *mut ffi::GtkTextIter,
            paintable: *mut gdk::ffi::GdkPaintable,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(
                TextBuffer::from_glib_borrow(this).unsafe_cast_ref(),
                &from_glib_borrow(location),
                &from_glib_borrow(paintable),
            )
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"insert-paintable".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    insert_paintable_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    /// 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,
        ) {
            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() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    mark_deleted_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    /// 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,
        ) {
            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() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    mark_set_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    /// 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,
        ) {
            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() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    modified_changed_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    /// 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 [`gdk::Clipboard`][crate::gdk::Clipboard] pasted from
    #[doc(alias = "paste-done")]
    fn connect_paste_done<F: Fn(&Self, &gdk::Clipboard) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn paste_done_trampoline<
            P: IsA<TextBuffer>,
            F: Fn(&P, &gdk::Clipboard) + 'static,
        >(
            this: *mut ffi::GtkTextBuffer,
            clipboard: *mut gdk::ffi::GdkClipboard,
            f: glib::ffi::gpointer,
        ) {
            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() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    paste_done_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    /// Emitted when a request has been made to redo the
    /// previously undone operation.
    #[doc(alias = "redo")]
    fn connect_redo<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn redo_trampoline<P: IsA<TextBuffer>, F: Fn(&P) + 'static>(
            this: *mut ffi::GtkTextBuffer,
            f: glib::ffi::gpointer,
        ) {
            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"redo".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    redo_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    /// 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: [`remove_tag()`][Self::remove_tag()].
    /// ## `tag`
    /// the tag to be removed
    /// ## `start`
    /// the start of the range the tag is removed from
    /// ## `end`
    /// the end of the range the tag is removed from
    #[doc(alias = "remove-tag")]
    fn connect_remove_tag<F: Fn(&Self, &TextTag, &TextIter, &TextIter) + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn remove_tag_trampoline<
            P: IsA<TextBuffer>,
            F: Fn(&P, &TextTag, &TextIter, &TextIter) + 'static,
        >(
            this: *mut ffi::GtkTextBuffer,
            tag: *mut ffi::GtkTextTag,
            start: *mut ffi::GtkTextIter,
            end: *mut ffi::GtkTextIter,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(
                TextBuffer::from_glib_borrow(this).unsafe_cast_ref(),
                &from_glib_borrow(tag),
                &from_glib_borrow(start),
                &from_glib_borrow(end),
            )
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"remove-tag".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    remove_tag_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    /// Emitted when a request has been made to undo the
    /// previous operation or set of operations that have
    /// been grouped together.
    #[doc(alias = "undo")]
    fn connect_undo<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn undo_trampoline<P: IsA<TextBuffer>, F: Fn(&P) + 'static>(
            this: *mut ffi::GtkTextBuffer,
            f: glib::ffi::gpointer,
        ) {
            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"undo".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    undo_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "can-redo")]
    fn connect_can_redo_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_can_redo_trampoline<P: IsA<TextBuffer>, F: Fn(&P) + 'static>(
            this: *mut ffi::GtkTextBuffer,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            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::can-redo".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_can_redo_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "can-undo")]
    fn connect_can_undo_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_can_undo_trampoline<P: IsA<TextBuffer>, F: Fn(&P) + 'static>(
            this: *mut ffi::GtkTextBuffer,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            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::can-undo".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_can_undo_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,
        ) {
            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() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_cursor_position_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "enable-undo")]
    fn connect_enable_undo_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_enable_undo_trampoline<
            P: IsA<TextBuffer>,
            F: Fn(&P) + 'static,
        >(
            this: *mut ffi::GtkTextBuffer,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            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::enable-undo".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_enable_undo_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,
        ) {
            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() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_has_selection_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,
        ) {
            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() as *const _,
                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 {}