// 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::PageSetup;
use glib::translate::*;
use std::fmt;
use std::mem;

glib::wrapper! {
    /// A [`PrintContext`][crate::PrintContext] encapsulates context information that is required when
    /// drawing pages for printing.
    ///
    /// This includes the cairo context and important parameters like page size
    /// and resolution. It also lets you easily create [`pango::Layout`][crate::pango::Layout] and
    /// [`pango::Context`][crate::pango::Context] objects that match the font metrics of the cairo surface.
    ///
    /// [`PrintContext`][crate::PrintContext] objects get passed to the
    /// `signal::PrintOperation::begin-print`,
    /// `signal::PrintOperation::end-print`,
    /// `signal::PrintOperation::request-page-setup` and
    /// `signal::PrintOperation::draw-page` signals on the
    /// [`PrintOperation`][crate::PrintOperation] object.
    ///
    /// ## Using GtkPrintContext in a ::draw-page callback
    ///
    /// **⚠️ The following code is in c ⚠️**
    ///
    /// ```c
    /// static void
    /// draw_page (GtkPrintOperation *operation,
    ///            GtkPrintContext   *context,
    ///            int                page_nr)
    /// {
    ///   cairo_t *cr;
    ///   PangoLayout *layout;
    ///   PangoFontDescription *desc;
    ///
    ///   cr = gtk_print_context_get_cairo_context (context);
    ///
    ///   // Draw a red rectangle, as wide as the paper (inside the margins)
    ///   cairo_set_source_rgb (cr, 1.0, 0, 0);
    ///   cairo_rectangle (cr, 0, 0, gtk_print_context_get_width (context), 50);
    ///
    ///   cairo_fill (cr);
    ///
    ///   // Draw some lines
    ///   cairo_move_to (cr, 20, 10);
    ///   cairo_line_to (cr, 40, 20);
    ///   cairo_arc (cr, 60, 60, 20, 0, M_PI);
    ///   cairo_line_to (cr, 80, 20);
    ///
    ///   cairo_set_source_rgb (cr, 0, 0, 0);
    ///   cairo_set_line_width (cr, 5);
    ///   cairo_set_line_cap (cr, CAIRO_LINE_CAP_ROUND);
    ///   cairo_set_line_join (cr, CAIRO_LINE_JOIN_ROUND);
    ///
    ///   cairo_stroke (cr);
    ///
    ///   // Draw some text
    ///   layout = gtk_print_context_create_pango_layout (context);
    ///   pango_layout_set_text (layout, "Hello World! Printing is easy", -1);
    ///   desc = pango_font_description_from_string ("sans 28");
    ///   pango_layout_set_font_description (layout, desc);
    ///   pango_font_description_free (desc);
    ///
    ///   cairo_move_to (cr, 30, 20);
    ///   pango_cairo_layout_path (cr, layout);
    ///
    ///   // Font Outline
    ///   cairo_set_source_rgb (cr, 0.93, 1.0, 0.47);
    ///   cairo_set_line_width (cr, 0.5);
    ///   cairo_stroke_preserve (cr);
    ///
    ///   // Font Fill
    ///   cairo_set_source_rgb (cr, 0, 0.0, 1.0);
    ///   cairo_fill (cr);
    ///
    ///   g_object_unref (layout);
    /// }
    /// ```
    ///
    /// # Implements
    ///
    /// [`trait@glib::ObjectExt`]
    #[doc(alias = "GtkPrintContext")]
    pub struct PrintContext(Object<ffi::GtkPrintContext>);

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

impl PrintContext {
    /// Creates a new [`pango::Context`][crate::pango::Context] that can be used with the
    /// [`PrintContext`][crate::PrintContext].
    ///
    /// # Returns
    ///
    /// a new Pango context for @self
    #[doc(alias = "gtk_print_context_create_pango_context")]
    pub fn create_pango_context(&self) -> pango::Context {
        unsafe {
            from_glib_full(ffi::gtk_print_context_create_pango_context(
                self.to_glib_none().0,
            ))
        }
    }

    /// Creates a new [`pango::Layout`][crate::pango::Layout] that is suitable for use
    /// with the [`PrintContext`][crate::PrintContext].
    ///
    /// # Returns
    ///
    /// a new Pango layout for @self
    #[doc(alias = "gtk_print_context_create_pango_layout")]
    pub fn create_pango_layout(&self) -> pango::Layout {
        unsafe {
            from_glib_full(ffi::gtk_print_context_create_pango_layout(
                self.to_glib_none().0,
            ))
        }
    }

    /// Obtains the cairo context that is associated with the
    /// [`PrintContext`][crate::PrintContext].
    ///
    /// # Returns
    ///
    /// the cairo context of @self
    #[doc(alias = "gtk_print_context_get_cairo_context")]
    #[doc(alias = "get_cairo_context")]
    pub fn cairo_context(&self) -> cairo::Context {
        unsafe {
            from_glib_none(ffi::gtk_print_context_get_cairo_context(
                self.to_glib_none().0,
            ))
        }
    }

    /// Obtains the horizontal resolution of the [`PrintContext`][crate::PrintContext],
    /// in dots per inch.
    ///
    /// # Returns
    ///
    /// the horizontal resolution of @self
    #[doc(alias = "gtk_print_context_get_dpi_x")]
    #[doc(alias = "get_dpi_x")]
    pub fn dpi_x(&self) -> f64 {
        unsafe { ffi::gtk_print_context_get_dpi_x(self.to_glib_none().0) }
    }

    /// Obtains the vertical resolution of the [`PrintContext`][crate::PrintContext],
    /// in dots per inch.
    ///
    /// # Returns
    ///
    /// the vertical resolution of @self
    #[doc(alias = "gtk_print_context_get_dpi_y")]
    #[doc(alias = "get_dpi_y")]
    pub fn dpi_y(&self) -> f64 {
        unsafe { ffi::gtk_print_context_get_dpi_y(self.to_glib_none().0) }
    }

    /// Obtains the hardware printer margins of the [`PrintContext`][crate::PrintContext],
    /// in units.
    ///
    /// # Returns
    ///
    /// [`true`] if the hard margins were retrieved
    ///
    /// ## `top`
    /// top hardware printer margin
    ///
    /// ## `bottom`
    /// bottom hardware printer margin
    ///
    /// ## `left`
    /// left hardware printer margin
    ///
    /// ## `right`
    /// right hardware printer margin
    #[doc(alias = "gtk_print_context_get_hard_margins")]
    #[doc(alias = "get_hard_margins")]
    pub fn hard_margins(&self) -> Option<(f64, f64, f64, f64)> {
        unsafe {
            let mut top = mem::MaybeUninit::uninit();
            let mut bottom = mem::MaybeUninit::uninit();
            let mut left = mem::MaybeUninit::uninit();
            let mut right = mem::MaybeUninit::uninit();
            let ret = from_glib(ffi::gtk_print_context_get_hard_margins(
                self.to_glib_none().0,
                top.as_mut_ptr(),
                bottom.as_mut_ptr(),
                left.as_mut_ptr(),
                right.as_mut_ptr(),
            ));
            if ret {
                Some((
                    top.assume_init(),
                    bottom.assume_init(),
                    left.assume_init(),
                    right.assume_init(),
                ))
            } else {
                None
            }
        }
    }

    /// Obtains the height of the [`PrintContext`][crate::PrintContext], in pixels.
    ///
    /// # Returns
    ///
    /// the height of @self
    #[doc(alias = "gtk_print_context_get_height")]
    #[doc(alias = "get_height")]
    pub fn height(&self) -> f64 {
        unsafe { ffi::gtk_print_context_get_height(self.to_glib_none().0) }
    }

    /// Obtains the [`PageSetup`][crate::PageSetup] that determines the page
    /// dimensions of the [`PrintContext`][crate::PrintContext].
    ///
    /// # Returns
    ///
    /// the page setup of @self
    #[doc(alias = "gtk_print_context_get_page_setup")]
    #[doc(alias = "get_page_setup")]
    pub fn page_setup(&self) -> PageSetup {
        unsafe { from_glib_none(ffi::gtk_print_context_get_page_setup(self.to_glib_none().0)) }
    }

    /// Returns a [`pango::FontMap`][crate::pango::FontMap] that is suitable for use
    /// with the [`PrintContext`][crate::PrintContext].
    ///
    /// # Returns
    ///
    /// the font map of @self
    #[doc(alias = "gtk_print_context_get_pango_fontmap")]
    #[doc(alias = "get_pango_fontmap")]
    pub fn pango_fontmap(&self) -> pango::FontMap {
        unsafe {
            from_glib_none(ffi::gtk_print_context_get_pango_fontmap(
                self.to_glib_none().0,
            ))
        }
    }

    /// Obtains the width of the [`PrintContext`][crate::PrintContext], in pixels.
    ///
    /// # Returns
    ///
    /// the width of @self
    #[doc(alias = "gtk_print_context_get_width")]
    #[doc(alias = "get_width")]
    pub fn width(&self) -> f64 {
        unsafe { ffi::gtk_print_context_get_width(self.to_glib_none().0) }
    }

    /// Sets a new cairo context on a print context.
    ///
    /// This function is intended to be used when implementing
    /// an internal print preview, it is not needed for printing,
    /// since GTK itself creates a suitable cairo context in that
    /// case.
    /// ## `cr`
    /// the cairo context
    /// ## `dpi_x`
    /// the horizontal resolution to use with @cr
    /// ## `dpi_y`
    /// the vertical resolution to use with @cr
    #[doc(alias = "gtk_print_context_set_cairo_context")]
    pub fn set_cairo_context(&self, cr: &cairo::Context, dpi_x: f64, dpi_y: f64) {
        unsafe {
            ffi::gtk_print_context_set_cairo_context(
                self.to_glib_none().0,
                mut_override(cr.to_glib_none().0),
                dpi_x,
                dpi_y,
            );
        }
    }
}

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