gtk/auto/

paper_size.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::Unit;
use glib::translate::*;
use std::ptr;

glib::wrapper! {
    /// GtkPaperSize handles paper sizes. It uses the standard called
    /// [PWG 5101.1-2002 PWG: Standard for Media Standardized Names](http://www.pwg.org/standards.html)
    /// to name the paper sizes (and to get the data for the page sizes).
    /// In addition to standard paper sizes, GtkPaperSize allows to
    /// construct custom paper sizes with arbitrary dimensions.
    ///
    /// The [`PaperSize`][crate::PaperSize] object stores not only the dimensions (width
    /// and height) of a paper size and its name, it also provides
    /// default [print margins][print-margins].
    ///
    /// Printing support has been added in GTK+ 2.10.
    #[derive(Debug, PartialOrd, Ord, Hash)]
    pub struct PaperSize(Boxed<ffi::GtkPaperSize>);

    match fn {
        copy => |ptr| ffi::gtk_paper_size_copy(mut_override(ptr)),
        free => |ptr| ffi::gtk_paper_size_free(ptr),
        type_ => || ffi::gtk_paper_size_get_type(),
    }
}

impl PaperSize {
    /// Creates a new [`PaperSize`][crate::PaperSize] object by parsing a
    /// [PWG 5101.1-2002](ftp://ftp.pwg.org/pub/pwg/candidates/cs-pwgmsn10-20020226-5101.1.pdf)
    /// paper name.
    ///
    /// If `name` is [`None`], the default paper size is returned,
    /// see [`default()`][Self::default()].
    /// ## `name`
    /// a paper size name, or [`None`]
    ///
    /// # Returns
    ///
    /// a new [`PaperSize`][crate::PaperSize], use `gtk_paper_size_free()`
    /// to free it
    #[doc(alias = "gtk_paper_size_new")]
    pub fn new(name: Option<&str>) -> PaperSize {
        assert_initialized_main_thread!();
        unsafe { from_glib_full(ffi::gtk_paper_size_new(name.to_glib_none().0)) }
    }

    /// Creates a new [`PaperSize`][crate::PaperSize] object with the
    /// given parameters.
    /// ## `name`
    /// the paper name
    /// ## `display_name`
    /// the human-readable name
    /// ## `width`
    /// the paper width, in units of `unit`
    /// ## `height`
    /// the paper height, in units of `unit`
    /// ## `unit`
    /// the unit for `width` and `height`. not [`Unit::None`][crate::Unit::None].
    ///
    /// # Returns
    ///
    /// a new [`PaperSize`][crate::PaperSize] object, use `gtk_paper_size_free()`
    /// to free it
    #[doc(alias = "gtk_paper_size_new_custom")]
    pub fn new_custom(
        name: &str,
        display_name: &str,
        width: f64,
        height: f64,
        unit: Unit,
    ) -> PaperSize {
        assert_initialized_main_thread!();
        unsafe {
            from_glib_full(ffi::gtk_paper_size_new_custom(
                name.to_glib_none().0,
                display_name.to_glib_none().0,
                width,
                height,
                unit.into_glib(),
            ))
        }
    }

    /// Deserialize a paper size from an a{sv} variant in
    /// the format produced by [`to_gvariant()`][Self::to_gvariant()].
    /// ## `variant`
    /// an a{sv} [`glib::Variant`][struct@crate::glib::Variant]
    ///
    /// # Returns
    ///
    /// a new [`PaperSize`][crate::PaperSize] object
    #[doc(alias = "gtk_paper_size_new_from_gvariant")]
    #[doc(alias = "new_from_gvariant")]
    pub fn from_gvariant(variant: &glib::Variant) -> PaperSize {
        assert_initialized_main_thread!();
        unsafe {
            from_glib_full(ffi::gtk_paper_size_new_from_gvariant(
                variant.to_glib_none().0,
            ))
        }
    }

    /// Creates a new [`PaperSize`][crate::PaperSize] object by using
    /// IPP information.
    ///
    /// If `ipp_name` is not a recognized paper name,
    /// `width` and `height` are used to
    /// construct a custom [`PaperSize`][crate::PaperSize] object.
    /// ## `ipp_name`
    /// an IPP paper name
    /// ## `width`
    /// the paper width, in points
    /// ## `height`
    /// the paper height in points
    ///
    /// # Returns
    ///
    /// a new [`PaperSize`][crate::PaperSize], use `gtk_paper_size_free()`
    /// to free it
    #[doc(alias = "gtk_paper_size_new_from_ipp")]
    #[doc(alias = "new_from_ipp")]
    pub fn from_ipp(ipp_name: &str, width: f64, height: f64) -> PaperSize {
        assert_initialized_main_thread!();
        unsafe {
            from_glib_full(ffi::gtk_paper_size_new_from_ipp(
                ipp_name.to_glib_none().0,
                width,
                height,
            ))
        }
    }

    /// Reads a paper size from the group `group_name` in the key file
    /// `key_file`.
    /// ## `key_file`
    /// the [`glib::KeyFile`][crate::glib::KeyFile] to retrieve the papersize from
    /// ## `group_name`
    /// the name of the group in the key file to read,
    ///  or [`None`] to read the first group
    ///
    /// # Returns
    ///
    /// a new [`PaperSize`][crate::PaperSize] object with the restored
    ///  paper size, or [`None`] if an error occurred
    #[doc(alias = "gtk_paper_size_new_from_key_file")]
    #[doc(alias = "new_from_key_file")]
    pub fn from_key_file(
        key_file: &glib::KeyFile,
        group_name: Option<&str>,
    ) -> Result<PaperSize, glib::Error> {
        assert_initialized_main_thread!();
        unsafe {
            let mut error = ptr::null_mut();
            let ret = ffi::gtk_paper_size_new_from_key_file(
                key_file.to_glib_none().0,
                group_name.to_glib_none().0,
                &mut error,
            );
            if error.is_null() {
                Ok(from_glib_full(ret))
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    /// Creates a new [`PaperSize`][crate::PaperSize] object by using
    /// PPD information.
    ///
    /// If `ppd_name` is not a recognized PPD paper name,
    /// `ppd_display_name`, `width` and `height` are used to
    /// construct a custom [`PaperSize`][crate::PaperSize] object.
    /// ## `ppd_name`
    /// a PPD paper name
    /// ## `ppd_display_name`
    /// the corresponding human-readable name
    /// ## `width`
    /// the paper width, in points
    /// ## `height`
    /// the paper height in points
    ///
    /// # Returns
    ///
    /// a new [`PaperSize`][crate::PaperSize], use `gtk_paper_size_free()`
    /// to free it
    #[doc(alias = "gtk_paper_size_new_from_ppd")]
    #[doc(alias = "new_from_ppd")]
    pub fn from_ppd(ppd_name: &str, ppd_display_name: &str, width: f64, height: f64) -> PaperSize {
        assert_initialized_main_thread!();
        unsafe {
            from_glib_full(ffi::gtk_paper_size_new_from_ppd(
                ppd_name.to_glib_none().0,
                ppd_display_name.to_glib_none().0,
                width,
                height,
            ))
        }
    }

    /// Gets the default bottom margin for the [`PaperSize`][crate::PaperSize].
    /// ## `unit`
    /// the unit for the return value, not [`Unit::None`][crate::Unit::None]
    ///
    /// # Returns
    ///
    /// the default bottom margin
    #[doc(alias = "gtk_paper_size_get_default_bottom_margin")]
    #[doc(alias = "get_default_bottom_margin")]
    pub fn default_bottom_margin(&self, unit: Unit) -> f64 {
        unsafe {
            ffi::gtk_paper_size_get_default_bottom_margin(
                mut_override(self.to_glib_none().0),
                unit.into_glib(),
            )
        }
    }

    /// Gets the default left margin for the [`PaperSize`][crate::PaperSize].
    /// ## `unit`
    /// the unit for the return value, not [`Unit::None`][crate::Unit::None]
    ///
    /// # Returns
    ///
    /// the default left margin
    #[doc(alias = "gtk_paper_size_get_default_left_margin")]
    #[doc(alias = "get_default_left_margin")]
    pub fn default_left_margin(&self, unit: Unit) -> f64 {
        unsafe {
            ffi::gtk_paper_size_get_default_left_margin(
                mut_override(self.to_glib_none().0),
                unit.into_glib(),
            )
        }
    }

    /// Gets the default right margin for the [`PaperSize`][crate::PaperSize].
    /// ## `unit`
    /// the unit for the return value, not [`Unit::None`][crate::Unit::None]
    ///
    /// # Returns
    ///
    /// the default right margin
    #[doc(alias = "gtk_paper_size_get_default_right_margin")]
    #[doc(alias = "get_default_right_margin")]
    pub fn default_right_margin(&self, unit: Unit) -> f64 {
        unsafe {
            ffi::gtk_paper_size_get_default_right_margin(
                mut_override(self.to_glib_none().0),
                unit.into_glib(),
            )
        }
    }

    /// Gets the default top margin for the [`PaperSize`][crate::PaperSize].
    /// ## `unit`
    /// the unit for the return value, not [`Unit::None`][crate::Unit::None]
    ///
    /// # Returns
    ///
    /// the default top margin
    #[doc(alias = "gtk_paper_size_get_default_top_margin")]
    #[doc(alias = "get_default_top_margin")]
    pub fn default_top_margin(&self, unit: Unit) -> f64 {
        unsafe {
            ffi::gtk_paper_size_get_default_top_margin(
                mut_override(self.to_glib_none().0),
                unit.into_glib(),
            )
        }
    }

    /// Gets the human-readable name of the [`PaperSize`][crate::PaperSize].
    ///
    /// # Returns
    ///
    /// the human-readable name of `self`
    #[doc(alias = "gtk_paper_size_get_display_name")]
    #[doc(alias = "get_display_name")]
    pub fn display_name(&self) -> Option<glib::GString> {
        unsafe {
            from_glib_none(ffi::gtk_paper_size_get_display_name(mut_override(
                self.to_glib_none().0,
            )))
        }
    }

    /// Gets the paper height of the [`PaperSize`][crate::PaperSize], in
    /// units of `unit`.
    /// ## `unit`
    /// the unit for the return value, not [`Unit::None`][crate::Unit::None]
    ///
    /// # Returns
    ///
    /// the paper height
    #[doc(alias = "gtk_paper_size_get_height")]
    #[doc(alias = "get_height")]
    pub fn height(&self, unit: Unit) -> f64 {
        unsafe {
            ffi::gtk_paper_size_get_height(mut_override(self.to_glib_none().0), unit.into_glib())
        }
    }

    /// Gets the name of the [`PaperSize`][crate::PaperSize].
    ///
    /// # Returns
    ///
    /// the name of `self`
    #[doc(alias = "gtk_paper_size_get_name")]
    #[doc(alias = "get_name")]
    pub fn name(&self) -> Option<glib::GString> {
        unsafe {
            from_glib_none(ffi::gtk_paper_size_get_name(mut_override(
                self.to_glib_none().0,
            )))
        }
    }

    /// Gets the PPD name of the [`PaperSize`][crate::PaperSize], which
    /// may be [`None`].
    ///
    /// # Returns
    ///
    /// the PPD name of `self`
    #[doc(alias = "gtk_paper_size_get_ppd_name")]
    #[doc(alias = "get_ppd_name")]
    pub fn ppd_name(&self) -> Option<glib::GString> {
        unsafe {
            from_glib_none(ffi::gtk_paper_size_get_ppd_name(mut_override(
                self.to_glib_none().0,
            )))
        }
    }

    /// Gets the paper width of the [`PaperSize`][crate::PaperSize], in
    /// units of `unit`.
    /// ## `unit`
    /// the unit for the return value, not [`Unit::None`][crate::Unit::None]
    ///
    /// # Returns
    ///
    /// the paper width
    #[doc(alias = "gtk_paper_size_get_width")]
    #[doc(alias = "get_width")]
    pub fn width(&self, unit: Unit) -> f64 {
        unsafe {
            ffi::gtk_paper_size_get_width(mut_override(self.to_glib_none().0), unit.into_glib())
        }
    }

    /// Returns [`true`] if `self` is not a standard paper size.
    ///
    /// # Returns
    ///
    /// whether `self` is a custom paper size.
    #[doc(alias = "gtk_paper_size_is_custom")]
    pub fn is_custom(&self) -> bool {
        unsafe {
            from_glib(ffi::gtk_paper_size_is_custom(mut_override(
                self.to_glib_none().0,
            )))
        }
    }

    #[doc(alias = "gtk_paper_size_is_equal")]
    fn is_equal(&self, size2: &PaperSize) -> bool {
        unsafe {
            from_glib(ffi::gtk_paper_size_is_equal(
                mut_override(self.to_glib_none().0),
                mut_override(size2.to_glib_none().0),
            ))
        }
    }

    /// Returns [`true`] if `self` is an IPP standard paper size.
    ///
    /// # Returns
    ///
    /// whether `self` is not an IPP custom paper size.
    #[doc(alias = "gtk_paper_size_is_ipp")]
    pub fn is_ipp(&self) -> bool {
        unsafe {
            from_glib(ffi::gtk_paper_size_is_ipp(mut_override(
                self.to_glib_none().0,
            )))
        }
    }

    /// Changes the dimensions of a `self` to `width` x `height`.
    /// ## `width`
    /// the new width in units of `unit`
    /// ## `height`
    /// the new height in units of `unit`
    /// ## `unit`
    /// the unit for `width` and `height`
    #[doc(alias = "gtk_paper_size_set_size")]
    pub fn set_size(&mut self, width: f64, height: f64, unit: Unit) {
        unsafe {
            ffi::gtk_paper_size_set_size(
                self.to_glib_none_mut().0,
                width,
                height,
                unit.into_glib(),
            );
        }
    }

    /// Serialize a paper size to an a{sv} variant.
    ///
    /// # Returns
    ///
    /// a new, floating, [`glib::Variant`][struct@crate::glib::Variant]
    #[doc(alias = "gtk_paper_size_to_gvariant")]
    pub fn to_gvariant(&mut self) -> Option<glib::Variant> {
        unsafe { from_glib_none(ffi::gtk_paper_size_to_gvariant(self.to_glib_none_mut().0)) }
    }

    /// This function adds the paper size from `self` to `key_file`.
    /// ## `key_file`
    /// the [`glib::KeyFile`][crate::glib::KeyFile] to save the paper size to
    /// ## `group_name`
    /// the group to add the settings to in `key_file`
    #[doc(alias = "gtk_paper_size_to_key_file")]
    pub fn to_key_file(&mut self, key_file: &glib::KeyFile, group_name: &str) {
        unsafe {
            ffi::gtk_paper_size_to_key_file(
                self.to_glib_none_mut().0,
                key_file.to_glib_none().0,
                group_name.to_glib_none().0,
            );
        }
    }

    /// Returns the name of the default paper size, which
    /// depends on the current locale.
    ///
    /// # Returns
    ///
    /// the name of the default paper size. The string
    /// is owned by GTK+ and should not be modified.
    #[doc(alias = "gtk_paper_size_get_default")]
    #[doc(alias = "get_default")]
    #[allow(clippy::should_implement_trait)]
    pub fn default() -> Option<glib::GString> {
        assert_initialized_main_thread!();
        unsafe { from_glib_none(ffi::gtk_paper_size_get_default()) }
    }

    /// Creates a list of known paper sizes.
    /// ## `include_custom`
    /// whether to include custom paper sizes
    ///  as defined in the page setup dialog
    ///
    /// # Returns
    ///
    /// a newly allocated list of newly
    ///  allocated [`PaperSize`][crate::PaperSize] objects
    #[doc(alias = "gtk_paper_size_get_paper_sizes")]
    #[doc(alias = "get_paper_sizes")]
    pub fn paper_sizes(include_custom: bool) -> Vec<PaperSize> {
        assert_initialized_main_thread!();
        unsafe {
            FromGlibPtrContainer::from_glib_full(ffi::gtk_paper_size_get_paper_sizes(
                include_custom.into_glib(),
            ))
        }
    }
}

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

impl Eq for PaperSize {}