gtk4/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! {
    /// Iterates over the contents of a [`TextBuffer`][crate::TextBuffer].
    ///
    /// 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.
    #[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), this function 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
    ///
    /// # 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
    ///
    /// ## `match_end`
    /// return location for end of match
    #[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.
    ///
    /// # 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.
    ///
    /// 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
    /// @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]
    ///
    /// # 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 backward 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.
    ///
    /// # 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
    ///
    /// # 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]. 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.
    ///
    /// # 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 this function 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 this function
    /// returns [`true`], [`has_tag()`][Self::has_tag()] will return
    /// [`false`] for the same parameters.
    /// ## `tag`
    /// a [`TextTag`][crate::TextTag]
    ///
    /// # 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.
    ///
    /// # 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
    /// this function 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 this function 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 `Pango::LogAttr` struct and the `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
    ///
    /// # 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
    /// dereferenceable, 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
    ///
    /// ## `match_end`
    /// return location for end of match
    #[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.
    ///
    /// # 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.
    ///
    /// 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.
    ///
    /// The possible characters are 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
    /// @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]
    ///
    /// # 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
    ///
    /// # 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.
    ///
    /// # 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) -> 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) }
    }

    /// The Unicode character at this iterator is returned.
    ///
    /// Equivalent to operator* on a C++ iterator. If the element at
    /// this iterator is a non-character element, such as an image
    /// embedded in the buffer, the Unicode “unknown” character 0xFFFC
    /// is returned. If invoked on the end iterator, zero is returned;
    /// zero is not a valid Unicode character.
    ///
    /// So you can write a loop which ends when this function returns 0.
    ///
    /// # Returns
    ///
    /// a Unicode character, or 0 if @self is not dereferenceable
    #[doc(alias = "gtk_text_iter_get_char")]
    #[doc(alias = "get_char")]
    pub fn char(&self) -> char {
        unsafe {
            std::convert::TryFrom::try_from(ffi::gtk_text_iter_get_char(self.to_glib_none().0))
                .expect("conversion from an invalid Unicode value attempted")
        }
    }

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

    /// 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) -> 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 paintable, the paintable is returned.
    ///
    /// Otherwise, [`None`] is returned.
    ///
    /// # Returns
    ///
    /// the paintable at @self
    #[doc(alias = "gtk_text_iter_get_paintable")]
    #[doc(alias = "get_paintable")]
    pub fn paintable(&self) -> Option<gdk::Paintable> {
        unsafe { from_glib_none(ffi::gtk_text_iter_get_paintable(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 paintable 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) -> 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.
    ///
    /// The highest-priority tags are last.
    ///
    /// The [`TextTag`][crate::TextTag]s 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) -> 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) }
    }

    /// Returns visible text in the given range.
    ///
    /// 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) -> glib::GString {
        unsafe {
            from_glib_full(ffi::gtk_text_iter_get_visible_slice(
                self.to_glib_none().0,
                end.to_glib_none().0,
            ))
        }
    }

    /// Returns visible text in the given range.
    ///
    /// 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) -> 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.
    ///
    /// # 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.
    ///
    /// 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)) }
    }

    /// Determine if @self is at a cursor position.
    ///
    /// See [`forward_cursor_position()`][Self::forward_cursor_position()] or
    /// `Pango::LogAttr` or `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.
    ///
    /// This means it is 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.
    ///
    /// # 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 or equal to 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.
    ///
    /// This is the case 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.
    ///
    /// # 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 this function 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
    /// this function returns [`true`], [`has_tag()`][Self::has_tag()]
    /// will also return [`true`] for the same parameters.
    /// ## `tag`
    /// a [`TextTag`][crate::TextTag]
    ///
    /// # 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.
    ///
    /// # 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)) }
    }

    /// Gets whether a range with @tag applied to it begins
    /// or ends at @self.
    ///
    /// This is equivalent to (gtk_text_iter_starts_tag() ||
    /// gtk_text_iter_ends_tag())
    /// ## `tag`
    /// a [`TextTag`][crate::TextTag]
    ///
    /// # 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 {}