// 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 gdk_pixbuf;
use glib::object::IsA;
use glib::translate::*;
use glib::GString;
use gtk_sys;
use pango;
use std::cmp;
use TextBuffer;
use TextChildAnchor;
use TextMark;
use TextSearchFlags;
use TextTag;

glib_wrapper! {
    /// You may wish to begin by reading the
    /// [text widget conceptual overview](https://developer.gnome.org/gtk3/stable/TextWidget.html)
    /// which gives an overview of all the objects and data
    /// types related to the text widget and how they work together.
    #[derive(Debug, Hash)]
    pub struct TextIter(Boxed<gtk_sys::GtkTextIter>);

    match fn {
        copy => |ptr| gtk_sys::gtk_text_iter_copy(mut_override(ptr)),
        free => |ptr| gtk_sys::gtk_text_iter_free(ptr),
        init => |_ptr| (),
        clear => |_ptr| (),
        get_type => || gtk_sys::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`
    pub fn assign(&mut self, other: &TextIter) {
        unsafe {
            gtk_sys::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), `TextIter::backward_char` returns `false` for convenience when
    /// writing loops.
    ///
    /// # Returns
    ///
    /// whether movement was possible
    pub fn backward_char(&mut self) -> bool {
        unsafe {
            from_glib(gtk_sys::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
    pub fn backward_chars(&mut self, count: i32) -> bool {
        unsafe {
            from_glib(gtk_sys::gtk_text_iter_backward_chars(
                self.to_glib_none_mut().0,
                count,
            ))
        }
    }

    /// Like `TextIter::forward_cursor_position`, but moves backward.
    ///
    /// # Returns
    ///
    /// `true` if we moved
    pub fn backward_cursor_position(&mut self) -> bool {
        unsafe {
            from_glib(gtk_sys::gtk_text_iter_backward_cursor_position(
                self.to_glib_none_mut().0,
            ))
        }
    }

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

    /// Same as `TextIter::forward_find_char`, but goes backward from `self`.
    /// ## `pred`
    /// function to be called on each character
    /// ## `user_data`
    /// user data for `pred`
    /// ## `limit`
    /// search limit, or `None` for none
    ///
    /// # Returns
    ///
    /// whether a match was found
    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_sys::gpointer,
        ) -> glib_sys::gboolean {
            let ch = from_glib(ch);
            let callback: *mut P = user_data as *const _ as usize as *mut P;
            let res = (*callback)(ch);
            res.to_glib()
        }
        let pred = Some(pred_func::<P> as _);
        let super_callback0: &P = &pred_data;
        unsafe {
            from_glib(gtk_sys::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
    pub fn backward_line(&mut self) -> bool {
        unsafe {
            from_glib(gtk_sys::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
    pub fn backward_lines(&mut self, count: i32) -> bool {
        unsafe {
            from_glib(gtk_sys::gtk_text_iter_backward_lines(
                self.to_glib_none_mut().0,
                count,
            ))
        }
    }

    /// Same as `TextIter::forward_search`, but moves backward.
    ///
    /// `match_end` will never be set to a `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
    /// ## `match_start`
    /// return location for start of match, or `None`
    /// ## `match_end`
    /// return location for end of match, or `None`
    /// ## `limit`
    /// location of last possible `match_start`, or `None` for start of buffer
    ///
    /// # Returns
    ///
    /// whether a match was found
    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(gtk_sys::gtk_text_iter_backward_search(
                self.to_glib_none().0,
                str.to_glib_none().0,
                flags.to_glib(),
                match_start.to_glib_none_mut().0,
                match_end.to_glib_none_mut().0,
                limit.to_glib_none().0,
            ));
            if ret {
                Some((match_start, match_end))
            } else {
                None
            }
        }
    }

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

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

    /// Moves backward to the next toggle (on or off) of the
    /// `TextTag` `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`, or `None`
    ///
    /// # Returns
    ///
    /// whether we found a tag toggle before `self`
    pub fn backward_to_tag_toggle<P: IsA<TextTag>>(&mut self, tag: Option<&P>) -> bool {
        unsafe {
            from_glib(gtk_sys::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
    /// `TextIter::backward_cursor_position` for details.
    ///
    /// # Returns
    ///
    /// `true` if we moved and the new position is dereferenceable
    pub fn backward_visible_cursor_position(&mut self) -> bool {
        unsafe {
            from_glib(gtk_sys::gtk_text_iter_backward_visible_cursor_position(
                self.to_glib_none_mut().0,
            ))
        }
    }

    /// Moves up to `count` visible cursor positions. See
    /// `TextIter::backward_cursor_position` for details.
    /// ## `count`
    /// number of positions to move
    ///
    /// # Returns
    ///
    /// `true` if we moved and the new position is dereferenceable
    pub fn backward_visible_cursor_positions(&mut self, count: i32) -> bool {
        unsafe {
            from_glib(gtk_sys::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
    pub fn backward_visible_line(&mut self) -> bool {
        unsafe {
            from_glib(gtk_sys::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
    pub fn backward_visible_lines(&mut self, count: i32) -> bool {
        unsafe {
            from_glib(gtk_sys::gtk_text_iter_backward_visible_lines(
                self.to_glib_none_mut().0,
                count,
            ))
        }
    }

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

    /// Calls `TextIter::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
    pub fn backward_visible_word_starts(&mut self, count: i32) -> bool {
        unsafe {
            from_glib(gtk_sys::gtk_text_iter_backward_visible_word_starts(
                self.to_glib_none_mut().0,
                count,
            ))
        }
    }

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

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

    /// 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 `TextIter::begins_tag` returns `true`, it means that `self` is
    /// at the beginning of the tagged range, and that the
    /// character at `self` is inside the tagged range. In other
    /// words, unlike `TextIter::ends_tag`, if `TextIter::begins_tag` returns
    /// `true`, `TextIter::has_tag` will also return `true` for the same
    /// parameters.
    ///
    /// # Deprecated since 3.20
    ///
    /// Use `TextIter::starts_tag` instead.
    /// ## `tag`
    /// a `TextTag`, or `None`
    ///
    /// # Returns
    ///
    /// whether `self` is the start of a range tagged with `tag`
    #[cfg_attr(feature = "v3_20", deprecated)]
    pub fn begins_tag<P: IsA<TextTag>>(&self, tag: Option<&P>) -> bool {
        unsafe {
            from_glib(gtk_sys::gtk_text_iter_begins_tag(
                self.to_glib_none().0,
                tag.map(|p| p.as_ref()).to_glib_none().0,
            ))
        }
    }

    /// 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` 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
    pub fn can_insert(&self, default_editability: bool) -> bool {
        unsafe {
            from_glib(gtk_sys::gtk_text_iter_can_insert(
                self.to_glib_none().0,
                default_editability.to_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`
    ///
    /// # Returns
    ///
    /// -1 if `self` is less than `rhs`, 1 if `self` is greater, 0 if they are equal
    fn compare(&self, rhs: &TextIter) -> i32 {
        unsafe { gtk_sys::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`. This function is simply a convenience
    /// wrapper around `TextIter::get_attributes`. If no tags applied
    /// to this text affect editability, `default_setting` will be returned.
    ///
    /// You don’t want to use this function to decide whether text can be
    /// inserted at `self`, because for insertion you don’t want to know
    /// whether the char at `self` is inside an editable range, you want to
    /// know whether a new character inserted at `self` would be inside an
    /// editable range. Use `TextIter::can_insert` to handle this
    /// case.
    /// ## `default_setting`
    /// `true` if text is editable by default
    ///
    /// # Returns
    ///
    /// whether `self` is inside an editable range
    pub fn editable(&self, default_setting: bool) -> bool {
        unsafe {
            from_glib(gtk_sys::gtk_text_iter_editable(
                self.to_glib_none().0,
                default_setting.to_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
    pub fn ends_line(&self) -> bool {
        unsafe { from_glib(gtk_sys::gtk_text_iter_ends_line(self.to_glib_none().0)) }
    }

    /// Determines whether `self` ends a sentence. Sentence boundaries are
    /// determined by Pango and should be correct for nearly any language
    /// (if not, the correct fix would be to the Pango text boundary
    /// algorithms).
    ///
    /// # Returns
    ///
    /// `true` if `self` is at the end of a sentence.
    pub fn ends_sentence(&self) -> bool {
        unsafe { from_glib(gtk_sys::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 `TextIter::ends_tag` returns `true`, it means that `self` is
    /// at the end of the tagged range, but that the character
    /// at `self` is outside the tagged range. In other words,
    /// unlike `TextIter::starts_tag`, if `TextIter::ends_tag` returns `true`,
    /// `TextIter::has_tag` will return `false` for the same parameters.
    /// ## `tag`
    /// a `TextTag`, or `None`
    ///
    /// # Returns
    ///
    /// whether `self` is the end of a range tagged with `tag`
    pub fn ends_tag<P: IsA<TextTag>>(&self, tag: Option<&P>) -> bool {
        unsafe {
            from_glib(gtk_sys::gtk_text_iter_ends_tag(
                self.to_glib_none().0,
                tag.map(|p| p.as_ref()).to_glib_none().0,
            ))
        }
    }

    /// Determines whether `self` ends a natural-language word. Word breaks
    /// are determined by Pango and should be correct for nearly any
    /// language (if not, the correct fix would be to the Pango word break
    /// algorithms).
    ///
    /// # Returns
    ///
    /// `true` if `self` is at the end of a word
    pub fn ends_word(&self) -> bool {
        unsafe { from_glib(gtk_sys::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
    /// `TextIter::compare`.
    /// ## `rhs`
    /// another `TextIter`
    ///
    /// # Returns
    ///
    /// `true` if the iterators point to the same place in the buffer
    fn equal(&self, rhs: &TextIter) -> bool {
        unsafe {
            from_glib(gtk_sys::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
    /// `TextIter::forward_char` may actually move onto an image instead
    /// of a character, if you have images in your buffer. If `self` is the
    /// end iterator or one character before it, `self` will now point at
    /// the end iterator, and `TextIter::forward_char` returns `false` for
    /// convenience when writing loops.
    ///
    /// # Returns
    ///
    /// whether `self` moved and is dereferenceable
    pub fn forward_char(&mut self) -> bool {
        unsafe {
            from_glib(gtk_sys::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
    pub fn forward_chars(&mut self, count: i32) -> bool {
        unsafe {
            from_glib(gtk_sys::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
    /// `pango_break` function.
    ///
    /// # Returns
    ///
    /// `true` if we moved and the new position is dereferenceable
    pub fn forward_cursor_position(&mut self) -> bool {
        unsafe {
            from_glib(gtk_sys::gtk_text_iter_forward_cursor_position(
                self.to_glib_none_mut().0,
            ))
        }
    }

    /// Moves up to `count` cursor positions. See
    /// `TextIter::forward_cursor_position` for details.
    /// ## `count`
    /// number of positions to move
    ///
    /// # Returns
    ///
    /// `true` if we moved and the new position is dereferenceable
    pub fn forward_cursor_positions(&mut self, count: i32) -> bool {
        unsafe {
            from_glib(gtk_sys::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
    /// ## `user_data`
    /// user data for `pred`
    /// ## `limit`
    /// search limit, or `None` for none
    ///
    /// # Returns
    ///
    /// whether a match was found
    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_sys::gpointer,
        ) -> glib_sys::gboolean {
            let ch = from_glib(ch);
            let callback: *mut P = user_data as *const _ as usize as *mut P;
            let res = (*callback)(ch);
            res.to_glib()
        }
        let pred = Some(pred_func::<P> as _);
        let super_callback0: &P = &pred_data;
        unsafe {
            from_glib(gtk_sys::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
    /// dereferencable, returns `false`. Otherwise, returns `true`.
    ///
    /// # Returns
    ///
    /// whether `self` can be dereferenced
    pub fn forward_line(&mut self) -> bool {
        unsafe {
            from_glib(gtk_sys::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
    pub fn forward_lines(&mut self, count: i32) -> bool {
        unsafe {
            from_glib(gtk_sys::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` 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
    /// ## `match_start`
    /// return location for start of match, or `None`
    /// ## `match_end`
    /// return location for end of match, or `None`
    /// ## `limit`
    /// location of last possible `match_end`, or `None` for the end of the buffer
    ///
    /// # Returns
    ///
    /// whether a match was found
    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(gtk_sys::gtk_text_iter_forward_search(
                self.to_glib_none().0,
                str.to_glib_none().0,
                flags.to_glib(),
                match_start.to_glib_none_mut().0,
                match_end.to_glib_none_mut().0,
                limit.to_glib_none().0,
            ));
            if ret {
                Some((match_start, match_end))
            } else {
                None
            }
        }
    }

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

    /// Calls `TextIter::forward_sentence_end` `count` times (or until
    /// `TextIter::forward_sentence_end` returns `false`). If `count` is
    /// negative, moves backward instead of forward.
    /// ## `count`
    /// number of sentences to move
    ///
    /// # Returns
    ///
    /// `true` if `self` moved and is not the end iterator
    pub fn forward_sentence_ends(&mut self, count: i32) -> bool {
        unsafe {
            from_glib(gtk_sys::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. `TextIter::get_char` called on the
    /// end iterator returns 0, which is convenient for writing loops.
    pub fn forward_to_end(&mut self) {
        unsafe {
            gtk_sys::gtk_text_iter_forward_to_end(self.to_glib_none_mut().0);
        }
    }

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

    /// Moves forward to the next toggle (on or off) of the
    /// `TextTag` `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`, or `None`
    ///
    /// # Returns
    ///
    /// whether we found a tag toggle after `self`
    pub fn forward_to_tag_toggle<P: IsA<TextTag>>(&mut self, tag: Option<&P>) -> bool {
        unsafe {
            from_glib(gtk_sys::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
    /// `TextIter::forward_cursor_position` for details.
    ///
    /// # Returns
    ///
    /// `true` if we moved and the new position is dereferenceable
    pub fn forward_visible_cursor_position(&mut self) -> bool {
        unsafe {
            from_glib(gtk_sys::gtk_text_iter_forward_visible_cursor_position(
                self.to_glib_none_mut().0,
            ))
        }
    }

    /// Moves up to `count` visible cursor positions. See
    /// `TextIter::forward_cursor_position` for details.
    /// ## `count`
    /// number of positions to move
    ///
    /// # Returns
    ///
    /// `true` if we moved and the new position is dereferenceable
    pub fn forward_visible_cursor_positions(&mut self, count: i32) -> bool {
        unsafe {
            from_glib(gtk_sys::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
    pub fn forward_visible_line(&mut self) -> bool {
        unsafe {
            from_glib(gtk_sys::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
    pub fn forward_visible_lines(&mut self, count: i32) -> bool {
        unsafe {
            from_glib(gtk_sys::gtk_text_iter_forward_visible_lines(
                self.to_glib_none_mut().0,
                count,
            ))
        }
    }

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

    /// Calls `TextIter::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
    pub fn forward_visible_word_ends(&mut self, count: i32) -> bool {
        unsafe {
            from_glib(gtk_sys::gtk_text_iter_forward_visible_word_ends(
                self.to_glib_none_mut().0,
                count,
            ))
        }
    }

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

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

    /// Returns the `TextBuffer` this iterator is associated with.
    ///
    /// # Returns
    ///
    /// the buffer
    pub fn get_buffer(&self) -> Option<TextBuffer> {
        unsafe { from_glib_none(gtk_sys::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
    pub fn get_bytes_in_line(&self) -> i32 {
        unsafe { gtk_sys::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 `TextIter::get_char`
    /// returns 0.
    ///
    /// # Returns
    ///
    /// a Unicode character, or 0 if `self` is not dereferenceable
    pub fn get_char(&self) -> Option<char> {
        unsafe { from_glib(gtk_sys::gtk_text_iter_get_char(self.to_glib_none().0)) }
    }

    /// Returns the number of characters in the line containing `self`,
    /// including the paragraph delimiters.
    ///
    /// # Returns
    ///
    /// number of characters in the line
    pub fn get_chars_in_line(&self) -> i32 {
        unsafe { gtk_sys::gtk_text_iter_get_chars_in_line(self.to_glib_none().0) }
    }

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

    /// A convenience wrapper around `TextIter::get_attributes`,
    /// which returns the language in effect at `self`. If no tags affecting
    /// language apply to `self`, the return value is identical to that of
    /// `gtk_get_default_language`.
    ///
    /// # Returns
    ///
    /// language in effect at `self`
    pub fn get_language(&self) -> Option<pango::Language> {
        unsafe { from_glib_full(gtk_sys::gtk_text_iter_get_language(self.to_glib_none().0)) }
    }

    /// Returns the line number containing the iterator. Lines in
    /// a `TextBuffer` are numbered beginning with 0 for the first
    /// line in the buffer.
    ///
    /// # Returns
    ///
    /// a line number
    pub fn get_line(&self) -> i32 {
        unsafe { gtk_sys::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` 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
    pub fn get_line_index(&self) -> i32 {
        unsafe { gtk_sys::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
    pub fn get_line_offset(&self) -> i32 {
        unsafe { gtk_sys::gtk_text_iter_get_line_offset(self.to_glib_none().0) }
    }

    /// Returns a list of all `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`
    pub fn get_marks(&self) -> Vec<TextMark> {
        unsafe {
            FromGlibPtrContainer::from_glib_container(gtk_sys::gtk_text_iter_get_marks(
                self.to_glib_none().0,
            ))
        }
    }

    /// Returns the character offset of an iterator.
    /// Each character in a `TextBuffer` has an offset,
    /// starting with 0 for the first character in the buffer.
    /// Use `TextBufferExt::get_iter_at_offset` to convert an
    /// offset back into an iterator.
    ///
    /// # Returns
    ///
    /// a character offset
    pub fn get_offset(&self) -> i32 {
        unsafe { gtk_sys::gtk_text_iter_get_offset(self.to_glib_none().0) }
    }

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

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

    /// Returns a list of tags that apply to `self`, in ascending order of
    /// priority (highest-priority tags are last). The `TextTag` in the
    /// list don’t have a reference added, but you have to free the list
    /// itself.
    ///
    /// # Returns
    ///
    /// list of `TextTag`
    pub fn get_tags(&self) -> Vec<TextTag> {
        unsafe {
            FromGlibPtrContainer::from_glib_container(gtk_sys::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
    /// `TextIter::get_slice`.
    /// ## `end`
    /// iterator at end of a range
    ///
    /// # Returns
    ///
    /// array of characters from the buffer
    pub fn get_text(&self, end: &TextIter) -> Option<GString> {
        unsafe {
            from_glib_full(gtk_sys::gtk_text_iter_get_text(
                self.to_glib_none().0,
                end.to_glib_none().0,
            ))
        }
    }

    /// Returns a list of `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
    pub fn get_toggled_tags(&self, toggled_on: bool) -> Vec<TextTag> {
        unsafe {
            FromGlibPtrContainer::from_glib_container(gtk_sys::gtk_text_iter_get_toggled_tags(
                self.to_glib_none().0,
                toggled_on.to_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
    pub fn get_visible_line_index(&self) -> i32 {
        unsafe { gtk_sys::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
    pub fn get_visible_line_offset(&self) -> i32 {
        unsafe { gtk_sys::gtk_text_iter_get_visible_line_offset(self.to_glib_none().0) }
    }

    /// Like `TextIter::get_slice`, but invisible text is not included.
    /// Invisible text is usually invisible because a `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
    pub fn get_visible_slice(&self, end: &TextIter) -> Option<GString> {
        unsafe {
            from_glib_full(gtk_sys::gtk_text_iter_get_visible_slice(
                self.to_glib_none().0,
                end.to_glib_none().0,
            ))
        }
    }

    /// Like `TextIter::get_text`, but invisible text is not included.
    /// Invisible text is usually invisible because a `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
    pub fn get_visible_text(&self, end: &TextIter) -> Option<GString> {
        unsafe {
            from_glib_full(gtk_sys::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 `TextIter::starts_tag` and `TextIter::ends_tag`.
    /// ## `tag`
    /// a `TextTag`
    ///
    /// # Returns
    ///
    /// whether `self` is tagged with `tag`
    pub fn has_tag<P: IsA<TextTag>>(&self, tag: &P) -> bool {
        unsafe {
            from_glib(gtk_sys::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
    pub fn in_range(&self, start: &TextIter, end: &TextIter) -> bool {
        unsafe {
            from_glib(gtk_sys::gtk_text_iter_in_range(
                self.to_glib_none().0,
                start.to_glib_none().0,
                end.to_glib_none().0,
            ))
        }
    }

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

    /// Determines whether the character pointed by `self` is part of a
    /// natural-language word (as opposed to say inside some whitespace). Word
    /// breaks are determined by Pango and should be correct for nearly any language
    /// (if not, the correct fix would be to the Pango word break algorithms).
    ///
    /// Note that if `TextIter::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
    pub fn inside_word(&self) -> bool {
        unsafe { from_glib(gtk_sys::gtk_text_iter_inside_word(self.to_glib_none().0)) }
    }

    /// See `TextIter::forward_cursor_position` or `pango::LogAttr` or
    /// `pango_break` for details on what a cursor position is.
    ///
    /// # Returns
    ///
    /// `true` if the cursor can be placed at `self`
    pub fn is_cursor_position(&self) -> bool {
        unsafe {
            from_glib(gtk_sys::gtk_text_iter_is_cursor_position(
                self.to_glib_none().0,
            ))
        }
    }

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

    /// Returns `true` if `self` is the first iterator in the buffer, that is
    /// if `self` has a character offset of 0.
    ///
    /// # Returns
    ///
    /// whether `self` is the first in the buffer
    pub fn is_start(&self) -> bool {
        unsafe { from_glib(gtk_sys::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 `TextIter::in_range`,
    /// that expect a pre-sorted range.
    /// ## `second`
    /// another `TextIter`
    pub fn order(&mut self, second: &mut TextIter) {
        unsafe {
            gtk_sys::gtk_text_iter_order(self.to_glib_none_mut().0, second.to_glib_none_mut().0);
        }
    }

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

    /// Same as `TextIter::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
    pub fn set_line_index(&mut self, byte_on_line: i32) {
        unsafe {
            gtk_sys::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
    /// `TextIter::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
    pub fn set_line_offset(&mut self, char_on_line: i32) {
        unsafe {
            gtk_sys::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
    pub fn set_offset(&mut self, char_offset: i32) {
        unsafe {
            gtk_sys::gtk_text_iter_set_offset(self.to_glib_none_mut().0, char_offset);
        }
    }

    /// Like `TextIter::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
    pub fn set_visible_line_index(&mut self, byte_on_line: i32) {
        unsafe {
            gtk_sys::gtk_text_iter_set_visible_line_index(self.to_glib_none_mut().0, byte_on_line);
        }
    }

    /// Like `TextIter::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
    pub fn set_visible_line_offset(&mut self, char_on_line: i32) {
        unsafe {
            gtk_sys::gtk_text_iter_set_visible_line_offset(self.to_glib_none_mut().0, char_on_line);
        }
    }

    /// Returns `true` if `self` begins a paragraph,
    /// i.e. if `TextIter::get_line_offset` would return 0.
    /// However this function is potentially more efficient than
    /// `TextIter::get_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
    pub fn starts_line(&self) -> bool {
        unsafe { from_glib(gtk_sys::gtk_text_iter_starts_line(self.to_glib_none().0)) }
    }

    /// Determines whether `self` begins a sentence. Sentence boundaries are
    /// determined by Pango and should be correct for nearly any language
    /// (if not, the correct fix would be to the Pango text boundary
    /// algorithms).
    ///
    /// # Returns
    ///
    /// `true` if `self` is at the start of a sentence.
    pub fn starts_sentence(&self) -> bool {
        unsafe {
            from_glib(gtk_sys::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 `TextIter::starts_tag` returns `true`, it means that `self` is
    /// at the beginning of the tagged range, and that the
    /// character at `self` is inside the tagged range. In other
    /// words, unlike `TextIter::ends_tag`, if `TextIter::starts_tag` returns
    /// `true`, `TextIter::has_tag` will also return `true` for the same
    /// parameters.
    ///
    /// Feature: `v3_20`
    ///
    /// ## `tag`
    /// a `TextTag`, or `None`
    ///
    /// # Returns
    ///
    /// whether `self` is the start of a range tagged with `tag`
    #[cfg(any(feature = "v3_20", feature = "dox"))]
    pub fn starts_tag<P: IsA<TextTag>>(&self, tag: Option<&P>) -> bool {
        unsafe {
            from_glib(gtk_sys::gtk_text_iter_starts_tag(
                self.to_glib_none().0,
                tag.map(|p| p.as_ref()).to_glib_none().0,
            ))
        }
    }

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

    /// This is equivalent to (`TextIter::starts_tag` ||
    /// `TextIter::ends_tag`), i.e. it tells you whether a range with
    /// `tag` applied to it begins or ends at `self`.
    /// ## `tag`
    /// a `TextTag`, or `None`
    ///
    /// # Returns
    ///
    /// whether `tag` is toggled on or off at `self`
    pub fn toggles_tag<P: IsA<TextTag>>(&self, tag: Option<&P>) -> bool {
        unsafe {
            from_glib(gtk_sys::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 {}