gtk4/auto/

print_operation.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, PageSetup, PrintContext, PrintOperationAction, PrintOperationPreview,
    PrintOperationResult, PrintSettings, PrintStatus, Unit, Widget, Window,
};
use glib::{
    prelude::*,
    signal::{connect_raw, SignalHandlerId},
    translate::*,
};
use std::boxed::Box as Box_;

glib::wrapper! {
    /// [`PrintOperation`][crate::PrintOperation] is the high-level, portable printing API.
    ///
    /// It looks a bit different than other GTK dialogs such as the
    /// [`FileChooser`][crate::FileChooser], since some platforms don’t expose enough
    /// infrastructure to implement a good print dialog. On such
    /// platforms, [`PrintOperation`][crate::PrintOperation] uses the native print dialog.
    /// On platforms which do not provide a native print dialog, GTK
    /// uses its own, see [`PrintUnixDialog`][crate::PrintUnixDialog].
    ///
    /// The typical way to use the high-level printing API is to create
    /// a [`PrintOperation`][crate::PrintOperation] object with [`new()`][Self::new()]
    /// when the user selects to print. Then you set some properties on it,
    /// e.g. the page size, any [`PrintSettings`][crate::PrintSettings] from previous print
    /// operations, the number of pages, the current page, etc.
    ///
    /// Then you start the print operation by calling [`PrintOperationExt::run()`][crate::prelude::PrintOperationExt::run()].
    /// It will then show a dialog, let the user select a printer and options.
    /// When the user finished the dialog, various signals will be emitted on
    /// the [`PrintOperation`][crate::PrintOperation], the main one being
    /// [`draw-page`][struct@crate::PrintOperation#draw-page], which you are supposed to handle
    /// and render the page on the provided [`PrintContext`][crate::PrintContext] using Cairo.
    ///
    /// # The high-level printing API
    ///
    /// **⚠️ The following code is in c ⚠️**
    ///
    /// ```c
    /// static GtkPrintSettings *settings = NULL;
    ///
    /// static void
    /// do_print (void)
    /// {
    ///   GtkPrintOperation *print;
    ///   GtkPrintOperationResult res;
    ///
    ///   print = gtk_print_operation_new ();
    ///
    ///   if (settings != NULL)
    ///     gtk_print_operation_set_print_settings (print, settings);
    ///
    ///   g_signal_connect (print, "begin_print", G_CALLBACK (begin_print), NULL);
    ///   g_signal_connect (print, "draw_page", G_CALLBACK (draw_page), NULL);
    ///
    ///   res = gtk_print_operation_run (print, GTK_PRINT_OPERATION_ACTION_PRINT_DIALOG,
    ///                                  GTK_WINDOW (main_window), NULL);
    ///
    ///   if (res == GTK_PRINT_OPERATION_RESULT_APPLY)
    ///     {
    ///       if (settings != NULL)
    ///         g_object_unref (settings);
    ///       settings = g_object_ref (gtk_print_operation_get_print_settings (print));
    ///     }
    ///
    ///   g_object_unref (print);
    /// }
    /// ```
    ///
    /// By default [`PrintOperation`][crate::PrintOperation] uses an external application to do
    /// print preview. To implement a custom print preview, an application
    /// must connect to the preview signal. The functions
    /// [`PrintOperationPreviewExt::render_page()`][crate::prelude::PrintOperationPreviewExt::render_page()],
    /// [`PrintOperationPreviewExt::end_preview()`][crate::prelude::PrintOperationPreviewExt::end_preview()] and
    /// [`PrintOperationPreviewExt::is_selected()`][crate::prelude::PrintOperationPreviewExt::is_selected()]
    /// are useful when implementing a print preview.
    ///
    /// ## Properties
    ///
    ///
    /// #### `allow-async`
    ///  Determines whether the print operation may run asynchronously or not.
    ///
    /// Some systems don't support asynchronous printing, but those that do
    /// will return [`PrintOperationResult::InProgress`][crate::PrintOperationResult::InProgress] as the status, and
    /// emit the [`done`][struct@crate::PrintOperation#done] signal when the operation
    /// is actually done.
    ///
    /// The Windows port does not support asynchronous operation at all (this
    /// is unlikely to change). On other platforms, all actions except for
    /// [`PrintOperationAction::Export`][crate::PrintOperationAction::Export] support asynchronous operation.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `current-page`
    ///  The current page in the document.
    ///
    /// If this is set before [`PrintOperationExt::run()`][crate::prelude::PrintOperationExt::run()],
    /// the user will be able to select to print only the current page.
    ///
    /// Note that this only makes sense for pre-paginated documents.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `custom-tab-label`
    ///  Used as the label of the tab containing custom widgets.
    ///
    /// Note that this property may be ignored on some platforms.
    ///
    /// If this is [`None`], GTK uses a default label.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `default-page-setup`
    ///  The [`PageSetup`][crate::PageSetup] used by default.
    ///
    /// This page setup will be used by [`PrintOperationExt::run()`][crate::prelude::PrintOperationExt::run()],
    /// but it can be overridden on a per-page basis by connecting
    /// to the [`request-page-setup`][struct@crate::PrintOperation#request-page-setup] signal.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `embed-page-setup`
    ///  If [`true`], page size combo box and orientation combo box
    /// are embedded into page setup page.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `export-filename`
    ///  The name of a file to generate instead of showing the print dialog.
    ///
    /// Currently, PDF is the only supported format.
    ///
    /// The intended use of this property is for implementing
    /// “Export to PDF” actions.
    ///
    /// “Print to PDF” support is independent of this and is done
    /// by letting the user pick the “Print to PDF” item from the
    /// list of printers in the print dialog.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `has-selection`
    ///  Determines whether there is a selection in your application.
    ///
    /// This can allow your application to print the selection.
    /// This is typically used to make a "Selection" button sensitive.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `job-name`
    ///  A string used to identify the job (e.g. in monitoring
    /// applications like eggcups).
    ///
    /// If you don't set a job name, GTK picks a default one
    /// by numbering successive print jobs.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `n-pages`
    ///  The number of pages in the document.
    ///
    /// This must be set to a positive number before the rendering
    /// starts. It may be set in a [`begin-print`][struct@crate::PrintOperation#begin-print]
    /// signal handler.
    ///
    /// Note that the page numbers passed to the
    /// [`request-page-setup`][struct@crate::PrintOperation#request-page-setup] and
    /// [`draw-page`][struct@crate::PrintOperation#draw-page] signals are 0-based, i.e.
    /// if the user chooses to print all pages, the last ::draw-page signal
    /// will be for page @n_pages - 1.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `n-pages-to-print`
    ///  The number of pages that will be printed.
    ///
    /// Note that this value is set during print preparation phase
    /// ([`PrintStatus::Preparing`][crate::PrintStatus::Preparing]), so this value should never be
    /// get before the data generation phase ([`PrintStatus::GeneratingData`][crate::PrintStatus::GeneratingData]).
    /// You can connect to the [`status-changed`][struct@crate::PrintOperation#status-changed] signal
    /// and call [`PrintOperationExt::n_pages_to_print()`][crate::prelude::PrintOperationExt::n_pages_to_print()] when
    /// print status is [`PrintStatus::GeneratingData`][crate::PrintStatus::GeneratingData].
    ///
    /// This is typically used to track the progress of print operation.
    ///
    /// Readable
    ///
    ///
    /// #### `print-settings`
    ///  The [`PrintSettings`][crate::PrintSettings] used for initializing the dialog.
    ///
    /// Setting this property is typically used to re-establish
    /// print settings from a previous print operation, see
    /// [`PrintOperationExt::run()`][crate::prelude::PrintOperationExt::run()].
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `show-progress`
    ///  Determines whether to show a progress dialog during the
    /// print operation.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `status`
    ///  The status of the print operation.
    ///
    /// Readable
    ///
    ///
    /// #### `status-string`
    ///  A string representation of the status of the print operation.
    ///
    /// The string is translated and suitable for displaying the print
    /// status e.g. in a [`Statusbar`][crate::Statusbar].
    ///
    /// See the [`status`][struct@crate::PrintOperation#status] property for a status
    /// value that is suitable for programmatic use.
    ///
    /// Readable
    ///
    ///
    /// #### `support-selection`
    ///  If [`true`], the print operation will support print of selection.
    ///
    /// This allows the print dialog to show a "Selection" button.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `track-print-status`
    ///  If [`true`], the print operation will try to continue report on
    /// the status of the print job in the printer queues and printer.
    ///
    /// This can allow your application to show things like “out of paper”
    /// issues, and when the print job actually reaches the printer.
    /// However, this is often implemented using polling, and should
    /// not be enabled unless needed.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `unit`
    ///  The transformation for the cairo context obtained from
    /// [`PrintContext`][crate::PrintContext] is set up in such a way that distances
    /// are measured in units of @unit.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `use-full-page`
    ///  If [`true`], the transformation for the cairo context obtained
    /// from [`PrintContext`][crate::PrintContext] puts the origin at the top left corner
    /// of the page.
    ///
    /// This may not be the top left corner of the sheet, depending on
    /// page orientation and the number of pages per sheet. Otherwise,
    /// the origin is at the top left corner of the imageable area (i.e.
    /// inside the margins).
    ///
    /// Readable | Writeable
    ///
    /// ## Signals
    ///
    ///
    /// #### `begin-print`
    ///  Emitted after the user has finished changing print settings
    /// in the dialog, before the actual rendering starts.
    ///
    /// A typical use for ::begin-print is to use the parameters from the
    /// [`PrintContext`][crate::PrintContext] and paginate the document accordingly,
    /// and then set the number of pages with
    /// [`PrintOperationExt::set_n_pages()`][crate::prelude::PrintOperationExt::set_n_pages()].
    ///
    ///
    ///
    ///
    /// #### `create-custom-widget`
    ///  Emitted when displaying the print dialog.
    ///
    /// If you return a widget in a handler for this signal it will be
    /// added to a custom tab in the print dialog. You typically return a
    /// container widget with multiple widgets in it.
    ///
    /// The print dialog owns the returned widget, and its lifetime is not
    /// controlled by the application. However, the widget is guaranteed
    /// to stay around until the [`custom-widget-apply`][struct@crate::PrintOperation#custom-widget-apply]
    /// signal is emitted on the operation. Then you can read out any
    /// information you need from the widgets.
    ///
    ///
    ///
    ///
    /// #### `custom-widget-apply`
    ///  Emitted right before ::begin-print if you added
    /// a custom widget in the ::create-custom-widget handler.
    ///
    /// When you get this signal you should read the information from the
    /// custom widgets, as the widgets are not guaranteed to be around at a
    /// later time.
    ///
    ///
    ///
    ///
    /// #### `done`
    ///  Emitted when the print operation run has finished doing
    /// everything required for printing.
    ///
    /// @result gives you information about what happened during the run.
    /// If @result is [`PrintOperationResult::Error`][crate::PrintOperationResult::Error] then you can call
    /// `Gtk::PrintOperation::get_error()` for more information.
    ///
    /// If you enabled print status tracking then
    /// [`PrintOperationExt::is_finished()`][crate::prelude::PrintOperationExt::is_finished()] may still return [`false`]
    /// after the ::done signal was emitted.
    ///
    ///
    ///
    ///
    /// #### `draw-page`
    ///  Emitted for every page that is printed.
    ///
    /// The signal handler must render the @page_nr's page onto the cairo
    /// context obtained from @context using
    /// [`PrintContext::cairo_context()`][crate::PrintContext::cairo_context()].
    ///
    /// **⚠️ The following code is in c ⚠️**
    ///
    /// ```c
    /// static void
    /// draw_page (GtkPrintOperation *operation,
    ///            GtkPrintContext   *context,
    ///            int                page_nr,
    ///            gpointer           user_data)
    /// {
    ///   cairo_t *cr;
    ///   PangoLayout *layout;
    ///   double width, text_height;
    ///   int layout_height;
    ///   PangoFontDescription *desc;
    ///
    ///   cr = gtk_print_context_get_cairo_context (context);
    ///   width = gtk_print_context_get_width (context);
    ///
    ///   cairo_rectangle (cr, 0, 0, width, HEADER_HEIGHT);
    ///
    ///   cairo_set_source_rgb (cr, 0.8, 0.8, 0.8);
    ///   cairo_fill (cr);
    ///
    ///   layout = gtk_print_context_create_pango_layout (context);
    ///
    ///   desc = pango_font_description_from_string ("sans 14");
    ///   pango_layout_set_font_description (layout, desc);
    ///   pango_font_description_free (desc);
    ///
    ///   pango_layout_set_text (layout, "some text", -1);
    ///   pango_layout_set_width (layout, width * PANGO_SCALE);
    ///   pango_layout_set_alignment (layout, PANGO_ALIGN_CENTER);
    ///
    ///   pango_layout_get_size (layout, NULL, &layout_height);
    ///   text_height = (double)layout_height / PANGO_SCALE;
    ///
    ///   cairo_move_to (cr, width / 2,  (HEADER_HEIGHT - text_height) / 2);
    ///   pango_cairo_show_layout (cr, layout);
    ///
    ///   g_object_unref (layout);
    /// }
    /// ```
    ///
    /// Use [`PrintOperationExt::set_use_full_page()`][crate::prelude::PrintOperationExt::set_use_full_page()] and
    /// [`PrintOperationExt::set_unit()`][crate::prelude::PrintOperationExt::set_unit()] before starting the print
    /// operation to set up the transformation of the cairo context
    /// according to your needs.
    ///
    ///
    ///
    ///
    /// #### `end-print`
    ///  Emitted after all pages have been rendered.
    ///
    /// A handler for this signal can clean up any resources that have
    /// been allocated in the [`begin-print`][struct@crate::PrintOperation#begin-print] handler.
    ///
    ///
    ///
    ///
    /// #### `paginate`
    ///  Emitted after the ::begin-print signal, but before the actual rendering
    /// starts.
    ///
    /// It keeps getting emitted until a connected signal handler returns [`true`].
    ///
    /// The ::paginate signal is intended to be used for paginating a document
    /// in small chunks, to avoid blocking the user interface for a long
    /// time. The signal handler should update the number of pages using
    /// [`PrintOperationExt::set_n_pages()`][crate::prelude::PrintOperationExt::set_n_pages()], and return [`true`] if the document
    /// has been completely paginated.
    ///
    /// If you don't need to do pagination in chunks, you can simply do
    /// it all in the ::begin-print handler, and set the number of pages
    /// from there.
    ///
    ///
    ///
    ///
    /// #### `preview`
    ///  Gets emitted when a preview is requested from the native dialog.
    ///
    /// The default handler for this signal uses an external viewer
    /// application to preview.
    ///
    /// To implement a custom print preview, an application must return
    /// [`true`] from its handler for this signal. In order to use the
    /// provided @context for the preview implementation, it must be
    /// given a suitable cairo context with
    /// [`PrintContext::set_cairo_context()`][crate::PrintContext::set_cairo_context()].
    ///
    /// The custom preview implementation can use
    /// [`PrintOperationPreviewExt::is_selected()`][crate::prelude::PrintOperationPreviewExt::is_selected()] and
    /// [`PrintOperationPreviewExt::render_page()`][crate::prelude::PrintOperationPreviewExt::render_page()] to find pages which
    /// are selected for print and render them. The preview must be
    /// finished by calling [`PrintOperationPreviewExt::end_preview()`][crate::prelude::PrintOperationPreviewExt::end_preview()]
    /// (typically in response to the user clicking a close button).
    ///
    ///
    ///
    ///
    /// #### `request-page-setup`
    ///  Emitted once for every page that is printed.
    ///
    /// This gives the application a chance to modify the page setup.
    /// Any changes done to @setup will be in force only for printing
    /// this page.
    ///
    ///
    ///
    ///
    /// #### `status-changed`
    ///  Emitted at between the various phases of the print operation.
    ///
    /// See [`PrintStatus`][crate::PrintStatus] for the phases that are being discriminated.
    /// Use [`PrintOperationExt::status()`][crate::prelude::PrintOperationExt::status()] to find out the current
    /// status.
    ///
    ///
    ///
    ///
    /// #### `update-custom-widget`
    ///  Emitted after change of selected printer.
    ///
    /// The actual page setup and print settings are passed to the custom
    /// widget, which can actualize itself according to this change.
    ///
    ///
    /// <details><summary><h4>PrintOperationPreview</h4></summary>
    ///
    ///
    /// #### `got-page-size`
    ///  Emitted once for each page that gets rendered to the preview.
    ///
    /// A handler for this signal should update the @context
    /// according to @page_setup and set up a suitable cairo
    /// context, using [`PrintContext::set_cairo_context()`][crate::PrintContext::set_cairo_context()].
    ///
    ///
    ///
    ///
    /// #### `ready`
    ///  The ::ready signal gets emitted once per preview operation,
    /// before the first page is rendered.
    ///
    /// A handler for this signal can be used for setup tasks.
    ///
    ///
    /// </details>
    ///
    /// # Implements
    ///
    /// [`PrintOperationExt`][trait@crate::prelude::PrintOperationExt], [`trait@glib::ObjectExt`], [`PrintOperationPreviewExt`][trait@crate::prelude::PrintOperationPreviewExt]
    #[doc(alias = "GtkPrintOperation")]
    pub struct PrintOperation(Object<ffi::GtkPrintOperation, ffi::GtkPrintOperationClass>) @implements PrintOperationPreview;

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

impl PrintOperation {
    pub const NONE: Option<&'static PrintOperation> = None;

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

    // rustdoc-stripper-ignore-next
    /// Creates a new builder-pattern struct instance to construct [`PrintOperation`] objects.
    ///
    /// This method returns an instance of [`PrintOperationBuilder`](crate::builders::PrintOperationBuilder) which can be used to create [`PrintOperation`] objects.
    pub fn builder() -> PrintOperationBuilder {
        PrintOperationBuilder::new()
    }
}

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

// rustdoc-stripper-ignore-next
/// A [builder-pattern] type to construct [`PrintOperation`] objects.
///
/// [builder-pattern]: https://doc.rust-lang.org/1.0.0/style/ownership/builders.html
#[must_use = "The builder must be built to be used"]
pub struct PrintOperationBuilder {
    builder: glib::object::ObjectBuilder<'static, PrintOperation>,
}

impl PrintOperationBuilder {
    fn new() -> Self {
        Self {
            builder: glib::object::Object::builder(),
        }
    }

    /// Determines whether the print operation may run asynchronously or not.
    ///
    /// Some systems don't support asynchronous printing, but those that do
    /// will return [`PrintOperationResult::InProgress`][crate::PrintOperationResult::InProgress] as the status, and
    /// emit the [`done`][struct@crate::PrintOperation#done] signal when the operation
    /// is actually done.
    ///
    /// The Windows port does not support asynchronous operation at all (this
    /// is unlikely to change). On other platforms, all actions except for
    /// [`PrintOperationAction::Export`][crate::PrintOperationAction::Export] support asynchronous operation.
    pub fn allow_async(self, allow_async: bool) -> Self {
        Self {
            builder: self.builder.property("allow-async", allow_async),
        }
    }

    /// The current page in the document.
    ///
    /// If this is set before [`PrintOperationExt::run()`][crate::prelude::PrintOperationExt::run()],
    /// the user will be able to select to print only the current page.
    ///
    /// Note that this only makes sense for pre-paginated documents.
    pub fn current_page(self, current_page: i32) -> Self {
        Self {
            builder: self.builder.property("current-page", current_page),
        }
    }

    /// Used as the label of the tab containing custom widgets.
    ///
    /// Note that this property may be ignored on some platforms.
    ///
    /// If this is [`None`], GTK uses a default label.
    pub fn custom_tab_label(self, custom_tab_label: impl Into<glib::GString>) -> Self {
        Self {
            builder: self
                .builder
                .property("custom-tab-label", custom_tab_label.into()),
        }
    }

    /// The [`PageSetup`][crate::PageSetup] used by default.
    ///
    /// This page setup will be used by [`PrintOperationExt::run()`][crate::prelude::PrintOperationExt::run()],
    /// but it can be overridden on a per-page basis by connecting
    /// to the [`request-page-setup`][struct@crate::PrintOperation#request-page-setup] signal.
    pub fn default_page_setup(self, default_page_setup: &PageSetup) -> Self {
        Self {
            builder: self
                .builder
                .property("default-page-setup", default_page_setup.clone()),
        }
    }

    /// If [`true`], page size combo box and orientation combo box
    /// are embedded into page setup page.
    pub fn embed_page_setup(self, embed_page_setup: bool) -> Self {
        Self {
            builder: self.builder.property("embed-page-setup", embed_page_setup),
        }
    }

    /// The name of a file to generate instead of showing the print dialog.
    ///
    /// Currently, PDF is the only supported format.
    ///
    /// The intended use of this property is for implementing
    /// “Export to PDF” actions.
    ///
    /// “Print to PDF” support is independent of this and is done
    /// by letting the user pick the “Print to PDF” item from the
    /// list of printers in the print dialog.
    pub fn export_filename(self, export_filename: impl Into<glib::GString>) -> Self {
        Self {
            builder: self
                .builder
                .property("export-filename", export_filename.into()),
        }
    }

    /// Determines whether there is a selection in your application.
    ///
    /// This can allow your application to print the selection.
    /// This is typically used to make a "Selection" button sensitive.
    pub fn has_selection(self, has_selection: bool) -> Self {
        Self {
            builder: self.builder.property("has-selection", has_selection),
        }
    }

    /// A string used to identify the job (e.g. in monitoring
    /// applications like eggcups).
    ///
    /// If you don't set a job name, GTK picks a default one
    /// by numbering successive print jobs.
    pub fn job_name(self, job_name: impl Into<glib::GString>) -> Self {
        Self {
            builder: self.builder.property("job-name", job_name.into()),
        }
    }

    /// The number of pages in the document.
    ///
    /// This must be set to a positive number before the rendering
    /// starts. It may be set in a [`begin-print`][struct@crate::PrintOperation#begin-print]
    /// signal handler.
    ///
    /// Note that the page numbers passed to the
    /// [`request-page-setup`][struct@crate::PrintOperation#request-page-setup] and
    /// [`draw-page`][struct@crate::PrintOperation#draw-page] signals are 0-based, i.e.
    /// if the user chooses to print all pages, the last ::draw-page signal
    /// will be for page @n_pages - 1.
    pub fn n_pages(self, n_pages: i32) -> Self {
        Self {
            builder: self.builder.property("n-pages", n_pages),
        }
    }

    /// The [`PrintSettings`][crate::PrintSettings] used for initializing the dialog.
    ///
    /// Setting this property is typically used to re-establish
    /// print settings from a previous print operation, see
    /// [`PrintOperationExt::run()`][crate::prelude::PrintOperationExt::run()].
    pub fn print_settings(self, print_settings: &PrintSettings) -> Self {
        Self {
            builder: self
                .builder
                .property("print-settings", print_settings.clone()),
        }
    }

    /// Determines whether to show a progress dialog during the
    /// print operation.
    pub fn show_progress(self, show_progress: bool) -> Self {
        Self {
            builder: self.builder.property("show-progress", show_progress),
        }
    }

    /// If [`true`], the print operation will support print of selection.
    ///
    /// This allows the print dialog to show a "Selection" button.
    pub fn support_selection(self, support_selection: bool) -> Self {
        Self {
            builder: self
                .builder
                .property("support-selection", support_selection),
        }
    }

    /// If [`true`], the print operation will try to continue report on
    /// the status of the print job in the printer queues and printer.
    ///
    /// This can allow your application to show things like “out of paper”
    /// issues, and when the print job actually reaches the printer.
    /// However, this is often implemented using polling, and should
    /// not be enabled unless needed.
    pub fn track_print_status(self, track_print_status: bool) -> Self {
        Self {
            builder: self
                .builder
                .property("track-print-status", track_print_status),
        }
    }

    /// The transformation for the cairo context obtained from
    /// [`PrintContext`][crate::PrintContext] is set up in such a way that distances
    /// are measured in units of @unit.
    pub fn unit(self, unit: Unit) -> Self {
        Self {
            builder: self.builder.property("unit", unit),
        }
    }

    /// If [`true`], the transformation for the cairo context obtained
    /// from [`PrintContext`][crate::PrintContext] puts the origin at the top left corner
    /// of the page.
    ///
    /// This may not be the top left corner of the sheet, depending on
    /// page orientation and the number of pages per sheet. Otherwise,
    /// the origin is at the top left corner of the imageable area (i.e.
    /// inside the margins).
    pub fn use_full_page(self, use_full_page: bool) -> Self {
        Self {
            builder: self.builder.property("use-full-page", use_full_page),
        }
    }

    // rustdoc-stripper-ignore-next
    /// Build the [`PrintOperation`].
    #[must_use = "Building the object from the builder is usually expensive and is not expected to have side effects"]
    pub fn build(self) -> PrintOperation {
        self.builder.build()
    }
}

mod sealed {
    pub trait Sealed {}
    impl<T: super::IsA<super::PrintOperation>> Sealed for T {}
}

/// Trait containing all [`struct@PrintOperation`] methods.
///
/// # Implementors
///
/// [`PrintOperation`][struct@crate::PrintOperation]
pub trait PrintOperationExt: IsA<PrintOperation> + sealed::Sealed + 'static {
    /// Cancels a running print operation.
    ///
    /// This function may be called from a [`begin-print`][struct@crate::PrintOperation#begin-print],
    /// [`paginate`][struct@crate::PrintOperation#paginate] or [`draw-page`][struct@crate::PrintOperation#draw-page]
    /// signal handler to stop the currently running print operation.
    #[doc(alias = "gtk_print_operation_cancel")]
    fn cancel(&self) {
        unsafe {
            ffi::gtk_print_operation_cancel(self.as_ref().to_glib_none().0);
        }
    }

    /// Signal that drawing of particular page is complete.
    ///
    /// It is called after completion of page drawing (e.g. drawing
    /// in another thread). If [`set_defer_drawing()`][Self::set_defer_drawing()]
    /// was called before, then this function has to be called by application.
    /// Otherwise it is called by GTK itself.
    #[doc(alias = "gtk_print_operation_draw_page_finish")]
    fn draw_page_finish(&self) {
        unsafe {
            ffi::gtk_print_operation_draw_page_finish(self.as_ref().to_glib_none().0);
        }
    }

    /// Returns the default page setup.
    ///
    /// # Returns
    ///
    /// the default page setup
    #[doc(alias = "gtk_print_operation_get_default_page_setup")]
    #[doc(alias = "get_default_page_setup")]
    #[doc(alias = "default-page-setup")]
    fn default_page_setup(&self) -> PageSetup {
        unsafe {
            from_glib_none(ffi::gtk_print_operation_get_default_page_setup(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Gets whether page setup selection combos are embedded
    ///
    /// # Returns
    ///
    /// whether page setup selection combos are embedded
    #[doc(alias = "gtk_print_operation_get_embed_page_setup")]
    #[doc(alias = "get_embed_page_setup")]
    #[doc(alias = "embed-page-setup")]
    fn embeds_page_setup(&self) -> bool {
        unsafe {
            from_glib(ffi::gtk_print_operation_get_embed_page_setup(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Gets whether there is a selection.
    ///
    /// # Returns
    ///
    /// whether there is a selection
    #[doc(alias = "gtk_print_operation_get_has_selection")]
    #[doc(alias = "get_has_selection")]
    #[doc(alias = "has-selection")]
    fn has_selection(&self) -> bool {
        unsafe {
            from_glib(ffi::gtk_print_operation_get_has_selection(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Returns the number of pages that will be printed.
    ///
    /// Note that this value is set during print preparation phase
    /// ([`PrintStatus::Preparing`][crate::PrintStatus::Preparing]), so this function should never be
    /// called before the data generation phase ([`PrintStatus::GeneratingData`][crate::PrintStatus::GeneratingData]).
    /// You can connect to the [`status-changed`][struct@crate::PrintOperation#status-changed]
    /// signal and call gtk_print_operation_get_n_pages_to_print() when
    /// print status is [`PrintStatus::GeneratingData`][crate::PrintStatus::GeneratingData].
    ///
    /// This is typically used to track the progress of print operation.
    ///
    /// # Returns
    ///
    /// the number of pages that will be printed
    #[doc(alias = "gtk_print_operation_get_n_pages_to_print")]
    #[doc(alias = "get_n_pages_to_print")]
    #[doc(alias = "n-pages-to-print")]
    fn n_pages_to_print(&self) -> i32 {
        unsafe { ffi::gtk_print_operation_get_n_pages_to_print(self.as_ref().to_glib_none().0) }
    }

    /// Returns the current print settings.
    ///
    /// Note that the return value is [`None`] until either
    /// [`set_print_settings()`][Self::set_print_settings()] or
    /// [`run()`][Self::run()] have been called.
    ///
    /// # Returns
    ///
    /// the current print settings of @self.
    #[doc(alias = "gtk_print_operation_get_print_settings")]
    #[doc(alias = "get_print_settings")]
    #[doc(alias = "print-settings")]
    fn print_settings(&self) -> Option<PrintSettings> {
        unsafe {
            from_glib_none(ffi::gtk_print_operation_get_print_settings(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Returns the status of the print operation.
    ///
    /// Also see [`status_string()`][Self::status_string()].
    ///
    /// # Returns
    ///
    /// the status of the print operation
    #[doc(alias = "gtk_print_operation_get_status")]
    #[doc(alias = "get_status")]
    fn status(&self) -> PrintStatus {
        unsafe {
            from_glib(ffi::gtk_print_operation_get_status(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Returns a string representation of the status of the
    /// print operation.
    ///
    /// The string is translated and suitable for displaying
    /// the print status e.g. in a [`Statusbar`][crate::Statusbar].
    ///
    /// Use [`status()`][Self::status()] to obtain
    /// a status value that is suitable for programmatic use.
    ///
    /// # Returns
    ///
    /// a string representation of the status
    ///    of the print operation
    #[doc(alias = "gtk_print_operation_get_status_string")]
    #[doc(alias = "get_status_string")]
    #[doc(alias = "status-string")]
    fn status_string(&self) -> glib::GString {
        unsafe {
            from_glib_none(ffi::gtk_print_operation_get_status_string(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Gets whether the application supports print of selection
    ///
    /// # Returns
    ///
    /// whether the application supports print of selection
    #[doc(alias = "gtk_print_operation_get_support_selection")]
    #[doc(alias = "get_support_selection")]
    #[doc(alias = "support-selection")]
    fn supports_selection(&self) -> bool {
        unsafe {
            from_glib(ffi::gtk_print_operation_get_support_selection(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// A convenience function to find out if the print operation
    /// is finished.
    ///
    /// a print operation is finished if its status is either
    /// [`PrintStatus::Finished`][crate::PrintStatus::Finished] or [`PrintStatus::FinishedAborted`][crate::PrintStatus::FinishedAborted].
    ///
    /// Note: when you enable print status tracking the print operation
    /// can be in a non-finished state even after done has been called, as
    /// the operation status then tracks the print job status on the printer.
    ///
    /// # Returns
    ///
    /// [`true`], if the print operation is finished.
    #[doc(alias = "gtk_print_operation_is_finished")]
    fn is_finished(&self) -> bool {
        unsafe {
            from_glib(ffi::gtk_print_operation_is_finished(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Runs the print operation.
    ///
    /// Normally that this function does not return until the rendering
    /// of all pages is complete. You can connect to the
    /// [`status-changed`][struct@crate::PrintOperation#status-changed] signal on @self to obtain
    /// some information about the progress of the print operation.
    ///
    /// Furthermore, it may use a recursive mainloop to show the print dialog.
    ///
    /// If you set the [Gtk.PrintOperation:allow-async] property, the operation
    /// will run asynchronously if this is supported on the platform. The
    /// [`done`][struct@crate::PrintOperation#done] signal will be emitted with the result
    /// of the operation when the it is done (i.e. when the dialog is canceled,
    /// or when the print succeeds or fails).
    ///
    /// **⚠️ The following code is in c ⚠️**
    ///
    /// ```c
    /// if (settings != NULL)
    ///   gtk_print_operation_set_print_settings (print, settings);
    ///
    /// if (page_setup != NULL)
    ///   gtk_print_operation_set_default_page_setup (print, page_setup);
    ///
    /// g_signal_connect (print, "begin-print",
    ///                   G_CALLBACK (begin_print), &data);
    /// g_signal_connect (print, "draw-page",
    ///                   G_CALLBACK (draw_page), &data);
    ///
    /// res = gtk_print_operation_run (print,
    ///                                GTK_PRINT_OPERATION_ACTION_PRINT_DIALOG,
    ///                                parent,
    ///                                &error);
    ///
    /// if (res == GTK_PRINT_OPERATION_RESULT_ERROR)
    ///  {
    ///    error_dialog = gtk_message_dialog_new (GTK_WINDOW (parent),
    ///                                    GTK_DIALOG_DESTROY_WITH_PARENT,
    ///                          GTK_MESSAGE_ERROR,
    ///                          GTK_BUTTONS_CLOSE,
    ///                          "Error printing file:\n%s",
    ///                          error->message);
    ///    g_signal_connect (error_dialog, "response",
    ///                      G_CALLBACK (gtk_window_destroy), NULL);
    ///    gtk_window_present (GTK_WINDOW (error_dialog));
    ///    g_error_free (error);
    ///  }
    /// else if (res == GTK_PRINT_OPERATION_RESULT_APPLY)
    ///  {
    ///    if (settings != NULL)
    /// g_object_unref (settings);
    ///    settings = g_object_ref (gtk_print_operation_get_print_settings (print));
    ///  }
    /// ```
    ///
    /// Note that gtk_print_operation_run() can only be called once on a
    /// given [`PrintOperation`][crate::PrintOperation].
    /// ## `action`
    /// the action to start
    /// ## `parent`
    /// Transient parent of the dialog
    ///
    /// # Returns
    ///
    /// the result of the print operation. A return value of
    ///   [`PrintOperationResult::Apply`][crate::PrintOperationResult::Apply] indicates that the printing was
    ///   completed successfully. In this case, it is a good idea to obtain
    ///   the used print settings with
    ///   [`print_settings()`][Self::print_settings()]
    ///   and store them for reuse with the next print operation. A value of
    ///   [`PrintOperationResult::InProgress`][crate::PrintOperationResult::InProgress] means the operation is running
    ///   asynchronously, and will emit the [`done`][struct@crate::PrintOperation#done]
    ///   signal when done.
    #[doc(alias = "gtk_print_operation_run")]
    fn run(
        &self,
        action: PrintOperationAction,
        parent: Option<&impl IsA<Window>>,
    ) -> Result<PrintOperationResult, glib::Error> {
        unsafe {
            let mut error = std::ptr::null_mut();
            let ret = ffi::gtk_print_operation_run(
                self.as_ref().to_glib_none().0,
                action.into_glib(),
                parent.map(|p| p.as_ref()).to_glib_none().0,
                &mut error,
            );
            if error.is_null() {
                Ok(from_glib(ret))
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    /// Sets whether gtk_print_operation_run() may return
    /// before the print operation is completed.
    ///
    /// Note that some platforms may not allow asynchronous
    /// operation.
    /// ## `allow_async`
    /// [`true`] to allow asynchronous operation
    #[doc(alias = "gtk_print_operation_set_allow_async")]
    #[doc(alias = "allow-async")]
    fn set_allow_async(&self, allow_async: bool) {
        unsafe {
            ffi::gtk_print_operation_set_allow_async(
                self.as_ref().to_glib_none().0,
                allow_async.into_glib(),
            );
        }
    }

    /// Sets the current page.
    ///
    /// If this is called before [`run()`][Self::run()],
    /// the user will be able to select to print only the current page.
    ///
    /// Note that this only makes sense for pre-paginated documents.
    /// ## `current_page`
    /// the current page, 0-based
    #[doc(alias = "gtk_print_operation_set_current_page")]
    #[doc(alias = "current-page")]
    fn set_current_page(&self, current_page: i32) {
        unsafe {
            ffi::gtk_print_operation_set_current_page(self.as_ref().to_glib_none().0, current_page);
        }
    }

    /// Sets the label for the tab holding custom widgets.
    /// ## `label`
    /// the label to use, or [`None`] to use the default label
    #[doc(alias = "gtk_print_operation_set_custom_tab_label")]
    #[doc(alias = "custom-tab-label")]
    fn set_custom_tab_label(&self, label: Option<&str>) {
        unsafe {
            ffi::gtk_print_operation_set_custom_tab_label(
                self.as_ref().to_glib_none().0,
                label.to_glib_none().0,
            );
        }
    }

    /// Makes @default_page_setup the default page setup for @self.
    ///
    /// This page setup will be used by [`run()`][Self::run()],
    /// but it can be overridden on a per-page basis by connecting
    /// to the [`request-page-setup`][struct@crate::PrintOperation#request-page-setup] signal.
    /// ## `default_page_setup`
    /// a [`PageSetup`][crate::PageSetup]
    #[doc(alias = "gtk_print_operation_set_default_page_setup")]
    #[doc(alias = "default-page-setup")]
    fn set_default_page_setup(&self, default_page_setup: Option<&PageSetup>) {
        unsafe {
            ffi::gtk_print_operation_set_default_page_setup(
                self.as_ref().to_glib_none().0,
                default_page_setup.to_glib_none().0,
            );
        }
    }

    /// Sets up the [`PrintOperation`][crate::PrintOperation] to wait for calling of
    /// [`draw_page_finish()`][Self::draw_page_finish()] from application.
    ///
    /// This can be used for drawing page in another thread.
    ///
    /// This function must be called in the callback of the
    /// [`draw-page`][struct@crate::PrintOperation#draw-page] signal.
    #[doc(alias = "gtk_print_operation_set_defer_drawing")]
    fn set_defer_drawing(&self) {
        unsafe {
            ffi::gtk_print_operation_set_defer_drawing(self.as_ref().to_glib_none().0);
        }
    }

    /// Embed page size combo box and orientation combo box into page setup page.
    ///
    /// Selected page setup is stored as default page setup in [`PrintOperation`][crate::PrintOperation].
    /// ## `embed`
    /// [`true`] to embed page setup selection in the [`PrintUnixDialog`][crate::PrintUnixDialog]
    #[doc(alias = "gtk_print_operation_set_embed_page_setup")]
    #[doc(alias = "embed-page-setup")]
    fn set_embed_page_setup(&self, embed: bool) {
        unsafe {
            ffi::gtk_print_operation_set_embed_page_setup(
                self.as_ref().to_glib_none().0,
                embed.into_glib(),
            );
        }
    }

    /// Sets up the [`PrintOperation`][crate::PrintOperation] to generate a file instead
    /// of showing the print dialog.
    ///
    /// The intended use of this function is for implementing
    /// “Export to PDF” actions. Currently, PDF is the only supported
    /// format.
    ///
    /// “Print to PDF” support is independent of this and is done
    /// by letting the user pick the “Print to PDF” item from the list
    /// of printers in the print dialog.
    /// ## `filename`
    /// the filename for the exported file
    #[doc(alias = "gtk_print_operation_set_export_filename")]
    #[doc(alias = "export-filename")]
    fn set_export_filename(&self, filename: impl AsRef<std::path::Path>) {
        unsafe {
            ffi::gtk_print_operation_set_export_filename(
                self.as_ref().to_glib_none().0,
                filename.as_ref().to_glib_none().0,
            );
        }
    }

    /// Sets whether there is a selection to print.
    ///
    /// Application has to set number of pages to which the selection
    /// will draw by [`set_n_pages()`][Self::set_n_pages()] in a handler
    /// for the [`begin-print`][struct@crate::PrintOperation#begin-print] signal.
    /// ## `has_selection`
    /// [`true`] indicates that a selection exists
    #[doc(alias = "gtk_print_operation_set_has_selection")]
    #[doc(alias = "has-selection")]
    fn set_has_selection(&self, has_selection: bool) {
        unsafe {
            ffi::gtk_print_operation_set_has_selection(
                self.as_ref().to_glib_none().0,
                has_selection.into_glib(),
            );
        }
    }

    /// Sets the name of the print job.
    ///
    /// The name is used to identify the job (e.g. in monitoring
    /// applications like eggcups).
    ///
    /// If you don’t set a job name, GTK picks a default one by
    /// numbering successive print jobs.
    /// ## `job_name`
    /// a string that identifies the print job
    #[doc(alias = "gtk_print_operation_set_job_name")]
    #[doc(alias = "job-name")]
    fn set_job_name(&self, job_name: &str) {
        unsafe {
            ffi::gtk_print_operation_set_job_name(
                self.as_ref().to_glib_none().0,
                job_name.to_glib_none().0,
            );
        }
    }

    /// Sets the number of pages in the document.
    ///
    /// This must be set to a positive number before the rendering
    /// starts. It may be set in a [`begin-print`][struct@crate::PrintOperation#begin-print]
    /// signal handler.
    ///
    /// Note that the page numbers passed to the
    /// [`request-page-setup`][struct@crate::PrintOperation#request-page-setup]
    /// and [`draw-page`][struct@crate::PrintOperation#draw-page] signals are 0-based, i.e.
    /// if the user chooses to print all pages, the last ::draw-page signal
    /// will be for page @n_pages - 1.
    /// ## `n_pages`
    /// the number of pages
    #[doc(alias = "gtk_print_operation_set_n_pages")]
    #[doc(alias = "n-pages")]
    fn set_n_pages(&self, n_pages: i32) {
        unsafe {
            ffi::gtk_print_operation_set_n_pages(self.as_ref().to_glib_none().0, n_pages);
        }
    }

    /// Sets the print settings for @self.
    ///
    /// This is typically used to re-establish print settings
    /// from a previous print operation, see [`run()`][Self::run()].
    /// ## `print_settings`
    /// [`PrintSettings`][crate::PrintSettings]
    #[doc(alias = "gtk_print_operation_set_print_settings")]
    #[doc(alias = "print-settings")]
    fn set_print_settings(&self, print_settings: Option<&PrintSettings>) {
        unsafe {
            ffi::gtk_print_operation_set_print_settings(
                self.as_ref().to_glib_none().0,
                print_settings.to_glib_none().0,
            );
        }
    }

    /// If @show_progress is [`true`], the print operation will show
    /// a progress dialog during the print operation.
    /// ## `show_progress`
    /// [`true`] to show a progress dialog
    #[doc(alias = "gtk_print_operation_set_show_progress")]
    #[doc(alias = "show-progress")]
    fn set_show_progress(&self, show_progress: bool) {
        unsafe {
            ffi::gtk_print_operation_set_show_progress(
                self.as_ref().to_glib_none().0,
                show_progress.into_glib(),
            );
        }
    }

    /// Sets whether selection is supported by [`PrintOperation`][crate::PrintOperation].
    /// ## `support_selection`
    /// [`true`] to support selection
    #[doc(alias = "gtk_print_operation_set_support_selection")]
    #[doc(alias = "support-selection")]
    fn set_support_selection(&self, support_selection: bool) {
        unsafe {
            ffi::gtk_print_operation_set_support_selection(
                self.as_ref().to_glib_none().0,
                support_selection.into_glib(),
            );
        }
    }

    /// If track_status is [`true`], the print operation will try to continue
    /// report on the status of the print job in the printer queues and printer.
    ///
    /// This can allow your application to show things like “out of paper”
    /// issues, and when the print job actually reaches the printer.
    ///
    /// This function is often implemented using some form of polling,
    /// so it should not be enabled unless needed.
    /// ## `track_status`
    /// [`true`] to track status after printing
    #[doc(alias = "gtk_print_operation_set_track_print_status")]
    #[doc(alias = "track-print-status")]
    fn set_track_print_status(&self, track_status: bool) {
        unsafe {
            ffi::gtk_print_operation_set_track_print_status(
                self.as_ref().to_glib_none().0,
                track_status.into_glib(),
            );
        }
    }

    /// Sets up the transformation for the cairo context obtained from
    /// [`PrintContext`][crate::PrintContext] in such a way that distances are measured in
    /// units of @unit.
    /// ## `unit`
    /// the unit to use
    #[doc(alias = "gtk_print_operation_set_unit")]
    #[doc(alias = "unit")]
    fn set_unit(&self, unit: Unit) {
        unsafe {
            ffi::gtk_print_operation_set_unit(self.as_ref().to_glib_none().0, unit.into_glib());
        }
    }

    /// If @full_page is [`true`], the transformation for the cairo context
    /// obtained from [`PrintContext`][crate::PrintContext] puts the origin at the top left
    /// corner of the page.
    ///
    /// This may not be the top left corner of the sheet, depending on page
    /// orientation and the number of pages per sheet). Otherwise, the origin
    /// is at the top left corner of the imageable area (i.e. inside the margins).
    /// ## `full_page`
    /// [`true`] to set up the [`PrintContext`][crate::PrintContext] for the full page
    #[doc(alias = "gtk_print_operation_set_use_full_page")]
    #[doc(alias = "use-full-page")]
    fn set_use_full_page(&self, full_page: bool) {
        unsafe {
            ffi::gtk_print_operation_set_use_full_page(
                self.as_ref().to_glib_none().0,
                full_page.into_glib(),
            );
        }
    }

    /// Determines whether the print operation may run asynchronously or not.
    ///
    /// Some systems don't support asynchronous printing, but those that do
    /// will return [`PrintOperationResult::InProgress`][crate::PrintOperationResult::InProgress] as the status, and
    /// emit the [`done`][struct@crate::PrintOperation#done] signal when the operation
    /// is actually done.
    ///
    /// The Windows port does not support asynchronous operation at all (this
    /// is unlikely to change). On other platforms, all actions except for
    /// [`PrintOperationAction::Export`][crate::PrintOperationAction::Export] support asynchronous operation.
    #[doc(alias = "allow-async")]
    fn allows_async(&self) -> bool {
        ObjectExt::property(self.as_ref(), "allow-async")
    }

    /// The current page in the document.
    ///
    /// If this is set before [`run()`][Self::run()],
    /// the user will be able to select to print only the current page.
    ///
    /// Note that this only makes sense for pre-paginated documents.
    #[doc(alias = "current-page")]
    fn current_page(&self) -> i32 {
        ObjectExt::property(self.as_ref(), "current-page")
    }

    /// Used as the label of the tab containing custom widgets.
    ///
    /// Note that this property may be ignored on some platforms.
    ///
    /// If this is [`None`], GTK uses a default label.
    #[doc(alias = "custom-tab-label")]
    fn custom_tab_label(&self) -> Option<glib::GString> {
        ObjectExt::property(self.as_ref(), "custom-tab-label")
    }

    /// The name of a file to generate instead of showing the print dialog.
    ///
    /// Currently, PDF is the only supported format.
    ///
    /// The intended use of this property is for implementing
    /// “Export to PDF” actions.
    ///
    /// “Print to PDF” support is independent of this and is done
    /// by letting the user pick the “Print to PDF” item from the
    /// list of printers in the print dialog.
    #[doc(alias = "export-filename")]
    fn export_filename(&self) -> Option<glib::GString> {
        ObjectExt::property(self.as_ref(), "export-filename")
    }

    /// A string used to identify the job (e.g. in monitoring
    /// applications like eggcups).
    ///
    /// If you don't set a job name, GTK picks a default one
    /// by numbering successive print jobs.
    #[doc(alias = "job-name")]
    fn job_name(&self) -> Option<glib::GString> {
        ObjectExt::property(self.as_ref(), "job-name")
    }

    /// The number of pages in the document.
    ///
    /// This must be set to a positive number before the rendering
    /// starts. It may be set in a [`begin-print`][struct@crate::PrintOperation#begin-print]
    /// signal handler.
    ///
    /// Note that the page numbers passed to the
    /// [`request-page-setup`][struct@crate::PrintOperation#request-page-setup] and
    /// [`draw-page`][struct@crate::PrintOperation#draw-page] signals are 0-based, i.e.
    /// if the user chooses to print all pages, the last ::draw-page signal
    /// will be for page @n_pages - 1.
    #[doc(alias = "n-pages")]
    fn n_pages(&self) -> i32 {
        ObjectExt::property(self.as_ref(), "n-pages")
    }

    /// Determines whether to show a progress dialog during the
    /// print operation.
    #[doc(alias = "show-progress")]
    fn shows_progress(&self) -> bool {
        ObjectExt::property(self.as_ref(), "show-progress")
    }

    /// If [`true`], the print operation will try to continue report on
    /// the status of the print job in the printer queues and printer.
    ///
    /// This can allow your application to show things like “out of paper”
    /// issues, and when the print job actually reaches the printer.
    /// However, this is often implemented using polling, and should
    /// not be enabled unless needed.
    #[doc(alias = "track-print-status")]
    fn tracks_print_status(&self) -> bool {
        ObjectExt::property(self.as_ref(), "track-print-status")
    }

    /// The transformation for the cairo context obtained from
    /// [`PrintContext`][crate::PrintContext] is set up in such a way that distances
    /// are measured in units of @unit.
    fn unit(&self) -> Unit {
        ObjectExt::property(self.as_ref(), "unit")
    }

    /// If [`true`], the transformation for the cairo context obtained
    /// from [`PrintContext`][crate::PrintContext] puts the origin at the top left corner
    /// of the page.
    ///
    /// This may not be the top left corner of the sheet, depending on
    /// page orientation and the number of pages per sheet. Otherwise,
    /// the origin is at the top left corner of the imageable area (i.e.
    /// inside the margins).
    #[doc(alias = "use-full-page")]
    fn uses_full_page(&self) -> bool {
        ObjectExt::property(self.as_ref(), "use-full-page")
    }

    /// Emitted after the user has finished changing print settings
    /// in the dialog, before the actual rendering starts.
    ///
    /// A typical use for ::begin-print is to use the parameters from the
    /// [`PrintContext`][crate::PrintContext] and paginate the document accordingly,
    /// and then set the number of pages with
    /// [`set_n_pages()`][Self::set_n_pages()].
    /// ## `context`
    /// the [`PrintContext`][crate::PrintContext] for the current operation
    #[doc(alias = "begin-print")]
    fn connect_begin_print<F: Fn(&Self, &PrintContext) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn begin_print_trampoline<
            P: IsA<PrintOperation>,
            F: Fn(&P, &PrintContext) + 'static,
        >(
            this: *mut ffi::GtkPrintOperation,
            context: *mut ffi::GtkPrintContext,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(
                PrintOperation::from_glib_borrow(this).unsafe_cast_ref(),
                &from_glib_borrow(context),
            )
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"begin-print\0".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    begin_print_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    /// Emitted when displaying the print dialog.
    ///
    /// If you return a widget in a handler for this signal it will be
    /// added to a custom tab in the print dialog. You typically return a
    /// container widget with multiple widgets in it.
    ///
    /// The print dialog owns the returned widget, and its lifetime is not
    /// controlled by the application. However, the widget is guaranteed
    /// to stay around until the [`custom-widget-apply`][struct@crate::PrintOperation#custom-widget-apply]
    /// signal is emitted on the operation. Then you can read out any
    /// information you need from the widgets.
    ///
    /// # Returns
    ///
    /// A custom widget that gets embedded in
    ///   the print dialog
    #[doc(alias = "create-custom-widget")]
    fn connect_create_custom_widget<F: Fn(&Self) -> Option<glib::Object> + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn create_custom_widget_trampoline<
            P: IsA<PrintOperation>,
            F: Fn(&P) -> Option<glib::Object> + 'static,
        >(
            this: *mut ffi::GtkPrintOperation,
            f: glib::ffi::gpointer,
        ) -> *mut glib::gobject_ffi::GObject {
            let f: &F = &*(f as *const F);
            f(PrintOperation::from_glib_borrow(this).unsafe_cast_ref()) /*Not checked*/
                .to_glib_none()
                .0
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"create-custom-widget\0".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    create_custom_widget_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    /// Emitted right before ::begin-print if you added
    /// a custom widget in the ::create-custom-widget handler.
    ///
    /// When you get this signal you should read the information from the
    /// custom widgets, as the widgets are not guaranteed to be around at a
    /// later time.
    /// ## `widget`
    /// the custom widget added in ::create-custom-widget
    #[doc(alias = "custom-widget-apply")]
    fn connect_custom_widget_apply<F: Fn(&Self, &Widget) + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn custom_widget_apply_trampoline<
            P: IsA<PrintOperation>,
            F: Fn(&P, &Widget) + 'static,
        >(
            this: *mut ffi::GtkPrintOperation,
            widget: *mut ffi::GtkWidget,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(
                PrintOperation::from_glib_borrow(this).unsafe_cast_ref(),
                &from_glib_borrow(widget),
            )
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"custom-widget-apply\0".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    custom_widget_apply_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    /// Emitted when the print operation run has finished doing
    /// everything required for printing.
    ///
    /// @result gives you information about what happened during the run.
    /// If @result is [`PrintOperationResult::Error`][crate::PrintOperationResult::Error] then you can call
    /// `Gtk::PrintOperation::get_error()` for more information.
    ///
    /// If you enabled print status tracking then
    /// [`is_finished()`][Self::is_finished()] may still return [`false`]
    /// after the ::done signal was emitted.
    /// ## `result`
    /// the result of the print operation
    #[doc(alias = "done")]
    fn connect_done<F: Fn(&Self, PrintOperationResult) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn done_trampoline<
            P: IsA<PrintOperation>,
            F: Fn(&P, PrintOperationResult) + 'static,
        >(
            this: *mut ffi::GtkPrintOperation,
            result: ffi::GtkPrintOperationResult,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(
                PrintOperation::from_glib_borrow(this).unsafe_cast_ref(),
                from_glib(result),
            )
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"done\0".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    done_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    /// Emitted for every page that is printed.
    ///
    /// The signal handler must render the @page_nr's page onto the cairo
    /// context obtained from @context using
    /// [`PrintContext::cairo_context()`][crate::PrintContext::cairo_context()].
    ///
    /// **⚠️ The following code is in c ⚠️**
    ///
    /// ```c
    /// static void
    /// draw_page (GtkPrintOperation *operation,
    ///            GtkPrintContext   *context,
    ///            int                page_nr,
    ///            gpointer           user_data)
    /// {
    ///   cairo_t *cr;
    ///   PangoLayout *layout;
    ///   double width, text_height;
    ///   int layout_height;
    ///   PangoFontDescription *desc;
    ///
    ///   cr = gtk_print_context_get_cairo_context (context);
    ///   width = gtk_print_context_get_width (context);
    ///
    ///   cairo_rectangle (cr, 0, 0, width, HEADER_HEIGHT);
    ///
    ///   cairo_set_source_rgb (cr, 0.8, 0.8, 0.8);
    ///   cairo_fill (cr);
    ///
    ///   layout = gtk_print_context_create_pango_layout (context);
    ///
    ///   desc = pango_font_description_from_string ("sans 14");
    ///   pango_layout_set_font_description (layout, desc);
    ///   pango_font_description_free (desc);
    ///
    ///   pango_layout_set_text (layout, "some text", -1);
    ///   pango_layout_set_width (layout, width * PANGO_SCALE);
    ///   pango_layout_set_alignment (layout, PANGO_ALIGN_CENTER);
    ///
    ///   pango_layout_get_size (layout, NULL, &layout_height);
    ///   text_height = (double)layout_height / PANGO_SCALE;
    ///
    ///   cairo_move_to (cr, width / 2,  (HEADER_HEIGHT - text_height) / 2);
    ///   pango_cairo_show_layout (cr, layout);
    ///
    ///   g_object_unref (layout);
    /// }
    /// ```
    ///
    /// Use [`set_use_full_page()`][Self::set_use_full_page()] and
    /// [`set_unit()`][Self::set_unit()] before starting the print
    /// operation to set up the transformation of the cairo context
    /// according to your needs.
    /// ## `context`
    /// the [`PrintContext`][crate::PrintContext] for the current operation
    /// ## `page_nr`
    /// the number of the currently printed page (0-based)
    #[doc(alias = "draw-page")]
    fn connect_draw_page<F: Fn(&Self, &PrintContext, i32) + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn draw_page_trampoline<
            P: IsA<PrintOperation>,
            F: Fn(&P, &PrintContext, i32) + 'static,
        >(
            this: *mut ffi::GtkPrintOperation,
            context: *mut ffi::GtkPrintContext,
            page_nr: std::ffi::c_int,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(
                PrintOperation::from_glib_borrow(this).unsafe_cast_ref(),
                &from_glib_borrow(context),
                page_nr,
            )
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"draw-page\0".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    draw_page_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    /// Emitted after all pages have been rendered.
    ///
    /// A handler for this signal can clean up any resources that have
    /// been allocated in the [`begin-print`][struct@crate::PrintOperation#begin-print] handler.
    /// ## `context`
    /// the [`PrintContext`][crate::PrintContext] for the current operation
    #[doc(alias = "end-print")]
    fn connect_end_print<F: Fn(&Self, &PrintContext) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn end_print_trampoline<
            P: IsA<PrintOperation>,
            F: Fn(&P, &PrintContext) + 'static,
        >(
            this: *mut ffi::GtkPrintOperation,
            context: *mut ffi::GtkPrintContext,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(
                PrintOperation::from_glib_borrow(this).unsafe_cast_ref(),
                &from_glib_borrow(context),
            )
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"end-print\0".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    end_print_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    /// Emitted after the ::begin-print signal, but before the actual rendering
    /// starts.
    ///
    /// It keeps getting emitted until a connected signal handler returns [`true`].
    ///
    /// The ::paginate signal is intended to be used for paginating a document
    /// in small chunks, to avoid blocking the user interface for a long
    /// time. The signal handler should update the number of pages using
    /// [`set_n_pages()`][Self::set_n_pages()], and return [`true`] if the document
    /// has been completely paginated.
    ///
    /// If you don't need to do pagination in chunks, you can simply do
    /// it all in the ::begin-print handler, and set the number of pages
    /// from there.
    /// ## `context`
    /// the [`PrintContext`][crate::PrintContext] for the current operation
    ///
    /// # Returns
    ///
    /// [`true`] if pagination is complete
    #[doc(alias = "paginate")]
    fn connect_paginate<F: Fn(&Self, &PrintContext) -> bool + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn paginate_trampoline<
            P: IsA<PrintOperation>,
            F: Fn(&P, &PrintContext) -> bool + 'static,
        >(
            this: *mut ffi::GtkPrintOperation,
            context: *mut ffi::GtkPrintContext,
            f: glib::ffi::gpointer,
        ) -> glib::ffi::gboolean {
            let f: &F = &*(f as *const F);
            f(
                PrintOperation::from_glib_borrow(this).unsafe_cast_ref(),
                &from_glib_borrow(context),
            )
            .into_glib()
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"paginate\0".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    paginate_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    /// Gets emitted when a preview is requested from the native dialog.
    ///
    /// The default handler for this signal uses an external viewer
    /// application to preview.
    ///
    /// To implement a custom print preview, an application must return
    /// [`true`] from its handler for this signal. In order to use the
    /// provided @context for the preview implementation, it must be
    /// given a suitable cairo context with
    /// [`PrintContext::set_cairo_context()`][crate::PrintContext::set_cairo_context()].
    ///
    /// The custom preview implementation can use
    /// [`PrintOperationPreviewExt::is_selected()`][crate::prelude::PrintOperationPreviewExt::is_selected()] and
    /// [`PrintOperationPreviewExt::render_page()`][crate::prelude::PrintOperationPreviewExt::render_page()] to find pages which
    /// are selected for print and render them. The preview must be
    /// finished by calling [`PrintOperationPreviewExt::end_preview()`][crate::prelude::PrintOperationPreviewExt::end_preview()]
    /// (typically in response to the user clicking a close button).
    /// ## `preview`
    /// the [`PrintOperationPreview`][crate::PrintOperationPreview] for the current operation
    /// ## `context`
    /// the [`PrintContext`][crate::PrintContext] that will be used
    /// ## `parent`
    /// the [`Window`][crate::Window] to use as window parent
    ///
    /// # Returns
    ///
    /// [`true`] if the listener wants to take over control of the preview
    #[doc(alias = "preview")]
    fn connect_preview<
        F: Fn(&Self, &PrintOperationPreview, &PrintContext, Option<&Window>) -> bool + 'static,
    >(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn preview_trampoline<
            P: IsA<PrintOperation>,
            F: Fn(&P, &PrintOperationPreview, &PrintContext, Option<&Window>) -> bool + 'static,
        >(
            this: *mut ffi::GtkPrintOperation,
            preview: *mut ffi::GtkPrintOperationPreview,
            context: *mut ffi::GtkPrintContext,
            parent: *mut ffi::GtkWindow,
            f: glib::ffi::gpointer,
        ) -> glib::ffi::gboolean {
            let f: &F = &*(f as *const F);
            f(
                PrintOperation::from_glib_borrow(this).unsafe_cast_ref(),
                &from_glib_borrow(preview),
                &from_glib_borrow(context),
                Option::<Window>::from_glib_borrow(parent).as_ref().as_ref(),
            )
            .into_glib()
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"preview\0".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    preview_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    /// Emitted once for every page that is printed.
    ///
    /// This gives the application a chance to modify the page setup.
    /// Any changes done to @setup will be in force only for printing
    /// this page.
    /// ## `context`
    /// the [`PrintContext`][crate::PrintContext] for the current operation
    /// ## `page_nr`
    /// the number of the currently printed page (0-based)
    /// ## `setup`
    /// the [`PageSetup`][crate::PageSetup]
    #[doc(alias = "request-page-setup")]
    fn connect_request_page_setup<F: Fn(&Self, &PrintContext, i32, &PageSetup) + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn request_page_setup_trampoline<
            P: IsA<PrintOperation>,
            F: Fn(&P, &PrintContext, i32, &PageSetup) + 'static,
        >(
            this: *mut ffi::GtkPrintOperation,
            context: *mut ffi::GtkPrintContext,
            page_nr: std::ffi::c_int,
            setup: *mut ffi::GtkPageSetup,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(
                PrintOperation::from_glib_borrow(this).unsafe_cast_ref(),
                &from_glib_borrow(context),
                page_nr,
                &from_glib_borrow(setup),
            )
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"request-page-setup\0".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    request_page_setup_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    /// Emitted at between the various phases of the print operation.
    ///
    /// See [`PrintStatus`][crate::PrintStatus] for the phases that are being discriminated.
    /// Use [`status()`][Self::status()] to find out the current
    /// status.
    #[doc(alias = "status-changed")]
    fn connect_status_changed<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn status_changed_trampoline<
            P: IsA<PrintOperation>,
            F: Fn(&P) + 'static,
        >(
            this: *mut ffi::GtkPrintOperation,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(PrintOperation::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"status-changed\0".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    status_changed_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    /// Emitted after change of selected printer.
    ///
    /// The actual page setup and print settings are passed to the custom
    /// widget, which can actualize itself according to this change.
    /// ## `widget`
    /// the custom widget added in ::create-custom-widget
    /// ## `setup`
    /// actual page setup
    /// ## `settings`
    /// actual print settings
    #[doc(alias = "update-custom-widget")]
    fn connect_update_custom_widget<F: Fn(&Self, &Widget, &PageSetup, &PrintSettings) + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn update_custom_widget_trampoline<
            P: IsA<PrintOperation>,
            F: Fn(&P, &Widget, &PageSetup, &PrintSettings) + 'static,
        >(
            this: *mut ffi::GtkPrintOperation,
            widget: *mut ffi::GtkWidget,
            setup: *mut ffi::GtkPageSetup,
            settings: *mut ffi::GtkPrintSettings,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(
                PrintOperation::from_glib_borrow(this).unsafe_cast_ref(),
                &from_glib_borrow(widget),
                &from_glib_borrow(setup),
                &from_glib_borrow(settings),
            )
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"update-custom-widget\0".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    update_custom_widget_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "allow-async")]
    fn connect_allow_async_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_allow_async_trampoline<
            P: IsA<PrintOperation>,
            F: Fn(&P) + 'static,
        >(
            this: *mut ffi::GtkPrintOperation,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(PrintOperation::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"notify::allow-async\0".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_allow_async_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "current-page")]
    fn connect_current_page_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_current_page_trampoline<
            P: IsA<PrintOperation>,
            F: Fn(&P) + 'static,
        >(
            this: *mut ffi::GtkPrintOperation,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(PrintOperation::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"notify::current-page\0".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_current_page_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "custom-tab-label")]
    fn connect_custom_tab_label_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_custom_tab_label_trampoline<
            P: IsA<PrintOperation>,
            F: Fn(&P) + 'static,
        >(
            this: *mut ffi::GtkPrintOperation,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(PrintOperation::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"notify::custom-tab-label\0".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_custom_tab_label_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "default-page-setup")]
    fn connect_default_page_setup_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_default_page_setup_trampoline<
            P: IsA<PrintOperation>,
            F: Fn(&P) + 'static,
        >(
            this: *mut ffi::GtkPrintOperation,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(PrintOperation::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"notify::default-page-setup\0".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_default_page_setup_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "embed-page-setup")]
    fn connect_embed_page_setup_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_embed_page_setup_trampoline<
            P: IsA<PrintOperation>,
            F: Fn(&P) + 'static,
        >(
            this: *mut ffi::GtkPrintOperation,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(PrintOperation::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"notify::embed-page-setup\0".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_embed_page_setup_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "export-filename")]
    fn connect_export_filename_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_export_filename_trampoline<
            P: IsA<PrintOperation>,
            F: Fn(&P) + 'static,
        >(
            this: *mut ffi::GtkPrintOperation,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(PrintOperation::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"notify::export-filename\0".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_export_filename_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "has-selection")]
    fn connect_has_selection_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_has_selection_trampoline<
            P: IsA<PrintOperation>,
            F: Fn(&P) + 'static,
        >(
            this: *mut ffi::GtkPrintOperation,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(PrintOperation::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"notify::has-selection\0".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_has_selection_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "job-name")]
    fn connect_job_name_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_job_name_trampoline<
            P: IsA<PrintOperation>,
            F: Fn(&P) + 'static,
        >(
            this: *mut ffi::GtkPrintOperation,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(PrintOperation::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"notify::job-name\0".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_job_name_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "n-pages")]
    fn connect_n_pages_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_n_pages_trampoline<
            P: IsA<PrintOperation>,
            F: Fn(&P) + 'static,
        >(
            this: *mut ffi::GtkPrintOperation,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(PrintOperation::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"notify::n-pages\0".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_n_pages_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "n-pages-to-print")]
    fn connect_n_pages_to_print_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_n_pages_to_print_trampoline<
            P: IsA<PrintOperation>,
            F: Fn(&P) + 'static,
        >(
            this: *mut ffi::GtkPrintOperation,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(PrintOperation::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"notify::n-pages-to-print\0".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_n_pages_to_print_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "print-settings")]
    fn connect_print_settings_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_print_settings_trampoline<
            P: IsA<PrintOperation>,
            F: Fn(&P) + 'static,
        >(
            this: *mut ffi::GtkPrintOperation,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(PrintOperation::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"notify::print-settings\0".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_print_settings_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "show-progress")]
    fn connect_show_progress_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_show_progress_trampoline<
            P: IsA<PrintOperation>,
            F: Fn(&P) + 'static,
        >(
            this: *mut ffi::GtkPrintOperation,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(PrintOperation::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"notify::show-progress\0".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_show_progress_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "status")]
    fn connect_status_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_status_trampoline<
            P: IsA<PrintOperation>,
            F: Fn(&P) + 'static,
        >(
            this: *mut ffi::GtkPrintOperation,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(PrintOperation::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"notify::status\0".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_status_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "status-string")]
    fn connect_status_string_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_status_string_trampoline<
            P: IsA<PrintOperation>,
            F: Fn(&P) + 'static,
        >(
            this: *mut ffi::GtkPrintOperation,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(PrintOperation::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"notify::status-string\0".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_status_string_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "support-selection")]
    fn connect_support_selection_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_support_selection_trampoline<
            P: IsA<PrintOperation>,
            F: Fn(&P) + 'static,
        >(
            this: *mut ffi::GtkPrintOperation,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(PrintOperation::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"notify::support-selection\0".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_support_selection_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "track-print-status")]
    fn connect_track_print_status_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_track_print_status_trampoline<
            P: IsA<PrintOperation>,
            F: Fn(&P) + 'static,
        >(
            this: *mut ffi::GtkPrintOperation,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(PrintOperation::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"notify::track-print-status\0".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_track_print_status_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "unit")]
    fn connect_unit_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_unit_trampoline<P: IsA<PrintOperation>, F: Fn(&P) + 'static>(
            this: *mut ffi::GtkPrintOperation,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(PrintOperation::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"notify::unit\0".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_unit_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "use-full-page")]
    fn connect_use_full_page_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_use_full_page_trampoline<
            P: IsA<PrintOperation>,
            F: Fn(&P) + 'static,
        >(
            this: *mut ffi::GtkPrintOperation,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(PrintOperation::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"notify::use-full-page\0".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_use_full_page_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }
}

impl<O: IsA<PrintOperation>> PrintOperationExt for O {}