The Tor Browser / file comparison

comparison: widget/gtk/nsPrintSettingsGTK.cpp

widget/gtk/nsPrintSettingsGTK.cpp

changeset 0
6474c204b198
equal deleted inserted replaced
-1:000000000000 0:8d06a27ac2e7
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; gecko 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 Gecko 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 aGeckoUnit)
546 {
547 if (aGeckoUnit == 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

Mercurial Repository: The Tor Browser

Europalab SCM Repository Server

mercurial