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

use crate::Layout;
use crate::LayoutLine;
use crate::LayoutRun;
use crate::Rectangle;
use glib::translate::*;
use std::mem;

glib::wrapper! {
    /// A [`LayoutIter`][crate::LayoutIter] structure can be used to
    /// iterate over the visual extents of a [`Layout`][crate::Layout].
    ///
    /// The [`LayoutIter`][crate::LayoutIter] structure is opaque, and
    /// has no user-visible fields.
    #[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
    pub struct LayoutIter(Boxed<ffi::PangoLayoutIter>);

    match fn {
        copy => |ptr| ffi::pango_layout_iter_copy(mut_override(ptr)),
        free => |ptr| ffi::pango_layout_iter_free(ptr),
        type_ => || ffi::pango_layout_iter_get_type(),
    }
}

impl LayoutIter {
    /// Determines whether `self` is on the last line of the layout.
    ///
    /// # Returns
    ///
    /// [`true`] if `self` is on the last line.
    #[doc(alias = "pango_layout_iter_at_last_line")]
    pub fn at_last_line(&mut self) -> bool {
        unsafe {
            from_glib(ffi::pango_layout_iter_at_last_line(
                self.to_glib_none_mut().0,
            ))
        }
    }

    /// Gets the Y position of the current line's baseline, in layout
    /// coordinates (origin at top left of the entire layout).
    ///
    /// # Returns
    ///
    /// baseline of current line.
    #[doc(alias = "pango_layout_iter_get_baseline")]
    #[doc(alias = "get_baseline")]
    pub fn baseline(&mut self) -> i32 {
        unsafe { ffi::pango_layout_iter_get_baseline(self.to_glib_none_mut().0) }
    }

    /// Gets the extents of the current character, in layout coordinates
    /// (origin is the top left of the entire layout). Only logical extents
    /// can sensibly be obtained for characters; ink extents make sense only
    /// down to the level of clusters.
    ///
    /// # Returns
    ///
    ///
    /// ## `logical_rect`
    /// rectangle to fill with
    ///  logical extents
    #[doc(alias = "pango_layout_iter_get_char_extents")]
    #[doc(alias = "get_char_extents")]
    pub fn char_extents(&mut self) -> Rectangle {
        unsafe {
            let mut logical_rect = Rectangle::uninitialized();
            ffi::pango_layout_iter_get_char_extents(
                self.to_glib_none_mut().0,
                logical_rect.to_glib_none_mut().0,
            );
            logical_rect
        }
    }

    /// Gets the extents of the current cluster, in layout coordinates
    /// (origin is the top left of the entire layout).
    ///
    /// # Returns
    ///
    ///
    /// ## `ink_rect`
    /// rectangle to fill with ink extents, or [`None`]
    ///
    /// ## `logical_rect`
    /// rectangle to fill with logical extents, or [`None`]
    #[doc(alias = "pango_layout_iter_get_cluster_extents")]
    #[doc(alias = "get_cluster_extents")]
    pub fn cluster_extents(&mut self) -> (Rectangle, Rectangle) {
        unsafe {
            let mut ink_rect = Rectangle::uninitialized();
            let mut logical_rect = Rectangle::uninitialized();
            ffi::pango_layout_iter_get_cluster_extents(
                self.to_glib_none_mut().0,
                ink_rect.to_glib_none_mut().0,
                logical_rect.to_glib_none_mut().0,
            );
            (ink_rect, logical_rect)
        }
    }

    /// Gets the current byte index. Note that iterating forward by char
    /// moves in visual order, not logical order, so indexes may not be
    /// sequential. Also, the index may be equal to the length of the text
    /// in the layout, if on the [`None`] run (see [`run()`][Self::run()]).
    ///
    /// # Returns
    ///
    /// current byte index.
    #[doc(alias = "pango_layout_iter_get_index")]
    #[doc(alias = "get_index")]
    pub fn index(&mut self) -> i32 {
        unsafe { ffi::pango_layout_iter_get_index(self.to_glib_none_mut().0) }
    }

    /// Gets the layout associated with a [`LayoutIter`][crate::LayoutIter].
    ///
    /// # Returns
    ///
    /// the layout associated with `self`.
    #[doc(alias = "pango_layout_iter_get_layout")]
    #[doc(alias = "get_layout")]
    pub fn layout(&mut self) -> Option<Layout> {
        unsafe { from_glib_none(ffi::pango_layout_iter_get_layout(self.to_glib_none_mut().0)) }
    }

    /// Obtains the extents of the [`Layout`][crate::Layout] being iterated
    /// over. `ink_rect` or `logical_rect` can be [`None`] if you
    /// aren't interested in them.
    ///
    /// # Returns
    ///
    ///
    /// ## `ink_rect`
    /// rectangle to fill with ink extents,
    ///  or [`None`]
    ///
    /// ## `logical_rect`
    /// rectangle to fill with logical
    ///  extents, or [`None`]
    #[doc(alias = "pango_layout_iter_get_layout_extents")]
    #[doc(alias = "get_layout_extents")]
    pub fn layout_extents(&mut self) -> (Rectangle, Rectangle) {
        unsafe {
            let mut ink_rect = Rectangle::uninitialized();
            let mut logical_rect = Rectangle::uninitialized();
            ffi::pango_layout_iter_get_layout_extents(
                self.to_glib_none_mut().0,
                ink_rect.to_glib_none_mut().0,
                logical_rect.to_glib_none_mut().0,
            );
            (ink_rect, logical_rect)
        }
    }

    /// Gets the current line.
    ///
    /// Use the faster [`line_readonly()`][Self::line_readonly()] if you do not plan
    /// to modify the contents of the line (glyphs, glyph widths, etc.).
    ///
    /// # Returns
    ///
    /// the current line.
    #[doc(alias = "pango_layout_iter_get_line")]
    #[doc(alias = "get_line")]
    pub fn line(&mut self) -> Option<LayoutLine> {
        unsafe { from_glib_none(ffi::pango_layout_iter_get_line(self.to_glib_none_mut().0)) }
    }

    /// Obtains the extents of the current line. `ink_rect` or `logical_rect`
    /// can be [`None`] if you aren't interested in them. Extents are in layout
    /// coordinates (origin is the top-left corner of the entire
    /// [`Layout`][crate::Layout]). Thus the extents returned by this function will be
    /// the same width/height but not at the same x/y as the extents
    /// returned from [`LayoutLine::extents()`][crate::LayoutLine::extents()].
    ///
    /// # Returns
    ///
    ///
    /// ## `ink_rect`
    /// rectangle to fill with ink extents, or [`None`]
    ///
    /// ## `logical_rect`
    /// rectangle to fill with logical extents, or [`None`]
    #[doc(alias = "pango_layout_iter_get_line_extents")]
    #[doc(alias = "get_line_extents")]
    pub fn line_extents(&mut self) -> (Rectangle, Rectangle) {
        unsafe {
            let mut ink_rect = Rectangle::uninitialized();
            let mut logical_rect = Rectangle::uninitialized();
            ffi::pango_layout_iter_get_line_extents(
                self.to_glib_none_mut().0,
                ink_rect.to_glib_none_mut().0,
                logical_rect.to_glib_none_mut().0,
            );
            (ink_rect, logical_rect)
        }
    }

    /// Gets the current line for read-only access.
    ///
    /// This is a faster alternative to [`line()`][Self::line()],
    /// but the user is not expected
    /// to modify the contents of the line (glyphs, glyph widths, etc.).
    ///
    /// # Returns
    ///
    /// the current line, that should not be
    /// modified.
    #[doc(alias = "pango_layout_iter_get_line_readonly")]
    #[doc(alias = "get_line_readonly")]
    pub fn line_readonly(&mut self) -> Option<LayoutLine> {
        unsafe {
            from_glib_none(ffi::pango_layout_iter_get_line_readonly(
                self.to_glib_none_mut().0,
            ))
        }
    }

    /// Divides the vertical space in the [`Layout`][crate::Layout] being iterated over
    /// between the lines in the layout, and returns the space belonging to
    /// the current line. A line's range includes the line's logical
    /// extents, plus half of the spacing above and below the line, if
    /// [`Layout::set_spacing()`][crate::Layout::set_spacing()] has been called to set layout spacing.
    /// The Y positions are in layout coordinates (origin at top left of the
    /// entire layout).
    ///
    /// Note: Since 1.44, Pango uses line heights for placing lines,
    /// and there may be gaps between the ranges returned by this
    /// function.
    ///
    /// # Returns
    ///
    ///
    /// ## `y0_`
    /// start of line, or [`None`]
    ///
    /// ## `y1_`
    /// end of line, or [`None`]
    #[doc(alias = "pango_layout_iter_get_line_yrange")]
    #[doc(alias = "get_line_yrange")]
    pub fn line_yrange(&mut self) -> (i32, i32) {
        unsafe {
            let mut y0_ = mem::MaybeUninit::uninit();
            let mut y1_ = mem::MaybeUninit::uninit();
            ffi::pango_layout_iter_get_line_yrange(
                self.to_glib_none_mut().0,
                y0_.as_mut_ptr(),
                y1_.as_mut_ptr(),
            );
            let y0_ = y0_.assume_init();
            let y1_ = y1_.assume_init();
            (y0_, y1_)
        }
    }

    /// Gets the current run. When iterating by run, at the end of each
    /// line, there's a position with a [`None`] run, so this function can return
    /// [`None`]. The [`None`] run at the end of each line ensures that all lines have
    /// at least one run, even lines consisting of only a newline.
    ///
    /// Use the faster [`run_readonly()`][Self::run_readonly()] if you do not plan
    /// to modify the contents of the run (glyphs, glyph widths, etc.).
    ///
    /// # Returns
    ///
    /// the current run.
    #[doc(alias = "pango_layout_iter_get_run")]
    #[doc(alias = "get_run")]
    pub fn run(&mut self) -> Option<LayoutRun> {
        unsafe { from_glib_none(ffi::pango_layout_iter_get_run(self.to_glib_none_mut().0)) }
    }

    /// Gets the extents of the current run in layout coordinates
    /// (origin is the top left of the entire layout).
    ///
    /// # Returns
    ///
    ///
    /// ## `ink_rect`
    /// rectangle to fill with ink extents, or [`None`]
    ///
    /// ## `logical_rect`
    /// rectangle to fill with logical extents, or [`None`]
    #[doc(alias = "pango_layout_iter_get_run_extents")]
    #[doc(alias = "get_run_extents")]
    pub fn run_extents(&mut self) -> (Rectangle, Rectangle) {
        unsafe {
            let mut ink_rect = Rectangle::uninitialized();
            let mut logical_rect = Rectangle::uninitialized();
            ffi::pango_layout_iter_get_run_extents(
                self.to_glib_none_mut().0,
                ink_rect.to_glib_none_mut().0,
                logical_rect.to_glib_none_mut().0,
            );
            (ink_rect, logical_rect)
        }
    }

    /// Gets the current run. When iterating by run, at the end of each
    /// line, there's a position with a [`None`] run, so this function can return
    /// [`None`]. The [`None`] run at the end of each line ensures that all lines have
    /// at least one run, even lines consisting of only a newline.
    ///
    /// This is a faster alternative to [`run()`][Self::run()],
    /// but the user is not expected
    /// to modify the contents of the run (glyphs, glyph widths, etc.).
    ///
    /// # Returns
    ///
    /// the current run, that
    /// should not be modified.
    #[doc(alias = "pango_layout_iter_get_run_readonly")]
    #[doc(alias = "get_run_readonly")]
    pub fn run_readonly(&mut self) -> Option<LayoutRun> {
        unsafe {
            from_glib_none(ffi::pango_layout_iter_get_run_readonly(
                self.to_glib_none_mut().0,
            ))
        }
    }

    /// Moves `self` forward to the next character in visual order. If `self` was already at
    /// the end of the layout, returns [`false`].
    ///
    /// # Returns
    ///
    /// whether motion was possible.
    #[doc(alias = "pango_layout_iter_next_char")]
    pub fn next_char(&mut self) -> bool {
        unsafe { from_glib(ffi::pango_layout_iter_next_char(self.to_glib_none_mut().0)) }
    }

    /// Moves `self` forward to the next cluster in visual order. If `self`
    /// was already at the end of the layout, returns [`false`].
    ///
    /// # Returns
    ///
    /// whether motion was possible.
    #[doc(alias = "pango_layout_iter_next_cluster")]
    pub fn next_cluster(&mut self) -> bool {
        unsafe {
            from_glib(ffi::pango_layout_iter_next_cluster(
                self.to_glib_none_mut().0,
            ))
        }
    }

    /// Moves `self` forward to the start of the next line. If `self` is
    /// already on the last line, returns [`false`].
    ///
    /// # Returns
    ///
    /// whether motion was possible.
    #[doc(alias = "pango_layout_iter_next_line")]
    pub fn next_line(&mut self) -> bool {
        unsafe { from_glib(ffi::pango_layout_iter_next_line(self.to_glib_none_mut().0)) }
    }

    /// Moves `self` forward to the next run in visual order. If `self` was
    /// already at the end of the layout, returns [`false`].
    ///
    /// # Returns
    ///
    /// whether motion was possible.
    #[doc(alias = "pango_layout_iter_next_run")]
    pub fn next_run(&mut self) -> bool {
        unsafe { from_glib(ffi::pango_layout_iter_next_run(self.to_glib_none_mut().0)) }
    }
}