cbdc900617
Send the size from PMGetAdjustedPaperRect to the child to use as the page size. Add an Mac implementation of GetEffectivePageSize that returns the adjusted dimensions. Add an Mac implementation of SetPaperWidth and SetPaperHeight so that adjusted dimensions can be manually set for reftest-print. MozReview-Commit-ID: GgTFgBzkxTy
350 lines
13 KiB
Plaintext
350 lines
13 KiB
Plaintext
/* -*- Mode: C++; tab-width: 2; 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 "nsCOMPtr.h"
|
|
#include "nsQueryObject.h"
|
|
#include "nsIServiceManager.h"
|
|
#include "nsPrintOptionsX.h"
|
|
#include "nsPrintSettingsX.h"
|
|
|
|
// The constants for paper orientation were renamed in 10.9. __MAC_10_9 is
|
|
// defined on OS X 10.9 and later. Although 10.8 and earlier are not supported
|
|
// at this time, this allows for building on those older OS versions. The
|
|
// values are consistent across OS versions so the rename does not affect
|
|
// runtime, just compilation.
|
|
#ifdef __MAC_10_9
|
|
#define NS_PAPER_ORIENTATION_PORTRAIT (NSPaperOrientationPortrait)
|
|
#define NS_PAPER_ORIENTATION_LANDSCAPE (NSPaperOrientationLandscape)
|
|
#else
|
|
#define NS_PAPER_ORIENTATION_PORTRAIT (NSPortraitOrientation)
|
|
#define NS_PAPER_ORIENTATION_LANDSCAPE (NSLandscapeOrientation)
|
|
#endif
|
|
|
|
using namespace mozilla::embedding;
|
|
|
|
nsPrintOptionsX::nsPrintOptionsX()
|
|
{
|
|
}
|
|
|
|
nsPrintOptionsX::~nsPrintOptionsX()
|
|
{
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsPrintOptionsX::SerializeToPrintData(nsIPrintSettings* aSettings,
|
|
nsIWebBrowserPrint* aWBP,
|
|
PrintData* data)
|
|
{
|
|
nsresult rv = nsPrintOptions::SerializeToPrintData(aSettings, aWBP, data);
|
|
if (NS_WARN_IF(NS_FAILED(rv))) {
|
|
return rv;
|
|
}
|
|
|
|
if (aWBP) {
|
|
// When serializing an nsIWebBrowserPrint, we need to pass up the first
|
|
// document name. We could pass up the entire collection of document
|
|
// names, but the OS X printing prompt code only really cares about
|
|
// the first one, so we just send the first to save IPC traffic.
|
|
char16_t** docTitles;
|
|
uint32_t titleCount;
|
|
rv = aWBP->EnumerateDocumentNames(&titleCount, &docTitles);
|
|
if (NS_SUCCEEDED(rv) && titleCount > 0) {
|
|
data->printJobName().Assign(docTitles[0]);
|
|
}
|
|
|
|
for (int32_t i = titleCount - 1; i >= 0; i--) {
|
|
free(docTitles[i]);
|
|
}
|
|
free(docTitles);
|
|
docTitles = nullptr;
|
|
}
|
|
|
|
RefPtr<nsPrintSettingsX> settingsX(do_QueryObject(aSettings));
|
|
if (NS_WARN_IF(!settingsX)) {
|
|
return NS_ERROR_FAILURE;
|
|
}
|
|
|
|
NSPrintInfo* printInfo = settingsX->GetCocoaPrintInfo();
|
|
if (NS_WARN_IF(!printInfo)) {
|
|
return NS_ERROR_FAILURE;
|
|
}
|
|
|
|
double adjustedWidth, adjustedHeight;
|
|
settingsX->GetAdjustedPaperSize(&adjustedWidth, &adjustedHeight);
|
|
data->adjustedPaperWidth() = adjustedWidth;
|
|
data->adjustedPaperHeight() = adjustedHeight;
|
|
|
|
NSDictionary* dict = [printInfo dictionary];
|
|
if (NS_WARN_IF(!dict)) {
|
|
return NS_ERROR_FAILURE;
|
|
}
|
|
|
|
NSString* printerName = [dict objectForKey: NSPrintPrinterName];
|
|
if (printerName) {
|
|
nsCocoaUtils::GetStringForNSString(printerName, data->printerName());
|
|
}
|
|
|
|
NSString* faxNumber = [dict objectForKey: NSPrintFaxNumber];
|
|
if (faxNumber) {
|
|
nsCocoaUtils::GetStringForNSString(faxNumber, data->faxNumber());
|
|
}
|
|
|
|
NSURL* printToFileURL = [dict objectForKey: NSPrintJobSavingURL];
|
|
if (printToFileURL) {
|
|
nsCocoaUtils::GetStringForNSString([printToFileURL absoluteString],
|
|
data->toFileName());
|
|
}
|
|
|
|
NSDate* printTime = [dict objectForKey: NSPrintTime];
|
|
if (printTime) {
|
|
NSTimeInterval timestamp = [printTime timeIntervalSinceReferenceDate];
|
|
data->printTime() = timestamp;
|
|
}
|
|
|
|
NSString* disposition = [dict objectForKey: NSPrintJobDisposition];
|
|
if (disposition) {
|
|
nsCocoaUtils::GetStringForNSString(disposition, data->disposition());
|
|
}
|
|
|
|
NSString* paperName = [dict objectForKey: NSPrintPaperName];
|
|
if (paperName) {
|
|
nsCocoaUtils::GetStringForNSString(paperName, data->paperName());
|
|
}
|
|
|
|
float scalingFactor = [[dict objectForKey: NSPrintScalingFactor] floatValue];
|
|
data->scalingFactor() = scalingFactor;
|
|
|
|
int32_t orientation;
|
|
if ([printInfo orientation] == NS_PAPER_ORIENTATION_PORTRAIT) {
|
|
orientation = nsIPrintSettings::kPortraitOrientation;
|
|
} else {
|
|
orientation = nsIPrintSettings::kLandscapeOrientation;
|
|
}
|
|
data->orientation() = orientation;
|
|
|
|
NSSize paperSize = [printInfo paperSize];
|
|
float widthScale, heightScale;
|
|
settingsX->GetInchesScale(&widthScale, &heightScale);
|
|
if (orientation == nsIPrintSettings::kLandscapeOrientation) {
|
|
// switch widths and heights
|
|
data->widthScale() = heightScale;
|
|
data->heightScale() = widthScale;
|
|
data->paperWidth() = paperSize.height / heightScale;
|
|
data->paperHeight() = paperSize.width / widthScale;
|
|
} else {
|
|
data->widthScale() = widthScale;
|
|
data->heightScale() = heightScale;
|
|
data->paperWidth() = paperSize.width / widthScale;
|
|
data->paperHeight() = paperSize.height / heightScale;
|
|
}
|
|
|
|
data->numCopies() = [[dict objectForKey: NSPrintCopies] intValue];
|
|
data->printAllPages() = [[dict objectForKey: NSPrintAllPages] boolValue];
|
|
data->startPageRange() = [[dict objectForKey: NSPrintFirstPage] intValue];
|
|
data->endPageRange() = [[dict objectForKey: NSPrintLastPage] intValue];
|
|
data->mustCollate() = [[dict objectForKey: NSPrintMustCollate] boolValue];
|
|
data->printReversed() = [[dict objectForKey: NSPrintReversePageOrder] boolValue];
|
|
data->pagesAcross() = [[dict objectForKey: NSPrintPagesAcross] unsignedShortValue];
|
|
data->pagesDown() = [[dict objectForKey: NSPrintPagesDown] unsignedShortValue];
|
|
data->detailedErrorReporting() = [[dict objectForKey: NSPrintDetailedErrorReporting] boolValue];
|
|
data->addHeaderAndFooter() = [[dict objectForKey: NSPrintHeaderAndFooter] boolValue];
|
|
data->fileNameExtensionHidden() =
|
|
[[dict objectForKey: NSPrintJobSavingFileNameExtensionHidden] boolValue];
|
|
|
|
bool printSelectionOnly = [[dict objectForKey: NSPrintSelectionOnly] boolValue];
|
|
aSettings->SetPrintOptions(nsIPrintSettings::kEnableSelectionRB,
|
|
printSelectionOnly);
|
|
aSettings->GetPrintOptionsBits(&data->optionFlags());
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsPrintOptionsX::DeserializeToPrintSettings(const PrintData& data,
|
|
nsIPrintSettings* settings)
|
|
{
|
|
nsresult rv = nsPrintOptions::DeserializeToPrintSettings(data, settings);
|
|
if (NS_WARN_IF(NS_FAILED(rv))) {
|
|
return rv;
|
|
}
|
|
|
|
RefPtr<nsPrintSettingsX> settingsX(do_QueryObject(settings));
|
|
if (NS_WARN_IF(!settingsX)) {
|
|
return NS_ERROR_FAILURE;
|
|
}
|
|
|
|
NSPrintInfo* sharedPrintInfo = [NSPrintInfo sharedPrintInfo];
|
|
if (NS_WARN_IF(!sharedPrintInfo)) {
|
|
return NS_ERROR_FAILURE;
|
|
}
|
|
|
|
NSDictionary* sharedDict = [sharedPrintInfo dictionary];
|
|
if (NS_WARN_IF(!sharedDict)) {
|
|
return NS_ERROR_FAILURE;
|
|
}
|
|
|
|
// We need to create a new NSMutableDictionary to pass to NSPrintInfo with
|
|
// the values that we got from the other process.
|
|
NSMutableDictionary* newPrintInfoDict =
|
|
[NSMutableDictionary dictionaryWithDictionary:sharedDict];
|
|
if (NS_WARN_IF(!newPrintInfoDict)) {
|
|
return NS_ERROR_OUT_OF_MEMORY;
|
|
}
|
|
|
|
NSString* printerName = nsCocoaUtils::ToNSString(data.printerName());
|
|
if (printerName) {
|
|
NSPrinter* printer = [NSPrinter printerWithName: printerName];
|
|
if (printer) {
|
|
[newPrintInfoDict setObject: printer forKey: NSPrintPrinter];
|
|
[newPrintInfoDict setObject: printerName forKey: NSPrintPrinterName];
|
|
}
|
|
}
|
|
|
|
[newPrintInfoDict setObject: [NSNumber numberWithInt: data.numCopies()]
|
|
forKey: NSPrintCopies];
|
|
[newPrintInfoDict setObject: [NSNumber numberWithBool: data.printAllPages()]
|
|
forKey: NSPrintAllPages];
|
|
[newPrintInfoDict setObject: [NSNumber numberWithInt: data.startPageRange()]
|
|
forKey: NSPrintFirstPage];
|
|
[newPrintInfoDict setObject: [NSNumber numberWithInt: data.endPageRange()]
|
|
forKey: NSPrintLastPage];
|
|
[newPrintInfoDict setObject: [NSNumber numberWithBool: data.mustCollate()]
|
|
forKey: NSPrintMustCollate];
|
|
[newPrintInfoDict setObject: [NSNumber numberWithBool: data.printReversed()]
|
|
forKey: NSPrintReversePageOrder];
|
|
|
|
[newPrintInfoDict setObject: nsCocoaUtils::ToNSString(data.disposition())
|
|
forKey: NSPrintJobDisposition];
|
|
|
|
[newPrintInfoDict setObject: nsCocoaUtils::ToNSString(data.paperName())
|
|
forKey: NSPrintPaperName];
|
|
|
|
[newPrintInfoDict setObject: [NSNumber numberWithFloat: data.scalingFactor()]
|
|
forKey: NSPrintScalingFactor];
|
|
|
|
CGFloat width = data.paperWidth() * data.widthScale();
|
|
CGFloat height = data.paperHeight() * data.heightScale();
|
|
[newPrintInfoDict setObject: [NSValue valueWithSize:NSMakeSize(width,height)]
|
|
forKey: NSPrintPaperSize];
|
|
|
|
int paperOrientation;
|
|
if (data.orientation() == nsIPrintSettings::kPortraitOrientation) {
|
|
paperOrientation = NS_PAPER_ORIENTATION_PORTRAIT;
|
|
settings->SetOrientation(nsIPrintSettings::kPortraitOrientation);
|
|
} else {
|
|
paperOrientation = NS_PAPER_ORIENTATION_LANDSCAPE;
|
|
settings->SetOrientation(nsIPrintSettings::kLandscapeOrientation);
|
|
}
|
|
[newPrintInfoDict setObject: [NSNumber numberWithInt:paperOrientation]
|
|
forKey: NSPrintOrientation];
|
|
|
|
[newPrintInfoDict setObject: [NSNumber numberWithShort: data.pagesAcross()]
|
|
forKey: NSPrintPagesAcross];
|
|
[newPrintInfoDict setObject: [NSNumber numberWithShort: data.pagesDown()]
|
|
forKey: NSPrintPagesDown];
|
|
[newPrintInfoDict setObject: [NSNumber numberWithBool: data.detailedErrorReporting()]
|
|
forKey: NSPrintDetailedErrorReporting];
|
|
[newPrintInfoDict setObject: nsCocoaUtils::ToNSString(data.faxNumber())
|
|
forKey: NSPrintFaxNumber];
|
|
[newPrintInfoDict setObject: [NSNumber numberWithBool: data.addHeaderAndFooter()]
|
|
forKey: NSPrintHeaderAndFooter];
|
|
[newPrintInfoDict setObject: [NSNumber numberWithBool: data.fileNameExtensionHidden()]
|
|
forKey: NSPrintJobSavingFileNameExtensionHidden];
|
|
|
|
// At this point, the base class should have properly deserialized the print
|
|
// options bitfield for nsIPrintSettings, so that it holds the correct value
|
|
// for kEnableSelectionRB, which we use to set NSPrintSelectionOnly.
|
|
|
|
bool printSelectionOnly = false;
|
|
rv = settings->GetPrintOptions(nsIPrintSettings::kEnableSelectionRB, &printSelectionOnly);
|
|
if (NS_SUCCEEDED(rv)) {
|
|
[newPrintInfoDict setObject: [NSNumber numberWithBool: printSelectionOnly]
|
|
forKey: NSPrintSelectionOnly];
|
|
} else {
|
|
[newPrintInfoDict setObject: [NSNumber numberWithBool: NO]
|
|
forKey: NSPrintSelectionOnly];
|
|
}
|
|
|
|
NSURL* jobSavingURL =
|
|
[NSURL URLWithString: nsCocoaUtils::ToNSString(data.toFileName())];
|
|
if (jobSavingURL) {
|
|
[newPrintInfoDict setObject: jobSavingURL forKey: NSPrintJobSavingURL];
|
|
}
|
|
|
|
NSTimeInterval timestamp = data.printTime();
|
|
NSDate* printTime = [NSDate dateWithTimeIntervalSinceReferenceDate: timestamp];
|
|
if (printTime) {
|
|
[newPrintInfoDict setObject: printTime forKey: NSPrintTime];
|
|
}
|
|
|
|
// Next, we create a new NSPrintInfo with the values in our dictionary.
|
|
NSPrintInfo* newPrintInfo =
|
|
[[NSPrintInfo alloc] initWithDictionary: newPrintInfoDict];
|
|
if (NS_WARN_IF(!newPrintInfo)) {
|
|
return NS_ERROR_OUT_OF_MEMORY;
|
|
}
|
|
|
|
// And now swap in the new NSPrintInfo we've just populated.
|
|
settingsX->SetCocoaPrintInfo(newPrintInfo);
|
|
[newPrintInfo release];
|
|
|
|
settingsX->SetAdjustedPaperSize(data.adjustedPaperWidth(),
|
|
data.adjustedPaperHeight());
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
nsresult
|
|
nsPrintOptionsX::ReadPrefs(nsIPrintSettings* aPS, const nsAString& aPrinterName, uint32_t aFlags)
|
|
{
|
|
nsresult rv;
|
|
|
|
rv = nsPrintOptions::ReadPrefs(aPS, aPrinterName, aFlags);
|
|
NS_ASSERTION(NS_SUCCEEDED(rv), "nsPrintOptions::ReadPrefs() failed");
|
|
|
|
RefPtr<nsPrintSettingsX> printSettingsX(do_QueryObject(aPS));
|
|
if (!printSettingsX)
|
|
return NS_ERROR_NO_INTERFACE;
|
|
rv = printSettingsX->ReadPageFormatFromPrefs();
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
nsresult nsPrintOptionsX::_CreatePrintSettings(nsIPrintSettings **_retval)
|
|
{
|
|
nsresult rv;
|
|
*_retval = nullptr;
|
|
|
|
nsPrintSettingsX* printSettings = new nsPrintSettingsX; // does not initially ref count
|
|
NS_ENSURE_TRUE(printSettings, NS_ERROR_OUT_OF_MEMORY);
|
|
NS_ADDREF(*_retval = printSettings);
|
|
|
|
rv = printSettings->Init();
|
|
if (NS_FAILED(rv)) {
|
|
NS_RELEASE(*_retval);
|
|
return rv;
|
|
}
|
|
|
|
InitPrintSettingsFromPrefs(*_retval, false, nsIPrintSettings::kInitSaveAll);
|
|
return rv;
|
|
}
|
|
|
|
nsresult
|
|
nsPrintOptionsX::WritePrefs(nsIPrintSettings* aPS, const nsAString& aPrinterName, uint32_t aFlags)
|
|
{
|
|
nsresult rv;
|
|
|
|
rv = nsPrintOptions::WritePrefs(aPS, aPrinterName, aFlags);
|
|
NS_ASSERTION(NS_SUCCEEDED(rv), "nsPrintOptions::WritePrefs() failed");
|
|
|
|
RefPtr<nsPrintSettingsX> printSettingsX(do_QueryObject(aPS));
|
|
if (!printSettingsX)
|
|
return NS_ERROR_NO_INTERFACE;
|
|
rv = printSettingsX->WritePageFormatToPrefs();
|
|
NS_ASSERTION(NS_SUCCEEDED(rv), "nsPrintSettingsX::WritePageFormatToPrefs() failed");
|
|
|
|
return NS_OK;
|
|
}
|