gtk/auto/

page_setup.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::{PageOrientation, PaperSize, Unit};
use glib::translate::*;
use std::{fmt, ptr};

glib::wrapper! {
    /// A GtkPageSetup object stores the page size, orientation and margins.
    /// The idea is that you can get one of these from the page setup dialog
    /// and then pass it to the [`PrintOperation`][crate::PrintOperation] when printing.
    /// The benefit of splitting this out of the [`PrintSettings`][crate::PrintSettings] is that
    /// these affect the actual layout of the page, and thus need to be set
    /// long before user prints.
    ///
    /// ## Margins ## {`print`-margins}
    /// The margins specified in this object are the “print margins”, i.e. the
    /// parts of the page that the printer cannot print on. These are different
    /// from the layout margins that a word processor uses; they are typically
    /// used to determine the minimal size for the layout
    /// margins.
    ///
    /// To obtain a [`PageSetup`][crate::PageSetup] use [`new()`][Self::new()] to get the defaults,
    /// or use [`print_run_page_setup_dialog()`][crate::print_run_page_setup_dialog()] to show the page setup dialog
    /// and receive the resulting page setup.
    ///
    /// ## A page setup dialog
    ///
    ///
    ///
    /// **⚠️ The following code is in C ⚠️**
    ///
    /// ```C
    /// static GtkPrintSettings *settings = NULL;
    /// static GtkPageSetup *page_setup = NULL;
    ///
    /// static void
    /// do_page_setup (void)
    /// {
    ///   GtkPageSetup *new_page_setup;
    ///
    ///   if (settings == NULL)
    ///     settings = gtk_print_settings_new ();
    ///
    ///   new_page_setup = gtk_print_run_page_setup_dialog (GTK_WINDOW (main_window),
    ///                                                     page_setup, settings);
    ///
    ///   if (page_setup)
    ///     g_object_unref (page_setup);
    ///
    ///   page_setup = new_page_setup;
    /// }
    /// ```
    ///
    /// Printing support was added in GTK+ 2.10.
    ///
    /// # Implements
    ///
    /// [`trait@glib::ObjectExt`]
    #[doc(alias = "GtkPageSetup")]
    pub struct PageSetup(Object<ffi::GtkPageSetup>);

    match fn {
        type_ => || ffi::gtk_page_setup_get_type(),
    }
}

impl PageSetup {
    /// Creates a new [`PageSetup`][crate::PageSetup].
    ///
    /// # Returns
    ///
    /// a new [`PageSetup`][crate::PageSetup].
    #[doc(alias = "gtk_page_setup_new")]
    pub fn new() -> PageSetup {
        assert_initialized_main_thread!();
        unsafe { from_glib_full(ffi::gtk_page_setup_new()) }
    }

    /// Reads the page setup from the file `file_name`. Returns a
    /// new [`PageSetup`][crate::PageSetup] object with the restored page setup,
    /// or [`None`] if an error occurred. See [`to_file()`][Self::to_file()].
    /// ## `file_name`
    /// the filename to read the page setup from
    ///
    /// # Returns
    ///
    /// the restored [`PageSetup`][crate::PageSetup]
    #[doc(alias = "gtk_page_setup_new_from_file")]
    #[doc(alias = "new_from_file")]
    pub fn from_file(file_name: impl AsRef<std::path::Path>) -> Result<PageSetup, glib::Error> {
        assert_initialized_main_thread!();
        unsafe {
            let mut error = ptr::null_mut();
            let ret =
                ffi::gtk_page_setup_new_from_file(file_name.as_ref().to_glib_none().0, &mut error);
            if error.is_null() {
                Ok(from_glib_full(ret))
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    /// Desrialize a page setup 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 [`PageSetup`][crate::PageSetup] object
    #[doc(alias = "gtk_page_setup_new_from_gvariant")]
    #[doc(alias = "new_from_gvariant")]
    pub fn from_gvariant(variant: &glib::Variant) -> PageSetup {
        assert_initialized_main_thread!();
        unsafe {
            from_glib_full(ffi::gtk_page_setup_new_from_gvariant(
                variant.to_glib_none().0,
            ))
        }
    }

    /// Reads the page setup from the group `group_name` in the key file
    /// `key_file`. Returns a new [`PageSetup`][crate::PageSetup] object with the restored
    /// page setup, or [`None`] if an error occurred.
    /// ## `key_file`
    /// the [`glib::KeyFile`][crate::glib::KeyFile] to retrieve the page_setup from
    /// ## `group_name`
    /// the name of the group in the key_file to read, or [`None`]
    ///  to use the default name “Page Setup”
    ///
    /// # Returns
    ///
    /// the restored [`PageSetup`][crate::PageSetup]
    #[doc(alias = "gtk_page_setup_new_from_key_file")]
    #[doc(alias = "new_from_key_file")]
    pub fn from_key_file(
        key_file: &glib::KeyFile,
        group_name: Option<&str>,
    ) -> Result<PageSetup, glib::Error> {
        assert_initialized_main_thread!();
        unsafe {
            let mut error = ptr::null_mut();
            let ret = ffi::gtk_page_setup_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))
            }
        }
    }

    #[doc(alias = "gtk_page_setup_copy")]
    #[must_use]
    pub fn copy(&self) -> Option<PageSetup> {
        unsafe { from_glib_full(ffi::gtk_page_setup_copy(self.to_glib_none().0)) }
    }

    /// Gets the bottom margin in units of `unit`.
    /// ## `unit`
    /// the unit for the return value
    ///
    /// # Returns
    ///
    /// the bottom margin
    #[doc(alias = "gtk_page_setup_get_bottom_margin")]
    #[doc(alias = "get_bottom_margin")]
    pub fn bottom_margin(&self, unit: Unit) -> f64 {
        unsafe { ffi::gtk_page_setup_get_bottom_margin(self.to_glib_none().0, unit.into_glib()) }
    }

    /// Gets the left margin in units of `unit`.
    /// ## `unit`
    /// the unit for the return value
    ///
    /// # Returns
    ///
    /// the left margin
    #[doc(alias = "gtk_page_setup_get_left_margin")]
    #[doc(alias = "get_left_margin")]
    pub fn left_margin(&self, unit: Unit) -> f64 {
        unsafe { ffi::gtk_page_setup_get_left_margin(self.to_glib_none().0, unit.into_glib()) }
    }

    /// Gets the page orientation of the [`PageSetup`][crate::PageSetup].
    ///
    /// # Returns
    ///
    /// the page orientation
    #[doc(alias = "gtk_page_setup_get_orientation")]
    #[doc(alias = "get_orientation")]
    pub fn orientation(&self) -> PageOrientation {
        unsafe { from_glib(ffi::gtk_page_setup_get_orientation(self.to_glib_none().0)) }
    }

    /// Returns the page height in units of `unit`.
    ///
    /// Note that this function takes orientation and
    /// margins into consideration.
    /// See [`paper_height()`][Self::paper_height()].
    /// ## `unit`
    /// the unit for the return value
    ///
    /// # Returns
    ///
    /// the page height.
    #[doc(alias = "gtk_page_setup_get_page_height")]
    #[doc(alias = "get_page_height")]
    pub fn page_height(&self, unit: Unit) -> f64 {
        unsafe { ffi::gtk_page_setup_get_page_height(self.to_glib_none().0, unit.into_glib()) }
    }

    /// Returns the page width in units of `unit`.
    ///
    /// Note that this function takes orientation and
    /// margins into consideration.
    /// See [`paper_width()`][Self::paper_width()].
    /// ## `unit`
    /// the unit for the return value
    ///
    /// # Returns
    ///
    /// the page width.
    #[doc(alias = "gtk_page_setup_get_page_width")]
    #[doc(alias = "get_page_width")]
    pub fn page_width(&self, unit: Unit) -> f64 {
        unsafe { ffi::gtk_page_setup_get_page_width(self.to_glib_none().0, unit.into_glib()) }
    }

    /// Returns the paper height in units of `unit`.
    ///
    /// Note that this function takes orientation, but
    /// not margins into consideration.
    /// See [`page_height()`][Self::page_height()].
    /// ## `unit`
    /// the unit for the return value
    ///
    /// # Returns
    ///
    /// the paper height.
    #[doc(alias = "gtk_page_setup_get_paper_height")]
    #[doc(alias = "get_paper_height")]
    pub fn paper_height(&self, unit: Unit) -> f64 {
        unsafe { ffi::gtk_page_setup_get_paper_height(self.to_glib_none().0, unit.into_glib()) }
    }

    /// Gets the paper size of the [`PageSetup`][crate::PageSetup].
    ///
    /// # Returns
    ///
    /// the paper size
    #[doc(alias = "gtk_page_setup_get_paper_size")]
    #[doc(alias = "get_paper_size")]
    pub fn paper_size(&self) -> PaperSize {
        unsafe { from_glib_none(ffi::gtk_page_setup_get_paper_size(self.to_glib_none().0)) }
    }

    /// Returns the paper width in units of `unit`.
    ///
    /// Note that this function takes orientation, but
    /// not margins into consideration.
    /// See [`page_width()`][Self::page_width()].
    /// ## `unit`
    /// the unit for the return value
    ///
    /// # Returns
    ///
    /// the paper width.
    #[doc(alias = "gtk_page_setup_get_paper_width")]
    #[doc(alias = "get_paper_width")]
    pub fn paper_width(&self, unit: Unit) -> f64 {
        unsafe { ffi::gtk_page_setup_get_paper_width(self.to_glib_none().0, unit.into_glib()) }
    }

    /// Gets the right margin in units of `unit`.
    /// ## `unit`
    /// the unit for the return value
    ///
    /// # Returns
    ///
    /// the right margin
    #[doc(alias = "gtk_page_setup_get_right_margin")]
    #[doc(alias = "get_right_margin")]
    pub fn right_margin(&self, unit: Unit) -> f64 {
        unsafe { ffi::gtk_page_setup_get_right_margin(self.to_glib_none().0, unit.into_glib()) }
    }

    /// Gets the top margin in units of `unit`.
    /// ## `unit`
    /// the unit for the return value
    ///
    /// # Returns
    ///
    /// the top margin
    #[doc(alias = "gtk_page_setup_get_top_margin")]
    #[doc(alias = "get_top_margin")]
    pub fn top_margin(&self, unit: Unit) -> f64 {
        unsafe { ffi::gtk_page_setup_get_top_margin(self.to_glib_none().0, unit.into_glib()) }
    }

    /// Reads the page setup from the file `file_name`.
    /// See [`to_file()`][Self::to_file()].
    /// ## `file_name`
    /// the filename to read the page setup from
    ///
    /// # Returns
    ///
    /// [`true`] on success
    #[doc(alias = "gtk_page_setup_load_file")]
    pub fn load_file(&self, file_name: impl AsRef<std::path::Path>) -> Result<(), glib::Error> {
        unsafe {
            let mut error = ptr::null_mut();
            let is_ok = ffi::gtk_page_setup_load_file(
                self.to_glib_none().0,
                file_name.as_ref().to_glib_none().0,
                &mut error,
            );
            debug_assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
            if error.is_null() {
                Ok(())
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    /// Reads the page setup from the group `group_name` in the key file
    /// `key_file`.
    /// ## `key_file`
    /// the [`glib::KeyFile`][crate::glib::KeyFile] to retrieve the page_setup from
    /// ## `group_name`
    /// the name of the group in the key_file to read, or [`None`]
    ///  to use the default name “Page Setup”
    ///
    /// # Returns
    ///
    /// [`true`] on success
    #[doc(alias = "gtk_page_setup_load_key_file")]
    pub fn load_key_file(
        &self,
        key_file: &glib::KeyFile,
        group_name: Option<&str>,
    ) -> Result<(), glib::Error> {
        unsafe {
            let mut error = ptr::null_mut();
            let is_ok = ffi::gtk_page_setup_load_key_file(
                self.to_glib_none().0,
                key_file.to_glib_none().0,
                group_name.to_glib_none().0,
                &mut error,
            );
            debug_assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
            if error.is_null() {
                Ok(())
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    /// Sets the bottom margin of the [`PageSetup`][crate::PageSetup].
    /// ## `margin`
    /// the new bottom margin in units of `unit`
    /// ## `unit`
    /// the units for `margin`
    #[doc(alias = "gtk_page_setup_set_bottom_margin")]
    pub fn set_bottom_margin(&self, margin: f64, unit: Unit) {
        unsafe {
            ffi::gtk_page_setup_set_bottom_margin(self.to_glib_none().0, margin, unit.into_glib());
        }
    }

    /// Sets the left margin of the [`PageSetup`][crate::PageSetup].
    /// ## `margin`
    /// the new left margin in units of `unit`
    /// ## `unit`
    /// the units for `margin`
    #[doc(alias = "gtk_page_setup_set_left_margin")]
    pub fn set_left_margin(&self, margin: f64, unit: Unit) {
        unsafe {
            ffi::gtk_page_setup_set_left_margin(self.to_glib_none().0, margin, unit.into_glib());
        }
    }

    /// Sets the page orientation of the [`PageSetup`][crate::PageSetup].
    /// ## `orientation`
    /// a [`PageOrientation`][crate::PageOrientation] value
    #[doc(alias = "gtk_page_setup_set_orientation")]
    pub fn set_orientation(&self, orientation: PageOrientation) {
        unsafe {
            ffi::gtk_page_setup_set_orientation(self.to_glib_none().0, orientation.into_glib());
        }
    }

    /// Sets the paper size of the [`PageSetup`][crate::PageSetup] without
    /// changing the margins. See
    /// [`set_paper_size_and_default_margins()`][Self::set_paper_size_and_default_margins()].
    /// ## `size`
    /// a [`PaperSize`][crate::PaperSize]
    #[doc(alias = "gtk_page_setup_set_paper_size")]
    pub fn set_paper_size(&self, size: &PaperSize) {
        unsafe {
            ffi::gtk_page_setup_set_paper_size(
                self.to_glib_none().0,
                mut_override(size.to_glib_none().0),
            );
        }
    }

    /// Sets the paper size of the [`PageSetup`][crate::PageSetup] and modifies
    /// the margins according to the new paper size.
    /// ## `size`
    /// a [`PaperSize`][crate::PaperSize]
    #[doc(alias = "gtk_page_setup_set_paper_size_and_default_margins")]
    pub fn set_paper_size_and_default_margins(&self, size: &PaperSize) {
        unsafe {
            ffi::gtk_page_setup_set_paper_size_and_default_margins(
                self.to_glib_none().0,
                mut_override(size.to_glib_none().0),
            );
        }
    }

    /// Sets the right margin of the [`PageSetup`][crate::PageSetup].
    /// ## `margin`
    /// the new right margin in units of `unit`
    /// ## `unit`
    /// the units for `margin`
    #[doc(alias = "gtk_page_setup_set_right_margin")]
    pub fn set_right_margin(&self, margin: f64, unit: Unit) {
        unsafe {
            ffi::gtk_page_setup_set_right_margin(self.to_glib_none().0, margin, unit.into_glib());
        }
    }

    /// Sets the top margin of the [`PageSetup`][crate::PageSetup].
    /// ## `margin`
    /// the new top margin in units of `unit`
    /// ## `unit`
    /// the units for `margin`
    #[doc(alias = "gtk_page_setup_set_top_margin")]
    pub fn set_top_margin(&self, margin: f64, unit: Unit) {
        unsafe {
            ffi::gtk_page_setup_set_top_margin(self.to_glib_none().0, margin, unit.into_glib());
        }
    }

    /// This function saves the information from `self` to `file_name`.
    /// ## `file_name`
    /// the file to save to
    ///
    /// # Returns
    ///
    /// [`true`] on success
    #[doc(alias = "gtk_page_setup_to_file")]
    pub fn to_file(&self, file_name: impl AsRef<std::path::Path>) -> Result<(), glib::Error> {
        unsafe {
            let mut error = ptr::null_mut();
            let is_ok = ffi::gtk_page_setup_to_file(
                self.to_glib_none().0,
                file_name.as_ref().to_glib_none().0,
                &mut error,
            );
            debug_assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
            if error.is_null() {
                Ok(())
            } else {
                Err(from_glib_full(error))
            }
        }
    }

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

    /// This function adds the page setup from `self` to `key_file`.
    /// ## `key_file`
    /// the [`glib::KeyFile`][crate::glib::KeyFile] to save the page setup to
    /// ## `group_name`
    /// the group to add the settings to in `key_file`,
    ///  or [`None`] to use the default name “Page Setup”
    #[doc(alias = "gtk_page_setup_to_key_file")]
    pub fn to_key_file(&self, key_file: &glib::KeyFile, group_name: Option<&str>) {
        unsafe {
            ffi::gtk_page_setup_to_key_file(
                self.to_glib_none().0,
                key_file.to_glib_none().0,
                group_name.to_glib_none().0,
            );
        }
    }
}

impl Default for PageSetup {
    fn default() -> Self {
        Self::new()
    }
}

impl fmt::Display for PageSetup {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        f.write_str("PageSetup")
    }
}