wine/gecko
0
0
Fork 0
mirror of https://gitlab.winehq.org/wine/wine-gecko.git synced 2024-09-13 09:24:08 -07:00
Code Issues Packages Projects Releases Wiki Activity
a187fb3edb
gecko/layout/printing/nsPrintEngine.cpp
L. David Baron a187fb3edb Bug 896138 patch 4: Move restyle management code from nsCSSFrameConstructor to RestyleManager. r=heycam 
This moves restyling management out of nsCSSFrameConstructor (thus
reducing its size), and keeps the restyling code closer together.

This is the first of two big chunks of code moved in this patch series.
A later patch in this series will move related code from nsFrameManager
into the same destination file.
2013-07-20 12:14:25 -07:00

4059 lines
132 KiB
C++
Raw Blame History

/* -*- 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 "nsPrintEngine.h"
#include "nsIStringBundle.h"
#include "nsReadableUtils.h"
#include "nsCRT.h"
#include "mozilla/Selection.h"
#include "nsIScriptGlobalObject.h"
#include "nsPIDOMWindow.h"
#include "nsIDocShell.h"
#include "nsIFrame.h"
#include "nsIURI.h"
#include "nsITextToSubURI.h"
#include "nsError.h"
#include "nsView.h"
#include "nsAsyncDOMEvent.h"
#include <algorithm>
// Print Options
#include "nsIPrintSettings.h"
#include "nsIPrintSettingsService.h"
#include "nsIPrintOptions.h"
#include "nsIPrintSession.h"
#include "nsGfxCIID.h"
#include "nsIServiceManager.h"
#include "nsGkAtoms.h"
#include "nsXPCOM.h"
#include "nsISupportsPrimitives.h"
static const char sPrintSettingsServiceContractID[] = "@mozilla.org/gfx/printsettings-service;1";
// Printing Events
#include "nsPrintPreviewListener.h"
#include "nsThreadUtils.h"
// Printing
#include "nsIWebBrowserPrint.h"
#include "nsIDOMHTMLFrameElement.h"
#include "nsIDOMHTMLFrameSetElement.h"
#include "nsIDOMHTMLIFrameElement.h"
#include "nsIDOMHTMLObjectElement.h"
#include "nsIDOMHTMLEmbedElement.h"
// Print Preview
#include "imgIContainer.h" // image animation mode constants
#include "nsIWebBrowserPrint.h" // needed for PrintPreview Navigation constants
// Print Progress
#include "nsIPrintProgress.h"
#include "nsIPrintProgressParams.h"
#include "nsIObserver.h"
// Print error dialog
#include "nsIPrompt.h"
#include "nsIWindowWatcher.h"
// Printing Prompts
#include "nsIPrintingPromptService.h"
static const char kPrintingPromptService[] = "@mozilla.org/embedcomp/printingprompt-service;1";
// Printing Timer
#include "nsPagePrintTimer.h"
// FrameSet
#include "nsIDocument.h"
// Focus
#include "nsISelectionController.h"
// Misc
#include "nsISupportsUtils.h"
#include "nsIScriptContext.h"
#include "nsIDOMDocument.h"
#include "nsISelectionListener.h"
#include "nsISelectionPrivate.h"
#include "nsIDOMRange.h"
#include "nsContentCID.h"
#include "nsLayoutCID.h"
#include "nsContentUtils.h"
#include "nsIPresShell.h"
#include "nsLayoutUtils.h"
#include "mozilla/Preferences.h"
#include "nsWidgetsCID.h"
#include "nsIDeviceContextSpec.h"
#include "nsViewManager.h"
#include "nsView.h"
#include "nsRenderingContext.h"
#include "nsIPageSequenceFrame.h"
#include "nsIURL.h"
#include "nsIContentViewerEdit.h"
#include "nsIContentViewerFile.h"
#include "nsIMarkupDocumentViewer.h"
#include "nsIInterfaceRequestor.h"
#include "nsIInterfaceRequestorUtils.h"
#include "nsIDocShellTreeOwner.h"
#include "nsIWebBrowserChrome.h"
#include "nsIBaseWindow.h"
#include "nsILayoutHistoryState.h"
#include "nsFrameManager.h"
#include "nsGUIEvent.h"
#include "nsHTMLReflowState.h"
#include "nsIDOMHTMLAnchorElement.h"
#include "nsIDOMHTMLAreaElement.h"
#include "nsIDOMHTMLLinkElement.h"
#include "nsIDOMHTMLImageElement.h"
#include "nsIContentViewerContainer.h"
#include "nsIContentViewer.h"
#include "nsIDocumentViewerPrint.h"
#include "nsCSSFrameConstructor.h"
#include "nsFocusManager.h"
#include "nsRange.h"
#include "nsCDefaultURIFixup.h"
#include "nsIURIFixup.h"
#include "mozilla/dom/Element.h"
#include "nsContentList.h"
using namespace mozilla;
using namespace mozilla::dom;
//-----------------------------------------------------
// PR LOGGING
#ifdef MOZ_LOGGING
#define FORCE_PR_LOG /* Allow logging in the release build */
#endif
#include "prlog.h"
#ifdef PR_LOGGING
#ifdef DEBUG
// PR_LOGGING is force to always be on (even in release builds)
// but we only want some of it on,
//#define EXTENDED_DEBUG_PRINTING
#endif
#define DUMP_LAYOUT_LEVEL 9 // this turns on the dumping of each doucment's layout info
static PRLogModuleInfo *
GetPrintingLog()
{
static PRLogModuleInfo *sLog;
if (!sLog)
sLog = PR_NewLogModule("printing");
return sLog;
}
#define PR_PL(_p1) PR_LOG(GetPrintingLog(), PR_LOG_DEBUG, _p1);
#ifdef EXTENDED_DEBUG_PRINTING
static uint32_t gDumpFileNameCnt = 0;
static uint32_t gDumpLOFileNameCnt = 0;
#endif
#define PRT_YESNO(_p) ((_p)?"YES":"NO")
static const char * gFrameTypesStr[] = {"eDoc", "eFrame", "eIFrame", "eFrameSet"};
static const char * gPrintFrameTypeStr[] = {"kNoFrames", "kFramesAsIs", "kSelectedFrame", "kEachFrameSep"};
static const char * gFrameHowToEnableStr[] = {"kFrameEnableNone", "kFrameEnableAll", "kFrameEnableAsIsAndEach"};
static const char * gPrintRangeStr[] = {"kRangeAllPages", "kRangeSpecifiedPageRange", "kRangeSelection", "kRangeFocusFrame"};
#else
#define PRT_YESNO(_p)
#define PR_PL(_p1)
#endif
#ifdef EXTENDED_DEBUG_PRINTING
// Forward Declarations
static void DumpPrintObjectsListStart(const char * aStr, nsTArray<nsPrintObject*> * aDocList);
static void DumpPrintObjectsTree(nsPrintObject * aPO, int aLevel= 0, FILE* aFD = nullptr);
static void DumpPrintObjectsTreeLayout(nsPrintObject * aPO,nsDeviceContext * aDC, int aLevel= 0, FILE * aFD = nullptr);
#define DUMP_DOC_LIST(_title) DumpPrintObjectsListStart((_title), mPrt->mPrintDocList);
#define DUMP_DOC_TREE DumpPrintObjectsTree(mPrt->mPrintObject);
#define DUMP_DOC_TREELAYOUT DumpPrintObjectsTreeLayout(mPrt->mPrintObject, mPrt->mPrintDC);
#else
#define DUMP_DOC_LIST(_title)
#define DUMP_DOC_TREE
#define DUMP_DOC_TREELAYOUT
#endif
class nsScriptSuppressor
{
public:
nsScriptSuppressor(nsPrintEngine* aPrintEngine)
: mPrintEngine(aPrintEngine), mSuppressed(false) {}
~nsScriptSuppressor() { Unsuppress(); }
void Suppress()
{
if (mPrintEngine) {
mSuppressed = true;
mPrintEngine->TurnScriptingOn(false);
}
}
void Unsuppress()
{
if (mPrintEngine && mSuppressed) {
mPrintEngine->TurnScriptingOn(true);
}
mSuppressed = false;
}
void Disconnect() { mPrintEngine = nullptr; }
protected:
nsRefPtr<nsPrintEngine> mPrintEngine;
bool mSuppressed;
};
NS_IMPL_ISUPPORTS3(nsPrintEngine, nsIWebProgressListener,
nsISupportsWeakReference, nsIObserver)
//---------------------------------------------------
//-- nsPrintEngine Class Impl
//---------------------------------------------------
nsPrintEngine::nsPrintEngine() :
mIsCreatingPrintPreview(false),
mIsDoingPrinting(false),
mIsDoingPrintPreview(false),
mProgressDialogIsShown(false),
mScreenDPI(115.0f),
mPrt(nullptr),
mPagePrintTimer(nullptr),
mPageSeqFrame(nullptr),
mPrtPreview(nullptr),
mOldPrtPreview(nullptr),
mDebugFile(nullptr),
mLoadCounter(0),
mDidLoadDataForPrinting(false),
mIsDestroying(false),
mDisallowSelectionPrint(false),
mNoMarginBoxes(false)
{
}
//-------------------------------------------------------
nsPrintEngine::~nsPrintEngine()
{
Destroy(); // for insurance
}
//-------------------------------------------------------
void nsPrintEngine::Destroy()
{
if (mIsDestroying) {
return;
}
mIsDestroying = true;
if (mPrt) {
delete mPrt;
mPrt = nullptr;
}
#ifdef NS_PRINT_PREVIEW
if (mPrtPreview) {
delete mPrtPreview;
mPrtPreview = nullptr;
}
// This is insruance
if (mOldPrtPreview) {
delete mOldPrtPreview;
mOldPrtPreview = nullptr;
}
#endif
mDocViewerPrint = nullptr;
}
//-------------------------------------------------------
void nsPrintEngine::DestroyPrintingData()
{
if (mPrt) {
nsPrintData* data = mPrt;
mPrt = nullptr;
delete data;
}
}
//---------------------------------------------------------------------------------
//-- Section: Methods needed by the DocViewer
//---------------------------------------------------------------------------------
//--------------------------------------------------------
nsresult nsPrintEngine::Initialize(nsIDocumentViewerPrint* aDocViewerPrint,
nsIWeakReference* aContainer,
nsIDocument* aDocument,
float aScreenDPI,
FILE* aDebugFile)
{
NS_ENSURE_ARG_POINTER(aDocViewerPrint);
NS_ENSURE_ARG_POINTER(aContainer);
NS_ENSURE_ARG_POINTER(aDocument);
mDocViewerPrint = aDocViewerPrint;
mContainer = aContainer;
mDocument = aDocument;
mScreenDPI = aScreenDPI;
mDebugFile = aDebugFile; // ok to be NULL
return NS_OK;
}
//-------------------------------------------------------
bool
nsPrintEngine::CheckBeforeDestroy()
{
if (mPrt && mPrt->mPreparingForPrint) {
mPrt->mDocWasToBeDestroyed = true;
return true;
}
return false;
}
//-------------------------------------------------------
nsresult
nsPrintEngine::Cancelled()
{
if (mPrt && mPrt->mPrintSettings) {
return mPrt->mPrintSettings->SetIsCancelled(true);
}
return NS_ERROR_FAILURE;
}
//-------------------------------------------------------
// Install our event listeners on the document to prevent
// some events from being processed while in PrintPreview
//
// No return code - if this fails, there isn't much we can do
void
nsPrintEngine::InstallPrintPreviewListener()
{
if (!mPrt->mPPEventListeners) {
nsCOMPtr<nsIDocShell> docShell = do_QueryReferent(mContainer);
nsCOMPtr<nsPIDOMWindow> win(do_GetInterface(docShell));
if (win) {
nsCOMPtr<EventTarget> target = do_QueryInterface(win->GetFrameElementInternal());
mPrt->mPPEventListeners = new nsPrintPreviewListener(target);
mPrt->mPPEventListeners->AddListeners();
}
}
}
//----------------------------------------------------------------------
nsresult
nsPrintEngine::GetSeqFrameAndCountPagesInternal(nsPrintObject* aPO,
nsIFrame*& aSeqFrame,
int32_t& aCount)
{
NS_ENSURE_ARG_POINTER(aPO);
// Finds the SimplePageSequencer frame
nsIPageSequenceFrame* seqFrame = aPO->mPresShell->GetPageSequenceFrame();
if (seqFrame) {
aSeqFrame = do_QueryFrame(seqFrame);
} else {
aSeqFrame = nullptr;
}
if (aSeqFrame == nullptr) return NS_ERROR_FAILURE;
// first count the total number of pages
aCount = 0;
nsIFrame* pageFrame = aSeqFrame->GetFirstPrincipalChild();
while (pageFrame != nullptr) {
aCount++;
pageFrame = pageFrame->GetNextSibling();
}
return NS_OK;
}
//-----------------------------------------------------------------
nsresult nsPrintEngine::GetSeqFrameAndCountPages(nsIFrame*& aSeqFrame, int32_t& aCount)
{
NS_ASSERTION(mPrtPreview, "mPrtPreview can't be null!");
return GetSeqFrameAndCountPagesInternal(mPrtPreview->mPrintObject, aSeqFrame, aCount);
}
//---------------------------------------------------------------------------------
//-- Done: Methods needed by the DocViewer
//---------------------------------------------------------------------------------
//---------------------------------------------------------------------------------
//-- Section: nsIWebBrowserPrint
//---------------------------------------------------------------------------------
// Foward decl for Debug Helper Functions
#ifdef EXTENDED_DEBUG_PRINTING
static int RemoveFilesInDir(const char * aDir);
static void GetDocTitleAndURL(nsPrintObject* aPO, char *& aDocStr, char *& aURLStr);
static void DumpPrintObjectsTree(nsPrintObject * aPO, int aLevel, FILE* aFD);
static void DumpPrintObjectsList(nsTArray<nsPrintObject*> * aDocList);
static void RootFrameList(nsPresContext* aPresContext, FILE* out, int32_t aIndent);
static void DumpViews(nsIDocShell* aDocShell, FILE* out);
static void DumpLayoutData(char* aTitleStr, char* aURLStr,
nsPresContext* aPresContext,
nsDeviceContext * aDC, nsIFrame * aRootFrame,
nsIDocShell * aDocShell, FILE* aFD);
#endif
//--------------------------------------------------------------------------------
nsresult
nsPrintEngine::CommonPrint(bool aIsPrintPreview,
nsIPrintSettings* aPrintSettings,
nsIWebProgressListener* aWebProgressListener,
nsIDOMDocument* aDoc) {
nsRefPtr<nsPrintEngine> kungfuDeathGrip = this;
nsresult rv = DoCommonPrint(aIsPrintPreview, aPrintSettings,
aWebProgressListener, aDoc);
if (NS_FAILED(rv)) {
if (aIsPrintPreview) {
SetIsCreatingPrintPreview(false);
SetIsPrintPreview(false);
} else {
SetIsPrinting(false);
}
if (mProgressDialogIsShown)
CloseProgressDialog(aWebProgressListener);
if (rv != NS_ERROR_ABORT && rv != NS_ERROR_OUT_OF_MEMORY)
ShowPrintErrorDialog(rv, !aIsPrintPreview);
delete mPrt;
mPrt = nullptr;
}
return rv;
}
nsresult
nsPrintEngine::DoCommonPrint(bool aIsPrintPreview,
nsIPrintSettings* aPrintSettings,
nsIWebProgressListener* aWebProgressListener,
nsIDOMDocument* aDoc)
{
nsresult rv;
if (aIsPrintPreview) {
// The WebProgressListener can be QI'ed to nsIPrintingPromptService
// then that means the progress dialog is already being shown.
nsCOMPtr<nsIPrintingPromptService> pps(do_QueryInterface(aWebProgressListener));
mProgressDialogIsShown = pps != nullptr;
if (mIsDoingPrintPreview) {
mOldPrtPreview = mPrtPreview;
mPrtPreview = nullptr;
}
} else {
mProgressDialogIsShown = false;
}
mPrt = new nsPrintData(aIsPrintPreview ? nsPrintData::eIsPrintPreview :
nsPrintData::eIsPrinting);
NS_ENSURE_TRUE(mPrt, NS_ERROR_OUT_OF_MEMORY);
// if they don't pass in a PrintSettings, then get the Global PS
mPrt->mPrintSettings = aPrintSettings;
if (!mPrt->mPrintSettings) {
rv = GetGlobalPrintSettings(getter_AddRefs(mPrt->mPrintSettings));
NS_ENSURE_SUCCESS(rv, rv);
}
rv = CheckForPrinters(mPrt->mPrintSettings);
NS_ENSURE_SUCCESS(rv, rv);
mPrt->mPrintSettings->SetIsCancelled(false);
mPrt->mPrintSettings->GetShrinkToFit(&mPrt->mShrinkToFit);
// In the case the margin boxes are not printed store the print settings for
// the footer/header to be used as default print setting for follow up prints.
mPrt->mPrintSettings->SetPersistMarginBoxSettings(!mNoMarginBoxes);
if (mNoMarginBoxes) {
// Set the footer/header to blank.
const PRUnichar* emptyString = EmptyString().get();
mPrt->mPrintSettings->SetHeaderStrLeft(emptyString);
mPrt->mPrintSettings->SetHeaderStrCenter(emptyString);
mPrt->mPrintSettings->SetHeaderStrRight(emptyString);
mPrt->mPrintSettings->SetFooterStrLeft(emptyString);
mPrt->mPrintSettings->SetFooterStrCenter(emptyString);
mPrt->mPrintSettings->SetFooterStrRight(emptyString);
}
if (aIsPrintPreview) {
SetIsCreatingPrintPreview(true);
SetIsPrintPreview(true);
nsCOMPtr<nsIMarkupDocumentViewer> viewer =
do_QueryInterface(mDocViewerPrint);
if (viewer) {
viewer->SetTextZoom(1.0f);
viewer->SetFullZoom(1.0f);
viewer->SetMinFontSize(0);
}
}
// Create a print session and let the print settings know about it.
// The print settings hold an nsWeakPtr to the session so it does not
// need to be cleared from the settings at the end of the job.
// XXX What lifetime does the printSession need to have?
nsCOMPtr<nsIPrintSession> printSession;
if (!aIsPrintPreview) {
printSession = do_CreateInstance("@mozilla.org/gfx/printsession;1", &rv);
NS_ENSURE_SUCCESS(rv, rv);
mPrt->mPrintSettings->SetPrintSession(printSession);
}
if (aWebProgressListener != nullptr) {
mPrt->mPrintProgressListeners.AppendObject(aWebProgressListener);
}
// Get the currently focused window and cache it
// because the Print Dialog will "steal" focus and later when you try
// to get the currently focused windows it will be NULL
mPrt->mCurrentFocusWin = FindFocusedDOMWindow();
// Check to see if there is a "regular" selection
bool isSelection = IsThereARangeSelection(mPrt->mCurrentFocusWin);
// Get the docshell for this documentviewer
nsCOMPtr<nsIDocShell> webContainer(do_QueryReferent(mContainer, &rv));
NS_ENSURE_SUCCESS(rv, rv);
{
if (aIsPrintPreview) {
nsCOMPtr<nsIContentViewer> viewer;
webContainer->GetContentViewer(getter_AddRefs(viewer));
if (viewer && viewer->GetDocument() && viewer->GetDocument()->IsShowing()) {
viewer->GetDocument()->OnPageHide(false, nullptr);
}
}
nsAutoScriptBlocker scriptBlocker;
mPrt->mPrintObject = new nsPrintObject();
NS_ENSURE_TRUE(mPrt->mPrintObject, NS_ERROR_OUT_OF_MEMORY);
rv = mPrt->mPrintObject->Init(webContainer, aDoc, aIsPrintPreview);
NS_ENSURE_SUCCESS(rv, rv);
NS_ENSURE_TRUE(mPrt->mPrintDocList.AppendElement(mPrt->mPrintObject),
NS_ERROR_OUT_OF_MEMORY);
mPrt->mIsParentAFrameSet = IsParentAFrameSet(webContainer);
mPrt->mPrintObject->mFrameType = mPrt->mIsParentAFrameSet ? eFrameSet : eDoc;
// Build the "tree" of PrintObjects
BuildDocTree(mPrt->mPrintObject->mDocShell, &mPrt->mPrintDocList,
mPrt->mPrintObject);
}
if (!aIsPrintPreview) {
SetIsPrinting(true);
}
// XXX This isn't really correct...
if (!mPrt->mPrintObject->mDocument ||
!mPrt->mPrintObject->mDocument->GetRootElement())
return NS_ERROR_GFX_PRINTER_STARTDOC;
// Create the linkage from the sub-docs back to the content element
// in the parent document
MapContentToWebShells(mPrt->mPrintObject, mPrt->mPrintObject);
mPrt->mIsIFrameSelected = IsThereAnIFrameSelected(webContainer, mPrt->mCurrentFocusWin, mPrt->mIsParentAFrameSet);
// Setup print options for UI
if (mPrt->mIsParentAFrameSet) {
if (mPrt->mCurrentFocusWin) {
mPrt->mPrintSettings->SetHowToEnableFrameUI(nsIPrintSettings::kFrameEnableAll);
} else {
mPrt->mPrintSettings->SetHowToEnableFrameUI(nsIPrintSettings::kFrameEnableAsIsAndEach);
}
} else {
mPrt->mPrintSettings->SetHowToEnableFrameUI(nsIPrintSettings::kFrameEnableNone);
}
// Now determine how to set up the Frame print UI
mPrt->mPrintSettings->SetPrintOptions(nsIPrintSettings::kEnableSelectionRB,
isSelection || mPrt->mIsIFrameSelected);
nsCOMPtr<nsIDeviceContextSpec> devspec
(do_CreateInstance("@mozilla.org/gfx/devicecontextspec;1", &rv));
NS_ENSURE_SUCCESS(rv, rv);
nsScriptSuppressor scriptSuppressor(this);
if (!aIsPrintPreview) {
#ifdef DEBUG
mPrt->mDebugFilePtr = mDebugFile;
#endif
scriptSuppressor.Suppress();
bool printSilently;
mPrt->mPrintSettings->GetPrintSilent(&printSilently);
// Check prefs for a default setting as to whether we should print silently
printSilently =
Preferences::GetBool("print.always_print_silent", printSilently);
// Ask dialog to be Print Shown via the Plugable Printing Dialog Service
// This service is for the Print Dialog and the Print Progress Dialog
// If printing silently or you can't get the service continue on
if (!printSilently) {
nsCOMPtr<nsIPrintingPromptService> printPromptService(do_GetService(kPrintingPromptService));
if (printPromptService) {
nsIDOMWindow *domWin = mDocument->GetWindow();
NS_ENSURE_TRUE(domWin, NS_ERROR_FAILURE);
// Platforms not implementing a given dialog for the service may
// return NS_ERROR_NOT_IMPLEMENTED or an error code.
//
// NS_ERROR_NOT_IMPLEMENTED indicates they want default behavior
// Any other error code means we must bail out
//
nsCOMPtr<nsIWebBrowserPrint> wbp(do_QueryInterface(mDocViewerPrint));
rv = printPromptService->ShowPrintDialog(domWin, wbp,
mPrt->mPrintSettings);
//
// ShowPrintDialog triggers an event loop which means we can't assume
// that the state of this->{anything} matches the state we've checked
// above. Including that a given {thing} is non null.
if (!mPrt) {
return NS_ERROR_FAILURE;
}
if (NS_SUCCEEDED(rv)) {
// since we got the dialog and it worked then make sure we
// are telling GFX we want to print silent
printSilently = true;
if (mPrt->mPrintSettings) {
// The user might have changed shrink-to-fit in the print dialog, so update our copy of its state
mPrt->mPrintSettings->GetShrinkToFit(&mPrt->mShrinkToFit);
}
} else if (rv == NS_ERROR_NOT_IMPLEMENTED) {
// This means the Dialog service was there,
// but they choose not to implement this dialog and
// are looking for default behavior from the toolkit
rv = NS_OK;
}
} else {
// No dialog service available
rv = NS_ERROR_NOT_IMPLEMENTED;
}
} else {
// Call any code that requires a run of the event loop.
rv = mPrt->mPrintSettings->SetupSilentPrinting();
}
// Check explicitly for abort because it's expected
if (rv == NS_ERROR_ABORT)
return rv;
NS_ENSURE_SUCCESS(rv, rv);
}
rv = devspec->Init(nullptr, mPrt->mPrintSettings, aIsPrintPreview);
NS_ENSURE_SUCCESS(rv, rv);
mPrt->mPrintDC = new nsDeviceContext();
rv = mPrt->mPrintDC->InitForPrinting(devspec);
NS_ENSURE_SUCCESS(rv, rv);
if (aIsPrintPreview) {
mPrt->mPrintSettings->SetPrintFrameType(nsIPrintSettings::kFramesAsIs);
// override any UI that wants to PrintPreview any selection or page range
// we want to view every page in PrintPreview each time
mPrt->mPrintSettings->SetPrintRange(nsIPrintSettings::kRangeAllPages);
} else {
// Always check and set the print settings first and then fall back
// onto the PrintService if there isn't a PrintSettings
//
// Posiible Usage values:
// nsIPrintSettings::kUseInternalDefault
// nsIPrintSettings::kUseSettingWhenPossible
//
// NOTE: The consts are the same for PrintSettings and PrintSettings
int16_t printFrameTypeUsage = nsIPrintSettings::kUseSettingWhenPossible;
mPrt->mPrintSettings->GetPrintFrameTypeUsage(&printFrameTypeUsage);
// Ok, see if we are going to use our value and override the default
if (printFrameTypeUsage == nsIPrintSettings::kUseSettingWhenPossible) {
// Get the Print Options/Settings PrintFrameType to see what is preferred
int16_t printFrameType = nsIPrintSettings::kEachFrameSep;
mPrt->mPrintSettings->GetPrintFrameType(&printFrameType);
// Don't let anybody do something stupid like try to set it to
// kNoFrames when we are printing a FrameSet
if (printFrameType == nsIPrintSettings::kNoFrames) {
mPrt->mPrintFrameType = nsIPrintSettings::kEachFrameSep;
mPrt->mPrintSettings->SetPrintFrameType(mPrt->mPrintFrameType);
} else {
// First find out from the PrinService what options are available
// to us for Printing FrameSets
int16_t howToEnableFrameUI;
mPrt->mPrintSettings->GetHowToEnableFrameUI(&howToEnableFrameUI);
if (howToEnableFrameUI != nsIPrintSettings::kFrameEnableNone) {
switch (howToEnableFrameUI) {
case nsIPrintSettings::kFrameEnableAll:
mPrt->mPrintFrameType = printFrameType;
break;
case nsIPrintSettings::kFrameEnableAsIsAndEach:
if (printFrameType != nsIPrintSettings::kSelectedFrame) {
mPrt->mPrintFrameType = printFrameType;
} else { // revert back to a good value
mPrt->mPrintFrameType = nsIPrintSettings::kEachFrameSep;
}
break;
} // switch
mPrt->mPrintSettings->SetPrintFrameType(mPrt->mPrintFrameType);
}
}
} else {
mPrt->mPrintSettings->GetPrintFrameType(&mPrt->mPrintFrameType);
}
}
if (mPrt->mPrintFrameType == nsIPrintSettings::kEachFrameSep) {
CheckForChildFrameSets(mPrt->mPrintObject);
}
if (NS_FAILED(EnablePOsForPrinting())) {
return NS_ERROR_FAILURE;
}
// Attach progressListener to catch network requests.
nsCOMPtr<nsIWebProgress> webProgress = do_QueryInterface(mPrt->mPrintObject->mDocShell);
webProgress->AddProgressListener(
static_cast<nsIWebProgressListener*>(this),
nsIWebProgress::NOTIFY_STATE_REQUEST);
mLoadCounter = 0;
mDidLoadDataForPrinting = false;
if (aIsPrintPreview) {
bool notifyOnInit = false;
ShowPrintProgress(false, notifyOnInit);
// Very important! Turn Off scripting
TurnScriptingOn(false);
if (!notifyOnInit) {
InstallPrintPreviewListener();
rv = InitPrintDocConstruction(false);
} else {
rv = NS_OK;
}
} else {
bool doNotify;
ShowPrintProgress(true, doNotify);
if (!doNotify) {
// Print listener setup...
mPrt->OnStartPrinting();
rv = InitPrintDocConstruction(false);
}
}
// We will enable scripting later after printing has finished.
scriptSuppressor.Disconnect();
return NS_OK;
}
//---------------------------------------------------------------------------------
NS_IMETHODIMP
nsPrintEngine::Print(nsIPrintSettings* aPrintSettings,
nsIWebProgressListener* aWebProgressListener)
{
// If we have a print preview document, use that instead of the original
// mDocument. That way animated images etc. get printed using the same state
// as in print preview.
nsCOMPtr<nsIDOMDocument> doc =
do_QueryInterface(mPrtPreview && mPrtPreview->mPrintObject ?
mPrtPreview->mPrintObject->mDocument : mDocument);
return CommonPrint(false, aPrintSettings, aWebProgressListener, doc);
}
NS_IMETHODIMP
nsPrintEngine::PrintPreview(nsIPrintSettings* aPrintSettings,
nsIDOMWindow *aChildDOMWin,
nsIWebProgressListener* aWebProgressListener)
{
// Get the DocShell and see if it is busy
// (We can't Print Preview this document if it is still busy)
nsCOMPtr<nsIDocShell> docShell(do_QueryReferent(mContainer));
NS_ENSURE_STATE(docShell);
uint32_t busyFlags = nsIDocShell::BUSY_FLAGS_NONE;
if (NS_FAILED(docShell->GetBusyFlags(&busyFlags)) ||
busyFlags != nsIDocShell::BUSY_FLAGS_NONE) {
CloseProgressDialog(aWebProgressListener);
ShowPrintErrorDialog(NS_ERROR_GFX_PRINTER_DOC_IS_BUSY, false);
return NS_ERROR_FAILURE;
}
NS_ENSURE_STATE(aChildDOMWin);
nsCOMPtr<nsIDOMDocument> doc;
aChildDOMWin->GetDocument(getter_AddRefs(doc));
NS_ENSURE_STATE(doc);
// Document is not busy -- go ahead with the Print Preview
return CommonPrint(true, aPrintSettings, aWebProgressListener, doc);
}
//----------------------------------------------------------------------------------
/* readonly attribute boolean isFramesetDocument; */
NS_IMETHODIMP
nsPrintEngine::GetIsFramesetDocument(bool *aIsFramesetDocument)
{
nsCOMPtr<nsIDocShell> webContainer(do_QueryReferent(mContainer));
*aIsFramesetDocument = IsParentAFrameSet(webContainer);
return NS_OK;
}
//----------------------------------------------------------------------------------
/* readonly attribute boolean isIFrameSelected; */
NS_IMETHODIMP
nsPrintEngine::GetIsIFrameSelected(bool *aIsIFrameSelected)
{
*aIsIFrameSelected = false;
// Get the docshell for this documentviewer
nsCOMPtr<nsIDocShell> webContainer(do_QueryReferent(mContainer));
// Get the currently focused window
nsCOMPtr<nsIDOMWindow> currentFocusWin = FindFocusedDOMWindow();
if (currentFocusWin && webContainer) {
// Get whether the doc contains a frameset
// Also, check to see if the currently focus docshell
// is a child of this docshell
bool isParentFrameSet;
*aIsIFrameSelected = IsThereAnIFrameSelected(webContainer, currentFocusWin, isParentFrameSet);
}
return NS_OK;
}
//----------------------------------------------------------------------------------
/* readonly attribute boolean isRangeSelection; */
NS_IMETHODIMP
nsPrintEngine::GetIsRangeSelection(bool *aIsRangeSelection)
{
// Get the currently focused window
nsCOMPtr<nsIDOMWindow> currentFocusWin = FindFocusedDOMWindow();
*aIsRangeSelection = IsThereARangeSelection(currentFocusWin);
return NS_OK;
}
//----------------------------------------------------------------------------------
/* readonly attribute boolean isFramesetFrameSelected; */
NS_IMETHODIMP
nsPrintEngine::GetIsFramesetFrameSelected(bool *aIsFramesetFrameSelected)
{
// Get the currently focused window
nsCOMPtr<nsIDOMWindow> currentFocusWin = FindFocusedDOMWindow();
*aIsFramesetFrameSelected = currentFocusWin != nullptr;
return NS_OK;
}
//----------------------------------------------------------------------------------
/* readonly attribute long printPreviewNumPages; */
NS_IMETHODIMP
nsPrintEngine::GetPrintPreviewNumPages(int32_t *aPrintPreviewNumPages)
{
NS_ENSURE_ARG_POINTER(aPrintPreviewNumPages);
nsPrintData* prt = nullptr;
nsIFrame* seqFrame = nullptr;
*aPrintPreviewNumPages = 0;
// When calling this function, the FinishPrintPreview() function might not
// been called as there are still some
if (mPrtPreview) {
prt = mPrtPreview;
} else {
prt = mPrt;
}
if ((!prt) ||
NS_FAILED(GetSeqFrameAndCountPagesInternal(prt->mPrintObject, seqFrame, *aPrintPreviewNumPages))) {
return NS_ERROR_FAILURE;
}
return NS_OK;
}
//----------------------------------------------------------------------------------
// Enumerate all the documents for their titles
NS_IMETHODIMP
nsPrintEngine::EnumerateDocumentNames(uint32_t* aCount,
PRUnichar*** aResult)
{
NS_ENSURE_ARG(aCount);
NS_ENSURE_ARG_POINTER(aResult);
*aCount = 0;
*aResult = nullptr;
int32_t numDocs = mPrt->mPrintDocList.Length();
PRUnichar** array = (PRUnichar**) nsMemory::Alloc(numDocs * sizeof(PRUnichar*));
if (!array)
return NS_ERROR_OUT_OF_MEMORY;
for (int32_t i=0;i<numDocs;i++) {
nsPrintObject* po = mPrt->mPrintDocList.ElementAt(i);
NS_ASSERTION(po, "nsPrintObject can't be null!");
PRUnichar * docTitleStr;
PRUnichar * docURLStr;
GetDocumentTitleAndURL(po->mDocument, &docTitleStr, &docURLStr);
// Use the URL if the doc is empty
if (!docTitleStr || !*docTitleStr) {
if (docURLStr && *docURLStr) {
nsMemory::Free(docTitleStr);
docTitleStr = docURLStr;
} else {
nsMemory::Free(docURLStr);
}
docURLStr = nullptr;
if (!docTitleStr || !*docTitleStr) {
CleanupDocTitleArray(array, i);
return NS_ERROR_OUT_OF_MEMORY;
}
}
array[i] = docTitleStr;
if (docURLStr) nsMemory::Free(docURLStr);
}
*aCount = numDocs;
*aResult = array;
return NS_OK;
}
//----------------------------------------------------------------------------------
/* readonly attribute nsIPrintSettings globalPrintSettings; */
nsresult
nsPrintEngine::GetGlobalPrintSettings(nsIPrintSettings **aGlobalPrintSettings)
{
NS_ENSURE_ARG_POINTER(aGlobalPrintSettings);
nsresult rv = NS_ERROR_FAILURE;
nsCOMPtr<nsIPrintSettingsService> printSettingsService =
do_GetService(sPrintSettingsServiceContractID, &rv);
if (NS_SUCCEEDED(rv)) {
rv = printSettingsService->GetGlobalPrintSettings(aGlobalPrintSettings);
}
return rv;
}
//----------------------------------------------------------------------------------
/* readonly attribute boolean doingPrint; */
NS_IMETHODIMP
nsPrintEngine::GetDoingPrint(bool *aDoingPrint)
{
NS_ENSURE_ARG_POINTER(aDoingPrint);
*aDoingPrint = mIsDoingPrinting;
return NS_OK;
}
//----------------------------------------------------------------------------------
/* readonly attribute boolean doingPrintPreview; */
NS_IMETHODIMP
nsPrintEngine::GetDoingPrintPreview(bool *aDoingPrintPreview)
{
NS_ENSURE_ARG_POINTER(aDoingPrintPreview);
*aDoingPrintPreview = mIsDoingPrintPreview;
return NS_OK;
}
//----------------------------------------------------------------------------------
/* readonly attribute nsIPrintSettings currentPrintSettings; */
NS_IMETHODIMP
nsPrintEngine::GetCurrentPrintSettings(nsIPrintSettings * *aCurrentPrintSettings)
{
NS_ENSURE_ARG_POINTER(aCurrentPrintSettings);
if (mPrt) {
*aCurrentPrintSettings = mPrt->mPrintSettings;
} else if (mPrtPreview) {
*aCurrentPrintSettings = mPrtPreview->mPrintSettings;
} else {
*aCurrentPrintSettings = nullptr;
}
NS_IF_ADDREF(*aCurrentPrintSettings);
return NS_OK;
}
//-----------------------------------------------------------------
//-- Section: Pre-Reflow Methods
//-----------------------------------------------------------------
//---------------------------------------------------------------------
// This method checks to see if there is at least one printer defined
// and if so, it sets the first printer in the list as the default name
// in the PrintSettings which is then used for Printer Preview
nsresult
nsPrintEngine::CheckForPrinters(nsIPrintSettings* aPrintSettings)
{
#if defined(XP_MACOSX) || defined(ANDROID)
// Mac doesn't support retrieving a printer list.
return NS_OK;
#else
NS_ENSURE_ARG_POINTER(aPrintSettings);
// See if aPrintSettings already has a printer
nsXPIDLString printerName;
nsresult rv = aPrintSettings->GetPrinterName(getter_Copies(printerName));
if (NS_SUCCEEDED(rv) && !printerName.IsEmpty()) {
return NS_OK;
}
// aPrintSettings doesn't have a printer set. Try to fetch the default.
nsCOMPtr<nsIPrintSettingsService> printSettingsService =
do_GetService(sPrintSettingsServiceContractID, &rv);
NS_ENSURE_SUCCESS(rv, rv);
rv = printSettingsService->GetDefaultPrinterName(getter_Copies(printerName));
if (NS_SUCCEEDED(rv) && !printerName.IsEmpty()) {
rv = aPrintSettings->SetPrinterName(printerName.get());
}
return rv;
#endif
}
//----------------------------------------------------------------------
// Set up to use the "pluggable" Print Progress Dialog
void
nsPrintEngine::ShowPrintProgress(bool aIsForPrinting, bool& aDoNotify)
{
// default to not notifying, that if something here goes wrong
// or we aren't going to show the progress dialog we can straight into
// reflowing the doc for printing.
aDoNotify = false;
// Assume we can't do progress and then see if we can
bool showProgresssDialog = false;
// if it is already being shown then don't bother to find out if it should be
// so skip this and leave mShowProgressDialog set to FALSE
if (!mProgressDialogIsShown) {
showProgresssDialog = Preferences::GetBool("print.show_print_progress");
}
// Turning off the showing of Print Progress in Prefs overrides
// whether the calling PS desire to have it on or off, so only check PS if
// prefs says it's ok to be on.
if (showProgresssDialog) {
mPrt->mPrintSettings->GetShowPrintProgress(&showProgresssDialog);
}
// Now open the service to get the progress dialog
// If we don't get a service, that's ok, then just don't show progress
if (showProgresssDialog) {
nsCOMPtr<nsIPrintingPromptService> printPromptService(do_GetService(kPrintingPromptService));
if (printPromptService) {
nsPIDOMWindow *domWin = mDocument->GetWindow();
if (!domWin) return;
nsCOMPtr<nsIDocShell> docShell = domWin->GetDocShell();
if (!docShell) return;
nsCOMPtr<nsIDocShellTreeOwner> owner;
docShell->GetTreeOwner(getter_AddRefs(owner));
nsCOMPtr<nsIWebBrowserChrome> browserChrome = do_GetInterface(owner);
if (!browserChrome) return;
bool isModal = true;
browserChrome->IsWindowModal(&isModal);
if (isModal) {
// Showing a print progress dialog when printing a modal window
// isn't supported. See bug 301560.
return;
}
nsCOMPtr<nsIWebProgressListener> printProgressListener;
nsCOMPtr<nsIWebBrowserPrint> wbp(do_QueryInterface(mDocViewerPrint));
nsresult rv = printPromptService->ShowProgress(domWin, wbp, mPrt->mPrintSettings, this, aIsForPrinting,
getter_AddRefs(printProgressListener),
getter_AddRefs(mPrt->mPrintProgressParams),
&aDoNotify);
if (NS_SUCCEEDED(rv)) {
if (printProgressListener && mPrt->mPrintProgressParams) {
mPrt->mPrintProgressListeners.AppendObject(printProgressListener);
SetDocAndURLIntoProgress(mPrt->mPrintObject, mPrt->mPrintProgressParams);
}
}
}
}
}
//---------------------------------------------------------------------
bool
nsPrintEngine::IsThereARangeSelection(nsIDOMWindow* aDOMWin)
{
if (mDisallowSelectionPrint)
return false;
nsCOMPtr<nsIPresShell> presShell;
if (aDOMWin) {
nsCOMPtr<nsPIDOMWindow> window(do_QueryInterface(aDOMWin));
presShell = window->GetDocShell()->GetPresShell();
}
if (!presShell)
return false;
// check here to see if there is a range selection
// so we know whether to turn on the "Selection" radio button
Selection* selection =
presShell->GetCurrentSelection(nsISelectionController::SELECTION_NORMAL);
if (!selection) {
return false;
}
int32_t rangeCount = selection->GetRangeCount();
if (!rangeCount) {
return false;
}
if (rangeCount > 1) {
return true;
}
// check to make sure it isn't an insertion selection
return selection->GetRangeAt(0) && !selection->IsCollapsed();
}
//---------------------------------------------------------------------
bool
nsPrintEngine::IsParentAFrameSet(nsIDocShell * aParent)
{
// See if the incoming doc is the root document
if (!aParent) return false;
// When it is the top level document we need to check
// to see if it contains a frameset. If it does, then
// we only want to print the doc's children and not the document itself
// For anything else we always print all the children and the document
// for example, if the doc contains an IFRAME we eant to print the child
// document (the IFRAME) and then the rest of the document.
//
// XXX we really need to search the frame tree, and not the content
// but there is no way to distinguish between IFRAMEs and FRAMEs
// with the GetFrameType call.
// Bug 53459 has been files so we can eventually distinguish
// between IFRAME frames and FRAME frames
bool isFrameSet = false;
// only check to see if there is a frameset if there is
// NO parent doc for this doc. meaning this parent is the root doc
nsCOMPtr<nsIDOMDocument> domDoc = do_GetInterface(aParent);
nsCOMPtr<nsIDocument> doc = do_QueryInterface(domDoc);
if (doc) {
nsIContent *rootElement = doc->GetRootElement();
if (rootElement) {
isFrameSet = HasFramesetChild(rootElement);
}
}
return isFrameSet;
}
//---------------------------------------------------------------------
// Recursively build a list of sub documents to be printed
// that mirrors the document tree
void
nsPrintEngine::BuildDocTree(nsIDocShellTreeNode * aParentNode,
nsTArray<nsPrintObject*> * aDocList,
nsPrintObject * aPO)
{
NS_ASSERTION(aParentNode, "Pointer is null!");
NS_ASSERTION(aDocList, "Pointer is null!");
NS_ASSERTION(aPO, "Pointer is null!");
int32_t childWebshellCount;
aParentNode->GetChildCount(&childWebshellCount);
if (childWebshellCount > 0) {
for (int32_t i=0;i<childWebshellCount;i++) {
nsCOMPtr<nsIDocShellTreeItem> child;
aParentNode->GetChildAt(i, getter_AddRefs(child));
nsCOMPtr<nsIDocShell> childAsShell(do_QueryInterface(child));
nsCOMPtr<nsIContentViewer> viewer;
childAsShell->GetContentViewer(getter_AddRefs(viewer));
if (viewer) {
nsCOMPtr<nsIContentViewerFile> viewerFile(do_QueryInterface(viewer));
if (viewerFile) {
nsCOMPtr<nsIDocShell> childDocShell(do_QueryInterface(child));
nsCOMPtr<nsIDocShellTreeNode> childNode(do_QueryInterface(child));
nsCOMPtr<nsIDOMDocument> doc = do_GetInterface(childDocShell);
nsPrintObject * po = new nsPrintObject();
po->mParent = aPO;
nsresult rv = po->Init(childDocShell, doc, aPO->mPrintPreview);
if (NS_FAILED(rv))
NS_NOTREACHED("Init failed?");
aPO->mKids.AppendElement(po);
aDocList->AppendElement(po);
BuildDocTree(childNode, aDocList, po);
}
}
}
}
}
//---------------------------------------------------------------------
void
nsPrintEngine::GetDocumentTitleAndURL(nsIDocument* aDoc,
PRUnichar** aTitle,
PRUnichar** aURLStr)
{
NS_ASSERTION(aDoc, "Pointer is null!");
NS_ASSERTION(aTitle, "Pointer is null!");
NS_ASSERTION(aURLStr, "Pointer is null!");
*aTitle = nullptr;
*aURLStr = nullptr;
nsAutoString docTitle;
nsCOMPtr<nsIDOMDocument> doc = do_QueryInterface(aDoc);
doc->GetTitle(docTitle);
if (!docTitle.IsEmpty()) {
*aTitle = ToNewUnicode(docTitle);
}
nsIURI* url = aDoc->GetDocumentURI();
if (!url) return;
nsCOMPtr<nsIURIFixup> urifixup(do_GetService(NS_URIFIXUP_CONTRACTID));
if (!urifixup) return;
nsCOMPtr<nsIURI> exposableURI;
urifixup->CreateExposableURI(url, getter_AddRefs(exposableURI));
if (!exposableURI) return;
nsAutoCString urlCStr;
exposableURI->GetSpec(urlCStr);
nsresult rv;
nsCOMPtr<nsITextToSubURI> textToSubURI =
do_GetService(NS_ITEXTTOSUBURI_CONTRACTID, &rv);
if (NS_FAILED(rv)) return;
nsAutoString unescapedURI;
rv = textToSubURI->UnEscapeURIForUI(NS_LITERAL_CSTRING("UTF-8"),
urlCStr, unescapedURI);
if (NS_FAILED(rv)) return;
*aURLStr = ToNewUnicode(unescapedURI);
}
//---------------------------------------------------------------------
// The walks the PO tree and for each document it walks the content
// tree looking for any content that are sub-shells
//
// It then sets the mContent pointer in the "found" PO object back to the
// the document that contained it.
void
nsPrintEngine::MapContentToWebShells(nsPrintObject* aRootPO,
nsPrintObject* aPO)
{
NS_ASSERTION(aRootPO, "Pointer is null!");
NS_ASSERTION(aPO, "Pointer is null!");
// Recursively walk the content from the root item
// XXX Would be faster to enumerate the subdocuments, although right now
// nsIDocument doesn't expose quite what would be needed.
nsCOMPtr<nsIContentViewer> viewer;
aPO->mDocShell->GetContentViewer(getter_AddRefs(viewer));
if (!viewer) return;
nsCOMPtr<nsIDOMDocument> domDoc;
viewer->GetDOMDocument(getter_AddRefs(domDoc));
nsCOMPtr<nsIDocument> doc = do_QueryInterface(domDoc);
if (!doc) return;
Element* rootElement = doc->GetRootElement();
if (rootElement) {
MapContentForPO(aPO, rootElement);
} else {
NS_WARNING("Null root content on (sub)document.");
}
// Continue recursively walking the chilren of this PO
for (uint32_t i=0;i<aPO->mKids.Length();i++) {
MapContentToWebShells(aRootPO, aPO->mKids[i]);
}
}
//-------------------------------------------------------
// A Frame's sub-doc may contain content or a FrameSet
// When it contains a FrameSet the mFrameType for the PrintObject
// is always set to an eFrame. Which is fine when printing "AsIs"
// but is incorrect when when printing "Each Frame Separately".
// When printing "Each Frame Separately" the Frame really acts like
// a frameset.
//
// This method walks the PO tree and checks to see if the PrintObject is
// an eFrame and has children that are eFrames (meaning it's a Frame containing a FrameSet)
// If so, then the mFrameType need to be changed to eFrameSet
//
// Also note: We only want to call this we are printing "Each Frame Separately"
// when printing "As Is" leave it as an eFrame
void
nsPrintEngine::CheckForChildFrameSets(nsPrintObject* aPO)
{
NS_ASSERTION(aPO, "Pointer is null!");
// Continue recursively walking the chilren of this PO
bool hasChildFrames = false;
for (uint32_t i=0;i<aPO->mKids.Length();i++) {
nsPrintObject* po = aPO->mKids[i];
if (po->mFrameType == eFrame) {
hasChildFrames = true;
CheckForChildFrameSets(po);
}
}
if (hasChildFrames && aPO->mFrameType == eFrame) {
aPO->mFrameType = eFrameSet;
}
}
//---------------------------------------------------------------------
// This method is key to the entire print mechanism.
//
// This "maps" or figures out which sub-doc represents a
// given Frame or IFrame in its parent sub-doc.
//
// So the Mcontent pointer in the child sub-doc points to the
// content in the its parent document, that caused it to be printed.
// This is used later to (after reflow) to find the absolute location
// of the sub-doc on its parent's page frame so it can be
// printed in the correct location.
//
// This method recursvely "walks" the content for a document finding
// all the Frames and IFrames, then sets the "mFrameType" data member
// which tells us what type of PO we have
void
nsPrintEngine::MapContentForPO(nsPrintObject* aPO,
nsIContent* aContent)
{
NS_PRECONDITION(aPO && aContent, "Null argument");
nsIDocument* doc = aContent->GetDocument();
NS_ASSERTION(doc, "Content without a document from a document tree?");
nsIDocument* subDoc = doc->GetSubDocumentFor(aContent);
if (subDoc) {
nsCOMPtr<nsISupports> container = subDoc->GetContainer();
nsCOMPtr<nsIDocShell> docShell(do_QueryInterface(container));
if (docShell) {
nsPrintObject * po = nullptr;
int32_t cnt = aPO->mKids.Length();
for (int32_t i=0;i<cnt;i++) {
nsPrintObject* kid = aPO->mKids.ElementAt(i);
if (kid->mDocument == subDoc) {
po = kid;
break;
}
}
// XXX If a subdocument has no onscreen presentation, there will be no PO
// This is even if there should be a print presentation
if (po) {
nsCOMPtr<nsIDOMHTMLFrameElement> frame(do_QueryInterface(aContent));
// "frame" elements not in a frameset context should be treated
// as iframes
if (frame && po->mParent->mFrameType == eFrameSet) {
po->mFrameType = eFrame;
} else {
// Assume something iframe-like, i.e. iframe, object, or embed
po->mFrameType = eIFrame;
SetPrintAsIs(po, true);
NS_ASSERTION(po->mParent, "The root must be a parent");
po->mParent->mPrintAsIs = true;
}
}
}
}
// walk children content
for (nsIContent* child = aContent->GetFirstChild();
child;
child = child->GetNextSibling()) {
MapContentForPO(aPO, child);
}
}
//---------------------------------------------------------------------
bool
nsPrintEngine::IsThereAnIFrameSelected(nsIDocShell* aDocShell,
nsIDOMWindow* aDOMWin,
bool& aIsParentFrameSet)
{
aIsParentFrameSet = IsParentAFrameSet(aDocShell);
bool iFrameIsSelected = false;
if (mPrt && mPrt->mPrintObject) {
nsPrintObject* po = FindPrintObjectByDOMWin(mPrt->mPrintObject, aDOMWin);
iFrameIsSelected = po && po->mFrameType == eIFrame;
} else {
// First, check to see if we are a frameset
if (!aIsParentFrameSet) {
// Check to see if there is a currenlt focused frame
// if so, it means the selected frame is either the main docshell
// or an IFRAME
if (aDOMWin) {
// Get the main docshell's DOMWin to see if it matches
// the frame that is selected
nsCOMPtr<nsIDOMWindow> domWin = do_GetInterface(aDocShell);
if (domWin != aDOMWin) {
iFrameIsSelected = true; // we have a selected IFRAME
}
}
}
}
return iFrameIsSelected;
}
//---------------------------------------------------------------------
// Recursively sets all the PO items to be printed
// from the given item down into the tree
void
nsPrintEngine::SetPrintPO(nsPrintObject* aPO, bool aPrint)
{
NS_ASSERTION(aPO, "Pointer is null!");
// Set whether to print flag
aPO->mDontPrint = !aPrint;
for (uint32_t i=0;i<aPO->mKids.Length();i++) {
SetPrintPO(aPO->mKids[i], aPrint);
}
}
//---------------------------------------------------------------------
// This will first use a Title and/or URL from the PrintSettings
// if one isn't set then it uses the one from the document
// then if not title is there we will make sure we send something back
// depending on the situation.
void
nsPrintEngine::GetDisplayTitleAndURL(nsPrintObject* aPO,
PRUnichar** aTitle,
PRUnichar** aURLStr,
eDocTitleDefault aDefType)
{
NS_ASSERTION(aPO, "Pointer is null!");
NS_ASSERTION(aTitle, "Pointer is null!");
NS_ASSERTION(aURLStr, "Pointer is null!");
*aTitle = nullptr;
*aURLStr = nullptr;
if (!mPrt)
return;
// First check to see if the PrintSettings has defined an alternate title
// and use that if it did
PRUnichar * docTitleStrPS = nullptr;
PRUnichar * docURLStrPS = nullptr;
if (mPrt->mPrintSettings) {
mPrt->mPrintSettings->GetTitle(&docTitleStrPS);
mPrt->mPrintSettings->GetDocURL(&docURLStrPS);
if (docTitleStrPS && *docTitleStrPS) {
*aTitle = docTitleStrPS;
}
if (docURLStrPS && *docURLStrPS) {
*aURLStr = docURLStrPS;
}
// short circut
if (docTitleStrPS && docURLStrPS) {
return;
}
}
PRUnichar* docTitle;
PRUnichar* docUrl;
GetDocumentTitleAndURL(aPO->mDocument, &docTitle, &docUrl);
if (docUrl) {
if (!docURLStrPS)
*aURLStr = docUrl;
else
nsMemory::Free(docUrl);
}
if (docTitle) {
if (!docTitleStrPS)
*aTitle = docTitle;
else
nsMemory::Free(docTitle);
} else if (!docTitleStrPS) {
switch (aDefType) {
case eDocTitleDefBlank: *aTitle = ToNewUnicode(EmptyString());
break;
case eDocTitleDefURLDoc:
if (*aURLStr) {
*aTitle = NS_strdup(*aURLStr);
} else if (mPrt->mBrandName) {
*aTitle = NS_strdup(mPrt->mBrandName);
}
break;
case eDocTitleDefNone:
// *aTitle defaults to nullptr
break;
}
}
}
//---------------------------------------------------------------------
nsresult nsPrintEngine::DocumentReadyForPrinting()
{
if (mPrt->mPrintFrameType == nsIPrintSettings::kEachFrameSep) {
CheckForChildFrameSets(mPrt->mPrintObject);
}
//
// Send the document to the printer...
//
nsresult rv = SetupToPrintContent();
if (NS_FAILED(rv)) {
// The print job was canceled or there was a problem
// So remove all other documents from the print list
DonePrintingPages(nullptr, rv);
}
return rv;
}
/** ---------------------------------------------------
* Cleans up when an error occurred
*/
nsresult nsPrintEngine::CleanupOnFailure(nsresult aResult, bool aIsPrinting)
{
PR_PL(("**** Failed %s - rv 0x%X", aIsPrinting?"Printing":"Print Preview", aResult));
/* cleanup... */
if (mPagePrintTimer) {
mPagePrintTimer->Stop();
NS_RELEASE(mPagePrintTimer);
}
if (aIsPrinting) {
SetIsPrinting(false);
} else {
SetIsPrintPreview(false);
SetIsCreatingPrintPreview(false);
}
/* cleanup done, let's fire-up an error dialog to notify the user
* what went wrong...
*
* When rv == NS_ERROR_ABORT, it means we want out of the
* print job without displaying any error messages
*/
if (aResult != NS_ERROR_ABORT) {
ShowPrintErrorDialog(aResult, aIsPrinting);
}
FirePrintCompletionEvent();
return aResult;
}
//---------------------------------------------------------------------
void
nsPrintEngine::ShowPrintErrorDialog(nsresult aPrintError, bool aIsPrinting)
{
nsAutoCString stringName;
nsXPIDLString msg, title;
nsresult rv = NS_OK;
switch(aPrintError)
{
#define ENTITY_FOR_ERROR(label) \
case NS_ERROR_##label: stringName.AssignLiteral("PERR_" #label); break
ENTITY_FOR_ERROR(GFX_PRINTER_NO_PRINTER_AVAILABLE);
ENTITY_FOR_ERROR(GFX_PRINTER_NAME_NOT_FOUND);
ENTITY_FOR_ERROR(GFX_PRINTER_COULD_NOT_OPEN_FILE);
ENTITY_FOR_ERROR(GFX_PRINTER_STARTDOC);
ENTITY_FOR_ERROR(GFX_PRINTER_ENDDOC);
ENTITY_FOR_ERROR(GFX_PRINTER_STARTPAGE);
ENTITY_FOR_ERROR(GFX_PRINTER_DOC_IS_BUSY);
ENTITY_FOR_ERROR(GFX_PRINTER_NO_XUL); // bug 136185 / bug 240490
ENTITY_FOR_ERROR(ABORT);
ENTITY_FOR_ERROR(NOT_AVAILABLE);
ENTITY_FOR_ERROR(NOT_IMPLEMENTED);
ENTITY_FOR_ERROR(OUT_OF_MEMORY);
ENTITY_FOR_ERROR(UNEXPECTED);
default:
ENTITY_FOR_ERROR(FAILURE);
#undef ENTITY_FOR_ERROR
}
if (!aIsPrinting) {
// Try first with _PP suffix.
stringName.AppendLiteral("_PP");
rv = nsContentUtils::GetLocalizedString(
nsContentUtils::ePRINTING_PROPERTIES, stringName.get(), msg);
if (NS_FAILED(rv)) {
stringName.Truncate(stringName.Length() - 3);
}
}
if (aIsPrinting || NS_FAILED(rv)) {
rv = nsContentUtils::GetLocalizedString(
nsContentUtils::ePRINTING_PROPERTIES, stringName.get(), msg);
}
if (NS_FAILED(rv)) {
return;
}
rv = nsContentUtils::GetLocalizedString(
nsContentUtils::ePRINTING_PROPERTIES,
aIsPrinting ? "print_error_dialog_title"
: "printpreview_error_dialog_title",
title);
if (NS_FAILED(rv)) {
return;
}
nsCOMPtr<nsIWindowWatcher> wwatch =
do_GetService(NS_WINDOWWATCHER_CONTRACTID, &rv);
if (NS_FAILED(rv)) {
return;
}
nsCOMPtr<nsIDOMWindow> active;
wwatch->GetActiveWindow(getter_AddRefs(active));
nsCOMPtr<nsIPrompt> dialog;
/* |GetNewPrompter| allows that |active| is |nullptr|
* (see bug 234982 ("nsPrintEngine::ShowPrintErrorDialog() fails in many cases")) */
wwatch->GetNewPrompter(active, getter_AddRefs(dialog));
if (!dialog) {
return;
}
dialog->Alert(title.get(), msg.get());
}
//-----------------------------------------------------------------
//-- Section: Reflow Methods
//-----------------------------------------------------------------
nsresult
nsPrintEngine::ReconstructAndReflow(bool doSetPixelScale)
{
#if (defined(XP_WIN) || defined(XP_OS2)) && defined(EXTENDED_DEBUG_PRINTING)
// We need to clear all the output files here
// because they will be re-created with second reflow of the docs
if (kPrintingLogMod && kPrintingLogMod->level == DUMP_LAYOUT_LEVEL) {
RemoveFilesInDir(".\\");
gDumpFileNameCnt = 0;
gDumpLOFileNameCnt = 0;
}
#endif
for (uint32_t i = 0; i < mPrt->mPrintDocList.Length(); ++i) {
nsPrintObject* po = mPrt->mPrintDocList.ElementAt(i);
NS_ASSERTION(po, "nsPrintObject can't be null!");
if (po->mDontPrint || po->mInvisible) {
continue;
}
UpdateZoomRatio(po, doSetPixelScale);
po->mPresContext->SetPageScale(po->mZoomRatio);
// Calculate scale factor from printer to screen
float printDPI = float(mPrt->mPrintDC->AppUnitsPerCSSInch()) /
float(mPrt->mPrintDC->AppUnitsPerDevPixel());
po->mPresContext->SetPrintPreviewScale(mScreenDPI / printDPI);
po->mPresShell->ReconstructFrames();
// For all views except the first one, setup the root view.
// ??? Can there be multiple po for the top-level-document?
bool documentIsTopLevel = true;
if (i != 0) {
nsSize adjSize;
bool doReturn;
nsresult rv = SetRootView(po, doReturn, documentIsTopLevel, adjSize);
MOZ_ASSERT(!documentIsTopLevel, "How could this happen?");
if (NS_FAILED(rv) || doReturn) {
return rv;
}
}
po->mPresShell->FlushPendingNotifications(Flush_Layout);
nsresult rv = UpdateSelectionAndShrinkPrintObject(po, documentIsTopLevel);
NS_ENSURE_SUCCESS(rv, rv);
}
return NS_OK;
}
//-------------------------------------------------------
nsresult
nsPrintEngine::SetupToPrintContent()
{
nsresult rv;
bool didReconstruction = false;
// If some new content got loaded since the initial reflow rebuild
// everything.
if (mDidLoadDataForPrinting) {
rv = ReconstructAndReflow(DoSetPixelScale());
didReconstruction = true;
NS_ENSURE_SUCCESS(rv, rv);
}
// Here is where we figure out if extra reflow for shrinking the content
// is required.
// But skip this step if we are in PrintPreview
bool ppIsShrinkToFit = mPrtPreview && mPrtPreview->mShrinkToFit;
if (mPrt->mShrinkToFit && !ppIsShrinkToFit) {
// Now look for the PO that has the smallest percent for shrink to fit
if (mPrt->mPrintDocList.Length() > 1 && mPrt->mPrintObject->mFrameType == eFrameSet) {
nsPrintObject* smallestPO = FindSmallestSTF();
NS_ASSERTION(smallestPO, "There must always be an XMost PO!");
if (smallestPO) {
// Calc the shrinkage based on the entire content area
mPrt->mShrinkRatio = smallestPO->mShrinkRatio;
}
} else {
// Single document so use the Shrink as calculated for the PO
mPrt->mShrinkRatio = mPrt->mPrintObject->mShrinkRatio;
}
if (mPrt->mShrinkRatio < 0.998f) {
rv = ReconstructAndReflow(true);
didReconstruction = true;
NS_ENSURE_SUCCESS(rv, rv);
}
#ifdef PR_LOGGING
float calcRatio = 0.0f;
if (mPrt->mPrintDocList.Length() > 1 && mPrt->mPrintObject->mFrameType == eFrameSet) {
nsPrintObject* smallestPO = FindSmallestSTF();
NS_ASSERTION(smallestPO, "There must always be an XMost PO!");
if (smallestPO) {
// Calc the shrinkage based on the entire content area
calcRatio = smallestPO->mShrinkRatio;
}
} else {
// Single document so use the Shrink as calculated for the PO
calcRatio = mPrt->mPrintObject->mShrinkRatio;
}
PR_PL(("**************************************************************************\n"));
PR_PL(("STF Ratio is: %8.5f Effective Ratio: %8.5f Diff: %8.5f\n", mPrt->mShrinkRatio, calcRatio, mPrt->mShrinkRatio-calcRatio));
PR_PL(("**************************************************************************\n"));
#endif
}
// If the frames got reconstructed and reflowed the number of pages might
// has changed.
if (didReconstruction) {
FirePrintPreviewUpdateEvent();
}
DUMP_DOC_LIST(("\nAfter Reflow------------------------------------------"));
PR_PL(("\n"));
PR_PL(("-------------------------------------------------------\n"));
PR_PL(("\n"));
CalcNumPrintablePages(mPrt->mNumPrintablePages);
PromoteReflowsToReframeRoot();
PR_PL(("--- Printing %d pages\n", mPrt->mNumPrintablePages));
DUMP_DOC_TREELAYOUT;
// Print listener setup...
if (mPrt != nullptr) {
mPrt->OnStartPrinting();
}
PRUnichar* fileName = nullptr;
// check to see if we are printing to a file
bool isPrintToFile = false;
mPrt->mPrintSettings->GetPrintToFile(&isPrintToFile);
if (isPrintToFile) {
// On some platforms The BeginDocument needs to know the name of the file
// and it uses the PrintService to get it, so we need to set it into the PrintService here
mPrt->mPrintSettings->GetToFileName(&fileName);
}
PRUnichar * docTitleStr;
PRUnichar * docURLStr;
GetDisplayTitleAndURL(mPrt->mPrintObject, &docTitleStr, &docURLStr, eDocTitleDefURLDoc);
int32_t startPage = 1;
int32_t endPage = mPrt->mNumPrintablePages;
int16_t printRangeType = nsIPrintSettings::kRangeAllPages;
mPrt->mPrintSettings->GetPrintRange(&printRangeType);
if (printRangeType == nsIPrintSettings::kRangeSpecifiedPageRange) {
mPrt->mPrintSettings->GetStartPageRange(&startPage);
mPrt->mPrintSettings->GetEndPageRange(&endPage);
if (endPage > mPrt->mNumPrintablePages) {
endPage = mPrt->mNumPrintablePages;
}
}
rv = NS_OK;
// BeginDocument may pass back a FAILURE code
// i.e. On Windows, if you are printing to a file and hit "Cancel"
// to the "File Name" dialog, this comes back as an error
// Don't start printing when regression test are executed
if (!mPrt->mDebugFilePtr && mIsDoingPrinting) {
rv = mPrt->mPrintDC->BeginDocument(docTitleStr, fileName, startPage, endPage);
}
if (mIsCreatingPrintPreview) {
// Print Preview -- Pass ownership of docTitleStr and docURLStr
// to the pageSequenceFrame, to be displayed in the header
nsIPageSequenceFrame *seqFrame = mPrt->mPrintObject->mPresShell->GetPageSequenceFrame();
if (seqFrame) {
seqFrame->StartPrint(mPrt->mPrintObject->mPresContext,
mPrt->mPrintSettings, docTitleStr, docURLStr);
docTitleStr = nullptr;
docURLStr = nullptr;
}
}
if (docTitleStr) nsMemory::Free(docTitleStr);
if (docURLStr) nsMemory::Free(docURLStr);
PR_PL(("****************** Begin Document ************************\n"));
NS_ENSURE_SUCCESS(rv, rv);
// This will print the docshell document
// when it completes asynchronously in the DonePrintingPages method
// it will check to see if there are more docshells to be printed and
// then PrintDocContent will be called again.
if (mIsDoingPrinting) {
PrintDocContent(mPrt->mPrintObject, rv); // ignore return value
}
return rv;
}
//-------------------------------------------------------
// Recursively reflow each sub-doc and then calc
// all the frame locations of the sub-docs
nsresult
nsPrintEngine::ReflowDocList(nsPrintObject* aPO, bool aSetPixelScale)
{
NS_ENSURE_ARG_POINTER(aPO);
// Check to see if the subdocument's element has been hidden by the parent document
if (aPO->mParent && aPO->mParent->mPresShell) {
nsIFrame* frame = aPO->mContent ? aPO->mContent->GetPrimaryFrame() : nullptr;
if (!frame || !frame->StyleVisibility()->IsVisible()) {
SetPrintPO(aPO, false);
aPO->mInvisible = true;
return NS_OK;
}
}
UpdateZoomRatio(aPO, aSetPixelScale);
nsresult rv;
// Reflow the PO
rv = ReflowPrintObject(aPO);
NS_ENSURE_SUCCESS(rv, rv);
int32_t cnt = aPO->mKids.Length();
for (int32_t i=0;i<cnt;i++) {
rv = ReflowDocList(aPO->mKids[i], aSetPixelScale);
NS_ENSURE_SUCCESS(rv, rv);
}
return NS_OK;
}
void
nsPrintEngine::FirePrintPreviewUpdateEvent()
{
// Dispatch the event only while in PrintPreview. When printing, there is no
// listener bound to this event and therefore no need to dispatch it.
if (mIsDoingPrintPreview && !mIsDoingPrinting) {
nsCOMPtr<nsIContentViewer> cv = do_QueryInterface(mDocViewerPrint);
(new nsAsyncDOMEvent(
cv->GetDocument(), NS_LITERAL_STRING("printPreviewUpdate"), true, true)
)->RunDOMEventWhenSafe();
}
}
nsresult
nsPrintEngine::InitPrintDocConstruction(bool aHandleError)
{
nsresult rv;
rv = ReflowDocList(mPrt->mPrintObject, DoSetPixelScale());
NS_ENSURE_SUCCESS(rv, rv);
FirePrintPreviewUpdateEvent();
if (mLoadCounter == 0) {
AfterNetworkPrint(aHandleError);
}
return rv;
}
nsresult
nsPrintEngine::AfterNetworkPrint(bool aHandleError)
{
nsCOMPtr<nsIWebProgress> webProgress = do_QueryInterface(mPrt->mPrintObject->mDocShell);
webProgress->RemoveProgressListener(
static_cast<nsIWebProgressListener*>(this));
nsresult rv;
if (mIsDoingPrinting) {
rv = DocumentReadyForPrinting();
} else {
rv = FinishPrintPreview();
}
/* cleaup on failure + notify user */
if (aHandleError && NS_FAILED(rv)) {
CleanupOnFailure(rv, !mIsDoingPrinting);
}
return rv;
}
////////////////////////////////////////////////////////////////////////////////
// nsIWebProgressListener
NS_IMETHODIMP
nsPrintEngine::OnStateChange(nsIWebProgress* aWebProgress,
nsIRequest* aRequest,
uint32_t aStateFlags,
nsresult aStatus)
{
nsAutoCString name;
aRequest->GetName(name);
if (name.Equals("about:document-onload-blocker")) {
return NS_OK;
}
if (aStateFlags & STATE_START) {
nsCOMPtr<nsIChannel> channel = do_QueryInterface(aRequest);
++mLoadCounter;
} else if (aStateFlags & STATE_STOP) {
mDidLoadDataForPrinting = true;
--mLoadCounter;
// If all resources are loaded, then do a small timeout and if there
// are still no new requests, then another reflow.
if (mLoadCounter == 0) {
AfterNetworkPrint(true);
}
}
return NS_OK;
}
NS_IMETHODIMP
nsPrintEngine::OnProgressChange(nsIWebProgress* aWebProgress,
nsIRequest* aRequest,
int32_t aCurSelfProgress,
int32_t aMaxSelfProgress,
int32_t aCurTotalProgress,
int32_t aMaxTotalProgress)
{
NS_NOTREACHED("notification excluded in AddProgressListener(...)");
return NS_OK;
}
NS_IMETHODIMP
nsPrintEngine::OnLocationChange(nsIWebProgress* aWebProgress,
nsIRequest* aRequest,
nsIURI* aLocation,
uint32_t aFlags)
{
NS_NOTREACHED("notification excluded in AddProgressListener(...)");
return NS_OK;
}
NS_IMETHODIMP
nsPrintEngine::OnStatusChange(nsIWebProgress *aWebProgress,
nsIRequest *aRequest,
nsresult aStatus,
const PRUnichar *aMessage)
{
NS_NOTREACHED("notification excluded in AddProgressListener(...)");
return NS_OK;
}
NS_IMETHODIMP
nsPrintEngine::OnSecurityChange(nsIWebProgress *aWebProgress,
nsIRequest *aRequest,
uint32_t aState)
{
NS_NOTREACHED("notification excluded in AddProgressListener(...)");
return NS_OK;
}
//-------------------------------------------------------
void
nsPrintEngine::UpdateZoomRatio(nsPrintObject* aPO, bool aSetPixelScale)
{
// Here is where we set the shrinkage value into the DC
// and this is what actually makes it shrink
if (aSetPixelScale && aPO->mFrameType != eIFrame) {
float ratio;
if (mPrt->mPrintFrameType == nsIPrintSettings::kFramesAsIs || mPrt->mPrintFrameType == nsIPrintSettings::kNoFrames) {
ratio = mPrt->mShrinkRatio - 0.005f; // round down
} else {
ratio = aPO->mShrinkRatio - 0.005f; // round down
}
aPO->mZoomRatio = ratio;
} else if (!mPrt->mShrinkToFit) {
double scaling;
mPrt->mPrintSettings->GetScaling(&scaling);
aPO->mZoomRatio = float(scaling);
}
}
nsresult
nsPrintEngine::UpdateSelectionAndShrinkPrintObject(nsPrintObject* aPO,
bool aDocumentIsTopLevel)
{
nsCOMPtr<nsIPresShell> displayShell = aPO->mDocShell->GetPresShell();
// Transfer Selection Ranges to the new Print PresShell
nsRefPtr<Selection> selection, selectionPS;
// It's okay if there is no display shell, just skip copying the selection
if (displayShell) {
selection = displayShell->GetCurrentSelection(nsISelectionController::SELECTION_NORMAL);
}
selectionPS = aPO->mPresShell->GetCurrentSelection(nsISelectionController::SELECTION_NORMAL);
// Reset all existing selection ranges that might have been added by calling
// this function before.
if (selectionPS) {
selectionPS->RemoveAllRanges();
}
if (selection && selectionPS) {
int32_t cnt = selection->GetRangeCount();
int32_t inx;
for (inx = 0; inx < cnt; ++inx) {
selectionPS->AddRange(selection->GetRangeAt(inx));
}
}
// If we are trying to shrink the contents to fit on the page
// we must first locate the "pageContent" frame
// Then we walk the frame tree and look for the "xmost" frame
// this is the frame where the right-hand side of the frame extends
// the furthest
if (mPrt->mShrinkToFit && aDocumentIsTopLevel) {
nsIPageSequenceFrame* pageSequence = aPO->mPresShell->GetPageSequenceFrame();
NS_ENSURE_STATE(pageSequence);
pageSequence->GetSTFPercent(aPO->mShrinkRatio);
}
return NS_OK;
}
bool
nsPrintEngine::DoSetPixelScale()
{
// This is an Optimization
// If we are in PP then we already know all the shrinkage information
// so just transfer it to the PrintData and we will skip the extra shrinkage reflow
//
// doSetPixelScale tells Reflow whether to set the shrinkage value into the DC
// The first time we do not want to do this, the second time through we do
bool doSetPixelScale = false;
bool ppIsShrinkToFit = mPrtPreview && mPrtPreview->mShrinkToFit;
if (ppIsShrinkToFit) {
mPrt->mShrinkRatio = mPrtPreview->mShrinkRatio;
doSetPixelScale = true;
}
return doSetPixelScale;
}
nsView*
nsPrintEngine::GetParentViewForRoot()
{
if (mIsCreatingPrintPreview) {
nsCOMPtr<nsIContentViewer> cv = do_QueryInterface(mDocViewerPrint);
if (cv) {
return cv->FindContainerView();
}
}
return nullptr;
}
nsresult
nsPrintEngine::SetRootView(
nsPrintObject* aPO,
bool& doReturn,
bool& documentIsTopLevel,
nsSize& adjSize
)
{
bool canCreateScrollbars = true;
nsView* rootView;
nsView* parentView = nullptr;
doReturn = false;
if (aPO->mParent && aPO->mParent->IsPrintable()) {
nsIFrame* frame = aPO->mContent ? aPO->mContent->GetPrimaryFrame() : nullptr;
// Without a frame, this document can't be displayed; therefore, there is no
// point to reflowing it
if (!frame) {
SetPrintPO(aPO, false);
doReturn = true;
return NS_OK;
}
//XXX If printing supported printing document hierarchies with non-constant
// zoom this would be wrong as we use the same mPrt->mPrintDC for all
// subdocuments.
adjSize = frame->GetContentRect().Size();
documentIsTopLevel = false;
// presshell exists because parent is printable
// the top nsPrintObject's widget will always have scrollbars
if (frame && frame->GetType() == nsGkAtoms::subDocumentFrame) {
nsView* view = frame->GetView();
NS_ENSURE_TRUE(view, NS_ERROR_FAILURE);
view = view->GetFirstChild();
NS_ENSURE_TRUE(view, NS_ERROR_FAILURE);
parentView = view;
canCreateScrollbars = false;
}
} else {
nscoord pageWidth, pageHeight;
mPrt->mPrintDC->GetDeviceSurfaceDimensions(pageWidth, pageHeight);
adjSize = nsSize(pageWidth, pageHeight);
documentIsTopLevel = true;
parentView = GetParentViewForRoot();
}
if (aPO->mViewManager->GetRootView()) {
// Reuse the root view that is already on the root frame.
rootView = aPO->mViewManager->GetRootView();
// Remove it from its existing parent if necessary
aPO->mViewManager->RemoveChild(rootView);
rootView->SetParent(parentView);
} else {
// Create a child window of the parent that is our "root view/window"
nsRect tbounds = nsRect(nsPoint(0, 0), adjSize);
rootView = aPO->mViewManager->CreateView(tbounds, parentView);
NS_ENSURE_TRUE(rootView, NS_ERROR_OUT_OF_MEMORY);
}
if (mIsCreatingPrintPreview && documentIsTopLevel) {
aPO->mPresContext->SetPaginatedScrolling(canCreateScrollbars);
}
// Setup hierarchical relationship in view manager
aPO->mViewManager->SetRootView(rootView);
return NS_OK;
}
// Reflow a nsPrintObject
nsresult
nsPrintEngine::ReflowPrintObject(nsPrintObject * aPO)
{
NS_ENSURE_STATE(aPO);
if (!aPO->IsPrintable()) {
return NS_OK;
}
NS_ASSERTION(!aPO->mPresContext, "Recreating prescontext");
// create the PresContext
nsPresContext::nsPresContextType type =
mIsCreatingPrintPreview ? nsPresContext::eContext_PrintPreview:
nsPresContext::eContext_Print;
nsView* parentView =
aPO->mParent && aPO->mParent->IsPrintable() ? nullptr : GetParentViewForRoot();
aPO->mPresContext = parentView ?
new nsPresContext(aPO->mDocument, type) :
new nsRootPresContext(aPO->mDocument, type);
NS_ENSURE_TRUE(aPO->mPresContext, NS_ERROR_OUT_OF_MEMORY);
aPO->mPresContext->SetPrintSettings(mPrt->mPrintSettings);
// set the presentation context to the value in the print settings
bool printBGColors;
mPrt->mPrintSettings->GetPrintBGColors(&printBGColors);
aPO->mPresContext->SetBackgroundColorDraw(printBGColors);
mPrt->mPrintSettings->GetPrintBGImages(&printBGColors);
aPO->mPresContext->SetBackgroundImageDraw(printBGColors);
// init it with the DC
nsresult rv = aPO->mPresContext->Init(mPrt->mPrintDC);
NS_ENSURE_SUCCESS(rv, rv);
aPO->mViewManager = new nsViewManager();
rv = aPO->mViewManager->Init(mPrt->mPrintDC);
NS_ENSURE_SUCCESS(rv,rv);
nsStyleSet* styleSet;
rv = mDocViewerPrint->CreateStyleSet(aPO->mDocument, &styleSet);
NS_ENSURE_SUCCESS(rv, rv);
aPO->mPresShell = aPO->mDocument->CreateShell(aPO->mPresContext,
aPO->mViewManager, styleSet);
if (!aPO->mPresShell) {
delete styleSet;
return NS_ERROR_FAILURE;
}
styleSet->EndUpdate();
// The pres shell now owns the style set object.
bool doReturn = false;;
bool documentIsTopLevel = false;
nsSize adjSize;
rv = SetRootView(aPO, doReturn, documentIsTopLevel, adjSize);
if (NS_FAILED(rv) || doReturn) {
return rv;
}
PR_PL(("In DV::ReflowPrintObject PO: %p pS: %p (%9s) Setting w,h to %d,%d\n", aPO, aPO->mPresShell.get(),
gFrameTypesStr[aPO->mFrameType], adjSize.width, adjSize.height));
// This docshell stuff is weird; will go away when we stop having multiple
// presentations per document
nsCOMPtr<nsISupports> supps(do_QueryInterface(aPO->mDocShell));
aPO->mPresContext->SetContainer(supps);
aPO->mPresShell->BeginObservingDocument();
aPO->mPresContext->SetPageSize(adjSize);
aPO->mPresContext->SetIsRootPaginatedDocument(documentIsTopLevel);
aPO->mPresContext->SetPageScale(aPO->mZoomRatio);
// Calculate scale factor from printer to screen
float printDPI = float(mPrt->mPrintDC->AppUnitsPerCSSInch()) /
float(mPrt->mPrintDC->AppUnitsPerDevPixel());
aPO->mPresContext->SetPrintPreviewScale(mScreenDPI / printDPI);
if (mIsCreatingPrintPreview && documentIsTopLevel) {
mDocViewerPrint->SetPrintPreviewPresentation(aPO->mViewManager,
aPO->mPresContext,
aPO->mPresShell);
}
rv = aPO->mPresShell->Initialize(adjSize.width, adjSize.height);
NS_ENSURE_SUCCESS(rv, rv);
NS_ASSERTION(aPO->mPresShell, "Presshell should still be here");
// Process the reflow event Initialize posted
aPO->mPresShell->FlushPendingNotifications(Flush_Layout);
rv = UpdateSelectionAndShrinkPrintObject(aPO, documentIsTopLevel);
NS_ENSURE_SUCCESS(rv, rv);
#ifdef EXTENDED_DEBUG_PRINTING
if (kPrintingLogMod && kPrintingLogMod->level == DUMP_LAYOUT_LEVEL) {
char * docStr;
char * urlStr;
GetDocTitleAndURL(aPO, docStr, urlStr);
char filename[256];
sprintf(filename, "print_dump_%d.txt", gDumpFileNameCnt++);
// Dump all the frames and view to a a file
FILE * fd = fopen(filename, "w");
if (fd) {
nsIFrame *theRootFrame =
aPO->mPresShell->FrameManager()->GetRootFrame();
fprintf(fd, "Title: %s\n", docStr?docStr:"");
fprintf(fd, "URL: %s\n", urlStr?urlStr:"");
fprintf(fd, "--------------- Frames ----------------\n");
nsRefPtr<nsRenderingContext> renderingContext;
mPrt->mPrintDocDC->CreateRenderingContext(*getter_AddRefs(renderingContext));
RootFrameList(aPO->mPresContext, fd, 0);
//DumpFrames(fd, aPO->mPresContext, renderingContext, theRootFrame, 0);
fprintf(fd, "---------------------------------------\n\n");
fprintf(fd, "--------------- Views From Root Frame----------------\n");
nsView* v = theRootFrame->GetView();
if (v) {
v->List(fd);
} else {
printf("View is null!\n");
}
if (docShell) {
fprintf(fd, "--------------- All Views ----------------\n");
DumpViews(docShell, fd);
fprintf(fd, "---------------------------------------\n\n");
}
fclose(fd);
}
if (docStr) nsMemory::Free(docStr);
if (urlStr) nsMemory::Free(urlStr);
}
#endif
return NS_OK;
}
//-------------------------------------------------------
// Figure out how many documents and how many total pages we are printing
void
nsPrintEngine::CalcNumPrintablePages(int32_t& aNumPages)
{
aNumPages = 0;
// Count the number of printable documents
// and printable pages
for (uint32_t i=0; i<mPrt->mPrintDocList.Length(); i++) {
nsPrintObject* po = mPrt->mPrintDocList.ElementAt(i);
NS_ASSERTION(po, "nsPrintObject can't be null!");
if (po->mPresContext && po->mPresContext->IsRootPaginatedDocument()) {
nsIPageSequenceFrame* pageSequence = po->mPresShell->GetPageSequenceFrame();
nsIFrame * seqFrame = do_QueryFrame(pageSequence);
if (seqFrame) {
nsIFrame* frame = seqFrame->GetFirstPrincipalChild();
while (frame) {
aNumPages++;
frame = frame->GetNextSibling();
}
}
}
}
}
void
nsPrintEngine::PromoteReflowsToReframeRoot()
{
for (uint32_t i=0; i<mPrt->mPrintDocList.Length(); i++) {
nsPrintObject* po = mPrt->mPrintDocList.ElementAt(i);
NS_ASSERTION(po, "nsPrintObject can't be null!");
if (po->mPresContext) {
po->mPresContext->RestyleManager()->SetPromoteReflowsToReframeRoot(true);
}
}
}
//-----------------------------------------------------------------
//-- Done: Reflow Methods
//-----------------------------------------------------------------
//-----------------------------------------------------------------
//-- Section: Printing Methods
//-----------------------------------------------------------------
//-------------------------------------------------------
// Called for each DocShell that needs to be printed
bool
nsPrintEngine::PrintDocContent(nsPrintObject* aPO, nsresult& aStatus)
{
NS_ASSERTION(aPO, "Pointer is null!");
aStatus = NS_OK;
if (!aPO->mHasBeenPrinted && aPO->IsPrintable()) {
aStatus = DoPrint(aPO);
return true;
}
// If |aPO->mPrintAsIs| and |aPO->mHasBeenPrinted| are true,
// the kids frames are already processed in |PrintPage|.
if (!aPO->mInvisible && !(aPO->mPrintAsIs && aPO->mHasBeenPrinted)) {
for (uint32_t i=0;i<aPO->mKids.Length();i++) {
nsPrintObject* po = aPO->mKids[i];
bool printed = PrintDocContent(po, aStatus);
if (printed || NS_FAILED(aStatus)) {
return true;
}
}
}
return false;
}
static already_AddRefed<nsIDOMNode>
GetEqualNodeInCloneTree(nsIDOMNode* aNode, nsIDocument* aDoc)
{
nsCOMPtr<nsIContent> content = do_QueryInterface(aNode);
// Selections in anonymous subtrees aren't supported.
if (content && content->IsInAnonymousSubtree()) {
return nullptr;
}
nsCOMPtr<nsINode> node = do_QueryInterface(aNode);
NS_ENSURE_TRUE(node, nullptr);
nsTArray<int32_t> indexArray;
nsINode* current = node;
NS_ENSURE_TRUE(current, nullptr);
while (current) {
nsINode* parent = current->GetParentNode();
if (!parent) {
break;
}
int32_t index = parent->IndexOf(current);
NS_ENSURE_TRUE(index >= 0, nullptr);
indexArray.AppendElement(index);
current = parent;
}
NS_ENSURE_TRUE(current->IsNodeOfType(nsINode::eDOCUMENT), nullptr);
current = aDoc;
for (int32_t i = indexArray.Length() - 1; i >= 0; --i) {
current = current->GetChildAt(indexArray[i]);
NS_ENSURE_TRUE(current, nullptr);
}
nsCOMPtr<nsIDOMNode> result = do_QueryInterface(current);
return result.forget();
}
static void
CloneRangeToSelection(nsRange* aRange, nsIDocument* aDoc,
Selection* aSelection)
{
if (aRange->Collapsed()) {
return;
}
nsCOMPtr<nsIDOMNode> startContainer, endContainer;
aRange->GetStartContainer(getter_AddRefs(startContainer));
int32_t startOffset = aRange->StartOffset();
aRange->GetEndContainer(getter_AddRefs(endContainer));
int32_t endOffset = aRange->EndOffset();
NS_ENSURE_TRUE_VOID(startContainer && endContainer);
nsCOMPtr<nsIDOMNode> newStart = GetEqualNodeInCloneTree(startContainer, aDoc);
nsCOMPtr<nsIDOMNode> newEnd = GetEqualNodeInCloneTree(endContainer, aDoc);
NS_ENSURE_TRUE_VOID(newStart && newEnd);
nsCOMPtr<nsINode> newStartNode = do_QueryInterface(newStart);
NS_ENSURE_TRUE_VOID(newStartNode);
nsRefPtr<nsRange> range = new nsRange(newStartNode);
nsresult rv = range->SetStart(newStartNode, startOffset);
NS_ENSURE_SUCCESS_VOID(rv);
rv = range->SetEnd(newEnd, endOffset);
NS_ENSURE_SUCCESS_VOID(rv);
aSelection->AddRange(range);
}
static nsresult CloneSelection(nsIDocument* aOrigDoc, nsIDocument* aDoc)
{
nsIPresShell* origShell = aOrigDoc->GetShell();
nsIPresShell* shell = aDoc->GetShell();
NS_ENSURE_STATE(origShell && shell);
nsRefPtr<Selection> origSelection =
origShell->GetCurrentSelection(nsISelectionController::SELECTION_NORMAL);
nsRefPtr<Selection> selection =
shell->GetCurrentSelection(nsISelectionController::SELECTION_NORMAL);
NS_ENSURE_STATE(origSelection && selection);
int32_t rangeCount = origSelection->GetRangeCount();
for (int32_t i = 0; i < rangeCount; ++i) {
CloneRangeToSelection(origSelection->GetRangeAt(i), aDoc, selection);
}
return NS_OK;
}
//-------------------------------------------------------
nsresult
nsPrintEngine::DoPrint(nsPrintObject * aPO)
{
PR_PL(("\n"));
PR_PL(("**************************** %s ****************************\n", gFrameTypesStr[aPO->mFrameType]));
PR_PL(("****** In DV::DoPrint PO: %p \n", aPO));
nsIPresShell* poPresShell = aPO->mPresShell;
nsPresContext* poPresContext = aPO->mPresContext;
NS_ASSERTION(poPresContext, "PrintObject has not been reflowed");
NS_ASSERTION(poPresContext->Type() != nsPresContext::eContext_PrintPreview,
"How did this context end up here?");
if (mPrt->mPrintProgressParams) {
SetDocAndURLIntoProgress(aPO, mPrt->mPrintProgressParams);
}
{
int16_t printRangeType = nsIPrintSettings::kRangeAllPages;
nsresult rv;
if (mPrt->mPrintSettings != nullptr) {
mPrt->mPrintSettings->GetPrintRange(&printRangeType);
}
// Ask the page sequence frame to print all the pages
nsIPageSequenceFrame* pageSequence = poPresShell->GetPageSequenceFrame();
NS_ASSERTION(nullptr != pageSequence, "no page sequence frame");
// We are done preparing for printing, so we can turn this off
mPrt->mPreparingForPrint = false;
// mPrt->mDebugFilePtr this is onlu non-null when compiled for debugging
if (nullptr != mPrt->mDebugFilePtr) {
#ifdef DEBUG
// output the regression test
nsIFrame* root = poPresShell->FrameManager()->GetRootFrame();
root->DumpRegressionData(poPresContext, mPrt->mDebugFilePtr, 0);
fclose(mPrt->mDebugFilePtr);
SetIsPrinting(false);
#endif
} else {
#ifdef EXTENDED_DEBUG_PRINTING
nsIFrame* rootFrame = poPresShell->FrameManager()->GetRootFrame();
if (aPO->IsPrintable()) {
char * docStr;
char * urlStr;
GetDocTitleAndURL(aPO, docStr, urlStr);
DumpLayoutData(docStr, urlStr, poPresContext, mPrt->mPrintDocDC, rootFrame, docShell, nullptr);
if (docStr) nsMemory::Free(docStr);
if (urlStr) nsMemory::Free(urlStr);
}
#endif
if (!mPrt->mPrintSettings) {
// not sure what to do here!
SetIsPrinting(false);
return NS_ERROR_FAILURE;
}
PRUnichar * docTitleStr = nullptr;
PRUnichar * docURLStr = nullptr;
GetDisplayTitleAndURL(aPO, &docTitleStr, &docURLStr, eDocTitleDefBlank);
if (nsIPrintSettings::kRangeSelection == printRangeType) {
CloneSelection(aPO->mDocument->GetOriginalDocument(), aPO->mDocument);
poPresContext->SetIsRenderingOnlySelection(true);
// temporarily creating rendering context
// which is needed to find the selection frames
nsRefPtr<nsRenderingContext> rc;
mPrt->mPrintDC->CreateRenderingContext(*getter_AddRefs(rc));
// find the starting and ending page numbers
// via the selection
nsIFrame* startFrame;
nsIFrame* endFrame;
int32_t startPageNum;
int32_t endPageNum;
nsRect startRect;
nsRect endRect;
nsRefPtr<Selection> selectionPS =
poPresShell->GetCurrentSelection(nsISelectionController::SELECTION_NORMAL);
rv = GetPageRangeForSelection(poPresShell, poPresContext, *rc, selectionPS, pageSequence,
&startFrame, startPageNum, startRect,
&endFrame, endPageNum, endRect);
if (NS_SUCCEEDED(rv)) {
mPrt->mPrintSettings->SetStartPageRange(startPageNum);
mPrt->mPrintSettings->SetEndPageRange(endPageNum);
nsIntMargin marginTwips(0,0,0,0);
nsIntMargin unwrtMarginTwips(0,0,0,0);
mPrt->mPrintSettings->GetMarginInTwips(marginTwips);
mPrt->mPrintSettings->GetUnwriteableMarginInTwips(unwrtMarginTwips);
nsMargin totalMargin = poPresContext->CSSTwipsToAppUnits(marginTwips +
unwrtMarginTwips);
if (startPageNum == endPageNum) {
startRect.y -= totalMargin.top;
endRect.y -= totalMargin.top;
// Clip out selection regions above the top of the first page
if (startRect.y < 0) {
// Reduce height to be the height of the positive-territory
// region of original rect
startRect.height = std::max(0, startRect.YMost());
startRect.y = 0;
}
if (endRect.y < 0) {
// Reduce height to be the height of the positive-territory
// region of original rect
endRect.height = std::max(0, endRect.YMost());
endRect.y = 0;
}
NS_ASSERTION(endRect.y >= startRect.y,
"Selection end point should be after start point");
NS_ASSERTION(startRect.height >= 0,
"rect should have non-negative height.");
NS_ASSERTION(endRect.height >= 0,
"rect should have non-negative height.");
nscoord selectionHgt = endRect.y + endRect.height - startRect.y;
// XXX This is temporary fix for printing more than one page of a selection
pageSequence->SetSelectionHeight(startRect.y * aPO->mZoomRatio,
selectionHgt * aPO->mZoomRatio);
// calc total pages by getting calculating the selection's height
// and then dividing it by how page content frames will fit.
nscoord pageWidth, pageHeight;
mPrt->mPrintDC->GetDeviceSurfaceDimensions(pageWidth, pageHeight);
pageHeight -= totalMargin.top + totalMargin.bottom;
int32_t totalPages = NSToIntCeil(float(selectionHgt) * aPO->mZoomRatio / float(pageHeight));
pageSequence->SetTotalNumPages(totalPages);
}
}
}
nsIFrame * seqFrame = do_QueryFrame(pageSequence);
if (!seqFrame) {
SetIsPrinting(false);
if (docTitleStr) nsMemory::Free(docTitleStr);
if (docURLStr) nsMemory::Free(docURLStr);
return NS_ERROR_FAILURE;
}
mPageSeqFrame = pageSequence;
mPageSeqFrame->StartPrint(poPresContext, mPrt->mPrintSettings, docTitleStr, docURLStr);
// Schedule Page to Print
PR_PL(("Scheduling Print of PO: %p (%s) \n", aPO, gFrameTypesStr[aPO->mFrameType]));
StartPagePrintTimer(aPO);
}
}
return NS_OK;
}
//---------------------------------------------------------------------
void
nsPrintEngine::SetDocAndURLIntoProgress(nsPrintObject* aPO,
nsIPrintProgressParams* aParams)
{
NS_ASSERTION(aPO, "Must have vaild nsPrintObject");
NS_ASSERTION(aParams, "Must have vaild nsIPrintProgressParams");
if (!aPO || !aPO->mDocShell || !aParams) {
return;
}
const uint32_t kTitleLength = 64;
PRUnichar * docTitleStr;
PRUnichar * docURLStr;
GetDisplayTitleAndURL(aPO, &docTitleStr, &docURLStr, eDocTitleDefURLDoc);
// Make sure the Titles & URLS don't get too long for the progress dialog
ElipseLongString(docTitleStr, kTitleLength, false);
ElipseLongString(docURLStr, kTitleLength, true);
aParams->SetDocTitle(docTitleStr);
aParams->SetDocURL(docURLStr);
if (docTitleStr != nullptr) nsMemory::Free(docTitleStr);
if (docURLStr != nullptr) nsMemory::Free(docURLStr);
}
//---------------------------------------------------------------------
void
nsPrintEngine::ElipseLongString(PRUnichar *& aStr, const uint32_t aLen, bool aDoFront)
{
// Make sure the URLS don't get too long for the progress dialog
if (aStr && NS_strlen(aStr) > aLen) {
if (aDoFront) {
PRUnichar * ptr = &aStr[NS_strlen(aStr) - aLen + 3];
nsAutoString newStr;
newStr.AppendLiteral("...");
newStr += ptr;
nsMemory::Free(aStr);
aStr = ToNewUnicode(newStr);
} else {
nsAutoString newStr(aStr);
newStr.SetLength(aLen-3);
newStr.AppendLiteral("...");
nsMemory::Free(aStr);
aStr = ToNewUnicode(newStr);
}
}
}
static bool
DocHasPrintCallbackCanvas(nsIDocument* aDoc, void* aData)
{
if (!aDoc) {
return true;
}
Element* root = aDoc->GetRootElement();
if (!root) {
return true;
}
nsRefPtr<nsContentList> canvases = NS_GetContentList(root,
kNameSpaceID_XHTML,
NS_LITERAL_STRING("canvas"));
uint32_t canvasCount = canvases->Length(true);
for (uint32_t i = 0; i < canvasCount; ++i) {
nsCOMPtr<nsIDOMHTMLCanvasElement> canvas = do_QueryInterface(canvases->Item(i, false));
nsCOMPtr<nsIPrintCallback> printCallback;
if (canvas && NS_SUCCEEDED(canvas->GetMozPrintCallback(getter_AddRefs(printCallback))) &&
printCallback) {
// This subdocument has a print callback. Set result and return false to
// stop iteration.
*static_cast<bool*>(aData) = true;
return false;
}
}
return true;
}
static bool
DocHasPrintCallbackCanvas(nsIDocument* aDoc)
{
bool result = false;
aDoc->EnumerateSubDocuments(&DocHasPrintCallbackCanvas, static_cast<void*>(&result));
return result;
}
/**
* Checks to see if the document this print engine is associated with has any
* canvases that have a mozPrintCallback.
*/
bool
nsPrintEngine::HasPrintCallbackCanvas()
{
if (!mDocument) {
return false;
}
// First check this mDocument.
bool result = false;
DocHasPrintCallbackCanvas(mDocument, static_cast<void*>(&result));
// Also check the sub documents.
return result || DocHasPrintCallbackCanvas(mDocument);
}
//-------------------------------------------------------
bool
nsPrintEngine::PrePrintPage()
{
NS_ASSERTION(mPageSeqFrame, "mPageSeqFrame is null!");
NS_ASSERTION(mPrt, "mPrt is null!");
// Although these should NEVER be NULL
// This is added insurance, to make sure we don't crash in optimized builds
if (!mPrt || !mPageSeqFrame) {
return true; // means we are done preparing the page.
}
// Check setting to see if someone request it be cancelled
bool isCancelled = false;
mPrt->mPrintSettings->GetIsCancelled(&isCancelled);
if (isCancelled)
return true;
// Ask mPageSeqFrame if the page is ready to be printed.
// If the page doesn't get printed at all, the |done| will be |true|.
bool done = false;
nsresult rv = mPageSeqFrame->PrePrintNextPage(mPagePrintTimer, &done);
if (NS_FAILED(rv)) {
// ??? ::PrintPage doesn't set |mPrt->mIsAborted = true| if rv != NS_ERROR_ABORT,
// but I don't really understand why this should be the right thing to do?
// Shouldn't |mPrt->mIsAborted| set to true all the time if something
// wents wrong?
if (rv != NS_ERROR_ABORT) {
ShowPrintErrorDialog(rv);
mPrt->mIsAborted = true;
}
done = true;
}
return done;
}
bool
nsPrintEngine::PrintPage(nsPrintObject* aPO,
bool& aInRange)
{
NS_ASSERTION(aPO, "aPO is null!");
NS_ASSERTION(mPageSeqFrame, "mPageSeqFrame is null!");
NS_ASSERTION(mPrt, "mPrt is null!");
// Although these should NEVER be NULL
// This is added insurance, to make sure we don't crash in optimized builds
if (!mPrt || !aPO || !mPageSeqFrame) {
ShowPrintErrorDialog(NS_ERROR_FAILURE);
return true; // means we are done printing
}
PR_PL(("-----------------------------------\n"));
PR_PL(("------ In DV::PrintPage PO: %p (%s)\n", aPO, gFrameTypesStr[aPO->mFrameType]));
// Check setting to see if someone request it be cancelled
bool isCancelled = false;
mPrt->mPrintSettings->GetIsCancelled(&isCancelled);
if (isCancelled || mPrt->mIsAborted)
return true;
int32_t pageNum, numPages, endPage;
mPageSeqFrame->GetCurrentPageNum(&pageNum);
mPageSeqFrame->GetNumPages(&numPages);
bool donePrinting;
bool isDoingPrintRange;
mPageSeqFrame->IsDoingPrintRange(&isDoingPrintRange);
if (isDoingPrintRange) {
int32_t fromPage;
int32_t toPage;
mPageSeqFrame->GetPrintRange(&fromPage, &toPage);
if (fromPage > numPages) {
return true;
}
if (toPage > numPages) {
toPage = numPages;
}
PR_PL(("****** Printing Page %d printing from %d to page %d\n", pageNum, fromPage, toPage));
donePrinting = pageNum >= toPage;
aInRange = pageNum >= fromPage && pageNum <= toPage;
endPage = (toPage - fromPage)+1;
} else {
PR_PL(("****** Printing Page %d of %d page(s)\n", pageNum, numPages));
donePrinting = pageNum >= numPages;
endPage = numPages;
aInRange = true;
}
// XXX This is wrong, but the actual behavior in the presence of a print
// range sucks.
if (mPrt->mPrintFrameType == nsIPrintSettings::kEachFrameSep)
endPage = mPrt->mNumPrintablePages;
mPrt->DoOnProgressChange(++mPrt->mNumPagesPrinted, endPage, false, 0);
// Print the Page
// if a print job was cancelled externally, an EndPage or BeginPage may
// fail and the failure is passed back here.
// Returning true means we are done printing.
//
// When rv == NS_ERROR_ABORT, it means we want out of the
// print job without displaying any error messages
nsresult rv = mPageSeqFrame->PrintNextPage();
if (NS_FAILED(rv)) {
if (rv != NS_ERROR_ABORT) {
ShowPrintErrorDialog(rv);
mPrt->mIsAborted = true;
}
return true;
}
mPageSeqFrame->DoPageEnd();
return donePrinting;
}
/** ---------------------------------------------------
* Find by checking frames type
*/
nsresult
nsPrintEngine::FindSelectionBoundsWithList(nsPresContext* aPresContext,
nsRenderingContext& aRC,
nsFrameList::Enumerator& aChildFrames,
nsIFrame * aParentFrame,
nsRect& aRect,
nsIFrame *& aStartFrame,
nsRect& aStartRect,
nsIFrame *& aEndFrame,
nsRect& aEndRect)
{
NS_ASSERTION(aPresContext, "Pointer is null!");
NS_ASSERTION(aParentFrame, "Pointer is null!");
aRect += aParentFrame->GetPosition();
for (; !aChildFrames.AtEnd(); aChildFrames.Next()) {
nsIFrame* child = aChildFrames.get();
if (child->IsSelected() && child->IsVisibleForPainting()) {
nsRect r = child->GetRect();
if (aStartFrame == nullptr) {
aStartFrame = child;
aStartRect.SetRect(aRect.x + r.x, aRect.y + r.y, r.width, r.height);
} else {
aEndFrame = child;
aEndRect.SetRect(aRect.x + r.x, aRect.y + r.y, r.width, r.height);
}
}
FindSelectionBounds(aPresContext, aRC, child, aRect, aStartFrame, aStartRect, aEndFrame, aEndRect);
child = child->GetNextSibling();
}
aRect -= aParentFrame->GetPosition();
return NS_OK;
}
//-------------------------------------------------------
// Find the Frame that is XMost
nsresult
nsPrintEngine::FindSelectionBounds(nsPresContext* aPresContext,
nsRenderingContext& aRC,
nsIFrame * aParentFrame,
nsRect& aRect,
nsIFrame *& aStartFrame,
nsRect& aStartRect,
nsIFrame *& aEndFrame,
nsRect& aEndRect)
{
NS_ASSERTION(aPresContext, "Pointer is null!");
NS_ASSERTION(aParentFrame, "Pointer is null!");
// loop through named child lists
nsIFrame::ChildListIterator lists(aParentFrame);
for (; !lists.IsDone(); lists.Next()) {
nsFrameList::Enumerator childFrames(lists.CurrentList());
nsresult rv = FindSelectionBoundsWithList(aPresContext, aRC, childFrames, aParentFrame, aRect, aStartFrame, aStartRect, aEndFrame, aEndRect);
NS_ENSURE_SUCCESS(rv, rv);
}
return NS_OK;
}
/** ---------------------------------------------------
* This method finds the starting and ending page numbers
* of the selection and also returns rect for each where
* the x,y of the rect is relative to the very top of the
* frame tree (absolutely positioned)
*/
nsresult
nsPrintEngine::GetPageRangeForSelection(nsIPresShell * aPresShell,
nsPresContext* aPresContext,
nsRenderingContext& aRC,
nsISelection* aSelection,
nsIPageSequenceFrame* aPageSeqFrame,
nsIFrame** aStartFrame,
int32_t& aStartPageNum,
nsRect& aStartRect,
nsIFrame** aEndFrame,
int32_t& aEndPageNum,
nsRect& aEndRect)
{
NS_ASSERTION(aPresShell, "Pointer is null!");
NS_ASSERTION(aPresContext, "Pointer is null!");
NS_ASSERTION(aSelection, "Pointer is null!");
NS_ASSERTION(aPageSeqFrame, "Pointer is null!");
NS_ASSERTION(aStartFrame, "Pointer is null!");
NS_ASSERTION(aEndFrame, "Pointer is null!");
nsIFrame * seqFrame = do_QueryFrame(aPageSeqFrame);
if (!seqFrame) {
return NS_ERROR_FAILURE;
}
nsIFrame * startFrame = nullptr;
nsIFrame * endFrame = nullptr;
// start out with the sequence frame and search the entire frame tree
// capturing the starting and ending child frames of the selection
// and their rects
nsRect r = seqFrame->GetRect();
FindSelectionBounds(aPresContext, aRC, seqFrame, r,
startFrame, aStartRect, endFrame, aEndRect);
#ifdef DEBUG_rodsX
printf("Start Frame: %p\n", startFrame);
printf("End Frame: %p\n", endFrame);
#endif
// initial the page numbers here
// in case we don't find and frames
aStartPageNum = -1;
aEndPageNum = -1;
nsIFrame * startPageFrame;
nsIFrame * endPageFrame;
// check to make sure we found a starting frame
if (startFrame != nullptr) {
// Now search up the tree to find what page the
// start/ending selections frames are on
//
// Check to see if start should be same as end if
// the end frame comes back null
if (endFrame == nullptr) {
// XXX the "GetPageFrame" step could be integrated into
// the FindSelectionBounds step, but walking up to find
// the parent of a child frame isn't expensive and it makes
// FindSelectionBounds a little easier to understand
startPageFrame = nsLayoutUtils::GetPageFrame(startFrame);
endPageFrame = startPageFrame;
aEndRect = aStartRect;
} else {
startPageFrame = nsLayoutUtils::GetPageFrame(startFrame);
endPageFrame = nsLayoutUtils::GetPageFrame(endFrame);
}
} else {
return NS_ERROR_FAILURE;
}
#ifdef DEBUG_rodsX
printf("Start Page: %p\n", startPageFrame);
printf("End Page: %p\n", endPageFrame);
// dump all the pages and their pointers
{
int32_t pageNum = 1;
nsIFrame* child = seqFrame->GetFirstPrincipalChild();
while (child != nullptr) {
printf("Page: %d - %p\n", pageNum, child);
pageNum++;
child = child->GetNextSibling();
}
}
#endif
// Now that we have the page frames
// find out what the page numbers are for each frame
int32_t pageNum = 1;
nsIFrame* page = seqFrame->GetFirstPrincipalChild();
while (page != nullptr) {
if (page == startPageFrame) {
aStartPageNum = pageNum;
}
if (page == endPageFrame) {
aEndPageNum = pageNum;
}
pageNum++;
page = page->GetNextSibling();
}
#ifdef DEBUG_rodsX
printf("Start Page No: %d\n", aStartPageNum);
printf("End Page No: %d\n", aEndPageNum);
#endif
*aStartFrame = startPageFrame;
*aEndFrame = endPageFrame;
return NS_OK;
}
//-----------------------------------------------------------------
//-- Done: Printing Methods
//-----------------------------------------------------------------
//-----------------------------------------------------------------
//-- Section: Misc Support Methods
//-----------------------------------------------------------------
//---------------------------------------------------------------------
void nsPrintEngine::SetIsPrinting(bool aIsPrinting)
{
mIsDoingPrinting = aIsPrinting;
// Calling SetIsPrinting while in print preview confuses the document viewer
// This is safe because we prevent exiting print preview while printing
if (!mIsDoingPrintPreview && mDocViewerPrint) {
mDocViewerPrint->SetIsPrinting(aIsPrinting);
}
if (mPrt && aIsPrinting) {
mPrt->mPreparingForPrint = true;
}
}
//---------------------------------------------------------------------
void nsPrintEngine::SetIsPrintPreview(bool aIsPrintPreview)
{
mIsDoingPrintPreview = aIsPrintPreview;
if (mDocViewerPrint) {
mDocViewerPrint->SetIsPrintPreview(aIsPrintPreview);
}
}
//---------------------------------------------------------------------
void
nsPrintEngine::CleanupDocTitleArray(PRUnichar**& aArray, int32_t& aCount)
{
for (int32_t i = aCount - 1; i >= 0; i--) {
nsMemory::Free(aArray[i]);
}
nsMemory::Free(aArray);
aArray = NULL;
aCount = 0;
}
//---------------------------------------------------------------------
// static
bool nsPrintEngine::HasFramesetChild(nsIContent* aContent)
{
if (!aContent) {
return false;
}
// do a breadth search across all siblings
for (nsIContent* child = aContent->GetFirstChild();
child;
child = child->GetNextSibling()) {
if (child->IsHTML(nsGkAtoms::frameset)) {
return true;
}
}
return false;
}
/** ---------------------------------------------------
* Get the Focused Frame for a documentviewer
*/
already_AddRefed<nsIDOMWindow>
nsPrintEngine::FindFocusedDOMWindow()
{
nsIFocusManager* fm = nsFocusManager::GetFocusManager();
NS_ENSURE_TRUE(fm, nullptr);
nsCOMPtr<nsPIDOMWindow> window(mDocument->GetWindow());
NS_ENSURE_TRUE(window, nullptr);
nsCOMPtr<nsPIDOMWindow> rootWindow = window->GetPrivateRoot();
NS_ENSURE_TRUE(rootWindow, nullptr);
nsCOMPtr<nsPIDOMWindow> focusedWindow;
nsFocusManager::GetFocusedDescendant(rootWindow, true,
getter_AddRefs(focusedWindow));
NS_ENSURE_TRUE(focusedWindow, nullptr);
if (IsWindowsInOurSubTree(focusedWindow)) {
return focusedWindow.forget();
}
return nullptr;
}
//---------------------------------------------------------------------
bool
nsPrintEngine::IsWindowsInOurSubTree(nsPIDOMWindow * window)
{
bool found = false;
// now check to make sure it is in "our" tree of docshells
if (window) {
nsCOMPtr<nsIDocShell> docShell = window->GetDocShell();
if (docShell) {
// get this DocViewer docshell
nsCOMPtr<nsIDocShell> thisDVDocShell(do_QueryReferent(mContainer));
while (!found) {
if (docShell) {
if (docShell == thisDVDocShell) {
found = true;
break;
}
} else {
break; // at top of tree
}
nsCOMPtr<nsIDocShellTreeItem> docShellItemParent;
docShell->GetSameTypeParent(getter_AddRefs(docShellItemParent));
docShell = do_QueryInterface(docShellItemParent);
} // while
}
} // scriptobj
return found;
}
//-------------------------------------------------------
bool
nsPrintEngine::DonePrintingPages(nsPrintObject* aPO, nsresult aResult)
{
//NS_ASSERTION(aPO, "Pointer is null!");
PR_PL(("****** In DV::DonePrintingPages PO: %p (%s)\n", aPO, aPO?gFrameTypesStr[aPO->mFrameType]:""));
// If there is a pageSeqFrame, make sure there are no more printCanvas active
// that might call |Notify| on the pagePrintTimer after things are cleaned up
// and printing was marked as being done.
if (mPageSeqFrame) {
mPageSeqFrame->ResetPrintCanvasList();
}
if (aPO && !mPrt->mIsAborted) {
aPO->mHasBeenPrinted = true;
nsresult rv;
bool didPrint = PrintDocContent(mPrt->mPrintObject, rv);
if (NS_SUCCEEDED(rv) && didPrint) {
PR_PL(("****** In DV::DonePrintingPages PO: %p (%s) didPrint:%s (Not Done Printing)\n", aPO, gFrameTypesStr[aPO->mFrameType], PRT_YESNO(didPrint)));
return false;
}
}
if (NS_SUCCEEDED(aResult)) {
FirePrintCompletionEvent();
}
TurnScriptingOn(true);
SetIsPrinting(false);
// Release reference to mPagePrintTimer; the timer object destroys itself
// after this returns true
NS_IF_RELEASE(mPagePrintTimer);
return true;
}
//-------------------------------------------------------
// Recursively sets the PO items to be printed "As Is"
// from the given item down into the tree
void
nsPrintEngine::SetPrintAsIs(nsPrintObject* aPO, bool aAsIs)
{
NS_ASSERTION(aPO, "Pointer is null!");
aPO->mPrintAsIs = aAsIs;
for (uint32_t i=0;i<aPO->mKids.Length();i++) {
SetPrintAsIs(aPO->mKids[i], aAsIs);
}
}
//-------------------------------------------------------
// Given a DOMWindow it recursively finds the PO object that matches
nsPrintObject*
nsPrintEngine::FindPrintObjectByDOMWin(nsPrintObject* aPO,
nsIDOMWindow* aDOMWin)
{
NS_ASSERTION(aPO, "Pointer is null!");
// Often the CurFocused DOMWindow is passed in
// andit is valid for it to be null, so short circut
if (!aDOMWin) {
return nullptr;
}
nsCOMPtr<nsIDOMDocument> domDoc;
aDOMWin->GetDocument(getter_AddRefs(domDoc));
nsCOMPtr<nsIDocument> doc = do_QueryInterface(domDoc);
if (aPO->mDocument && aPO->mDocument->GetOriginalDocument() == doc) {
return aPO;
}
int32_t cnt = aPO->mKids.Length();
for (int32_t i = 0; i < cnt; ++i) {
nsPrintObject* po = FindPrintObjectByDOMWin(aPO->mKids[i], aDOMWin);
if (po) {
return po;
}
}
return nullptr;
}
//-------------------------------------------------------
nsresult
nsPrintEngine::EnablePOsForPrinting()
{
// NOTE: All POs have been "turned off" for printing
// this is where we decided which POs get printed.
mPrt->mSelectedPO = nullptr;
if (mPrt->mPrintSettings == nullptr) {
return NS_ERROR_FAILURE;
}
mPrt->mPrintFrameType = nsIPrintSettings::kNoFrames;
mPrt->mPrintSettings->GetPrintFrameType(&mPrt->mPrintFrameType);
int16_t printHowEnable = nsIPrintSettings::kFrameEnableNone;
mPrt->mPrintSettings->GetHowToEnableFrameUI(&printHowEnable);
int16_t printRangeType = nsIPrintSettings::kRangeAllPages;
mPrt->mPrintSettings->GetPrintRange(&printRangeType);
PR_PL(("\n"));
PR_PL(("********* nsPrintEngine::EnablePOsForPrinting *********\n"));
PR_PL(("PrintFrameType: %s \n", gPrintFrameTypeStr[mPrt->mPrintFrameType]));
PR_PL(("HowToEnableFrameUI: %s \n", gFrameHowToEnableStr[printHowEnable]));
PR_PL(("PrintRange: %s \n", gPrintRangeStr[printRangeType]));
PR_PL(("----\n"));
// ***** This is the ultimate override *****
// if we are printing the selection (either an IFrame or selection range)
// then set the mPrintFrameType as if it were the selected frame
if (printRangeType == nsIPrintSettings::kRangeSelection) {
mPrt->mPrintFrameType = nsIPrintSettings::kSelectedFrame;
printHowEnable = nsIPrintSettings::kFrameEnableNone;
}
// This tells us that the "Frame" UI has turned off,
// so therefore there are no FrameSets/Frames/IFrames to be printed
//
// This means there are not FrameSets,
// but the document could contain an IFrame
if (printHowEnable == nsIPrintSettings::kFrameEnableNone) {
// Print all the pages or a sub range of pages
if (printRangeType == nsIPrintSettings::kRangeAllPages ||
printRangeType == nsIPrintSettings::kRangeSpecifiedPageRange) {
SetPrintPO(mPrt->mPrintObject, true);
// Set the children so they are PrinAsIs
// In this case, the children are probably IFrames
if (mPrt->mPrintObject->mKids.Length() > 0) {
for (uint32_t i=0;i<mPrt->mPrintObject->mKids.Length();i++) {
nsPrintObject* po = mPrt->mPrintObject->mKids[i];
NS_ASSERTION(po, "nsPrintObject can't be null!");
SetPrintAsIs(po);
}
// ***** Another override *****
mPrt->mPrintFrameType = nsIPrintSettings::kFramesAsIs;
}
PR_PL(("PrintFrameType: %s \n", gPrintFrameTypeStr[mPrt->mPrintFrameType]));
PR_PL(("HowToEnableFrameUI: %s \n", gFrameHowToEnableStr[printHowEnable]));
PR_PL(("PrintRange: %s \n", gPrintRangeStr[printRangeType]));
return NS_OK;
}
// This means we are either printed a selected IFrame or
// we are printing the current selection
if (printRangeType == nsIPrintSettings::kRangeSelection) {
// If the currentFocusDOMWin can'r be null if something is selected
if (mPrt->mCurrentFocusWin) {
// Find the selected IFrame
nsPrintObject * po = FindPrintObjectByDOMWin(mPrt->mPrintObject, mPrt->mCurrentFocusWin);
if (po != nullptr) {
mPrt->mSelectedPO = po;
// Makes sure all of its children are be printed "AsIs"
SetPrintAsIs(po);
// Now, only enable this POs (the selected PO) and all of its children
SetPrintPO(po, true);
// check to see if we have a range selection,
// as oppose to a insert selection
// this means if the user just clicked on the IFrame then
// there will not be a selection so we want the entire page to print
//
// XXX this is sort of a hack right here to make the page
// not try to reposition itself when printing selection
nsCOMPtr<nsIDOMWindow> domWin =
do_QueryInterface(po->mDocument->GetOriginalDocument()->GetWindow());
if (!IsThereARangeSelection(domWin)) {
printRangeType = nsIPrintSettings::kRangeAllPages;
mPrt->mPrintSettings->SetPrintRange(printRangeType);
}
PR_PL(("PrintFrameType: %s \n", gPrintFrameTypeStr[mPrt->mPrintFrameType]));
PR_PL(("HowToEnableFrameUI: %s \n", gFrameHowToEnableStr[printHowEnable]));
PR_PL(("PrintRange: %s \n", gPrintRangeStr[printRangeType]));
return NS_OK;
}
} else {
for (uint32_t i=0;i<mPrt->mPrintDocList.Length();i++) {
nsPrintObject* po = mPrt->mPrintDocList.ElementAt(i);
NS_ASSERTION(po, "nsPrintObject can't be null!");
nsCOMPtr<nsIDOMWindow> domWin = do_GetInterface(po->mDocShell);
if (IsThereARangeSelection(domWin)) {
mPrt->mCurrentFocusWin = domWin;
SetPrintPO(po, true);
break;
}
}
return NS_OK;
}
}
}
// check to see if there is a selection when a FrameSet is present
if (printRangeType == nsIPrintSettings::kRangeSelection) {
// If the currentFocusDOMWin can'r be null if something is selected
if (mPrt->mCurrentFocusWin) {
// Find the selected IFrame
nsPrintObject * po = FindPrintObjectByDOMWin(mPrt->mPrintObject, mPrt->mCurrentFocusWin);
if (po != nullptr) {
mPrt->mSelectedPO = po;
// Makes sure all of its children are be printed "AsIs"
SetPrintAsIs(po);
// Now, only enable this POs (the selected PO) and all of its children
SetPrintPO(po, true);
// check to see if we have a range selection,
// as oppose to a insert selection
// this means if the user just clicked on the IFrame then
// there will not be a selection so we want the entire page to print
//
// XXX this is sort of a hack right here to make the page
// not try to reposition itself when printing selection
nsCOMPtr<nsIDOMWindow> domWin =
do_QueryInterface(po->mDocument->GetOriginalDocument()->GetWindow());
if (!IsThereARangeSelection(domWin)) {
printRangeType = nsIPrintSettings::kRangeAllPages;
mPrt->mPrintSettings->SetPrintRange(printRangeType);
}
PR_PL(("PrintFrameType: %s \n", gPrintFrameTypeStr[mPrt->mPrintFrameType]));
PR_PL(("HowToEnableFrameUI: %s \n", gFrameHowToEnableStr[printHowEnable]));
PR_PL(("PrintRange: %s \n", gPrintRangeStr[printRangeType]));
return NS_OK;
}
}
}
// If we are printing "AsIs" then sets all the POs to be printed as is
if (mPrt->mPrintFrameType == nsIPrintSettings::kFramesAsIs) {
SetPrintAsIs(mPrt->mPrintObject);
SetPrintPO(mPrt->mPrintObject, true);
return NS_OK;
}
// If we are printing the selected Frame then
// find that PO for that selected DOMWin and set it all of its
// children to be printed
if (mPrt->mPrintFrameType == nsIPrintSettings::kSelectedFrame) {
if ((mPrt->mIsParentAFrameSet && mPrt->mCurrentFocusWin) || mPrt->mIsIFrameSelected) {
nsPrintObject * po = FindPrintObjectByDOMWin(mPrt->mPrintObject, mPrt->mCurrentFocusWin);
if (po != nullptr) {
mPrt->mSelectedPO = po;
// NOTE: Calling this sets the "po" and
// we don't want to do this for documents that have no children,
// because then the "DoEndPage" gets called and it shouldn't
if (po->mKids.Length() > 0) {
// Makes sure that itself, and all of its children are printed "AsIs"
SetPrintAsIs(po);
}
// Now, only enable this POs (the selected PO) and all of its children
SetPrintPO(po, true);
}
}
return NS_OK;
}
// If we are print each subdoc separately,
// then don't print any of the FraneSet Docs
if (mPrt->mPrintFrameType == nsIPrintSettings::kEachFrameSep) {
SetPrintPO(mPrt->mPrintObject, true);
int32_t cnt = mPrt->mPrintDocList.Length();
for (int32_t i=0;i<cnt;i++) {
nsPrintObject* po = mPrt->mPrintDocList.ElementAt(i);
NS_ASSERTION(po, "nsPrintObject can't be null!");
if (po->mFrameType == eFrameSet) {
po->mDontPrint = true;
}
}
}
return NS_OK;
}
//-------------------------------------------------------
// Return the nsPrintObject with that is XMost (The widest frameset frame) AND
// contains the XMost (widest) layout frame
nsPrintObject*
nsPrintEngine::FindSmallestSTF()
{
float smallestRatio = 1.0f;
nsPrintObject* smallestPO = nullptr;
for (uint32_t i=0;i<mPrt->mPrintDocList.Length();i++) {
nsPrintObject* po = mPrt->mPrintDocList.ElementAt(i);
NS_ASSERTION(po, "nsPrintObject can't be null!");
if (po->mFrameType != eFrameSet && po->mFrameType != eIFrame) {
if (po->mShrinkRatio < smallestRatio) {
smallestRatio = po->mShrinkRatio;
smallestPO = po;
}
}
}
#ifdef EXTENDED_DEBUG_PRINTING
if (smallestPO) printf("*PO: %p Type: %d %10.3f\n", smallestPO, smallestPO->mFrameType, smallestPO->mShrinkRatio);
#endif
return smallestPO;
}
//-------------------------------------------------------
void
nsPrintEngine::TurnScriptingOn(bool aDoTurnOn)
{
if (mIsDoingPrinting && aDoTurnOn && mDocViewerPrint &&
mDocViewerPrint->GetIsPrintPreview()) {
// We don't want to turn scripting on if print preview is shown still after
// printing.
return;
}
nsPrintData* prt = mPrt;
#ifdef NS_PRINT_PREVIEW
if (!prt) {
prt = mPrtPreview;
}
#endif
if (!prt) {
return;
}
NS_ASSERTION(mDocument, "We MUST have a document.");
// First, get the script global object from the document...
for (uint32_t i=0;i<prt->mPrintDocList.Length();i++) {
nsPrintObject* po = prt->mPrintDocList.ElementAt(i);
NS_ASSERTION(po, "nsPrintObject can't be null!");
nsIDocument* doc = po->mDocument;
if (!doc) {
continue;
}
if (nsCOMPtr<nsPIDOMWindow> window = doc->GetWindow()) {
nsCOMPtr<nsIScriptGlobalObject> scriptGlobalObj = do_QueryInterface(window);
nsIScriptContext *scx = scriptGlobalObj->GetContext();
NS_WARN_IF_FALSE(scx, "Can't get nsIScriptContext");
nsresult propThere = NS_PROPTABLE_PROP_NOT_THERE;
doc->GetProperty(nsGkAtoms::scriptEnabledBeforePrintOrPreview,
&propThere);
if (aDoTurnOn) {
if (propThere != NS_PROPTABLE_PROP_NOT_THERE) {
doc->DeleteProperty(nsGkAtoms::scriptEnabledBeforePrintOrPreview);
if (scx) {
scx->SetScriptsEnabled(true, false);
}
window->ResumeTimeouts(false);
}
} else {
// Have to be careful, because people call us over and over again with
// aDoTurnOn == false. So don't set the property if it's already
// set, since in that case we'd set it to the wrong value.
if (propThere == NS_PROPTABLE_PROP_NOT_THERE) {
// Stash the current value of IsScriptEnabled on the document, so
// that layout code running in print preview doesn't get confused.
doc->SetProperty(nsGkAtoms::scriptEnabledBeforePrintOrPreview,
NS_INT32_TO_PTR(doc->IsScriptEnabled()));
if (scx) {
scx->SetScriptsEnabled(false, false);
}
window->SuspendTimeouts(1, false);
}
}
}
}
}
//-----------------------------------------------------------------
//-- Done: Misc Support Methods
//-----------------------------------------------------------------
//-----------------------------------------------------------------
//-- Section: Finishing up or Cleaning up
//-----------------------------------------------------------------
//-----------------------------------------------------------------
void
nsPrintEngine::CloseProgressDialog(nsIWebProgressListener* aWebProgressListener)
{
if (aWebProgressListener) {
aWebProgressListener->OnStateChange(nullptr, nullptr, nsIWebProgressListener::STATE_STOP|nsIWebProgressListener::STATE_IS_DOCUMENT, NS_OK);
}
}
//-----------------------------------------------------------------
nsresult
nsPrintEngine::FinishPrintPreview()
{
nsresult rv = NS_OK;
#ifdef NS_PRINT_PREVIEW
if (!mPrt) {
/* we're already finished with print preview */
return rv;
}
rv = DocumentReadyForPrinting();
SetIsCreatingPrintPreview(false);
/* cleaup on failure + notify user */
if (NS_FAILED(rv)) {
/* cleanup done, let's fire-up an error dialog to notify the user
* what went wrong...
*/
mPrt->OnEndPrinting();
TurnScriptingOn(true);
return rv;
}
// At this point we are done preparing everything
// before it is to be created
if (mIsDoingPrintPreview && mOldPrtPreview) {
delete mOldPrtPreview;
mOldPrtPreview = nullptr;
}
mPrt->OnEndPrinting();
// PrintPreview was built using the mPrt (code reuse)
// then we assign it over
mPrtPreview = mPrt;
mPrt = nullptr;
#endif // NS_PRINT_PREVIEW
return NS_OK;
}
//-----------------------------------------------------------------
//-- Done: Finishing up or Cleaning up
//-----------------------------------------------------------------
/*=============== Timer Related Code ======================*/
nsresult
nsPrintEngine::StartPagePrintTimer(nsPrintObject* aPO)
{
if (!mPagePrintTimer) {
// Get the delay time in between the printing of each page
// this gives the user more time to press cancel
int32_t printPageDelay = 50;
mPrt->mPrintSettings->GetPrintPageDelay(&printPageDelay);
nsRefPtr<nsPagePrintTimer> timer =
new nsPagePrintTimer(this, mDocViewerPrint, printPageDelay);
timer.forget(&mPagePrintTimer);
}
return mPagePrintTimer->Start(aPO);
}
/*=============== nsIObserver Interface ======================*/
NS_IMETHODIMP
nsPrintEngine::Observe(nsISupports *aSubject, const char *aTopic, const PRUnichar *aData)
{
nsresult rv = NS_ERROR_FAILURE;
rv = InitPrintDocConstruction(true);
if (!mIsDoingPrinting && mPrtPreview) {
mPrtPreview->OnEndPrinting();
}
return rv;
}
//---------------------------------------------------------------
//-- PLEvent Notification
//---------------------------------------------------------------
class nsPrintCompletionEvent : public nsRunnable {
public:
nsPrintCompletionEvent(nsIDocumentViewerPrint *docViewerPrint)
: mDocViewerPrint(docViewerPrint) {
NS_ASSERTION(mDocViewerPrint, "mDocViewerPrint is null.");
}
NS_IMETHOD Run() {
if (mDocViewerPrint)
mDocViewerPrint->OnDonePrinting();
return NS_OK;
}
private:
nsCOMPtr<nsIDocumentViewerPrint> mDocViewerPrint;
};
//-----------------------------------------------------------
void
nsPrintEngine::FirePrintCompletionEvent()
{
nsCOMPtr<nsIRunnable> event = new nsPrintCompletionEvent(mDocViewerPrint);
if (NS_FAILED(NS_DispatchToCurrentThread(event)))
NS_WARNING("failed to dispatch print completion event");
}
//---------------------------------------------------------------
//---------------------------------------------------------------
//-- Debug helper routines
//---------------------------------------------------------------
//---------------------------------------------------------------
#if (defined(XP_WIN) || defined(XP_OS2)) && defined(EXTENDED_DEBUG_PRINTING)
#include "windows.h"
#include "process.h"
#include "direct.h"
#define MY_FINDFIRST(a,b) FindFirstFile(a,b)
#define MY_FINDNEXT(a,b) FindNextFile(a,b)
#define ISDIR(a) (a.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
#define MY_FINDCLOSE(a) FindClose(a)
#define MY_FILENAME(a) a.cFileName
#define MY_FILESIZE(a) (a.nFileSizeHigh * MAXDWORD) + a.nFileSizeLow
int RemoveFilesInDir(const char * aDir)
{
WIN32_FIND_DATA data_ptr;
HANDLE find_handle;
char path[MAX_PATH];
strcpy(path, aDir);
// Append slash to the end of the directory names if not there
if (path[strlen(path)-1] != '\\')
strcat(path, "\\");
char findPath[MAX_PATH];
strcpy(findPath, path);
strcat(findPath, "*.*");
find_handle = MY_FINDFIRST(findPath, &data_ptr);
if (find_handle != INVALID_HANDLE_VALUE) {
do {
if (ISDIR(data_ptr)
&& (stricmp(MY_FILENAME(data_ptr),"."))
&& (stricmp(MY_FILENAME(data_ptr),".."))) {
// skip
}
else if (!ISDIR(data_ptr)) {
if (!strncmp(MY_FILENAME(data_ptr), "print_dump", 10)) {
char fileName[MAX_PATH];
strcpy(fileName, aDir);
strcat(fileName, "\\");
strcat(fileName, MY_FILENAME(data_ptr));
printf("Removing %s\n", fileName);
remove(fileName);
}
}
} while(MY_FINDNEXT(find_handle,&data_ptr));
MY_FINDCLOSE(find_handle);
}
return TRUE;
}
#endif
#ifdef EXTENDED_DEBUG_PRINTING
/** ---------------------------------------------------
* Dumps Frames for Printing
*/
static void RootFrameList(nsPresContext* aPresContext, FILE* out, int32_t aIndent)
{
if (!aPresContext || !out)
return;
nsIPresShell *shell = aPresContext->GetPresShell();
if (shell) {
nsIFrame* frame = shell->FrameManager()->GetRootFrame();
if (frame) {
frame->List(aPresContext, out, aIndent);
}
}
}
/** ---------------------------------------------------
* Dumps Frames for Printing
*/
static void DumpFrames(FILE* out,
nsPresContext* aPresContext,
nsRenderingContext * aRendContext,
nsIFrame * aFrame,
int32_t aLevel)
{
NS_ASSERTION(out, "Pointer is null!");
NS_ASSERTION(aPresContext, "Pointer is null!");
NS_ASSERTION(aRendContext, "Pointer is null!");
NS_ASSERTION(aFrame, "Pointer is null!");
nsIFrame* child = aFrame->GetFirstPrincipalChild();
while (child != nullptr) {
for (int32_t i=0;i<aLevel;i++) {
fprintf(out, " ");
}
nsAutoString tmp;
child->GetFrameName(tmp);
fputs(NS_LossyConvertUTF16toASCII(tmp).get(), out);
bool isSelected;
if (NS_SUCCEEDED(child->IsVisibleForPainting(aPresContext, *aRendContext, true, &isSelected))) {
fprintf(out, " %p %s", child, isSelected?"VIS":"UVS");
nsRect rect = child->GetRect();
fprintf(out, "[%d,%d,%d,%d] ", rect.x, rect.y, rect.width, rect.height);
fprintf(out, "v: %p ", (void*)child->GetView());
fprintf(out, "\n");
DumpFrames(out, aPresContext, aRendContext, child, aLevel+1);
child = child->GetNextSibling();
}
}
}
/** ---------------------------------------------------
* Dumps the Views from the DocShell
*/
static void
DumpViews(nsIDocShell* aDocShell, FILE* out)
{
NS_ASSERTION(aDocShell, "Pointer is null!");
NS_ASSERTION(out, "Pointer is null!");
if (nullptr != aDocShell) {
fprintf(out, "docshell=%p \n", aDocShell);
nsIPresShell* shell = nsPrintEngine::GetPresShellFor(aDocShell);
if (shell) {
nsViewManager* vm = shell->GetViewManager();
if (vm) {
nsView* root = vm->GetRootView();
if (root) {
root->List(out);
}
}
}
else {
fputs("null pres shell\n", out);
}
// dump the views of the sub documents
int32_t i, n;
nsCOMPtr<nsIDocShellTreeNode> docShellAsNode(do_QueryInterface(aDocShell));
docShellAsNode->GetChildCount(&n);
for (i = 0; i < n; i++) {
nsCOMPtr<nsIDocShellTreeItem> child;
docShellAsNode->GetChildAt(i, getter_AddRefs(child));
nsCOMPtr<nsIDocShell> childAsShell(do_QueryInterface(child));
if (childAsShell) {
DumpViews(childAsShell, out);
}
}
}
}
/** ---------------------------------------------------
* Dumps the Views and Frames
*/
void DumpLayoutData(char* aTitleStr,
char* aURLStr,
nsPresContext* aPresContext,
nsDeviceContext * aDC,
nsIFrame * aRootFrame,
nsIDocShekk * aDocShell,
FILE* aFD = nullptr)
{
if (!kPrintingLogMod || kPrintingLogMod->level != DUMP_LAYOUT_LEVEL) return;
if (aPresContext == nullptr || aDC == nullptr) {
return;
}
#ifdef NS_PRINT_PREVIEW
if (aPresContext->Type() == nsPresContext::eContext_PrintPreview) {
return;
}
#endif
NS_ASSERTION(aRootFrame, "Pointer is null!");
NS_ASSERTION(aDocShell, "Pointer is null!");
// Dump all the frames and view to a a file
char filename[256];
sprintf(filename, "print_dump_layout_%d.txt", gDumpLOFileNameCnt++);
FILE * fd = aFD?aFD:fopen(filename, "w");
if (fd) {
fprintf(fd, "Title: %s\n", aTitleStr?aTitleStr:"");
fprintf(fd, "URL: %s\n", aURLStr?aURLStr:"");
fprintf(fd, "--------------- Frames ----------------\n");
fprintf(fd, "--------------- Frames ----------------\n");
nsRefPtr<nsRenderingContext> renderingContext;
aDC->CreateRenderingContext(*getter_AddRefs(renderingContext));
RootFrameList(aPresContext, fd, 0);
//DumpFrames(fd, aPresContext, renderingContext, aRootFrame, 0);
fprintf(fd, "---------------------------------------\n\n");
fprintf(fd, "--------------- Views From Root Frame----------------\n");
nsView* v = aRootFrame->GetView();
if (v) {
v->List(fd);
} else {
printf("View is null!\n");
}
if (aDocShell) {
fprintf(fd, "--------------- All Views ----------------\n");
DumpViews(aDocShell, fd);
fprintf(fd, "---------------------------------------\n\n");
}
if (aFD == nullptr) {
fclose(fd);
}
}
}
//-------------------------------------------------------------
static void DumpPrintObjectsList(nsTArray<nsPrintObject*> * aDocList)
{
if (!kPrintingLogMod || kPrintingLogMod->level != DUMP_LAYOUT_LEVEL) return;
NS_ASSERTION(aDocList, "Pointer is null!");
const char types[][3] = {"DC", "FR", "IF", "FS"};
PR_PL(("Doc List\n***************************************************\n"));
PR_PL(("T P A H PO DocShell Seq Page Root Page# Rect\n"));
int32_t cnt = aDocList->Length();
for (int32_t i=0;i<cnt;i++) {
nsPrintObject* po = aDocList->ElementAt(i);
NS_ASSERTION(po, "nsPrintObject can't be null!");
nsIFrame* rootFrame = nullptr;
if (po->mPresShell) {
rootFrame = po->mPresShell->FrameManager()->GetRootFrame();
while (rootFrame != nullptr) {
nsIPageSequenceFrame * sqf = do_QueryFrame(rootFrame);
if (sqf) {
break;
}
rootFrame = rootFrame->GetFirstPrincipalChild();
}
}
PR_PL(("%s %d %d %d %p %p %p %p %p %d %d,%d,%d,%d\n", types[po->mFrameType],
po->IsPrintable(), po->mPrintAsIs, po->mHasBeenPrinted, po, po->mDocShell.get(), po->mSeqFrame,
po->mPageFrame, rootFrame, po->mPageNum, po->mRect.x, po->mRect.y, po->mRect.width, po->mRect.height));
}
}
//-------------------------------------------------------------
static void DumpPrintObjectsTree(nsPrintObject * aPO, int aLevel, FILE* aFD)
{
if (!kPrintingLogMod || kPrintingLogMod->level != DUMP_LAYOUT_LEVEL) return;
NS_ASSERTION(aPO, "Pointer is null!");
FILE * fd = aFD?aFD:stdout;
const char types[][3] = {"DC", "FR", "IF", "FS"};
if (aLevel == 0) {
fprintf(fd, "DocTree\n***************************************************\n");
fprintf(fd, "T PO DocShell Seq Page Page# Rect\n");
}
int32_t cnt = aPO->mKids.Length();
for (int32_t i=0;i<cnt;i++) {
nsPrintObject* po = aPO->mKids.ElementAt(i);
NS_ASSERTION(po, "nsPrintObject can't be null!");
for (int32_t k=0;k<aLevel;k++) fprintf(fd, " ");
fprintf(fd, "%s %p %p %p %p %d %d,%d,%d,%d\n", types[po->mFrameType], po, po->mDocShell.get(), po->mSeqFrame,
po->mPageFrame, po->mPageNum, po->mRect.x, po->mRect.y, po->mRect.width, po->mRect.height);
}
}
//-------------------------------------------------------------
static void GetDocTitleAndURL(nsPrintObject* aPO, char *& aDocStr, char *& aURLStr)
{
aDocStr = nullptr;
aURLStr = nullptr;
PRUnichar * docTitleStr;
PRUnichar * docURLStr;
nsPrintEngine::GetDisplayTitleAndURL(aPO,
&docTitleStr, &docURLStr,
nsPrintEngine::eDocTitleDefURLDoc);
if (docTitleStr) {
nsAutoString strDocTitle(docTitleStr);
aDocStr = ToNewCString(strDocTitle);
nsMemory::Free(docTitleStr);
}
if (docURLStr) {
nsAutoString strURL(docURLStr);
aURLStr = ToNewCString(strURL);
nsMemory::Free(docURLStr);
}
}
//-------------------------------------------------------------
static void DumpPrintObjectsTreeLayout(nsPrintObject * aPO,
nsDeviceContext * aDC,
int aLevel, FILE * aFD)
{
if (!kPrintingLogMod || kPrintingLogMod->level != DUMP_LAYOUT_LEVEL) return;
NS_ASSERTION(aPO, "Pointer is null!");
NS_ASSERTION(aDC, "Pointer is null!");
const char types[][3] = {"DC", "FR", "IF", "FS"};
FILE * fd = nullptr;
if (aLevel == 0) {
fd = fopen("tree_layout.txt", "w");
fprintf(fd, "DocTree\n***************************************************\n");
fprintf(fd, "***************************************************\n");
fprintf(fd, "T PO DocShell Seq Page Page# Rect\n");
} else {
fd = aFD;
}
if (fd) {
nsIFrame* rootFrame = nullptr;
if (aPO->mPresShell) {
rootFrame = aPO->mPresShell->FrameManager()->GetRootFrame();
}
for (int32_t k=0;k<aLevel;k++) fprintf(fd, " ");
fprintf(fd, "%s %p %p %p %p %d %d,%d,%d,%d\n", types[aPO->mFrameType], aPO, aPO->mDocShell.get(), aPO->mSeqFrame,
aPO->mPageFrame, aPO->mPageNum, aPO->mRect.x, aPO->mRect.y, aPO->mRect.width, aPO->mRect.height);
if (aPO->IsPrintable()) {
char * docStr;
char * urlStr;
GetDocTitleAndURL(aPO, docStr, urlStr);
DumpLayoutData(docStr, urlStr, aPO->mPresContext, aDC, rootFrame, aPO->mDocShell, fd);
if (docStr) nsMemory::Free(docStr);
if (urlStr) nsMemory::Free(urlStr);
}
fprintf(fd, "<***************************************************>\n");
int32_t cnt = aPO->mKids.Length();
for (int32_t i=0;i<cnt;i++) {
nsPrintObject* po = aPO->mKids.ElementAt(i);
NS_ASSERTION(po, "nsPrintObject can't be null!");
DumpPrintObjectsTreeLayout(po, aDC, aLevel+1, fd);
}
}
if (aLevel == 0 && fd) {
fclose(fd);
}
}
//-------------------------------------------------------------
static void DumpPrintObjectsListStart(const char * aStr, nsTArray<nsPrintObject*> * aDocList)
{
if (!kPrintingLogMod || kPrintingLogMod->level != DUMP_LAYOUT_LEVEL) return;
NS_ASSERTION(aStr, "Pointer is null!");
NS_ASSERTION(aDocList, "Pointer is null!");
PR_PL(("%s\n", aStr));
DumpPrintObjectsList(aDocList);
}
#define DUMP_DOC_LIST(_title) DumpPrintObjectsListStart((_title), mPrt->mPrintDocList);
#define DUMP_DOC_TREE DumpPrintObjectsTree(mPrt->mPrintObject);
#define DUMP_DOC_TREELAYOUT DumpPrintObjectsTreeLayout(mPrt->mPrintObject, mPrt->mPrintDC);
#else
#define DUMP_DOC_LIST(_title)
#define DUMP_DOC_TREE
#define DUMP_DOC_TREELAYOUT
#endif
//---------------------------------------------------------------
//---------------------------------------------------------------
//-- End of debug helper routines
//---------------------------------------------------------------
Reference in New Issue View Git Blame Copy Permalink