// 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, LayoutLine, LayoutRun, Rectangle};
use glib::translate::*;

glib::wrapper! {
    /// A [`LayoutIter`][crate::LayoutIter] can be used to iterate over the visual
    /// extents of a [`Layout`][crate::Layout].
    ///
    /// To obtain a [`LayoutIter`][crate::LayoutIter], use [`Layout::iter()`][crate::Layout::iter()].
    ///
    /// 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.
    ///
    /// Layout coordinates have the origin at the 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.
    ///
    /// Layout coordinates have the origin at 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.
    ///
    /// Layout coordinates have the origin at the top left of the entire layout.
    ///
    /// # Returns
    ///
    ///
    /// ## `ink_rect`
    /// rectangle to fill with ink extents
    ///
    /// ## `logical_rect`
    /// rectangle to fill with logical extents
    #[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.
    ///
    /// # Returns
    ///
    ///
    /// ## `ink_rect`
    /// rectangle to fill with ink extents
    ///
    /// ## `logical_rect`
    /// rectangle to fill with logical extents
    #[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.
    ///
    /// 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
    ///
    /// ## `logical_rect`
    /// rectangle to fill with logical extents
    #[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
    ///
    /// ## `y1_`
    /// end of line
    #[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_ = std::mem::MaybeUninit::uninit();
            let mut y1_ = std::mem::MaybeUninit::uninit();
            ffi::pango_layout_iter_get_line_yrange(
                self.to_glib_none_mut().0,
                y0_.as_mut_ptr(),
                y1_.as_mut_ptr(),
            );
            (y0_.assume_init(), y1_.assume_init())
        }
    }

    /// 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 Y position of the current run's baseline, in layout
    /// coordinates.
    ///
    /// Layout coordinates have the origin at the top left of the entire layout.
    ///
    /// The run baseline can be different from the line baseline, for
    /// example due to superscript or subscript positioning.
    #[cfg(feature = "v1_50")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_50")))]
    #[doc(alias = "pango_layout_iter_get_run_baseline")]
    #[doc(alias = "get_run_baseline")]
    pub fn run_baseline(&mut self) -> i32 {
        unsafe { ffi::pango_layout_iter_get_run_baseline(self.to_glib_none_mut().0) }
    }

    /// Gets the extents of the current run in layout coordinates.
    ///
    /// Layout coordinates have the origin at the top left of the entire layout.
    ///
    /// # Returns
    ///
    ///
    /// ## `ink_rect`
    /// rectangle to fill with ink extents
    ///
    /// ## `logical_rect`
    /// rectangle to fill with logical extents
    #[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 for read-only access.
    ///
    /// 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)) }
    }
}