gsk4/auto/

stroke.rs

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

use crate::{ffi, LineCap, LineJoin};
use glib::translate::*;

glib::wrapper! {
    /// Collects the parameters that influence the operation of stroking a path.
    #[derive(Debug, PartialOrd, Ord, Hash)]
    pub struct Stroke(Boxed<ffi::GskStroke>);

    match fn {
        copy => |ptr| ffi::gsk_stroke_copy(ptr),
        free => |ptr| ffi::gsk_stroke_free(ptr),
        type_ => || ffi::gsk_stroke_get_type(),
    }
}

impl Stroke {
    /// Creates a new [`Stroke`][crate::Stroke] with the given @line_width.
    /// ## `line_width`
    /// line width of the stroke. Must be > 0
    ///
    /// # Returns
    ///
    /// a new [`Stroke`][crate::Stroke]
    #[doc(alias = "gsk_stroke_new")]
    pub fn new(line_width: f32) -> Stroke {
        assert_initialized_main_thread!();
        unsafe { from_glib_full(ffi::gsk_stroke_new(line_width)) }
    }

    /// Gets the dash array in use.
    ///
    /// # Returns
    ///
    ///
    ///   the dash array or `NULL` if the dash array is empty
    #[doc(alias = "gsk_stroke_get_dash")]
    #[doc(alias = "get_dash")]
    pub fn dash(&self) -> Vec<f32> {
        unsafe {
            let mut n_dash = std::mem::MaybeUninit::uninit();
            let ret = FromGlibContainer::from_glib_none_num(
                ffi::gsk_stroke_get_dash(self.to_glib_none().0, n_dash.as_mut_ptr()),
                n_dash.assume_init() as _,
            );
            ret
        }
    }

    /// Gets the dash offset.
    ///
    /// # Returns
    ///
    /// the dash offset
    #[doc(alias = "gsk_stroke_get_dash_offset")]
    #[doc(alias = "get_dash_offset")]
    pub fn dash_offset(&self) -> f32 {
        unsafe { ffi::gsk_stroke_get_dash_offset(self.to_glib_none().0) }
    }

    /// Gets the line cap used.
    ///
    /// See [`LineCap`][crate::LineCap] for details.
    ///
    /// # Returns
    ///
    /// the line cap
    #[doc(alias = "gsk_stroke_get_line_cap")]
    #[doc(alias = "get_line_cap")]
    pub fn line_cap(&self) -> LineCap {
        unsafe { from_glib(ffi::gsk_stroke_get_line_cap(self.to_glib_none().0)) }
    }

    /// Gets the line join used.
    ///
    /// See [`LineJoin`][crate::LineJoin] for details.
    ///
    /// # Returns
    ///
    /// the line join
    #[doc(alias = "gsk_stroke_get_line_join")]
    #[doc(alias = "get_line_join")]
    pub fn line_join(&self) -> LineJoin {
        unsafe { from_glib(ffi::gsk_stroke_get_line_join(self.to_glib_none().0)) }
    }

    /// Gets the line width used.
    ///
    /// # Returns
    ///
    /// the line width
    #[doc(alias = "gsk_stroke_get_line_width")]
    #[doc(alias = "get_line_width")]
    pub fn line_width(&self) -> f32 {
        unsafe { ffi::gsk_stroke_get_line_width(self.to_glib_none().0) }
    }

    /// Gets the miter limit.
    ///
    /// # Returns
    ///
    /// the miter limit
    #[doc(alias = "gsk_stroke_get_miter_limit")]
    #[doc(alias = "get_miter_limit")]
    pub fn miter_limit(&self) -> f32 {
        unsafe { ffi::gsk_stroke_get_miter_limit(self.to_glib_none().0) }
    }

    /// Sets the dash pattern to use.
    ///
    /// A dash pattern is specified by an array of alternating non-negative
    /// values. Each value provides the length of alternate "on" and "off"
    /// portions of the stroke.
    ///
    /// Each "on" segment will have caps applied as if the segment were a
    /// separate contour. In particular, it is valid to use an "on" length
    /// of 0 with [enum@Gsk.LineCap.round] or [enum@Gsk.LineCap.square]
    /// to draw dots or squares along a path.
    ///
    /// If @n_dash is 0, if all elements in @dash are 0, or if there are
    /// negative values in @dash, then dashing is disabled.
    ///
    /// If @n_dash is 1, an alternating "on" and "off" pattern with the
    /// single dash length provided is assumed.
    ///
    /// If @n_dash is uneven, the dash array will be used with the first
    /// element in @dash defining an "on" or "off" in alternating passes
    /// through the array.
    ///
    /// You can specify a starting offset into the dash with
    /// [`set_dash_offset()`][Self::set_dash_offset()].
    /// ## `dash`
    ///
    ///   the array of dashes
    #[doc(alias = "gsk_stroke_set_dash")]
    pub fn set_dash(&self, dash: &[f32]) {
        let n_dash = dash.len() as _;
        unsafe {
            ffi::gsk_stroke_set_dash(
                mut_override(self.to_glib_none().0),
                dash.to_glib_none().0,
                n_dash,
            );
        }
    }

    /// Sets the offset into the dash pattern where dashing should begin.
    ///
    /// This is an offset into the length of the path, not an index into
    /// the array values of the dash array.
    ///
    /// See [`set_dash()`][Self::set_dash()] for more details on dashing.
    /// ## `offset`
    /// offset into the dash pattern
    #[doc(alias = "gsk_stroke_set_dash_offset")]
    pub fn set_dash_offset(&self, offset: f32) {
        unsafe {
            ffi::gsk_stroke_set_dash_offset(mut_override(self.to_glib_none().0), offset);
        }
    }

    /// Sets the line cap to be used when stroking.
    ///
    /// See [`LineCap`][crate::LineCap] for details.
    /// ## `line_cap`
    /// the line cap
    #[doc(alias = "gsk_stroke_set_line_cap")]
    pub fn set_line_cap(&self, line_cap: LineCap) {
        unsafe {
            ffi::gsk_stroke_set_line_cap(mut_override(self.to_glib_none().0), line_cap.into_glib());
        }
    }

    /// Sets the line join to be used when stroking.
    ///
    /// See [`LineJoin`][crate::LineJoin] for details.
    /// ## `line_join`
    /// the line join to use
    #[doc(alias = "gsk_stroke_set_line_join")]
    pub fn set_line_join(&self, line_join: LineJoin) {
        unsafe {
            ffi::gsk_stroke_set_line_join(
                mut_override(self.to_glib_none().0),
                line_join.into_glib(),
            );
        }
    }

    /// Sets the line width to be used when stroking.
    ///
    /// The line width must be > 0.
    /// ## `line_width`
    /// width of the line in pixels
    #[doc(alias = "gsk_stroke_set_line_width")]
    pub fn set_line_width(&self, line_width: f32) {
        unsafe {
            ffi::gsk_stroke_set_line_width(mut_override(self.to_glib_none().0), line_width);
        }
    }

    /// Sets the miter limit to be used when stroking.
    ///
    /// The miter limit is the distance from the corner where sharp
    /// turns of joins get cut off.
    ///
    /// The limit is specfied in units of line width and must be non-negative.
    ///
    /// For joins of type [enum@Gsk.LineJoin.miter] that exceed the miter limit,
    /// the join gets rendered as if it was of type [enum@Gsk.LineJoin.bevel].
    /// ## `limit`
    /// the miter limit
    #[doc(alias = "gsk_stroke_set_miter_limit")]
    pub fn set_miter_limit(&self, limit: f32) {
        unsafe {
            ffi::gsk_stroke_set_miter_limit(mut_override(self.to_glib_none().0), limit);
        }
    }

    /// A helper function that sets the stroke parameters
    /// of a cairo context from a [`Stroke`][crate::Stroke].
    /// ## `cr`
    /// the cairo context to configure
    #[doc(alias = "gsk_stroke_to_cairo")]
    pub fn to_cairo(&self, cr: &cairo::Context) {
        unsafe {
            ffi::gsk_stroke_to_cairo(self.to_glib_none().0, mut_override(cr.to_glib_none().0));
        }
    }

    #[doc(alias = "gsk_stroke_equal")]
    fn equal(&self, stroke2: &Stroke) -> bool {
        assert_initialized_main_thread!();
        unsafe {
            from_glib(ffi::gsk_stroke_equal(
                ToGlibPtr::<*const ffi::GskStroke>::to_glib_none(self).0
                    as glib::ffi::gconstpointer,
                ToGlibPtr::<*const ffi::GskStroke>::to_glib_none(stroke2).0
                    as glib::ffi::gconstpointer,
            ))
        }
    }
}

impl PartialEq for Stroke {
    #[inline]
    fn eq(&self, other: &Self) -> bool {
        self.equal(other)
    }
}

impl Eq for Stroke {}