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