2002-08-21 16:01:05 +04:00
|
|
|
/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
|
|
|
|
/* ***** BEGIN LICENSE BLOCK *****
|
2004-04-18 01:52:36 +04:00
|
|
|
* Version: MPL 1.1/GPL 2.0/LGPL 2.1
|
2002-08-21 16:01:05 +04:00
|
|
|
*
|
2004-04-18 01:52:36 +04:00
|
|
|
* The contents of this file are subject to the Mozilla Public License Version
|
|
|
|
* 1.1 (the "License"); you may not use this file except in compliance with
|
|
|
|
* the License. You may obtain a copy of the License at
|
|
|
|
* http://www.mozilla.org/MPL/
|
2002-08-21 16:01:05 +04:00
|
|
|
*
|
|
|
|
* Software distributed under the License is distributed on an "AS IS" basis,
|
|
|
|
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
|
|
|
|
* for the specific language governing rights and limitations under the
|
|
|
|
* License.
|
|
|
|
*
|
|
|
|
* The Original Code is mozilla.org code.
|
|
|
|
*
|
2004-04-18 01:52:36 +04:00
|
|
|
* The Initial Developer of the Original Code is
|
2002-08-21 16:01:05 +04:00
|
|
|
* Netscape Communications Corporation.
|
|
|
|
* Portions created by the Initial Developer are Copyright (C) 1998
|
|
|
|
* the Initial Developer. All Rights Reserved.
|
|
|
|
*
|
|
|
|
* Contributor(s):
|
2003-08-01 05:56:15 +04:00
|
|
|
* Roland Mainz <roland.mainz@informatik.med.uni-giessen.de>
|
2002-08-21 16:01:05 +04:00
|
|
|
*
|
|
|
|
* Alternatively, the contents of this file may be used under the terms of
|
2004-04-18 01:52:36 +04:00
|
|
|
* either of the GNU General Public License Version 2 or later (the "GPL"),
|
|
|
|
* or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
|
2002-08-21 16:01:05 +04:00
|
|
|
* in which case the provisions of the GPL or the LGPL are applicable instead
|
|
|
|
* of those above. If you wish to allow use of your version of this file only
|
|
|
|
* under the terms of either the GPL or the LGPL, and not to allow others to
|
2004-04-18 01:52:36 +04:00
|
|
|
* use your version of this file under the terms of the MPL, indicate your
|
2002-08-21 16:01:05 +04:00
|
|
|
* decision by deleting the provisions above and replace them with the notice
|
|
|
|
* and other provisions required by the GPL or the LGPL. If you do not delete
|
|
|
|
* the provisions above, a recipient may use your version of this file under
|
2004-04-18 01:52:36 +04:00
|
|
|
* the terms of any one of the MPL, the GPL or the LGPL.
|
2002-08-21 16:01:05 +04:00
|
|
|
*
|
|
|
|
* ***** END LICENSE BLOCK ***** */
|
|
|
|
|
|
|
|
#include "nsPrintEngine.h"
|
|
|
|
|
|
|
|
#include "nsIStringBundle.h"
|
|
|
|
#include "nsReadableUtils.h"
|
|
|
|
#include "nsCRT.h"
|
|
|
|
|
|
|
|
#include "nsISelection.h"
|
|
|
|
#include "nsIScriptGlobalObject.h"
|
2005-11-29 02:56:44 +03:00
|
|
|
#include "nsPIDOMWindow.h"
|
2002-08-21 16:01:05 +04:00
|
|
|
#include "nsIDocShell.h"
|
2011-08-25 00:54:30 +04:00
|
|
|
#include "nsIFrame.h"
|
2002-08-21 16:01:05 +04:00
|
|
|
#include "nsIURI.h"
|
2010-01-06 10:09:18 +03:00
|
|
|
#include "nsITextToSubURI.h"
|
2006-06-03 00:29:05 +04:00
|
|
|
#include "nsContentErrors.h"
|
2002-08-21 16:01:05 +04:00
|
|
|
|
|
|
|
// Print Options
|
|
|
|
#include "nsIPrintSettings.h"
|
|
|
|
#include "nsIPrintSettingsService.h"
|
|
|
|
#include "nsIPrintOptions.h"
|
2006-12-10 11:05:05 +03:00
|
|
|
#include "nsIPrintSession.h"
|
2002-08-21 16:01:05 +04:00
|
|
|
#include "nsGfxCIID.h"
|
|
|
|
#include "nsIServiceManager.h"
|
2007-01-30 03:06:41 +03:00
|
|
|
#include "nsGkAtoms.h"
|
2002-09-04 03:36:13 +04:00
|
|
|
#include "nsXPCOM.h"
|
2002-08-21 16:01:05 +04:00
|
|
|
#include "nsISupportsPrimitives.h"
|
|
|
|
|
|
|
|
static const char sPrintSettingsServiceContractID[] = "@mozilla.org/gfx/printsettings-service;1";
|
|
|
|
|
|
|
|
// Printing Events
|
|
|
|
#include "nsPrintPreviewListener.h"
|
2006-05-10 21:30:15 +04:00
|
|
|
#include "nsThreadUtils.h"
|
2002-08-21 16:01:05 +04:00
|
|
|
|
|
|
|
// Printing
|
|
|
|
#include "nsIWebBrowserPrint.h"
|
|
|
|
#include "nsIDOMHTMLFrameElement.h"
|
|
|
|
#include "nsIDOMHTMLFrameSetElement.h"
|
|
|
|
#include "nsIDOMHTMLIFrameElement.h"
|
|
|
|
#include "nsIDOMHTMLObjectElement.h"
|
2005-11-24 03:48:40 +03:00
|
|
|
#include "nsIDOMHTMLEmbedElement.h"
|
2002-08-21 16:01:05 +04:00
|
|
|
|
|
|
|
// 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"
|
2003-05-27 07:49:22 +04:00
|
|
|
static const char kPrintingPromptService[] = "@mozilla.org/embedcomp/printingprompt-service;1";
|
2002-08-21 16:01:05 +04:00
|
|
|
|
|
|
|
// Printing Timer
|
|
|
|
#include "nsPagePrintTimer.h"
|
|
|
|
|
|
|
|
// FrameSet
|
|
|
|
#include "nsIDocument.h"
|
|
|
|
|
|
|
|
// Focus
|
2007-05-14 13:11:38 +04:00
|
|
|
#include "nsIDOMEventTarget.h"
|
2002-08-21 16:01:05 +04:00
|
|
|
#include "nsISelectionController.h"
|
|
|
|
|
|
|
|
// Misc
|
|
|
|
#include "nsISupportsUtils.h"
|
|
|
|
#include "nsIScriptContext.h"
|
|
|
|
#include "nsILinkHandler.h"
|
|
|
|
#include "nsIDOMDocument.h"
|
|
|
|
#include "nsISelectionListener.h"
|
|
|
|
#include "nsISelectionPrivate.h"
|
|
|
|
#include "nsIDOMHTMLDocument.h"
|
|
|
|
#include "nsIDOMHTMLCollection.h"
|
|
|
|
#include "nsIDOMHTMLElement.h"
|
|
|
|
#include "nsIDOMRange.h"
|
|
|
|
#include "nsContentCID.h"
|
|
|
|
#include "nsLayoutCID.h"
|
2004-12-07 05:49:12 +03:00
|
|
|
#include "nsContentUtils.h"
|
2002-08-21 16:01:05 +04:00
|
|
|
#include "nsIPresShell.h"
|
2003-02-23 05:49:22 +03:00
|
|
|
#include "nsLayoutUtils.h"
|
2011-05-25 10:31:59 +04:00
|
|
|
#include "mozilla/Preferences.h"
|
2002-08-21 16:01:05 +04:00
|
|
|
|
|
|
|
#include "nsViewsCID.h"
|
|
|
|
#include "nsWidgetsCID.h"
|
|
|
|
#include "nsIDeviceContextSpec.h"
|
|
|
|
#include "nsIViewManager.h"
|
|
|
|
#include "nsIView.h"
|
2011-04-08 05:04:40 +04:00
|
|
|
#include "nsRenderingContext.h"
|
2002-08-21 16:01:05 +04:00
|
|
|
|
|
|
|
#include "nsIPageSequenceFrame.h"
|
|
|
|
#include "nsIURL.h"
|
|
|
|
#include "nsIContentViewerEdit.h"
|
|
|
|
#include "nsIContentViewerFile.h"
|
|
|
|
#include "nsIMarkupDocumentViewer.h"
|
|
|
|
#include "nsIInterfaceRequestor.h"
|
|
|
|
#include "nsIInterfaceRequestorUtils.h"
|
|
|
|
#include "nsIDocShellTreeItem.h"
|
|
|
|
#include "nsIDocShellTreeNode.h"
|
|
|
|
#include "nsIDocShellTreeOwner.h"
|
2007-11-12 15:17:23 +03:00
|
|
|
#include "nsIWebBrowserChrome.h"
|
2002-08-21 16:01:05 +04:00
|
|
|
#include "nsIBaseWindow.h"
|
|
|
|
#include "nsILayoutHistoryState.h"
|
2004-02-24 00:29:06 +03:00
|
|
|
#include "nsFrameManager.h"
|
2002-08-21 16:01:05 +04:00
|
|
|
#include "nsGUIEvent.h"
|
|
|
|
#include "nsHTMLReflowState.h"
|
|
|
|
#include "nsIDOMHTMLAnchorElement.h"
|
|
|
|
#include "nsIDOMHTMLAreaElement.h"
|
|
|
|
#include "nsIDOMHTMLLinkElement.h"
|
|
|
|
#include "nsIDOMHTMLImageElement.h"
|
|
|
|
#include "nsIContentViewerContainer.h"
|
|
|
|
#include "nsIContentViewer.h"
|
2006-12-10 11:05:05 +03:00
|
|
|
#include "nsIDocumentViewerPrint.h"
|
2002-08-21 16:01:05 +04:00
|
|
|
|
Bug 178324, refactor focus by moving all focus handling into one place and simplifying it, add many tests, fixes many other bugs too numerous to mention in this small checkin comment, r=josh,smichaud,ere,dbaron,marco,neil,gavin,smaug,sr=smaug (CLOSED TREE)
2009-06-10 22:00:39 +04:00
|
|
|
#include "nsFocusManager.h"
|
2009-12-11 07:02:13 +03:00
|
|
|
#include "nsRange.h"
|
2005-03-18 07:16:02 +03:00
|
|
|
#include "nsCDefaultURIFixup.h"
|
|
|
|
#include "nsIURIFixup.h"
|
2010-05-05 22:18:05 +04:00
|
|
|
#include "mozilla/dom/Element.h"
|
2010-04-30 17:12:05 +04:00
|
|
|
|
2011-05-25 10:31:59 +04:00
|
|
|
using namespace mozilla;
|
2010-04-30 17:12:05 +04:00
|
|
|
using namespace mozilla::dom;
|
2005-03-18 07:16:02 +03:00
|
|
|
|
2002-08-21 16:01:05 +04:00
|
|
|
//-----------------------------------------------------
|
|
|
|
// PR LOGGING
|
|
|
|
#ifdef MOZ_LOGGING
|
|
|
|
#define FORCE_PR_LOG /* Allow logging in the release build */
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#include "prlog.h"
|
|
|
|
|
|
|
|
#ifdef PR_LOGGING
|
|
|
|
|
|
|
|
#ifdef NS_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 * kPrintingLogMod = PR_NewLogModule("printing");
|
|
|
|
#define PR_PL(_p1) PR_LOG(kPrintingLogMod, PR_LOG_DEBUG, _p1);
|
|
|
|
|
|
|
|
#ifdef EXTENDED_DEBUG_PRINTING
|
|
|
|
static PRUint32 gDumpFileNameCnt = 0;
|
|
|
|
static PRUint32 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
|
2009-02-03 17:42:18 +03:00
|
|
|
static void DumpPrintObjectsListStart(const char * aStr, nsTArray<nsPrintObject*> * aDocList);
|
2004-02-03 01:42:29 +03:00
|
|
|
static void DumpPrintObjectsTree(nsPrintObject * aPO, int aLevel= 0, FILE* aFD = nsnull);
|
2011-04-17 05:22:44 +04:00
|
|
|
static void DumpPrintObjectsTreeLayout(nsPrintObject * aPO,nsDeviceContext * aDC, int aLevel= 0, FILE * aFD = nsnull);
|
2002-08-21 16:01:05 +04:00
|
|
|
|
|
|
|
#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
|
|
|
|
|
2009-03-10 22:30:50 +03:00
|
|
|
class nsScriptSuppressor
|
|
|
|
{
|
|
|
|
public:
|
|
|
|
nsScriptSuppressor(nsPrintEngine* aPrintEngine)
|
2011-10-17 18:59:28 +04:00
|
|
|
: mPrintEngine(aPrintEngine), mSuppressed(false) {}
|
2009-03-10 22:30:50 +03:00
|
|
|
|
|
|
|
~nsScriptSuppressor() { Unsuppress(); }
|
|
|
|
|
|
|
|
void Suppress()
|
|
|
|
{
|
|
|
|
if (mPrintEngine) {
|
2011-10-17 18:59:28 +04:00
|
|
|
mSuppressed = true;
|
|
|
|
mPrintEngine->TurnScriptingOn(false);
|
2009-03-10 22:30:50 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void Unsuppress()
|
|
|
|
{
|
|
|
|
if (mPrintEngine && mSuppressed) {
|
2011-10-17 18:59:28 +04:00
|
|
|
mPrintEngine->TurnScriptingOn(true);
|
2009-03-10 22:30:50 +03:00
|
|
|
}
|
2011-10-17 18:59:28 +04:00
|
|
|
mSuppressed = false;
|
2009-03-10 22:30:50 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
void Disconnect() { mPrintEngine = nsnull; }
|
|
|
|
protected:
|
|
|
|
nsRefPtr<nsPrintEngine> mPrintEngine;
|
2011-09-29 10:19:26 +04:00
|
|
|
bool mSuppressed;
|
2009-03-10 22:30:50 +03:00
|
|
|
};
|
2002-08-21 16:01:05 +04:00
|
|
|
|
|
|
|
// Class IDs
|
|
|
|
static NS_DEFINE_CID(kViewManagerCID, NS_VIEW_MANAGER_CID);
|
|
|
|
|
2006-03-30 04:27:42 +04:00
|
|
|
NS_IMPL_ISUPPORTS1(nsPrintEngine, nsIObserver)
|
2002-08-21 16:01:05 +04:00
|
|
|
|
|
|
|
//---------------------------------------------------
|
|
|
|
//-- nsPrintEngine Class Impl
|
|
|
|
//---------------------------------------------------
|
|
|
|
nsPrintEngine::nsPrintEngine() :
|
2011-10-17 18:59:28 +04:00
|
|
|
mIsCreatingPrintPreview(false),
|
|
|
|
mIsDoingPrinting(false),
|
|
|
|
mIsDoingPrintPreview(false),
|
|
|
|
mProgressDialogIsShown(false),
|
2009-08-24 13:55:28 +04:00
|
|
|
mScreenDPI(115.0f),
|
2002-08-21 16:01:05 +04:00
|
|
|
mPrt(nsnull),
|
|
|
|
mPagePrintTimer(nsnull),
|
|
|
|
mPageSeqFrame(nsnull),
|
|
|
|
mPrtPreview(nsnull),
|
|
|
|
mOldPrtPreview(nsnull),
|
2008-02-19 10:36:50 +03:00
|
|
|
mDebugFile(nsnull)
|
2002-08-21 16:01:05 +04:00
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
//-------------------------------------------------------
|
|
|
|
nsPrintEngine::~nsPrintEngine()
|
|
|
|
{
|
|
|
|
Destroy(); // for insurance
|
|
|
|
}
|
|
|
|
|
|
|
|
//-------------------------------------------------------
|
|
|
|
void nsPrintEngine::Destroy()
|
|
|
|
{
|
|
|
|
if (mPrt) {
|
|
|
|
delete mPrt;
|
|
|
|
mPrt = nsnull;
|
|
|
|
}
|
|
|
|
|
|
|
|
#ifdef NS_PRINT_PREVIEW
|
|
|
|
if (mPrtPreview) {
|
|
|
|
delete mPrtPreview;
|
|
|
|
mPrtPreview = nsnull;
|
|
|
|
}
|
|
|
|
|
|
|
|
// This is insruance
|
|
|
|
if (mOldPrtPreview) {
|
|
|
|
delete mOldPrtPreview;
|
|
|
|
mOldPrtPreview = nsnull;
|
|
|
|
}
|
|
|
|
|
|
|
|
#endif
|
2008-09-26 13:51:42 +04:00
|
|
|
mDocViewerPrint = nsnull;
|
2002-08-21 16:01:05 +04:00
|
|
|
}
|
|
|
|
|
2002-09-10 05:57:09 +04:00
|
|
|
//-------------------------------------------------------
|
|
|
|
void nsPrintEngine::DestroyPrintingData()
|
|
|
|
{
|
|
|
|
if (mPrt) {
|
|
|
|
delete mPrt;
|
|
|
|
mPrt = nsnull;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2002-08-21 16:01:05 +04:00
|
|
|
//---------------------------------------------------------------------------------
|
|
|
|
//-- Section: Methods needed by the DocViewer
|
|
|
|
//---------------------------------------------------------------------------------
|
|
|
|
|
|
|
|
//--------------------------------------------------------
|
2006-12-10 11:05:05 +03:00
|
|
|
nsresult nsPrintEngine::Initialize(nsIDocumentViewerPrint* aDocViewerPrint,
|
2011-05-10 16:55:26 +04:00
|
|
|
nsIWeakReference* aContainer,
|
2002-08-21 16:01:05 +04:00
|
|
|
nsIDocument* aDocument,
|
2009-08-24 13:55:28 +04:00
|
|
|
float aScreenDPI,
|
2002-08-21 16:01:05 +04:00
|
|
|
FILE* aDebugFile)
|
|
|
|
{
|
|
|
|
NS_ENSURE_ARG_POINTER(aDocViewerPrint);
|
|
|
|
NS_ENSURE_ARG_POINTER(aContainer);
|
|
|
|
NS_ENSURE_ARG_POINTER(aDocument);
|
|
|
|
|
2008-09-26 13:51:42 +04:00
|
|
|
mDocViewerPrint = aDocViewerPrint;
|
2011-05-10 16:55:26 +04:00
|
|
|
mContainer = aContainer;
|
2002-08-21 16:01:05 +04:00
|
|
|
mDocument = aDocument;
|
2009-08-24 13:55:28 +04:00
|
|
|
mScreenDPI = aScreenDPI;
|
2002-08-21 16:01:05 +04:00
|
|
|
|
|
|
|
mDebugFile = aDebugFile; // ok to be NULL
|
|
|
|
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
//-------------------------------------------------------
|
2011-09-29 10:19:26 +04:00
|
|
|
bool
|
2002-08-21 16:01:05 +04:00
|
|
|
nsPrintEngine::CheckBeforeDestroy()
|
|
|
|
{
|
|
|
|
if (mPrt && mPrt->mPreparingForPrint) {
|
2011-10-17 18:59:28 +04:00
|
|
|
mPrt->mDocWasToBeDestroyed = true;
|
|
|
|
return true;
|
2002-08-21 16:01:05 +04:00
|
|
|
}
|
2011-10-17 18:59:28 +04:00
|
|
|
return false;
|
2002-08-21 16:01:05 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
//-------------------------------------------------------
|
|
|
|
nsresult
|
|
|
|
nsPrintEngine::Cancelled()
|
|
|
|
{
|
|
|
|
if (mPrt && mPrt->mPrintSettings) {
|
2011-10-17 18:59:28 +04:00
|
|
|
return mPrt->mPrintSettings->SetIsCancelled(true);
|
2002-08-21 16:01:05 +04:00
|
|
|
}
|
|
|
|
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) {
|
2011-05-10 16:55:26 +04:00
|
|
|
nsCOMPtr<nsIDocShell> docShell = do_QueryReferent(mContainer);
|
|
|
|
nsCOMPtr<nsPIDOMWindow> win(do_GetInterface(docShell));
|
|
|
|
if (win) {
|
|
|
|
nsCOMPtr<nsIDOMEventTarget> target(do_QueryInterface(win->GetFrameElementInternal()));
|
|
|
|
mPrt->mPPEventListeners = new nsPrintPreviewListener(target);
|
2002-08-21 16:01:05 +04:00
|
|
|
mPrt->mPPEventListeners->AddListeners();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
//----------------------------------------------------------------------
|
|
|
|
nsresult
|
|
|
|
nsPrintEngine::GetSeqFrameAndCountPagesInternal(nsPrintObject* aPO,
|
|
|
|
nsIFrame*& aSeqFrame,
|
|
|
|
PRInt32& aCount)
|
|
|
|
{
|
|
|
|
NS_ENSURE_ARG_POINTER(aPO);
|
|
|
|
|
|
|
|
// Finds the SimplePageSequencer frame
|
2010-03-21 00:54:19 +03:00
|
|
|
nsIPageSequenceFrame* seqFrame = aPO->mPresShell->GetPageSequenceFrame();
|
2005-04-26 07:17:07 +04:00
|
|
|
if (seqFrame) {
|
2009-01-12 22:20:59 +03:00
|
|
|
aSeqFrame = do_QueryFrame(seqFrame);
|
2005-04-26 07:17:07 +04:00
|
|
|
} else {
|
|
|
|
aSeqFrame = nsnull;
|
2002-08-21 16:01:05 +04:00
|
|
|
}
|
|
|
|
if (aSeqFrame == nsnull) return NS_ERROR_FAILURE;
|
|
|
|
|
|
|
|
// first count the total number of pages
|
|
|
|
aCount = 0;
|
2011-08-25 00:54:30 +04:00
|
|
|
nsIFrame* pageFrame = aSeqFrame->GetFirstPrincipalChild();
|
2002-08-21 16:01:05 +04:00
|
|
|
while (pageFrame != nsnull) {
|
|
|
|
aCount++;
|
2003-08-06 07:07:12 +04:00
|
|
|
pageFrame = pageFrame->GetNextSibling();
|
2002-08-21 16:01:05 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
return NS_OK;
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
//-----------------------------------------------------------------
|
|
|
|
nsresult nsPrintEngine::GetSeqFrameAndCountPages(nsIFrame*& aSeqFrame, PRInt32& aCount)
|
|
|
|
{
|
|
|
|
NS_ASSERTION(mPrtPreview, "mPrtPreview can't be null!");
|
|
|
|
return GetSeqFrameAndCountPagesInternal(mPrtPreview->mPrintObject, aSeqFrame, aCount);
|
|
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------
|
|
|
|
//-- Done: Methods needed by the DocViewer
|
|
|
|
//---------------------------------------------------------------------------------
|
|
|
|
|
|
|
|
|
|
|
|
//---------------------------------------------------------------------------------
|
|
|
|
//-- Section: nsIWebBrowserPrint
|
|
|
|
//---------------------------------------------------------------------------------
|
|
|
|
|
2002-09-20 01:45:07 +04:00
|
|
|
// Foward decl for Debug Helper Functions
|
|
|
|
#ifdef EXTENDED_DEBUG_PRINTING
|
2004-02-03 01:42:29 +03:00
|
|
|
static int RemoveFilesInDir(const char * aDir);
|
|
|
|
static void GetDocTitleAndURL(nsPrintObject* aPO, char *& aDocStr, char *& aURLStr);
|
|
|
|
static void DumpPrintObjectsTree(nsPrintObject * aPO, int aLevel, FILE* aFD);
|
2009-02-03 17:42:18 +03:00
|
|
|
static void DumpPrintObjectsList(nsTArray<nsPrintObject*> * aDocList);
|
2004-08-01 03:15:21 +04:00
|
|
|
static void RootFrameList(nsPresContext* aPresContext, FILE* out, PRInt32 aIndent);
|
2004-02-03 01:42:29 +03:00
|
|
|
static void DumpViews(nsIDocShell* aDocShell, FILE* out);
|
|
|
|
static void DumpLayoutData(char* aTitleStr, char* aURLStr,
|
2004-08-01 03:15:21 +04:00
|
|
|
nsPresContext* aPresContext,
|
2011-04-17 05:22:44 +04:00
|
|
|
nsDeviceContext * aDC, nsIFrame * aRootFrame,
|
2005-01-04 01:51:17 +03:00
|
|
|
nsIDocShell * aDocShell, FILE* aFD);
|
2002-09-20 01:45:07 +04:00
|
|
|
#endif
|
|
|
|
|
2007-02-23 06:58:36 +03:00
|
|
|
//--------------------------------------------------------------------------------
|
|
|
|
|
|
|
|
nsresult
|
2011-09-29 10:19:26 +04:00
|
|
|
nsPrintEngine::CommonPrint(bool aIsPrintPreview,
|
2007-02-23 06:58:36 +03:00
|
|
|
nsIPrintSettings* aPrintSettings,
|
2009-12-11 07:02:13 +03:00
|
|
|
nsIWebProgressListener* aWebProgressListener,
|
|
|
|
nsIDOMDocument* aDoc) {
|
2007-02-23 06:58:36 +03:00
|
|
|
nsresult rv = DoCommonPrint(aIsPrintPreview, aPrintSettings,
|
2009-12-11 07:02:13 +03:00
|
|
|
aWebProgressListener, aDoc);
|
2007-02-23 06:58:36 +03:00
|
|
|
if (NS_FAILED(rv)) {
|
|
|
|
if (aIsPrintPreview) {
|
2011-10-17 18:59:28 +04:00
|
|
|
SetIsCreatingPrintPreview(false);
|
|
|
|
SetIsPrintPreview(false);
|
2007-02-23 06:58:36 +03:00
|
|
|
} else {
|
2011-10-17 18:59:28 +04:00
|
|
|
SetIsPrinting(false);
|
2007-02-23 06:58:36 +03:00
|
|
|
}
|
|
|
|
if (mProgressDialogIsShown)
|
|
|
|
CloseProgressDialog(aWebProgressListener);
|
|
|
|
if (rv != NS_ERROR_ABORT && rv != NS_ERROR_OUT_OF_MEMORY)
|
|
|
|
ShowPrintErrorDialog(rv, !aIsPrintPreview);
|
|
|
|
delete mPrt;
|
|
|
|
mPrt = nsnull;
|
2002-08-21 16:01:05 +04:00
|
|
|
}
|
|
|
|
|
2007-02-23 06:58:36 +03:00
|
|
|
return rv;
|
|
|
|
}
|
|
|
|
|
|
|
|
nsresult
|
2011-09-29 10:19:26 +04:00
|
|
|
nsPrintEngine::DoCommonPrint(bool aIsPrintPreview,
|
2007-02-23 06:58:36 +03:00
|
|
|
nsIPrintSettings* aPrintSettings,
|
2009-12-11 07:02:13 +03:00
|
|
|
nsIWebProgressListener* aWebProgressListener,
|
|
|
|
nsIDOMDocument* aDoc)
|
2007-02-23 06:58:36 +03:00
|
|
|
{
|
2006-12-10 11:05:05 +03:00
|
|
|
nsresult rv;
|
2002-08-21 16:01:05 +04:00
|
|
|
|
2007-02-23 06:58:36 +03:00
|
|
|
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 != nsnull;
|
|
|
|
|
|
|
|
if (mIsDoingPrintPreview) {
|
|
|
|
mOldPrtPreview = mPrtPreview;
|
|
|
|
mPrtPreview = nsnull;
|
|
|
|
}
|
|
|
|
} else {
|
2011-10-17 18:59:28 +04:00
|
|
|
mProgressDialogIsShown = false;
|
2002-08-21 16:01:05 +04:00
|
|
|
}
|
|
|
|
|
2007-02-23 06:58:36 +03:00
|
|
|
mPrt = new nsPrintData(aIsPrintPreview ? nsPrintData::eIsPrintPreview :
|
|
|
|
nsPrintData::eIsPrinting);
|
|
|
|
NS_ENSURE_TRUE(mPrt, NS_ERROR_OUT_OF_MEMORY);
|
|
|
|
|
2002-08-21 16:01:05 +04:00
|
|
|
// if they don't pass in a PrintSettings, then get the Global PS
|
|
|
|
mPrt->mPrintSettings = aPrintSettings;
|
|
|
|
if (!mPrt->mPrintSettings) {
|
2007-02-23 06:58:36 +03:00
|
|
|
rv = GetGlobalPrintSettings(getter_AddRefs(mPrt->mPrintSettings));
|
|
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
2002-08-21 16:01:05 +04:00
|
|
|
}
|
|
|
|
|
2007-05-06 15:29:41 +04:00
|
|
|
rv = CheckForPrinters(mPrt->mPrintSettings);
|
2007-02-23 06:58:36 +03:00
|
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
2002-08-21 16:01:05 +04:00
|
|
|
|
2011-10-17 18:59:28 +04:00
|
|
|
mPrt->mPrintSettings->SetIsCancelled(false);
|
2002-08-21 16:01:05 +04:00
|
|
|
mPrt->mPrintSettings->GetShrinkToFit(&mPrt->mShrinkToFit);
|
|
|
|
|
2007-02-23 06:58:36 +03:00
|
|
|
if (aIsPrintPreview) {
|
2011-10-17 18:59:28 +04:00
|
|
|
SetIsCreatingPrintPreview(true);
|
|
|
|
SetIsPrintPreview(true);
|
2011-05-30 20:36:23 +04:00
|
|
|
nsCOMPtr<nsIMarkupDocumentViewer> viewer =
|
2007-11-09 13:19:12 +03:00
|
|
|
do_QueryInterface(mDocViewerPrint);
|
|
|
|
if (viewer) {
|
|
|
|
viewer->SetTextZoom(1.0f);
|
|
|
|
viewer->SetFullZoom(1.0f);
|
2011-03-11 07:33:43 +03:00
|
|
|
viewer->SetMinFontSize(0);
|
2007-11-09 13:19:12 +03:00
|
|
|
}
|
2002-08-21 16:01:05 +04:00
|
|
|
}
|
|
|
|
|
2007-02-23 22:29:15 +03:00
|
|
|
// 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);
|
|
|
|
}
|
|
|
|
|
2002-08-21 16:01:05 +04:00
|
|
|
if (aWebProgressListener != nsnull) {
|
2006-12-10 11:05:05 +03:00
|
|
|
mPrt->mPrintProgressListeners.AppendObject(aWebProgressListener);
|
2002-08-21 16:01:05 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
// 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
|
2004-01-28 14:17:14 +03:00
|
|
|
mPrt->mCurrentFocusWin = FindFocusedDOMWindow();
|
2002-08-21 16:01:05 +04:00
|
|
|
|
|
|
|
// Check to see if there is a "regular" selection
|
2011-09-29 10:19:26 +04:00
|
|
|
bool isSelection = IsThereARangeSelection(mPrt->mCurrentFocusWin);
|
2002-08-21 16:01:05 +04:00
|
|
|
|
2005-01-04 01:51:17 +03:00
|
|
|
// Get the docshell for this documentviewer
|
2011-05-10 16:55:26 +04:00
|
|
|
nsCOMPtr<nsIDocShell> webContainer(do_QueryReferent(mContainer, &rv));
|
2007-02-23 06:58:36 +03:00
|
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
2002-08-21 16:01:05 +04:00
|
|
|
|
|
|
|
mPrt->mPrintObject = new nsPrintObject();
|
2007-02-23 06:58:36 +03:00
|
|
|
NS_ENSURE_TRUE(mPrt->mPrintObject, NS_ERROR_OUT_OF_MEMORY);
|
2009-12-11 07:02:13 +03:00
|
|
|
rv = mPrt->mPrintObject->Init(webContainer, aDoc, aIsPrintPreview);
|
2007-02-23 06:58:36 +03:00
|
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
|
2009-02-03 17:42:18 +03:00
|
|
|
NS_ENSURE_TRUE(mPrt->mPrintDocList.AppendElement(mPrt->mPrintObject),
|
2007-02-23 06:58:36 +03:00
|
|
|
NS_ERROR_OUT_OF_MEMORY);
|
2002-08-21 16:01:05 +04:00
|
|
|
|
|
|
|
mPrt->mIsParentAFrameSet = IsParentAFrameSet(webContainer);
|
2007-02-23 06:58:36 +03:00
|
|
|
mPrt->mPrintObject->mFrameType = mPrt->mIsParentAFrameSet ? eFrameSet : eDoc;
|
2002-08-21 16:01:05 +04:00
|
|
|
|
|
|
|
// Build the "tree" of PrintObjects
|
2009-12-11 07:02:13 +03:00
|
|
|
nsCOMPtr<nsIDocShellTreeNode> parentAsNode =
|
|
|
|
do_QueryInterface(mPrt->mPrintObject->mDocShell);
|
2009-02-03 17:42:18 +03:00
|
|
|
BuildDocTree(parentAsNode, &mPrt->mPrintDocList, mPrt->mPrintObject);
|
2002-08-21 16:01:05 +04:00
|
|
|
|
2011-03-24 14:41:16 +03:00
|
|
|
if (!aIsPrintPreview) {
|
2011-10-17 18:59:28 +04:00
|
|
|
SetIsPrinting(true);
|
2011-03-24 14:41:16 +03:00
|
|
|
}
|
|
|
|
|
2007-02-23 06:58:36 +03:00
|
|
|
// XXX This isn't really correct...
|
2009-12-11 07:02:13 +03:00
|
|
|
if (!mPrt->mPrintObject->mDocument ||
|
2010-04-30 17:12:05 +04:00
|
|
|
!mPrt->mPrintObject->mDocument->GetRootElement())
|
2007-02-23 06:58:36 +03:00
|
|
|
return NS_ERROR_GFX_PRINTER_STARTDOC;
|
2006-07-25 20:05:49 +04:00
|
|
|
|
2007-02-23 06:58:36 +03:00
|
|
|
// Create the linkage from the sub-docs back to the content element
|
2002-08-21 16:01:05 +04:00
|
|
|
// 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);
|
|
|
|
|
2007-02-23 06:58:36 +03:00
|
|
|
nsCOMPtr<nsIDeviceContextSpec> devspec
|
|
|
|
(do_CreateInstance("@mozilla.org/gfx/devicecontextspec;1", &rv));
|
|
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
2002-08-21 16:01:05 +04:00
|
|
|
|
2009-03-10 22:30:50 +03:00
|
|
|
nsScriptSuppressor scriptSuppressor(this);
|
2007-02-23 06:58:36 +03:00
|
|
|
if (!aIsPrintPreview) {
|
2002-08-21 16:01:05 +04:00
|
|
|
#ifdef NS_DEBUG
|
|
|
|
mPrt->mDebugFilePtr = mDebugFile;
|
|
|
|
#endif
|
|
|
|
|
2009-03-10 22:30:50 +03:00
|
|
|
scriptSuppressor.Suppress();
|
2011-09-29 10:19:26 +04:00
|
|
|
bool printSilently;
|
2002-08-21 16:01:05 +04:00
|
|
|
mPrt->mPrintSettings->GetPrintSilent(&printSilently);
|
|
|
|
|
|
|
|
// Check prefs for a default setting as to whether we should print silently
|
2011-05-25 10:31:59 +04:00
|
|
|
printSilently =
|
|
|
|
Preferences::GetBool("print.always_print_silent", printSilently);
|
2002-08-21 16:01:05 +04:00
|
|
|
|
|
|
|
// 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) {
|
2005-11-29 02:56:44 +03:00
|
|
|
nsIDOMWindow *domWin = mDocument->GetWindow();
|
2002-08-21 16:01:05 +04:00
|
|
|
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
|
|
|
|
//
|
2006-03-30 04:27:42 +04:00
|
|
|
nsCOMPtr<nsIWebBrowserPrint> wbp(do_QueryInterface(mDocViewerPrint));
|
|
|
|
rv = printPromptService->ShowPrintDialog(domWin, wbp,
|
|
|
|
mPrt->mPrintSettings);
|
2010-12-05 13:16:01 +03:00
|
|
|
//
|
|
|
|
// 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 (NS_SUCCEEDED(rv)) {
|
2002-08-21 16:01:05 +04:00
|
|
|
// since we got the dialog and it worked then make sure we
|
|
|
|
// are telling GFX we want to print silent
|
2011-10-17 18:59:28 +04:00
|
|
|
printSilently = true;
|
2010-12-05 13:16:01 +03:00
|
|
|
|
|
|
|
if (mPrt && 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;
|
2002-08-21 16:01:05 +04:00
|
|
|
}
|
|
|
|
} else {
|
|
|
|
rv = NS_ERROR_GFX_NO_PRINTROMPTSERVICE;
|
|
|
|
}
|
2008-01-21 06:47:25 +03:00
|
|
|
} else {
|
|
|
|
// Call any code that requires a run of the event loop.
|
|
|
|
rv = mPrt->mPrintSettings->SetupSilentPrinting();
|
2002-08-21 16:01:05 +04:00
|
|
|
}
|
2007-02-23 06:58:36 +03:00
|
|
|
// Check explicitly for abort because it's expected
|
|
|
|
if (rv == NS_ERROR_ABORT)
|
|
|
|
return rv;
|
|
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
}
|
2002-08-21 16:01:05 +04:00
|
|
|
|
2007-02-23 06:58:36 +03:00
|
|
|
rv = devspec->Init(nsnull, mPrt->mPrintSettings, aIsPrintPreview);
|
|
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
2002-08-21 16:01:05 +04:00
|
|
|
|
2011-04-17 05:22:42 +04:00
|
|
|
mPrt->mPrintDC = new nsDeviceContext();
|
2007-02-23 06:58:36 +03:00
|
|
|
rv = mPrt->mPrintDC->InitForPrinting(devspec);
|
|
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
2011-04-17 05:22:42 +04:00
|
|
|
|
2007-02-23 06:58:36 +03:00
|
|
|
if (aIsPrintPreview) {
|
|
|
|
mPrt->mPrintSettings->SetPrintFrameType(nsIPrintSettings::kFramesAsIs);
|
2002-08-21 16:01:05 +04:00
|
|
|
|
2007-02-23 06:58:36 +03:00
|
|
|
// 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
|
|
|
|
PRInt16 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
|
|
|
|
PRInt16 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
|
|
|
|
PRInt16 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
|
2004-02-03 01:17:21 +03:00
|
|
|
mPrt->mPrintFrameType = nsIPrintSettings::kEachFrameSep;
|
2002-08-21 16:01:05 +04:00
|
|
|
}
|
2007-02-23 06:58:36 +03:00
|
|
|
break;
|
|
|
|
} // switch
|
|
|
|
mPrt->mPrintSettings->SetPrintFrameType(mPrt->mPrintFrameType);
|
2002-08-21 16:01:05 +04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
} else {
|
2007-02-23 06:58:36 +03:00
|
|
|
mPrt->mPrintSettings->GetPrintFrameType(&mPrt->mPrintFrameType);
|
2002-08-21 16:01:05 +04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2007-02-23 06:58:36 +03:00
|
|
|
if (aIsPrintPreview) {
|
2011-09-29 10:19:26 +04:00
|
|
|
bool notifyOnInit = false;
|
2011-10-17 18:59:28 +04:00
|
|
|
ShowPrintProgress(false, notifyOnInit);
|
2007-02-23 06:58:36 +03:00
|
|
|
|
|
|
|
// Very important! Turn Off scripting
|
2011-10-17 18:59:28 +04:00
|
|
|
TurnScriptingOn(false);
|
2007-02-23 06:58:36 +03:00
|
|
|
|
|
|
|
if (!notifyOnInit) {
|
|
|
|
rv = FinishPrintPreview();
|
|
|
|
} else {
|
|
|
|
rv = NS_OK;
|
|
|
|
}
|
|
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
} else {
|
2011-09-29 10:19:26 +04:00
|
|
|
bool doNotify;
|
2011-10-17 18:59:28 +04:00
|
|
|
ShowPrintProgress(true, doNotify);
|
2007-02-23 06:58:36 +03:00
|
|
|
if (!doNotify) {
|
|
|
|
// Print listener setup...
|
2011-04-17 05:22:44 +04:00
|
|
|
mPrt->OnStartPrinting();
|
2007-02-23 06:58:36 +03:00
|
|
|
rv = DocumentReadyForPrinting();
|
|
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
}
|
2002-08-21 16:01:05 +04:00
|
|
|
}
|
|
|
|
|
2009-03-10 22:30:50 +03:00
|
|
|
// We will enable scripting later after printing has finished.
|
|
|
|
scriptSuppressor.Disconnect();
|
|
|
|
|
2007-02-23 06:58:36 +03:00
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
//---------------------------------------------------------------------------------
|
|
|
|
NS_IMETHODIMP
|
|
|
|
nsPrintEngine::Print(nsIPrintSettings* aPrintSettings,
|
|
|
|
nsIWebProgressListener* aWebProgressListener)
|
|
|
|
{
|
2010-01-18 15:39:34 +03:00
|
|
|
// 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);
|
|
|
|
|
2011-10-17 18:59:28 +04:00
|
|
|
return CommonPrint(false, aPrintSettings, aWebProgressListener, doc);
|
2002-08-21 16:01:05 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
nsPrintEngine::PrintPreview(nsIPrintSettings* aPrintSettings,
|
|
|
|
nsIDOMWindow *aChildDOMWin,
|
|
|
|
nsIWebProgressListener* aWebProgressListener)
|
|
|
|
{
|
2008-03-14 00:12:55 +03:00
|
|
|
// Get the DocShell and see if it is busy
|
|
|
|
// (We can't Print Preview this document if it is still busy)
|
2011-05-10 16:55:26 +04:00
|
|
|
nsCOMPtr<nsIDocShell> docShell(do_QueryReferent(mContainer));
|
|
|
|
NS_ENSURE_STATE(docShell);
|
2008-03-14 00:12:55 +03:00
|
|
|
|
|
|
|
PRUint32 busyFlags = nsIDocShell::BUSY_FLAGS_NONE;
|
|
|
|
if (NS_FAILED(docShell->GetBusyFlags(&busyFlags)) ||
|
|
|
|
busyFlags != nsIDocShell::BUSY_FLAGS_NONE) {
|
|
|
|
CloseProgressDialog(aWebProgressListener);
|
2011-10-17 18:59:28 +04:00
|
|
|
ShowPrintErrorDialog(NS_ERROR_GFX_PRINTER_DOC_IS_BUSY_PP, false);
|
2008-03-14 00:12:55 +03:00
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
}
|
|
|
|
|
2009-12-11 07:02:13 +03:00
|
|
|
NS_ENSURE_STATE(aChildDOMWin);
|
|
|
|
nsCOMPtr<nsIDOMDocument> doc;
|
|
|
|
aChildDOMWin->GetDocument(getter_AddRefs(doc));
|
|
|
|
NS_ENSURE_STATE(doc);
|
|
|
|
|
2008-03-14 00:12:55 +03:00
|
|
|
// Document is not busy -- go ahead with the Print Preview
|
2011-10-17 18:59:28 +04:00
|
|
|
return CommonPrint(true, aPrintSettings, aWebProgressListener, doc);
|
2002-08-21 16:01:05 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
//----------------------------------------------------------------------------------
|
|
|
|
/* readonly attribute boolean isFramesetDocument; */
|
|
|
|
NS_IMETHODIMP
|
2011-09-29 10:19:26 +04:00
|
|
|
nsPrintEngine::GetIsFramesetDocument(bool *aIsFramesetDocument)
|
2002-08-21 16:01:05 +04:00
|
|
|
{
|
2011-05-10 16:55:26 +04:00
|
|
|
nsCOMPtr<nsIDocShell> webContainer(do_QueryReferent(mContainer));
|
2002-08-21 16:01:05 +04:00
|
|
|
*aIsFramesetDocument = IsParentAFrameSet(webContainer);
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
//----------------------------------------------------------------------------------
|
|
|
|
/* readonly attribute boolean isIFrameSelected; */
|
|
|
|
NS_IMETHODIMP
|
2011-09-29 10:19:26 +04:00
|
|
|
nsPrintEngine::GetIsIFrameSelected(bool *aIsIFrameSelected)
|
2002-08-21 16:01:05 +04:00
|
|
|
{
|
2011-10-17 18:59:28 +04:00
|
|
|
*aIsIFrameSelected = false;
|
2002-08-21 16:01:05 +04:00
|
|
|
|
2005-01-04 01:51:17 +03:00
|
|
|
// Get the docshell for this documentviewer
|
2011-05-10 16:55:26 +04:00
|
|
|
nsCOMPtr<nsIDocShell> webContainer(do_QueryReferent(mContainer));
|
2002-08-21 16:01:05 +04:00
|
|
|
// Get the currently focused window
|
2004-01-28 14:17:14 +03:00
|
|
|
nsCOMPtr<nsIDOMWindow> currentFocusWin = FindFocusedDOMWindow();
|
2002-08-21 16:01:05 +04:00
|
|
|
if (currentFocusWin && webContainer) {
|
|
|
|
// Get whether the doc contains a frameset
|
2005-01-04 01:51:17 +03:00
|
|
|
// Also, check to see if the currently focus docshell
|
|
|
|
// is a child of this docshell
|
2011-09-29 10:19:26 +04:00
|
|
|
bool isParentFrameSet;
|
2002-08-21 16:01:05 +04:00
|
|
|
*aIsIFrameSelected = IsThereAnIFrameSelected(webContainer, currentFocusWin, isParentFrameSet);
|
|
|
|
}
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
//----------------------------------------------------------------------------------
|
|
|
|
/* readonly attribute boolean isRangeSelection; */
|
|
|
|
NS_IMETHODIMP
|
2011-09-29 10:19:26 +04:00
|
|
|
nsPrintEngine::GetIsRangeSelection(bool *aIsRangeSelection)
|
2002-08-21 16:01:05 +04:00
|
|
|
{
|
|
|
|
// Get the currently focused window
|
2004-01-28 14:17:14 +03:00
|
|
|
nsCOMPtr<nsIDOMWindow> currentFocusWin = FindFocusedDOMWindow();
|
2002-08-21 16:01:05 +04:00
|
|
|
*aIsRangeSelection = IsThereARangeSelection(currentFocusWin);
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
//----------------------------------------------------------------------------------
|
|
|
|
/* readonly attribute boolean isFramesetFrameSelected; */
|
|
|
|
NS_IMETHODIMP
|
2011-09-29 10:19:26 +04:00
|
|
|
nsPrintEngine::GetIsFramesetFrameSelected(bool *aIsFramesetFrameSelected)
|
2002-08-21 16:01:05 +04:00
|
|
|
{
|
|
|
|
// Get the currently focused window
|
2004-01-28 14:17:14 +03:00
|
|
|
nsCOMPtr<nsIDOMWindow> currentFocusWin = FindFocusedDOMWindow();
|
2002-08-21 16:01:05 +04:00
|
|
|
*aIsFramesetFrameSelected = currentFocusWin != nsnull;
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
//----------------------------------------------------------------------------------
|
|
|
|
/* readonly attribute long printPreviewNumPages; */
|
|
|
|
NS_IMETHODIMP
|
|
|
|
nsPrintEngine::GetPrintPreviewNumPages(PRInt32 *aPrintPreviewNumPages)
|
|
|
|
{
|
|
|
|
NS_ENSURE_ARG_POINTER(aPrintPreviewNumPages);
|
|
|
|
|
|
|
|
nsIFrame* seqFrame = nsnull;
|
|
|
|
*aPrintPreviewNumPages = 0;
|
|
|
|
if (!mPrtPreview ||
|
|
|
|
NS_FAILED(GetSeqFrameAndCountPagesInternal(mPrtPreview->mPrintObject, seqFrame, *aPrintPreviewNumPages))) {
|
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
}
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
//----------------------------------------------------------------------------------
|
|
|
|
// Enumerate all the documents for their titles
|
|
|
|
NS_IMETHODIMP
|
|
|
|
nsPrintEngine::EnumerateDocumentNames(PRUint32* aCount,
|
|
|
|
PRUnichar*** aResult)
|
|
|
|
{
|
|
|
|
NS_ENSURE_ARG(aCount);
|
|
|
|
NS_ENSURE_ARG_POINTER(aResult);
|
|
|
|
|
|
|
|
*aCount = 0;
|
|
|
|
*aResult = nsnull;
|
|
|
|
|
2009-02-03 17:42:18 +03:00
|
|
|
PRInt32 numDocs = mPrt->mPrintDocList.Length();
|
2002-08-21 16:01:05 +04:00
|
|
|
PRUnichar** array = (PRUnichar**) nsMemory::Alloc(numDocs * sizeof(PRUnichar*));
|
|
|
|
if (!array)
|
|
|
|
return NS_ERROR_OUT_OF_MEMORY;
|
|
|
|
|
|
|
|
for (PRInt32 i=0;i<numDocs;i++) {
|
2009-02-03 17:42:18 +03:00
|
|
|
nsPrintObject* po = mPrt->mPrintDocList.ElementAt(i);
|
2002-08-21 16:01:05 +04:00
|
|
|
NS_ASSERTION(po, "nsPrintObject can't be null!");
|
|
|
|
PRUnichar * docTitleStr;
|
|
|
|
PRUnichar * docURLStr;
|
2004-02-01 15:10:57 +03:00
|
|
|
GetDocumentTitleAndURL(po->mDocument, &docTitleStr, &docURLStr);
|
2002-08-21 16:01:05 +04:00
|
|
|
|
|
|
|
// Use the URL if the doc is empty
|
|
|
|
if (!docTitleStr || !*docTitleStr) {
|
2002-11-17 08:16:49 +03:00
|
|
|
if (docURLStr && *docURLStr) {
|
2002-08-21 16:01:05 +04:00
|
|
|
nsMemory::Free(docTitleStr);
|
|
|
|
docTitleStr = docURLStr;
|
|
|
|
} else {
|
|
|
|
nsMemory::Free(docURLStr);
|
|
|
|
}
|
|
|
|
docURLStr = nsnull;
|
|
|
|
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; */
|
2006-03-30 04:27:42 +04:00
|
|
|
nsresult
|
|
|
|
nsPrintEngine::GetGlobalPrintSettings(nsIPrintSettings **aGlobalPrintSettings)
|
2002-08-21 16:01:05 +04:00
|
|
|
{
|
|
|
|
NS_ENSURE_ARG_POINTER(aGlobalPrintSettings);
|
|
|
|
|
|
|
|
nsresult rv = NS_ERROR_FAILURE;
|
2006-03-30 04:27:42 +04:00
|
|
|
nsCOMPtr<nsIPrintSettingsService> printSettingsService =
|
|
|
|
do_GetService(sPrintSettingsServiceContractID, &rv);
|
2002-08-21 16:01:05 +04:00
|
|
|
if (NS_SUCCEEDED(rv)) {
|
|
|
|
rv = printSettingsService->GetGlobalPrintSettings(aGlobalPrintSettings);
|
|
|
|
}
|
|
|
|
return rv;
|
|
|
|
}
|
|
|
|
|
|
|
|
//----------------------------------------------------------------------------------
|
|
|
|
/* readonly attribute boolean doingPrint; */
|
|
|
|
NS_IMETHODIMP
|
2011-09-29 10:19:26 +04:00
|
|
|
nsPrintEngine::GetDoingPrint(bool *aDoingPrint)
|
2002-08-21 16:01:05 +04:00
|
|
|
{
|
|
|
|
NS_ENSURE_ARG_POINTER(aDoingPrint);
|
|
|
|
*aDoingPrint = mIsDoingPrinting;
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
//----------------------------------------------------------------------------------
|
|
|
|
/* readonly attribute boolean doingPrintPreview; */
|
|
|
|
NS_IMETHODIMP
|
2011-09-29 10:19:26 +04:00
|
|
|
nsPrintEngine::GetDoingPrintPreview(bool *aDoingPrintPreview)
|
2002-08-21 16:01:05 +04:00
|
|
|
{
|
|
|
|
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 = nsnull;
|
|
|
|
}
|
|
|
|
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
|
2007-05-06 15:29:41 +04:00
|
|
|
nsPrintEngine::CheckForPrinters(nsIPrintSettings* aPrintSettings)
|
2002-08-21 16:01:05 +04:00
|
|
|
{
|
2010-11-17 02:33:56 +03:00
|
|
|
#if defined(XP_MACOSX) || defined(ANDROID)
|
2007-05-06 15:29:41 +04:00
|
|
|
// Mac doesn't support retrieving a printer list.
|
|
|
|
return NS_OK;
|
|
|
|
#else
|
2002-08-21 16:01:05 +04:00
|
|
|
NS_ENSURE_ARG_POINTER(aPrintSettings);
|
|
|
|
|
2007-05-06 15:29:41 +04:00
|
|
|
// 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;
|
|
|
|
}
|
2007-05-06 15:29:42 +04:00
|
|
|
|
2007-05-06 15:29:41 +04:00
|
|
|
// 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());
|
2002-08-21 16:01:05 +04:00
|
|
|
}
|
|
|
|
return rv;
|
2007-05-06 15:29:41 +04:00
|
|
|
#endif
|
2002-08-21 16:01:05 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
//----------------------------------------------------------------------
|
|
|
|
// Set up to use the "pluggable" Print Progress Dialog
|
|
|
|
void
|
2011-09-29 10:19:26 +04:00
|
|
|
nsPrintEngine::ShowPrintProgress(bool aIsForPrinting, bool& aDoNotify)
|
2002-08-21 16:01:05 +04:00
|
|
|
{
|
|
|
|
// 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.
|
2011-10-17 18:59:28 +04:00
|
|
|
aDoNotify = false;
|
2002-08-21 16:01:05 +04:00
|
|
|
|
|
|
|
// Assume we can't do progress and then see if we can
|
2011-09-29 10:19:26 +04:00
|
|
|
bool showProgresssDialog = false;
|
2002-08-21 16:01:05 +04:00
|
|
|
|
|
|
|
// 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
|
2007-02-23 06:58:36 +03:00
|
|
|
if (!mProgressDialogIsShown) {
|
2011-05-25 10:31:59 +04:00
|
|
|
showProgresssDialog = Preferences::GetBool("print.show_print_progress");
|
2002-08-21 16:01:05 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
// 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.
|
2006-12-10 11:05:05 +03:00
|
|
|
if (showProgresssDialog) {
|
|
|
|
mPrt->mPrintSettings->GetShowPrintProgress(&showProgresssDialog);
|
2002-08-21 16:01:05 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
// 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
|
2006-12-10 11:05:05 +03:00
|
|
|
if (showProgresssDialog) {
|
2002-08-21 16:01:05 +04:00
|
|
|
nsCOMPtr<nsIPrintingPromptService> printPromptService(do_GetService(kPrintingPromptService));
|
|
|
|
if (printPromptService) {
|
2005-11-29 02:56:44 +03:00
|
|
|
nsPIDOMWindow *domWin = mDocument->GetWindow();
|
2002-08-21 16:01:05 +04:00
|
|
|
if (!domWin) return;
|
|
|
|
|
2007-11-12 15:17:23 +03:00
|
|
|
nsCOMPtr<nsIDocShellTreeItem> docShellItem =
|
|
|
|
do_QueryInterface(domWin->GetDocShell());
|
|
|
|
if (!docShellItem) return;
|
|
|
|
nsCOMPtr<nsIDocShellTreeOwner> owner;
|
|
|
|
docShellItem->GetTreeOwner(getter_AddRefs(owner));
|
|
|
|
nsCOMPtr<nsIWebBrowserChrome> browserChrome = do_GetInterface(owner);
|
|
|
|
if (!browserChrome) return;
|
2011-09-29 10:19:26 +04:00
|
|
|
bool isModal = true;
|
2007-11-12 15:17:23 +03:00
|
|
|
browserChrome->IsWindowModal(&isModal);
|
|
|
|
if (isModal) {
|
|
|
|
// Showing a print progress dialog when printing a modal window
|
|
|
|
// isn't supported. See bug 301560.
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2006-12-10 11:05:05 +03:00
|
|
|
nsCOMPtr<nsIWebProgressListener> printProgressListener;
|
|
|
|
|
2002-08-21 16:01:05 +04:00
|
|
|
nsCOMPtr<nsIWebBrowserPrint> wbp(do_QueryInterface(mDocViewerPrint));
|
|
|
|
nsresult rv = printPromptService->ShowProgress(domWin, wbp, mPrt->mPrintSettings, this, aIsForPrinting,
|
2006-12-10 11:05:05 +03:00
|
|
|
getter_AddRefs(printProgressListener),
|
2002-08-21 16:01:05 +04:00
|
|
|
getter_AddRefs(mPrt->mPrintProgressParams),
|
|
|
|
&aDoNotify);
|
|
|
|
if (NS_SUCCEEDED(rv)) {
|
2006-12-10 11:05:05 +03:00
|
|
|
if (printProgressListener && mPrt->mPrintProgressParams) {
|
|
|
|
mPrt->mPrintProgressListeners.AppendObject(printProgressListener);
|
2002-08-21 16:01:05 +04:00
|
|
|
SetDocAndURLIntoProgress(mPrt->mPrintObject, mPrt->mPrintProgressParams);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
//---------------------------------------------------------------------
|
2011-09-29 10:19:26 +04:00
|
|
|
bool
|
2004-01-28 14:17:14 +03:00
|
|
|
nsPrintEngine::IsThereARangeSelection(nsIDOMWindow* aDOMWin)
|
2002-08-21 16:01:05 +04:00
|
|
|
{
|
|
|
|
nsCOMPtr<nsIPresShell> presShell;
|
2004-01-28 14:17:14 +03:00
|
|
|
if (aDOMWin) {
|
2005-11-29 02:56:44 +03:00
|
|
|
nsCOMPtr<nsPIDOMWindow> window(do_QueryInterface(aDOMWin));
|
|
|
|
window->GetDocShell()->GetPresShell(getter_AddRefs(presShell));
|
2002-08-21 16:01:05 +04:00
|
|
|
}
|
|
|
|
|
2006-12-10 11:05:05 +03:00
|
|
|
if (!presShell)
|
2011-10-17 18:59:28 +04:00
|
|
|
return false;
|
2006-12-10 11:05:05 +03:00
|
|
|
|
2002-08-21 16:01:05 +04:00
|
|
|
// check here to see if there is a range selection
|
|
|
|
// so we know whether to turn on the "Selection" radio button
|
|
|
|
nsCOMPtr<nsISelection> selection;
|
2006-12-10 11:05:05 +03:00
|
|
|
selection = presShell->GetCurrentSelection(nsISelectionController::SELECTION_NORMAL);
|
2002-08-21 16:01:05 +04:00
|
|
|
if (selection) {
|
|
|
|
PRInt32 count;
|
|
|
|
selection->GetRangeCount(&count);
|
|
|
|
if (count == 1) {
|
|
|
|
nsCOMPtr<nsIDOMRange> range;
|
|
|
|
if (NS_SUCCEEDED(selection->GetRangeAt(0, getter_AddRefs(range)))) {
|
|
|
|
// check to make sure it isn't an insertion selection
|
2011-09-29 10:19:26 +04:00
|
|
|
bool isCollapsed;
|
2002-08-21 16:01:05 +04:00
|
|
|
selection->GetIsCollapsed(&isCollapsed);
|
|
|
|
return !isCollapsed;
|
|
|
|
}
|
|
|
|
}
|
2011-10-17 18:59:28 +04:00
|
|
|
if (count > 1) return true;
|
2002-08-21 16:01:05 +04:00
|
|
|
}
|
2011-10-17 18:59:28 +04:00
|
|
|
return false;
|
2002-08-21 16:01:05 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
//---------------------------------------------------------------------
|
2011-09-29 10:19:26 +04:00
|
|
|
bool
|
2005-01-04 01:51:17 +03:00
|
|
|
nsPrintEngine::IsParentAFrameSet(nsIDocShell * aParent)
|
2002-08-21 16:01:05 +04:00
|
|
|
{
|
2005-11-21 01:05:24 +03:00
|
|
|
// See if the incoming doc is the root document
|
2002-08-21 16:01:05 +04:00
|
|
|
nsCOMPtr<nsIDocShellTreeItem> parentAsItem(do_QueryInterface(aParent));
|
2011-10-17 18:59:28 +04:00
|
|
|
if (!parentAsItem) return false;
|
2002-08-21 16:01:05 +04:00
|
|
|
|
|
|
|
// 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
|
2011-09-29 10:19:26 +04:00
|
|
|
bool isFrameSet = false;
|
2002-08-21 16:01:05 +04:00
|
|
|
// 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
|
2009-12-11 07:02:13 +03:00
|
|
|
nsCOMPtr<nsIDOMDocument> domDoc = do_GetInterface(aParent);
|
|
|
|
nsCOMPtr<nsIDocument> doc = do_QueryInterface(domDoc);
|
|
|
|
if (doc) {
|
2010-04-30 17:12:05 +04:00
|
|
|
nsIContent *rootElement = doc->GetRootElement();
|
|
|
|
if (rootElement) {
|
|
|
|
isFrameSet = HasFramesetChild(rootElement);
|
2002-08-21 16:01:05 +04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
return isFrameSet;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
//---------------------------------------------------------------------
|
2005-11-21 01:05:24 +03:00
|
|
|
// Recursively build a list of sub documents to be printed
|
2002-08-21 16:01:05 +04:00
|
|
|
// that mirrors the document tree
|
|
|
|
void
|
2009-02-03 17:42:18 +03:00
|
|
|
nsPrintEngine::BuildDocTree(nsIDocShellTreeNode * aParentNode,
|
|
|
|
nsTArray<nsPrintObject*> * aDocList,
|
|
|
|
nsPrintObject * aPO)
|
2002-08-21 16:01:05 +04:00
|
|
|
{
|
|
|
|
NS_ASSERTION(aParentNode, "Pointer is null!");
|
|
|
|
NS_ASSERTION(aDocList, "Pointer is null!");
|
|
|
|
NS_ASSERTION(aPO, "Pointer is null!");
|
|
|
|
|
|
|
|
PRInt32 childWebshellCount;
|
|
|
|
aParentNode->GetChildCount(&childWebshellCount);
|
|
|
|
if (childWebshellCount > 0) {
|
|
|
|
for (PRInt32 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) {
|
2005-01-04 01:51:17 +03:00
|
|
|
nsCOMPtr<nsIDocShell> childDocShell(do_QueryInterface(child));
|
2002-08-21 16:01:05 +04:00
|
|
|
nsCOMPtr<nsIDocShellTreeNode> childNode(do_QueryInterface(child));
|
2009-12-11 07:02:13 +03:00
|
|
|
nsCOMPtr<nsIDOMDocument> doc = do_GetInterface(childDocShell);
|
2002-08-21 16:01:05 +04:00
|
|
|
nsPrintObject * po = new nsPrintObject();
|
2009-12-11 07:02:13 +03:00
|
|
|
po->mParent = aPO;
|
|
|
|
nsresult rv = po->Init(childDocShell, doc, aPO->mPrintPreview);
|
2006-12-10 11:05:05 +03:00
|
|
|
if (NS_FAILED(rv))
|
|
|
|
NS_NOTREACHED("Init failed?");
|
2002-08-21 16:01:05 +04:00
|
|
|
aPO->mKids.AppendElement(po);
|
|
|
|
aDocList->AppendElement(po);
|
|
|
|
BuildDocTree(childNode, aDocList, po);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
//---------------------------------------------------------------------
|
|
|
|
void
|
2004-02-01 15:10:57 +03:00
|
|
|
nsPrintEngine::GetDocumentTitleAndURL(nsIDocument* aDoc,
|
2002-08-21 16:01:05 +04:00
|
|
|
PRUnichar** aTitle,
|
|
|
|
PRUnichar** aURLStr)
|
|
|
|
{
|
|
|
|
NS_ASSERTION(aDoc, "Pointer is null!");
|
|
|
|
NS_ASSERTION(aTitle, "Pointer is null!");
|
|
|
|
NS_ASSERTION(aURLStr, "Pointer is null!");
|
|
|
|
|
|
|
|
*aTitle = nsnull;
|
|
|
|
*aURLStr = nsnull;
|
|
|
|
|
2008-08-18 06:10:28 +04:00
|
|
|
nsAutoString docTitle;
|
2011-05-28 11:43:53 +04:00
|
|
|
nsCOMPtr<nsIDOMDocument> doc = do_QueryInterface(aDoc);
|
2008-08-18 06:10:28 +04:00
|
|
|
doc->GetTitle(docTitle);
|
2003-03-26 10:41:30 +03:00
|
|
|
if (!docTitle.IsEmpty()) {
|
|
|
|
*aTitle = ToNewUnicode(docTitle);
|
2002-08-21 16:01:05 +04:00
|
|
|
}
|
|
|
|
|
2004-01-10 02:54:21 +03:00
|
|
|
nsIURI* url = aDoc->GetDocumentURI();
|
2002-08-21 16:01:05 +04:00
|
|
|
if (!url) return;
|
|
|
|
|
2005-03-18 07:16:02 +03:00
|
|
|
nsCOMPtr<nsIURIFixup> urifixup(do_GetService(NS_URIFIXUP_CONTRACTID));
|
|
|
|
if (!urifixup) return;
|
|
|
|
|
|
|
|
nsCOMPtr<nsIURI> exposableURI;
|
|
|
|
urifixup->CreateExposableURI(url, getter_AddRefs(exposableURI));
|
|
|
|
|
|
|
|
if (!exposableURI) return;
|
|
|
|
|
2002-08-21 16:01:05 +04:00
|
|
|
nsCAutoString urlCStr;
|
2005-03-18 07:16:02 +03:00
|
|
|
exposableURI->GetSpec(urlCStr);
|
2010-01-06 10:09:18 +03:00
|
|
|
|
|
|
|
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);
|
2002-08-21 16:01:05 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
//---------------------------------------------------------------------
|
|
|
|
// 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,
|
2006-03-30 04:27:42 +04:00
|
|
|
nsPrintObject* aPO)
|
2002-08-21 16:01:05 +04:00
|
|
|
{
|
|
|
|
NS_ASSERTION(aRootPO, "Pointer is null!");
|
|
|
|
NS_ASSERTION(aPO, "Pointer is null!");
|
|
|
|
|
|
|
|
// Recursively walk the content from the root item
|
2006-03-30 04:27:42 +04:00
|
|
|
// XXX Would be faster to enumerate the subdocuments, although right now
|
|
|
|
// nsIDocument doesn't expose quite what would be needed.
|
2009-12-11 07:02:13 +03:00
|
|
|
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;
|
|
|
|
|
2010-04-30 17:12:05 +04:00
|
|
|
Element* rootElement = doc->GetRootElement();
|
|
|
|
if (rootElement) {
|
|
|
|
MapContentForPO(aPO, rootElement);
|
2008-09-09 22:26:20 +04:00
|
|
|
} else {
|
|
|
|
NS_WARNING("Null root content on (sub)document.");
|
|
|
|
}
|
2002-08-21 16:01:05 +04:00
|
|
|
|
|
|
|
// Continue recursively walking the chilren of this PO
|
2009-02-03 17:42:18 +03:00
|
|
|
for (PRUint32 i=0;i<aPO->mKids.Length();i++) {
|
|
|
|
MapContentToWebShells(aRootPO, aPO->mKids[i]);
|
2002-08-21 16:01:05 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
//-------------------------------------------------------
|
|
|
|
// 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
|
2011-09-29 10:19:26 +04:00
|
|
|
bool hasChildFrames = false;
|
2009-02-03 17:42:18 +03:00
|
|
|
for (PRUint32 i=0;i<aPO->mKids.Length();i++) {
|
|
|
|
nsPrintObject* po = aPO->mKids[i];
|
2002-08-21 16:01:05 +04:00
|
|
|
if (po->mFrameType == eFrame) {
|
2011-10-17 18:59:28 +04:00
|
|
|
hasChildFrames = true;
|
2006-03-30 04:27:42 +04:00
|
|
|
CheckForChildFrameSets(po);
|
2002-08-21 16:01:05 +04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
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
|
2005-11-21 01:05:24 +03:00
|
|
|
// given Frame or IFrame in its parent sub-doc.
|
2002-08-21 16:01:05 +04:00
|
|
|
//
|
|
|
|
// So the Mcontent pointer in the child sub-doc points to the
|
2005-11-21 01:05:24 +03:00
|
|
|
// content in the its parent document, that caused it to be printed.
|
2002-08-21 16:01:05 +04:00
|
|
|
// This is used later to (after reflow) to find the absolute location
|
2005-11-21 01:05:24 +03:00
|
|
|
// of the sub-doc on its parent's page frame so it can be
|
2002-08-21 16:01:05 +04:00
|
|
|
// 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
|
2006-03-30 04:27:42 +04:00
|
|
|
nsPrintEngine::MapContentForPO(nsPrintObject* aPO,
|
|
|
|
nsIContent* aContent)
|
2002-08-21 16:01:05 +04:00
|
|
|
{
|
2006-03-30 04:27:42 +04:00
|
|
|
NS_PRECONDITION(aPO && aContent, "Null argument");
|
2002-08-21 16:01:05 +04:00
|
|
|
|
2003-07-29 01:09:56 +04:00
|
|
|
nsIDocument* doc = aContent->GetDocument();
|
2002-08-21 16:01:05 +04:00
|
|
|
|
2006-03-30 04:27:42 +04:00
|
|
|
NS_ASSERTION(doc, "Content without a document from a document tree?");
|
2002-08-21 16:01:05 +04:00
|
|
|
|
2003-10-22 10:09:48 +04:00
|
|
|
nsIDocument* subDoc = doc->GetSubDocumentFor(aContent);
|
2002-08-21 16:01:05 +04:00
|
|
|
|
|
|
|
if (subDoc) {
|
2003-10-22 10:09:48 +04:00
|
|
|
nsCOMPtr<nsISupports> container = subDoc->GetContainer();
|
2005-01-04 01:51:17 +03:00
|
|
|
nsCOMPtr<nsIDocShell> docShell(do_QueryInterface(container));
|
2002-08-21 16:01:05 +04:00
|
|
|
|
2006-03-30 04:27:42 +04:00
|
|
|
if (docShell) {
|
|
|
|
nsPrintObject * po = nsnull;
|
2009-02-03 17:42:18 +03:00
|
|
|
PRInt32 cnt = aPO->mKids.Length();
|
2006-03-30 04:27:42 +04:00
|
|
|
for (PRInt32 i=0;i<cnt;i++) {
|
2009-02-03 17:42:18 +03:00
|
|
|
nsPrintObject* kid = aPO->mKids.ElementAt(i);
|
2006-03-30 04:27:42 +04:00
|
|
|
if (kid->mDocument == subDoc) {
|
|
|
|
po = kid;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2002-08-21 16:01:05 +04:00
|
|
|
|
2006-03-30 04:27:42 +04:00
|
|
|
// XXX If a subdocument has no onscreen presentation, there will be no PO
|
|
|
|
// This is even if there should be a print presentation
|
2002-08-21 16:01:05 +04:00
|
|
|
if (po) {
|
|
|
|
|
2006-03-30 04:27:42 +04:00
|
|
|
nsCOMPtr<nsIDOMHTMLFrameElement> frame(do_QueryInterface(aContent));
|
2008-02-07 07:00:50 +03:00
|
|
|
// "frame" elements not in a frameset context should be treated
|
|
|
|
// as iframes
|
|
|
|
if (frame && po->mParent->mFrameType == eFrameSet) {
|
2006-03-30 04:27:42 +04:00
|
|
|
po->mFrameType = eFrame;
|
2002-08-21 16:01:05 +04:00
|
|
|
} else {
|
2006-03-30 04:27:42 +04:00
|
|
|
// Assume something iframe-like, i.e. iframe, object, or embed
|
|
|
|
po->mFrameType = eIFrame;
|
2011-10-17 18:59:28 +04:00
|
|
|
SetPrintAsIs(po, true);
|
2006-03-30 04:27:42 +04:00
|
|
|
NS_ASSERTION(po->mParent, "The root must be a parent");
|
2011-10-17 18:59:28 +04:00
|
|
|
po->mParent->mPrintAsIs = true;
|
2002-08-21 16:01:05 +04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// walk children content
|
2012-01-25 11:50:07 +04:00
|
|
|
for (nsIContent* child = aContent->GetFirstChild();
|
|
|
|
child;
|
|
|
|
child = child->GetNextSibling()) {
|
2006-03-30 04:27:42 +04:00
|
|
|
MapContentForPO(aPO, child);
|
2002-08-21 16:01:05 +04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
//---------------------------------------------------------------------
|
2011-09-29 10:19:26 +04:00
|
|
|
bool
|
2005-01-04 01:51:17 +03:00
|
|
|
nsPrintEngine::IsThereAnIFrameSelected(nsIDocShell* aDocShell,
|
2004-01-28 14:17:14 +03:00
|
|
|
nsIDOMWindow* aDOMWin,
|
2011-09-29 10:19:26 +04:00
|
|
|
bool& aIsParentFrameSet)
|
2002-08-21 16:01:05 +04:00
|
|
|
{
|
2005-01-04 01:51:17 +03:00
|
|
|
aIsParentFrameSet = IsParentAFrameSet(aDocShell);
|
2011-09-29 10:19:26 +04:00
|
|
|
bool iFrameIsSelected = false;
|
2002-08-21 16:01:05 +04:00
|
|
|
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
|
2005-01-04 01:51:17 +03:00
|
|
|
// if so, it means the selected frame is either the main docshell
|
2002-08-21 16:01:05 +04:00
|
|
|
// or an IFRAME
|
2004-01-28 14:17:14 +03:00
|
|
|
if (aDOMWin) {
|
2005-01-04 01:51:17 +03:00
|
|
|
// Get the main docshell's DOMWin to see if it matches
|
2002-08-21 16:01:05 +04:00
|
|
|
// the frame that is selected
|
2005-01-04 01:51:17 +03:00
|
|
|
nsCOMPtr<nsIDOMWindow> domWin = do_GetInterface(aDocShell);
|
2004-01-28 14:17:14 +03:00
|
|
|
if (domWin != aDOMWin) {
|
2011-10-17 18:59:28 +04:00
|
|
|
iFrameIsSelected = true; // we have a selected IFRAME
|
2002-08-21 16:01:05 +04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return iFrameIsSelected;
|
|
|
|
}
|
|
|
|
|
|
|
|
//---------------------------------------------------------------------
|
|
|
|
// Recursively sets all the PO items to be printed
|
|
|
|
// from the given item down into the tree
|
|
|
|
void
|
2011-09-29 10:19:26 +04:00
|
|
|
nsPrintEngine::SetPrintPO(nsPrintObject* aPO, bool aPrint)
|
2002-08-21 16:01:05 +04:00
|
|
|
{
|
|
|
|
NS_ASSERTION(aPO, "Pointer is null!");
|
|
|
|
|
|
|
|
// Set whether to print flag
|
2006-04-11 05:48:48 +04:00
|
|
|
aPO->mDontPrint = !aPrint;
|
2002-08-21 16:01:05 +04:00
|
|
|
|
2009-02-03 17:42:18 +03:00
|
|
|
for (PRUint32 i=0;i<aPO->mKids.Length();i++) {
|
|
|
|
SetPrintPO(aPO->mKids[i], aPrint);
|
2002-08-21 16:01:05 +04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
//---------------------------------------------------------------------
|
|
|
|
// 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
|
2006-12-10 11:05:05 +03:00
|
|
|
nsPrintEngine::GetDisplayTitleAndURL(nsPrintObject* aPO,
|
|
|
|
PRUnichar** aTitle,
|
|
|
|
PRUnichar** aURLStr,
|
|
|
|
eDocTitleDefault aDefType)
|
|
|
|
{
|
2002-08-21 16:01:05 +04:00
|
|
|
NS_ASSERTION(aPO, "Pointer is null!");
|
|
|
|
NS_ASSERTION(aTitle, "Pointer is null!");
|
|
|
|
NS_ASSERTION(aURLStr, "Pointer is null!");
|
|
|
|
|
|
|
|
*aTitle = nsnull;
|
|
|
|
*aURLStr = nsnull;
|
|
|
|
|
2006-12-10 11:05:05 +03:00
|
|
|
if (!mPrt)
|
|
|
|
return;
|
|
|
|
|
2002-08-21 16:01:05 +04:00
|
|
|
// First check to see if the PrintSettings has defined an alternate title
|
|
|
|
// and use that if it did
|
|
|
|
PRUnichar * docTitleStrPS = nsnull;
|
|
|
|
PRUnichar * docURLStrPS = nsnull;
|
2006-12-10 11:05:05 +03:00
|
|
|
if (mPrt->mPrintSettings) {
|
|
|
|
mPrt->mPrintSettings->GetTitle(&docTitleStrPS);
|
|
|
|
mPrt->mPrintSettings->GetDocURL(&docURLStrPS);
|
2002-08-21 16:01:05 +04:00
|
|
|
|
2002-11-17 08:16:49 +03:00
|
|
|
if (docTitleStrPS && *docTitleStrPS) {
|
2002-08-21 16:01:05 +04:00
|
|
|
*aTitle = docTitleStrPS;
|
|
|
|
}
|
|
|
|
|
2002-11-17 08:16:49 +03:00
|
|
|
if (docURLStrPS && *docURLStrPS) {
|
2002-08-21 16:01:05 +04:00
|
|
|
*aURLStr = docURLStrPS;
|
|
|
|
}
|
|
|
|
|
|
|
|
// short circut
|
|
|
|
if (docTitleStrPS && docURLStrPS) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2006-12-10 11:05:05 +03:00
|
|
|
PRUnichar* docTitle;
|
|
|
|
PRUnichar* docUrl;
|
|
|
|
GetDocumentTitleAndURL(aPO->mDocument, &docTitle, &docUrl);
|
2002-08-21 16:01:05 +04:00
|
|
|
|
2006-12-10 11:05:05 +03:00
|
|
|
if (docUrl) {
|
|
|
|
if (!docURLStrPS)
|
|
|
|
*aURLStr = docUrl;
|
|
|
|
else
|
|
|
|
nsMemory::Free(docUrl);
|
|
|
|
}
|
2002-08-21 16:01:05 +04:00
|
|
|
|
2006-12-10 11:05:05 +03:00
|
|
|
if (docTitle) {
|
|
|
|
if (!docTitleStrPS)
|
|
|
|
*aTitle = docTitle;
|
|
|
|
else
|
|
|
|
nsMemory::Free(docTitle);
|
|
|
|
} else if (!docTitleStrPS) {
|
|
|
|
switch (aDefType) {
|
|
|
|
case eDocTitleDefBlank: *aTitle = ToNewUnicode(EmptyString());
|
|
|
|
break;
|
2002-08-21 16:01:05 +04:00
|
|
|
|
2006-12-10 11:05:05 +03:00
|
|
|
case eDocTitleDefURLDoc:
|
|
|
|
if (*aURLStr) {
|
|
|
|
*aTitle = NS_strdup(*aURLStr);
|
|
|
|
} else if (mPrt->mBrandName) {
|
|
|
|
*aTitle = NS_strdup(mPrt->mBrandName);
|
|
|
|
}
|
|
|
|
break;
|
2008-09-16 15:25:35 +04:00
|
|
|
case eDocTitleDefNone:
|
|
|
|
// *aTitle defaults to nsnull
|
|
|
|
break;
|
2002-08-21 16:01:05 +04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
//---------------------------------------------------------------------
|
|
|
|
nsresult nsPrintEngine::DocumentReadyForPrinting()
|
|
|
|
{
|
2002-09-20 01:45:07 +04:00
|
|
|
if (mPrt->mPrintFrameType == nsIPrintSettings::kEachFrameSep) {
|
|
|
|
CheckForChildFrameSets(mPrt->mPrintObject);
|
|
|
|
}
|
2002-08-21 16:01:05 +04:00
|
|
|
|
2002-09-20 01:45:07 +04:00
|
|
|
//
|
|
|
|
// Send the document to the printer...
|
|
|
|
//
|
2006-12-10 11:05:05 +03:00
|
|
|
nsresult rv = SetupToPrintContent();
|
2002-09-20 01:45:07 +04:00
|
|
|
if (NS_FAILED(rv)) {
|
|
|
|
// The print job was canceled or there was a problem
|
|
|
|
// So remove all other documents from the print list
|
|
|
|
DonePrintingPages(nsnull, rv);
|
2002-08-21 16:01:05 +04:00
|
|
|
}
|
|
|
|
return rv;
|
|
|
|
}
|
|
|
|
|
|
|
|
/** ---------------------------------------------------
|
|
|
|
* Cleans up when an error occurred
|
|
|
|
*/
|
2011-09-29 10:19:26 +04:00
|
|
|
nsresult nsPrintEngine::CleanupOnFailure(nsresult aResult, bool aIsPrinting)
|
2002-08-21 16:01:05 +04:00
|
|
|
{
|
|
|
|
PR_PL(("**** Failed %s - rv 0x%X", aIsPrinting?"Printing":"Print Preview", aResult));
|
|
|
|
|
|
|
|
/* cleanup... */
|
|
|
|
if (mPagePrintTimer) {
|
|
|
|
mPagePrintTimer->Stop();
|
|
|
|
NS_RELEASE(mPagePrintTimer);
|
|
|
|
}
|
|
|
|
|
2006-07-25 20:05:49 +04:00
|
|
|
if (aIsPrinting) {
|
2011-10-17 18:59:28 +04:00
|
|
|
SetIsPrinting(false);
|
2006-07-25 20:05:49 +04:00
|
|
|
} else {
|
2011-10-17 18:59:28 +04:00
|
|
|
SetIsPrintPreview(false);
|
|
|
|
SetIsCreatingPrintPreview(false);
|
2006-07-25 20:05:49 +04:00
|
|
|
}
|
2002-08-21 16:01:05 +04:00
|
|
|
|
|
|
|
/* 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
|
2011-09-29 10:19:26 +04:00
|
|
|
nsPrintEngine::ShowPrintErrorDialog(nsresult aPrintError, bool aIsPrinting)
|
2002-08-21 16:01:05 +04:00
|
|
|
{
|
2004-04-30 03:34:19 +04:00
|
|
|
|
2011-09-29 10:19:26 +04:00
|
|
|
PR_PL(("nsPrintEngine::ShowPrintErrorDialog(nsresult aPrintError=%lx, bool aIsPrinting=%d)\n", (long)aPrintError, (int)aIsPrinting));
|
2002-08-21 16:01:05 +04:00
|
|
|
|
2004-12-17 23:40:48 +03:00
|
|
|
nsCAutoString stringName;
|
2002-08-21 16:01:05 +04:00
|
|
|
|
|
|
|
switch(aPrintError)
|
|
|
|
{
|
2004-06-17 04:13:25 +04:00
|
|
|
#define NS_ERROR_TO_LOCALIZED_PRINT_ERROR_MSG(nserr) case nserr: stringName.AssignLiteral(#nserr); break;
|
2002-08-21 16:01:05 +04:00
|
|
|
NS_ERROR_TO_LOCALIZED_PRINT_ERROR_MSG(NS_ERROR_GFX_PRINTER_CMD_NOT_FOUND)
|
|
|
|
NS_ERROR_TO_LOCALIZED_PRINT_ERROR_MSG(NS_ERROR_GFX_PRINTER_CMD_FAILURE)
|
|
|
|
NS_ERROR_TO_LOCALIZED_PRINT_ERROR_MSG(NS_ERROR_GFX_PRINTER_NO_PRINTER_AVAILABLE)
|
|
|
|
NS_ERROR_TO_LOCALIZED_PRINT_ERROR_MSG(NS_ERROR_GFX_PRINTER_NAME_NOT_FOUND)
|
|
|
|
NS_ERROR_TO_LOCALIZED_PRINT_ERROR_MSG(NS_ERROR_GFX_PRINTER_ACCESS_DENIED)
|
|
|
|
NS_ERROR_TO_LOCALIZED_PRINT_ERROR_MSG(NS_ERROR_GFX_PRINTER_INVALID_ATTRIBUTE)
|
|
|
|
NS_ERROR_TO_LOCALIZED_PRINT_ERROR_MSG(NS_ERROR_GFX_PRINTER_PRINTER_NOT_READY)
|
|
|
|
NS_ERROR_TO_LOCALIZED_PRINT_ERROR_MSG(NS_ERROR_GFX_PRINTER_OUT_OF_PAPER)
|
|
|
|
NS_ERROR_TO_LOCALIZED_PRINT_ERROR_MSG(NS_ERROR_GFX_PRINTER_PRINTER_IO_ERROR)
|
|
|
|
NS_ERROR_TO_LOCALIZED_PRINT_ERROR_MSG(NS_ERROR_GFX_PRINTER_COULD_NOT_OPEN_FILE)
|
|
|
|
NS_ERROR_TO_LOCALIZED_PRINT_ERROR_MSG(NS_ERROR_GFX_PRINTER_FILE_IO_ERROR)
|
|
|
|
NS_ERROR_TO_LOCALIZED_PRINT_ERROR_MSG(NS_ERROR_GFX_PRINTER_PRINTPREVIEW)
|
|
|
|
NS_ERROR_TO_LOCALIZED_PRINT_ERROR_MSG(NS_ERROR_UNEXPECTED)
|
|
|
|
NS_ERROR_TO_LOCALIZED_PRINT_ERROR_MSG(NS_ERROR_OUT_OF_MEMORY)
|
|
|
|
NS_ERROR_TO_LOCALIZED_PRINT_ERROR_MSG(NS_ERROR_NOT_IMPLEMENTED)
|
|
|
|
NS_ERROR_TO_LOCALIZED_PRINT_ERROR_MSG(NS_ERROR_NOT_AVAILABLE)
|
|
|
|
NS_ERROR_TO_LOCALIZED_PRINT_ERROR_MSG(NS_ERROR_ABORT)
|
|
|
|
NS_ERROR_TO_LOCALIZED_PRINT_ERROR_MSG(NS_ERROR_GFX_PRINTER_STARTDOC)
|
|
|
|
NS_ERROR_TO_LOCALIZED_PRINT_ERROR_MSG(NS_ERROR_GFX_PRINTER_ENDDOC)
|
|
|
|
NS_ERROR_TO_LOCALIZED_PRINT_ERROR_MSG(NS_ERROR_GFX_PRINTER_STARTPAGE)
|
|
|
|
NS_ERROR_TO_LOCALIZED_PRINT_ERROR_MSG(NS_ERROR_GFX_PRINTER_ENDPAGE)
|
|
|
|
NS_ERROR_TO_LOCALIZED_PRINT_ERROR_MSG(NS_ERROR_GFX_PRINTER_PRINT_WHILE_PREVIEW)
|
|
|
|
NS_ERROR_TO_LOCALIZED_PRINT_ERROR_MSG(NS_ERROR_GFX_PRINTER_PAPER_SIZE_NOT_SUPPORTED)
|
|
|
|
NS_ERROR_TO_LOCALIZED_PRINT_ERROR_MSG(NS_ERROR_GFX_PRINTER_ORIENTATION_NOT_SUPPORTED)
|
|
|
|
NS_ERROR_TO_LOCALIZED_PRINT_ERROR_MSG(NS_ERROR_GFX_PRINTER_COLORSPACE_NOT_SUPPORTED)
|
|
|
|
NS_ERROR_TO_LOCALIZED_PRINT_ERROR_MSG(NS_ERROR_GFX_PRINTER_TOO_MANY_COPIES)
|
|
|
|
NS_ERROR_TO_LOCALIZED_PRINT_ERROR_MSG(NS_ERROR_GFX_PRINTER_DRIVER_CONFIGURATION_ERROR)
|
|
|
|
NS_ERROR_TO_LOCALIZED_PRINT_ERROR_MSG(NS_ERROR_GFX_PRINTER_DOC_IS_BUSY_PP)
|
|
|
|
NS_ERROR_TO_LOCALIZED_PRINT_ERROR_MSG(NS_ERROR_GFX_PRINTER_DOC_WAS_DESTORYED)
|
|
|
|
NS_ERROR_TO_LOCALIZED_PRINT_ERROR_MSG(NS_ERROR_GFX_NO_PRINTDIALOG_IN_TOOLKIT)
|
|
|
|
NS_ERROR_TO_LOCALIZED_PRINT_ERROR_MSG(NS_ERROR_GFX_NO_PRINTROMPTSERVICE)
|
2004-12-25 01:27:57 +03:00
|
|
|
NS_ERROR_TO_LOCALIZED_PRINT_ERROR_MSG(NS_ERROR_GFX_PRINTER_NO_XUL) // Temporary code for Bug 136185 / bug 240490
|
2003-08-01 05:56:15 +04:00
|
|
|
NS_ERROR_TO_LOCALIZED_PRINT_ERROR_MSG(NS_ERROR_GFX_PRINTER_PLEX_NOT_SUPPORTED)
|
2004-02-20 00:58:40 +03:00
|
|
|
NS_ERROR_TO_LOCALIZED_PRINT_ERROR_MSG(NS_ERROR_GFX_PRINTER_DOC_IS_BUSY)
|
|
|
|
NS_ERROR_TO_LOCALIZED_PRINT_ERROR_MSG(NS_ERROR_GFX_PRINTING_NOT_IMPLEMENTED)
|
|
|
|
NS_ERROR_TO_LOCALIZED_PRINT_ERROR_MSG(NS_ERROR_GFX_COULD_NOT_LOAD_PRINT_MODULE)
|
2004-10-24 22:34:50 +04:00
|
|
|
NS_ERROR_TO_LOCALIZED_PRINT_ERROR_MSG(NS_ERROR_GFX_PRINTER_RESOLUTION_NOT_SUPPORTED)
|
2002-08-21 16:01:05 +04:00
|
|
|
|
|
|
|
default:
|
|
|
|
NS_ERROR_TO_LOCALIZED_PRINT_ERROR_MSG(NS_ERROR_FAILURE)
|
|
|
|
#undef NS_ERROR_TO_LOCALIZED_PRINT_ERROR_MSG
|
|
|
|
}
|
|
|
|
|
2004-12-17 23:40:48 +03:00
|
|
|
PR_PL(("ShowPrintErrorDialog: stringName='%s'\n", stringName.get()));
|
2002-08-21 16:01:05 +04:00
|
|
|
|
2005-01-19 02:46:59 +03:00
|
|
|
nsXPIDLString msg, title;
|
2004-12-17 23:40:48 +03:00
|
|
|
nsresult rv =
|
|
|
|
nsContentUtils::GetLocalizedString(nsContentUtils::ePRINTING_PROPERTIES,
|
|
|
|
stringName.get(), msg);
|
|
|
|
if (NS_FAILED(rv)) {
|
|
|
|
PR_PL(("GetLocalizedString failed\n"));
|
2002-08-21 16:01:05 +04:00
|
|
|
return;
|
2004-02-20 00:58:40 +03:00
|
|
|
}
|
2002-08-21 16:01:05 +04:00
|
|
|
|
2004-12-17 23:40:48 +03:00
|
|
|
rv = nsContentUtils::GetLocalizedString(nsContentUtils::ePRINTING_PROPERTIES,
|
|
|
|
aIsPrinting ? "print_error_dialog_title"
|
|
|
|
: "printpreview_error_dialog_title",
|
|
|
|
title);
|
|
|
|
|
2002-08-21 16:01:05 +04:00
|
|
|
nsCOMPtr<nsIWindowWatcher> wwatch = do_GetService(NS_WINDOWWATCHER_CONTRACTID, &rv);
|
2004-02-20 23:59:55 +03:00
|
|
|
if (NS_FAILED(rv)) {
|
|
|
|
PR_PL(("ShowPrintErrorDialog(): wwatch==nsnull\n"));
|
2002-08-21 16:01:05 +04:00
|
|
|
return;
|
2004-02-20 23:59:55 +03:00
|
|
|
}
|
2002-08-21 16:01:05 +04:00
|
|
|
|
|
|
|
nsCOMPtr<nsIDOMWindow> active;
|
|
|
|
wwatch->GetActiveWindow(getter_AddRefs(active));
|
|
|
|
|
|
|
|
nsCOMPtr<nsIPrompt> dialog;
|
2004-02-20 23:59:55 +03:00
|
|
|
/* |GetNewPrompter| allows that |active| is |nsnull|
|
|
|
|
* (see bug 234982 ("nsPrintEngine::ShowPrintErrorDialog() fails in many cases")) */
|
|
|
|
wwatch->GetNewPrompter(active, getter_AddRefs(dialog));
|
|
|
|
if (!dialog) {
|
|
|
|
PR_PL(("ShowPrintErrorDialog(): dialog==nsnull\n"));
|
2002-08-21 16:01:05 +04:00
|
|
|
return;
|
2004-02-20 23:59:55 +03:00
|
|
|
}
|
2002-08-21 16:01:05 +04:00
|
|
|
|
2004-12-17 23:40:48 +03:00
|
|
|
dialog->Alert(title.get(), msg.get());
|
2004-02-20 23:59:55 +03:00
|
|
|
PR_PL(("ShowPrintErrorDialog(): alert displayed successfully.\n"));
|
2002-08-21 16:01:05 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
//-----------------------------------------------------------------
|
|
|
|
//-- Section: Reflow Methods
|
|
|
|
//-----------------------------------------------------------------
|
|
|
|
|
|
|
|
//-------------------------------------------------------
|
|
|
|
nsresult
|
2006-12-10 11:05:05 +03:00
|
|
|
nsPrintEngine::SetupToPrintContent()
|
2002-08-21 16:01:05 +04:00
|
|
|
{
|
|
|
|
// In this step we figure out which documents should be printed
|
|
|
|
// i.e. if we are printing the selection then only enable that nsPrintObject
|
|
|
|
// for printing
|
|
|
|
if (NS_FAILED(EnablePOsForPrinting())) {
|
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
}
|
|
|
|
DUMP_DOC_LIST("\nAfter Enable------------------------------------------");
|
|
|
|
|
|
|
|
// 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
|
2005-11-21 01:05:24 +03:00
|
|
|
// The first time we do not want to do this, the second time through we do
|
2011-09-29 10:19:26 +04:00
|
|
|
bool doSetPixelScale = false;
|
|
|
|
bool ppIsShrinkToFit = mPrtPreview && mPrtPreview->mShrinkToFit;
|
2002-08-21 16:01:05 +04:00
|
|
|
if (ppIsShrinkToFit) {
|
|
|
|
mPrt->mShrinkRatio = mPrtPreview->mShrinkRatio;
|
2011-10-17 18:59:28 +04:00
|
|
|
doSetPixelScale = true;
|
2002-08-21 16:01:05 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
// Here we reflow all the PrintObjects
|
2006-04-11 05:48:48 +04:00
|
|
|
nsresult rv = ReflowDocList(mPrt->mPrintObject, doSetPixelScale);
|
2002-09-04 03:21:15 +04:00
|
|
|
if (NS_FAILED(rv)) {
|
2002-08-21 16:01:05 +04:00
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Here is where we do the extra reflow for shrinking the content
|
|
|
|
// But skip this step if we are in PrintPreview
|
|
|
|
if (mPrt->mShrinkToFit && !ppIsShrinkToFit) {
|
2002-09-20 01:45:07 +04:00
|
|
|
// Now look for the PO that has the smallest percent for shrink to fit
|
2009-02-03 17:42:18 +03:00
|
|
|
if (mPrt->mPrintDocList.Length() > 1 && mPrt->mPrintObject->mFrameType == eFrameSet) {
|
2002-09-20 01:45:07 +04:00
|
|
|
nsPrintObject* smallestPO = FindSmallestSTF();
|
|
|
|
NS_ASSERTION(smallestPO, "There must always be an XMost PO!");
|
|
|
|
if (smallestPO) {
|
2002-08-21 16:01:05 +04:00
|
|
|
// Calc the shrinkage based on the entire content area
|
2002-09-20 01:45:07 +04:00
|
|
|
mPrt->mShrinkRatio = smallestPO->mShrinkRatio;
|
2002-08-21 16:01:05 +04:00
|
|
|
}
|
|
|
|
} else {
|
|
|
|
// Single document so use the Shrink as calculated for the PO
|
|
|
|
mPrt->mShrinkRatio = mPrt->mPrintObject->mShrinkRatio;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Only Shrink if we are smaller
|
|
|
|
if (mPrt->mShrinkRatio < 0.998f) {
|
2009-02-03 17:42:18 +03:00
|
|
|
for (PRUint32 i=0;i<mPrt->mPrintDocList.Length();i++) {
|
|
|
|
nsPrintObject* po = mPrt->mPrintDocList.ElementAt(i);
|
2002-08-21 16:01:05 +04:00
|
|
|
NS_ASSERTION(po, "nsPrintObject can't be null!");
|
|
|
|
// Wipe out the presentation before we reflow
|
|
|
|
po->DestroyPresentation();
|
|
|
|
}
|
|
|
|
|
2003-04-03 02:45:08 +04:00
|
|
|
#if (defined(XP_WIN) || defined(XP_OS2)) && defined(EXTENDED_DEBUG_PRINTING)
|
2002-08-21 16:01:05 +04:00
|
|
|
// 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
|
|
|
|
|
|
|
|
// Here we reflow all the PrintObjects a second time
|
|
|
|
// this time using the shrinkage values
|
|
|
|
// The last param here tells reflow to NOT calc the shrinkage values
|
2011-10-17 18:59:28 +04:00
|
|
|
if (NS_FAILED(ReflowDocList(mPrt->mPrintObject, true))) {
|
2002-08-21 16:01:05 +04:00
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#ifdef PR_LOGGING
|
|
|
|
{
|
2003-09-27 08:18:26 +04:00
|
|
|
float calcRatio = 0.0f;
|
2009-02-03 17:42:18 +03:00
|
|
|
if (mPrt->mPrintDocList.Length() > 1 && mPrt->mPrintObject->mFrameType == eFrameSet) {
|
2002-09-20 01:45:07 +04:00
|
|
|
nsPrintObject* smallestPO = FindSmallestSTF();
|
|
|
|
NS_ASSERTION(smallestPO, "There must always be an XMost PO!");
|
|
|
|
if (smallestPO) {
|
2002-08-21 16:01:05 +04:00
|
|
|
// Calc the shrinkage based on the entire content area
|
2002-09-20 01:45:07 +04:00
|
|
|
calcRatio = smallestPO->mShrinkRatio;
|
2002-08-21 16:01:05 +04:00
|
|
|
}
|
|
|
|
} 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
|
|
|
|
}
|
|
|
|
|
|
|
|
DUMP_DOC_LIST(("\nAfter Reflow------------------------------------------"));
|
|
|
|
PR_PL(("\n"));
|
|
|
|
PR_PL(("-------------------------------------------------------\n"));
|
|
|
|
PR_PL(("\n"));
|
|
|
|
|
2006-12-10 11:05:05 +03:00
|
|
|
CalcNumPrintablePages(mPrt->mNumPrintablePages);
|
2002-08-21 16:01:05 +04:00
|
|
|
|
2006-12-10 11:05:05 +03:00
|
|
|
PR_PL(("--- Printing %d pages\n", mPrt->mNumPrintablePages));
|
2002-08-21 16:01:05 +04:00
|
|
|
DUMP_DOC_TREELAYOUT;
|
|
|
|
|
|
|
|
// Print listener setup...
|
|
|
|
if (mPrt != nsnull) {
|
|
|
|
mPrt->OnStartPrinting();
|
|
|
|
}
|
|
|
|
|
|
|
|
PRUnichar* fileName = nsnull;
|
|
|
|
// check to see if we are printing to a file
|
2011-09-29 10:19:26 +04:00
|
|
|
bool isPrintToFile = false;
|
2002-08-21 16:01:05 +04:00
|
|
|
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;
|
2006-12-10 11:05:05 +03:00
|
|
|
GetDisplayTitleAndURL(mPrt->mPrintObject, &docTitleStr, &docURLStr, eDocTitleDefURLDoc);
|
2002-08-21 16:01:05 +04:00
|
|
|
|
|
|
|
PRInt32 startPage = 1;
|
|
|
|
PRInt32 endPage = mPrt->mNumPrintablePages;
|
|
|
|
|
|
|
|
PRInt16 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;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2002-09-04 03:21:15 +04:00
|
|
|
rv = NS_OK;
|
2002-08-21 16:01:05 +04:00
|
|
|
// 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);
|
2008-01-29 09:49:54 +03:00
|
|
|
}
|
|
|
|
|
2008-03-20 02:04:40 +03:00
|
|
|
if (mIsCreatingPrintPreview) {
|
2008-01-29 09:49:54 +03:00
|
|
|
// Print Preview -- Pass ownership of docTitleStr and docURLStr
|
|
|
|
// to the pageSequenceFrame, to be displayed in the header
|
2010-03-21 00:54:19 +03:00
|
|
|
nsIPageSequenceFrame *seqFrame = mPrt->mPrintObject->mPresShell->GetPageSequenceFrame();
|
2008-01-29 09:49:54 +03:00
|
|
|
if (seqFrame) {
|
|
|
|
seqFrame->StartPrint(mPrt->mPrintObject->mPresContext,
|
|
|
|
mPrt->mPrintSettings, docTitleStr, docURLStr);
|
2010-11-05 21:24:12 +03:00
|
|
|
docTitleStr = nsnull;
|
|
|
|
docURLStr = nsnull;
|
2008-01-29 09:49:54 +03:00
|
|
|
}
|
2002-08-21 16:01:05 +04:00
|
|
|
}
|
2010-11-05 21:24:12 +03:00
|
|
|
if (docTitleStr) nsMemory::Free(docTitleStr);
|
|
|
|
if (docURLStr) nsMemory::Free(docURLStr);
|
2002-08-21 16:01:05 +04:00
|
|
|
|
|
|
|
PR_PL(("****************** Begin Document ************************\n"));
|
|
|
|
|
|
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
|
2005-01-04 01:51:17 +03:00
|
|
|
// This will print the docshell document
|
2002-08-21 16:01:05 +04:00
|
|
|
// when it completes asynchronously in the DonePrintingPages method
|
2005-01-04 01:51:17 +03:00
|
|
|
// it will check to see if there are more docshells to be printed and
|
2002-08-21 16:01:05 +04:00
|
|
|
// 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
|
2011-09-29 10:19:26 +04:00
|
|
|
nsPrintEngine::ReflowDocList(nsPrintObject* aPO, bool aSetPixelScale)
|
2002-08-21 16:01:05 +04:00
|
|
|
{
|
2006-04-11 05:48:48 +04:00
|
|
|
NS_ENSURE_ARG_POINTER(aPO);
|
2002-08-21 16:01:05 +04:00
|
|
|
|
2004-01-10 08:36:32 +03:00
|
|
|
// Check to see if the subdocument's element has been hidden by the parent document
|
2006-04-11 05:48:48 +04:00
|
|
|
if (aPO->mParent && aPO->mParent->mPresShell) {
|
2011-07-18 15:02:02 +04:00
|
|
|
nsIFrame* frame = aPO->mContent ? aPO->mContent->GetPrimaryFrame() : nsnull;
|
|
|
|
if (!frame || !frame->GetStyleVisibility()->IsVisible()) {
|
2011-10-17 18:59:28 +04:00
|
|
|
aPO->mDontPrint = true;
|
|
|
|
aPO->mInvisible = true;
|
2011-07-18 15:02:02 +04:00
|
|
|
return NS_OK;
|
2004-01-10 08:36:32 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2002-08-21 16:01:05 +04:00
|
|
|
// 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
|
|
|
|
}
|
2007-02-07 10:46:44 +03:00
|
|
|
aPO->mZoomRatio = ratio;
|
|
|
|
} else if (!mPrt->mShrinkToFit) {
|
|
|
|
double scaling;
|
|
|
|
mPrt->mPrintSettings->GetScaling(&scaling);
|
|
|
|
aPO->mZoomRatio = float(scaling);
|
2002-08-21 16:01:05 +04:00
|
|
|
}
|
|
|
|
|
2006-04-11 05:48:48 +04:00
|
|
|
nsresult rv;
|
2002-08-21 16:01:05 +04:00
|
|
|
// Reflow the PO
|
2006-04-11 05:48:48 +04:00
|
|
|
rv = ReflowPrintObject(aPO);
|
|
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
2002-08-21 16:01:05 +04:00
|
|
|
|
2009-02-03 17:42:18 +03:00
|
|
|
PRInt32 cnt = aPO->mKids.Length();
|
2002-08-21 16:01:05 +04:00
|
|
|
for (PRInt32 i=0;i<cnt;i++) {
|
2009-02-03 17:42:18 +03:00
|
|
|
rv = ReflowDocList(aPO->mKids[i], aSetPixelScale);
|
2006-04-11 05:48:48 +04:00
|
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
2002-08-21 16:01:05 +04:00
|
|
|
}
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
//-------------------------------------------------------
|
|
|
|
// Reflow a nsPrintObject
|
|
|
|
nsresult
|
2006-04-11 05:48:48 +04:00
|
|
|
nsPrintEngine::ReflowPrintObject(nsPrintObject * aPO)
|
2002-08-21 16:01:05 +04:00
|
|
|
{
|
|
|
|
NS_ASSERTION(aPO, "Pointer is null!");
|
|
|
|
if (!aPO) return NS_ERROR_FAILURE;
|
|
|
|
|
2006-04-11 05:48:48 +04:00
|
|
|
nsSize adjSize;
|
2011-09-29 10:19:26 +04:00
|
|
|
bool documentIsTopLevel;
|
2006-04-11 05:48:48 +04:00
|
|
|
if (!aPO->IsPrintable())
|
|
|
|
return NS_OK;
|
|
|
|
|
2011-09-29 10:19:26 +04:00
|
|
|
bool canCreateScrollbars = true;
|
2010-08-28 03:15:08 +04:00
|
|
|
nsIView* parentView = nsnull;
|
|
|
|
|
2006-04-11 05:48:48 +04:00
|
|
|
if (aPO->mParent && aPO->mParent->IsPrintable()) {
|
2011-07-18 15:02:02 +04:00
|
|
|
nsIFrame* frame = aPO->mContent ? aPO->mContent->GetPrimaryFrame() : nsnull;
|
2006-04-11 05:48:48 +04:00
|
|
|
// Without a frame, this document can't be displayed; therefore, there is no
|
|
|
|
// point to reflowing it
|
2009-12-16 01:17:57 +03:00
|
|
|
if (!frame) {
|
2011-10-17 18:59:28 +04:00
|
|
|
SetPrintPO(aPO, false);
|
2006-04-11 05:48:48 +04:00
|
|
|
return NS_OK;
|
2009-12-16 01:17:57 +03:00
|
|
|
}
|
2006-04-11 05:48:48 +04:00
|
|
|
|
2010-07-19 06:23:48 +04:00
|
|
|
//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.
|
2006-12-20 04:23:45 +03:00
|
|
|
adjSize = frame->GetContentRect().Size();
|
2011-10-17 18:59:28 +04:00
|
|
|
documentIsTopLevel = false;
|
2006-04-11 05:48:48 +04:00
|
|
|
// presshell exists because parent is printable
|
2010-08-28 03:15:08 +04:00
|
|
|
|
|
|
|
// the top nsPrintObject's widget will always have scrollbars
|
|
|
|
if (frame && frame->GetType() == nsGkAtoms::subDocumentFrame) {
|
|
|
|
nsIView* view = frame->GetView();
|
|
|
|
NS_ENSURE_TRUE(view, NS_ERROR_FAILURE);
|
|
|
|
view = view->GetFirstChild();
|
|
|
|
NS_ENSURE_TRUE(view, NS_ERROR_FAILURE);
|
|
|
|
parentView = view;
|
2011-10-17 18:59:28 +04:00
|
|
|
canCreateScrollbars = false;
|
2010-08-28 03:15:08 +04:00
|
|
|
}
|
2006-04-11 05:48:48 +04:00
|
|
|
} else {
|
2007-11-21 08:09:58 +03:00
|
|
|
nscoord pageWidth, pageHeight;
|
2006-12-10 11:05:05 +03:00
|
|
|
mPrt->mPrintDC->GetDeviceSurfaceDimensions(pageWidth, pageHeight);
|
2006-04-11 05:48:48 +04:00
|
|
|
adjSize = nsSize(pageWidth, pageHeight);
|
2011-10-17 18:59:28 +04:00
|
|
|
documentIsTopLevel = true;
|
2002-08-21 16:01:05 +04:00
|
|
|
|
2010-09-05 23:21:56 +04:00
|
|
|
if (mIsCreatingPrintPreview) {
|
2011-10-15 11:33:26 +04:00
|
|
|
nsCOMPtr<nsIContentViewer> cv = do_QueryInterface(mDocViewerPrint);
|
|
|
|
if (cv) {
|
|
|
|
parentView = cv->FindContainerView();
|
2010-09-05 23:21:56 +04:00
|
|
|
}
|
2010-08-28 03:15:08 +04:00
|
|
|
}
|
2009-01-15 17:24:40 +03:00
|
|
|
}
|
|
|
|
|
2009-12-11 07:02:13 +03:00
|
|
|
NS_ASSERTION(!aPO->mPresContext, "Recreating prescontext");
|
|
|
|
|
2002-08-21 16:01:05 +04:00
|
|
|
// create the PresContext
|
2010-08-28 03:15:08 +04:00
|
|
|
aPO->mPresContext = new nsPresContext(aPO->mDocument,
|
2009-07-22 04:44:54 +04:00
|
|
|
mIsCreatingPrintPreview ? nsPresContext::eContext_PrintPreview:
|
|
|
|
nsPresContext::eContext_Print);
|
2004-07-29 23:41:39 +04:00
|
|
|
NS_ENSURE_TRUE(aPO->mPresContext, NS_ERROR_OUT_OF_MEMORY);
|
|
|
|
aPO->mPresContext->SetPrintSettings(mPrt->mPrintSettings);
|
2002-08-21 16:01:05 +04:00
|
|
|
|
|
|
|
// set the presentation context to the value in the print settings
|
2011-09-29 10:19:26 +04:00
|
|
|
bool printBGColors;
|
2002-08-21 16:01:05 +04:00
|
|
|
mPrt->mPrintSettings->GetPrintBGColors(&printBGColors);
|
|
|
|
aPO->mPresContext->SetBackgroundColorDraw(printBGColors);
|
|
|
|
mPrt->mPrintSettings->GetPrintBGImages(&printBGColors);
|
|
|
|
aPO->mPresContext->SetBackgroundImageDraw(printBGColors);
|
|
|
|
|
|
|
|
// init it with the DC
|
2006-12-10 11:05:05 +03:00
|
|
|
nsresult rv = aPO->mPresContext->Init(mPrt->mPrintDC);
|
2006-04-11 05:48:48 +04:00
|
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
2002-08-21 16:01:05 +04:00
|
|
|
|
|
|
|
aPO->mViewManager = do_CreateInstance(kViewManagerCID, &rv);
|
2006-03-30 04:27:42 +04:00
|
|
|
NS_ENSURE_SUCCESS(rv,rv);
|
2002-08-21 16:01:05 +04:00
|
|
|
|
2006-12-10 11:05:05 +03:00
|
|
|
rv = aPO->mViewManager->Init(mPrt->mPrintDC);
|
2006-03-30 04:27:42 +04:00
|
|
|
NS_ENSURE_SUCCESS(rv,rv);
|
|
|
|
|
|
|
|
nsStyleSet* styleSet;
|
|
|
|
rv = mDocViewerPrint->CreateStyleSet(aPO->mDocument, &styleSet);
|
|
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
2002-08-21 16:01:05 +04:00
|
|
|
|
2002-09-20 01:45:07 +04:00
|
|
|
rv = aPO->mDocument->CreateShell(aPO->mPresContext, aPO->mViewManager,
|
2006-03-30 04:27:42 +04:00
|
|
|
styleSet, getter_AddRefs(aPO->mPresShell));
|
2002-08-21 16:01:05 +04:00
|
|
|
if (NS_FAILED(rv)) {
|
2006-03-30 04:27:42 +04:00
|
|
|
delete styleSet;
|
2002-08-21 16:01:05 +04:00
|
|
|
return rv;
|
|
|
|
}
|
|
|
|
|
2006-03-30 04:27:42 +04:00
|
|
|
styleSet->EndUpdate();
|
2004-07-16 00:30:30 +04:00
|
|
|
|
2004-01-10 01:54:09 +03:00
|
|
|
// The pres shell now owns the style set object.
|
|
|
|
|
2006-03-30 04:27:42 +04:00
|
|
|
PR_PL(("In DV::ReflowPrintObject PO: %p (%9s) Setting w,h to %d,%d\n", aPO,
|
|
|
|
gFrameTypesStr[aPO->mFrameType], adjSize.width, adjSize.height));
|
2002-08-21 16:01:05 +04:00
|
|
|
|
2006-04-11 05:48:48 +04:00
|
|
|
// Create a child window of the parent that is our "root view/window"
|
|
|
|
nsRect tbounds = nsRect(nsPoint(0, 0), adjSize);
|
2006-12-10 11:05:05 +03:00
|
|
|
nsIView* rootView = aPO->mViewManager->CreateView(tbounds, parentView);
|
|
|
|
NS_ENSURE_TRUE(rootView, NS_ERROR_OUT_OF_MEMORY);
|
2002-08-21 16:01:05 +04:00
|
|
|
|
2006-12-10 11:05:05 +03:00
|
|
|
if (mIsCreatingPrintPreview && documentIsTopLevel) {
|
2006-04-18 04:37:53 +04:00
|
|
|
aPO->mPresContext->SetPaginatedScrolling(canCreateScrollbars);
|
|
|
|
}
|
2002-08-21 16:01:05 +04:00
|
|
|
|
2006-04-11 05:48:48 +04:00
|
|
|
// Setup hierarchical relationship in view manager
|
2006-12-10 11:05:05 +03:00
|
|
|
aPO->mViewManager->SetRootView(rootView);
|
2002-08-21 16:01:05 +04:00
|
|
|
|
2006-04-11 05:48:48 +04:00
|
|
|
// 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);
|
2002-08-21 16:01:05 +04:00
|
|
|
|
2006-04-11 05:48:48 +04:00
|
|
|
aPO->mPresShell->BeginObservingDocument();
|
2002-08-21 16:01:05 +04:00
|
|
|
|
2006-03-30 04:27:42 +04:00
|
|
|
aPO->mPresContext->SetPageSize(adjSize);
|
|
|
|
aPO->mPresContext->SetIsRootPaginatedDocument(documentIsTopLevel);
|
2007-02-07 10:46:44 +03:00
|
|
|
aPO->mPresContext->SetPageScale(aPO->mZoomRatio);
|
2007-02-14 01:36:59 +03:00
|
|
|
// Calculate scale factor from printer to screen
|
2010-08-13 13:58:04 +04:00
|
|
|
float printDPI = float(mPrt->mPrintDC->AppUnitsPerCSSInch()) /
|
2007-11-21 08:09:58 +03:00
|
|
|
float(mPrt->mPrintDC->AppUnitsPerDevPixel());
|
2009-08-24 13:55:28 +04:00
|
|
|
aPO->mPresContext->SetPrintPreviewScale(mScreenDPI / printDPI);
|
2006-03-30 04:27:42 +04:00
|
|
|
|
2009-12-11 07:02:13 +03:00
|
|
|
if (mIsCreatingPrintPreview && documentIsTopLevel) {
|
2010-08-28 03:15:08 +04:00
|
|
|
mDocViewerPrint->SetPrintPreviewPresentation(aPO->mViewManager,
|
2009-12-11 07:02:13 +03:00
|
|
|
aPO->mPresContext,
|
|
|
|
aPO->mPresShell);
|
|
|
|
}
|
|
|
|
|
2006-03-30 04:27:42 +04:00
|
|
|
rv = aPO->mPresShell->InitialReflow(adjSize.width, adjSize.height);
|
2002-08-21 16:01:05 +04:00
|
|
|
|
2006-12-10 11:05:05 +03:00
|
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
2007-05-14 07:52:48 +04:00
|
|
|
NS_ASSERTION(aPO->mPresShell, "Presshell should still be here");
|
2007-05-01 21:15:08 +04:00
|
|
|
|
2007-05-01 21:15:08 +04:00
|
|
|
// Process the reflow event InitialReflow posted
|
2007-08-22 06:57:06 +04:00
|
|
|
aPO->mPresShell->FlushPendingNotifications(Flush_Layout);
|
2007-05-01 21:15:08 +04:00
|
|
|
|
2006-12-10 11:05:05 +03:00
|
|
|
nsCOMPtr<nsIPresShell> displayShell;
|
|
|
|
aPO->mDocShell->GetPresShell(getter_AddRefs(displayShell));
|
|
|
|
// Transfer Selection Ranges to the new Print PresShell
|
|
|
|
nsCOMPtr<nsISelection> 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);
|
|
|
|
if (selection && selectionPS) {
|
|
|
|
PRInt32 cnt;
|
|
|
|
selection->GetRangeCount(&cnt);
|
|
|
|
PRInt32 inx;
|
|
|
|
for (inx=0;inx<cnt;inx++) {
|
|
|
|
nsCOMPtr<nsIDOMRange> range;
|
|
|
|
if (NS_SUCCEEDED(selection->GetRangeAt(inx, getter_AddRefs(range))))
|
|
|
|
selectionPS->AddRange(range);
|
2002-08-21 16:01:05 +04:00
|
|
|
}
|
2006-12-10 11:05:05 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
// 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 && documentIsTopLevel) {
|
2010-03-21 00:54:19 +03:00
|
|
|
nsIPageSequenceFrame* pageSequence = aPO->mPresShell->GetPageSequenceFrame();
|
2010-04-19 02:17:41 +04:00
|
|
|
NS_ENSURE_STATE(pageSequence);
|
2006-12-10 11:05:05 +03:00
|
|
|
pageSequence->GetSTFPercent(aPO->mShrinkRatio);
|
|
|
|
}
|
2002-08-21 16:01:05 +04:00
|
|
|
|
|
|
|
#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) {
|
2004-09-02 07:08:51 +04:00
|
|
|
nsIFrame *theRootFrame =
|
|
|
|
aPO->mPresShell->FrameManager()->GetRootFrame();
|
2002-08-21 16:01:05 +04:00
|
|
|
fprintf(fd, "Title: %s\n", docStr?docStr:"");
|
|
|
|
fprintf(fd, "URL: %s\n", urlStr?urlStr:"");
|
|
|
|
fprintf(fd, "--------------- Frames ----------------\n");
|
2011-04-08 05:04:40 +04:00
|
|
|
nsRefPtr<nsRenderingContext> renderingContext;
|
2002-08-21 16:01:05 +04:00
|
|
|
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");
|
2003-08-06 07:07:12 +04:00
|
|
|
nsIView* v = theRootFrame->GetView();
|
2002-08-21 16:01:05 +04:00
|
|
|
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
|
|
|
|
|
2006-12-10 11:05:05 +03:00
|
|
|
return NS_OK;
|
2002-08-21 16:01:05 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
//-------------------------------------------------------
|
|
|
|
// Figure out how many documents and how many total pages we are printing
|
|
|
|
void
|
2006-12-10 11:05:05 +03:00
|
|
|
nsPrintEngine::CalcNumPrintablePages(PRInt32& aNumPages)
|
2002-08-21 16:01:05 +04:00
|
|
|
{
|
|
|
|
aNumPages = 0;
|
|
|
|
// Count the number of printable documents
|
|
|
|
// and printable pages
|
2009-02-03 17:42:18 +03:00
|
|
|
for (PRUint32 i=0; i<mPrt->mPrintDocList.Length(); i++) {
|
|
|
|
nsPrintObject* po = mPrt->mPrintDocList.ElementAt(i);
|
2002-08-21 16:01:05 +04:00
|
|
|
NS_ASSERTION(po, "nsPrintObject can't be null!");
|
2006-04-11 05:48:48 +04:00
|
|
|
if (po->mPresContext && po->mPresContext->IsRootPaginatedDocument()) {
|
2010-03-21 00:54:19 +03:00
|
|
|
nsIPageSequenceFrame* pageSequence = po->mPresShell->GetPageSequenceFrame();
|
2009-01-12 22:20:59 +03:00
|
|
|
nsIFrame * seqFrame = do_QueryFrame(pageSequence);
|
|
|
|
if (seqFrame) {
|
2011-08-25 00:54:30 +04:00
|
|
|
nsIFrame* frame = seqFrame->GetFirstPrincipalChild();
|
2006-04-11 05:48:48 +04:00
|
|
|
while (frame) {
|
|
|
|
aNumPages++;
|
|
|
|
frame = frame->GetNextSibling();
|
2002-08-21 16:01:05 +04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
//-----------------------------------------------------------------
|
|
|
|
//-- Done: Reflow Methods
|
|
|
|
//-----------------------------------------------------------------
|
|
|
|
|
|
|
|
//-----------------------------------------------------------------
|
|
|
|
//-- Section: Printing Methods
|
|
|
|
//-----------------------------------------------------------------
|
|
|
|
|
|
|
|
//-------------------------------------------------------
|
2005-01-04 01:51:17 +03:00
|
|
|
// Called for each DocShell that needs to be printed
|
2011-09-29 10:19:26 +04:00
|
|
|
bool
|
2002-08-21 16:01:05 +04:00
|
|
|
nsPrintEngine::PrintDocContent(nsPrintObject* aPO, nsresult& aStatus)
|
|
|
|
{
|
|
|
|
NS_ASSERTION(aPO, "Pointer is null!");
|
2004-12-22 06:26:29 +03:00
|
|
|
aStatus = NS_OK;
|
2002-08-21 16:01:05 +04:00
|
|
|
|
|
|
|
if (!aPO->mHasBeenPrinted && aPO->IsPrintable()) {
|
2006-04-11 05:48:48 +04:00
|
|
|
aStatus = DoPrint(aPO);
|
2011-10-17 18:59:28 +04:00
|
|
|
return true;
|
2002-08-21 16:01:05 +04:00
|
|
|
}
|
|
|
|
|
2005-11-30 16:24:00 +03:00
|
|
|
// If |aPO->mPrintAsIs| and |aPO->mHasBeenPrinted| are true,
|
|
|
|
// the kids frames are already processed in |PrintPage|.
|
|
|
|
if (!aPO->mInvisible && !(aPO->mPrintAsIs && aPO->mHasBeenPrinted)) {
|
2009-02-03 17:42:18 +03:00
|
|
|
for (PRUint32 i=0;i<aPO->mKids.Length();i++) {
|
|
|
|
nsPrintObject* po = aPO->mKids[i];
|
2011-09-29 10:19:26 +04:00
|
|
|
bool printed = PrintDocContent(po, aStatus);
|
2004-12-21 14:51:13 +03:00
|
|
|
if (printed || NS_FAILED(aStatus)) {
|
2011-10-17 18:59:28 +04:00
|
|
|
return true;
|
2004-12-21 14:51:13 +03:00
|
|
|
}
|
2002-08-21 16:01:05 +04:00
|
|
|
}
|
|
|
|
}
|
2011-10-17 18:59:28 +04:00
|
|
|
return false;
|
2002-08-21 16:01:05 +04:00
|
|
|
}
|
|
|
|
|
2009-12-11 07:02:13 +03:00
|
|
|
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 nsnull;
|
|
|
|
}
|
|
|
|
|
|
|
|
nsCOMPtr<nsINode> node = do_QueryInterface(aNode);
|
|
|
|
NS_ENSURE_TRUE(node, nsnull);
|
|
|
|
|
|
|
|
nsTArray<PRInt32> indexArray;
|
|
|
|
nsINode* current = node;
|
|
|
|
NS_ENSURE_TRUE(current, nsnull);
|
|
|
|
while (current) {
|
|
|
|
nsINode* parent = current->GetNodeParent();
|
|
|
|
if (!parent) {
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
PRInt32 index = parent->IndexOf(current);
|
|
|
|
NS_ENSURE_TRUE(index >= 0, nsnull);
|
|
|
|
indexArray.AppendElement(index);
|
|
|
|
current = parent;
|
|
|
|
}
|
|
|
|
NS_ENSURE_TRUE(current->IsNodeOfType(nsINode::eDOCUMENT), nsnull);
|
|
|
|
|
|
|
|
current = aDoc;
|
|
|
|
for (PRInt32 i = indexArray.Length() - 1; i >= 0; --i) {
|
|
|
|
current = current->GetChildAt(indexArray[i]);
|
|
|
|
NS_ENSURE_TRUE(current, nsnull);
|
|
|
|
}
|
|
|
|
nsCOMPtr<nsIDOMNode> result = do_QueryInterface(current);
|
|
|
|
return result.forget();
|
|
|
|
}
|
|
|
|
|
|
|
|
static nsresult CloneRangeToSelection(nsIDOMRange* aRange,
|
|
|
|
nsIDocument* aDoc,
|
|
|
|
nsISelection* aSelection)
|
|
|
|
{
|
2011-09-29 10:19:26 +04:00
|
|
|
bool collapsed = false;
|
2009-12-11 07:02:13 +03:00
|
|
|
aRange->GetCollapsed(&collapsed);
|
|
|
|
if (collapsed) {
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
nsCOMPtr<nsIDOMNode> startContainer, endContainer;
|
|
|
|
PRInt32 startOffset = -1, endOffset = -1;
|
|
|
|
aRange->GetStartContainer(getter_AddRefs(startContainer));
|
|
|
|
aRange->GetStartOffset(&startOffset);
|
|
|
|
aRange->GetEndContainer(getter_AddRefs(endContainer));
|
|
|
|
aRange->GetEndOffset(&endOffset);
|
|
|
|
NS_ENSURE_STATE(startContainer && endContainer);
|
|
|
|
|
|
|
|
nsCOMPtr<nsIDOMNode> newStart = GetEqualNodeInCloneTree(startContainer, aDoc);
|
|
|
|
nsCOMPtr<nsIDOMNode> newEnd = GetEqualNodeInCloneTree(endContainer, aDoc);
|
|
|
|
NS_ENSURE_STATE(newStart && newEnd);
|
|
|
|
|
2012-01-10 18:19:54 +04:00
|
|
|
nsRefPtr<nsRange> range = new nsRange();
|
2009-12-11 07:02:13 +03:00
|
|
|
nsresult rv = range->SetStart(newStart, startOffset);
|
|
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
rv = range->SetEnd(newEnd, endOffset);
|
|
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
|
|
|
|
return aSelection->AddRange(range);
|
|
|
|
}
|
|
|
|
|
|
|
|
static nsresult CloneSelection(nsIDocument* aOrigDoc, nsIDocument* aDoc)
|
|
|
|
{
|
2010-06-25 17:59:57 +04:00
|
|
|
nsIPresShell* origShell = aOrigDoc->GetShell();
|
|
|
|
nsIPresShell* shell = aDoc->GetShell();
|
2009-12-11 07:02:13 +03:00
|
|
|
NS_ENSURE_STATE(origShell && shell);
|
|
|
|
|
|
|
|
nsCOMPtr<nsISelection> origSelection =
|
|
|
|
origShell->GetCurrentSelection(nsISelectionController::SELECTION_NORMAL);
|
|
|
|
nsCOMPtr<nsISelection> selection =
|
|
|
|
shell->GetCurrentSelection(nsISelectionController::SELECTION_NORMAL);
|
|
|
|
NS_ENSURE_STATE(origSelection && selection);
|
|
|
|
|
|
|
|
PRInt32 rangeCount = 0;
|
|
|
|
origSelection->GetRangeCount(&rangeCount);
|
|
|
|
for (PRInt32 i = 0; i < rangeCount; ++i) {
|
|
|
|
nsCOMPtr<nsIDOMRange> range;
|
|
|
|
origSelection->GetRangeAt(i, getter_AddRefs(range));
|
|
|
|
if (range) {
|
|
|
|
CloneRangeToSelection(range, aDoc, selection);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2002-08-21 16:01:05 +04:00
|
|
|
//-------------------------------------------------------
|
|
|
|
nsresult
|
2006-04-11 05:48:48 +04:00
|
|
|
nsPrintEngine::DoPrint(nsPrintObject * aPO)
|
2002-08-21 16:01:05 +04:00
|
|
|
{
|
|
|
|
PR_PL(("\n"));
|
|
|
|
PR_PL(("**************************** %s ****************************\n", gFrameTypesStr[aPO->mFrameType]));
|
2006-04-11 05:48:48 +04:00
|
|
|
PR_PL(("****** In DV::DoPrint PO: %p \n", aPO));
|
2002-08-21 16:01:05 +04:00
|
|
|
|
|
|
|
nsIPresShell* poPresShell = aPO->mPresShell;
|
2006-04-11 05:48:48 +04:00
|
|
|
nsPresContext* poPresContext = aPO->mPresContext;
|
2002-08-21 16:01:05 +04:00
|
|
|
|
2004-12-21 14:51:13 +03:00
|
|
|
NS_ASSERTION(poPresContext, "PrintObject has not been reflowed");
|
2006-12-10 11:05:05 +03:00
|
|
|
NS_ASSERTION(poPresContext->Type() != nsPresContext::eContext_PrintPreview,
|
|
|
|
"How did this context end up here?");
|
2002-08-21 16:01:05 +04:00
|
|
|
|
|
|
|
if (mPrt->mPrintProgressParams) {
|
|
|
|
SetDocAndURLIntoProgress(aPO, mPrt->mPrintProgressParams);
|
|
|
|
}
|
|
|
|
|
2006-12-10 11:05:05 +03:00
|
|
|
{
|
2002-08-21 16:01:05 +04:00
|
|
|
PRInt16 printRangeType = nsIPrintSettings::kRangeAllPages;
|
|
|
|
nsresult rv;
|
|
|
|
if (mPrt->mPrintSettings != nsnull) {
|
|
|
|
mPrt->mPrintSettings->GetPrintRange(&printRangeType);
|
|
|
|
}
|
|
|
|
|
|
|
|
// Ask the page sequence frame to print all the pages
|
2010-03-21 00:54:19 +03:00
|
|
|
nsIPageSequenceFrame* pageSequence = poPresShell->GetPageSequenceFrame();
|
2002-08-21 16:01:05 +04:00
|
|
|
NS_ASSERTION(nsnull != pageSequence, "no page sequence frame");
|
|
|
|
|
|
|
|
// We are done preparing for printing, so we can turn this off
|
2011-10-17 18:59:28 +04:00
|
|
|
mPrt->mPreparingForPrint = false;
|
2002-08-21 16:01:05 +04:00
|
|
|
|
|
|
|
// mPrt->mDebugFilePtr this is onlu non-null when compiled for debugging
|
|
|
|
if (nsnull != mPrt->mDebugFilePtr) {
|
|
|
|
#ifdef NS_DEBUG
|
|
|
|
// output the regression test
|
2004-09-02 07:08:51 +04:00
|
|
|
nsIFrame* root = poPresShell->FrameManager()->GetRootFrame();
|
2009-08-21 01:52:48 +04:00
|
|
|
root->DumpRegressionData(poPresContext, mPrt->mDebugFilePtr, 0);
|
2002-08-21 16:01:05 +04:00
|
|
|
fclose(mPrt->mDebugFilePtr);
|
2011-10-17 18:59:28 +04:00
|
|
|
SetIsPrinting(false);
|
2002-08-21 16:01:05 +04:00
|
|
|
#endif
|
|
|
|
} else {
|
|
|
|
#ifdef EXTENDED_DEBUG_PRINTING
|
2007-02-16 11:04:44 +03:00
|
|
|
nsIFrame* rootFrame = poPresShell->FrameManager()->GetRootFrame();
|
2002-08-21 16:01:05 +04:00
|
|
|
if (aPO->IsPrintable()) {
|
|
|
|
char * docStr;
|
|
|
|
char * urlStr;
|
|
|
|
GetDocTitleAndURL(aPO, docStr, urlStr);
|
2005-01-04 01:51:17 +03:00
|
|
|
DumpLayoutData(docStr, urlStr, poPresContext, mPrt->mPrintDocDC, rootFrame, docShell, nsnull);
|
2002-08-21 16:01:05 +04:00
|
|
|
if (docStr) nsMemory::Free(docStr);
|
|
|
|
if (urlStr) nsMemory::Free(urlStr);
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2010-12-05 15:43:45 +03:00
|
|
|
if (!mPrt->mPrintSettings) {
|
|
|
|
// not sure what to do here!
|
2011-10-17 18:59:28 +04:00
|
|
|
SetIsPrinting(false);
|
2010-12-05 15:43:45 +03:00
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
}
|
|
|
|
|
|
|
|
PRUnichar * docTitleStr = nsnull;
|
|
|
|
PRUnichar * docURLStr = nsnull;
|
|
|
|
|
|
|
|
GetDisplayTitleAndURL(aPO, &docTitleStr, &docURLStr, eDocTitleDefBlank);
|
|
|
|
|
|
|
|
if (nsIPrintSettings::kRangeSelection == printRangeType) {
|
|
|
|
CloneSelection(aPO->mDocument->GetOriginalDocument(), aPO->mDocument);
|
|
|
|
|
2011-10-17 18:59:28 +04:00
|
|
|
poPresContext->SetIsRenderingOnlySelection(true);
|
2010-12-05 15:43:45 +03:00
|
|
|
// temporarily creating rendering context
|
2011-04-08 05:04:40 +04:00
|
|
|
// which is needed to find the selection frames
|
2011-04-08 05:04:40 +04:00
|
|
|
nsRefPtr<nsRenderingContext> rc;
|
2010-12-05 15:43:45 +03:00
|
|
|
mPrt->mPrintDC->CreateRenderingContext(*getter_AddRefs(rc));
|
|
|
|
|
|
|
|
// find the starting and ending page numbers
|
|
|
|
// via the selection
|
|
|
|
nsIFrame* startFrame;
|
|
|
|
nsIFrame* endFrame;
|
|
|
|
PRInt32 startPageNum;
|
|
|
|
PRInt32 endPageNum;
|
|
|
|
nsRect startRect;
|
|
|
|
nsRect endRect;
|
|
|
|
|
|
|
|
nsCOMPtr<nsISelection> selectionPS;
|
|
|
|
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 = NS_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 = NS_MAX(0, endRect.YMost());
|
|
|
|
endRect.y = 0;
|
2002-08-21 16:01:05 +04:00
|
|
|
}
|
2010-12-05 15:43:45 +03:00
|
|
|
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;
|
|
|
|
PRInt32 totalPages = NSToIntCeil(float(selectionHgt) * aPO->mZoomRatio / float(pageHeight));
|
|
|
|
pageSequence->SetTotalNumPages(totalPages);
|
2002-08-21 16:01:05 +04:00
|
|
|
}
|
|
|
|
}
|
2010-12-05 15:43:45 +03:00
|
|
|
}
|
2002-08-21 16:01:05 +04:00
|
|
|
|
2010-12-05 15:43:45 +03:00
|
|
|
nsIFrame * seqFrame = do_QueryFrame(pageSequence);
|
|
|
|
if (!seqFrame) {
|
2011-10-17 18:59:28 +04:00
|
|
|
SetIsPrinting(false);
|
2010-12-05 15:43:45 +03:00
|
|
|
if (docTitleStr) nsMemory::Free(docTitleStr);
|
|
|
|
if (docURLStr) nsMemory::Free(docURLStr);
|
2002-08-21 16:01:05 +04:00
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
}
|
2010-12-05 15:43:45 +03:00
|
|
|
|
|
|
|
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);
|
2002-08-21 16:01:05 +04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
//---------------------------------------------------------------------
|
|
|
|
void
|
|
|
|
nsPrintEngine::SetDocAndURLIntoProgress(nsPrintObject* aPO,
|
|
|
|
nsIPrintProgressParams* aParams)
|
|
|
|
{
|
|
|
|
NS_ASSERTION(aPO, "Must have vaild nsPrintObject");
|
|
|
|
NS_ASSERTION(aParams, "Must have vaild nsIPrintProgressParams");
|
|
|
|
|
2005-01-04 01:51:17 +03:00
|
|
|
if (!aPO || !aPO->mDocShell || !aParams) {
|
2002-08-21 16:01:05 +04:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
const PRUint32 kTitleLength = 64;
|
|
|
|
|
|
|
|
PRUnichar * docTitleStr;
|
|
|
|
PRUnichar * docURLStr;
|
2006-12-10 11:05:05 +03:00
|
|
|
GetDisplayTitleAndURL(aPO, &docTitleStr, &docURLStr, eDocTitleDefURLDoc);
|
2002-08-21 16:01:05 +04:00
|
|
|
|
|
|
|
// Make sure the Titles & URLS don't get too long for the progress dialog
|
2011-10-17 18:59:28 +04:00
|
|
|
ElipseLongString(docTitleStr, kTitleLength, false);
|
|
|
|
ElipseLongString(docURLStr, kTitleLength, true);
|
2002-08-21 16:01:05 +04:00
|
|
|
|
2006-12-10 11:05:05 +03:00
|
|
|
aParams->SetDocTitle(docTitleStr);
|
|
|
|
aParams->SetDocURL(docURLStr);
|
2002-08-21 16:01:05 +04:00
|
|
|
|
|
|
|
if (docTitleStr != nsnull) nsMemory::Free(docTitleStr);
|
|
|
|
if (docURLStr != nsnull) nsMemory::Free(docURLStr);
|
|
|
|
}
|
|
|
|
|
|
|
|
//---------------------------------------------------------------------
|
|
|
|
void
|
2011-09-29 10:19:26 +04:00
|
|
|
nsPrintEngine::ElipseLongString(PRUnichar *& aStr, const PRUint32 aLen, bool aDoFront)
|
2002-08-21 16:01:05 +04:00
|
|
|
{
|
|
|
|
// Make sure the URLS don't get too long for the progress dialog
|
2012-04-04 04:22:42 +04:00
|
|
|
if (aStr && nsCRT::strlen(aStr) > aLen) {
|
2002-08-21 16:01:05 +04:00
|
|
|
if (aDoFront) {
|
2012-04-04 04:22:42 +04:00
|
|
|
PRUnichar * ptr = &aStr[nsCRT::strlen(aStr)-aLen+3];
|
2002-08-21 16:01:05 +04:00
|
|
|
nsAutoString newStr;
|
2004-06-17 04:13:25 +04:00
|
|
|
newStr.AppendLiteral("...");
|
2002-08-21 16:01:05 +04:00
|
|
|
newStr += ptr;
|
|
|
|
nsMemory::Free(aStr);
|
|
|
|
aStr = ToNewUnicode(newStr);
|
|
|
|
} else {
|
|
|
|
nsAutoString newStr(aStr);
|
|
|
|
newStr.SetLength(aLen-3);
|
2004-06-17 04:13:25 +04:00
|
|
|
newStr.AppendLiteral("...");
|
2002-08-21 16:01:05 +04:00
|
|
|
nsMemory::Free(aStr);
|
|
|
|
aStr = ToNewUnicode(newStr);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
//-------------------------------------------------------
|
2011-09-29 10:19:26 +04:00
|
|
|
bool
|
2006-12-10 11:05:05 +03:00
|
|
|
nsPrintEngine::PrintPage(nsPrintObject* aPO,
|
2011-09-29 10:19:26 +04:00
|
|
|
bool& aInRange)
|
2002-08-21 16:01:05 +04:00
|
|
|
{
|
|
|
|
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
|
2006-12-10 11:05:05 +03:00
|
|
|
if (!mPrt || !aPO || !mPageSeqFrame) {
|
2002-08-21 16:01:05 +04:00
|
|
|
ShowPrintErrorDialog(NS_ERROR_FAILURE);
|
2011-10-17 18:59:28 +04:00
|
|
|
return true; // means we are done printing
|
2002-08-21 16:01:05 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
PR_PL(("-----------------------------------\n"));
|
|
|
|
PR_PL(("------ In DV::PrintPage PO: %p (%s)\n", aPO, gFrameTypesStr[aPO->mFrameType]));
|
|
|
|
|
2006-12-10 11:05:05 +03:00
|
|
|
// Check setting to see if someone request it be cancelled
|
2011-09-29 10:19:26 +04:00
|
|
|
bool isCancelled = false;
|
2006-12-10 11:05:05 +03:00
|
|
|
mPrt->mPrintSettings->GetIsCancelled(&isCancelled);
|
|
|
|
if (isCancelled)
|
2011-10-17 18:59:28 +04:00
|
|
|
return true;
|
2002-08-21 16:01:05 +04:00
|
|
|
|
2006-12-10 11:05:05 +03:00
|
|
|
PRInt32 pageNum, numPages, endPage;
|
2002-08-21 16:01:05 +04:00
|
|
|
mPageSeqFrame->GetCurrentPageNum(&pageNum);
|
2006-12-10 11:05:05 +03:00
|
|
|
mPageSeqFrame->GetNumPages(&numPages);
|
2002-08-21 16:01:05 +04:00
|
|
|
|
2011-09-29 10:19:26 +04:00
|
|
|
bool donePrinting;
|
|
|
|
bool isDoingPrintRange;
|
2002-08-21 16:01:05 +04:00
|
|
|
mPageSeqFrame->IsDoingPrintRange(&isDoingPrintRange);
|
|
|
|
if (isDoingPrintRange) {
|
|
|
|
PRInt32 fromPage;
|
|
|
|
PRInt32 toPage;
|
|
|
|
mPageSeqFrame->GetPrintRange(&fromPage, &toPage);
|
2006-12-10 11:05:05 +03:00
|
|
|
|
2002-08-21 16:01:05 +04:00
|
|
|
if (fromPage > numPages) {
|
2011-10-17 18:59:28 +04:00
|
|
|
return true;
|
2002-08-21 16:01:05 +04:00
|
|
|
}
|
|
|
|
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;
|
2011-10-17 18:59:28 +04:00
|
|
|
aInRange = true;
|
2002-08-21 16:01:05 +04:00
|
|
|
}
|
|
|
|
|
2006-12-10 11:05:05 +03:00
|
|
|
// XXX This is wrong, but the actual behavior in the presence of a print
|
|
|
|
// range sucks.
|
|
|
|
if (mPrt->mPrintFrameType == nsIPrintSettings::kEachFrameSep)
|
|
|
|
endPage = mPrt->mNumPrintablePages;
|
|
|
|
|
2011-10-17 18:59:28 +04:00
|
|
|
mPrt->DoOnProgressChange(++mPrt->mNumPagesPrinted, endPage, false, 0);
|
2002-08-21 16:01:05 +04:00
|
|
|
|
|
|
|
// Print the Page
|
|
|
|
// if a print job was cancelled externally, an EndPage or BeginPage may
|
|
|
|
// fail and the failure is passed back here.
|
2011-10-17 18:59:28 +04:00
|
|
|
// Returning true means we are done printing.
|
2002-08-21 16:01:05 +04:00
|
|
|
//
|
|
|
|
// When rv == NS_ERROR_ABORT, it means we want out of the
|
|
|
|
// print job without displaying any error messages
|
2006-03-30 04:27:42 +04:00
|
|
|
nsresult rv = mPageSeqFrame->PrintNextPage();
|
2002-08-21 16:01:05 +04:00
|
|
|
if (NS_FAILED(rv)) {
|
|
|
|
if (rv != NS_ERROR_ABORT) {
|
|
|
|
ShowPrintErrorDialog(rv);
|
2011-10-17 18:59:28 +04:00
|
|
|
mPrt->mIsAborted = true;
|
2002-08-21 16:01:05 +04:00
|
|
|
}
|
2011-10-17 18:59:28 +04:00
|
|
|
return true;
|
2002-08-21 16:01:05 +04:00
|
|
|
}
|
|
|
|
|
2006-03-30 04:27:42 +04:00
|
|
|
mPageSeqFrame->DoPageEnd();
|
2002-08-21 16:01:05 +04:00
|
|
|
|
|
|
|
return donePrinting;
|
|
|
|
}
|
|
|
|
|
|
|
|
/** ---------------------------------------------------
|
|
|
|
* Find by checking frames type
|
|
|
|
*/
|
2002-11-22 16:02:05 +03:00
|
|
|
nsresult
|
2004-08-01 03:15:21 +04:00
|
|
|
nsPrintEngine::FindSelectionBoundsWithList(nsPresContext* aPresContext,
|
2011-04-08 05:04:40 +04:00
|
|
|
nsRenderingContext& aRC,
|
2011-08-25 00:54:29 +04:00
|
|
|
nsFrameList::Enumerator& aChildFrames,
|
2002-11-22 16:02:05 +03:00
|
|
|
nsIFrame * aParentFrame,
|
|
|
|
nsRect& aRect,
|
|
|
|
nsIFrame *& aStartFrame,
|
|
|
|
nsRect& aStartRect,
|
|
|
|
nsIFrame *& aEndFrame,
|
|
|
|
nsRect& aEndRect)
|
2002-08-21 16:01:05 +04:00
|
|
|
{
|
|
|
|
NS_ASSERTION(aPresContext, "Pointer is null!");
|
|
|
|
NS_ASSERTION(aParentFrame, "Pointer is null!");
|
|
|
|
|
2003-08-06 07:07:12 +04:00
|
|
|
aRect += aParentFrame->GetPosition();
|
2011-08-25 00:54:29 +04:00
|
|
|
for (; !aChildFrames.AtEnd(); aChildFrames.Next()) {
|
|
|
|
nsIFrame* child = aChildFrames.get();
|
2011-12-20 13:15:41 +04:00
|
|
|
if (child->IsSelected() && child->IsVisibleForPainting()) {
|
2003-08-06 07:07:12 +04:00
|
|
|
nsRect r = child->GetRect();
|
2002-08-21 16:01:05 +04:00
|
|
|
if (aStartFrame == nsnull) {
|
|
|
|
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);
|
2003-08-06 07:07:12 +04:00
|
|
|
child = child->GetNextSibling();
|
2002-08-21 16:01:05 +04:00
|
|
|
}
|
2003-08-06 07:07:12 +04:00
|
|
|
aRect -= aParentFrame->GetPosition();
|
2002-08-21 16:01:05 +04:00
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2002-11-22 16:02:05 +03:00
|
|
|
//-------------------------------------------------------
|
|
|
|
// Find the Frame that is XMost
|
|
|
|
nsresult
|
2004-08-01 03:15:21 +04:00
|
|
|
nsPrintEngine::FindSelectionBounds(nsPresContext* aPresContext,
|
2011-04-08 05:04:40 +04:00
|
|
|
nsRenderingContext& aRC,
|
2002-11-22 16:02:05 +03:00
|
|
|
nsIFrame * aParentFrame,
|
|
|
|
nsRect& aRect,
|
|
|
|
nsIFrame *& aStartFrame,
|
|
|
|
nsRect& aStartRect,
|
|
|
|
nsIFrame *& aEndFrame,
|
|
|
|
nsRect& aEndRect)
|
|
|
|
{
|
|
|
|
NS_ASSERTION(aPresContext, "Pointer is null!");
|
|
|
|
NS_ASSERTION(aParentFrame, "Pointer is null!");
|
|
|
|
|
2005-11-21 01:05:24 +03:00
|
|
|
// loop through named child lists
|
2011-08-25 00:54:29 +04:00
|
|
|
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);
|
2002-11-22 16:02:05 +03:00
|
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
2011-08-25 00:54:29 +04:00
|
|
|
}
|
2002-11-22 16:02:05 +03:00
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2002-08-21 16:01:05 +04:00
|
|
|
/** ---------------------------------------------------
|
|
|
|
* 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,
|
2004-08-01 03:15:21 +04:00
|
|
|
nsPresContext* aPresContext,
|
2011-04-08 05:04:40 +04:00
|
|
|
nsRenderingContext& aRC,
|
2002-08-21 16:01:05 +04:00
|
|
|
nsISelection* aSelection,
|
|
|
|
nsIPageSequenceFrame* aPageSeqFrame,
|
|
|
|
nsIFrame** aStartFrame,
|
|
|
|
PRInt32& aStartPageNum,
|
|
|
|
nsRect& aStartRect,
|
|
|
|
nsIFrame** aEndFrame,
|
|
|
|
PRInt32& 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!");
|
|
|
|
|
2009-01-12 22:20:59 +03:00
|
|
|
nsIFrame * seqFrame = do_QueryFrame(aPageSeqFrame);
|
|
|
|
if (!seqFrame) {
|
2002-08-21 16:01:05 +04:00
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
}
|
|
|
|
|
|
|
|
nsIFrame * startFrame = nsnull;
|
|
|
|
nsIFrame * endFrame = nsnull;
|
|
|
|
|
|
|
|
// start out with the sequence frame and search the entire frame tree
|
2005-11-21 01:05:24 +03:00
|
|
|
// capturing the starting and ending child frames of the selection
|
2002-08-21 16:01:05 +04:00
|
|
|
// and their rects
|
2003-08-06 07:07:12 +04:00
|
|
|
nsRect r = seqFrame->GetRect();
|
|
|
|
FindSelectionBounds(aPresContext, aRC, seqFrame, r,
|
|
|
|
startFrame, aStartRect, endFrame, aEndRect);
|
2002-08-21 16:01:05 +04:00
|
|
|
|
|
|
|
#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 != nsnull) {
|
|
|
|
// 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 == nsnull) {
|
|
|
|
// 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
|
2003-02-23 05:49:22 +03:00
|
|
|
startPageFrame = nsLayoutUtils::GetPageFrame(startFrame);
|
2002-08-21 16:01:05 +04:00
|
|
|
endPageFrame = startPageFrame;
|
|
|
|
aEndRect = aStartRect;
|
|
|
|
} else {
|
2003-02-23 05:49:22 +03:00
|
|
|
startPageFrame = nsLayoutUtils::GetPageFrame(startFrame);
|
|
|
|
endPageFrame = nsLayoutUtils::GetPageFrame(endFrame);
|
2002-08-21 16:01:05 +04:00
|
|
|
}
|
|
|
|
} 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
|
|
|
|
{
|
|
|
|
PRInt32 pageNum = 1;
|
2011-08-25 00:54:30 +04:00
|
|
|
nsIFrame* child = seqFrame->GetFirstPrincipalChild();
|
2002-08-21 16:01:05 +04:00
|
|
|
while (child != nsnull) {
|
|
|
|
printf("Page: %d - %p\n", pageNum, child);
|
|
|
|
pageNum++;
|
2003-08-06 07:07:12 +04:00
|
|
|
child = child->GetNextSibling();
|
2002-08-21 16:01:05 +04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
// Now that we have the page frames
|
|
|
|
// find out what the page numbers are for each frame
|
|
|
|
PRInt32 pageNum = 1;
|
2011-08-25 00:54:30 +04:00
|
|
|
nsIFrame* page = seqFrame->GetFirstPrincipalChild();
|
2002-08-21 16:01:05 +04:00
|
|
|
while (page != nsnull) {
|
|
|
|
if (page == startPageFrame) {
|
|
|
|
aStartPageNum = pageNum;
|
|
|
|
}
|
|
|
|
if (page == endPageFrame) {
|
|
|
|
aEndPageNum = pageNum;
|
|
|
|
}
|
|
|
|
pageNum++;
|
2003-08-06 07:07:12 +04:00
|
|
|
page = page->GetNextSibling();
|
2002-08-21 16:01:05 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
#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
|
|
|
|
//-----------------------------------------------------------------
|
|
|
|
|
2002-10-08 17:17:56 +04:00
|
|
|
//---------------------------------------------------------------------
|
2011-09-29 10:19:26 +04:00
|
|
|
void nsPrintEngine::SetIsPrinting(bool aIsPrinting)
|
2002-10-08 17:17:56 +04:00
|
|
|
{
|
|
|
|
mIsDoingPrinting = aIsPrinting;
|
2009-01-22 18:36:25 +03:00
|
|
|
// Calling SetIsPrinting while in print preview confuses the document viewer
|
|
|
|
// This is safe because we prevent exiting print preview while printing
|
2011-03-24 14:41:16 +03:00
|
|
|
if (!mIsDoingPrintPreview &&
|
|
|
|
mPrt && mPrt->mPrintObject && mPrt->mPrintObject->mDocShell) {
|
|
|
|
nsCOMPtr<nsIContentViewer> viewer;
|
|
|
|
mPrt->mPrintObject->mDocShell->GetContentViewer(getter_AddRefs(viewer));
|
|
|
|
nsCOMPtr<nsIDocumentViewerPrint> docViewerPrint = do_QueryInterface(viewer);
|
|
|
|
if (docViewerPrint) {
|
|
|
|
docViewerPrint->SetIsPrinting(aIsPrinting);
|
|
|
|
}
|
2002-10-08 17:17:56 +04:00
|
|
|
}
|
2007-09-05 01:44:42 +04:00
|
|
|
if (mPrt && aIsPrinting) {
|
2011-10-17 18:59:28 +04:00
|
|
|
mPrt->mPreparingForPrint = true;
|
2007-09-05 01:44:42 +04:00
|
|
|
}
|
2002-10-08 17:17:56 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
//---------------------------------------------------------------------
|
2011-09-29 10:19:26 +04:00
|
|
|
void nsPrintEngine::SetIsPrintPreview(bool aIsPrintPreview)
|
2002-10-08 17:17:56 +04:00
|
|
|
{
|
|
|
|
mIsDoingPrintPreview = aIsPrintPreview;
|
|
|
|
|
|
|
|
if (mDocViewerPrint) {
|
|
|
|
mDocViewerPrint->SetIsPrintPreview(aIsPrintPreview);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2002-08-21 16:01:05 +04:00
|
|
|
//---------------------------------------------------------------------
|
|
|
|
void
|
|
|
|
nsPrintEngine::CleanupDocTitleArray(PRUnichar**& aArray, PRInt32& aCount)
|
|
|
|
{
|
|
|
|
for (PRInt32 i = aCount - 1; i >= 0; i--) {
|
|
|
|
nsMemory::Free(aArray[i]);
|
|
|
|
}
|
|
|
|
nsMemory::Free(aArray);
|
|
|
|
aArray = NULL;
|
|
|
|
aCount = 0;
|
|
|
|
}
|
2004-02-01 15:10:57 +03:00
|
|
|
|
|
|
|
//---------------------------------------------------------------------
|
|
|
|
// static
|
2011-09-29 10:19:26 +04:00
|
|
|
bool nsPrintEngine::HasFramesetChild(nsIContent* aContent)
|
2004-02-01 15:10:57 +03:00
|
|
|
{
|
|
|
|
if (!aContent) {
|
2011-10-17 18:59:28 +04:00
|
|
|
return false;
|
2004-02-01 15:10:57 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
// do a breadth search across all siblings
|
2012-01-25 11:50:07 +04:00
|
|
|
for (nsIContent* child = aContent->GetFirstChild();
|
|
|
|
child;
|
|
|
|
child = child->GetNextSibling()) {
|
|
|
|
if (child->IsHTML(nsGkAtoms::frameset)) {
|
2011-10-17 18:59:28 +04:00
|
|
|
return true;
|
2004-02-01 15:10:57 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-10-17 18:59:28 +04:00
|
|
|
return false;
|
2004-02-01 15:10:57 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2002-08-21 16:01:05 +04:00
|
|
|
|
|
|
|
/** ---------------------------------------------------
|
|
|
|
* Get the Focused Frame for a documentviewer
|
|
|
|
*/
|
2004-01-28 14:17:14 +03:00
|
|
|
already_AddRefed<nsIDOMWindow>
|
|
|
|
nsPrintEngine::FindFocusedDOMWindow()
|
2002-08-21 16:01:05 +04:00
|
|
|
{
|
Bug 178324, refactor focus by moving all focus handling into one place and simplifying it, add many tests, fixes many other bugs too numerous to mention in this small checkin comment, r=josh,smichaud,ere,dbaron,marco,neil,gavin,smaug,sr=smaug (CLOSED TREE)
2009-06-10 22:00:39 +04:00
|
|
|
nsIFocusManager* fm = nsFocusManager::GetFocusManager();
|
2010-04-29 18:14:09 +04:00
|
|
|
NS_ENSURE_TRUE(fm, nsnull);
|
|
|
|
|
|
|
|
nsCOMPtr<nsPIDOMWindow> window(mDocument->GetWindow());
|
|
|
|
NS_ENSURE_TRUE(window, nsnull);
|
|
|
|
|
|
|
|
nsCOMPtr<nsPIDOMWindow> rootWindow = window->GetPrivateRoot();
|
|
|
|
NS_ENSURE_TRUE(rootWindow, nsnull);
|
|
|
|
|
|
|
|
nsPIDOMWindow* focusedWindow;
|
2011-10-17 18:59:28 +04:00
|
|
|
nsFocusManager::GetFocusedDescendant(rootWindow, true, &focusedWindow);
|
2010-04-29 18:14:09 +04:00
|
|
|
NS_ENSURE_TRUE(focusedWindow, nsnull);
|
|
|
|
|
|
|
|
if (IsWindowsInOurSubTree(focusedWindow)) {
|
|
|
|
return focusedWindow;
|
2002-08-21 16:01:05 +04:00
|
|
|
}
|
2004-01-28 14:17:14 +03:00
|
|
|
|
2010-04-29 18:14:09 +04:00
|
|
|
NS_IF_RELEASE(focusedWindow);
|
Bug 178324, refactor focus by moving all focus handling into one place and simplifying it, add many tests, fixes many other bugs too numerous to mention in this small checkin comment, r=josh,smichaud,ere,dbaron,marco,neil,gavin,smaug,sr=smaug (CLOSED TREE)
2009-06-10 22:00:39 +04:00
|
|
|
return nsnull;
|
2002-08-21 16:01:05 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
//---------------------------------------------------------------------
|
2011-09-29 10:19:26 +04:00
|
|
|
bool
|
2010-04-29 18:14:09 +04:00
|
|
|
nsPrintEngine::IsWindowsInOurSubTree(nsPIDOMWindow * window)
|
2002-08-21 16:01:05 +04:00
|
|
|
{
|
2011-09-29 10:19:26 +04:00
|
|
|
bool found = false;
|
2004-01-28 14:17:14 +03:00
|
|
|
|
2005-01-04 01:51:17 +03:00
|
|
|
// now check to make sure it is in "our" tree of docshells
|
2005-11-29 02:56:44 +03:00
|
|
|
if (window) {
|
2004-02-10 01:48:53 +03:00
|
|
|
nsCOMPtr<nsIDocShellTreeItem> docShellAsItem =
|
2005-11-29 02:56:44 +03:00
|
|
|
do_QueryInterface(window->GetDocShell());
|
2004-01-28 14:17:14 +03:00
|
|
|
|
|
|
|
if (docShellAsItem) {
|
2005-01-04 01:51:17 +03:00
|
|
|
// get this DocViewer docshell
|
2011-05-10 16:55:26 +04:00
|
|
|
nsCOMPtr<nsIDocShell> thisDVDocShell(do_QueryReferent(mContainer));
|
2004-01-28 14:17:14 +03:00
|
|
|
while (!found) {
|
2006-12-10 11:05:05 +03:00
|
|
|
nsCOMPtr<nsIDocShell> parentDocshell(do_QueryInterface(docShellAsItem));
|
2005-01-04 01:51:17 +03:00
|
|
|
if (parentDocshell) {
|
|
|
|
if (parentDocshell == thisDVDocShell) {
|
2011-10-17 18:59:28 +04:00
|
|
|
found = true;
|
2004-01-28 14:17:14 +03:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
break; // at top of tree
|
2002-08-21 16:01:05 +04:00
|
|
|
}
|
2006-12-10 11:05:05 +03:00
|
|
|
nsCOMPtr<nsIDocShellTreeItem> docShellParent;
|
|
|
|
docShellAsItem->GetSameTypeParent(getter_AddRefs(docShellParent));
|
2004-01-28 14:17:14 +03:00
|
|
|
docShellAsItem = docShellParent;
|
|
|
|
} // while
|
|
|
|
}
|
|
|
|
} // scriptobj
|
2002-08-21 16:01:05 +04:00
|
|
|
|
|
|
|
return found;
|
|
|
|
}
|
|
|
|
|
|
|
|
//-------------------------------------------------------
|
2011-09-29 10:19:26 +04:00
|
|
|
bool
|
2002-08-21 16:01:05 +04:00
|
|
|
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 (aPO != nsnull) {
|
2011-10-17 18:59:28 +04:00
|
|
|
aPO->mHasBeenPrinted = true;
|
2002-08-21 16:01:05 +04:00
|
|
|
nsresult rv;
|
2011-09-29 10:19:26 +04:00
|
|
|
bool didPrint = PrintDocContent(mPrt->mPrintObject, rv);
|
2002-08-21 16:01:05 +04:00
|
|
|
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)));
|
2011-10-17 18:59:28 +04:00
|
|
|
return false;
|
2002-08-21 16:01:05 +04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (NS_SUCCEEDED(aResult)) {
|
|
|
|
FirePrintCompletionEvent();
|
|
|
|
}
|
|
|
|
|
2011-10-17 18:59:28 +04:00
|
|
|
TurnScriptingOn(true);
|
|
|
|
SetIsPrinting(false);
|
2002-08-21 16:01:05 +04:00
|
|
|
|
2006-12-10 11:05:05 +03:00
|
|
|
// Release reference to mPagePrintTimer; the timer object destroys itself
|
|
|
|
// after this returns true
|
2002-08-21 16:01:05 +04:00
|
|
|
NS_IF_RELEASE(mPagePrintTimer);
|
|
|
|
|
2011-10-17 18:59:28 +04:00
|
|
|
return true;
|
2002-08-21 16:01:05 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
//-------------------------------------------------------
|
|
|
|
// Recursively sets the PO items to be printed "As Is"
|
|
|
|
// from the given item down into the tree
|
|
|
|
void
|
2011-09-29 10:19:26 +04:00
|
|
|
nsPrintEngine::SetPrintAsIs(nsPrintObject* aPO, bool aAsIs)
|
2002-08-21 16:01:05 +04:00
|
|
|
{
|
|
|
|
NS_ASSERTION(aPO, "Pointer is null!");
|
|
|
|
|
|
|
|
aPO->mPrintAsIs = aAsIs;
|
2009-02-03 17:42:18 +03:00
|
|
|
for (PRUint32 i=0;i<aPO->mKids.Length();i++) {
|
|
|
|
SetPrintAsIs(aPO->mKids[i], aAsIs);
|
2002-08-21 16:01:05 +04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
//-------------------------------------------------------
|
|
|
|
// Given a DOMWindow it recursively finds the PO object that matches
|
|
|
|
nsPrintObject*
|
2004-01-28 14:17:14 +03:00
|
|
|
nsPrintEngine::FindPrintObjectByDOMWin(nsPrintObject* aPO,
|
|
|
|
nsIDOMWindow* aDOMWin)
|
2002-08-21 16:01:05 +04:00
|
|
|
{
|
|
|
|
NS_ASSERTION(aPO, "Pointer is null!");
|
|
|
|
|
|
|
|
// Often the CurFocused DOMWindow is passed in
|
|
|
|
// andit is valid for it to be null, so short circut
|
2004-01-28 14:17:14 +03:00
|
|
|
if (!aDOMWin) {
|
2002-08-21 16:01:05 +04:00
|
|
|
return nsnull;
|
|
|
|
}
|
|
|
|
|
2009-12-11 07:02:13 +03:00
|
|
|
nsCOMPtr<nsIDOMDocument> domDoc;
|
|
|
|
aDOMWin->GetDocument(getter_AddRefs(domDoc));
|
|
|
|
nsCOMPtr<nsIDocument> doc = do_QueryInterface(domDoc);
|
|
|
|
if (aPO->mDocument && aPO->mDocument->GetOriginalDocument() == doc) {
|
2002-08-21 16:01:05 +04:00
|
|
|
return aPO;
|
|
|
|
}
|
|
|
|
|
2009-02-03 17:42:18 +03:00
|
|
|
PRInt32 cnt = aPO->mKids.Length();
|
2004-01-28 14:17:14 +03:00
|
|
|
for (PRInt32 i = 0; i < cnt; ++i) {
|
2009-02-03 17:42:18 +03:00
|
|
|
nsPrintObject* po = FindPrintObjectByDOMWin(aPO->mKids[i], aDOMWin);
|
2004-01-28 14:17:14 +03:00
|
|
|
if (po) {
|
2002-08-21 16:01:05 +04:00
|
|
|
return po;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2004-01-28 14:17:14 +03:00
|
|
|
return nsnull;
|
2002-08-21 16:01:05 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
//-------------------------------------------------------
|
|
|
|
nsresult
|
|
|
|
nsPrintEngine::EnablePOsForPrinting()
|
|
|
|
{
|
|
|
|
// NOTE: All POs have been "turned off" for printing
|
|
|
|
// this is where we decided which POs get printed.
|
|
|
|
mPrt->mSelectedPO = nsnull;
|
|
|
|
|
|
|
|
if (mPrt->mPrintSettings == nsnull) {
|
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
}
|
|
|
|
|
|
|
|
mPrt->mPrintFrameType = nsIPrintSettings::kNoFrames;
|
|
|
|
mPrt->mPrintSettings->GetPrintFrameType(&mPrt->mPrintFrameType);
|
|
|
|
|
|
|
|
PRInt16 printHowEnable = nsIPrintSettings::kFrameEnableNone;
|
|
|
|
mPrt->mPrintSettings->GetHowToEnableFrameUI(&printHowEnable);
|
|
|
|
|
|
|
|
PRInt16 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) {
|
2011-10-17 18:59:28 +04:00
|
|
|
SetPrintPO(mPrt->mPrintObject, true);
|
2002-08-21 16:01:05 +04:00
|
|
|
|
|
|
|
// Set the children so they are PrinAsIs
|
|
|
|
// In this case, the children are probably IFrames
|
2009-02-03 17:42:18 +03:00
|
|
|
if (mPrt->mPrintObject->mKids.Length() > 0) {
|
|
|
|
for (PRUint32 i=0;i<mPrt->mPrintObject->mKids.Length();i++) {
|
|
|
|
nsPrintObject* po = mPrt->mPrintObject->mKids[i];
|
2002-08-21 16:01:05 +04:00
|
|
|
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 != nsnull) {
|
|
|
|
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
|
2011-10-17 18:59:28 +04:00
|
|
|
SetPrintPO(po, true);
|
2002-08-21 16:01:05 +04:00
|
|
|
|
|
|
|
// 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
|
2009-12-11 07:02:13 +03:00
|
|
|
nsCOMPtr<nsIDOMWindow> domWin =
|
|
|
|
do_QueryInterface(po->mDocument->GetOriginalDocument()->GetWindow());
|
2002-08-21 16:01:05 +04:00
|
|
|
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 {
|
2009-02-03 17:42:18 +03:00
|
|
|
for (PRUint32 i=0;i<mPrt->mPrintDocList.Length();i++) {
|
|
|
|
nsPrintObject* po = mPrt->mPrintDocList.ElementAt(i);
|
2002-08-21 16:01:05 +04:00
|
|
|
NS_ASSERTION(po, "nsPrintObject can't be null!");
|
2005-01-04 01:51:17 +03:00
|
|
|
nsCOMPtr<nsIDOMWindow> domWin = do_GetInterface(po->mDocShell);
|
2002-08-21 16:01:05 +04:00
|
|
|
if (IsThereARangeSelection(domWin)) {
|
|
|
|
mPrt->mCurrentFocusWin = domWin;
|
2011-10-17 18:59:28 +04:00
|
|
|
SetPrintPO(po, true);
|
2002-08-21 16:01:05 +04:00
|
|
|
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 != nsnull) {
|
|
|
|
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
|
2011-10-17 18:59:28 +04:00
|
|
|
SetPrintPO(po, true);
|
2002-08-21 16:01:05 +04:00
|
|
|
|
|
|
|
// 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
|
2009-12-11 07:02:13 +03:00
|
|
|
nsCOMPtr<nsIDOMWindow> domWin =
|
|
|
|
do_QueryInterface(po->mDocument->GetOriginalDocument()->GetWindow());
|
2002-08-21 16:01:05 +04:00
|
|
|
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);
|
2011-10-17 18:59:28 +04:00
|
|
|
SetPrintPO(mPrt->mPrintObject, true);
|
2002-08-21 16:01:05 +04:00
|
|
|
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 != nsnull) {
|
|
|
|
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
|
2009-02-03 17:42:18 +03:00
|
|
|
if (po->mKids.Length() > 0) {
|
2002-08-21 16:01:05 +04:00
|
|
|
// 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
|
2011-10-17 18:59:28 +04:00
|
|
|
SetPrintPO(po, true);
|
2002-08-21 16:01:05 +04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
// If we are print each subdoc separately,
|
|
|
|
// then don't print any of the FraneSet Docs
|
|
|
|
if (mPrt->mPrintFrameType == nsIPrintSettings::kEachFrameSep) {
|
2011-10-17 18:59:28 +04:00
|
|
|
SetPrintPO(mPrt->mPrintObject, true);
|
2009-02-03 17:42:18 +03:00
|
|
|
PRInt32 cnt = mPrt->mPrintDocList.Length();
|
2002-08-21 16:01:05 +04:00
|
|
|
for (PRInt32 i=0;i<cnt;i++) {
|
2009-02-03 17:42:18 +03:00
|
|
|
nsPrintObject* po = mPrt->mPrintDocList.ElementAt(i);
|
2002-08-21 16:01:05 +04:00
|
|
|
NS_ASSERTION(po, "nsPrintObject can't be null!");
|
|
|
|
if (po->mFrameType == eFrameSet) {
|
2011-10-17 18:59:28 +04:00
|
|
|
po->mDontPrint = true;
|
2002-08-21 16:01:05 +04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
//-------------------------------------------------------
|
|
|
|
// Return the nsPrintObject with that is XMost (The widest frameset frame) AND
|
|
|
|
// contains the XMost (widest) layout frame
|
|
|
|
nsPrintObject*
|
2002-09-20 01:45:07 +04:00
|
|
|
nsPrintEngine::FindSmallestSTF()
|
2002-08-21 16:01:05 +04:00
|
|
|
{
|
2002-09-20 01:45:07 +04:00
|
|
|
float smallestRatio = 1.0f;
|
|
|
|
nsPrintObject* smallestPO = nsnull;
|
2002-08-21 16:01:05 +04:00
|
|
|
|
2009-02-03 17:42:18 +03:00
|
|
|
for (PRUint32 i=0;i<mPrt->mPrintDocList.Length();i++) {
|
|
|
|
nsPrintObject* po = mPrt->mPrintDocList.ElementAt(i);
|
2002-08-21 16:01:05 +04:00
|
|
|
NS_ASSERTION(po, "nsPrintObject can't be null!");
|
|
|
|
if (po->mFrameType != eFrameSet && po->mFrameType != eIFrame) {
|
2002-09-20 01:45:07 +04:00
|
|
|
if (po->mShrinkRatio < smallestRatio) {
|
|
|
|
smallestRatio = po->mShrinkRatio;
|
|
|
|
smallestPO = po;
|
2002-08-21 16:01:05 +04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#ifdef EXTENDED_DEBUG_PRINTING
|
2002-09-20 01:45:07 +04:00
|
|
|
if (smallestPO) printf("*PO: %p Type: %d %10.3f\n", smallestPO, smallestPO->mFrameType, smallestPO->mShrinkRatio);
|
2002-08-21 16:01:05 +04:00
|
|
|
#endif
|
2002-09-20 01:45:07 +04:00
|
|
|
return smallestPO;
|
2002-08-21 16:01:05 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
//-------------------------------------------------------
|
|
|
|
void
|
2011-09-29 10:19:26 +04:00
|
|
|
nsPrintEngine::TurnScriptingOn(bool aDoTurnOn)
|
2002-08-21 16:01:05 +04:00
|
|
|
{
|
2009-03-10 22:30:50 +03:00
|
|
|
if (mIsDoingPrinting && aDoTurnOn && mDocViewerPrint &&
|
|
|
|
mDocViewerPrint->GetIsPrintPreview()) {
|
|
|
|
// We don't want to turn scripting on if print preview is shown still after
|
|
|
|
// printing.
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2005-07-13 23:10:00 +04:00
|
|
|
nsPrintData* prt = mPrt;
|
|
|
|
#ifdef NS_PRINT_PREVIEW
|
|
|
|
if (!prt) {
|
|
|
|
prt = mPrtPreview;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
if (!prt) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2002-08-21 16:01:05 +04:00
|
|
|
NS_ASSERTION(mDocument, "We MUST have a document.");
|
2005-07-13 23:10:00 +04:00
|
|
|
// First, get the script global object from the document...
|
2002-08-21 16:01:05 +04:00
|
|
|
|
2009-02-03 17:42:18 +03:00
|
|
|
for (PRUint32 i=0;i<prt->mPrintDocList.Length();i++) {
|
|
|
|
nsPrintObject* po = prt->mPrintDocList.ElementAt(i);
|
2005-07-13 23:10:00 +04:00
|
|
|
NS_ASSERTION(po, "nsPrintObject can't be null!");
|
2006-04-22 04:06:30 +04:00
|
|
|
|
|
|
|
nsIDocument* doc = po->mDocument;
|
2009-03-10 22:30:50 +03:00
|
|
|
if (!doc) {
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2005-07-13 23:10:00 +04:00
|
|
|
// get the script global object
|
2006-04-22 04:06:30 +04:00
|
|
|
nsIScriptGlobalObject *scriptGlobalObj = doc->GetScriptGlobalObject();
|
2005-11-29 02:56:44 +03:00
|
|
|
|
2005-07-13 23:10:00 +04:00
|
|
|
if (scriptGlobalObj) {
|
2009-03-10 22:30:50 +03:00
|
|
|
nsCOMPtr<nsPIDOMWindow> window = do_QueryInterface(scriptGlobalObj);
|
|
|
|
NS_ASSERTION(window, "Can't get nsPIDOMWindow");
|
2005-07-13 23:10:00 +04:00
|
|
|
nsIScriptContext *scx = scriptGlobalObj->GetContext();
|
2009-03-10 22:30:50 +03:00
|
|
|
NS_WARN_IF_FALSE(scx, "Can't get nsIScriptContext");
|
|
|
|
nsresult propThere = NS_PROPTABLE_PROP_NOT_THERE;
|
|
|
|
doc->GetProperty(nsGkAtoms::scriptEnabledBeforePrintOrPreview,
|
|
|
|
&propThere);
|
2006-04-22 04:06:30 +04:00
|
|
|
if (aDoTurnOn) {
|
2009-03-10 22:30:50 +03:00
|
|
|
if (propThere != NS_PROPTABLE_PROP_NOT_THERE) {
|
|
|
|
doc->DeleteProperty(nsGkAtoms::scriptEnabledBeforePrintOrPreview);
|
|
|
|
if (scx) {
|
2011-10-17 18:59:28 +04:00
|
|
|
scx->SetScriptsEnabled(true, false);
|
2009-03-10 22:30:50 +03:00
|
|
|
}
|
2011-10-17 18:59:28 +04:00
|
|
|
window->ResumeTimeouts(false);
|
2009-03-10 22:30:50 +03:00
|
|
|
}
|
2006-04-22 04:06:30 +04:00
|
|
|
} else {
|
2006-06-03 00:29:05 +04:00
|
|
|
// Have to be careful, because people call us over and over again with
|
2011-10-17 18:59:28 +04:00
|
|
|
// aDoTurnOn == false. So don't set the property if it's already
|
2006-06-03 00:29:05 +04:00
|
|
|
// 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.
|
2009-03-10 22:30:50 +03:00
|
|
|
doc->SetProperty(nsGkAtoms::scriptEnabledBeforePrintOrPreview,
|
2006-06-03 00:29:05 +04:00
|
|
|
NS_INT32_TO_PTR(doc->IsScriptEnabled()));
|
2009-03-10 22:30:50 +03:00
|
|
|
if (scx) {
|
2011-10-17 18:59:28 +04:00
|
|
|
scx->SetScriptsEnabled(false, false);
|
2009-03-10 22:30:50 +03:00
|
|
|
}
|
2011-10-17 18:59:28 +04:00
|
|
|
window->SuspendTimeouts(1, false);
|
2006-06-03 00:29:05 +04:00
|
|
|
}
|
2006-04-22 04:06:30 +04:00
|
|
|
}
|
2005-07-13 23:10:00 +04:00
|
|
|
}
|
2005-05-05 00:22:32 +04:00
|
|
|
}
|
2002-08-21 16:01:05 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
//-----------------------------------------------------------------
|
|
|
|
//-- Done: Misc Support Methods
|
|
|
|
//-----------------------------------------------------------------
|
|
|
|
|
|
|
|
|
|
|
|
//-----------------------------------------------------------------
|
|
|
|
//-- Section: Finishing up or Cleaning up
|
|
|
|
//-----------------------------------------------------------------
|
|
|
|
|
|
|
|
//-----------------------------------------------------------------
|
|
|
|
void
|
|
|
|
nsPrintEngine::CloseProgressDialog(nsIWebProgressListener* aWebProgressListener)
|
|
|
|
{
|
|
|
|
if (aWebProgressListener) {
|
|
|
|
aWebProgressListener->OnStateChange(nsnull, nsnull, nsIWebProgressListener::STATE_STOP|nsIWebProgressListener::STATE_IS_DOCUMENT, nsnull);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
//-----------------------------------------------------------------
|
|
|
|
nsresult
|
|
|
|
nsPrintEngine::FinishPrintPreview()
|
|
|
|
{
|
|
|
|
nsresult rv = NS_OK;
|
|
|
|
|
|
|
|
#ifdef NS_PRINT_PREVIEW
|
|
|
|
|
2008-04-09 09:24:13 +04:00
|
|
|
if (!mPrt) {
|
|
|
|
/* we're already finished with print preview */
|
|
|
|
return rv;
|
|
|
|
}
|
|
|
|
|
2002-08-21 16:01:05 +04:00
|
|
|
rv = DocumentReadyForPrinting();
|
|
|
|
|
2011-10-17 18:59:28 +04:00
|
|
|
SetIsCreatingPrintPreview(false);
|
2002-08-21 16:01:05 +04:00
|
|
|
|
|
|
|
/* 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();
|
2011-10-17 18:59:28 +04:00
|
|
|
TurnScriptingOn(true);
|
2002-08-21 16:01:05 +04:00
|
|
|
|
2007-11-10 01:38:46 +03:00
|
|
|
return rv;
|
2002-08-21 16:01:05 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
// At this point we are done preparing everything
|
|
|
|
// before it is to be created
|
|
|
|
|
2006-12-10 11:05:05 +03:00
|
|
|
|
|
|
|
if (mIsDoingPrintPreview && mOldPrtPreview) {
|
|
|
|
delete mOldPrtPreview;
|
|
|
|
mOldPrtPreview = nsnull;
|
|
|
|
}
|
|
|
|
|
|
|
|
InstallPrintPreviewListener();
|
2002-08-21 16:01:05 +04:00
|
|
|
|
|
|
|
mPrt->OnEndPrinting();
|
2006-12-10 11:05:05 +03:00
|
|
|
|
2002-08-21 16:01:05 +04:00
|
|
|
// PrintPreview was built using the mPrt (code reuse)
|
|
|
|
// then we assign it over
|
|
|
|
mPrtPreview = mPrt;
|
|
|
|
mPrt = nsnull;
|
|
|
|
|
|
|
|
#endif // NS_PRINT_PREVIEW
|
|
|
|
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
//-----------------------------------------------------------------
|
|
|
|
//-- Done: Finishing up or Cleaning up
|
|
|
|
//-----------------------------------------------------------------
|
|
|
|
|
|
|
|
|
|
|
|
/*=============== Timer Related Code ======================*/
|
|
|
|
nsresult
|
2006-12-10 11:05:05 +03:00
|
|
|
nsPrintEngine::StartPagePrintTimer(nsPrintObject* aPO)
|
2002-08-21 16:01:05 +04:00
|
|
|
{
|
|
|
|
if (!mPagePrintTimer) {
|
2006-12-10 11:05:05 +03:00
|
|
|
nsresult rv = NS_NewPagePrintTimer(&mPagePrintTimer);
|
|
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
2002-08-21 16:01:05 +04:00
|
|
|
|
2006-12-10 11:05:05 +03:00
|
|
|
// Get the delay time in between the printing of each page
|
|
|
|
// this gives the user more time to press cancel
|
2009-12-19 13:32:53 +03:00
|
|
|
PRInt32 printPageDelay = 50;
|
2006-12-10 11:05:05 +03:00
|
|
|
mPrt->mPrintSettings->GetPrintPageDelay(&printPageDelay);
|
2002-08-21 16:01:05 +04:00
|
|
|
|
2006-12-10 11:05:05 +03:00
|
|
|
mPagePrintTimer->Init(this, mDocViewerPrint, printPageDelay);
|
2002-08-21 16:01:05 +04:00
|
|
|
}
|
|
|
|
|
2006-12-10 11:05:05 +03:00
|
|
|
return mPagePrintTimer->Start(aPO);
|
2002-08-21 16:01:05 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
/*=============== nsIObserver Interface ======================*/
|
|
|
|
NS_IMETHODIMP
|
|
|
|
nsPrintEngine::Observe(nsISupports *aSubject, const char *aTopic, const PRUnichar *aData)
|
|
|
|
{
|
|
|
|
nsresult rv = NS_ERROR_FAILURE;
|
|
|
|
|
|
|
|
if (mIsDoingPrinting) {
|
|
|
|
rv = DocumentReadyForPrinting();
|
|
|
|
|
|
|
|
/* cleaup on failure + notify user */
|
|
|
|
if (NS_FAILED(rv)) {
|
2011-10-17 18:59:28 +04:00
|
|
|
CleanupOnFailure(rv, true);
|
2002-08-21 16:01:05 +04:00
|
|
|
}
|
|
|
|
} else {
|
|
|
|
rv = FinishPrintPreview();
|
2007-11-10 01:38:46 +03:00
|
|
|
if (NS_FAILED(rv)) {
|
2011-10-17 18:59:28 +04:00
|
|
|
CleanupOnFailure(rv, false);
|
2007-11-10 01:38:46 +03:00
|
|
|
}
|
2002-08-21 16:01:05 +04:00
|
|
|
if (mPrtPreview) {
|
|
|
|
mPrtPreview->OnEndPrinting();
|
|
|
|
}
|
|
|
|
rv = NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
return rv;
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
//---------------------------------------------------------------
|
|
|
|
//-- PLEvent Notification
|
|
|
|
//---------------------------------------------------------------
|
2006-05-10 21:30:15 +04:00
|
|
|
class nsPrintCompletionEvent : public nsRunnable {
|
|
|
|
public:
|
|
|
|
nsPrintCompletionEvent(nsIDocumentViewerPrint *docViewerPrint)
|
|
|
|
: mDocViewerPrint(docViewerPrint) {
|
|
|
|
NS_ASSERTION(mDocViewerPrint, "mDocViewerPrint is null.");
|
2002-08-21 16:01:05 +04:00
|
|
|
}
|
2005-11-14 23:09:51 +03:00
|
|
|
|
2006-05-10 21:30:15 +04:00
|
|
|
NS_IMETHOD Run() {
|
|
|
|
if (mDocViewerPrint)
|
|
|
|
mDocViewerPrint->OnDonePrinting();
|
|
|
|
return NS_OK;
|
|
|
|
}
|
2002-08-21 16:01:05 +04:00
|
|
|
|
2006-05-10 21:30:15 +04:00
|
|
|
private:
|
|
|
|
nsCOMPtr<nsIDocumentViewerPrint> mDocViewerPrint;
|
|
|
|
};
|
2002-08-21 16:01:05 +04:00
|
|
|
|
|
|
|
//-----------------------------------------------------------
|
|
|
|
void
|
|
|
|
nsPrintEngine::FirePrintCompletionEvent()
|
|
|
|
{
|
2006-05-10 21:30:15 +04:00
|
|
|
nsCOMPtr<nsIRunnable> event = new nsPrintCompletionEvent(mDocViewerPrint);
|
|
|
|
if (NS_FAILED(NS_DispatchToCurrentThread(event)))
|
|
|
|
NS_WARNING("failed to dispatch print completion event");
|
2002-08-21 16:01:05 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
//---------------------------------------------------------------
|
|
|
|
//---------------------------------------------------------------
|
|
|
|
//-- Debug helper routines
|
|
|
|
//---------------------------------------------------------------
|
|
|
|
//---------------------------------------------------------------
|
2003-04-03 02:45:08 +04:00
|
|
|
#if (defined(XP_WIN) || defined(XP_OS2)) && defined(EXTENDED_DEBUG_PRINTING)
|
2002-08-21 16:01:05 +04:00
|
|
|
#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
|
|
|
|
*/
|
2004-08-01 03:15:21 +04:00
|
|
|
static void RootFrameList(nsPresContext* aPresContext, FILE* out, PRInt32 aIndent)
|
2002-08-21 16:01:05 +04:00
|
|
|
{
|
2002-12-11 17:24:49 +03:00
|
|
|
if (!aPresContext || !out)
|
2002-08-21 16:01:05 +04:00
|
|
|
return;
|
|
|
|
|
2003-12-21 08:36:36 +03:00
|
|
|
nsIPresShell *shell = aPresContext->GetPresShell();
|
2002-12-11 17:24:49 +03:00
|
|
|
if (shell) {
|
2004-09-02 07:08:51 +04:00
|
|
|
nsIFrame* frame = shell->FrameManager()->GetRootFrame();
|
2002-12-11 17:24:49 +03:00
|
|
|
if (frame) {
|
2009-08-21 01:52:48 +04:00
|
|
|
frame->List(aPresContext, out, aIndent);
|
2002-08-21 16:01:05 +04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/** ---------------------------------------------------
|
|
|
|
* Dumps Frames for Printing
|
|
|
|
*/
|
|
|
|
static void DumpFrames(FILE* out,
|
2004-08-01 03:15:21 +04:00
|
|
|
nsPresContext* aPresContext,
|
2011-04-08 05:04:40 +04:00
|
|
|
nsRenderingContext * aRendContext,
|
2002-08-21 16:01:05 +04:00
|
|
|
nsIFrame * aFrame,
|
|
|
|
PRInt32 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!");
|
|
|
|
|
2011-08-25 00:54:30 +04:00
|
|
|
nsIFrame* child = aFrame->GetFirstPrincipalChild();
|
2002-08-21 16:01:05 +04:00
|
|
|
while (child != nsnull) {
|
|
|
|
for (PRInt32 i=0;i<aLevel;i++) {
|
|
|
|
fprintf(out, " ");
|
|
|
|
}
|
|
|
|
nsAutoString tmp;
|
2009-08-21 01:52:48 +04:00
|
|
|
child->GetFrameName(tmp);
|
2006-02-03 17:18:39 +03:00
|
|
|
fputs(NS_LossyConvertUTF16toASCII(tmp).get(), out);
|
2011-09-29 10:19:26 +04:00
|
|
|
bool isSelected;
|
2011-10-17 18:59:28 +04:00
|
|
|
if (NS_SUCCEEDED(child->IsVisibleForPainting(aPresContext, *aRendContext, true, &isSelected))) {
|
2002-08-21 16:01:05 +04:00
|
|
|
fprintf(out, " %p %s", child, isSelected?"VIS":"UVS");
|
2003-08-06 07:07:12 +04:00
|
|
|
nsRect rect = child->GetRect();
|
2002-08-21 16:01:05 +04:00
|
|
|
fprintf(out, "[%d,%d,%d,%d] ", rect.x, rect.y, rect.width, rect.height);
|
2003-08-06 07:07:12 +04:00
|
|
|
fprintf(out, "v: %p ", (void*)child->GetView());
|
2002-08-21 16:01:05 +04:00
|
|
|
fprintf(out, "\n");
|
|
|
|
DumpFrames(out, aPresContext, aRendContext, child, aLevel+1);
|
2003-08-06 07:07:12 +04:00
|
|
|
child = child->GetNextSibling();
|
2002-08-21 16:01:05 +04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/** ---------------------------------------------------
|
|
|
|
* 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 (nsnull != aDocShell) {
|
|
|
|
fprintf(out, "docshell=%p \n", aDocShell);
|
2002-09-20 01:45:07 +04:00
|
|
|
nsIPresShell* shell = nsPrintEngine::GetPresShellFor(aDocShell);
|
2003-09-27 08:18:26 +04:00
|
|
|
if (shell) {
|
2003-08-06 07:07:12 +04:00
|
|
|
nsIViewManager* vm = shell->GetViewManager();
|
2002-08-21 16:01:05 +04:00
|
|
|
if (vm) {
|
2011-03-30 06:24:54 +04:00
|
|
|
nsIView* root = vm->GetRootView();
|
|
|
|
if (root) {
|
2004-05-17 20:29:13 +04:00
|
|
|
root->List(out);
|
|
|
|
}
|
2002-08-21 16:01:05 +04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
fputs("null pres shell\n", out);
|
|
|
|
}
|
|
|
|
|
|
|
|
// dump the views of the sub documents
|
|
|
|
PRInt32 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,
|
2004-08-01 03:15:21 +04:00
|
|
|
nsPresContext* aPresContext,
|
2011-04-17 05:22:44 +04:00
|
|
|
nsDeviceContext * aDC,
|
2002-08-21 16:01:05 +04:00
|
|
|
nsIFrame * aRootFrame,
|
2005-01-04 01:51:17 +03:00
|
|
|
nsIDocShekk * aDocShell,
|
2002-08-21 16:01:05 +04:00
|
|
|
FILE* aFD = nsnull)
|
|
|
|
{
|
|
|
|
if (!kPrintingLogMod || kPrintingLogMod->level != DUMP_LAYOUT_LEVEL) return;
|
|
|
|
|
|
|
|
if (aPresContext == nsnull || aDC == nsnull) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
#ifdef NS_PRINT_PREVIEW
|
2004-08-01 03:15:21 +04:00
|
|
|
if (aPresContext->Type() == nsPresContext::eContext_PrintPreview) {
|
2002-08-21 16:01:05 +04:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
NS_ASSERTION(aRootFrame, "Pointer is null!");
|
2005-01-04 01:51:17 +03:00
|
|
|
NS_ASSERTION(aDocShell, "Pointer is null!");
|
2002-08-21 16:01:05 +04:00
|
|
|
|
|
|
|
// 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");
|
2011-04-08 05:04:40 +04:00
|
|
|
nsRefPtr<nsRenderingContext> renderingContext;
|
2002-08-21 16:01:05 +04:00
|
|
|
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");
|
2003-08-06 07:07:12 +04:00
|
|
|
nsIView* v = aRootFrame->GetView();
|
2002-08-21 16:01:05 +04:00
|
|
|
if (v) {
|
|
|
|
v->List(fd);
|
|
|
|
} else {
|
|
|
|
printf("View is null!\n");
|
|
|
|
}
|
2005-01-04 01:51:17 +03:00
|
|
|
if (aDocShell) {
|
2002-08-21 16:01:05 +04:00
|
|
|
fprintf(fd, "--------------- All Views ----------------\n");
|
2005-01-04 01:51:17 +03:00
|
|
|
DumpViews(aDocShell, fd);
|
2002-08-21 16:01:05 +04:00
|
|
|
fprintf(fd, "---------------------------------------\n\n");
|
|
|
|
}
|
|
|
|
if (aFD == nsnull) {
|
|
|
|
fclose(fd);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
//-------------------------------------------------------------
|
2009-02-03 17:42:18 +03:00
|
|
|
static void DumpPrintObjectsList(nsTArray<nsPrintObject*> * aDocList)
|
2002-08-21 16:01:05 +04:00
|
|
|
{
|
|
|
|
if (!kPrintingLogMod || kPrintingLogMod->level != DUMP_LAYOUT_LEVEL) return;
|
|
|
|
|
|
|
|
NS_ASSERTION(aDocList, "Pointer is null!");
|
|
|
|
|
2004-02-03 01:42:29 +03:00
|
|
|
const char types[][3] = {"DC", "FR", "IF", "FS"};
|
2002-08-21 16:01:05 +04:00
|
|
|
PR_PL(("Doc List\n***************************************************\n"));
|
2005-01-04 01:51:17 +03:00
|
|
|
PR_PL(("T P A H PO DocShell Seq Page Root Page# Rect\n"));
|
2009-02-03 17:42:18 +03:00
|
|
|
PRInt32 cnt = aDocList->Length();
|
2002-08-21 16:01:05 +04:00
|
|
|
for (PRInt32 i=0;i<cnt;i++) {
|
2009-02-03 17:42:18 +03:00
|
|
|
nsPrintObject* po = aDocList->ElementAt(i);
|
2002-08-21 16:01:05 +04:00
|
|
|
NS_ASSERTION(po, "nsPrintObject can't be null!");
|
|
|
|
nsIFrame* rootFrame = nsnull;
|
|
|
|
if (po->mPresShell) {
|
2004-09-02 07:08:51 +04:00
|
|
|
rootFrame = po->mPresShell->FrameManager()->GetRootFrame();
|
2002-08-21 16:01:05 +04:00
|
|
|
while (rootFrame != nsnull) {
|
2009-01-12 22:20:59 +03:00
|
|
|
nsIPageSequenceFrame * sqf = do_QueryFrame(rootFrame);
|
|
|
|
if (sqf) {
|
2002-08-21 16:01:05 +04:00
|
|
|
break;
|
|
|
|
}
|
2011-08-25 00:54:30 +04:00
|
|
|
rootFrame = rootFrame->GetFirstPrincipalChild();
|
2002-08-21 16:01:05 +04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
PR_PL(("%s %d %d %d %p %p %p %p %p %d %d,%d,%d,%d\n", types[po->mFrameType],
|
2005-01-04 01:51:17 +03:00
|
|
|
po->IsPrintable(), po->mPrintAsIs, po->mHasBeenPrinted, po, po->mDocShell.get(), po->mSeqFrame,
|
2002-08-21 16:01:05 +04:00
|
|
|
po->mPageFrame, rootFrame, po->mPageNum, po->mRect.x, po->mRect.y, po->mRect.width, po->mRect.height));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
//-------------------------------------------------------------
|
2002-09-20 01:45:07 +04:00
|
|
|
static void DumpPrintObjectsTree(nsPrintObject * aPO, int aLevel, FILE* aFD)
|
2002-08-21 16:01:05 +04:00
|
|
|
{
|
|
|
|
if (!kPrintingLogMod || kPrintingLogMod->level != DUMP_LAYOUT_LEVEL) return;
|
|
|
|
|
|
|
|
NS_ASSERTION(aPO, "Pointer is null!");
|
|
|
|
|
|
|
|
FILE * fd = aFD?aFD:stdout;
|
2004-02-03 01:42:29 +03:00
|
|
|
const char types[][3] = {"DC", "FR", "IF", "FS"};
|
2002-08-21 16:01:05 +04:00
|
|
|
if (aLevel == 0) {
|
|
|
|
fprintf(fd, "DocTree\n***************************************************\n");
|
2005-01-04 01:51:17 +03:00
|
|
|
fprintf(fd, "T PO DocShell Seq Page Page# Rect\n");
|
2002-08-21 16:01:05 +04:00
|
|
|
}
|
2009-02-03 17:42:18 +03:00
|
|
|
PRInt32 cnt = aPO->mKids.Length();
|
2002-08-21 16:01:05 +04:00
|
|
|
for (PRInt32 i=0;i<cnt;i++) {
|
2009-02-03 17:42:18 +03:00
|
|
|
nsPrintObject* po = aPO->mKids.ElementAt(i);
|
2002-08-21 16:01:05 +04:00
|
|
|
NS_ASSERTION(po, "nsPrintObject can't be null!");
|
|
|
|
for (PRInt32 k=0;k<aLevel;k++) fprintf(fd, " ");
|
2005-01-04 01:51:17 +03:00
|
|
|
fprintf(fd, "%s %p %p %p %p %d %d,%d,%d,%d\n", types[po->mFrameType], po, po->mDocShell.get(), po->mSeqFrame,
|
2002-08-21 16:01:05 +04:00
|
|
|
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 = nsnull;
|
|
|
|
aURLStr = nsnull;
|
|
|
|
|
|
|
|
PRUnichar * docTitleStr;
|
|
|
|
PRUnichar * docURLStr;
|
2006-12-10 11:05:05 +03:00
|
|
|
nsPrintEngine::GetDisplayTitleAndURL(aPO,
|
2002-08-21 16:01:05 +04:00
|
|
|
&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,
|
2011-04-17 05:22:44 +04:00
|
|
|
nsDeviceContext * aDC,
|
2002-09-20 01:45:07 +04:00
|
|
|
int aLevel, FILE * aFD)
|
2002-08-21 16:01:05 +04:00
|
|
|
{
|
|
|
|
if (!kPrintingLogMod || kPrintingLogMod->level != DUMP_LAYOUT_LEVEL) return;
|
|
|
|
|
|
|
|
NS_ASSERTION(aPO, "Pointer is null!");
|
|
|
|
NS_ASSERTION(aDC, "Pointer is null!");
|
|
|
|
|
2004-02-03 01:42:29 +03:00
|
|
|
const char types[][3] = {"DC", "FR", "IF", "FS"};
|
2002-08-21 16:01:05 +04:00
|
|
|
FILE * fd = nsnull;
|
|
|
|
if (aLevel == 0) {
|
|
|
|
fd = fopen("tree_layout.txt", "w");
|
|
|
|
fprintf(fd, "DocTree\n***************************************************\n");
|
|
|
|
fprintf(fd, "***************************************************\n");
|
2005-01-04 01:51:17 +03:00
|
|
|
fprintf(fd, "T PO DocShell Seq Page Page# Rect\n");
|
2002-08-21 16:01:05 +04:00
|
|
|
} else {
|
|
|
|
fd = aFD;
|
|
|
|
}
|
|
|
|
if (fd) {
|
|
|
|
nsIFrame* rootFrame = nsnull;
|
|
|
|
if (aPO->mPresShell) {
|
2004-09-02 07:08:51 +04:00
|
|
|
rootFrame = aPO->mPresShell->FrameManager()->GetRootFrame();
|
2002-08-21 16:01:05 +04:00
|
|
|
}
|
|
|
|
for (PRInt32 k=0;k<aLevel;k++) fprintf(fd, " ");
|
2005-01-04 01:51:17 +03:00
|
|
|
fprintf(fd, "%s %p %p %p %p %d %d,%d,%d,%d\n", types[aPO->mFrameType], aPO, aPO->mDocShell.get(), aPO->mSeqFrame,
|
2002-08-21 16:01:05 +04:00
|
|
|
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);
|
2005-01-04 01:51:17 +03:00
|
|
|
DumpLayoutData(docStr, urlStr, aPO->mPresContext, aDC, rootFrame, aPO->mDocShell, fd);
|
2002-08-21 16:01:05 +04:00
|
|
|
if (docStr) nsMemory::Free(docStr);
|
|
|
|
if (urlStr) nsMemory::Free(urlStr);
|
|
|
|
}
|
|
|
|
fprintf(fd, "<***************************************************>\n");
|
|
|
|
|
2009-02-03 17:42:18 +03:00
|
|
|
PRInt32 cnt = aPO->mKids.Length();
|
2002-08-21 16:01:05 +04:00
|
|
|
for (PRInt32 i=0;i<cnt;i++) {
|
2009-02-03 17:42:18 +03:00
|
|
|
nsPrintObject* po = aPO->mKids.ElementAt(i);
|
2002-08-21 16:01:05 +04:00
|
|
|
NS_ASSERTION(po, "nsPrintObject can't be null!");
|
|
|
|
DumpPrintObjectsTreeLayout(po, aDC, aLevel+1, fd);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (aLevel == 0 && fd) {
|
|
|
|
fclose(fd);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
//-------------------------------------------------------------
|
2009-02-03 17:42:18 +03:00
|
|
|
static void DumpPrintObjectsListStart(const char * aStr, nsTArray<nsPrintObject*> * aDocList)
|
2002-08-21 16:01:05 +04:00
|
|
|
{
|
|
|
|
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);
|
2002-09-04 03:21:15 +04:00
|
|
|
|
2002-08-21 16:01:05 +04:00
|
|
|
#else
|
|
|
|
#define DUMP_DOC_LIST(_title)
|
|
|
|
#define DUMP_DOC_TREE
|
|
|
|
#define DUMP_DOC_TREELAYOUT
|
|
|
|
#endif
|
|
|
|
|
|
|
|
//---------------------------------------------------------------
|
|
|
|
//---------------------------------------------------------------
|
|
|
|
//-- End of debug helper routines
|
|
|
|
//---------------------------------------------------------------
|