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

use crate::TextBuffer;
use crate::TextChildAnchor;
use crate::TextMark;
use crate::TextSearchFlags;
use crate::TextTag;
use glib::object::IsA;
use glib::translate::*;
use std::cmp;

glib::wrapper! {
    /// An iterator for 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, Hash)]
    pub struct TextIter(Boxed<ffi::GtkTextIter>);

    match fn {
        copy => |ptr| ffi::gtk_text_iter_copy(ptr),
        free => |ptr| ffi::gtk_text_iter_free(ptr),
        init => |_ptr| (),
        clear => |_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 pred_data: P = pred;
        unsafe extern "C" fn pred_func<P: FnMut(char) -> bool>(
            ch: u32,
            user_data: glib::ffi::gpointer,
        ) -> glib::ffi::gboolean {
            let ch = std::convert::TryFrom::try_from(ch)
                .expect("conversion from an invalid Unicode value attempted");
            let callback: *mut P = user_data as *const _ as usize as *mut P;
            let res = (*callback)(ch);
            res.into_glib()
        }
        let pred = Some(pred_func::<P> as _);
        let super_callback0: &P = &pred_data;
        unsafe {
            from_glib(ffi::gtk_text_iter_backward_find_char(
                self.to_glib_none_mut().0,
                pred,
                super_callback0 as *const _ as usize 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<P: IsA<TextTag>>(&mut self, tag: Option<&P>) -> 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.
    ///
    /// # 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(),
            ))
        }
    }

    /// A `qsort()`-style function that returns negative if `self` is less than
    /// `rhs`, positive if `self` is greater than `rhs`, and 0 if they’re equal.
    ///
    /// Ordering is in character offset order, i.e. the first character
    /// in the buffer is less than the second character in the buffer.
    /// ## `rhs`
    /// another [`TextIter`][crate::TextIter]
    ///
    /// # Returns
    ///
    /// -1 if `self` is less than `rhs`, 1 if `self` is greater, 0 if they are equal
    #[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<P: IsA<TextTag>>(&self, tag: Option<&P>) -> 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)) }
    }

    /// Tests whether two iterators are equal, using the fastest possible
    /// mechanism.
    ///
    /// This function is very fast; you can expect it to perform
    /// better than e.g. getting the character offset for each
    /// iterator and comparing the offsets yourself. Also, it’s a
    /// bit faster than `Gtk::`TextIter::compare()``.
    /// ## `rhs`
    /// another [`TextIter`][crate::TextIter]
    ///
    /// # Returns
    ///
    /// [`true`] if the iterators point to the same place in the buffer
    #[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 pred_data: P = pred;
        unsafe extern "C" fn pred_func<P: FnMut(char) -> bool>(
            ch: u32,
            user_data: glib::ffi::gpointer,
        ) -> glib::ffi::gboolean {
            let ch = std::convert::TryFrom::try_from(ch)
                .expect("conversion from an invalid Unicode value attempted");
            let callback: *mut P = user_data as *const _ as usize as *mut P;
            let res = (*callback)(ch);
            res.into_glib()
        }
        let pred = Some(pred_func::<P> as _);
        let super_callback0: &P = &pred_data;
        unsafe {
            from_glib(ffi::gtk_text_iter_forward_find_char(
                self.to_glib_none_mut().0,
                pred,
                super_callback0 as *const _ as usize 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<P: IsA<TextTag>>(&mut self, tag: Option<&P>) -> 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) -> 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) }
    }

    /// 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 [method`Gtk`,TextBuffer.get_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) -> 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.
    ///
    /// 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) -> 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) }
    }

    /// 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) -> Option<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) -> 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<P: IsA<TextTag>>(&self, tag: &P) -> 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<P: IsA<TextTag>>(&self, tag: Option<&P>) -> 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 ([`starts_tag()`][Self::starts_tag()] ||
    /// [`ends_tag()`][Self::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<P: IsA<TextTag>>(&self, tag: Option<&P>) -> 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<cmp::Ordering> {
        self.compare(other).partial_cmp(&0)
    }
}

impl Ord for TextIter {
    #[inline]
    fn cmp(&self, other: &Self) -> 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 {}