The Tor Browser / file comparison

comparison: widget/xpwidgets/nsPrintSettingsImpl.cpp

widget/xpwidgets/nsPrintSettingsImpl.cpp

branch
TOR_BUG_9701
changeset 13
44a2da4a2ab2
equal deleted inserted replaced
-1:000000000000 0:9565ffe34afb
1 /* -*- Mode: C++; tab-width: 4; 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 "nsPrintSettingsImpl.h"
7 #include "nsReadableUtils.h"
8 #include "nsIPrintSession.h"
9
10 #define DEFAULT_MARGIN_WIDTH 0.5
11
12 NS_IMPL_ISUPPORTS(nsPrintSettings, nsIPrintSettings)
13
14 /** ---------------------------------------------------
15 * See documentation in nsPrintSettingsImpl.h
16 * @update 6/21/00 dwc
17 */
18 nsPrintSettings::nsPrintSettings() :
19 mPrintOptions(0L),
20 mPrintRange(kRangeAllPages),
21 mStartPageNum(1),
22 mEndPageNum(1),
23 mScaling(1.0),
24 mPrintBGColors(false),
25 mPrintBGImages(false),
26 mPrintFrameTypeUsage(kUseInternalDefault),
27 mPrintFrameType(kFramesAsIs),
28 mHowToEnableFrameUI(kFrameEnableNone),
29 mIsCancelled(false),
30 mPrintSilent(false),
31 mPrintPreview(false),
32 mShrinkToFit(true),
33 mShowPrintProgress(true),
34 mPrintPageDelay(50),
35 mPaperData(0),
36 mPaperSizeType(kPaperSizeDefined),
37 mPaperWidth(8.5),
38 mPaperHeight(11.0),
39 mPaperSizeUnit(kPaperSizeInches),
40 mPrintReversed(false),
41 mPrintInColor(true),
42 mOrientation(kPortraitOrientation),
43 mDownloadFonts(false),
44 mNumCopies(1),
45 mPrintToFile(false),
46 mOutputFormat(kOutputFormatNative),
47 mIsInitedFromPrinter(false),
48 mIsInitedFromPrefs(false),
49 mPersistMarginBoxSettings(true)
50 {
51
52 /* member initializers and constructor code */
53 int32_t marginWidth = NS_INCHES_TO_INT_TWIPS(DEFAULT_MARGIN_WIDTH);
54 mMargin.SizeTo(marginWidth, marginWidth, marginWidth, marginWidth);
55 mEdge.SizeTo(0, 0, 0, 0);
56 mUnwriteableMargin.SizeTo(0,0,0,0);
57
58 mPrintOptions = kPrintOddPages | kPrintEvenPages;
59
60 mHeaderStrs[0].AssignLiteral("&T");
61 mHeaderStrs[2].AssignLiteral("&U");
62
63 mFooterStrs[0].AssignLiteral("&PT"); // Use &P (Page Num Only) or &PT (Page Num of Page Total)
64 mFooterStrs[2].AssignLiteral("&D");
65
66 }
67
68 /** ---------------------------------------------------
69 * See documentation in nsPrintSettingsImpl.h
70 * @update 6/21/00 dwc
71 */
72 nsPrintSettings::nsPrintSettings(const nsPrintSettings& aPS)
73 {
74 *this = aPS;
75 }
76
77 /** ---------------------------------------------------
78 * See documentation in nsPrintSettingsImpl.h
79 * @update 6/21/00 dwc
80 */
81 nsPrintSettings::~nsPrintSettings()
82 {
83 }
84
85 /* [noscript] attribute nsIPrintSession printSession; */
86 NS_IMETHODIMP nsPrintSettings::GetPrintSession(nsIPrintSession **aPrintSession)
87 {
88 NS_ENSURE_ARG_POINTER(aPrintSession);
89 *aPrintSession = nullptr;
90
91 nsCOMPtr<nsIPrintSession> session = do_QueryReferent(mSession);
92 if (!session)
93 return NS_ERROR_NOT_INITIALIZED;
94 *aPrintSession = session;
95 NS_ADDREF(*aPrintSession);
96 return NS_OK;
97 }
98 NS_IMETHODIMP nsPrintSettings::SetPrintSession(nsIPrintSession *aPrintSession)
99 {
100 // Clearing it by passing nullptr is not allowed. That's why we
101 // use a weak ref so that it doesn't have to be cleared.
102 NS_ENSURE_ARG(aPrintSession);
103
104 mSession = do_GetWeakReference(aPrintSession);
105 if (!mSession) {
106 // This may happen if the implementation of this object does
107 // not support weak references - programmer error.
108 NS_ERROR("Could not get a weak reference from aPrintSession");
109 return NS_ERROR_FAILURE;
110 }
111 return NS_OK;
112 }
113
114 /* attribute long startPageRange; */
115 NS_IMETHODIMP nsPrintSettings::GetStartPageRange(int32_t *aStartPageRange)
116 {
117 //NS_ENSURE_ARG_POINTER(aStartPageRange);
118 *aStartPageRange = mStartPageNum;
119 return NS_OK;
120 }
121 NS_IMETHODIMP nsPrintSettings::SetStartPageRange(int32_t aStartPageRange)
122 {
123 mStartPageNum = aStartPageRange;
124 return NS_OK;
125 }
126
127 /* attribute long endPageRange; */
128 NS_IMETHODIMP nsPrintSettings::GetEndPageRange(int32_t *aEndPageRange)
129 {
130 //NS_ENSURE_ARG_POINTER(aEndPageRange);
131 *aEndPageRange = mEndPageNum;
132 return NS_OK;
133 }
134 NS_IMETHODIMP nsPrintSettings::SetEndPageRange(int32_t aEndPageRange)
135 {
136 mEndPageNum = aEndPageRange;
137 return NS_OK;
138 }
139
140 /* attribute boolean printReversed; */
141 NS_IMETHODIMP nsPrintSettings::GetPrintReversed(bool *aPrintReversed)
142 {
143 //NS_ENSURE_ARG_POINTER(aPrintReversed);
144 *aPrintReversed = mPrintReversed;
145 return NS_OK;
146 }
147 NS_IMETHODIMP nsPrintSettings::SetPrintReversed(bool aPrintReversed)
148 {
149 mPrintReversed = aPrintReversed;
150 return NS_OK;
151 }
152
153 /* attribute boolean printInColor; */
154 NS_IMETHODIMP nsPrintSettings::GetPrintInColor(bool *aPrintInColor)
155 {
156 //NS_ENSURE_ARG_POINTER(aPrintInColor);
157 *aPrintInColor = mPrintInColor;
158 return NS_OK;
159 }
160 NS_IMETHODIMP nsPrintSettings::SetPrintInColor(bool aPrintInColor)
161 {
162 mPrintInColor = aPrintInColor;
163 return NS_OK;
164 }
165
166 /* attribute short orientation; */
167 NS_IMETHODIMP nsPrintSettings::GetOrientation(int32_t *aOrientation)
168 {
169 NS_ENSURE_ARG_POINTER(aOrientation);
170 *aOrientation = mOrientation;
171 return NS_OK;
172 }
173 NS_IMETHODIMP nsPrintSettings::SetOrientation(int32_t aOrientation)
174 {
175 mOrientation = aOrientation;
176 return NS_OK;
177 }
178
179 /* attribute wstring colorspace; */
180 NS_IMETHODIMP nsPrintSettings::GetColorspace(char16_t * *aColorspace)
181 {
182 NS_ENSURE_ARG_POINTER(aColorspace);
183 if (!mColorspace.IsEmpty()) {
184 *aColorspace = ToNewUnicode(mColorspace);
185 } else {
186 *aColorspace = nullptr;
187 }
188 return NS_OK;
189 }
190 NS_IMETHODIMP nsPrintSettings::SetColorspace(const char16_t * aColorspace)
191 {
192 if (aColorspace) {
193 mColorspace = aColorspace;
194 } else {
195 mColorspace.SetLength(0);
196 }
197 return NS_OK;
198 }
199
200 /* attribute wstring resolutionname; */
201 NS_IMETHODIMP nsPrintSettings::GetResolutionName(char16_t * *aResolutionName)
202 {
203 NS_ENSURE_ARG_POINTER(aResolutionName);
204 if (!mResolutionName.IsEmpty()) {
205 *aResolutionName = ToNewUnicode(mResolutionName);
206 } else {
207 *aResolutionName = nullptr;
208 }
209 return NS_OK;
210 }
211 NS_IMETHODIMP nsPrintSettings::SetResolutionName(const char16_t * aResolutionName)
212 {
213 if (aResolutionName) {
214 mResolutionName = aResolutionName;
215 } else {
216 mResolutionName.SetLength(0);
217 }
218 return NS_OK;
219 }
220
221 /* attribute wstring resolution; */
222 NS_IMETHODIMP nsPrintSettings::GetResolution(int32_t *aResolution)
223 {
224 NS_ENSURE_ARG_POINTER(aResolution);
225 *aResolution = mResolution;
226 return NS_OK;
227 }
228 NS_IMETHODIMP nsPrintSettings::SetResolution(const int32_t aResolution)
229 {
230 mResolution = aResolution;
231 return NS_OK;
232 }
233
234 /* attribute wstring duplex; */
235 NS_IMETHODIMP nsPrintSettings::GetDuplex(int32_t *aDuplex)
236 {
237 NS_ENSURE_ARG_POINTER(aDuplex);
238 *aDuplex = mDuplex;
239 return NS_OK;
240 }
241 NS_IMETHODIMP nsPrintSettings::SetDuplex(const int32_t aDuplex)
242 {
243 mDuplex = aDuplex;
244 return NS_OK;
245 }
246
247 /* attribute boolean downloadFonts; */
248 NS_IMETHODIMP nsPrintSettings::GetDownloadFonts(bool *aDownloadFonts)
249 {
250 //NS_ENSURE_ARG_POINTER(aDownloadFonts);
251 *aDownloadFonts = mDownloadFonts;
252 return NS_OK;
253 }
254 NS_IMETHODIMP nsPrintSettings::SetDownloadFonts(bool aDownloadFonts)
255 {
256 mDownloadFonts = aDownloadFonts;
257 return NS_OK;
258 }
259
260 /* attribute wstring printer; */
261 NS_IMETHODIMP nsPrintSettings::GetPrinterName(char16_t * *aPrinter)
262 {
263 NS_ENSURE_ARG_POINTER(aPrinter);
264
265 *aPrinter = ToNewUnicode(mPrinter);
266 NS_ENSURE_TRUE(*aPrinter, NS_ERROR_OUT_OF_MEMORY);
267
268 return NS_OK;
269 }
270
271 NS_IMETHODIMP nsPrintSettings::SetPrinterName(const char16_t * aPrinter)
272 {
273 if (!aPrinter || !mPrinter.Equals(aPrinter)) {
274 mIsInitedFromPrinter = false;
275 mIsInitedFromPrefs = false;
276 }
277
278 mPrinter.Assign(aPrinter);
279 return NS_OK;
280 }
281
282 /* attribute long numCopies; */
283 NS_IMETHODIMP nsPrintSettings::GetNumCopies(int32_t *aNumCopies)
284 {
285 NS_ENSURE_ARG_POINTER(aNumCopies);
286 *aNumCopies = mNumCopies;
287 return NS_OK;
288 }
289 NS_IMETHODIMP nsPrintSettings::SetNumCopies(int32_t aNumCopies)
290 {
291 mNumCopies = aNumCopies;
292 return NS_OK;
293 }
294
295 /* attribute wstring printCommand; */
296 NS_IMETHODIMP nsPrintSettings::GetPrintCommand(char16_t * *aPrintCommand)
297 {
298 //NS_ENSURE_ARG_POINTER(aPrintCommand);
299 *aPrintCommand = ToNewUnicode(mPrintCommand);
300 return NS_OK;
301 }
302 NS_IMETHODIMP nsPrintSettings::SetPrintCommand(const char16_t * aPrintCommand)
303 {
304 if (aPrintCommand) {
305 mPrintCommand = aPrintCommand;
306 } else {
307 mPrintCommand.SetLength(0);
308 }
309 return NS_OK;
310 }
311
312 /* attribute boolean printToFile; */
313 NS_IMETHODIMP nsPrintSettings::GetPrintToFile(bool *aPrintToFile)
314 {
315 //NS_ENSURE_ARG_POINTER(aPrintToFile);
316 *aPrintToFile = mPrintToFile;
317 return NS_OK;
318 }
319 NS_IMETHODIMP nsPrintSettings::SetPrintToFile(bool aPrintToFile)
320 {
321 mPrintToFile = aPrintToFile;
322 return NS_OK;
323 }
324
325 /* attribute wstring toFileName; */
326 NS_IMETHODIMP nsPrintSettings::GetToFileName(char16_t * *aToFileName)
327 {
328 //NS_ENSURE_ARG_POINTER(aToFileName);
329 *aToFileName = ToNewUnicode(mToFileName);
330 return NS_OK;
331 }
332 NS_IMETHODIMP nsPrintSettings::SetToFileName(const char16_t * aToFileName)
333 {
334 if (aToFileName) {
335 mToFileName = aToFileName;
336 } else {
337 mToFileName.SetLength(0);
338 }
339 return NS_OK;
340 }
341
342 /* attribute short outputFormat; */
343 NS_IMETHODIMP nsPrintSettings::GetOutputFormat(int16_t *aOutputFormat)
344 {
345 NS_ENSURE_ARG_POINTER(aOutputFormat);
346 *aOutputFormat = mOutputFormat;
347 return NS_OK;
348 }
349 NS_IMETHODIMP nsPrintSettings::SetOutputFormat(int16_t aOutputFormat)
350 {
351 mOutputFormat = aOutputFormat;
352 return NS_OK;
353 }
354
355 /* attribute long printPageDelay; */
356 NS_IMETHODIMP nsPrintSettings::GetPrintPageDelay(int32_t *aPrintPageDelay)
357 {
358 *aPrintPageDelay = mPrintPageDelay;
359 return NS_OK;
360 }
361 NS_IMETHODIMP nsPrintSettings::SetPrintPageDelay(int32_t aPrintPageDelay)
362 {
363 mPrintPageDelay = aPrintPageDelay;
364 return NS_OK;
365 }
366
367 /* attribute boolean isInitializedFromPrinter; */
368 NS_IMETHODIMP nsPrintSettings::GetIsInitializedFromPrinter(bool *aIsInitializedFromPrinter)
369 {
370 NS_ENSURE_ARG_POINTER(aIsInitializedFromPrinter);
371 *aIsInitializedFromPrinter = (bool)mIsInitedFromPrinter;
372 return NS_OK;
373 }
374 NS_IMETHODIMP nsPrintSettings::SetIsInitializedFromPrinter(bool aIsInitializedFromPrinter)
375 {
376 mIsInitedFromPrinter = (bool)aIsInitializedFromPrinter;
377 return NS_OK;
378 }
379
380 /* attribute boolean isInitializedFromPrefs; */
381 NS_IMETHODIMP nsPrintSettings::GetIsInitializedFromPrefs(bool *aInitializedFromPrefs)
382 {
383 NS_ENSURE_ARG_POINTER(aInitializedFromPrefs);
384 *aInitializedFromPrefs = (bool)mIsInitedFromPrefs;
385 return NS_OK;
386 }
387 NS_IMETHODIMP nsPrintSettings::SetIsInitializedFromPrefs(bool aInitializedFromPrefs)
388 {
389 mIsInitedFromPrefs = (bool)aInitializedFromPrefs;
390 return NS_OK;
391 }
392
393 /* attribute boolean persistMarginBoxSettings; */
394 NS_IMETHODIMP nsPrintSettings::GetPersistMarginBoxSettings(bool *aPersistMarginBoxSettings)
395 {
396 NS_ENSURE_ARG_POINTER(aPersistMarginBoxSettings);
397 *aPersistMarginBoxSettings = mPersistMarginBoxSettings;
398 return NS_OK;
399 }
400 NS_IMETHODIMP nsPrintSettings::SetPersistMarginBoxSettings(bool aPersistMarginBoxSettings)
401 {
402 mPersistMarginBoxSettings = aPersistMarginBoxSettings;
403 return NS_OK;
404 }
405
406 /* attribute double marginTop; */
407 NS_IMETHODIMP nsPrintSettings::GetMarginTop(double *aMarginTop)
408 {
409 NS_ENSURE_ARG_POINTER(aMarginTop);
410 *aMarginTop = NS_TWIPS_TO_INCHES(mMargin.top);
411 return NS_OK;
412 }
413 NS_IMETHODIMP nsPrintSettings::SetMarginTop(double aMarginTop)
414 {
415 mMargin.top = NS_INCHES_TO_INT_TWIPS(float(aMarginTop));
416 return NS_OK;
417 }
418
419 /* attribute double marginLeft; */
420 NS_IMETHODIMP nsPrintSettings::GetMarginLeft(double *aMarginLeft)
421 {
422 NS_ENSURE_ARG_POINTER(aMarginLeft);
423 *aMarginLeft = NS_TWIPS_TO_INCHES(mMargin.left);
424 return NS_OK;
425 }
426 NS_IMETHODIMP nsPrintSettings::SetMarginLeft(double aMarginLeft)
427 {
428 mMargin.left = NS_INCHES_TO_INT_TWIPS(float(aMarginLeft));
429 return NS_OK;
430 }
431
432 /* attribute double marginBottom; */
433 NS_IMETHODIMP nsPrintSettings::GetMarginBottom(double *aMarginBottom)
434 {
435 NS_ENSURE_ARG_POINTER(aMarginBottom);
436 *aMarginBottom = NS_TWIPS_TO_INCHES(mMargin.bottom);
437 return NS_OK;
438 }
439 NS_IMETHODIMP nsPrintSettings::SetMarginBottom(double aMarginBottom)
440 {
441 mMargin.bottom = NS_INCHES_TO_INT_TWIPS(float(aMarginBottom));
442 return NS_OK;
443 }
444
445 /* attribute double marginRight; */
446 NS_IMETHODIMP nsPrintSettings::GetMarginRight(double *aMarginRight)
447 {
448 NS_ENSURE_ARG_POINTER(aMarginRight);
449 *aMarginRight = NS_TWIPS_TO_INCHES(mMargin.right);
450 return NS_OK;
451 }
452 NS_IMETHODIMP nsPrintSettings::SetMarginRight(double aMarginRight)
453 {
454 mMargin.right = NS_INCHES_TO_INT_TWIPS(float(aMarginRight));
455 return NS_OK;
456 }
457
458 /* attribute double edgeTop; */
459 NS_IMETHODIMP nsPrintSettings::GetEdgeTop(double *aEdgeTop)
460 {
461 NS_ENSURE_ARG_POINTER(aEdgeTop);
462 *aEdgeTop = NS_TWIPS_TO_INCHES(mEdge.top);
463 return NS_OK;
464 }
465 NS_IMETHODIMP nsPrintSettings::SetEdgeTop(double aEdgeTop)
466 {
467 mEdge.top = NS_INCHES_TO_INT_TWIPS(float(aEdgeTop));
468 return NS_OK;
469 }
470
471 /* attribute double edgeLeft; */
472 NS_IMETHODIMP nsPrintSettings::GetEdgeLeft(double *aEdgeLeft)
473 {
474 NS_ENSURE_ARG_POINTER(aEdgeLeft);
475 *aEdgeLeft = NS_TWIPS_TO_INCHES(mEdge.left);
476 return NS_OK;
477 }
478 NS_IMETHODIMP nsPrintSettings::SetEdgeLeft(double aEdgeLeft)
479 {
480 mEdge.left = NS_INCHES_TO_INT_TWIPS(float(aEdgeLeft));
481 return NS_OK;
482 }
483
484 /* attribute double edgeBottom; */
485 NS_IMETHODIMP nsPrintSettings::GetEdgeBottom(double *aEdgeBottom)
486 {
487 NS_ENSURE_ARG_POINTER(aEdgeBottom);
488 *aEdgeBottom = NS_TWIPS_TO_INCHES(mEdge.bottom);
489 return NS_OK;
490 }
491 NS_IMETHODIMP nsPrintSettings::SetEdgeBottom(double aEdgeBottom)
492 {
493 mEdge.bottom = NS_INCHES_TO_INT_TWIPS(float(aEdgeBottom));
494 return NS_OK;
495 }
496
497 /* attribute double edgeRight; */
498 NS_IMETHODIMP nsPrintSettings::GetEdgeRight(double *aEdgeRight)
499 {
500 NS_ENSURE_ARG_POINTER(aEdgeRight);
501 *aEdgeRight = NS_TWIPS_TO_INCHES(mEdge.right);
502 return NS_OK;
503 }
504 NS_IMETHODIMP nsPrintSettings::SetEdgeRight(double aEdgeRight)
505 {
506 mEdge.right = NS_INCHES_TO_INT_TWIPS(float(aEdgeRight));
507 return NS_OK;
508 }
509
510 /* attribute double unwriteableMarginTop; */
511 NS_IMETHODIMP nsPrintSettings::GetUnwriteableMarginTop(double *aUnwriteableMarginTop)
512 {
513 NS_ENSURE_ARG_POINTER(aUnwriteableMarginTop);
514 *aUnwriteableMarginTop = NS_TWIPS_TO_INCHES(mUnwriteableMargin.top);
515 return NS_OK;
516 }
517 NS_IMETHODIMP nsPrintSettings::SetUnwriteableMarginTop(double aUnwriteableMarginTop)
518 {
519 if (aUnwriteableMarginTop >= 0.0) {
520 mUnwriteableMargin.top = NS_INCHES_TO_INT_TWIPS(aUnwriteableMarginTop);
521 }
522 return NS_OK;
523 }
524
525 /* attribute double unwriteableMarginLeft; */
526 NS_IMETHODIMP nsPrintSettings::GetUnwriteableMarginLeft(double *aUnwriteableMarginLeft)
527 {
528 NS_ENSURE_ARG_POINTER(aUnwriteableMarginLeft);
529 *aUnwriteableMarginLeft = NS_TWIPS_TO_INCHES(mUnwriteableMargin.left);
530 return NS_OK;
531 }
532 NS_IMETHODIMP nsPrintSettings::SetUnwriteableMarginLeft(double aUnwriteableMarginLeft)
533 {
534 if (aUnwriteableMarginLeft >= 0.0) {
535 mUnwriteableMargin.left = NS_INCHES_TO_INT_TWIPS(aUnwriteableMarginLeft);
536 }
537 return NS_OK;
538 }
539
540 /* attribute double unwriteableMarginBottom; */
541 NS_IMETHODIMP nsPrintSettings::GetUnwriteableMarginBottom(double *aUnwriteableMarginBottom)
542 {
543 NS_ENSURE_ARG_POINTER(aUnwriteableMarginBottom);
544 *aUnwriteableMarginBottom = NS_TWIPS_TO_INCHES(mUnwriteableMargin.bottom);
545 return NS_OK;
546 }
547 NS_IMETHODIMP nsPrintSettings::SetUnwriteableMarginBottom(double aUnwriteableMarginBottom)
548 {
549 if (aUnwriteableMarginBottom >= 0.0) {
550 mUnwriteableMargin.bottom = NS_INCHES_TO_INT_TWIPS(aUnwriteableMarginBottom);
551 }
552 return NS_OK;
553 }
554
555 /* attribute double unwriteableMarginRight; */
556 NS_IMETHODIMP nsPrintSettings::GetUnwriteableMarginRight(double *aUnwriteableMarginRight)
557 {
558 NS_ENSURE_ARG_POINTER(aUnwriteableMarginRight);
559 *aUnwriteableMarginRight = NS_TWIPS_TO_INCHES(mUnwriteableMargin.right);
560 return NS_OK;
561 }
562 NS_IMETHODIMP nsPrintSettings::SetUnwriteableMarginRight(double aUnwriteableMarginRight)
563 {
564 if (aUnwriteableMarginRight >= 0.0) {
565 mUnwriteableMargin.right = NS_INCHES_TO_INT_TWIPS(aUnwriteableMarginRight);
566 }
567 return NS_OK;
568 }
569
570 /* attribute double scaling; */
571 NS_IMETHODIMP nsPrintSettings::GetScaling(double *aScaling)
572 {
573 NS_ENSURE_ARG_POINTER(aScaling);
574 *aScaling = mScaling;
575 return NS_OK;
576 }
577
578 NS_IMETHODIMP nsPrintSettings::SetScaling(double aScaling)
579 {
580 mScaling = aScaling;
581 return NS_OK;
582 }
583
584 /* attribute boolean printBGColors; */
585 NS_IMETHODIMP nsPrintSettings::GetPrintBGColors(bool *aPrintBGColors)
586 {
587 NS_ENSURE_ARG_POINTER(aPrintBGColors);
588 *aPrintBGColors = mPrintBGColors;
589 return NS_OK;
590 }
591 NS_IMETHODIMP nsPrintSettings::SetPrintBGColors(bool aPrintBGColors)
592 {
593 mPrintBGColors = aPrintBGColors;
594 return NS_OK;
595 }
596
597 /* attribute boolean printBGImages; */
598 NS_IMETHODIMP nsPrintSettings::GetPrintBGImages(bool *aPrintBGImages)
599 {
600 NS_ENSURE_ARG_POINTER(aPrintBGImages);
601 *aPrintBGImages = mPrintBGImages;
602 return NS_OK;
603 }
604 NS_IMETHODIMP nsPrintSettings::SetPrintBGImages(bool aPrintBGImages)
605 {
606 mPrintBGImages = aPrintBGImages;
607 return NS_OK;
608 }
609
610 /* attribute long printRange; */
611 NS_IMETHODIMP nsPrintSettings::GetPrintRange(int16_t *aPrintRange)
612 {
613 NS_ENSURE_ARG_POINTER(aPrintRange);
614 *aPrintRange = mPrintRange;
615 return NS_OK;
616 }
617 NS_IMETHODIMP nsPrintSettings::SetPrintRange(int16_t aPrintRange)
618 {
619 mPrintRange = aPrintRange;
620 return NS_OK;
621 }
622
623 /* attribute wstring docTitle; */
624 NS_IMETHODIMP nsPrintSettings::GetTitle(char16_t * *aTitle)
625 {
626 NS_ENSURE_ARG_POINTER(aTitle);
627 if (!mTitle.IsEmpty()) {
628 *aTitle = ToNewUnicode(mTitle);
629 } else {
630 *aTitle = nullptr;
631 }
632 return NS_OK;
633 }
634 NS_IMETHODIMP nsPrintSettings::SetTitle(const char16_t * aTitle)
635 {
636 if (aTitle) {
637 mTitle = aTitle;
638 } else {
639 mTitle.SetLength(0);
640 }
641 return NS_OK;
642 }
643
644 /* attribute wstring docURL; */
645 NS_IMETHODIMP nsPrintSettings::GetDocURL(char16_t * *aDocURL)
646 {
647 NS_ENSURE_ARG_POINTER(aDocURL);
648 if (!mURL.IsEmpty()) {
649 *aDocURL = ToNewUnicode(mURL);
650 } else {
651 *aDocURL = nullptr;
652 }
653 return NS_OK;
654 }
655 NS_IMETHODIMP nsPrintSettings::SetDocURL(const char16_t * aDocURL)
656 {
657 if (aDocURL) {
658 mURL = aDocURL;
659 } else {
660 mURL.SetLength(0);
661 }
662 return NS_OK;
663 }
664
665 /** ---------------------------------------------------
666 * See documentation in nsPrintSettingsImpl.h
667 * @update 1/12/01 rods
668 */
669 NS_IMETHODIMP
670 nsPrintSettings::GetPrintOptions(int32_t aType, bool *aTurnOnOff)
671 {
672 NS_ENSURE_ARG_POINTER(aTurnOnOff);
673 *aTurnOnOff = mPrintOptions & aType ? true : false;
674 return NS_OK;
675 }
676 /** ---------------------------------------------------
677 * See documentation in nsPrintSettingsImpl.h
678 * @update 1/12/01 rods
679 */
680 NS_IMETHODIMP
681 nsPrintSettings::SetPrintOptions(int32_t aType, bool aTurnOnOff)
682 {
683 if (aTurnOnOff) {
684 mPrintOptions |= aType;
685 } else {
686 mPrintOptions &= ~aType;
687 }
688 return NS_OK;
689 }
690
691 /** ---------------------------------------------------
692 * See documentation in nsPrintSettingsImpl.h
693 * @update 1/12/01 rods
694 */
695 NS_IMETHODIMP
696 nsPrintSettings::GetPrintOptionsBits(int32_t *aBits)
697 {
698 NS_ENSURE_ARG_POINTER(aBits);
699 *aBits = mPrintOptions;
700 return NS_OK;
701 }
702
703 /* attribute wstring docTitle; */
704 nsresult
705 nsPrintSettings::GetMarginStrs(char16_t * *aTitle,
706 nsHeaderFooterEnum aType,
707 int16_t aJust)
708 {
709 NS_ENSURE_ARG_POINTER(aTitle);
710 *aTitle = nullptr;
711 if (aType == eHeader) {
712 switch (aJust) {
713 case kJustLeft: *aTitle = ToNewUnicode(mHeaderStrs[0]);break;
714 case kJustCenter: *aTitle = ToNewUnicode(mHeaderStrs[1]);break;
715 case kJustRight: *aTitle = ToNewUnicode(mHeaderStrs[2]);break;
716 } //switch
717 } else {
718 switch (aJust) {
719 case kJustLeft: *aTitle = ToNewUnicode(mFooterStrs[0]);break;
720 case kJustCenter: *aTitle = ToNewUnicode(mFooterStrs[1]);break;
721 case kJustRight: *aTitle = ToNewUnicode(mFooterStrs[2]);break;
722 } //switch
723 }
724 return NS_OK;
725 }
726
727 nsresult
728 nsPrintSettings::SetMarginStrs(const char16_t * aTitle,
729 nsHeaderFooterEnum aType,
730 int16_t aJust)
731 {
732 NS_ENSURE_ARG_POINTER(aTitle);
733 if (aType == eHeader) {
734 switch (aJust) {
735 case kJustLeft: mHeaderStrs[0] = aTitle;break;
736 case kJustCenter: mHeaderStrs[1] = aTitle;break;
737 case kJustRight: mHeaderStrs[2] = aTitle;break;
738 } //switch
739 } else {
740 switch (aJust) {
741 case kJustLeft: mFooterStrs[0] = aTitle;break;
742 case kJustCenter: mFooterStrs[1] = aTitle;break;
743 case kJustRight: mFooterStrs[2] = aTitle;break;
744 } //switch
745 }
746 return NS_OK;
747 }
748
749 /* attribute wstring Header String Left */
750 NS_IMETHODIMP nsPrintSettings::GetHeaderStrLeft(char16_t * *aTitle)
751 {
752 return GetMarginStrs(aTitle, eHeader, kJustLeft);
753 }
754 NS_IMETHODIMP nsPrintSettings::SetHeaderStrLeft(const char16_t * aTitle)
755 {
756 return SetMarginStrs(aTitle, eHeader, kJustLeft);
757 }
758
759 /* attribute wstring Header String Center */
760 NS_IMETHODIMP nsPrintSettings::GetHeaderStrCenter(char16_t * *aTitle)
761 {
762 return GetMarginStrs(aTitle, eHeader, kJustCenter);
763 }
764 NS_IMETHODIMP nsPrintSettings::SetHeaderStrCenter(const char16_t * aTitle)
765 {
766 return SetMarginStrs(aTitle, eHeader, kJustCenter);
767 }
768
769 /* attribute wstring Header String Right */
770 NS_IMETHODIMP nsPrintSettings::GetHeaderStrRight(char16_t * *aTitle)
771 {
772 return GetMarginStrs(aTitle, eHeader, kJustRight);
773 }
774 NS_IMETHODIMP nsPrintSettings::SetHeaderStrRight(const char16_t * aTitle)
775 {
776 return SetMarginStrs(aTitle, eHeader, kJustRight);
777 }
778
779
780 /* attribute wstring Footer String Left */
781 NS_IMETHODIMP nsPrintSettings::GetFooterStrLeft(char16_t * *aTitle)
782 {
783 return GetMarginStrs(aTitle, eFooter, kJustLeft);
784 }
785 NS_IMETHODIMP nsPrintSettings::SetFooterStrLeft(const char16_t * aTitle)
786 {
787 return SetMarginStrs(aTitle, eFooter, kJustLeft);
788 }
789
790 /* attribute wstring Footer String Center */
791 NS_IMETHODIMP nsPrintSettings::GetFooterStrCenter(char16_t * *aTitle)
792 {
793 return GetMarginStrs(aTitle, eFooter, kJustCenter);
794 }
795 NS_IMETHODIMP nsPrintSettings::SetFooterStrCenter(const char16_t * aTitle)
796 {
797 return SetMarginStrs(aTitle, eFooter, kJustCenter);
798 }
799
800 /* attribute wstring Footer String Right */
801 NS_IMETHODIMP nsPrintSettings::GetFooterStrRight(char16_t * *aTitle)
802 {
803 return GetMarginStrs(aTitle, eFooter, kJustRight);
804 }
805 NS_IMETHODIMP nsPrintSettings::SetFooterStrRight(const char16_t * aTitle)
806 {
807 return SetMarginStrs(aTitle, eFooter, kJustRight);
808 }
809
810 /* attribute short printFrameTypeUsage; */
811 NS_IMETHODIMP nsPrintSettings::GetPrintFrameTypeUsage(int16_t *aPrintFrameTypeUsage)
812 {
813 NS_ENSURE_ARG_POINTER(aPrintFrameTypeUsage);
814 *aPrintFrameTypeUsage = mPrintFrameTypeUsage;
815 return NS_OK;
816 }
817 NS_IMETHODIMP nsPrintSettings::SetPrintFrameTypeUsage(int16_t aPrintFrameTypeUsage)
818 {
819 mPrintFrameTypeUsage = aPrintFrameTypeUsage;
820 return NS_OK;
821 }
822
823 /* attribute long printFrameType; */
824 NS_IMETHODIMP nsPrintSettings::GetPrintFrameType(int16_t *aPrintFrameType)
825 {
826 NS_ENSURE_ARG_POINTER(aPrintFrameType);
827 *aPrintFrameType = (int32_t)mPrintFrameType;
828 return NS_OK;
829 }
830 NS_IMETHODIMP nsPrintSettings::SetPrintFrameType(int16_t aPrintFrameType)
831 {
832 mPrintFrameType = aPrintFrameType;
833 return NS_OK;
834 }
835
836 /* attribute boolean printSilent; */
837 NS_IMETHODIMP nsPrintSettings::GetPrintSilent(bool *aPrintSilent)
838 {
839 NS_ENSURE_ARG_POINTER(aPrintSilent);
840 *aPrintSilent = mPrintSilent;
841 return NS_OK;
842 }
843 NS_IMETHODIMP nsPrintSettings::SetPrintSilent(bool aPrintSilent)
844 {
845 mPrintSilent = aPrintSilent;
846 return NS_OK;
847 }
848
849 /* attribute boolean shrinkToFit; */
850 NS_IMETHODIMP nsPrintSettings::GetShrinkToFit(bool *aShrinkToFit)
851 {
852 NS_ENSURE_ARG_POINTER(aShrinkToFit);
853 *aShrinkToFit = mShrinkToFit;
854 return NS_OK;
855 }
856 NS_IMETHODIMP nsPrintSettings::SetShrinkToFit(bool aShrinkToFit)
857 {
858 mShrinkToFit = aShrinkToFit;
859 return NS_OK;
860 }
861
862 /* attribute boolean showPrintProgress; */
863 NS_IMETHODIMP nsPrintSettings::GetShowPrintProgress(bool *aShowPrintProgress)
864 {
865 NS_ENSURE_ARG_POINTER(aShowPrintProgress);
866 *aShowPrintProgress = mShowPrintProgress;
867 return NS_OK;
868 }
869 NS_IMETHODIMP nsPrintSettings::SetShowPrintProgress(bool aShowPrintProgress)
870 {
871 mShowPrintProgress = aShowPrintProgress;
872 return NS_OK;
873 }
874
875 /* attribute wstring paperName; */
876 NS_IMETHODIMP nsPrintSettings::GetPaperName(char16_t * *aPaperName)
877 {
878 NS_ENSURE_ARG_POINTER(aPaperName);
879 if (!mPaperName.IsEmpty()) {
880 *aPaperName = ToNewUnicode(mPaperName);
881 } else {
882 *aPaperName = nullptr;
883 }
884 return NS_OK;
885 }
886 NS_IMETHODIMP nsPrintSettings::SetPaperName(const char16_t * aPaperName)
887 {
888 if (aPaperName) {
889 mPaperName = aPaperName;
890 } else {
891 mPaperName.SetLength(0);
892 }
893 return NS_OK;
894 }
895
896 /* attribute wstring plexName; */
897 NS_IMETHODIMP nsPrintSettings::GetPlexName(char16_t * *aPlexName)
898 {
899 NS_ENSURE_ARG_POINTER(aPlexName);
900 if (!mPlexName.IsEmpty()) {
901 *aPlexName = ToNewUnicode(mPlexName);
902 } else {
903 *aPlexName = nullptr;
904 }
905 return NS_OK;
906 }
907 NS_IMETHODIMP nsPrintSettings::SetPlexName(const char16_t * aPlexName)
908 {
909 if (aPlexName) {
910 mPlexName = aPlexName;
911 } else {
912 mPlexName.SetLength(0);
913 }
914 return NS_OK;
915 }
916
917 /* attribute boolean howToEnableFrameUI; */
918 NS_IMETHODIMP nsPrintSettings::GetHowToEnableFrameUI(int16_t *aHowToEnableFrameUI)
919 {
920 NS_ENSURE_ARG_POINTER(aHowToEnableFrameUI);
921 *aHowToEnableFrameUI = mHowToEnableFrameUI;
922 return NS_OK;
923 }
924 NS_IMETHODIMP nsPrintSettings::SetHowToEnableFrameUI(int16_t aHowToEnableFrameUI)
925 {
926 mHowToEnableFrameUI = aHowToEnableFrameUI;
927 return NS_OK;
928 }
929
930 /* attribute long isCancelled; */
931 NS_IMETHODIMP nsPrintSettings::GetIsCancelled(bool *aIsCancelled)
932 {
933 NS_ENSURE_ARG_POINTER(aIsCancelled);
934 *aIsCancelled = mIsCancelled;
935 return NS_OK;
936 }
937 NS_IMETHODIMP nsPrintSettings::SetIsCancelled(bool aIsCancelled)
938 {
939 mIsCancelled = aIsCancelled;
940 return NS_OK;
941 }
942
943 /* attribute double paperWidth; */
944 NS_IMETHODIMP nsPrintSettings::GetPaperWidth(double *aPaperWidth)
945 {
946 NS_ENSURE_ARG_POINTER(aPaperWidth);
947 *aPaperWidth = mPaperWidth;
948 return NS_OK;
949 }
950 NS_IMETHODIMP nsPrintSettings::SetPaperWidth(double aPaperWidth)
951 {
952 mPaperWidth = aPaperWidth;
953 return NS_OK;
954 }
955
956 /* attribute double paperHeight; */
957 NS_IMETHODIMP nsPrintSettings::GetPaperHeight(double *aPaperHeight)
958 {
959 NS_ENSURE_ARG_POINTER(aPaperHeight);
960 *aPaperHeight = mPaperHeight;
961 return NS_OK;
962 }
963 NS_IMETHODIMP nsPrintSettings::SetPaperHeight(double aPaperHeight)
964 {
965 mPaperHeight = aPaperHeight;
966 return NS_OK;
967 }
968
969 /* attribute short PaperSizeUnit; */
970 NS_IMETHODIMP nsPrintSettings::GetPaperSizeUnit(int16_t *aPaperSizeUnit)
971 {
972 NS_ENSURE_ARG_POINTER(aPaperSizeUnit);
973 *aPaperSizeUnit = mPaperSizeUnit;
974 return NS_OK;
975 }
976 NS_IMETHODIMP nsPrintSettings::SetPaperSizeUnit(int16_t aPaperSizeUnit)
977 {
978 mPaperSizeUnit = aPaperSizeUnit;
979 return NS_OK;
980 }
981
982 /* attribute short PaperSizeType; */
983 NS_IMETHODIMP nsPrintSettings::GetPaperSizeType(int16_t *aPaperSizeType)
984 {
985 NS_ENSURE_ARG_POINTER(aPaperSizeType);
986 *aPaperSizeType = mPaperSizeType;
987 return NS_OK;
988 }
989 NS_IMETHODIMP nsPrintSettings::SetPaperSizeType(int16_t aPaperSizeType)
990 {
991 mPaperSizeType = aPaperSizeType;
992 return NS_OK;
993 }
994
995 /* attribute short PaperData; */
996 NS_IMETHODIMP nsPrintSettings::GetPaperData(int16_t *aPaperData)
997 {
998 NS_ENSURE_ARG_POINTER(aPaperData);
999 *aPaperData = mPaperData;
1000 return NS_OK;
1001 }
1002 NS_IMETHODIMP nsPrintSettings::SetPaperData(int16_t aPaperData)
1003 {
1004 mPaperData = aPaperData;
1005 return NS_OK;
1006 }
1007
1008 /** ---------------------------------------------------
1009 * See documentation in nsPrintOptionsImpl.h
1010 * @update 6/21/00 dwc
1011 * @update 1/12/01 rods
1012 */
1013 NS_IMETHODIMP
1014 nsPrintSettings::SetMarginInTwips(nsIntMargin& aMargin)
1015 {
1016 mMargin = aMargin;
1017 return NS_OK;
1018 }
1019
1020 NS_IMETHODIMP
1021 nsPrintSettings::SetEdgeInTwips(nsIntMargin& aEdge)
1022 {
1023 mEdge = aEdge;
1024 return NS_OK;
1025 }
1026
1027 // NOTE: Any subclass implementation of this function should make sure
1028 // to check for negative margin values in aUnwriteableMargin (which
1029 // would indicate that we should use the system default unwriteable margin.)
1030 NS_IMETHODIMP
1031 nsPrintSettings::SetUnwriteableMarginInTwips(nsIntMargin& aUnwriteableMargin)
1032 {
1033 if (aUnwriteableMargin.top >= 0) {
1034 mUnwriteableMargin.top = aUnwriteableMargin.top;
1035 }
1036 if (aUnwriteableMargin.left >= 0) {
1037 mUnwriteableMargin.left = aUnwriteableMargin.left;
1038 }
1039 if (aUnwriteableMargin.bottom >= 0) {
1040 mUnwriteableMargin.bottom = aUnwriteableMargin.bottom;
1041 }
1042 if (aUnwriteableMargin.right >= 0) {
1043 mUnwriteableMargin.right = aUnwriteableMargin.right;
1044 }
1045 return NS_OK;
1046 }
1047
1048 /** ---------------------------------------------------
1049 * See documentation in nsPrintOptionsImpl.h
1050 * @update 6/21/00 dwc
1051 */
1052 NS_IMETHODIMP
1053 nsPrintSettings::GetMarginInTwips(nsIntMargin& aMargin)
1054 {
1055 aMargin = mMargin;
1056 return NS_OK;
1057 }
1058
1059 NS_IMETHODIMP
1060 nsPrintSettings::GetEdgeInTwips(nsIntMargin& aEdge)
1061 {
1062 aEdge = mEdge;
1063 return NS_OK;
1064 }
1065
1066 NS_IMETHODIMP
1067 nsPrintSettings::GetUnwriteableMarginInTwips(nsIntMargin& aUnwriteableMargin)
1068 {
1069 aUnwriteableMargin = mUnwriteableMargin;
1070 return NS_OK;
1071 }
1072
1073 /** ---------------------------------------------------
1074 * Stub - platform-specific implementations can use this function.
1075 */
1076 NS_IMETHODIMP
1077 nsPrintSettings::SetupSilentPrinting()
1078 {
1079 return NS_OK;
1080 }
1081
1082 /** ---------------------------------------------------
1083 * See documentation in nsPrintOptionsImpl.h
1084 */
1085 NS_IMETHODIMP
1086 nsPrintSettings::GetEffectivePageSize(double *aWidth, double *aHeight)
1087 {
1088 if (mPaperSizeUnit == kPaperSizeInches) {
1089 *aWidth = NS_INCHES_TO_TWIPS(float(mPaperWidth));
1090 *aHeight = NS_INCHES_TO_TWIPS(float(mPaperHeight));
1091 } else {
1092 *aWidth = NS_MILLIMETERS_TO_TWIPS(float(mPaperWidth));
1093 *aHeight = NS_MILLIMETERS_TO_TWIPS(float(mPaperHeight));
1094 }
1095 if (kLandscapeOrientation == mOrientation) {
1096 double temp = *aWidth;
1097 *aWidth = *aHeight;
1098 *aHeight = temp;
1099 }
1100 return NS_OK;
1101 }
1102
1103 NS_IMETHODIMP
1104 nsPrintSettings::GetPageRanges(nsTArray<int32_t> &aPages)
1105 {
1106 aPages.Clear();
1107 return NS_OK;
1108 }
1109
1110 nsresult
1111 nsPrintSettings::_Clone(nsIPrintSettings **_retval)
1112 {
1113 nsPrintSettings* printSettings = new nsPrintSettings(*this);
1114 return printSettings->QueryInterface(NS_GET_IID(nsIPrintSettings), (void**)_retval); // ref counts
1115 }
1116
1117 /* nsIPrintSettings clone (); */
1118 NS_IMETHODIMP
1119 nsPrintSettings::Clone(nsIPrintSettings **_retval)
1120 {
1121 NS_ENSURE_ARG_POINTER(_retval);
1122 return _Clone(_retval);
1123 }
1124
1125 /* void assign (in nsIPrintSettings aPS); */
1126 nsresult
1127 nsPrintSettings::_Assign(nsIPrintSettings *aPS)
1128 {
1129 nsPrintSettings *ps = static_cast<nsPrintSettings*>(aPS);
1130 *this = *ps;
1131 return NS_OK;
1132 }
1133
1134 /* void assign (in nsIPrintSettings aPS); */
1135 NS_IMETHODIMP
1136 nsPrintSettings::Assign(nsIPrintSettings *aPS)
1137 {
1138 NS_ENSURE_ARG(aPS);
1139 return _Assign(aPS);
1140 }
1141
1142 //-------------------------------------------
1143 nsPrintSettings& nsPrintSettings::operator=(const nsPrintSettings& rhs)
1144 {
1145 if (this == &rhs) {
1146 return *this;
1147 }
1148
1149 mStartPageNum = rhs.mStartPageNum;
1150 mEndPageNum = rhs.mEndPageNum;
1151 mMargin = rhs.mMargin;
1152 mEdge = rhs.mEdge;
1153 mUnwriteableMargin = rhs.mUnwriteableMargin;
1154 mScaling = rhs.mScaling;
1155 mPrintBGColors = rhs.mPrintBGColors;
1156 mPrintBGImages = rhs.mPrintBGImages;
1157 mPrintRange = rhs.mPrintRange;
1158 mTitle = rhs.mTitle;
1159 mURL = rhs.mURL;
1160 mHowToEnableFrameUI = rhs.mHowToEnableFrameUI;
1161 mIsCancelled = rhs.mIsCancelled;
1162 mPrintFrameTypeUsage = rhs.mPrintFrameTypeUsage;
1163 mPrintFrameType = rhs.mPrintFrameType;
1164 mPrintSilent = rhs.mPrintSilent;
1165 mShrinkToFit = rhs.mShrinkToFit;
1166 mShowPrintProgress = rhs.mShowPrintProgress;
1167 mPaperName = rhs.mPaperName;
1168 mPlexName = rhs.mPlexName;
1169 mPaperSizeType = rhs.mPaperSizeType;
1170 mPaperData = rhs.mPaperData;
1171 mPaperWidth = rhs.mPaperWidth;
1172 mPaperHeight = rhs.mPaperHeight;
1173 mPaperSizeUnit = rhs.mPaperSizeUnit;
1174 mPrintReversed = rhs.mPrintReversed;
1175 mPrintInColor = rhs.mPrintInColor;
1176 mOrientation = rhs.mOrientation;
1177 mPrintCommand = rhs.mPrintCommand;
1178 mNumCopies = rhs.mNumCopies;
1179 mPrinter = rhs.mPrinter;
1180 mPrintToFile = rhs.mPrintToFile;
1181 mToFileName = rhs.mToFileName;
1182 mOutputFormat = rhs.mOutputFormat;
1183 mPrintPageDelay = rhs.mPrintPageDelay;
1184
1185 for (int32_t i=0;i<NUM_HEAD_FOOT;i++) {
1186 mHeaderStrs[i] = rhs.mHeaderStrs[i];
1187 mFooterStrs[i] = rhs.mFooterStrs[i];
1188 }
1189
1190 return *this;
1191 }
1192

Mercurial Repository: The Tor Browser

Europalab SCM Repository Server

mercurial