gtk/auto/

text_iter.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::{TextBuffer, TextChildAnchor, TextMark, TextSearchFlags, TextTag, ffi};
use glib::{prelude::*, translate::*};

glib::wrapper! {
    /// You may wish to begin by reading the
    /// [text widget conceptual overview](TextWidget.html)
    /// which gives an overview of all the objects and data
    /// types related to the text widget and how they work together.
    #[derive(Debug)]
    pub struct TextIter(BoxedInline<ffi::GtkTextIter>);

    match fn {
        copy => |ptr| ffi::gtk_text_iter_copy(ptr),
        free => |ptr| ffi::gtk_text_iter_free(ptr),
        type_ => || ffi::gtk_text_iter_get_type(),
    }
}

impl TextIter {
    /// Assigns the value of `other` to `self`. This function
    /// is not useful in applications, because iterators can be assigned
    /// with `GtkTextIter i = j;`. The
    /// function is used by language bindings.
    /// ## `other`
    /// another [`TextIter`][crate::TextIter]
    #[doc(alias = "gtk_text_iter_assign")]
    pub fn assign(&mut self, other: &TextIter) {
        unsafe {
            ffi::gtk_text_iter_assign(self.to_glib_none_mut().0, other.to_glib_none().0);
        }
    }

    /// Moves backward by one character offset. Returns [`true`] if movement
    /// was possible; if `self` was the first in the buffer (character
    /// offset 0), [`backward_char()`][Self::backward_char()] returns [`false`] for convenience when
    /// writing loops.
    ///
    /// # Returns
    ///
    /// whether movement was possible
    #[doc(alias = "gtk_text_iter_backward_char")]
    pub fn backward_char(&mut self) -> bool {
        unsafe { from_glib(ffi::gtk_text_iter_backward_char(self.to_glib_none_mut().0)) }
    }

    /// Moves `count` characters backward, if possible (if `count` would move
    /// past the start or end of the buffer, moves to the start or end of
    /// the buffer). The return value indicates whether the iterator moved
    /// onto a dereferenceable position; if the iterator didn’t move, or
    /// moved onto the end iterator, then [`false`] is returned. If `count` is 0,
    /// the function does nothing and returns [`false`].
    /// ## `count`
    /// number of characters to move
    ///
    /// # Returns
    ///
    /// whether `self` moved and is dereferenceable
    #[doc(alias = "gtk_text_iter_backward_chars")]
    pub fn backward_chars(&mut self, count: i32) -> bool {
        unsafe {
            from_glib(ffi::gtk_text_iter_backward_chars(
                self.to_glib_none_mut().0,
                count,
            ))
        }
    }

    /// Like [`forward_cursor_position()`][Self::forward_cursor_position()], but moves backward.
    ///
    /// # Returns
    ///
    /// [`true`] if we moved
    #[doc(alias = "gtk_text_iter_backward_cursor_position")]
    pub fn backward_cursor_position(&mut self) -> bool {
        unsafe {
            from_glib(ffi::gtk_text_iter_backward_cursor_position(
                self.to_glib_none_mut().0,
            ))
        }
    }

    /// Moves up to `count` cursor positions. See
    /// [`forward_cursor_position()`][Self::forward_cursor_position()] for details.
    /// ## `count`
    /// number of positions to move
    ///
    /// # Returns
    ///
    /// [`true`] if we moved and the new position is dereferenceable
    #[doc(alias = "gtk_text_iter_backward_cursor_positions")]
    pub fn backward_cursor_positions(&mut self, count: i32) -> bool {
        unsafe {
            from_glib(ffi::gtk_text_iter_backward_cursor_positions(
                self.to_glib_none_mut().0,
                count,
            ))
        }
    }

    /// Same as [`forward_find_char()`][Self::forward_find_char()], but goes backward from `self`.
    /// ## `pred`
    /// function to be called on each character
    /// ## `limit`
    /// search limit, or [`None`] for none
    ///
    /// # Returns
    ///
    /// whether a match was found
    #[doc(alias = "gtk_text_iter_backward_find_char")]
    pub fn backward_find_char<P: FnMut(char) -> bool>(
        &mut self,
        pred: P,
        limit: Option<&TextIter>,
    ) -> bool {
        let mut pred_data: P = pred;
        unsafe extern "C" fn pred_func<P: FnMut(char) -> bool>(
            ch: u32,
            user_data: glib::ffi::gpointer,
        ) -> glib::ffi::gboolean {
            unsafe {
                let ch = std::convert::TryFrom::try_from(ch)
                    .expect("conversion from an invalid Unicode value attempted");
                let callback = user_data as *mut P;
                (*callback)(ch).into_glib()
            }
        }
        let pred = Some(pred_func::<P> as _);
        let super_callback0: &mut P = &mut pred_data;
        unsafe {
            from_glib(ffi::gtk_text_iter_backward_find_char(
                self.to_glib_none_mut().0,
                pred,
                super_callback0 as *mut _ as *mut _,
                limit.to_glib_none().0,
            ))
        }
    }

    /// Moves `self` to the start of the previous line. Returns [`true`] if
    /// `self` could be moved; i.e. if `self` was at character offset 0, this
    /// function returns [`false`]. Therefore if `self` was already on line 0,
    /// but not at the start of the line, `self` is snapped to the start of
    /// the line and the function returns [`true`]. (Note that this implies that
    /// in a loop calling this function, the line number may not change on
    /// every iteration, if your first iteration is on line 0.)
    ///
    /// # Returns
    ///
    /// whether `self` moved
    #[doc(alias = "gtk_text_iter_backward_line")]
    pub fn backward_line(&mut self) -> bool {
        unsafe { from_glib(ffi::gtk_text_iter_backward_line(self.to_glib_none_mut().0)) }
    }

    /// Moves `count` lines backward, if possible (if `count` would move
    /// past the start or end of the buffer, moves to the start or end of
    /// the buffer). The return value indicates whether the iterator moved
    /// onto a dereferenceable position; if the iterator didn’t move, or
    /// moved onto the end iterator, then [`false`] is returned. If `count` is 0,
    /// the function does nothing and returns [`false`]. If `count` is negative,
    /// moves forward by 0 - `count` lines.
    /// ## `count`
    /// number of lines to move backward
    ///
    /// # Returns
    ///
    /// whether `self` moved and is dereferenceable
    #[doc(alias = "gtk_text_iter_backward_lines")]
    pub fn backward_lines(&mut self, count: i32) -> bool {
        unsafe {
            from_glib(ffi::gtk_text_iter_backward_lines(
                self.to_glib_none_mut().0,
                count,
            ))
        }
    }

    /// Same as [`forward_search()`][Self::forward_search()], but moves backward.
    ///
    /// `match_end` will never be set to a [`TextIter`][crate::TextIter] located after `self`, even if
    /// there is a possible `match_start` before or at `self`.
    /// ## `str`
    /// search string
    /// ## `flags`
    /// bitmask of flags affecting the search
    /// ## `limit`
    /// location of last possible `match_start`, or [`None`] for start of buffer
    ///
    /// # Returns
    ///
    /// whether a match was found
    ///
    /// ## `match_start`
    /// return location for start of match, or [`None`]
    ///
    /// ## `match_end`
    /// return location for end of match, or [`None`]
    #[doc(alias = "gtk_text_iter_backward_search")]
    pub fn backward_search(
        &self,
        str: &str,
        flags: TextSearchFlags,
        limit: Option<&TextIter>,
    ) -> Option<(TextIter, TextIter)> {
        unsafe {
            let mut match_start = TextIter::uninitialized();
            let mut match_end = TextIter::uninitialized();
            let ret = from_glib(ffi::gtk_text_iter_backward_search(
                self.to_glib_none().0,
                str.to_glib_none().0,
                flags.into_glib(),
                match_start.to_glib_none_mut().0,
                match_end.to_glib_none_mut().0,
                limit.to_glib_none().0,
            ));
            if ret {
                Some((match_start, match_end))
            } else {
                None
            }
        }
    }

    /// Moves backward to the previous sentence start; if `self` is already at
    /// the start of a sentence, moves backward to the next one. Sentence
    /// boundaries are determined by Pango and should be correct for nearly
    /// any language (if not, the correct fix would be to the Pango text
    /// boundary algorithms).
    ///
    /// # Returns
    ///
    /// [`true`] if `self` moved and is not the end iterator
    #[doc(alias = "gtk_text_iter_backward_sentence_start")]
    pub fn backward_sentence_start(&mut self) -> bool {
        unsafe {
            from_glib(ffi::gtk_text_iter_backward_sentence_start(
                self.to_glib_none_mut().0,
            ))
        }
    }

    /// Calls [`backward_sentence_start()`][Self::backward_sentence_start()] up to `count` times,
    /// or until it returns [`false`]. If `count` is negative, moves forward
    /// instead of backward.
    /// ## `count`
    /// number of sentences to move
    ///
    /// # Returns
    ///
    /// [`true`] if `self` moved and is not the end iterator
    #[doc(alias = "gtk_text_iter_backward_sentence_starts")]
    pub fn backward_sentence_starts(&mut self, count: i32) -> bool {
        unsafe {
            from_glib(ffi::gtk_text_iter_backward_sentence_starts(
                self.to_glib_none_mut().0,
                count,
            ))
        }
    }

    /// Moves backward to the next toggle (on or off) of the
    /// [`TextTag`][crate::TextTag] `tag`, or to the next toggle of any tag if
    /// `tag` is [`None`]. If no matching tag toggles are found,
    /// returns [`false`], otherwise [`true`]. Does not return toggles
    /// located at `self`, only toggles before `self`. Sets `self`
    /// to the location of the toggle, or the start of the buffer
    /// if no toggle is found.
    /// ## `tag`
    /// a [`TextTag`][crate::TextTag], or [`None`]
    ///
    /// # Returns
    ///
    /// whether we found a tag toggle before `self`
    #[doc(alias = "gtk_text_iter_backward_to_tag_toggle")]
    pub fn backward_to_tag_toggle(&mut self, tag: Option<&impl IsA<TextTag>>) -> bool {
        unsafe {
            from_glib(ffi::gtk_text_iter_backward_to_tag_toggle(
                self.to_glib_none_mut().0,
                tag.map(|p| p.as_ref()).to_glib_none().0,
            ))
        }
    }

    /// Moves `self` forward to the previous visible cursor position. See
    /// [`backward_cursor_position()`][Self::backward_cursor_position()] for details.
    ///
    /// # Returns
    ///
    /// [`true`] if we moved and the new position is dereferenceable
    #[doc(alias = "gtk_text_iter_backward_visible_cursor_position")]
    pub fn backward_visible_cursor_position(&mut self) -> bool {
        unsafe {
            from_glib(ffi::gtk_text_iter_backward_visible_cursor_position(
                self.to_glib_none_mut().0,
            ))
        }
    }

    /// Moves up to `count` visible cursor positions. See
    /// [`backward_cursor_position()`][Self::backward_cursor_position()] for details.
    /// ## `count`
    /// number of positions to move
    ///
    /// # Returns
    ///
    /// [`true`] if we moved and the new position is dereferenceable
    #[doc(alias = "gtk_text_iter_backward_visible_cursor_positions")]
    pub fn backward_visible_cursor_positions(&mut self, count: i32) -> bool {
        unsafe {
            from_glib(ffi::gtk_text_iter_backward_visible_cursor_positions(
                self.to_glib_none_mut().0,
                count,
            ))
        }
    }

    /// Moves `self` to the start of the previous visible line. Returns [`true`] if
    /// `self` could be moved; i.e. if `self` was at character offset 0, this
    /// function returns [`false`]. Therefore if `self` was already on line 0,
    /// but not at the start of the line, `self` is snapped to the start of
    /// the line and the function returns [`true`]. (Note that this implies that
    /// in a loop calling this function, the line number may not change on
    /// every iteration, if your first iteration is on line 0.)
    ///
    /// # Returns
    ///
    /// whether `self` moved
    #[doc(alias = "gtk_text_iter_backward_visible_line")]
    pub fn backward_visible_line(&mut self) -> bool {
        unsafe {
            from_glib(ffi::gtk_text_iter_backward_visible_line(
                self.to_glib_none_mut().0,
            ))
        }
    }

    /// Moves `count` visible lines backward, if possible (if `count` would move
    /// past the start or end of the buffer, moves to the start or end of
    /// the buffer). The return value indicates whether the iterator moved
    /// onto a dereferenceable position; if the iterator didn’t move, or
    /// moved onto the end iterator, then [`false`] is returned. If `count` is 0,
    /// the function does nothing and returns [`false`]. If `count` is negative,
    /// moves forward by 0 - `count` lines.
    /// ## `count`
    /// number of lines to move backward
    ///
    /// # Returns
    ///
    /// whether `self` moved and is dereferenceable
    #[doc(alias = "gtk_text_iter_backward_visible_lines")]
    pub fn backward_visible_lines(&mut self, count: i32) -> bool {
        unsafe {
            from_glib(ffi::gtk_text_iter_backward_visible_lines(
                self.to_glib_none_mut().0,
                count,
            ))
        }
    }

    /// Moves backward to the previous visible word start. (If `self` is currently
    /// on a word start, moves backward to the next one after that.) Word breaks
    /// are determined by Pango and should be correct for nearly any
    /// language (if not, the correct fix would be to the Pango word break
    /// algorithms).
    ///
    /// # Returns
    ///
    /// [`true`] if `self` moved and is not the end iterator
    #[doc(alias = "gtk_text_iter_backward_visible_word_start")]
    pub fn backward_visible_word_start(&mut self) -> bool {
        unsafe {
            from_glib(ffi::gtk_text_iter_backward_visible_word_start(
                self.to_glib_none_mut().0,
            ))
        }
    }

    /// Calls [`backward_visible_word_start()`][Self::backward_visible_word_start()] up to `count` times.
    /// ## `count`
    /// number of times to move
    ///
    /// # Returns
    ///
    /// [`true`] if `self` moved and is not the end iterator
    #[doc(alias = "gtk_text_iter_backward_visible_word_starts")]
    pub fn backward_visible_word_starts(&mut self, count: i32) -> bool {
        unsafe {
            from_glib(ffi::gtk_text_iter_backward_visible_word_starts(
                self.to_glib_none_mut().0,
                count,
            ))
        }
    }

    /// Moves backward to the previous word start. (If `self` is currently on a
    /// word start, moves backward to the next one after that.) Word breaks
    /// are determined by Pango and should be correct for nearly any
    /// language (if not, the correct fix would be to the Pango word break
    /// algorithms).
    ///
    /// # Returns
    ///
    /// [`true`] if `self` moved and is not the end iterator
    #[doc(alias = "gtk_text_iter_backward_word_start")]
    pub fn backward_word_start(&mut self) -> bool {
        unsafe {
            from_glib(ffi::gtk_text_iter_backward_word_start(
                self.to_glib_none_mut().0,
            ))
        }
    }

    /// Calls [`backward_word_start()`][Self::backward_word_start()] up to `count` times.
    /// ## `count`
    /// number of times to move
    ///
    /// # Returns
    ///
    /// [`true`] if `self` moved and is not the end iterator
    #[doc(alias = "gtk_text_iter_backward_word_starts")]
    pub fn backward_word_starts(&mut self, count: i32) -> bool {
        unsafe {
            from_glib(ffi::gtk_text_iter_backward_word_starts(
                self.to_glib_none_mut().0,
                count,
            ))
        }
    }

    /// Considering the default editability of the buffer, and tags that
    /// affect editability, determines whether text inserted at `self` would
    /// be editable. If text inserted at `self` would be editable then the
    /// user should be allowed to insert text at `self`.
    /// [`TextBufferExt::insert_interactive()`][crate::prelude::TextBufferExt::insert_interactive()] uses this function to decide
    /// whether insertions are allowed at a given position.
    /// ## `default_editability`
    /// [`true`] if text is editable by default
    ///
    /// # Returns
    ///
    /// whether text inserted at `self` would be editable
    #[doc(alias = "gtk_text_iter_can_insert")]
    pub fn can_insert(&self, default_editability: bool) -> bool {
        unsafe {
            from_glib(ffi::gtk_text_iter_can_insert(
                self.to_glib_none().0,
                default_editability.into_glib(),
            ))
        }
    }

    #[doc(alias = "gtk_text_iter_compare")]
    fn compare(&self, rhs: &TextIter) -> i32 {
        unsafe { ffi::gtk_text_iter_compare(self.to_glib_none().0, rhs.to_glib_none().0) }
    }

    /// Returns whether the character at `self` is within an editable region
    /// of text. Non-editable text is “locked” and can’t be changed by the
    /// user via [`TextView`][crate::TextView]. This function is simply a convenience
    /// wrapper around [`is_attributes()`][Self::is_attributes()]. If no tags applied
    /// to this text affect editability, `default_setting` will be returned.
    ///
    /// You don’t want to use this function to decide whether text can be
    /// inserted at `self`, because for insertion you don’t want to know
    /// whether the char at `self` is inside an editable range, you want to
    /// know whether a new character inserted at `self` would be inside an
    /// editable range. Use [`can_insert()`][Self::can_insert()] to handle this
    /// case.
    /// ## `default_setting`
    /// [`true`] if text is editable by default
    ///
    /// # Returns
    ///
    /// whether `self` is inside an editable range
    #[doc(alias = "gtk_text_iter_editable")]
    pub fn editable(&self, default_setting: bool) -> bool {
        unsafe {
            from_glib(ffi::gtk_text_iter_editable(
                self.to_glib_none().0,
                default_setting.into_glib(),
            ))
        }
    }

    /// Returns [`true`] if `self` points to the start of the paragraph
    /// delimiter characters for a line (delimiters will be either a
    /// newline, a carriage return, a carriage return followed by a
    /// newline, or a Unicode paragraph separator character). Note that an
    /// iterator pointing to the \n of a \r\n pair will not be counted as
    /// the end of a line, the line ends before the \r. The end iterator is
    /// considered to be at the end of a line, even though there are no
    /// paragraph delimiter chars there.
    ///
    /// # Returns
    ///
    /// whether `self` is at the end of a line
    #[doc(alias = "gtk_text_iter_ends_line")]
    pub fn ends_line(&self) -> bool {
        unsafe { from_glib(ffi::gtk_text_iter_ends_line(self.to_glib_none().0)) }
    }

    /// Determines whether `self` ends a sentence. Sentence boundaries are
    /// determined by Pango and should be correct for nearly any language
    /// (if not, the correct fix would be to the Pango text boundary
    /// algorithms).
    ///
    /// # Returns
    ///
    /// [`true`] if `self` is at the end of a sentence.
    #[doc(alias = "gtk_text_iter_ends_sentence")]
    pub fn ends_sentence(&self) -> bool {
        unsafe { from_glib(ffi::gtk_text_iter_ends_sentence(self.to_glib_none().0)) }
    }

    /// Returns [`true`] if `tag` is toggled off at exactly this point. If `tag`
    /// is [`None`], returns [`true`] if any tag is toggled off at this point.
    ///
    /// Note that if [`ends_tag()`][Self::ends_tag()] returns [`true`], it means that `self` is
    /// at the end of the tagged range, but that the character
    /// at `self` is outside the tagged range. In other words,
    /// unlike [`starts_tag()`][Self::starts_tag()], if [`ends_tag()`][Self::ends_tag()] returns [`true`],
    /// [`has_tag()`][Self::has_tag()] will return [`false`] for the same parameters.
    /// ## `tag`
    /// a [`TextTag`][crate::TextTag], or [`None`]
    ///
    /// # Returns
    ///
    /// whether `self` is the end of a range tagged with `tag`
    #[doc(alias = "gtk_text_iter_ends_tag")]
    pub fn ends_tag(&self, tag: Option<&impl IsA<TextTag>>) -> bool {
        unsafe {
            from_glib(ffi::gtk_text_iter_ends_tag(
                self.to_glib_none().0,
                tag.map(|p| p.as_ref()).to_glib_none().0,
            ))
        }
    }

    /// Determines whether `self` ends a natural-language word. Word breaks
    /// are determined by Pango and should be correct for nearly any
    /// language (if not, the correct fix would be to the Pango word break
    /// algorithms).
    ///
    /// # Returns
    ///
    /// [`true`] if `self` is at the end of a word
    #[doc(alias = "gtk_text_iter_ends_word")]
    pub fn ends_word(&self) -> bool {
        unsafe { from_glib(ffi::gtk_text_iter_ends_word(self.to_glib_none().0)) }
    }

    #[doc(alias = "gtk_text_iter_equal")]
    fn equal(&self, rhs: &TextIter) -> bool {
        unsafe {
            from_glib(ffi::gtk_text_iter_equal(
                self.to_glib_none().0,
                rhs.to_glib_none().0,
            ))
        }
    }

    /// Moves `self` forward by one character offset. Note that images
    /// embedded in the buffer occupy 1 character slot, so
    /// [`forward_char()`][Self::forward_char()] may actually move onto an image instead
    /// of a character, if you have images in your buffer. If `self` is the
    /// end iterator or one character before it, `self` will now point at
    /// the end iterator, and [`forward_char()`][Self::forward_char()] returns [`false`] for
    /// convenience when writing loops.
    ///
    /// # Returns
    ///
    /// whether `self` moved and is dereferenceable
    #[doc(alias = "gtk_text_iter_forward_char")]
    pub fn forward_char(&mut self) -> bool {
        unsafe { from_glib(ffi::gtk_text_iter_forward_char(self.to_glib_none_mut().0)) }
    }

    /// Moves `count` characters if possible (if `count` would move past the
    /// start or end of the buffer, moves to the start or end of the
    /// buffer). The return value indicates whether the new position of
    /// `self` is different from its original position, and dereferenceable
    /// (the last iterator in the buffer is not dereferenceable). If `count`
    /// is 0, the function does nothing and returns [`false`].
    /// ## `count`
    /// number of characters to move, may be negative
    ///
    /// # Returns
    ///
    /// whether `self` moved and is dereferenceable
    #[doc(alias = "gtk_text_iter_forward_chars")]
    pub fn forward_chars(&mut self, count: i32) -> bool {
        unsafe {
            from_glib(ffi::gtk_text_iter_forward_chars(
                self.to_glib_none_mut().0,
                count,
            ))
        }
    }

    /// Moves `self` forward by a single cursor position. Cursor positions
    /// are (unsurprisingly) positions where the cursor can appear. Perhaps
    /// surprisingly, there may not be a cursor position between all
    /// characters. The most common example for European languages would be
    /// a carriage return/newline sequence. For some Unicode characters,
    /// the equivalent of say the letter “a” with an accent mark will be
    /// represented as two characters, first the letter then a "combining
    /// mark" that causes the accent to be rendered; so the cursor can’t go
    /// between those two characters. See also the `PangoLogAttr`-struct and
    /// `pango_break()` function.
    ///
    /// # Returns
    ///
    /// [`true`] if we moved and the new position is dereferenceable
    #[doc(alias = "gtk_text_iter_forward_cursor_position")]
    pub fn forward_cursor_position(&mut self) -> bool {
        unsafe {
            from_glib(ffi::gtk_text_iter_forward_cursor_position(
                self.to_glib_none_mut().0,
            ))
        }
    }

    /// Moves up to `count` cursor positions. See
    /// [`forward_cursor_position()`][Self::forward_cursor_position()] for details.
    /// ## `count`
    /// number of positions to move
    ///
    /// # Returns
    ///
    /// [`true`] if we moved and the new position is dereferenceable
    #[doc(alias = "gtk_text_iter_forward_cursor_positions")]
    pub fn forward_cursor_positions(&mut self, count: i32) -> bool {
        unsafe {
            from_glib(ffi::gtk_text_iter_forward_cursor_positions(
                self.to_glib_none_mut().0,
                count,
            ))
        }
    }

    /// Advances `self`, calling `pred` on each character. If
    /// `pred` returns [`true`], returns [`true`] and stops scanning.
    /// If `pred` never returns [`true`], `self` is set to `limit` if
    /// `limit` is non-[`None`], otherwise to the end iterator.
    /// ## `pred`
    /// a function to be called on each character
    /// ## `limit`
    /// search limit, or [`None`] for none
    ///
    /// # Returns
    ///
    /// whether a match was found
    #[doc(alias = "gtk_text_iter_forward_find_char")]
    pub fn forward_find_char<P: FnMut(char) -> bool>(
        &mut self,
        pred: P,
        limit: Option<&TextIter>,
    ) -> bool {
        let mut pred_data: P = pred;
        unsafe extern "C" fn pred_func<P: FnMut(char) -> bool>(
            ch: u32,
            user_data: glib::ffi::gpointer,
        ) -> glib::ffi::gboolean {
            unsafe {
                let ch = std::convert::TryFrom::try_from(ch)
                    .expect("conversion from an invalid Unicode value attempted");
                let callback = user_data as *mut P;
                (*callback)(ch).into_glib()
            }
        }
        let pred = Some(pred_func::<P> as _);
        let super_callback0: &mut P = &mut pred_data;
        unsafe {
            from_glib(ffi::gtk_text_iter_forward_find_char(
                self.to_glib_none_mut().0,
                pred,
                super_callback0 as *mut _ as *mut _,
                limit.to_glib_none().0,
            ))
        }
    }

    /// Moves `self` to the start of the next line. If the iter is already on the
    /// last line of the buffer, moves the iter to the end of the current line.
    /// If after the operation, the iter is at the end of the buffer and not
    /// dereferencable, returns [`false`]. Otherwise, returns [`true`].
    ///
    /// # Returns
    ///
    /// whether `self` can be dereferenced
    #[doc(alias = "gtk_text_iter_forward_line")]
    pub fn forward_line(&mut self) -> bool {
        unsafe { from_glib(ffi::gtk_text_iter_forward_line(self.to_glib_none_mut().0)) }
    }

    /// Moves `count` lines forward, if possible (if `count` would move
    /// past the start or end of the buffer, moves to the start or end of
    /// the buffer). The return value indicates whether the iterator moved
    /// onto a dereferenceable position; if the iterator didn’t move, or
    /// moved onto the end iterator, then [`false`] is returned. If `count` is 0,
    /// the function does nothing and returns [`false`]. If `count` is negative,
    /// moves backward by 0 - `count` lines.
    /// ## `count`
    /// number of lines to move forward
    ///
    /// # Returns
    ///
    /// whether `self` moved and is dereferenceable
    #[doc(alias = "gtk_text_iter_forward_lines")]
    pub fn forward_lines(&mut self, count: i32) -> bool {
        unsafe {
            from_glib(ffi::gtk_text_iter_forward_lines(
                self.to_glib_none_mut().0,
                count,
            ))
        }
    }

    /// Searches forward for `str`. Any match is returned by setting
    /// `match_start` to the first character of the match and `match_end` to the
    /// first character after the match. The search will not continue past
    /// `limit`. Note that a search is a linear or O(n) operation, so you
    /// may wish to use `limit` to avoid locking up your UI on large
    /// buffers.
    ///
    /// `match_start` will never be set to a [`TextIter`][crate::TextIter] located before `self`, even if
    /// there is a possible `match_end` after or at `self`.
    /// ## `str`
    /// a search string
    /// ## `flags`
    /// flags affecting how the search is done
    /// ## `limit`
    /// location of last possible `match_end`, or [`None`] for the end of the buffer
    ///
    /// # Returns
    ///
    /// whether a match was found
    ///
    /// ## `match_start`
    /// return location for start of match, or [`None`]
    ///
    /// ## `match_end`
    /// return location for end of match, or [`None`]
    #[doc(alias = "gtk_text_iter_forward_search")]
    pub fn forward_search(
        &self,
        str: &str,
        flags: TextSearchFlags,
        limit: Option<&TextIter>,
    ) -> Option<(TextIter, TextIter)> {
        unsafe {
            let mut match_start = TextIter::uninitialized();
            let mut match_end = TextIter::uninitialized();
            let ret = from_glib(ffi::gtk_text_iter_forward_search(
                self.to_glib_none().0,
                str.to_glib_none().0,
                flags.into_glib(),
                match_start.to_glib_none_mut().0,
                match_end.to_glib_none_mut().0,
                limit.to_glib_none().0,
            ));
            if ret {
                Some((match_start, match_end))
            } else {
                None
            }
        }
    }

    /// Moves forward to the next sentence end. (If `self` is at the end of
    /// a sentence, moves to the next end of sentence.) Sentence
    /// boundaries are determined by Pango and should be correct for nearly
    /// any language (if not, the correct fix would be to the Pango text
    /// boundary algorithms).
    ///
    /// # Returns
    ///
    /// [`true`] if `self` moved and is not the end iterator
    #[doc(alias = "gtk_text_iter_forward_sentence_end")]
    pub fn forward_sentence_end(&mut self) -> bool {
        unsafe {
            from_glib(ffi::gtk_text_iter_forward_sentence_end(
                self.to_glib_none_mut().0,
            ))
        }
    }

    /// Calls [`forward_sentence_end()`][Self::forward_sentence_end()] `count` times (or until
    /// [`forward_sentence_end()`][Self::forward_sentence_end()] returns [`false`]). If `count` is
    /// negative, moves backward instead of forward.
    /// ## `count`
    /// number of sentences to move
    ///
    /// # Returns
    ///
    /// [`true`] if `self` moved and is not the end iterator
    #[doc(alias = "gtk_text_iter_forward_sentence_ends")]
    pub fn forward_sentence_ends(&mut self, count: i32) -> bool {
        unsafe {
            from_glib(ffi::gtk_text_iter_forward_sentence_ends(
                self.to_glib_none_mut().0,
                count,
            ))
        }
    }

    /// Moves `self` forward to the “end iterator,” which points one past the last
    /// valid character in the buffer. [`char()`][Self::char()] called on the
    /// end iterator returns 0, which is convenient for writing loops.
    #[doc(alias = "gtk_text_iter_forward_to_end")]
    pub fn forward_to_end(&mut self) {
        unsafe {
            ffi::gtk_text_iter_forward_to_end(self.to_glib_none_mut().0);
        }
    }

    /// Moves the iterator to point to the paragraph delimiter characters,
    /// which will be either a newline, a carriage return, a carriage
    /// return/newline in sequence, or the Unicode paragraph separator
    /// character. If the iterator is already at the paragraph delimiter
    /// characters, moves to the paragraph delimiter characters for the
    /// next line. If `self` is on the last line in the buffer, which does
    /// not end in paragraph delimiters, moves to the end iterator (end of
    /// the last line), and returns [`false`].
    ///
    /// # Returns
    ///
    /// [`true`] if we moved and the new location is not the end iterator
    #[doc(alias = "gtk_text_iter_forward_to_line_end")]
    pub fn forward_to_line_end(&mut self) -> bool {
        unsafe {
            from_glib(ffi::gtk_text_iter_forward_to_line_end(
                self.to_glib_none_mut().0,
            ))
        }
    }

    /// Moves forward to the next toggle (on or off) of the
    /// [`TextTag`][crate::TextTag] `tag`, or to the next toggle of any tag if
    /// `tag` is [`None`]. If no matching tag toggles are found,
    /// returns [`false`], otherwise [`true`]. Does not return toggles
    /// located at `self`, only toggles after `self`. Sets `self` to
    /// the location of the toggle, or to the end of the buffer
    /// if no toggle is found.
    /// ## `tag`
    /// a [`TextTag`][crate::TextTag], or [`None`]
    ///
    /// # Returns
    ///
    /// whether we found a tag toggle after `self`
    #[doc(alias = "gtk_text_iter_forward_to_tag_toggle")]
    pub fn forward_to_tag_toggle(&mut self, tag: Option<&impl IsA<TextTag>>) -> bool {
        unsafe {
            from_glib(ffi::gtk_text_iter_forward_to_tag_toggle(
                self.to_glib_none_mut().0,
                tag.map(|p| p.as_ref()).to_glib_none().0,
            ))
        }
    }

    /// Moves `self` forward to the next visible cursor position. See
    /// [`forward_cursor_position()`][Self::forward_cursor_position()] for details.
    ///
    /// # Returns
    ///
    /// [`true`] if we moved and the new position is dereferenceable
    #[doc(alias = "gtk_text_iter_forward_visible_cursor_position")]
    pub fn forward_visible_cursor_position(&mut self) -> bool {
        unsafe {
            from_glib(ffi::gtk_text_iter_forward_visible_cursor_position(
                self.to_glib_none_mut().0,
            ))
        }
    }

    /// Moves up to `count` visible cursor positions. See
    /// [`forward_cursor_position()`][Self::forward_cursor_position()] for details.
    /// ## `count`
    /// number of positions to move
    ///
    /// # Returns
    ///
    /// [`true`] if we moved and the new position is dereferenceable
    #[doc(alias = "gtk_text_iter_forward_visible_cursor_positions")]
    pub fn forward_visible_cursor_positions(&mut self, count: i32) -> bool {
        unsafe {
            from_glib(ffi::gtk_text_iter_forward_visible_cursor_positions(
                self.to_glib_none_mut().0,
                count,
            ))
        }
    }

    /// Moves `self` to the start of the next visible line. Returns [`true`] if there
    /// was a next line to move to, and [`false`] if `self` was simply moved to
    /// the end of the buffer and is now not dereferenceable, or if `self` was
    /// already at the end of the buffer.
    ///
    /// # Returns
    ///
    /// whether `self` can be dereferenced
    #[doc(alias = "gtk_text_iter_forward_visible_line")]
    pub fn forward_visible_line(&mut self) -> bool {
        unsafe {
            from_glib(ffi::gtk_text_iter_forward_visible_line(
                self.to_glib_none_mut().0,
            ))
        }
    }

    /// Moves `count` visible lines forward, if possible (if `count` would move
    /// past the start or end of the buffer, moves to the start or end of
    /// the buffer). The return value indicates whether the iterator moved
    /// onto a dereferenceable position; if the iterator didn’t move, or
    /// moved onto the end iterator, then [`false`] is returned. If `count` is 0,
    /// the function does nothing and returns [`false`]. If `count` is negative,
    /// moves backward by 0 - `count` lines.
    /// ## `count`
    /// number of lines to move forward
    ///
    /// # Returns
    ///
    /// whether `self` moved and is dereferenceable
    #[doc(alias = "gtk_text_iter_forward_visible_lines")]
    pub fn forward_visible_lines(&mut self, count: i32) -> bool {
        unsafe {
            from_glib(ffi::gtk_text_iter_forward_visible_lines(
                self.to_glib_none_mut().0,
                count,
            ))
        }
    }

    /// Moves forward to the next visible word end. (If `self` is currently on a
    /// word end, moves forward to the next one after that.) Word breaks
    /// are determined by Pango and should be correct for nearly any
    /// language (if not, the correct fix would be to the Pango word break
    /// algorithms).
    ///
    /// # Returns
    ///
    /// [`true`] if `self` moved and is not the end iterator
    #[doc(alias = "gtk_text_iter_forward_visible_word_end")]
    pub fn forward_visible_word_end(&mut self) -> bool {
        unsafe {
            from_glib(ffi::gtk_text_iter_forward_visible_word_end(
                self.to_glib_none_mut().0,
            ))
        }
    }

    /// Calls [`forward_visible_word_end()`][Self::forward_visible_word_end()] up to `count` times.
    /// ## `count`
    /// number of times to move
    ///
    /// # Returns
    ///
    /// [`true`] if `self` moved and is not the end iterator
    #[doc(alias = "gtk_text_iter_forward_visible_word_ends")]
    pub fn forward_visible_word_ends(&mut self, count: i32) -> bool {
        unsafe {
            from_glib(ffi::gtk_text_iter_forward_visible_word_ends(
                self.to_glib_none_mut().0,
                count,
            ))
        }
    }

    /// Moves forward to the next word end. (If `self` is currently on a
    /// word end, moves forward to the next one after that.) Word breaks
    /// are determined by Pango and should be correct for nearly any
    /// language (if not, the correct fix would be to the Pango word break
    /// algorithms).
    ///
    /// # Returns
    ///
    /// [`true`] if `self` moved and is not the end iterator
    #[doc(alias = "gtk_text_iter_forward_word_end")]
    pub fn forward_word_end(&mut self) -> bool {
        unsafe {
            from_glib(ffi::gtk_text_iter_forward_word_end(
                self.to_glib_none_mut().0,
            ))
        }
    }

    /// Calls [`forward_word_end()`][Self::forward_word_end()] up to `count` times.
    /// ## `count`
    /// number of times to move
    ///
    /// # Returns
    ///
    /// [`true`] if `self` moved and is not the end iterator
    #[doc(alias = "gtk_text_iter_forward_word_ends")]
    pub fn forward_word_ends(&mut self, count: i32) -> bool {
        unsafe {
            from_glib(ffi::gtk_text_iter_forward_word_ends(
                self.to_glib_none_mut().0,
                count,
            ))
        }
    }

    /// Returns the [`TextBuffer`][crate::TextBuffer] this iterator is associated with.
    ///
    /// # Returns
    ///
    /// the buffer
    #[doc(alias = "gtk_text_iter_get_buffer")]
    #[doc(alias = "get_buffer")]
    pub fn buffer(&self) -> Option<TextBuffer> {
        unsafe { from_glib_none(ffi::gtk_text_iter_get_buffer(self.to_glib_none().0)) }
    }

    /// Returns the number of bytes in the line containing `self`,
    /// including the paragraph delimiters.
    ///
    /// # Returns
    ///
    /// number of bytes in the line
    #[doc(alias = "gtk_text_iter_get_bytes_in_line")]
    #[doc(alias = "get_bytes_in_line")]
    pub fn bytes_in_line(&self) -> i32 {
        unsafe { ffi::gtk_text_iter_get_bytes_in_line(self.to_glib_none().0) }
    }

    /// Returns the number of characters in the line containing `self`,
    /// including the paragraph delimiters.
    ///
    /// # Returns
    ///
    /// number of characters in the line
    #[doc(alias = "gtk_text_iter_get_chars_in_line")]
    #[doc(alias = "get_chars_in_line")]
    pub fn chars_in_line(&self) -> i32 {
        unsafe { ffi::gtk_text_iter_get_chars_in_line(self.to_glib_none().0) }
    }

    /// If the location at `self` contains a child anchor, the
    /// anchor is returned (with no new reference count added). Otherwise,
    /// [`None`] is returned.
    ///
    /// # Returns
    ///
    /// the anchor at `self`
    #[doc(alias = "gtk_text_iter_get_child_anchor")]
    #[doc(alias = "get_child_anchor")]
    pub fn child_anchor(&self) -> Option<TextChildAnchor> {
        unsafe { from_glib_none(ffi::gtk_text_iter_get_child_anchor(self.to_glib_none().0)) }
    }

    /// A convenience wrapper around [`is_attributes()`][Self::is_attributes()],
    /// which returns the language in effect at `self`. If no tags affecting
    /// language apply to `self`, the return value is identical to that of
    /// [`default_language()`][crate::default_language()].
    ///
    /// # Returns
    ///
    /// language in effect at `self`
    #[doc(alias = "gtk_text_iter_get_language")]
    #[doc(alias = "get_language")]
    pub fn language(&self) -> Option<pango::Language> {
        unsafe { from_glib_full(ffi::gtk_text_iter_get_language(self.to_glib_none().0)) }
    }

    /// Returns the line number containing the iterator. Lines in
    /// a [`TextBuffer`][crate::TextBuffer] are numbered beginning with 0 for the first
    /// line in the buffer.
    ///
    /// # Returns
    ///
    /// a line number
    #[doc(alias = "gtk_text_iter_get_line")]
    #[doc(alias = "get_line")]
    pub fn line(&self) -> i32 {
        unsafe { ffi::gtk_text_iter_get_line(self.to_glib_none().0) }
    }

    /// Returns the byte index of the iterator, counting
    /// from the start of a newline-terminated line.
    /// Remember that [`TextBuffer`][crate::TextBuffer] encodes text in
    /// UTF-8, and that characters can require a variable
    /// number of bytes to represent.
    ///
    /// # Returns
    ///
    /// distance from start of line, in bytes
    #[doc(alias = "gtk_text_iter_get_line_index")]
    #[doc(alias = "get_line_index")]
    pub fn line_index(&self) -> i32 {
        unsafe { ffi::gtk_text_iter_get_line_index(self.to_glib_none().0) }
    }

    /// Returns the character offset of the iterator,
    /// counting from the start of a newline-terminated line.
    /// The first character on the line has offset 0.
    ///
    /// # Returns
    ///
    /// offset from start of line
    #[doc(alias = "gtk_text_iter_get_line_offset")]
    #[doc(alias = "get_line_offset")]
    pub fn line_offset(&self) -> i32 {
        unsafe { ffi::gtk_text_iter_get_line_offset(self.to_glib_none().0) }
    }

    /// Returns a list of all [`TextMark`][crate::TextMark] at this location. Because marks
    /// are not iterable (they don’t take up any "space" in the buffer,
    /// they are just marks in between iterable locations), multiple marks
    /// can exist in the same place. The returned list is not in any
    /// meaningful order.
    ///
    /// # Returns
    ///
    /// list of [`TextMark`][crate::TextMark]
    #[doc(alias = "gtk_text_iter_get_marks")]
    #[doc(alias = "get_marks")]
    pub fn marks(&self) -> Vec<TextMark> {
        unsafe {
            FromGlibPtrContainer::from_glib_container(ffi::gtk_text_iter_get_marks(
                self.to_glib_none().0,
            ))
        }
    }

    /// Returns the character offset of an iterator.
    /// Each character in a [`TextBuffer`][crate::TextBuffer] has an offset,
    /// starting with 0 for the first character in the buffer.
    /// Use [`TextBufferExt::iter_at_offset()`][crate::prelude::TextBufferExt::iter_at_offset()] to convert an
    /// offset back into an iterator.
    ///
    /// # Returns
    ///
    /// a character offset
    #[doc(alias = "gtk_text_iter_get_offset")]
    #[doc(alias = "get_offset")]
    pub fn offset(&self) -> i32 {
        unsafe { ffi::gtk_text_iter_get_offset(self.to_glib_none().0) }
    }

    /// If the element at `self` is a pixbuf, the pixbuf is returned
    /// (with no new reference count added). Otherwise,
    /// [`None`] is returned.
    ///
    /// # Returns
    ///
    /// the pixbuf at `self`
    #[doc(alias = "gtk_text_iter_get_pixbuf")]
    #[doc(alias = "get_pixbuf")]
    pub fn pixbuf(&self) -> Option<gdk_pixbuf::Pixbuf> {
        unsafe { from_glib_none(ffi::gtk_text_iter_get_pixbuf(self.to_glib_none().0)) }
    }

    /// Returns the text in the given range. A “slice” is an array of
    /// characters encoded in UTF-8 format, including the Unicode “unknown”
    /// character 0xFFFC for iterable non-character elements in the buffer,
    /// such as images. Because images are encoded in the slice, byte and
    /// character offsets in the returned array will correspond to byte
    /// offsets in the text buffer. Note that 0xFFFC can occur in normal
    /// text as well, so it is not a reliable indicator that a pixbuf or
    /// widget is in the buffer.
    /// ## `end`
    /// iterator at end of a range
    ///
    /// # Returns
    ///
    /// slice of text from the buffer
    #[doc(alias = "gtk_text_iter_get_slice")]
    #[doc(alias = "get_slice")]
    pub fn slice(&self, end: &TextIter) -> Option<glib::GString> {
        unsafe {
            from_glib_full(ffi::gtk_text_iter_get_slice(
                self.to_glib_none().0,
                end.to_glib_none().0,
            ))
        }
    }

    /// Returns a list of tags that apply to `self`, in ascending order of
    /// priority (highest-priority tags are last). The [`TextTag`][crate::TextTag] in the
    /// list don’t have a reference added, but you have to free the list
    /// itself.
    ///
    /// # Returns
    ///
    /// list of [`TextTag`][crate::TextTag]
    #[doc(alias = "gtk_text_iter_get_tags")]
    #[doc(alias = "get_tags")]
    pub fn tags(&self) -> Vec<TextTag> {
        unsafe {
            FromGlibPtrContainer::from_glib_container(ffi::gtk_text_iter_get_tags(
                self.to_glib_none().0,
            ))
        }
    }

    /// Returns text in the given range. If the range
    /// contains non-text elements such as images, the character and byte
    /// offsets in the returned string will not correspond to character and
    /// byte offsets in the buffer. If you want offsets to correspond, see
    /// [`slice()`][Self::slice()].
    /// ## `end`
    /// iterator at end of a range
    ///
    /// # Returns
    ///
    /// array of characters from the buffer
    #[doc(alias = "gtk_text_iter_get_text")]
    #[doc(alias = "get_text")]
    pub fn text(&self, end: &TextIter) -> Option<glib::GString> {
        unsafe {
            from_glib_full(ffi::gtk_text_iter_get_text(
                self.to_glib_none().0,
                end.to_glib_none().0,
            ))
        }
    }

    /// Returns a list of [`TextTag`][crate::TextTag] that are toggled on or off at this
    /// point. (If `toggled_on` is [`true`], the list contains tags that are
    /// toggled on.) If a tag is toggled on at `self`, then some non-empty
    /// range of characters following `self` has that tag applied to it. If
    /// a tag is toggled off, then some non-empty range following `self`
    /// does not have the tag applied to it.
    /// ## `toggled_on`
    /// [`true`] to get toggled-on tags
    ///
    /// # Returns
    ///
    /// tags toggled at this point
    #[doc(alias = "gtk_text_iter_get_toggled_tags")]
    #[doc(alias = "get_toggled_tags")]
    pub fn toggled_tags(&self, toggled_on: bool) -> Vec<TextTag> {
        unsafe {
            FromGlibPtrContainer::from_glib_container(ffi::gtk_text_iter_get_toggled_tags(
                self.to_glib_none().0,
                toggled_on.into_glib(),
            ))
        }
    }

    /// Returns the number of bytes from the start of the
    /// line to the given `self`, not counting bytes that
    /// are invisible due to tags with the “invisible” flag
    /// toggled on.
    ///
    /// # Returns
    ///
    /// byte index of `self` with respect to the start of the line
    #[doc(alias = "gtk_text_iter_get_visible_line_index")]
    #[doc(alias = "get_visible_line_index")]
    pub fn visible_line_index(&self) -> i32 {
        unsafe { ffi::gtk_text_iter_get_visible_line_index(self.to_glib_none().0) }
    }

    /// Returns the offset in characters from the start of the
    /// line to the given `self`, not counting characters that
    /// are invisible due to tags with the “invisible” flag
    /// toggled on.
    ///
    /// # Returns
    ///
    /// offset in visible characters from the start of the line
    #[doc(alias = "gtk_text_iter_get_visible_line_offset")]
    #[doc(alias = "get_visible_line_offset")]
    pub fn visible_line_offset(&self) -> i32 {
        unsafe { ffi::gtk_text_iter_get_visible_line_offset(self.to_glib_none().0) }
    }

    /// Like [`slice()`][Self::slice()], but invisible text is not included.
    /// Invisible text is usually invisible because a [`TextTag`][crate::TextTag] with the
    /// “invisible” attribute turned on has been applied to it.
    /// ## `end`
    /// iterator at end of range
    ///
    /// # Returns
    ///
    /// slice of text from the buffer
    #[doc(alias = "gtk_text_iter_get_visible_slice")]
    #[doc(alias = "get_visible_slice")]
    pub fn visible_slice(&self, end: &TextIter) -> Option<glib::GString> {
        unsafe {
            from_glib_full(ffi::gtk_text_iter_get_visible_slice(
                self.to_glib_none().0,
                end.to_glib_none().0,
            ))
        }
    }

    /// Like [`text()`][Self::text()], but invisible text is not included.
    /// Invisible text is usually invisible because a [`TextTag`][crate::TextTag] with the
    /// “invisible” attribute turned on has been applied to it.
    /// ## `end`
    /// iterator at end of range
    ///
    /// # Returns
    ///
    /// string containing visible text in the
    /// range
    #[doc(alias = "gtk_text_iter_get_visible_text")]
    #[doc(alias = "get_visible_text")]
    pub fn visible_text(&self, end: &TextIter) -> Option<glib::GString> {
        unsafe {
            from_glib_full(ffi::gtk_text_iter_get_visible_text(
                self.to_glib_none().0,
                end.to_glib_none().0,
            ))
        }
    }

    /// Returns [`true`] if `self` points to a character that is part of a range tagged
    /// with `tag`. See also [`starts_tag()`][Self::starts_tag()] and [`ends_tag()`][Self::ends_tag()].
    /// ## `tag`
    /// a [`TextTag`][crate::TextTag]
    ///
    /// # Returns
    ///
    /// whether `self` is tagged with `tag`
    #[doc(alias = "gtk_text_iter_has_tag")]
    pub fn has_tag(&self, tag: &impl IsA<TextTag>) -> bool {
        unsafe {
            from_glib(ffi::gtk_text_iter_has_tag(
                self.to_glib_none().0,
                tag.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Checks whether `self` falls in the range [`start`, `end`).
    /// `start` and `end` must be in ascending order.
    /// ## `start`
    /// start of range
    /// ## `end`
    /// end of range
    ///
    /// # Returns
    ///
    /// [`true`] if `self` is in the range
    #[doc(alias = "gtk_text_iter_in_range")]
    pub fn in_range(&self, start: &TextIter, end: &TextIter) -> bool {
        unsafe {
            from_glib(ffi::gtk_text_iter_in_range(
                self.to_glib_none().0,
                start.to_glib_none().0,
                end.to_glib_none().0,
            ))
        }
    }

    /// Determines whether `self` is inside a sentence (as opposed to in
    /// between two sentences, e.g. after a period and before the first
    /// letter of the next sentence). Sentence boundaries are determined
    /// by Pango and should be correct for nearly any language (if not, the
    /// correct fix would be to the Pango text boundary algorithms).
    ///
    /// # Returns
    ///
    /// [`true`] if `self` is inside a sentence.
    #[doc(alias = "gtk_text_iter_inside_sentence")]
    pub fn inside_sentence(&self) -> bool {
        unsafe { from_glib(ffi::gtk_text_iter_inside_sentence(self.to_glib_none().0)) }
    }

    /// Determines whether the character pointed by `self` is part of a
    /// natural-language word (as opposed to say inside some whitespace). Word
    /// breaks are determined by Pango and should be correct for nearly any language
    /// (if not, the correct fix would be to the Pango word break algorithms).
    ///
    /// Note that if [`starts_word()`][Self::starts_word()] returns [`true`], then this function
    /// returns [`true`] too, since `self` points to the first character of the word.
    ///
    /// # Returns
    ///
    /// [`true`] if `self` is inside a word
    #[doc(alias = "gtk_text_iter_inside_word")]
    pub fn inside_word(&self) -> bool {
        unsafe { from_glib(ffi::gtk_text_iter_inside_word(self.to_glib_none().0)) }
    }

    /// See [`forward_cursor_position()`][Self::forward_cursor_position()] or `PangoLogAttr` or
    /// `pango_break()` for details on what a cursor position is.
    ///
    /// # Returns
    ///
    /// [`true`] if the cursor can be placed at `self`
    #[doc(alias = "gtk_text_iter_is_cursor_position")]
    pub fn is_cursor_position(&self) -> bool {
        unsafe { from_glib(ffi::gtk_text_iter_is_cursor_position(self.to_glib_none().0)) }
    }

    /// Returns [`true`] if `self` is the end iterator, i.e. one past the last
    /// dereferenceable iterator in the buffer. [`is_end()`][Self::is_end()] is
    /// the most efficient way to check whether an iterator is the end
    /// iterator.
    ///
    /// # Returns
    ///
    /// whether `self` is the end iterator
    #[doc(alias = "gtk_text_iter_is_end")]
    pub fn is_end(&self) -> bool {
        unsafe { from_glib(ffi::gtk_text_iter_is_end(self.to_glib_none().0)) }
    }

    /// Returns [`true`] if `self` is the first iterator in the buffer, that is
    /// if `self` has a character offset of 0.
    ///
    /// # Returns
    ///
    /// whether `self` is the first in the buffer
    #[doc(alias = "gtk_text_iter_is_start")]
    pub fn is_start(&self) -> bool {
        unsafe { from_glib(ffi::gtk_text_iter_is_start(self.to_glib_none().0)) }
    }

    /// Swaps the value of `self` and `second` if `second` comes before
    /// `self` in the buffer. That is, ensures that `self` and `second` are
    /// in sequence. Most text buffer functions that take a range call this
    /// automatically on your behalf, so there’s no real reason to call it yourself
    /// in those cases. There are some exceptions, such as [`in_range()`][Self::in_range()],
    /// that expect a pre-sorted range.
    /// ## `second`
    /// another [`TextIter`][crate::TextIter]
    #[doc(alias = "gtk_text_iter_order")]
    pub fn order(&mut self, second: &mut TextIter) {
        unsafe {
            ffi::gtk_text_iter_order(self.to_glib_none_mut().0, second.to_glib_none_mut().0);
        }
    }

    /// Moves iterator `self` to the start of the line `line_number`. If
    /// `line_number` is negative or larger than the number of lines in the
    /// buffer, moves `self` to the start of the last line in the buffer.
    /// ## `line_number`
    /// line number (counted from 0)
    #[doc(alias = "gtk_text_iter_set_line")]
    pub fn set_line(&mut self, line_number: i32) {
        unsafe {
            ffi::gtk_text_iter_set_line(self.to_glib_none_mut().0, line_number);
        }
    }

    /// Same as [`set_line_offset()`][Self::set_line_offset()], but works with a
    /// byte index. The given byte index must be at
    /// the start of a character, it can’t be in the middle of a UTF-8
    /// encoded character.
    /// ## `byte_on_line`
    /// a byte index relative to the start of `self`’s current line
    #[doc(alias = "gtk_text_iter_set_line_index")]
    pub fn set_line_index(&mut self, byte_on_line: i32) {
        unsafe {
            ffi::gtk_text_iter_set_line_index(self.to_glib_none_mut().0, byte_on_line);
        }
    }

    /// Moves `self` within a line, to a new character
    /// (not byte) offset. The given character offset must be less than or
    /// equal to the number of characters in the line; if equal, `self`
    /// moves to the start of the next line. See
    /// [`set_line_index()`][Self::set_line_index()] if you have a byte index rather than
    /// a character offset.
    /// ## `char_on_line`
    /// a character offset relative to the start of `self`’s current line
    #[doc(alias = "gtk_text_iter_set_line_offset")]
    pub fn set_line_offset(&mut self, char_on_line: i32) {
        unsafe {
            ffi::gtk_text_iter_set_line_offset(self.to_glib_none_mut().0, char_on_line);
        }
    }

    /// Sets `self` to point to `char_offset`. `char_offset` counts from the start
    /// of the entire text buffer, starting with 0.
    /// ## `char_offset`
    /// a character number
    #[doc(alias = "gtk_text_iter_set_offset")]
    pub fn set_offset(&mut self, char_offset: i32) {
        unsafe {
            ffi::gtk_text_iter_set_offset(self.to_glib_none_mut().0, char_offset);
        }
    }

    /// Like [`set_line_index()`][Self::set_line_index()], but the index is in visible
    /// bytes, i.e. text with a tag making it invisible is not counted
    /// in the index.
    /// ## `byte_on_line`
    /// a byte index
    #[doc(alias = "gtk_text_iter_set_visible_line_index")]
    pub fn set_visible_line_index(&mut self, byte_on_line: i32) {
        unsafe {
            ffi::gtk_text_iter_set_visible_line_index(self.to_glib_none_mut().0, byte_on_line);
        }
    }

    /// Like [`set_line_offset()`][Self::set_line_offset()], but the offset is in visible
    /// characters, i.e. text with a tag making it invisible is not
    /// counted in the offset.
    /// ## `char_on_line`
    /// a character offset
    #[doc(alias = "gtk_text_iter_set_visible_line_offset")]
    pub fn set_visible_line_offset(&mut self, char_on_line: i32) {
        unsafe {
            ffi::gtk_text_iter_set_visible_line_offset(self.to_glib_none_mut().0, char_on_line);
        }
    }

    /// Returns [`true`] if `self` begins a paragraph,
    /// i.e. if [`line_offset()`][Self::line_offset()] would return 0.
    /// However this function is potentially more efficient than
    /// [`line_offset()`][Self::line_offset()] because it doesn’t have to compute
    /// the offset, it just has to see whether it’s 0.
    ///
    /// # Returns
    ///
    /// whether `self` begins a line
    #[doc(alias = "gtk_text_iter_starts_line")]
    pub fn starts_line(&self) -> bool {
        unsafe { from_glib(ffi::gtk_text_iter_starts_line(self.to_glib_none().0)) }
    }

    /// Determines whether `self` begins a sentence. Sentence boundaries are
    /// determined by Pango and should be correct for nearly any language
    /// (if not, the correct fix would be to the Pango text boundary
    /// algorithms).
    ///
    /// # Returns
    ///
    /// [`true`] if `self` is at the start of a sentence.
    #[doc(alias = "gtk_text_iter_starts_sentence")]
    pub fn starts_sentence(&self) -> bool {
        unsafe { from_glib(ffi::gtk_text_iter_starts_sentence(self.to_glib_none().0)) }
    }

    /// Returns [`true`] if `tag` is toggled on at exactly this point. If `tag`
    /// is [`None`], returns [`true`] if any tag is toggled on at this point.
    ///
    /// Note that if [`starts_tag()`][Self::starts_tag()] returns [`true`], it means that `self` is
    /// at the beginning of the tagged range, and that the
    /// character at `self` is inside the tagged range. In other
    /// words, unlike [`ends_tag()`][Self::ends_tag()], if [`starts_tag()`][Self::starts_tag()] returns
    /// [`true`], [`has_tag()`][Self::has_tag()] will also return [`true`] for the same
    /// parameters.
    /// ## `tag`
    /// a [`TextTag`][crate::TextTag], or [`None`]
    ///
    /// # Returns
    ///
    /// whether `self` is the start of a range tagged with `tag`
    #[doc(alias = "gtk_text_iter_starts_tag")]
    pub fn starts_tag(&self, tag: Option<&impl IsA<TextTag>>) -> bool {
        unsafe {
            from_glib(ffi::gtk_text_iter_starts_tag(
                self.to_glib_none().0,
                tag.map(|p| p.as_ref()).to_glib_none().0,
            ))
        }
    }

    /// Determines whether `self` begins a natural-language word. Word
    /// breaks are determined by Pango and should be correct for nearly any
    /// language (if not, the correct fix would be to the Pango word break
    /// algorithms).
    ///
    /// # Returns
    ///
    /// [`true`] if `self` is at the start of a word
    #[doc(alias = "gtk_text_iter_starts_word")]
    pub fn starts_word(&self) -> bool {
        unsafe { from_glib(ffi::gtk_text_iter_starts_word(self.to_glib_none().0)) }
    }

    /// This is equivalent to ([`starts_tag()`][Self::starts_tag()] ||
    /// [`ends_tag()`][Self::ends_tag()]), i.e. it tells you whether a range with
    /// `tag` applied to it begins or ends at `self`.
    /// ## `tag`
    /// a [`TextTag`][crate::TextTag], or [`None`]
    ///
    /// # Returns
    ///
    /// whether `tag` is toggled on or off at `self`
    #[doc(alias = "gtk_text_iter_toggles_tag")]
    pub fn toggles_tag(&self, tag: Option<&impl IsA<TextTag>>) -> bool {
        unsafe {
            from_glib(ffi::gtk_text_iter_toggles_tag(
                self.to_glib_none().0,
                tag.map(|p| p.as_ref()).to_glib_none().0,
            ))
        }
    }
}

impl PartialOrd for TextIter {
    #[inline]
    fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
        Some(self.cmp(other))
    }
}

impl Ord for TextIter {
    #[inline]
    fn cmp(&self, other: &Self) -> std::cmp::Ordering {
        self.compare(other).cmp(&0)
    }
}

impl PartialEq for TextIter {
    #[inline]
    fn eq(&self, other: &Self) -> bool {
        self.equal(other)
    }
}

impl Eq for TextIter {}