diff options
Diffstat (limited to 'widget/nsPrintSettingsImpl.cpp')
| -rw-r--r-- | widget/nsPrintSettingsImpl.cpp | 1019 |
1 files changed, 1019 insertions, 0 deletions
diff --git a/widget/nsPrintSettingsImpl.cpp b/widget/nsPrintSettingsImpl.cpp new file mode 100644 index 000000000..48cce8625 --- /dev/null +++ b/widget/nsPrintSettingsImpl.cpp @@ -0,0 +1,1019 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#include "nsPrintSettingsImpl.h" +#include "nsReadableUtils.h" +#include "nsIPrintSession.h" +#include "mozilla/RefPtr.h" + +#define DEFAULT_MARGIN_WIDTH 0.5 + +NS_IMPL_ISUPPORTS(nsPrintSettings, nsIPrintSettings) + +/** --------------------------------------------------- + * See documentation in nsPrintSettingsImpl.h + * @update 6/21/00 dwc + */ +nsPrintSettings::nsPrintSettings() : + mPrintOptions(0L), + mPrintRange(kRangeAllPages), + mStartPageNum(1), + mEndPageNum(1), + mScaling(1.0), + mPrintBGColors(false), + mPrintBGImages(false), + mPrintFrameTypeUsage(kUseInternalDefault), + mPrintFrameType(kFramesAsIs), + mHowToEnableFrameUI(kFrameEnableNone), + mIsCancelled(false), + mPrintSilent(false), + mPrintPreview(false), + mShrinkToFit(true), + mShowPrintProgress(true), + mPrintPageDelay(50), + mPaperData(0), + mPaperWidth(8.5), + mPaperHeight(11.0), + mPaperSizeUnit(kPaperSizeInches), + mPrintReversed(false), + mPrintInColor(true), + mOrientation(kPortraitOrientation), + mNumCopies(1), + mPrintToFile(false), + mOutputFormat(kOutputFormatNative), + mIsInitedFromPrinter(false), + mIsInitedFromPrefs(false) +{ + + /* member initializers and constructor code */ + int32_t marginWidth = NS_INCHES_TO_INT_TWIPS(DEFAULT_MARGIN_WIDTH); + mMargin.SizeTo(marginWidth, marginWidth, marginWidth, marginWidth); + mEdge.SizeTo(0, 0, 0, 0); + mUnwriteableMargin.SizeTo(0,0,0,0); + + mPrintOptions = kPrintOddPages | kPrintEvenPages; + + mHeaderStrs[0].AssignLiteral("&T"); + mHeaderStrs[2].AssignLiteral("&U"); + + mFooterStrs[0].AssignLiteral("&PT"); // Use &P (Page Num Only) or &PT (Page Num of Page Total) + mFooterStrs[2].AssignLiteral("&D"); + +} + +/** --------------------------------------------------- + * See documentation in nsPrintSettingsImpl.h + * @update 6/21/00 dwc + */ +nsPrintSettings::nsPrintSettings(const nsPrintSettings& aPS) +{ + *this = aPS; +} + +/** --------------------------------------------------- + * See documentation in nsPrintSettingsImpl.h + * @update 6/21/00 dwc + */ +nsPrintSettings::~nsPrintSettings() +{ +} + +NS_IMETHODIMP nsPrintSettings::GetPrintSession(nsIPrintSession **aPrintSession) +{ + NS_ENSURE_ARG_POINTER(aPrintSession); + *aPrintSession = nullptr; + + nsCOMPtr<nsIPrintSession> session = do_QueryReferent(mSession); + if (!session) + return NS_ERROR_NOT_INITIALIZED; + *aPrintSession = session; + NS_ADDREF(*aPrintSession); + return NS_OK; +} +NS_IMETHODIMP nsPrintSettings::SetPrintSession(nsIPrintSession *aPrintSession) +{ + // Clearing it by passing nullptr is not allowed. That's why we + // use a weak ref so that it doesn't have to be cleared. + NS_ENSURE_ARG(aPrintSession); + + mSession = do_GetWeakReference(aPrintSession); + if (!mSession) { + // This may happen if the implementation of this object does + // not support weak references - programmer error. + NS_ERROR("Could not get a weak reference from aPrintSession"); + return NS_ERROR_FAILURE; + } + return NS_OK; +} + +NS_IMETHODIMP nsPrintSettings::GetStartPageRange(int32_t *aStartPageRange) +{ + //NS_ENSURE_ARG_POINTER(aStartPageRange); + *aStartPageRange = mStartPageNum; + return NS_OK; +} +NS_IMETHODIMP nsPrintSettings::SetStartPageRange(int32_t aStartPageRange) +{ + mStartPageNum = aStartPageRange; + return NS_OK; +} + +NS_IMETHODIMP nsPrintSettings::GetEndPageRange(int32_t *aEndPageRange) +{ + //NS_ENSURE_ARG_POINTER(aEndPageRange); + *aEndPageRange = mEndPageNum; + return NS_OK; +} +NS_IMETHODIMP nsPrintSettings::SetEndPageRange(int32_t aEndPageRange) +{ + mEndPageNum = aEndPageRange; + return NS_OK; +} + +NS_IMETHODIMP nsPrintSettings::GetPrintReversed(bool *aPrintReversed) +{ + //NS_ENSURE_ARG_POINTER(aPrintReversed); + *aPrintReversed = mPrintReversed; + return NS_OK; +} +NS_IMETHODIMP nsPrintSettings::SetPrintReversed(bool aPrintReversed) +{ + mPrintReversed = aPrintReversed; + return NS_OK; +} + +NS_IMETHODIMP nsPrintSettings::GetPrintInColor(bool *aPrintInColor) +{ + //NS_ENSURE_ARG_POINTER(aPrintInColor); + *aPrintInColor = mPrintInColor; + return NS_OK; +} +NS_IMETHODIMP nsPrintSettings::SetPrintInColor(bool aPrintInColor) +{ + mPrintInColor = aPrintInColor; + return NS_OK; +} + +NS_IMETHODIMP nsPrintSettings::GetOrientation(int32_t *aOrientation) +{ + NS_ENSURE_ARG_POINTER(aOrientation); + *aOrientation = mOrientation; + return NS_OK; +} +NS_IMETHODIMP nsPrintSettings::SetOrientation(int32_t aOrientation) +{ + mOrientation = aOrientation; + return NS_OK; +} + +NS_IMETHODIMP nsPrintSettings::GetResolution(int32_t *aResolution) +{ + NS_ENSURE_ARG_POINTER(aResolution); + *aResolution = mResolution; + return NS_OK; +} +NS_IMETHODIMP nsPrintSettings::SetResolution(const int32_t aResolution) +{ + mResolution = aResolution; + return NS_OK; +} + +NS_IMETHODIMP nsPrintSettings::GetDuplex(int32_t *aDuplex) +{ + NS_ENSURE_ARG_POINTER(aDuplex); + *aDuplex = mDuplex; + return NS_OK; +} +NS_IMETHODIMP nsPrintSettings::SetDuplex(const int32_t aDuplex) +{ + mDuplex = aDuplex; + return NS_OK; +} + +NS_IMETHODIMP nsPrintSettings::GetPrinterName(char16_t * *aPrinter) +{ + NS_ENSURE_ARG_POINTER(aPrinter); + + *aPrinter = ToNewUnicode(mPrinter); + NS_ENSURE_TRUE(*aPrinter, NS_ERROR_OUT_OF_MEMORY); + + return NS_OK; +} + +NS_IMETHODIMP nsPrintSettings::SetPrinterName(const char16_t * aPrinter) +{ + if (!aPrinter || !mPrinter.Equals(aPrinter)) { + mIsInitedFromPrinter = false; + mIsInitedFromPrefs = false; + } + + mPrinter.Assign(aPrinter); + return NS_OK; +} + +NS_IMETHODIMP nsPrintSettings::GetNumCopies(int32_t *aNumCopies) +{ + NS_ENSURE_ARG_POINTER(aNumCopies); + *aNumCopies = mNumCopies; + return NS_OK; +} +NS_IMETHODIMP nsPrintSettings::SetNumCopies(int32_t aNumCopies) +{ + mNumCopies = aNumCopies; + return NS_OK; +} + +NS_IMETHODIMP nsPrintSettings::GetPrintToFile(bool *aPrintToFile) +{ + //NS_ENSURE_ARG_POINTER(aPrintToFile); + *aPrintToFile = mPrintToFile; + return NS_OK; +} +NS_IMETHODIMP nsPrintSettings::SetPrintToFile(bool aPrintToFile) +{ + mPrintToFile = aPrintToFile; + return NS_OK; +} + +NS_IMETHODIMP nsPrintSettings::GetToFileName(char16_t * *aToFileName) +{ + //NS_ENSURE_ARG_POINTER(aToFileName); + *aToFileName = ToNewUnicode(mToFileName); + return NS_OK; +} +NS_IMETHODIMP nsPrintSettings::SetToFileName(const char16_t * aToFileName) +{ + if (aToFileName) { + mToFileName = aToFileName; + } else { + mToFileName.SetLength(0); + } + return NS_OK; +} + +NS_IMETHODIMP nsPrintSettings::GetOutputFormat(int16_t *aOutputFormat) +{ + NS_ENSURE_ARG_POINTER(aOutputFormat); + *aOutputFormat = mOutputFormat; + return NS_OK; +} +NS_IMETHODIMP nsPrintSettings::SetOutputFormat(int16_t aOutputFormat) +{ + mOutputFormat = aOutputFormat; + return NS_OK; +} + +NS_IMETHODIMP nsPrintSettings::GetPrintPageDelay(int32_t *aPrintPageDelay) +{ + *aPrintPageDelay = mPrintPageDelay; + return NS_OK; +} +NS_IMETHODIMP nsPrintSettings::SetPrintPageDelay(int32_t aPrintPageDelay) +{ + mPrintPageDelay = aPrintPageDelay; + return NS_OK; +} + +NS_IMETHODIMP nsPrintSettings::GetIsInitializedFromPrinter(bool *aIsInitializedFromPrinter) +{ + NS_ENSURE_ARG_POINTER(aIsInitializedFromPrinter); + *aIsInitializedFromPrinter = (bool)mIsInitedFromPrinter; + return NS_OK; +} +NS_IMETHODIMP nsPrintSettings::SetIsInitializedFromPrinter(bool aIsInitializedFromPrinter) +{ + mIsInitedFromPrinter = (bool)aIsInitializedFromPrinter; + return NS_OK; +} + +NS_IMETHODIMP nsPrintSettings::GetIsInitializedFromPrefs(bool *aInitializedFromPrefs) +{ + NS_ENSURE_ARG_POINTER(aInitializedFromPrefs); + *aInitializedFromPrefs = (bool)mIsInitedFromPrefs; + return NS_OK; +} +NS_IMETHODIMP nsPrintSettings::SetIsInitializedFromPrefs(bool aInitializedFromPrefs) +{ + mIsInitedFromPrefs = (bool)aInitializedFromPrefs; + return NS_OK; +} + +NS_IMETHODIMP nsPrintSettings::GetMarginTop(double *aMarginTop) +{ + NS_ENSURE_ARG_POINTER(aMarginTop); + *aMarginTop = NS_TWIPS_TO_INCHES(mMargin.top); + return NS_OK; +} +NS_IMETHODIMP nsPrintSettings::SetMarginTop(double aMarginTop) +{ + mMargin.top = NS_INCHES_TO_INT_TWIPS(float(aMarginTop)); + return NS_OK; +} + +NS_IMETHODIMP nsPrintSettings::GetMarginLeft(double *aMarginLeft) +{ + NS_ENSURE_ARG_POINTER(aMarginLeft); + *aMarginLeft = NS_TWIPS_TO_INCHES(mMargin.left); + return NS_OK; +} +NS_IMETHODIMP nsPrintSettings::SetMarginLeft(double aMarginLeft) +{ + mMargin.left = NS_INCHES_TO_INT_TWIPS(float(aMarginLeft)); + return NS_OK; +} + +NS_IMETHODIMP nsPrintSettings::GetMarginBottom(double *aMarginBottom) +{ + NS_ENSURE_ARG_POINTER(aMarginBottom); + *aMarginBottom = NS_TWIPS_TO_INCHES(mMargin.bottom); + return NS_OK; +} +NS_IMETHODIMP nsPrintSettings::SetMarginBottom(double aMarginBottom) +{ + mMargin.bottom = NS_INCHES_TO_INT_TWIPS(float(aMarginBottom)); + return NS_OK; +} + +NS_IMETHODIMP nsPrintSettings::GetMarginRight(double *aMarginRight) +{ + NS_ENSURE_ARG_POINTER(aMarginRight); + *aMarginRight = NS_TWIPS_TO_INCHES(mMargin.right); + return NS_OK; +} +NS_IMETHODIMP nsPrintSettings::SetMarginRight(double aMarginRight) +{ + mMargin.right = NS_INCHES_TO_INT_TWIPS(float(aMarginRight)); + return NS_OK; +} + +NS_IMETHODIMP nsPrintSettings::GetEdgeTop(double *aEdgeTop) +{ + NS_ENSURE_ARG_POINTER(aEdgeTop); + *aEdgeTop = NS_TWIPS_TO_INCHES(mEdge.top); + return NS_OK; +} +NS_IMETHODIMP nsPrintSettings::SetEdgeTop(double aEdgeTop) +{ + mEdge.top = NS_INCHES_TO_INT_TWIPS(float(aEdgeTop)); + return NS_OK; +} + +NS_IMETHODIMP nsPrintSettings::GetEdgeLeft(double *aEdgeLeft) +{ + NS_ENSURE_ARG_POINTER(aEdgeLeft); + *aEdgeLeft = NS_TWIPS_TO_INCHES(mEdge.left); + return NS_OK; +} +NS_IMETHODIMP nsPrintSettings::SetEdgeLeft(double aEdgeLeft) +{ + mEdge.left = NS_INCHES_TO_INT_TWIPS(float(aEdgeLeft)); + return NS_OK; +} + +NS_IMETHODIMP nsPrintSettings::GetEdgeBottom(double *aEdgeBottom) +{ + NS_ENSURE_ARG_POINTER(aEdgeBottom); + *aEdgeBottom = NS_TWIPS_TO_INCHES(mEdge.bottom); + return NS_OK; +} +NS_IMETHODIMP nsPrintSettings::SetEdgeBottom(double aEdgeBottom) +{ + mEdge.bottom = NS_INCHES_TO_INT_TWIPS(float(aEdgeBottom)); + return NS_OK; +} + +NS_IMETHODIMP nsPrintSettings::GetEdgeRight(double *aEdgeRight) +{ + NS_ENSURE_ARG_POINTER(aEdgeRight); + *aEdgeRight = NS_TWIPS_TO_INCHES(mEdge.right); + return NS_OK; +} +NS_IMETHODIMP nsPrintSettings::SetEdgeRight(double aEdgeRight) +{ + mEdge.right = NS_INCHES_TO_INT_TWIPS(float(aEdgeRight)); + return NS_OK; +} + +NS_IMETHODIMP nsPrintSettings::GetUnwriteableMarginTop(double *aUnwriteableMarginTop) +{ + NS_ENSURE_ARG_POINTER(aUnwriteableMarginTop); + *aUnwriteableMarginTop = NS_TWIPS_TO_INCHES(mUnwriteableMargin.top); + return NS_OK; +} +NS_IMETHODIMP nsPrintSettings::SetUnwriteableMarginTop(double aUnwriteableMarginTop) +{ + if (aUnwriteableMarginTop >= 0.0) { + mUnwriteableMargin.top = NS_INCHES_TO_INT_TWIPS(aUnwriteableMarginTop); + } + return NS_OK; +} + +NS_IMETHODIMP nsPrintSettings::GetUnwriteableMarginLeft(double *aUnwriteableMarginLeft) +{ + NS_ENSURE_ARG_POINTER(aUnwriteableMarginLeft); + *aUnwriteableMarginLeft = NS_TWIPS_TO_INCHES(mUnwriteableMargin.left); + return NS_OK; +} +NS_IMETHODIMP nsPrintSettings::SetUnwriteableMarginLeft(double aUnwriteableMarginLeft) +{ + if (aUnwriteableMarginLeft >= 0.0) { + mUnwriteableMargin.left = NS_INCHES_TO_INT_TWIPS(aUnwriteableMarginLeft); + } + return NS_OK; +} + +NS_IMETHODIMP nsPrintSettings::GetUnwriteableMarginBottom(double *aUnwriteableMarginBottom) +{ + NS_ENSURE_ARG_POINTER(aUnwriteableMarginBottom); + *aUnwriteableMarginBottom = NS_TWIPS_TO_INCHES(mUnwriteableMargin.bottom); + return NS_OK; +} +NS_IMETHODIMP nsPrintSettings::SetUnwriteableMarginBottom(double aUnwriteableMarginBottom) +{ + if (aUnwriteableMarginBottom >= 0.0) { + mUnwriteableMargin.bottom = NS_INCHES_TO_INT_TWIPS(aUnwriteableMarginBottom); + } + return NS_OK; +} + +NS_IMETHODIMP nsPrintSettings::GetUnwriteableMarginRight(double *aUnwriteableMarginRight) +{ + NS_ENSURE_ARG_POINTER(aUnwriteableMarginRight); + *aUnwriteableMarginRight = NS_TWIPS_TO_INCHES(mUnwriteableMargin.right); + return NS_OK; +} +NS_IMETHODIMP nsPrintSettings::SetUnwriteableMarginRight(double aUnwriteableMarginRight) +{ + if (aUnwriteableMarginRight >= 0.0) { + mUnwriteableMargin.right = NS_INCHES_TO_INT_TWIPS(aUnwriteableMarginRight); + } + return NS_OK; +} + +NS_IMETHODIMP nsPrintSettings::GetScaling(double *aScaling) +{ + NS_ENSURE_ARG_POINTER(aScaling); + *aScaling = mScaling; + return NS_OK; +} + +NS_IMETHODIMP nsPrintSettings::SetScaling(double aScaling) +{ + mScaling = aScaling; + return NS_OK; +} + +NS_IMETHODIMP nsPrintSettings::GetPrintBGColors(bool *aPrintBGColors) +{ + NS_ENSURE_ARG_POINTER(aPrintBGColors); + *aPrintBGColors = mPrintBGColors; + return NS_OK; +} +NS_IMETHODIMP nsPrintSettings::SetPrintBGColors(bool aPrintBGColors) +{ + mPrintBGColors = aPrintBGColors; + return NS_OK; +} + +NS_IMETHODIMP nsPrintSettings::GetPrintBGImages(bool *aPrintBGImages) +{ + NS_ENSURE_ARG_POINTER(aPrintBGImages); + *aPrintBGImages = mPrintBGImages; + return NS_OK; +} +NS_IMETHODIMP nsPrintSettings::SetPrintBGImages(bool aPrintBGImages) +{ + mPrintBGImages = aPrintBGImages; + return NS_OK; +} + +NS_IMETHODIMP nsPrintSettings::GetPrintRange(int16_t *aPrintRange) +{ + NS_ENSURE_ARG_POINTER(aPrintRange); + *aPrintRange = mPrintRange; + return NS_OK; +} +NS_IMETHODIMP nsPrintSettings::SetPrintRange(int16_t aPrintRange) +{ + mPrintRange = aPrintRange; + return NS_OK; +} + +NS_IMETHODIMP nsPrintSettings::GetTitle(char16_t * *aTitle) +{ + NS_ENSURE_ARG_POINTER(aTitle); + if (!mTitle.IsEmpty()) { + *aTitle = ToNewUnicode(mTitle); + } else { + *aTitle = nullptr; + } + return NS_OK; +} +NS_IMETHODIMP nsPrintSettings::SetTitle(const char16_t * aTitle) +{ + if (aTitle) { + mTitle = aTitle; + } else { + mTitle.SetLength(0); + } + return NS_OK; +} + +NS_IMETHODIMP nsPrintSettings::GetDocURL(char16_t * *aDocURL) +{ + NS_ENSURE_ARG_POINTER(aDocURL); + if (!mURL.IsEmpty()) { + *aDocURL = ToNewUnicode(mURL); + } else { + *aDocURL = nullptr; + } + return NS_OK; +} +NS_IMETHODIMP nsPrintSettings::SetDocURL(const char16_t * aDocURL) +{ + if (aDocURL) { + mURL = aDocURL; + } else { + mURL.SetLength(0); + } + return NS_OK; +} + +/** --------------------------------------------------- + * See documentation in nsPrintSettingsImpl.h + * @update 1/12/01 rods + */ +NS_IMETHODIMP +nsPrintSettings::GetPrintOptions(int32_t aType, bool *aTurnOnOff) +{ + NS_ENSURE_ARG_POINTER(aTurnOnOff); + *aTurnOnOff = mPrintOptions & aType ? true : false; + return NS_OK; +} +/** --------------------------------------------------- + * See documentation in nsPrintSettingsImpl.h + * @update 1/12/01 rods + */ +NS_IMETHODIMP +nsPrintSettings::SetPrintOptions(int32_t aType, bool aTurnOnOff) +{ + if (aTurnOnOff) { + mPrintOptions |= aType; + } else { + mPrintOptions &= ~aType; + } + return NS_OK; +} + +/** --------------------------------------------------- + * See documentation in nsPrintSettingsImpl.h + * @update 1/12/01 rods + */ +NS_IMETHODIMP +nsPrintSettings::GetPrintOptionsBits(int32_t *aBits) +{ + NS_ENSURE_ARG_POINTER(aBits); + *aBits = mPrintOptions; + return NS_OK; +} + +NS_IMETHODIMP +nsPrintSettings::SetPrintOptionsBits(int32_t aBits) +{ + mPrintOptions = aBits; + return NS_OK; +} + +nsresult +nsPrintSettings::GetMarginStrs(char16_t * *aTitle, + nsHeaderFooterEnum aType, + int16_t aJust) +{ + NS_ENSURE_ARG_POINTER(aTitle); + *aTitle = nullptr; + if (aType == eHeader) { + switch (aJust) { + case kJustLeft: *aTitle = ToNewUnicode(mHeaderStrs[0]);break; + case kJustCenter: *aTitle = ToNewUnicode(mHeaderStrs[1]);break; + case kJustRight: *aTitle = ToNewUnicode(mHeaderStrs[2]);break; + } //switch + } else { + switch (aJust) { + case kJustLeft: *aTitle = ToNewUnicode(mFooterStrs[0]);break; + case kJustCenter: *aTitle = ToNewUnicode(mFooterStrs[1]);break; + case kJustRight: *aTitle = ToNewUnicode(mFooterStrs[2]);break; + } //switch + } + return NS_OK; +} + +nsresult +nsPrintSettings::SetMarginStrs(const char16_t * aTitle, + nsHeaderFooterEnum aType, + int16_t aJust) +{ + NS_ENSURE_ARG_POINTER(aTitle); + if (aType == eHeader) { + switch (aJust) { + case kJustLeft: mHeaderStrs[0] = aTitle;break; + case kJustCenter: mHeaderStrs[1] = aTitle;break; + case kJustRight: mHeaderStrs[2] = aTitle;break; + } //switch + } else { + switch (aJust) { + case kJustLeft: mFooterStrs[0] = aTitle;break; + case kJustCenter: mFooterStrs[1] = aTitle;break; + case kJustRight: mFooterStrs[2] = aTitle;break; + } //switch + } + return NS_OK; +} + +NS_IMETHODIMP nsPrintSettings::GetHeaderStrLeft(char16_t * *aTitle) +{ + return GetMarginStrs(aTitle, eHeader, kJustLeft); +} +NS_IMETHODIMP nsPrintSettings::SetHeaderStrLeft(const char16_t * aTitle) +{ + return SetMarginStrs(aTitle, eHeader, kJustLeft); +} + +NS_IMETHODIMP nsPrintSettings::GetHeaderStrCenter(char16_t * *aTitle) +{ + return GetMarginStrs(aTitle, eHeader, kJustCenter); +} +NS_IMETHODIMP nsPrintSettings::SetHeaderStrCenter(const char16_t * aTitle) +{ + return SetMarginStrs(aTitle, eHeader, kJustCenter); +} + +NS_IMETHODIMP nsPrintSettings::GetHeaderStrRight(char16_t * *aTitle) +{ + return GetMarginStrs(aTitle, eHeader, kJustRight); +} +NS_IMETHODIMP nsPrintSettings::SetHeaderStrRight(const char16_t * aTitle) +{ + return SetMarginStrs(aTitle, eHeader, kJustRight); +} + +NS_IMETHODIMP nsPrintSettings::GetFooterStrLeft(char16_t * *aTitle) +{ + return GetMarginStrs(aTitle, eFooter, kJustLeft); +} +NS_IMETHODIMP nsPrintSettings::SetFooterStrLeft(const char16_t * aTitle) +{ + return SetMarginStrs(aTitle, eFooter, kJustLeft); +} + +NS_IMETHODIMP nsPrintSettings::GetFooterStrCenter(char16_t * *aTitle) +{ + return GetMarginStrs(aTitle, eFooter, kJustCenter); +} +NS_IMETHODIMP nsPrintSettings::SetFooterStrCenter(const char16_t * aTitle) +{ + return SetMarginStrs(aTitle, eFooter, kJustCenter); +} + +NS_IMETHODIMP nsPrintSettings::GetFooterStrRight(char16_t * *aTitle) +{ + return GetMarginStrs(aTitle, eFooter, kJustRight); +} +NS_IMETHODIMP nsPrintSettings::SetFooterStrRight(const char16_t * aTitle) +{ + return SetMarginStrs(aTitle, eFooter, kJustRight); +} + +NS_IMETHODIMP nsPrintSettings::GetPrintFrameTypeUsage(int16_t *aPrintFrameTypeUsage) +{ + NS_ENSURE_ARG_POINTER(aPrintFrameTypeUsage); + *aPrintFrameTypeUsage = mPrintFrameTypeUsage; + return NS_OK; +} +NS_IMETHODIMP nsPrintSettings::SetPrintFrameTypeUsage(int16_t aPrintFrameTypeUsage) +{ + mPrintFrameTypeUsage = aPrintFrameTypeUsage; + return NS_OK; +} + +NS_IMETHODIMP nsPrintSettings::GetPrintFrameType(int16_t *aPrintFrameType) +{ + NS_ENSURE_ARG_POINTER(aPrintFrameType); + *aPrintFrameType = (int32_t)mPrintFrameType; + return NS_OK; +} +NS_IMETHODIMP nsPrintSettings::SetPrintFrameType(int16_t aPrintFrameType) +{ + mPrintFrameType = aPrintFrameType; + return NS_OK; +} + +NS_IMETHODIMP nsPrintSettings::GetPrintSilent(bool *aPrintSilent) +{ + NS_ENSURE_ARG_POINTER(aPrintSilent); + *aPrintSilent = mPrintSilent; + return NS_OK; +} +NS_IMETHODIMP nsPrintSettings::SetPrintSilent(bool aPrintSilent) +{ + mPrintSilent = aPrintSilent; + return NS_OK; +} + +NS_IMETHODIMP nsPrintSettings::GetShrinkToFit(bool *aShrinkToFit) +{ + NS_ENSURE_ARG_POINTER(aShrinkToFit); + *aShrinkToFit = mShrinkToFit; + return NS_OK; +} +NS_IMETHODIMP nsPrintSettings::SetShrinkToFit(bool aShrinkToFit) +{ + mShrinkToFit = aShrinkToFit; + return NS_OK; +} + +NS_IMETHODIMP nsPrintSettings::GetShowPrintProgress(bool *aShowPrintProgress) +{ + NS_ENSURE_ARG_POINTER(aShowPrintProgress); + *aShowPrintProgress = mShowPrintProgress; + return NS_OK; +} +NS_IMETHODIMP nsPrintSettings::SetShowPrintProgress(bool aShowPrintProgress) +{ + mShowPrintProgress = aShowPrintProgress; + return NS_OK; +} + +NS_IMETHODIMP nsPrintSettings::GetPaperName(char16_t * *aPaperName) +{ + NS_ENSURE_ARG_POINTER(aPaperName); + if (!mPaperName.IsEmpty()) { + *aPaperName = ToNewUnicode(mPaperName); + } else { + *aPaperName = nullptr; + } + return NS_OK; +} +NS_IMETHODIMP nsPrintSettings::SetPaperName(const char16_t * aPaperName) +{ + if (aPaperName) { + mPaperName = aPaperName; + } else { + mPaperName.SetLength(0); + } + return NS_OK; +} + +NS_IMETHODIMP nsPrintSettings::GetHowToEnableFrameUI(int16_t *aHowToEnableFrameUI) +{ + NS_ENSURE_ARG_POINTER(aHowToEnableFrameUI); + *aHowToEnableFrameUI = mHowToEnableFrameUI; + return NS_OK; +} +NS_IMETHODIMP nsPrintSettings::SetHowToEnableFrameUI(int16_t aHowToEnableFrameUI) +{ + mHowToEnableFrameUI = aHowToEnableFrameUI; + return NS_OK; +} + +NS_IMETHODIMP nsPrintSettings::GetIsCancelled(bool *aIsCancelled) +{ + NS_ENSURE_ARG_POINTER(aIsCancelled); + *aIsCancelled = mIsCancelled; + return NS_OK; +} +NS_IMETHODIMP nsPrintSettings::SetIsCancelled(bool aIsCancelled) +{ + mIsCancelled = aIsCancelled; + return NS_OK; +} + +NS_IMETHODIMP nsPrintSettings::GetPaperWidth(double *aPaperWidth) +{ + NS_ENSURE_ARG_POINTER(aPaperWidth); + *aPaperWidth = mPaperWidth; + return NS_OK; +} +NS_IMETHODIMP nsPrintSettings::SetPaperWidth(double aPaperWidth) +{ + mPaperWidth = aPaperWidth; + return NS_OK; +} + +NS_IMETHODIMP nsPrintSettings::GetPaperHeight(double *aPaperHeight) +{ + NS_ENSURE_ARG_POINTER(aPaperHeight); + *aPaperHeight = mPaperHeight; + return NS_OK; +} +NS_IMETHODIMP nsPrintSettings::SetPaperHeight(double aPaperHeight) +{ + mPaperHeight = aPaperHeight; + return NS_OK; +} + +NS_IMETHODIMP nsPrintSettings::GetPaperSizeUnit(int16_t *aPaperSizeUnit) +{ + NS_ENSURE_ARG_POINTER(aPaperSizeUnit); + *aPaperSizeUnit = mPaperSizeUnit; + return NS_OK; +} +NS_IMETHODIMP nsPrintSettings::SetPaperSizeUnit(int16_t aPaperSizeUnit) +{ + mPaperSizeUnit = aPaperSizeUnit; + return NS_OK; +} + +NS_IMETHODIMP nsPrintSettings::GetPaperData(int16_t *aPaperData) +{ + NS_ENSURE_ARG_POINTER(aPaperData); + *aPaperData = mPaperData; + return NS_OK; +} +NS_IMETHODIMP nsPrintSettings::SetPaperData(int16_t aPaperData) +{ + mPaperData = aPaperData; + return NS_OK; +} + +/** --------------------------------------------------- + * See documentation in nsPrintOptionsImpl.h + * @update 6/21/00 dwc + * @update 1/12/01 rods + */ +NS_IMETHODIMP +nsPrintSettings::SetMarginInTwips(nsIntMargin& aMargin) +{ + mMargin = aMargin; + return NS_OK; +} + +NS_IMETHODIMP +nsPrintSettings::SetEdgeInTwips(nsIntMargin& aEdge) +{ + mEdge = aEdge; + return NS_OK; +} + +// NOTE: Any subclass implementation of this function should make sure +// to check for negative margin values in aUnwriteableMargin (which +// would indicate that we should use the system default unwriteable margin.) +NS_IMETHODIMP +nsPrintSettings::SetUnwriteableMarginInTwips(nsIntMargin& aUnwriteableMargin) +{ + if (aUnwriteableMargin.top >= 0) { + mUnwriteableMargin.top = aUnwriteableMargin.top; + } + if (aUnwriteableMargin.left >= 0) { + mUnwriteableMargin.left = aUnwriteableMargin.left; + } + if (aUnwriteableMargin.bottom >= 0) { + mUnwriteableMargin.bottom = aUnwriteableMargin.bottom; + } + if (aUnwriteableMargin.right >= 0) { + mUnwriteableMargin.right = aUnwriteableMargin.right; + } + return NS_OK; +} + +/** --------------------------------------------------- + * See documentation in nsPrintOptionsImpl.h + * @update 6/21/00 dwc + */ +NS_IMETHODIMP +nsPrintSettings::GetMarginInTwips(nsIntMargin& aMargin) +{ + aMargin = mMargin; + return NS_OK; +} + +NS_IMETHODIMP +nsPrintSettings::GetEdgeInTwips(nsIntMargin& aEdge) +{ + aEdge = mEdge; + return NS_OK; +} + +NS_IMETHODIMP +nsPrintSettings::GetUnwriteableMarginInTwips(nsIntMargin& aUnwriteableMargin) +{ + aUnwriteableMargin = mUnwriteableMargin; + return NS_OK; +} + +/** --------------------------------------------------- + * Stub - platform-specific implementations can use this function. + */ +NS_IMETHODIMP +nsPrintSettings::SetupSilentPrinting() +{ + return NS_OK; +} + +/** --------------------------------------------------- + * See documentation in nsPrintOptionsImpl.h + */ +NS_IMETHODIMP +nsPrintSettings::GetEffectivePageSize(double *aWidth, double *aHeight) +{ + if (mPaperSizeUnit == kPaperSizeInches) { + *aWidth = NS_INCHES_TO_TWIPS(float(mPaperWidth)); + *aHeight = NS_INCHES_TO_TWIPS(float(mPaperHeight)); + } else { + *aWidth = NS_MILLIMETERS_TO_TWIPS(float(mPaperWidth)); + *aHeight = NS_MILLIMETERS_TO_TWIPS(float(mPaperHeight)); + } + if (kLandscapeOrientation == mOrientation) { + double temp = *aWidth; + *aWidth = *aHeight; + *aHeight = temp; + } + return NS_OK; +} + +NS_IMETHODIMP +nsPrintSettings::GetPageRanges(nsTArray<int32_t> &aPages) +{ + aPages.Clear(); + return NS_OK; +} + +nsresult +nsPrintSettings::_Clone(nsIPrintSettings **_retval) +{ + RefPtr<nsPrintSettings> printSettings = new nsPrintSettings(*this); + printSettings.forget(_retval); + return NS_OK; +} + +NS_IMETHODIMP +nsPrintSettings::Clone(nsIPrintSettings **_retval) +{ + NS_ENSURE_ARG_POINTER(_retval); + return _Clone(_retval); +} + +nsresult +nsPrintSettings::_Assign(nsIPrintSettings *aPS) +{ + nsPrintSettings *ps = static_cast<nsPrintSettings*>(aPS); + *this = *ps; + return NS_OK; +} + +NS_IMETHODIMP +nsPrintSettings::Assign(nsIPrintSettings *aPS) +{ + NS_ENSURE_ARG(aPS); + return _Assign(aPS); +} + +//------------------------------------------- +nsPrintSettings& nsPrintSettings::operator=(const nsPrintSettings& rhs) +{ + if (this == &rhs) { + return *this; + } + + mStartPageNum = rhs.mStartPageNum; + mEndPageNum = rhs.mEndPageNum; + mMargin = rhs.mMargin; + mEdge = rhs.mEdge; + mUnwriteableMargin = rhs.mUnwriteableMargin; + mScaling = rhs.mScaling; + mPrintBGColors = rhs.mPrintBGColors; + mPrintBGImages = rhs.mPrintBGImages; + mPrintRange = rhs.mPrintRange; + mTitle = rhs.mTitle; + mURL = rhs.mURL; + mHowToEnableFrameUI = rhs.mHowToEnableFrameUI; + mIsCancelled = rhs.mIsCancelled; + mPrintFrameTypeUsage = rhs.mPrintFrameTypeUsage; + mPrintFrameType = rhs.mPrintFrameType; + mPrintSilent = rhs.mPrintSilent; + mShrinkToFit = rhs.mShrinkToFit; + mShowPrintProgress = rhs.mShowPrintProgress; + mPaperName = rhs.mPaperName; + mPaperData = rhs.mPaperData; + mPaperWidth = rhs.mPaperWidth; + mPaperHeight = rhs.mPaperHeight; + mPaperSizeUnit = rhs.mPaperSizeUnit; + mPrintReversed = rhs.mPrintReversed; + mPrintInColor = rhs.mPrintInColor; + mOrientation = rhs.mOrientation; + mNumCopies = rhs.mNumCopies; + mPrinter = rhs.mPrinter; + mPrintToFile = rhs.mPrintToFile; + mToFileName = rhs.mToFileName; + mOutputFormat = rhs.mOutputFormat; + mPrintPageDelay = rhs.mPrintPageDelay; + + for (int32_t i=0;i<NUM_HEAD_FOOT;i++) { + mHeaderStrs[i] = rhs.mHeaderStrs[i]; + mFooterStrs[i] = rhs.mFooterStrs[i]; + } + + return *this; +} + |