diff --git a/gtk/gtkpagesetup.c b/gtk/gtkpagesetup.c
index b0c9ef4..aa95703 100644
--- a/gtk/gtkpagesetup.c
+++ b/gtk/gtkpagesetup.c
@@ -485,10 +485,14 @@ gtk_page_setup_get_page_width (GtkPageSetup *setup,
 			       GtkUnit       unit)
 {
   gdouble width;
-  
+
   width = gtk_page_setup_get_paper_width (setup, GTK_UNIT_MM);
-  width -= setup->left_margin + setup->right_margin;
-  
+  if (setup->orientation == GTK_PAGE_ORIENTATION_PORTRAIT ||
+      setup->orientation == GTK_PAGE_ORIENTATION_REVERSE_PORTRAIT)
+    width -= setup->left_margin + setup->right_margin;
+  else
+    width -= setup->top_margin + setup->bottom_margin;
+
   return _gtk_print_convert_from_mm (width, unit);
 }
 
@@ -512,10 +516,14 @@ gtk_page_setup_get_page_height (GtkPageSetup *setup,
 				GtkUnit       unit)
 {
   gdouble height;
-  
+
   height = gtk_page_setup_get_paper_height (setup, GTK_UNIT_MM);
-  height -= setup->top_margin + setup->bottom_margin;
-  
+  if (setup->orientation == GTK_PAGE_ORIENTATION_PORTRAIT ||
+      setup->orientation == GTK_PAGE_ORIENTATION_REVERSE_PORTRAIT)
+    height -= setup->top_margin + setup->bottom_margin;
+  else
+    height -= setup->left_margin + setup->right_margin;
+
   return _gtk_print_convert_from_mm (height, unit);
 }
 
diff --git a/gtk/gtkprintcontext.c b/gtk/gtkprintcontext.c
index 4b27590..d3f69fd 100644
--- a/gtk/gtkprintcontext.c
+++ b/gtk/gtkprintcontext.c
@@ -111,6 +111,7 @@ struct _GtkPrintContext
   GtkPrintOperation *op;
   cairo_t *cr;
   GtkPageSetup *page_setup;
+  gboolean full_page;
 
   gdouble surface_dpi_x;
   gdouble surface_dpi_y;
@@ -317,22 +318,41 @@ _gtk_print_context_reverse_according_to_orientation (GtkPrintContext *context)
 void
 _gtk_print_context_translate_into_margin (GtkPrintContext *context)
 {
-  gdouble left, top;
+  gdouble dx, dy;
 
   g_return_if_fail (GTK_IS_PRINT_CONTEXT (context));
 
   /* We do it this way to also handle GTK_UNIT_NONE */
-  left = gtk_page_setup_get_left_margin (context->page_setup, GTK_UNIT_INCH);
-  top = gtk_page_setup_get_top_margin (context->page_setup, GTK_UNIT_INCH);
+  switch (gtk_page_setup_get_orientation (context->page_setup))
+    {
+      default:
+      case GTK_PAGE_ORIENTATION_PORTRAIT:
+        dx = gtk_page_setup_get_left_margin (context->page_setup, GTK_UNIT_INCH);
+        dy = gtk_page_setup_get_top_margin (context->page_setup, GTK_UNIT_INCH);
+        break;
+      case GTK_PAGE_ORIENTATION_LANDSCAPE:
+        dx = gtk_page_setup_get_bottom_margin (context->page_setup, GTK_UNIT_INCH);
+        dy = gtk_page_setup_get_left_margin (context->page_setup, GTK_UNIT_INCH);
+        break;
+      case GTK_PAGE_ORIENTATION_REVERSE_PORTRAIT:
+        dx = gtk_page_setup_get_right_margin (context->page_setup, GTK_UNIT_INCH);
+        dy = gtk_page_setup_get_bottom_margin (context->page_setup, GTK_UNIT_INCH);
+        break;
+      case GTK_PAGE_ORIENTATION_REVERSE_LANDSCAPE:
+        dx = gtk_page_setup_get_top_margin (context->page_setup, GTK_UNIT_INCH);
+        dy = gtk_page_setup_get_right_margin (context->page_setup, GTK_UNIT_INCH);
+        break;
+    }
 
   cairo_translate (context->cr,
-                   left * context->surface_dpi_x / context->pixels_per_unit_x,
-                   top * context->surface_dpi_y / context->pixels_per_unit_y);
+                   dx * context->surface_dpi_x / context->pixels_per_unit_x,
+                   dy * context->surface_dpi_y / context->pixels_per_unit_y);
 }
 
 void
 _gtk_print_context_set_page_setup (GtkPrintContext *context,
-				   GtkPageSetup    *page_setup)
+				   GtkPageSetup    *page_setup,
+                                   gboolean         full_page)
 {
   g_return_if_fail (GTK_IS_PRINT_CONTEXT (context));
   g_return_if_fail (page_setup == NULL ||
@@ -344,6 +364,7 @@ _gtk_print_context_set_page_setup (GtkPrintContext *context,
     g_object_unref (context->page_setup);
 
   context->page_setup = page_setup;
+  context->full_page = full_page;
 }
 
 /**
@@ -481,6 +502,100 @@ gtk_print_context_get_dpi_y (GtkPrintContext *context)
 }
 
 /**
+ * gtk_print_context_get_printable_margins:
+ * @context: a #GtkPrintContext
+ * @top: (out): top printable margin
+ * @bottom: (out): bottom printable margin
+ * @left: (out): left printable margin
+ * @right: (out): right printable margin
+ *
+ * Obtains the margins of the printable area of the #GtkPrintContext, in units.
+ * If the entire print context is within the printable area the margins returned
+ * are zero.
+ *
+ * Returns: %TRUE if the printable margins were retrieved, %FALSE if no
+ * information about the printable area is available for this print context.
+ *
+ * Since: 3.16
+ */
+gboolean
+gtk_print_context_get_printable_margins (GtkPrintContext *context,
+					 gdouble         *top,
+					 gdouble         *bottom,
+					 gdouble         *left,
+					 gdouble         *right)
+{
+  gdouble print_top, print_bottom, print_left, print_right;
+  gdouble page_top, page_bottom, page_left, page_right;
+  gdouble xscale, yscale;
+
+  if (context->has_hard_margins)
+    {
+      xscale = context->surface_dpi_x / context->pixels_per_unit_x;
+      yscale = context->surface_dpi_y / context->pixels_per_unit_y;
+      switch (gtk_page_setup_get_orientation (context->page_setup))
+        {
+	  default:
+	  case GTK_PAGE_ORIENTATION_PORTRAIT:
+	    print_top    = context->hard_margin_top / context->pixels_per_unit_y;
+	    print_bottom = context->hard_margin_bottom / context->pixels_per_unit_y;
+	    print_left   = context->hard_margin_left / context->pixels_per_unit_x;
+	    print_right  = context->hard_margin_right / context->pixels_per_unit_x;
+	    page_top     = gtk_page_setup_get_top_margin (context->page_setup, GTK_UNIT_INCH) * yscale;
+	    page_bottom  = gtk_page_setup_get_bottom_margin (context->page_setup, GTK_UNIT_INCH) * yscale;
+	    page_left    = gtk_page_setup_get_left_margin (context->page_setup, GTK_UNIT_INCH) * xscale;
+	    page_right   = gtk_page_setup_get_right_margin (context->page_setup, GTK_UNIT_INCH) * xscale;
+	    break;
+	  case GTK_PAGE_ORIENTATION_LANDSCAPE:
+	    print_top    = context->hard_margin_left / context->pixels_per_unit_x;
+	    print_bottom = context->hard_margin_right / context->pixels_per_unit_x;
+	    print_left   = context->hard_margin_bottom / context->pixels_per_unit_y;
+	    print_right  = context->hard_margin_top / context->pixels_per_unit_y;
+	    page_top     = gtk_page_setup_get_top_margin (context->page_setup, GTK_UNIT_INCH) * xscale;
+	    page_bottom  = gtk_page_setup_get_bottom_margin (context->page_setup, GTK_UNIT_INCH) * xscale;
+	    page_left    = gtk_page_setup_get_left_margin (context->page_setup, GTK_UNIT_INCH) * yscale;
+	    page_right   = gtk_page_setup_get_right_margin (context->page_setup, GTK_UNIT_INCH) * yscale;
+	    break;
+	  case GTK_PAGE_ORIENTATION_REVERSE_PORTRAIT:
+	    print_top    = context->hard_margin_bottom / context->pixels_per_unit_y;
+	    print_bottom = context->hard_margin_top / context->pixels_per_unit_y;
+	    print_left   = context->hard_margin_right / context->pixels_per_unit_x;
+	    print_right  = context->hard_margin_left / context->pixels_per_unit_x;
+	    page_top     = gtk_page_setup_get_top_margin (context->page_setup, GTK_UNIT_INCH) * yscale;
+	    page_bottom  = gtk_page_setup_get_bottom_margin (context->page_setup, GTK_UNIT_INCH) * yscale;
+	    page_left    = gtk_page_setup_get_left_margin (context->page_setup, GTK_UNIT_INCH) * xscale;
+	    page_right   = gtk_page_setup_get_right_margin (context->page_setup, GTK_UNIT_INCH) * xscale;
+	    break;
+	  case GTK_PAGE_ORIENTATION_REVERSE_LANDSCAPE:
+	    print_top    = context->hard_margin_right / context->pixels_per_unit_x;
+	    print_bottom = context->hard_margin_left / context->pixels_per_unit_x;
+	    print_left   = context->hard_margin_top / context->pixels_per_unit_y;
+	    print_right  = context->hard_margin_bottom / context->pixels_per_unit_y;
+	    page_top     = gtk_page_setup_get_top_margin (context->page_setup, GTK_UNIT_INCH) * xscale;
+	    page_bottom  = gtk_page_setup_get_bottom_margin (context->page_setup, GTK_UNIT_INCH) * xscale;
+	    page_left    = gtk_page_setup_get_left_margin (context->page_setup, GTK_UNIT_INCH) * yscale;
+	    page_right   = gtk_page_setup_get_right_margin (context->page_setup, GTK_UNIT_INCH) * yscale;
+	    break;
+	}
+
+      if (!context->full_page)
+      {
+	  print_top    -= page_top;
+	  print_bottom -= page_bottom;
+	  print_left   -= page_left;
+	  print_right  -= page_right;
+      }
+
+      *top    = print_top    > 0 ? print_top    : 0;
+      *bottom = print_bottom > 0 ? print_bottom : 0;
+      *left   = print_left   > 0 ? print_left   : 0;
+      *right  = print_right  > 0 ? print_right  : 0;
+    }
+
+  return context->has_hard_margins;
+}
+
+/**
  * gtk_print_context_get_hard_margins:
  * @context: a #GtkPrintContext
  * @top: (out): top hardware printer margin
diff --git a/gtk/gtkprintcontext.h b/gtk/gtkprintcontext.h
index c78be90..8ecdf3f 100644
--- a/gtk/gtkprintcontext.h
+++ b/gtk/gtkprintcontext.h
@@ -55,6 +55,12 @@ gdouble       gtk_print_context_get_dpi_x            (GtkPrintContext *context);
 GDK_AVAILABLE_IN_ALL
 gdouble       gtk_print_context_get_dpi_y            (GtkPrintContext *context);
 GDK_AVAILABLE_IN_ALL
+gboolean      gtk_print_context_get_printable_margins (GtkPrintContext *context,
+						       gdouble         *top,
+						       gdouble         *bottom,
+						       gdouble         *left,
+						       gdouble         *right);
+GDK_AVAILABLE_IN_ALL
 gboolean      gtk_print_context_get_hard_margins     (GtkPrintContext *context,
 						      gdouble         *top,
 						      gdouble         *bottom,
diff --git a/gtk/gtkprinter.c b/gtk/gtkprinter.c
index c34eafb..5e485f6 100644
--- a/gtk/gtkprinter.c
+++ b/gtk/gtkprinter.c
@@ -993,7 +993,7 @@ gtk_printer_get_default_page_size (GtkPrinter *printer)
  * @left: (out): a location to store the left margin in
  * @right: (out): a location to store the right margin in
  *
- * Retrieve the hard margins of @printer, i.e. the margins that define
+ * Retrieve the hard margins of @printer in points, i.e. the margins that define
  * the area at the borders of the paper that the printer cannot print to.
  *
  * Note: This will not succeed unless the printer’s details are available,
diff --git a/gtk/gtkprintoperation-private.h b/gtk/gtkprintoperation-private.h
index 6a7b509..c79dc36 100644
--- a/gtk/gtkprintoperation-private.h
+++ b/gtk/gtkprintoperation-private.h
@@ -135,7 +135,8 @@ void _gtk_print_operation_set_status (GtkPrintOperation *op,
 
 GtkPrintContext *_gtk_print_context_new                             (GtkPrintOperation *op);
 void             _gtk_print_context_set_page_setup                  (GtkPrintContext   *context,
-								     GtkPageSetup      *page_setup);
+								     GtkPageSetup      *page_setup,
+								     gboolean         full_page);
 void             _gtk_print_context_translate_into_margin           (GtkPrintContext   *context);
 void             _gtk_print_context_rotate_according_to_orientation (GtkPrintContext   *context);
 void             _gtk_print_context_reverse_according_to_orientation (GtkPrintContext *context);
diff --git a/gtk/gtkprintoperation-unix.c b/gtk/gtkprintoperation-unix.c
index 1e17b0f..2843d82 100644
--- a/gtk/gtkprintoperation-unix.c
+++ b/gtk/gtkprintoperation-unix.c
@@ -27,6 +27,7 @@
 #include <errno.h>
 #include <stdlib.h>       
 #include <fcntl.h>
+#include <math.h>
 
 #include <glib/gstdio.h>
 #include "gtkprintoperation-private.h"
@@ -55,7 +56,10 @@ typedef struct
   cairo_surface_t *surface;
   gulong job_status_changed_tag;
 
-  
+  gboolean has_hard_margins;
+  GList *paper_sizes; /* paper sizes and hard margins for each size */
+  gdouble top, bottom, left, right; /* hard margins for custom page size */
+
 } GtkPrintOperationUnix;
 
 typedef struct _PrinterFinder PrinterFinder;
@@ -65,6 +69,9 @@ static void find_printer        (const gchar   *printer,
 				 GFunc          func,
 				 gpointer       data);
 
+/* Tolerance of paper size in points according to PostScript Language Reference */
+#define PAPER_SIZE_TOLERANCE 5
+
 static void
 unix_start_page (GtkPrintOperation *op,
 		 GtkPrintContext   *print_context,
@@ -73,7 +80,9 @@ unix_start_page (GtkPrintOperation *op,
   GtkPrintOperationUnix *op_unix;  
   GtkPaperSize *paper_size;
   cairo_surface_type_t type;
-  gdouble w, h;
+  gdouble w, h, pw, ph;
+  GList *node;
+  gdouble top, bottom, left, right;
 
   op_unix = op->priv->platform_data;
   
@@ -113,7 +122,47 @@ unix_start_page (GtkPrintOperation *op,
             }
           cairo_pdf_surface_set_size (op_unix->surface, w, h);
         }
+
+      if (op_unix->has_hard_margins)
+        {
+	  /* Find matching paper size and get hard margins for the size. */
+	    node = op_unix->paper_sizes;
+	    while (node != NULL)
+	      {
+		pw = gtk_page_setup_get_paper_width (node->data, GTK_UNIT_POINTS);
+		ph = gtk_page_setup_get_paper_height (node->data, GTK_UNIT_POINTS);
+
+		if (fabs(w - pw) < PAPER_SIZE_TOLERANCE && fabs(h - ph) < PAPER_SIZE_TOLERANCE)
+		  {
+		    top = gtk_page_setup_get_top_margin (node->data, GTK_UNIT_POINTS);
+		    bottom = gtk_page_setup_get_bottom_margin (node->data, GTK_UNIT_POINTS);
+		    left = gtk_page_setup_get_left_margin (node->data, GTK_UNIT_POINTS);
+		    right = gtk_page_setup_get_right_margin (node->data, GTK_UNIT_POINTS);
+		    break;
+		  }
+		node = node->next;
+	      }
+
+	  /* No matching page size. Use custom page size hard margins */
+	    if (node == NULL)
+	      {
+		top = op_unix->top;
+		bottom = op_unix->bottom;
+		left = op_unix->left;
+		right = op_unix->right;
+	      }
+
+	    _gtk_print_context_set_hard_margins (print_context, top, bottom, left, right);
+	}
     }
+  else
+  {
+      /* Pages do not have any unprintable area when printing n-up as each page on the
+       * sheet has been scaled down and translated to a position within the printable
+       * area of the sheet.
+       */
+      _gtk_print_context_set_hard_margins (print_context, 0, 0, 0, 0);
+  }
 }
 
 static void
@@ -524,33 +573,18 @@ finish_print (PrintResponseData *rdata,
   GtkPrintOperation *op = rdata->op;
   GtkPrintOperationPrivate *priv = op->priv;
   GtkPrintJob *job;
-  gdouble top, bottom, left, right;
-  
+
   if (rdata->do_print)
     {
       gtk_print_operation_set_print_settings (op, settings);
       priv->print_context = _gtk_print_context_new (op);
 
-      if (gtk_print_settings_get_number_up (settings) < 2)
-        {
-	  if (printer && gtk_printer_get_hard_margins (printer, &top, &bottom, &left, &right))
-	    _gtk_print_context_set_hard_margins (priv->print_context, top, bottom, left, right);
-	}
-      else
-        {
-	  /* Pages do not have any unprintable area when printing n-up as each page on the
-	   * sheet has been scaled down and translated to a position within the printable
-	   * area of the sheet.
-	   */
-	  _gtk_print_context_set_hard_margins (priv->print_context, 0, 0, 0, 0);
-	}
-
       if (page_setup != NULL &&
           (gtk_print_operation_get_default_page_setup (op) == NULL ||
            page_setup_set))
         gtk_print_operation_set_default_page_setup (op, page_setup);
 
-      _gtk_print_context_set_page_setup (priv->print_context, page_setup);
+      _gtk_print_context_set_page_setup (priv->print_context, page_setup, priv->use_full_page);
 
       if (!rdata->do_preview)
         {
@@ -565,7 +599,14 @@ finish_print (PrintResponseData *rdata,
 	  priv->start_page = unix_start_page;
 	  priv->end_page = unix_end_page;
 	  priv->end_run = unix_end_run;
-	  
+
+	  op_unix->paper_sizes = gtk_printer_list_papers (printer);
+	  op_unix->has_hard_margins = gtk_printer_get_hard_margins (printer,
+								   &op_unix->top,
+								   &op_unix->bottom,
+								   &op_unix->left,
+								   &op_unix->right);
+
 	  job = gtk_print_job_new (priv->job_name, printer, settings, page_setup);
           op_unix->job = job;
           gtk_print_job_set_track_print_status (job, priv->track_print_status);
diff --git a/gtk/gtkprintoperation-win32.c b/gtk/gtkprintoperation-win32.c
index 64f7714..33145f6 100644
--- a/gtk/gtkprintoperation-win32.c
+++ b/gtk/gtkprintoperation-win32.c
@@ -438,7 +438,7 @@ get_default_printer (void)
 }
 
 static void
-set_hard_margins (GtkPrintOperation *op)
+set_hard_margins (GtkPrintOperation *op, GtkPageSetup *page_setup)
 {
   double top, bottom, left, right;
   GtkPrintOperationWin32 *op_win32 = op->priv->platform_data;
@@ -450,7 +450,22 @@ set_hard_margins (GtkPrintOperation *op)
   right = GetDeviceCaps (op_win32->hdc, PHYSICALWIDTH)
       - GetDeviceCaps (op_win32->hdc, HORZRES) - left;
 
-  _gtk_print_context_set_hard_margins (op->priv->print_context, top, bottom, left, right);
+  switch (gtk_page_setup_get_orientation (page_setup))
+    {
+      default:
+      case GTK_PAGE_ORIENTATION_PORTRAIT:
+	_gtk_print_context_set_hard_margins (op->priv->print_context, top, bottom, left, right);
+	break;
+      case GTK_PAGE_ORIENTATION_LANDSCAPE:
+	_gtk_print_context_set_hard_margins (op->priv->print_context, left, right, bottom, top);
+	break;
+      case GTK_PAGE_ORIENTATION_REVERSE_PORTRAIT:
+	_gtk_print_context_set_hard_margins (op->priv->print_context, bottom, top, right, left);
+	break;
+      case GTK_PAGE_ORIENTATION_REVERSE_LANDSCAPE:
+	_gtk_print_context_set_hard_margins (op->priv->print_context, right, left, top, bottom);
+	break;
+    }
 }
 
 void
@@ -487,7 +502,7 @@ win32_start_page (GtkPrintOperation *op,
   
   GlobalUnlock (op_win32->devmode);
 
-  set_hard_margins (op);
+  set_hard_margins (op, page_setup);
   x_off = GetDeviceCaps (op_win32->hdc, PHYSICALOFFSETX);
   y_off = GetDeviceCaps (op_win32->hdc, PHYSICALOFFSETY);
   cairo_surface_set_device_offset (op_win32->surface, -x_off, -y_off);
@@ -1574,7 +1589,7 @@ gtk_print_operation_run_without_dialog (GtkPrintOperation *op,
   
   priv->print_context = _gtk_print_context_new (op);
   page_setup = create_page_setup (op);
-  _gtk_print_context_set_page_setup (priv->print_context, page_setup);
+  _gtk_print_context_set_page_setup (priv->print_context, page_setup, priv->use_full_page);
   g_object_unref (page_setup);
 
   *do_print = TRUE;
@@ -1587,7 +1602,7 @@ gtk_print_operation_run_without_dialog (GtkPrintOperation *op,
   gtk_print_context_set_cairo_context (priv->print_context, cr, dpi_x, dpi_y);
   cairo_destroy (cr);
 
-  set_hard_margins (op);
+  set_hard_margins (op, page_setup);
 
   memset (&docinfo, 0, sizeof (DOCINFOW));
   docinfo.cbSize = sizeof (DOCINFOW); 
@@ -1819,7 +1834,7 @@ gtk_print_operation_run_with_dialog (GtkPrintOperation *op,
 
       priv->print_context = _gtk_print_context_new (op);
       page_setup = create_page_setup (op);
-      _gtk_print_context_set_page_setup (priv->print_context, page_setup);
+      _gtk_print_context_set_page_setup (priv->print_context, page_setup, priv->use_full_page);
       g_object_unref (page_setup);
       
       *do_print = TRUE;
@@ -1833,7 +1848,7 @@ gtk_print_operation_run_with_dialog (GtkPrintOperation *op,
       gtk_print_context_set_cairo_context (priv->print_context, cr, dpi_x, dpi_y);
       cairo_destroy (cr);
 
-      set_hard_margins (op);
+      set_hard_margins (op, page_setup);
 
       memset ( &docinfo, 0, sizeof (DOCINFOW));
       docinfo.cbSize = sizeof (DOCINFOW); 
diff --git a/gtk/gtkprintoperation.c b/gtk/gtkprintoperation.c
index 1f45c4f..40684df 100644
--- a/gtk/gtkprintoperation.c
+++ b/gtk/gtkprintoperation.c
@@ -2102,7 +2102,7 @@ run_pdf (GtkPrintOperation  *op,
   priv->print_context = _gtk_print_context_new (op);
   
   page_setup = create_page_setup (op);
-  _gtk_print_context_set_page_setup (priv->print_context, page_setup);
+  _gtk_print_context_set_page_setup (priv->print_context, page_setup, priv->use_full_page);
 
   /* This will be overwritten later by the non-default size, but
      we need to pass some size: */
@@ -2481,7 +2481,7 @@ common_render_page (GtkPrintOperation *op,
   g_signal_emit (op, signals[REQUEST_PAGE_SETUP], 0, 
 		 print_context, page_nr, page_setup);
   
-  _gtk_print_context_set_page_setup (print_context, page_setup);
+  _gtk_print_context_set_page_setup (print_context, page_setup, priv->use_full_page);
   
   priv->start_page (op, print_context, page_setup);
   
@@ -2718,7 +2718,8 @@ prepare_data (PrintPagesData *data)
       data->initialized = TRUE;
       page_setup = create_page_setup (data->op);
       _gtk_print_context_set_page_setup (priv->print_context,
-                                         page_setup);
+                                         page_setup,
+					 priv->use_full_page);
       g_object_unref (page_setup);
 
       g_signal_emit (data->op, signals[BEGIN_PRINT], 0, priv->print_context);
@@ -3215,7 +3216,7 @@ gtk_print_operation_run (GtkPrintOperation        *op,
       priv->is_sync = !priv->allow_async;
       priv->print_context = _gtk_print_context_new (op);
       page_setup = create_page_setup (op);
-      _gtk_print_context_set_page_setup (priv->print_context, page_setup);
+      _gtk_print_context_set_page_setup (priv->print_context, page_setup, priv->use_full_page);
       g_object_unref (page_setup);
       do_print = TRUE;
       result = priv->is_sync ? GTK_PRINT_OPERATION_RESULT_APPLY : GTK_PRINT_OPERATION_RESULT_IN_PROGRESS;
