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