widget/gtk/nsPrintSettingsGTK.cpp

   1 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* This Source Code Form is subject to the terms of the Mozilla Public
   3  * License, v. 2.0. If a copy of the MPL was not distributed with this
   4  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   5
   6 #include "nsPrintSettingsGTK.h"
   7 #include "nsIFile.h"
   8 #include "nsNetUtil.h"
   9 #include <stdlib.h>
  10 #include <algorithm>
  11
  12 static gboolean ref_printer(GtkPrinter* aPrinter, gpointer aData) {
  13   ((nsPrintSettingsGTK*)aData)->SetGtkPrinter(aPrinter);
  14   return TRUE;
  15 }
  16
  17 static gboolean printer_enumerator(GtkPrinter* aPrinter, gpointer aData) {
  18   if (gtk_printer_is_default(aPrinter)) return ref_printer(aPrinter, aData);
  19
  20   return FALSE;  // Keep 'em coming...
  21 }
  22
  23 static GtkPaperSize* moz_gtk_paper_size_copy_to_new_custom(
  24     GtkPaperSize* oldPaperSize) {
  25   // We make a "custom-ified" copy of the paper size so it can be changed later.
  26   return gtk_paper_size_new_custom(
  27       gtk_paper_size_get_name(oldPaperSize),
  28       gtk_paper_size_get_display_name(oldPaperSize),
  29       gtk_paper_size_get_width(oldPaperSize, GTK_UNIT_INCH),
  30       gtk_paper_size_get_height(oldPaperSize, GTK_UNIT_INCH), GTK_UNIT_INCH);
  31 }
  32
  33 NS_IMPL_ISUPPORTS_INHERITED(nsPrintSettingsGTK, nsPrintSettings,
  34                             nsPrintSettingsGTK)
  35
  36 /** ---------------------------------------------------
  37  */
  38 nsPrintSettingsGTK::nsPrintSettingsGTK()
  39     : mPageSetup(nullptr),
  40       mPrintSettings(nullptr),
  41       mGTKPrinter(nullptr),
  42       mPrintSelectionOnly(false) {
  43   // The aim here is to set up the objects enough that silent printing works
  44   // well. These will be replaced anyway if the print dialog is used.
  45   mPrintSettings = gtk_print_settings_new();
  46   GtkPageSetup* pageSetup = gtk_page_setup_new();
  47   SetGtkPageSetup(pageSetup);
  48   g_object_unref(pageSetup);
  49
  50   SetOutputFormat(nsIPrintSettings::kOutputFormatNative);
  51 }
  52
  53 already_AddRefed<nsIPrintSettings> CreatePlatformPrintSettings(
  54     const PrintSettingsInitializer& aSettings) {
  55   RefPtr<nsPrintSettings> settings = new nsPrintSettingsGTK();
  56   settings->InitWithInitializer(aSettings);
  57   settings->SetDefaultFileName();
  58   return settings.forget();
  59 }
  60
  61 /** ---------------------------------------------------
  62  */
  63 nsPrintSettingsGTK::~nsPrintSettingsGTK() {
  64   if (mPageSetup) {
  65     g_object_unref(mPageSetup);
  66     mPageSetup = nullptr;
  67   }
  68   if (mPrintSettings) {
  69     g_object_unref(mPrintSettings);
  70     mPrintSettings = nullptr;
  71   }
  72   if (mGTKPrinter) {
  73     g_object_unref(mGTKPrinter);
  74     mGTKPrinter = nullptr;
  75   }
  76 }
  77
  78 /** ---------------------------------------------------
  79  */
  80 nsPrintSettingsGTK::nsPrintSettingsGTK(const nsPrintSettingsGTK& aPS)
  81     : mPageSetup(nullptr),
  82       mPrintSettings(nullptr),
  83       mGTKPrinter(nullptr),
  84       mPrintSelectionOnly(false) {
  85   *this = aPS;
  86 }
  87
  88 /** ---------------------------------------------------
  89  */
  90 nsPrintSettingsGTK& nsPrintSettingsGTK::operator=(
  91     const nsPrintSettingsGTK& rhs) {
  92   if (this == &rhs) {
  93     return *this;
  94   }
  95
  96   nsPrintSettings::operator=(rhs);
  97
  98   if (mPageSetup) g_object_unref(mPageSetup);
  99   mPageSetup = gtk_page_setup_copy(rhs.mPageSetup);
 100   // NOTE: No need to re-initialize mUnwriteableMargin here (even
 101   // though mPageSetup is changing). It'll be copied correctly by
 102   // nsPrintSettings::operator=.
 103
 104   if (mPrintSettings) g_object_unref(mPrintSettings);
 105   mPrintSettings = gtk_print_settings_copy(rhs.mPrintSettings);
 106
 107   if (mGTKPrinter) g_object_unref(mGTKPrinter);
 108   mGTKPrinter = (GtkPrinter*)g_object_ref(rhs.mGTKPrinter);
 109
 110   mPrintSelectionOnly = rhs.mPrintSelectionOnly;
 111
 112   return *this;
 113 }
 114
 115 /** -------------------------------------------
 116  */
 117 nsresult nsPrintSettingsGTK::_Clone(nsIPrintSettings** _retval) {
 118   NS_ENSURE_ARG_POINTER(_retval);
 119   *_retval = nullptr;
 120
 121   nsPrintSettingsGTK* newSettings = new nsPrintSettingsGTK(*this);
 122   if (!newSettings) return NS_ERROR_FAILURE;
 123   *_retval = newSettings;
 124   NS_ADDREF(*_retval);
 125   return NS_OK;
 126 }
 127
 128 /** -------------------------------------------
 129  */
 130 NS_IMETHODIMP
 131 nsPrintSettingsGTK::_Assign(nsIPrintSettings* aPS) {
 132   nsPrintSettingsGTK* printSettingsGTK = static_cast<nsPrintSettingsGTK*>(aPS);
 133   if (!printSettingsGTK) return NS_ERROR_UNEXPECTED;
 134   *this = *printSettingsGTK;
 135   return NS_OK;
 136 }
 137
 138 /** ---------------------------------------------------
 139  */
 140 void nsPrintSettingsGTK::SetGtkPageSetup(GtkPageSetup* aPageSetup) {
 141   if (mPageSetup) g_object_unref(mPageSetup);
 142
 143   mPageSetup = (GtkPageSetup*)g_object_ref(aPageSetup);
 144   InitUnwriteableMargin();
 145
 146   // If the paper size is not custom, then we make a custom copy of the
 147   // GtkPaperSize, so it can be mutable. If a GtkPaperSize wasn't made as
 148   // custom, its properties are immutable.
 149   GtkPaperSize* paperSize = gtk_page_setup_get_paper_size(aPageSetup);
 150   if (!gtk_paper_size_is_custom(paperSize)) {
 151     GtkPaperSize* customPaperSize =
 152         moz_gtk_paper_size_copy_to_new_custom(paperSize);
 153     gtk_page_setup_set_paper_size(mPageSetup, customPaperSize);
 154     gtk_paper_size_free(customPaperSize);
 155   }
 156   SaveNewPageSize();
 157 }
 158
 159 /** ---------------------------------------------------
 160  */
 161 void nsPrintSettingsGTK::SetGtkPrintSettings(GtkPrintSettings* aPrintSettings) {
 162   if (mPrintSettings) g_object_unref(mPrintSettings);
 163
 164   mPrintSettings = (GtkPrintSettings*)g_object_ref(aPrintSettings);
 165
 166   GtkPaperSize* paperSize = gtk_print_settings_get_paper_size(aPrintSettings);
 167   if (paperSize) {
 168     GtkPaperSize* customPaperSize =
 169         moz_gtk_paper_size_copy_to_new_custom(paperSize);
 170     gtk_paper_size_free(paperSize);
 171     gtk_page_setup_set_paper_size(mPageSetup, customPaperSize);
 172     gtk_paper_size_free(customPaperSize);
 173   } else {
 174     // paperSize was null, and so we add the paper size in the GtkPageSetup to
 175     // the settings.
 176     SaveNewPageSize();
 177   }
 178 }
 179
 180 /** ---------------------------------------------------
 181  */
 182 void nsPrintSettingsGTK::SetGtkPrinter(GtkPrinter* aPrinter) {
 183   if (mGTKPrinter) g_object_unref(mGTKPrinter);
 184
 185   mGTKPrinter = (GtkPrinter*)g_object_ref(aPrinter);
 186 }
 187
 188 NS_IMETHODIMP nsPrintSettingsGTK::GetOutputFormat(int16_t* aOutputFormat) {
 189   NS_ENSURE_ARG_POINTER(aOutputFormat);
 190
 191   int16_t format;
 192   nsresult rv = nsPrintSettings::GetOutputFormat(&format);
 193   if (NS_FAILED(rv)) {
 194     return rv;
 195   }
 196
 197   if (format == nsIPrintSettings::kOutputFormatNative &&
 198       GTK_IS_PRINTER(mGTKPrinter)) {
 199     if (gtk_printer_accepts_pdf(mGTKPrinter)) {
 200       format = nsIPrintSettings::kOutputFormatPDF;
 201     } else {
 202       format = nsIPrintSettings::kOutputFormatPS;
 203     }
 204   }
 205
 206   *aOutputFormat = format;
 207   return NS_OK;
 208 }
 209
 210 /**
 211  * Reimplementation of nsPrintSettings functions so that we get the values
 212  * from the GTK objects rather than our own variables.
 213  */
 214
 215 NS_IMETHODIMP nsPrintSettingsGTK::GetPrintRange(int16_t* aPrintRange) {
 216   NS_ENSURE_ARG_POINTER(aPrintRange);
 217   if (mPrintSelectionOnly) {
 218     *aPrintRange = kRangeSelection;
 219     return NS_OK;
 220   }
 221
 222   GtkPrintPages gtkRange = gtk_print_settings_get_print_pages(mPrintSettings);
 223   if (gtkRange == GTK_PRINT_PAGES_RANGES)
 224     *aPrintRange = kRangeSpecifiedPageRange;
 225   else
 226     *aPrintRange = kRangeAllPages;
 227
 228   return NS_OK;
 229 }
 230 NS_IMETHODIMP nsPrintSettingsGTK::SetPrintRange(int16_t aPrintRange) {
 231   if (aPrintRange == kRangeSelection) {
 232     mPrintSelectionOnly = true;
 233     return NS_OK;
 234   }
 235
 236   mPrintSelectionOnly = false;
 237   if (aPrintRange == kRangeSpecifiedPageRange)
 238     gtk_print_settings_set_print_pages(mPrintSettings, GTK_PRINT_PAGES_RANGES);
 239   else
 240     gtk_print_settings_set_print_pages(mPrintSettings, GTK_PRINT_PAGES_ALL);
 241   return NS_OK;
 242 }
 243
 244 NS_IMETHODIMP
 245 nsPrintSettingsGTK::GetStartPageRange(int32_t* aStartPageRange) {
 246   gint ctRanges;
 247   GtkPageRange* lstRanges =
 248       gtk_print_settings_get_page_ranges(mPrintSettings, &ctRanges);
 249
 250   // Make sure we got a range.
 251   if (ctRanges < 1) {
 252     *aStartPageRange = 1;
 253   } else {
 254     // GTK supports multiple page ranges; gecko only supports 1. So find
 255     // the lowest start page.
 256     int32_t start(lstRanges[0].start);
 257     for (gint ii = 1; ii < ctRanges; ii++) {
 258       start = std::min(lstRanges[ii].start, start);
 259     }
 260     *aStartPageRange = start + 1;
 261   }
 262
 263   g_free(lstRanges);
 264   return NS_OK;
 265 }
 266 NS_IMETHODIMP
 267 nsPrintSettingsGTK::SetStartPageRange(int32_t aStartPageRange) {
 268   int32_t endRange;
 269   GetEndPageRange(&endRange);
 270
 271   GtkPageRange gtkRange;
 272   gtkRange.start = aStartPageRange - 1;
 273   gtkRange.end = endRange - 1;
 274
 275   gtk_print_settings_set_page_ranges(mPrintSettings, &gtkRange, 1);
 276
 277   return NS_OK;
 278 }
 279
 280 NS_IMETHODIMP
 281 nsPrintSettingsGTK::GetEndPageRange(int32_t* aEndPageRange) {
 282   gint ctRanges;
 283   GtkPageRange* lstRanges =
 284       gtk_print_settings_get_page_ranges(mPrintSettings, &ctRanges);
 285
 286   if (ctRanges < 1) {
 287     *aEndPageRange = 1;
 288   } else {
 289     int32_t end(lstRanges[0].end);
 290     for (gint ii = 1; ii < ctRanges; ii++) {
 291       end = std::max(lstRanges[ii].end, end);
 292     }
 293     *aEndPageRange = end + 1;
 294   }
 295
 296   g_free(lstRanges);
 297   return NS_OK;
 298 }
 299 NS_IMETHODIMP
 300 nsPrintSettingsGTK::SetEndPageRange(int32_t aEndPageRange) {
 301   int32_t startRange;
 302   GetStartPageRange(&startRange);
 303
 304   GtkPageRange gtkRange;
 305   gtkRange.start = startRange - 1;
 306   gtkRange.end = aEndPageRange - 1;
 307
 308   gtk_print_settings_set_page_ranges(mPrintSettings, &gtkRange, 1);
 309
 310   return NS_OK;
 311 }
 312
 313 NS_IMETHODIMP
 314 nsPrintSettingsGTK::GetPrintReversed(bool* aPrintReversed) {
 315   *aPrintReversed = gtk_print_settings_get_reverse(mPrintSettings);
 316   return NS_OK;
 317 }
 318 NS_IMETHODIMP
 319 nsPrintSettingsGTK::SetPrintReversed(bool aPrintReversed) {
 320   gtk_print_settings_set_reverse(mPrintSettings, aPrintReversed);
 321   return NS_OK;
 322 }
 323
 324 NS_IMETHODIMP
 325 nsPrintSettingsGTK::GetPrintInColor(bool* aPrintInColor) {
 326   *aPrintInColor = gtk_print_settings_get_use_color(mPrintSettings);
 327   return NS_OK;
 328 }
 329 NS_IMETHODIMP
 330 nsPrintSettingsGTK::SetPrintInColor(bool aPrintInColor) {
 331   gtk_print_settings_set_use_color(mPrintSettings, aPrintInColor);
 332   return NS_OK;
 333 }
 334
 335 NS_IMETHODIMP
 336 nsPrintSettingsGTK::GetOrientation(int32_t* aOrientation) {
 337   NS_ENSURE_ARG_POINTER(aOrientation);
 338
 339   GtkPageOrientation gtkOrient = gtk_page_setup_get_orientation(mPageSetup);
 340   switch (gtkOrient) {
 341     case GTK_PAGE_ORIENTATION_LANDSCAPE:
 342     case GTK_PAGE_ORIENTATION_REVERSE_LANDSCAPE:
 343       *aOrientation = kLandscapeOrientation;
 344       break;
 345
 346     case GTK_PAGE_ORIENTATION_PORTRAIT:
 347     case GTK_PAGE_ORIENTATION_REVERSE_PORTRAIT:
 348     default:
 349       *aOrientation = kPortraitOrientation;
 350   }
 351   return NS_OK;
 352 }
 353 NS_IMETHODIMP
 354 nsPrintSettingsGTK::SetOrientation(int32_t aOrientation) {
 355   GtkPageOrientation gtkOrient;
 356   if (aOrientation == kLandscapeOrientation)
 357     gtkOrient = GTK_PAGE_ORIENTATION_LANDSCAPE;
 358   else
 359     gtkOrient = GTK_PAGE_ORIENTATION_PORTRAIT;
 360
 361   gtk_print_settings_set_orientation(mPrintSettings, gtkOrient);
 362   gtk_page_setup_set_orientation(mPageSetup, gtkOrient);
 363   return NS_OK;
 364 }
 365
 366 NS_IMETHODIMP
 367 nsPrintSettingsGTK::GetToFileName(nsAString& aToFileName) {
 368   // Get the gtk output filename
 369   const char* gtk_output_uri =
 370       gtk_print_settings_get(mPrintSettings, GTK_PRINT_SETTINGS_OUTPUT_URI);
 371   if (!gtk_output_uri) {
 372     aToFileName = mToFileName;
 373     return NS_OK;
 374   }
 375
 376   // Convert to an nsIFile
 377   nsCOMPtr<nsIFile> file;
 378   nsresult rv = NS_GetFileFromURLSpec(nsDependentCString(gtk_output_uri),
 379                                       getter_AddRefs(file));
 380   if (NS_FAILED(rv)) return rv;
 381
 382   // Extract the path
 383   return file->GetPath(aToFileName);
 384 }
 385
 386 NS_IMETHODIMP
 387 nsPrintSettingsGTK::SetToFileName(const nsAString& aToFileName) {
 388   if (aToFileName.IsEmpty()) {
 389     mToFileName.SetLength(0);
 390     gtk_print_settings_set(mPrintSettings, GTK_PRINT_SETTINGS_OUTPUT_URI,
 391                            nullptr);
 392     return NS_OK;
 393   }
 394
 395   gtk_print_settings_set(mPrintSettings, GTK_PRINT_SETTINGS_OUTPUT_FILE_FORMAT,
 396                          "pdf");
 397
 398   nsCOMPtr<nsIFile> file;
 399   nsresult rv = NS_NewLocalFile(aToFileName, true, getter_AddRefs(file));
 400   NS_ENSURE_SUCCESS(rv, rv);
 401
 402   // Convert the nsIFile to a URL
 403   nsAutoCString url;
 404   rv = NS_GetURLSpecFromFile(file, url);
 405   NS_ENSURE_SUCCESS(rv, rv);
 406
 407   gtk_print_settings_set(mPrintSettings, GTK_PRINT_SETTINGS_OUTPUT_URI,
 408                          url.get());
 409   mToFileName = aToFileName;
 410
 411   return NS_OK;
 412 }
 413
 414 NS_IMETHODIMP
 415 nsPrintSettingsGTK::GetPrinterName(nsAString& aPrinter) {
 416   const char* gtkPrintName = gtk_print_settings_get_printer(mPrintSettings);
 417   if (!gtkPrintName) {
 418     if (GTK_IS_PRINTER(mGTKPrinter)) {
 419       gtkPrintName = gtk_printer_get_name(mGTKPrinter);
 420     } else {
 421       // This mimics what nsPrintSettingsImpl does when we try to Get before we
 422       // Set
 423       aPrinter.Truncate();
 424       return NS_OK;
 425     }
 426   }
 427   aPrinter = NS_ConvertUTF8toUTF16(gtkPrintName);
 428   return NS_OK;
 429 }
 430
 431 NS_IMETHODIMP
 432 nsPrintSettingsGTK::SetPrinterName(const nsAString& aPrinter) {
 433   NS_ConvertUTF16toUTF8 gtkPrinter(aPrinter);
 434
 435   if (StringBeginsWith(gtkPrinter, "CUPS/"_ns)) {
 436     // Strip off "CUPS/"; GTK might recognize the rest
 437     gtkPrinter.Cut(0, strlen("CUPS/"));
 438   }
 439
 440   // Give mPrintSettings the passed-in printer name if either...
 441   // - it has no printer name stored yet
 442   // - it has an existing printer name that's different from
 443   //   the name passed to this function.
 444   const char* oldPrinterName = gtk_print_settings_get_printer(mPrintSettings);
 445   if (!oldPrinterName || !gtkPrinter.Equals(oldPrinterName)) {
 446     mIsInitedFromPrinter = false;
 447     mIsInitedFromPrefs = false;
 448     gtk_print_settings_set_printer(mPrintSettings, gtkPrinter.get());
 449   }
 450
 451   return NS_OK;
 452 }
 453
 454 NS_IMETHODIMP
 455 nsPrintSettingsGTK::GetNumCopies(int32_t* aNumCopies) {
 456   NS_ENSURE_ARG_POINTER(aNumCopies);
 457   *aNumCopies = gtk_print_settings_get_n_copies(mPrintSettings);
 458   return NS_OK;
 459 }
 460 NS_IMETHODIMP
 461 nsPrintSettingsGTK::SetNumCopies(int32_t aNumCopies) {
 462   gtk_print_settings_set_n_copies(mPrintSettings, aNumCopies);
 463   return NS_OK;
 464 }
 465
 466 NS_IMETHODIMP
 467 nsPrintSettingsGTK::GetScaling(double* aScaling) {
 468   *aScaling = gtk_print_settings_get_scale(mPrintSettings) / 100.0;
 469   return NS_OK;
 470 }
 471
 472 NS_IMETHODIMP
 473 nsPrintSettingsGTK::SetScaling(double aScaling) {
 474   gtk_print_settings_set_scale(mPrintSettings, aScaling * 100.0);
 475   return NS_OK;
 476 }
 477
 478 NS_IMETHODIMP
 479 nsPrintSettingsGTK::GetPaperName(nsAString& aPaperName) {
 480   const gchar* name =
 481       gtk_paper_size_get_name(gtk_page_setup_get_paper_size(mPageSetup));
 482   aPaperName = NS_ConvertUTF8toUTF16(name);
 483   return NS_OK;
 484 }
 485 NS_IMETHODIMP
 486 nsPrintSettingsGTK::SetPaperName(const nsAString& aPaperName) {
 487   NS_ConvertUTF16toUTF8 gtkPaperName(aPaperName);
 488
 489   // Convert these Gecko names to GTK names
 490   if (gtkPaperName.EqualsIgnoreCase("letter"))
 491     gtkPaperName.AssignLiteral(GTK_PAPER_NAME_LETTER);
 492   else if (gtkPaperName.EqualsIgnoreCase("legal"))
 493     gtkPaperName.AssignLiteral(GTK_PAPER_NAME_LEGAL);
 494
 495   GtkPaperSize* oldPaperSize = gtk_page_setup_get_paper_size(mPageSetup);
 496   gdouble width = gtk_paper_size_get_width(oldPaperSize, GTK_UNIT_INCH);
 497   gdouble height = gtk_paper_size_get_height(oldPaperSize, GTK_UNIT_INCH);
 498
 499   // Try to get the display name from the name so our paper size fits in the
 500   // Page Setup dialog.
 501   GtkPaperSize* paperSize = gtk_paper_size_new(gtkPaperName.get());
 502   GtkPaperSize* customPaperSize = gtk_paper_size_new_custom(
 503       gtkPaperName.get(), gtk_paper_size_get_display_name(paperSize), width,
 504       height, GTK_UNIT_INCH);
 505   gtk_paper_size_free(paperSize);
 506
 507   gtk_page_setup_set_paper_size(mPageSetup, customPaperSize);
 508   gtk_paper_size_free(customPaperSize);
 509   SaveNewPageSize();
 510   return NS_OK;
 511 }
 512
 513 GtkUnit nsPrintSettingsGTK::GetGTKUnit(int16_t aGeckoUnit) {
 514   if (aGeckoUnit == kPaperSizeMillimeters)
 515     return GTK_UNIT_MM;
 516   else
 517     return GTK_UNIT_INCH;
 518 }
 519
 520 void nsPrintSettingsGTK::SaveNewPageSize() {
 521   gtk_print_settings_set_paper_size(mPrintSettings,
 522                                     gtk_page_setup_get_paper_size(mPageSetup));
 523 }
 524
 525 void nsPrintSettingsGTK::InitUnwriteableMargin() {
 526   mUnwriteableMargin.SizeTo(
 527       NS_INCHES_TO_INT_TWIPS(
 528           gtk_page_setup_get_top_margin(mPageSetup, GTK_UNIT_INCH)),
 529       NS_INCHES_TO_INT_TWIPS(
 530           gtk_page_setup_get_right_margin(mPageSetup, GTK_UNIT_INCH)),
 531       NS_INCHES_TO_INT_TWIPS(
 532           gtk_page_setup_get_bottom_margin(mPageSetup, GTK_UNIT_INCH)),
 533       NS_INCHES_TO_INT_TWIPS(
 534           gtk_page_setup_get_left_margin(mPageSetup, GTK_UNIT_INCH)));
 535 }
 536
 537 /**
 538  * NOTE: Need a custom set of SetUnwriteableMargin functions, because
 539  * whenever we change mUnwriteableMargin, we must pass the change
 540  * down to our GTKPageSetup object.  (This is needed in order for us
 541  * to give the correct default values in nsPrintDialogGTK.)
 542  *
 543  * It's important that the following functions pass
 544  * mUnwriteableMargin values rather than aUnwriteableMargin values
 545  * to gtk_page_setup_set_[blank]_margin, because the two may not be
 546  * the same.  (Specifically, negative values of aUnwriteableMargin
 547  * are ignored by the nsPrintSettings::SetUnwriteableMargin functions.)
 548  */
 549 NS_IMETHODIMP
 550 nsPrintSettingsGTK::SetUnwriteableMarginInTwips(
 551     nsIntMargin& aUnwriteableMargin) {
 552   nsPrintSettings::SetUnwriteableMarginInTwips(aUnwriteableMargin);
 553   gtk_page_setup_set_top_margin(
 554       mPageSetup, NS_TWIPS_TO_INCHES(mUnwriteableMargin.top), GTK_UNIT_INCH);
 555   gtk_page_setup_set_left_margin(
 556       mPageSetup, NS_TWIPS_TO_INCHES(mUnwriteableMargin.left), GTK_UNIT_INCH);
 557   gtk_page_setup_set_bottom_margin(
 558       mPageSetup, NS_TWIPS_TO_INCHES(mUnwriteableMargin.bottom), GTK_UNIT_INCH);
 559   gtk_page_setup_set_right_margin(
 560       mPageSetup, NS_TWIPS_TO_INCHES(mUnwriteableMargin.right), GTK_UNIT_INCH);
 561   return NS_OK;
 562 }
 563
 564 NS_IMETHODIMP
 565 nsPrintSettingsGTK::SetUnwriteableMarginTop(double aUnwriteableMarginTop) {
 566   nsPrintSettings::SetUnwriteableMarginTop(aUnwriteableMarginTop);
 567   gtk_page_setup_set_top_margin(
 568       mPageSetup, NS_TWIPS_TO_INCHES(mUnwriteableMargin.top), GTK_UNIT_INCH);
 569   return NS_OK;
 570 }
 571
 572 NS_IMETHODIMP
 573 nsPrintSettingsGTK::SetUnwriteableMarginLeft(double aUnwriteableMarginLeft) {
 574   nsPrintSettings::SetUnwriteableMarginLeft(aUnwriteableMarginLeft);
 575   gtk_page_setup_set_left_margin(
 576       mPageSetup, NS_TWIPS_TO_INCHES(mUnwriteableMargin.left), GTK_UNIT_INCH);
 577   return NS_OK;
 578 }
 579
 580 NS_IMETHODIMP
 581 nsPrintSettingsGTK::SetUnwriteableMarginBottom(
 582     double aUnwriteableMarginBottom) {
 583   nsPrintSettings::SetUnwriteableMarginBottom(aUnwriteableMarginBottom);
 584   gtk_page_setup_set_bottom_margin(
 585       mPageSetup, NS_TWIPS_TO_INCHES(mUnwriteableMargin.bottom), GTK_UNIT_INCH);
 586   return NS_OK;
 587 }
 588
 589 NS_IMETHODIMP
 590 nsPrintSettingsGTK::SetUnwriteableMarginRight(double aUnwriteableMarginRight) {
 591   nsPrintSettings::SetUnwriteableMarginRight(aUnwriteableMarginRight);
 592   gtk_page_setup_set_right_margin(
 593       mPageSetup, NS_TWIPS_TO_INCHES(mUnwriteableMargin.right), GTK_UNIT_INCH);
 594   return NS_OK;
 595 }
 596
 597 NS_IMETHODIMP
 598 nsPrintSettingsGTK::GetPaperWidth(double* aPaperWidth) {
 599   NS_ENSURE_ARG_POINTER(aPaperWidth);
 600   GtkPaperSize* paperSize = gtk_page_setup_get_paper_size(mPageSetup);
 601   *aPaperWidth =
 602       gtk_paper_size_get_width(paperSize, GetGTKUnit(mPaperSizeUnit));
 603   return NS_OK;
 604 }
 605 NS_IMETHODIMP
 606 nsPrintSettingsGTK::SetPaperWidth(double aPaperWidth) {
 607   GtkPaperSize* paperSize = gtk_page_setup_get_paper_size(mPageSetup);
 608   gtk_paper_size_set_size(
 609       paperSize, aPaperWidth,
 610       gtk_paper_size_get_height(paperSize, GetGTKUnit(mPaperSizeUnit)),
 611       GetGTKUnit(mPaperSizeUnit));
 612   SaveNewPageSize();
 613   return NS_OK;
 614 }
 615
 616 NS_IMETHODIMP
 617 nsPrintSettingsGTK::GetPaperHeight(double* aPaperHeight) {
 618   NS_ENSURE_ARG_POINTER(aPaperHeight);
 619   GtkPaperSize* paperSize = gtk_page_setup_get_paper_size(mPageSetup);
 620   *aPaperHeight =
 621       gtk_paper_size_get_height(paperSize, GetGTKUnit(mPaperSizeUnit));
 622   return NS_OK;
 623 }
 624 NS_IMETHODIMP
 625 nsPrintSettingsGTK::SetPaperHeight(double aPaperHeight) {
 626   GtkPaperSize* paperSize = gtk_page_setup_get_paper_size(mPageSetup);
 627   gtk_paper_size_set_size(
 628       paperSize,
 629       gtk_paper_size_get_width(paperSize, GetGTKUnit(mPaperSizeUnit)),
 630       aPaperHeight, GetGTKUnit(mPaperSizeUnit));
 631   SaveNewPageSize();
 632   return NS_OK;
 633 }
 634
 635 NS_IMETHODIMP
 636 nsPrintSettingsGTK::SetPaperSizeUnit(int16_t aPaperSizeUnit) {
 637   // Convert units internally. e.g. they might have set the values while we're
 638   // still in mm but they change to inch just afterwards, expecting that their
 639   // sizes are in inches.
 640   GtkPaperSize* paperSize = gtk_page_setup_get_paper_size(mPageSetup);
 641   gtk_paper_size_set_size(
 642       paperSize,
 643       gtk_paper_size_get_width(paperSize, GetGTKUnit(mPaperSizeUnit)),
 644       gtk_paper_size_get_height(paperSize, GetGTKUnit(mPaperSizeUnit)),
 645       GetGTKUnit(aPaperSizeUnit));
 646   SaveNewPageSize();
 647
 648   mPaperSizeUnit = aPaperSizeUnit;
 649   return NS_OK;
 650 }
 651
 652 NS_IMETHODIMP
 653 nsPrintSettingsGTK::GetEffectivePageSize(double* aWidth, double* aHeight) {
 654   GtkPaperSize* paperSize = gtk_page_setup_get_paper_size(mPageSetup);
 655   *aWidth = NS_INCHES_TO_INT_TWIPS(
 656       gtk_paper_size_get_width(paperSize, GTK_UNIT_INCH));
 657   *aHeight = NS_INCHES_TO_INT_TWIPS(
 658       gtk_paper_size_get_height(paperSize, GTK_UNIT_INCH));
 659
 660   GtkPageOrientation gtkOrient = gtk_page_setup_get_orientation(mPageSetup);
 661
 662   if (gtkOrient == GTK_PAGE_ORIENTATION_LANDSCAPE ||
 663       gtkOrient == GTK_PAGE_ORIENTATION_REVERSE_LANDSCAPE) {
 664     double temp = *aWidth;
 665     *aWidth = *aHeight;
 666     *aHeight = temp;
 667   }
 668   return NS_OK;
 669 }
 670
 671 NS_IMETHODIMP
 672 nsPrintSettingsGTK::SetupSilentPrinting() {
 673   // We have to get a printer here, rather than when the print settings are
 674   // constructed. This is because when we request sync, GTK makes us wait in the
 675   // *event loop* while waiting for the enumeration to finish. We must do this
 676   // when event loop runs are expected.
 677   gtk_enumerate_printers(printer_enumerator, this, nullptr, TRUE);
 678
 679   // XXX If no default printer set, get the first one.
 680   if (!GTK_IS_PRINTER(mGTKPrinter))
 681     gtk_enumerate_printers(ref_printer, this, nullptr, TRUE);
 682
 683   return NS_OK;
 684 }
 685
 686 NS_IMETHODIMP
 687 nsPrintSettingsGTK::GetPageRanges(nsTArray<int32_t>& aPages) {
 688   gint ctRanges;
 689   GtkPageRange* lstRanges =
 690       gtk_print_settings_get_page_ranges(mPrintSettings, &ctRanges);
 691
 692   aPages.Clear();
 693
 694   if (ctRanges > 1) {
 695     for (gint i = 0; i < ctRanges; i++) {
 696       aPages.AppendElement(lstRanges[i].start + 1);
 697       aPages.AppendElement(lstRanges[i].end + 1);
 698     }
 699   }
 700
 701   g_free(lstRanges);
 702   return NS_OK;
 703 }
 704
 705 NS_IMETHODIMP
 706 nsPrintSettingsGTK::GetResolution(int32_t* aResolution) {
 707   if (!gtk_print_settings_has_key(mPrintSettings,
 708                                   GTK_PRINT_SETTINGS_RESOLUTION))
 709     return NS_ERROR_FAILURE;
 710   *aResolution = gtk_print_settings_get_resolution(mPrintSettings);
 711   return NS_OK;
 712 }
 713
 714 NS_IMETHODIMP
 715 nsPrintSettingsGTK::SetResolution(int32_t aResolution) {
 716   gtk_print_settings_set_resolution(mPrintSettings, aResolution);
 717   return NS_OK;
 718 }
 719
 720 NS_IMETHODIMP
 721 nsPrintSettingsGTK::GetDuplex(int32_t* aDuplex) {
 722   if (!gtk_print_settings_has_key(mPrintSettings, GTK_PRINT_SETTINGS_DUPLEX)) {
 723     *aDuplex = GTK_PRINT_DUPLEX_SIMPLEX;
 724   } else {
 725     *aDuplex = gtk_print_settings_get_duplex(mPrintSettings);
 726   }
 727   return NS_OK;
 728 }
 729
 730 NS_IMETHODIMP
 731 nsPrintSettingsGTK::SetDuplex(int32_t aDuplex) {
 732   MOZ_ASSERT(aDuplex >= GTK_PRINT_DUPLEX_SIMPLEX &&
 733                  aDuplex <= GTK_PRINT_DUPLEX_VERTICAL,
 734              "value is out of bounds for GtkPrintDuplex enum");
 735   gtk_print_settings_set_duplex(mPrintSettings,
 736                                 static_cast<GtkPrintDuplex>(aDuplex));
 737   return NS_OK;
 738 }