2001-11-27 12:30:15 +03:00
|
|
|
/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
|
2001-09-25 05:32:19 +04:00
|
|
|
/* ***** BEGIN LICENSE BLOCK *****
|
|
|
|
* Version: NPL 1.1/GPL 2.0/LGPL 2.1
|
1999-05-06 23:25:40 +04:00
|
|
|
*
|
2001-09-25 05:32:19 +04:00
|
|
|
* The contents of this file are subject to the Netscape 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/NPL/
|
1999-05-06 23:25:40 +04:00
|
|
|
*
|
2001-09-25 05:32:19 +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.
|
1999-05-06 23:25:40 +04:00
|
|
|
*
|
|
|
|
* The Original Code is Mozilla Communicator client code.
|
|
|
|
*
|
2001-09-25 05:32:19 +04:00
|
|
|
* The Initial Developer of the Original Code is
|
|
|
|
* Netscape Communications Corporation.
|
|
|
|
* Portions created by the Initial Developer are Copyright (C) 1998
|
|
|
|
* the Initial Developer. All Rights Reserved.
|
1999-11-06 06:40:37 +03:00
|
|
|
*
|
2001-04-18 10:06:31 +04:00
|
|
|
* Contributor(s):
|
|
|
|
* Dan Rosen <dr@netscape.com>
|
2001-09-21 17:52:39 +04:00
|
|
|
* Roland Mainz <roland.mainz@informatik.med.uni-giessen.de>
|
2001-09-25 05:32:19 +04:00
|
|
|
*
|
|
|
|
*
|
|
|
|
* Alternatively, the contents of this file may be used under the terms of
|
|
|
|
* either 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"),
|
|
|
|
* 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
|
|
|
|
* use your version of this file under the terms of the NPL, indicate your
|
|
|
|
* 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
|
|
|
|
* the terms of any one of the NPL, the GPL or the LGPL.
|
|
|
|
*
|
|
|
|
* ***** END LICENSE BLOCK ***** */
|
2001-04-18 10:06:31 +04:00
|
|
|
|
2001-08-14 11:59:59 +04:00
|
|
|
#include "nscore.h"
|
1999-05-06 23:25:40 +04:00
|
|
|
#include "nsCOMPtr.h"
|
|
|
|
#include "nsCRT.h"
|
|
|
|
#include "nsString.h"
|
2001-09-29 12:28:41 +04:00
|
|
|
#include "nsReadableUtils.h"
|
1999-05-06 23:25:40 +04:00
|
|
|
#include "nsISupports.h"
|
1999-11-19 10:35:27 +03:00
|
|
|
#include "nsIContent.h"
|
|
|
|
#include "nsIContentViewerContainer.h"
|
1999-05-06 23:25:40 +04:00
|
|
|
#include "nsIDocumentViewer.h"
|
2000-09-01 05:54:35 +04:00
|
|
|
#include "nsIDOMWindowInternal.h"
|
1999-09-22 11:34:31 +04:00
|
|
|
|
1999-05-06 23:25:40 +04:00
|
|
|
#include "nsIDocument.h"
|
|
|
|
#include "nsIPresContext.h"
|
|
|
|
#include "nsIPresShell.h"
|
|
|
|
#include "nsIStyleSet.h"
|
|
|
|
#include "nsIStyleSheet.h"
|
2000-04-29 03:32:51 +04:00
|
|
|
#include "nsICSSStyleSheet.h"
|
1999-05-06 23:25:40 +04:00
|
|
|
#include "nsIFrame.h"
|
|
|
|
|
1999-12-03 12:24:22 +03:00
|
|
|
#include "nsIScriptGlobalObjectOwner.h"
|
1999-05-06 23:25:40 +04:00
|
|
|
#include "nsIScriptGlobalObject.h"
|
|
|
|
#include "nsILinkHandler.h"
|
|
|
|
#include "nsIDOMDocument.h"
|
2000-09-14 15:45:01 +04:00
|
|
|
#include "nsISelectionListener.h"
|
|
|
|
#include "nsISelectionPrivate.h"
|
2000-01-19 00:06:10 +03:00
|
|
|
#include "nsIDOMHTMLDocument.h"
|
2002-03-26 14:43:40 +03:00
|
|
|
#include "nsIDOMNSHTMLDocument.h"
|
|
|
|
#include "nsIDOMHTMLCollection.h"
|
2000-01-19 00:06:10 +03:00
|
|
|
#include "nsIDOMHTMLElement.h"
|
|
|
|
#include "nsIDOMRange.h"
|
2001-02-19 15:55:42 +03:00
|
|
|
#include "nsContentCID.h"
|
2000-01-19 00:06:10 +03:00
|
|
|
#include "nsLayoutCID.h"
|
2001-10-30 13:14:06 +03:00
|
|
|
#include "nsGenericHTMLElement.h"
|
1999-05-06 23:25:40 +04:00
|
|
|
|
|
|
|
#include "nsViewsCID.h"
|
|
|
|
#include "nsWidgetsCID.h"
|
|
|
|
#include "nsIDeviceContext.h"
|
|
|
|
#include "nsIDeviceContextSpec.h"
|
|
|
|
#include "nsIDeviceContextSpecFactory.h"
|
|
|
|
#include "nsIViewManager.h"
|
|
|
|
#include "nsIView.h"
|
|
|
|
|
|
|
|
#include "nsIPref.h"
|
|
|
|
#include "nsIPageSequenceFrame.h"
|
|
|
|
#include "nsIURL.h"
|
1999-05-14 18:40:59 +04:00
|
|
|
#include "nsIWebShell.h"
|
1999-11-19 10:35:27 +03:00
|
|
|
#include "nsIContentViewerEdit.h"
|
|
|
|
#include "nsIContentViewerFile.h"
|
|
|
|
#include "nsIMarkupDocumentViewer.h"
|
1999-11-13 10:36:28 +03:00
|
|
|
#include "nsIInterfaceRequestor.h"
|
2001-09-06 01:28:38 +04:00
|
|
|
#include "nsIInterfaceRequestorUtils.h"
|
1999-12-18 05:09:29 +03:00
|
|
|
#include "nsIDocShellTreeItem.h"
|
|
|
|
#include "nsIDocShellTreeNode.h"
|
2000-02-08 18:49:14 +03:00
|
|
|
#include "nsIDocShellTreeOwner.h"
|
1999-12-18 05:09:29 +03:00
|
|
|
#include "nsIDocShell.h"
|
2000-01-26 18:14:41 +03:00
|
|
|
#include "nsIFrameDebug.h"
|
2000-10-20 01:49:12 +04:00
|
|
|
#include "nsILayoutHistoryState.h"
|
2000-09-22 18:42:13 +04:00
|
|
|
#include "nsLayoutAtoms.h"
|
|
|
|
#include "nsIFrameManager.h"
|
2001-01-27 19:58:15 +03:00
|
|
|
#include "nsIParser.h"
|
2001-01-08 23:26:05 +03:00
|
|
|
#include "nsIPrintContext.h"
|
2001-07-16 06:40:48 +04:00
|
|
|
#include "nsGUIEvent.h"
|
|
|
|
#include "nsHTMLReflowState.h"
|
2001-04-18 10:06:31 +04:00
|
|
|
#include "nsIDOMHTMLAnchorElement.h"
|
2001-09-13 03:31:37 +04:00
|
|
|
#include "nsIDOMHTMLAreaElement.h"
|
|
|
|
#include "nsIDOMHTMLLinkElement.h"
|
2001-04-18 10:06:31 +04:00
|
|
|
#include "nsIDOMHTMLImageElement.h"
|
2000-10-29 02:17:53 +04:00
|
|
|
|
2000-04-29 03:32:51 +04:00
|
|
|
#include "nsIChromeRegistry.h"
|
1999-05-14 18:40:59 +04:00
|
|
|
|
1999-09-22 11:34:31 +04:00
|
|
|
#include "nsIEventQueueService.h"
|
|
|
|
#include "nsIEventQueue.h"
|
|
|
|
|
2001-03-27 15:56:03 +04:00
|
|
|
// Timer Includes
|
|
|
|
#include "nsITimer.h"
|
|
|
|
#include "nsITimerCallback.h"
|
2001-11-27 02:13:36 +03:00
|
|
|
#include "nsITimelineService.h"
|
2001-03-27 15:56:03 +04:00
|
|
|
|
2001-02-01 23:49:10 +03:00
|
|
|
#include "nsPIDOMWindow.h"
|
|
|
|
#include "nsIFocusController.h"
|
|
|
|
|
2001-01-27 17:09:34 +03:00
|
|
|
// Print Options
|
2002-01-01 15:58:53 +03:00
|
|
|
#include "nsIPrintSettings.h"
|
2001-01-27 17:09:34 +03:00
|
|
|
#include "nsIPrintOptions.h"
|
|
|
|
#include "nsGfxCIID.h"
|
|
|
|
#include "nsIServiceManager.h"
|
|
|
|
#include "nsHTMLAtoms.h" // XXX until atoms get factored into nsLayoutAtoms
|
2002-01-01 15:58:53 +03:00
|
|
|
#include "nsISimpleEnumerator.h"
|
|
|
|
#include "nsISupportsPrimitives.h"
|
|
|
|
static NS_DEFINE_CID(kPrintOptionsCID, NS_PRINTOPTIONS_CID);
|
2002-02-13 16:58:41 +03:00
|
|
|
static NS_DEFINE_IID(kPrinterEnumeratorCID, NS_PRINTER_ENUMERATOR_CID);
|
2001-01-27 17:09:34 +03:00
|
|
|
|
2001-03-27 15:56:03 +04:00
|
|
|
// Printing Events
|
|
|
|
#include "nsIEventQueue.h"
|
|
|
|
#include "nsIEventQueueService.h"
|
2002-03-23 21:07:51 +03:00
|
|
|
#include "nsPrintPreviewListener.h"
|
2001-03-27 15:56:03 +04:00
|
|
|
|
2001-04-12 17:04:29 +04:00
|
|
|
// Printing
|
2002-02-01 17:52:11 +03:00
|
|
|
#include "nsIWebBrowserPrint.h"
|
2001-04-12 17:04:29 +04:00
|
|
|
#include "nsIDOMHTMLFrameElement.h"
|
|
|
|
#include "nsIDOMHTMLFrameSetElement.h"
|
|
|
|
#include "nsIDOMHTMLIFrameElement.h"
|
2002-03-07 15:44:57 +03:00
|
|
|
#include "nsIDOMHTMLObjectElement.h"
|
2001-04-12 17:04:29 +04:00
|
|
|
|
2001-11-03 17:59:39 +03:00
|
|
|
// Print Preview
|
|
|
|
#include "nsIPrintPreviewContext.h"
|
2001-11-14 17:03:09 +03:00
|
|
|
#include "imgIContainer.h" // image animation mode constants
|
2002-02-01 17:52:11 +03:00
|
|
|
#include "nsIScrollableView.h"
|
|
|
|
#include "nsIWebBrowserPrint.h" // needed for PrintPreview Navigation constants
|
2001-11-03 17:59:39 +03:00
|
|
|
|
2002-01-01 15:58:53 +03:00
|
|
|
// Print Progress
|
|
|
|
#include "nsPrintProgress.h"
|
|
|
|
#include "nsPrintProgressParams.h"
|
|
|
|
|
|
|
|
|
2001-09-21 17:52:39 +04:00
|
|
|
// Print error dialog
|
|
|
|
#include "nsIPrompt.h"
|
|
|
|
#include "nsIWindowWatcher.h"
|
|
|
|
#include "nsIStringBundle.h"
|
|
|
|
|
|
|
|
#define NS_ERROR_GFX_PRINTER_BUNDLE_URL "chrome://communicator/locale/printing.properties"
|
|
|
|
|
2001-02-07 02:03:17 +03:00
|
|
|
// FrameSet
|
|
|
|
#include "nsINodeInfo.h"
|
|
|
|
#include "nsIDocument.h"
|
|
|
|
#include "nsHTMLAtoms.h"
|
|
|
|
#include "nsIHTMLContent.h"
|
|
|
|
#include "nsINameSpaceManager.h"
|
|
|
|
#include "nsIWebShell.h"
|
|
|
|
|
2000-04-22 01:40:28 +04:00
|
|
|
//focus
|
|
|
|
#include "nsIDOMEventReceiver.h"
|
|
|
|
#include "nsIDOMFocusListener.h"
|
2000-04-27 11:37:12 +04:00
|
|
|
#include "nsISelectionController.h"
|
2000-04-22 01:40:28 +04:00
|
|
|
|
2000-09-02 19:32:28 +04:00
|
|
|
#include "nsITransformMediator.h"
|
2000-04-22 01:40:28 +04:00
|
|
|
|
2001-04-13 03:35:24 +04:00
|
|
|
#ifdef IBMBIDI
|
2002-02-19 23:41:32 +03:00
|
|
|
#include "nsBidiUtils.h"
|
2001-04-13 03:35:24 +04:00
|
|
|
#endif
|
|
|
|
|
2001-02-19 15:55:42 +03:00
|
|
|
static NS_DEFINE_CID(kPresShellCID, NS_PRESSHELL_CID);
|
|
|
|
static NS_DEFINE_CID(kGalleyContextCID, NS_GALLEYCONTEXT_CID);
|
|
|
|
static NS_DEFINE_CID(kPrintContextCID, NS_PRINTCONTEXT_CID);
|
|
|
|
static NS_DEFINE_CID(kStyleSetCID, NS_STYLESET_CID);
|
1999-05-06 23:25:40 +04:00
|
|
|
|
|
|
|
#ifdef NS_DEBUG
|
2001-04-12 17:04:29 +04:00
|
|
|
|
1999-05-06 23:25:40 +04:00
|
|
|
#undef NOISY_VIEWER
|
|
|
|
#else
|
|
|
|
#undef NOISY_VIEWER
|
|
|
|
#endif
|
|
|
|
|
2001-04-12 17:04:29 +04:00
|
|
|
#if defined(DEBUG_rods) || defined(DEBUG_dcone)
|
|
|
|
#define DEBUG_PRINTING
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#ifdef DEBUG_PRINTING
|
|
|
|
// XXX NOTE: I am including a header from the layout directory
|
|
|
|
// merely to set up a file pointer for debug logging. This is
|
|
|
|
// fragile and may break in the future, which means it can be
|
|
|
|
// removed if necessary
|
|
|
|
#if defined(XP_PC)
|
|
|
|
#include "../../../layout/html/base/src/nsSimplePageSequence.h"
|
|
|
|
#endif
|
|
|
|
#define PRT_YESNO(_p) ((_p)?"YES":"NO")
|
|
|
|
|
2001-09-21 17:52:39 +04:00
|
|
|
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"};
|
2001-11-03 17:59:39 +03:00
|
|
|
static PRUint32 gDumpFileNameCnt = 0;
|
|
|
|
static PRUint32 gDumpLOFileNameCnt = 0;
|
2001-06-15 18:03:12 +04:00
|
|
|
|
2001-04-12 17:04:29 +04:00
|
|
|
#define PRINT_DEBUG_MSG1(_msg1) fprintf(mPrt->mDebugFD, (_msg1));
|
|
|
|
#define PRINT_DEBUG_MSG2(_msg1, _msg2) fprintf(mPrt->mDebugFD, (_msg1), (_msg2));
|
|
|
|
#define PRINT_DEBUG_MSG3(_msg1, _msg2, _msg3) fprintf(mPrt->mDebugFD, (_msg1), (_msg2), (_msg3));
|
|
|
|
#define PRINT_DEBUG_MSG4(_msg1, _msg2, _msg3, _msg4) fprintf(mPrt->mDebugFD, (_msg1), (_msg2), (_msg3), (_msg4));
|
|
|
|
#define PRINT_DEBUG_MSG5(_msg1, _msg2, _msg3, _msg4, _msg5) fprintf(mPrt->mDebugFD, (_msg1), (_msg2), (_msg3), (_msg4), (_msg5));
|
|
|
|
#define PRINT_DEBUG_FLUSH fflush(mPrt->mDebugFD);
|
|
|
|
#else //--------------
|
|
|
|
#define PRT_YESNO(_p)
|
|
|
|
#define PRINT_DEBUG_MSG1(_msg)
|
|
|
|
#define PRINT_DEBUG_MSG2(_msg1, _msg2)
|
|
|
|
#define PRINT_DEBUG_MSG3(_msg1, _msg2, _msg3)
|
|
|
|
#define PRINT_DEBUG_MSG4(_msg1, _msg2, _msg3, _msg4)
|
|
|
|
#define PRINT_DEBUG_MSG5(_msg1, _msg2, _msg3, _msg4, _msg5)
|
|
|
|
#define PRINT_DEBUG_FLUSH
|
2001-11-03 17:59:39 +03:00
|
|
|
|
2001-04-12 17:04:29 +04:00
|
|
|
#endif
|
|
|
|
|
|
|
|
enum PrintObjectType {eDoc = 0, eFrame = 1, eIFrame = 2, eFrameSet = 3};
|
2000-02-16 04:39:30 +03:00
|
|
|
|
|
|
|
class DocumentViewerImpl;
|
2001-03-27 15:56:03 +04:00
|
|
|
class nsPagePrintTimer;
|
2000-02-16 04:39:30 +03:00
|
|
|
|
2001-11-03 17:59:39 +03:00
|
|
|
// New PrintPreview
|
|
|
|
static NS_DEFINE_CID(kPrintPreviewContextCID, NS_PRINT_PREVIEW_CONTEXT_CID);
|
|
|
|
|
2000-02-16 04:39:30 +03:00
|
|
|
// a small delegate class used to avoid circular references
|
|
|
|
|
|
|
|
#ifdef XP_MAC
|
2001-04-18 10:06:31 +04:00
|
|
|
#pragma mark ** nsDocViewerSelectionListener **
|
2000-02-16 04:39:30 +03:00
|
|
|
#endif
|
|
|
|
|
2001-04-18 10:06:31 +04:00
|
|
|
class nsDocViewerSelectionListener : public nsISelectionListener
|
2000-02-16 04:39:30 +03:00
|
|
|
{
|
|
|
|
public:
|
|
|
|
|
|
|
|
// nsISupports interface...
|
|
|
|
NS_DECL_ISUPPORTS
|
|
|
|
|
2000-09-14 15:45:01 +04:00
|
|
|
// nsISelectionListerner interface
|
|
|
|
NS_DECL_NSISELECTIONLISTENER
|
2000-02-16 04:39:30 +03:00
|
|
|
|
2001-04-18 10:06:31 +04:00
|
|
|
nsDocViewerSelectionListener()
|
2000-02-16 04:39:30 +03:00
|
|
|
: mDocViewer(NULL)
|
|
|
|
, mGotSelectionState(PR_FALSE)
|
|
|
|
, mSelectionWasCollapsed(PR_FALSE)
|
|
|
|
{
|
|
|
|
NS_INIT_REFCNT();
|
|
|
|
}
|
|
|
|
|
2001-04-18 10:06:31 +04:00
|
|
|
virtual ~nsDocViewerSelectionListener() {}
|
2000-02-16 04:39:30 +03:00
|
|
|
|
|
|
|
nsresult Init(DocumentViewerImpl *aDocViewer);
|
|
|
|
|
|
|
|
protected:
|
|
|
|
|
|
|
|
DocumentViewerImpl* mDocViewer;
|
|
|
|
PRPackedBool mGotSelectionState;
|
|
|
|
PRPackedBool mSelectionWasCollapsed;
|
|
|
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
2000-04-22 01:40:28 +04:00
|
|
|
/** editor Implementation of the FocusListener interface
|
|
|
|
*/
|
|
|
|
class nsDocViewerFocusListener : public nsIDOMFocusListener
|
|
|
|
{
|
|
|
|
public:
|
|
|
|
/** default constructor
|
|
|
|
*/
|
|
|
|
nsDocViewerFocusListener();
|
|
|
|
/** default destructor
|
|
|
|
*/
|
|
|
|
virtual ~nsDocViewerFocusListener();
|
|
|
|
|
|
|
|
|
|
|
|
/*interfaces for addref and release and queryinterface*/
|
|
|
|
NS_DECL_ISUPPORTS
|
|
|
|
|
|
|
|
/*BEGIN implementations of focus event handler interface*/
|
Landing the XPCDOM_20010329_BRANCH branch, changes mostly done by jband@netscape.com and jst@netscape.com, also some changes done by shaver@mozilla.org, peterv@netscape.com and markh@activestate.com. r= and sr= by vidur@netscape.com, jband@netscape.com, jst@netscpae.com, danm@netscape.com, hyatt@netscape.com, shaver@mozilla.org, dbradley@netscape.com, rpotts@netscape.com.
2001-05-08 20:46:42 +04:00
|
|
|
NS_IMETHOD HandleEvent(nsIDOMEvent* aEvent);
|
|
|
|
NS_IMETHOD Focus(nsIDOMEvent* aEvent);
|
|
|
|
NS_IMETHOD Blur(nsIDOMEvent* aEvent);
|
2000-04-22 01:40:28 +04:00
|
|
|
/*END implementations of focus event handler interface*/
|
|
|
|
nsresult Init(DocumentViewerImpl *aDocViewer);
|
|
|
|
|
|
|
|
private:
|
|
|
|
DocumentViewerImpl* mDocViewer;
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
2000-02-16 04:39:30 +03:00
|
|
|
#ifdef XP_MAC
|
|
|
|
#pragma mark ** DocumentViewerImpl **
|
|
|
|
#endif
|
|
|
|
|
2002-03-26 14:43:40 +03:00
|
|
|
//---------------------------------------------------
|
|
|
|
//-- Object for Caching the Presentation
|
|
|
|
//---------------------------------------------------
|
|
|
|
class CachedPresentationObj
|
|
|
|
{
|
|
|
|
public:
|
|
|
|
CachedPresentationObj(nsIPresShell* aShell, nsIPresContext* aPC, nsIViewManager* aVM, nsIWidget* aW):
|
|
|
|
mPresShell(aShell), mPresContext(aPC), mViewManager(aVM), mWindow(aW) {}
|
|
|
|
|
|
|
|
|
|
|
|
nsCOMPtr<nsIPresContext> mPresContext;
|
|
|
|
nsCOMPtr<nsIPresShell> mPresShell;
|
|
|
|
nsCOMPtr<nsIViewManager> mViewManager;
|
|
|
|
nsCOMPtr<nsIWidget> mWindow;
|
|
|
|
};
|
|
|
|
|
2001-04-12 17:04:29 +04:00
|
|
|
//---------------------------------------------------
|
|
|
|
//-- PrintObject Class
|
|
|
|
//---------------------------------------------------
|
|
|
|
struct PrintObject
|
|
|
|
{
|
|
|
|
|
|
|
|
public:
|
|
|
|
PrintObject();
|
2001-08-01 07:15:50 +04:00
|
|
|
~PrintObject(); // non-virtual
|
2001-04-12 17:04:29 +04:00
|
|
|
|
|
|
|
// Methods
|
|
|
|
PRBool IsPrintable() { return !mDontPrint; }
|
2002-02-19 14:49:27 +03:00
|
|
|
void DestroyPresentation();
|
2001-04-12 17:04:29 +04:00
|
|
|
|
2002-02-19 14:49:27 +03:00
|
|
|
// Data Members
|
2001-11-03 17:59:39 +03:00
|
|
|
nsCOMPtr<nsIWebShell> mWebShell;
|
2001-04-12 17:04:29 +04:00
|
|
|
PrintObjectType mFrameType;
|
2001-08-01 07:15:50 +04:00
|
|
|
nsCOMPtr<nsIPresContext> mPresContext;
|
2001-11-03 17:59:39 +03:00
|
|
|
nsCOMPtr<nsIStyleSet> mStyleSet;
|
|
|
|
nsCOMPtr<nsIPresShell> mPresShell;
|
2001-08-01 07:15:50 +04:00
|
|
|
nsCOMPtr<nsIViewManager> mViewManager;
|
2001-11-03 17:59:39 +03:00
|
|
|
nsCOMPtr<nsIWidget> mWindow;
|
2001-04-12 17:04:29 +04:00
|
|
|
nsIView *mRootView;
|
|
|
|
|
|
|
|
nsIContent *mContent;
|
|
|
|
nsIFrame *mSeqFrame;
|
|
|
|
nsIFrame *mPageFrame;
|
|
|
|
PRInt32 mPageNum;
|
|
|
|
nsRect mRect;
|
|
|
|
nsRect mReflowRect;
|
|
|
|
|
|
|
|
nsVoidArray mKids;
|
|
|
|
PrintObject* mParent;
|
|
|
|
PRPackedBool mHasBeenPrinted;
|
|
|
|
PRPackedBool mDontPrint;
|
|
|
|
PRPackedBool mPrintAsIs;
|
|
|
|
PRPackedBool mSkippedPageEject;
|
2001-11-03 17:59:39 +03:00
|
|
|
PRPackedBool mSharedPresShell;
|
2001-04-12 17:04:29 +04:00
|
|
|
|
|
|
|
nsRect mClipRect;
|
|
|
|
|
2001-11-14 17:03:09 +03:00
|
|
|
PRUint16 mImgAnimationMode;
|
2002-02-12 16:33:39 +03:00
|
|
|
PRUnichar* mDocTitle;
|
|
|
|
PRUnichar* mDocURL;
|
2002-02-19 14:49:27 +03:00
|
|
|
float mShrinkRatio;
|
|
|
|
nscoord mXMost;
|
2001-11-14 14:24:03 +03:00
|
|
|
|
2001-08-01 07:15:50 +04:00
|
|
|
private:
|
|
|
|
PrintObject& operator=(const PrintObject& aOther); // not implemented
|
|
|
|
|
2001-04-12 17:04:29 +04:00
|
|
|
};
|
|
|
|
|
2002-03-23 19:48:58 +03:00
|
|
|
//------------------------------------------------------------------------
|
|
|
|
// PrintData Class
|
|
|
|
//
|
|
|
|
// mPreparingForPrint - indicates that we have started Printing but
|
|
|
|
// have not gone to the timer to start printing the pages. It gets turned
|
|
|
|
// off right before we go to the timer.
|
|
|
|
//
|
|
|
|
// mDocWasToBeDestroyed - Gets set when "someone" tries to unload the document
|
|
|
|
// while we were prparing to Print. This typically happens if a user starts
|
|
|
|
// to print while a page is still loading. If they start printing and pause
|
|
|
|
// at the print dialog and then the page comes in, we then abort printing
|
|
|
|
// because the document is no longer stable.
|
|
|
|
//
|
|
|
|
//------------------------------------------------------------------------
|
2001-11-03 17:59:39 +03:00
|
|
|
class PrintData {
|
2001-04-12 17:04:29 +04:00
|
|
|
public:
|
|
|
|
|
|
|
|
PrintData();
|
2001-08-01 07:15:50 +04:00
|
|
|
~PrintData(); // non-virtual
|
2001-04-12 17:04:29 +04:00
|
|
|
|
|
|
|
// Listener Helper Methods
|
2002-02-21 16:23:11 +03:00
|
|
|
void OnEndPrinting();
|
2001-04-12 17:04:29 +04:00
|
|
|
void OnStartPrinting();
|
2002-01-01 15:58:53 +03:00
|
|
|
static void DoOnProgressChange(nsVoidArray& aListeners,
|
|
|
|
PRInt32 aProgess,
|
|
|
|
PRInt32 aMaxProgress,
|
|
|
|
PRBool aDoStartStop = PR_FALSE,
|
|
|
|
PRInt32 aFlag = 0);
|
2001-04-12 17:04:29 +04:00
|
|
|
|
2001-08-01 07:15:50 +04:00
|
|
|
nsCOMPtr<nsIDeviceContext> mPrintDC;
|
2001-04-12 17:04:29 +04:00
|
|
|
nsIView *mPrintView;
|
2002-01-01 15:58:53 +03:00
|
|
|
FILE *mDebugFilePtr; // a file where information can go to when printing
|
2001-04-12 17:04:29 +04:00
|
|
|
|
|
|
|
PrintObject * mPrintObject;
|
|
|
|
PrintObject * mSelectedPO;
|
|
|
|
|
2002-01-01 15:58:53 +03:00
|
|
|
nsVoidArray mPrintProgressListeners;
|
|
|
|
nsCOMPtr<nsIWebProgressListener> mPrintProgressListener;
|
|
|
|
nsCOMPtr<nsIPrintProgress> mPrintProgress;
|
|
|
|
nsCOMPtr<nsIPrintProgressParams> mPrintProgressParams;
|
|
|
|
PRBool mShowProgressDialog;
|
|
|
|
|
2001-05-31 05:06:33 +04:00
|
|
|
nsCOMPtr<nsIDOMWindowInternal> mCurrentFocusWin; // cache a pointer to the currently focused window
|
2001-04-12 17:04:29 +04:00
|
|
|
|
|
|
|
nsVoidArray* mPrintDocList;
|
|
|
|
nsCOMPtr<nsIDeviceContext> mPrintDocDC;
|
|
|
|
nsCOMPtr<nsIDOMWindow> mPrintDocDW;
|
|
|
|
PRPackedBool mIsIFrameSelected;
|
|
|
|
PRPackedBool mIsParentAFrameSet;
|
|
|
|
PRPackedBool mPrintingAsIsSubDoc;
|
|
|
|
PRPackedBool mOnStartSent;
|
2002-03-23 19:48:58 +03:00
|
|
|
PRPackedBool mIsAborted; // tells us the document is being aborted
|
|
|
|
PRPackedBool mPreparingForPrint; // see comments above
|
|
|
|
PRPackedBool mDocWasToBeDestroyed; // see comments above
|
2002-02-19 14:49:27 +03:00
|
|
|
PRBool mShrinkToFit;
|
|
|
|
PRInt16 mPrintFrameType;
|
2001-04-12 17:04:29 +04:00
|
|
|
PRInt32 mNumPrintableDocs;
|
|
|
|
PRInt32 mNumDocsPrinted;
|
|
|
|
PRInt32 mNumPrintablePages;
|
|
|
|
PRInt32 mNumPagesPrinted;
|
2002-02-19 14:49:27 +03:00
|
|
|
float mShrinkRatio;
|
|
|
|
float mOrigDCScale;
|
2001-04-12 17:04:29 +04:00
|
|
|
|
2002-01-01 15:58:53 +03:00
|
|
|
nsCOMPtr<nsIPrintSettings> mPrintSettings;
|
2002-01-12 15:31:05 +03:00
|
|
|
nsCOMPtr<nsIPrintOptions> mPrintOptions;
|
2002-03-23 21:07:51 +03:00
|
|
|
nsPrintPreviewListener* mPPEventListeners;
|
2002-01-01 15:58:53 +03:00
|
|
|
|
2002-03-26 14:43:40 +03:00
|
|
|
// CachedPresentationObj is used to cache the presentation
|
|
|
|
// so we can bring it back later
|
|
|
|
PRBool HasCachedPres() { return mIsCachingPresentation && mCachedPresObj; }
|
|
|
|
PRBool IsCachingPres() { return mIsCachingPresentation; }
|
|
|
|
void SetCacheOldPres(PRBool aDoCache) { mIsCachingPresentation = aDoCache; }
|
|
|
|
|
|
|
|
PRBool mIsCachingPresentation;
|
|
|
|
CachedPresentationObj* mCachedPresObj;
|
|
|
|
|
2002-03-27 06:02:42 +03:00
|
|
|
PRUnichar* mBrandName; // needed as a substitute name for a document
|
2002-03-26 14:43:40 +03:00
|
|
|
|
2001-04-12 17:04:29 +04:00
|
|
|
#ifdef DEBUG_PRINTING
|
|
|
|
FILE * mDebugFD;
|
|
|
|
#endif
|
|
|
|
|
2001-08-01 07:15:50 +04:00
|
|
|
private:
|
|
|
|
PrintData& operator=(const PrintData& aOther); // not implemented
|
|
|
|
|
2001-04-12 17:04:29 +04:00
|
|
|
};
|
2001-02-01 23:49:10 +03:00
|
|
|
|
2001-04-12 17:04:29 +04:00
|
|
|
//-------------------------------------------------------------
|
1999-09-22 11:34:31 +04:00
|
|
|
class DocumentViewerImpl : public nsIDocumentViewer,
|
1999-11-19 10:35:27 +03:00
|
|
|
public nsIContentViewerEdit,
|
|
|
|
public nsIContentViewerFile,
|
2002-02-01 17:52:11 +03:00
|
|
|
public nsIMarkupDocumentViewer,
|
|
|
|
public nsIWebBrowserPrint
|
1999-05-06 23:25:40 +04:00
|
|
|
{
|
2001-04-18 10:06:31 +04:00
|
|
|
friend class nsDocViewerSelectionListener;
|
2001-11-03 17:59:39 +03:00
|
|
|
friend class nsPagePrintTimer;
|
|
|
|
friend class PrintData;
|
2000-02-16 04:39:30 +03:00
|
|
|
|
1999-05-06 23:25:40 +04:00
|
|
|
public:
|
|
|
|
DocumentViewerImpl();
|
|
|
|
DocumentViewerImpl(nsIPresContext* aPresContext);
|
|
|
|
|
|
|
|
NS_DECL_AND_IMPL_ZEROING_OPERATOR_NEW
|
|
|
|
|
|
|
|
// nsISupports interface...
|
|
|
|
NS_DECL_ISUPPORTS
|
|
|
|
|
|
|
|
// nsIContentViewer interface...
|
2001-08-01 07:15:50 +04:00
|
|
|
NS_DECL_NSICONTENTVIEWER
|
1999-05-06 23:25:40 +04:00
|
|
|
|
|
|
|
// nsIDocumentViewer interface...
|
|
|
|
NS_IMETHOD SetUAStyleSheet(nsIStyleSheet* aUAStyleSheet);
|
|
|
|
NS_IMETHOD GetDocument(nsIDocument*& aResult);
|
|
|
|
NS_IMETHOD GetPresShell(nsIPresShell*& aResult);
|
|
|
|
NS_IMETHOD GetPresContext(nsIPresContext*& aResult);
|
|
|
|
NS_IMETHOD CreateDocumentViewerUsing(nsIPresContext* aPresContext,
|
|
|
|
nsIDocumentViewer*& aResult);
|
2000-09-02 19:32:28 +04:00
|
|
|
NS_IMETHOD SetTransformMediator(nsITransformMediator* aMediator);
|
1999-05-06 23:25:40 +04:00
|
|
|
|
1999-11-19 10:35:27 +03:00
|
|
|
// nsIContentViewerEdit
|
|
|
|
NS_DECL_NSICONTENTVIEWEREDIT
|
|
|
|
|
|
|
|
// nsIContentViewerFile
|
|
|
|
NS_DECL_NSICONTENTVIEWERFILE
|
|
|
|
|
|
|
|
// nsIMarkupDocumentViewer
|
|
|
|
NS_DECL_NSIMARKUPDOCUMENTVIEWER
|
|
|
|
|
2002-02-01 17:52:11 +03:00
|
|
|
// nsIWebBrowserPrint
|
|
|
|
NS_DECL_NSIWEBBROWSERPRINT
|
|
|
|
|
2000-04-03 01:52:17 +04:00
|
|
|
typedef void (*CallChildFunc)(nsIMarkupDocumentViewer* aViewer,
|
|
|
|
void* aClosure);
|
|
|
|
nsresult CallChildren(CallChildFunc aFunc, void* aClosure);
|
|
|
|
|
2001-03-27 15:56:03 +04:00
|
|
|
// Printing Methods
|
2002-02-12 16:33:39 +03:00
|
|
|
PRBool PrintPage(nsIPresContext* aPresContext,nsIPrintSettings* aPrintSettings,PrintObject* aPOect, PRBool& aInRange);
|
2001-04-12 17:04:29 +04:00
|
|
|
PRBool DonePrintingPages(PrintObject* aPO);
|
2000-01-19 00:06:10 +03:00
|
|
|
|
2001-11-03 17:59:39 +03:00
|
|
|
// helper method
|
2002-02-12 16:33:39 +03:00
|
|
|
static void GetWebShellTitleAndURL(nsIWebShell * aWebShell, PRUnichar** aTitle, PRUnichar** aURLStr);
|
|
|
|
|
|
|
|
// This enum tells indicates what the default should be for the title
|
|
|
|
// if the title from the document is null
|
|
|
|
enum eDocTitleDefault {eDocTitleDefNone, eDocTitleDefBlank, eDocTitleDefDocument, eDocTitleDefURLDoc};
|
|
|
|
static void GetDisplayTitleAndURL(PrintObject* aPO,
|
|
|
|
nsIPrintSettings* aPrintSettings,
|
2002-03-27 06:02:42 +03:00
|
|
|
const PRUnichar* aBrandName,
|
2002-02-12 16:33:39 +03:00
|
|
|
PRUnichar** aTitle,
|
|
|
|
PRUnichar** aURLStr,
|
|
|
|
eDocTitleDefault aDefType = eDocTitleDefNone);
|
2001-11-03 17:59:39 +03:00
|
|
|
|
1999-05-06 23:25:40 +04:00
|
|
|
protected:
|
|
|
|
virtual ~DocumentViewerImpl();
|
|
|
|
|
|
|
|
private:
|
|
|
|
void ForceRefresh(void);
|
|
|
|
nsresult CreateStyleSet(nsIDocument* aDocument, nsIStyleSet** aStyleSet);
|
2000-03-11 04:24:59 +03:00
|
|
|
nsresult MakeWindow(nsIWidget* aParentWidget,
|
|
|
|
const nsRect& aBounds);
|
2002-03-26 14:43:40 +03:00
|
|
|
nsresult InitInternal(nsIWidget* aParentWidget,
|
|
|
|
nsIDeviceContext* aDeviceContext,
|
|
|
|
const nsRect& aBounds,
|
|
|
|
PRBool aDoCreation);
|
2001-02-07 02:03:17 +03:00
|
|
|
nsresult GetDocumentSelection(nsISelection **aSelection, nsIPresShell * aPresShell = nsnull);
|
2000-09-22 18:42:13 +04:00
|
|
|
nsresult FindFrameSetWithIID(nsIContent * aParentContent, const nsIID& aIID);
|
2001-04-12 17:04:29 +04:00
|
|
|
PRBool IsThereARangeSelection(nsIDOMWindowInternal * aDOMWin);
|
|
|
|
PRBool IsParentAFrameSet(nsIWebShell * aParent);
|
|
|
|
PRBool IsWebShellAFrameSet(nsIWebShell * aParent);
|
|
|
|
|
2001-02-07 02:03:17 +03:00
|
|
|
PRBool IsThereAnIFrameSelected(nsIWebShell* aWebShell,
|
|
|
|
nsIDOMWindowInternal * aDOMWin,
|
2001-04-12 17:04:29 +04:00
|
|
|
PRPackedBool& aDoesContainFrameset);
|
2001-02-07 02:03:17 +03:00
|
|
|
PRBool IsWindowsInOurSubTree(nsIDOMWindowInternal * aDOMWindow);
|
2001-04-12 17:04:29 +04:00
|
|
|
|
2001-04-18 10:06:31 +04:00
|
|
|
|
|
|
|
nsresult GetPopupNode(nsIDOMNode** aNode);
|
|
|
|
nsresult GetPopupLinkNode(nsIDOMNode** aNode);
|
|
|
|
nsresult GetPopupImageNode(nsIDOMNode** aNode);
|
|
|
|
|
2001-04-12 17:04:29 +04:00
|
|
|
//---------------------------------------------------------------------
|
|
|
|
void BuildDocTree(nsIDocShellTreeNode * aParentNode,
|
|
|
|
nsVoidArray * aDocList,
|
|
|
|
PrintObject * aPO);
|
2002-02-19 14:49:27 +03:00
|
|
|
nsresult ReflowDocList(PrintObject * aPO, PRBool aSetPixelScale, PRBool aDoCalcShrink);
|
2001-04-12 17:04:29 +04:00
|
|
|
void SetClipRect(PrintObject* aPO,
|
|
|
|
const nsRect& aClipRect,
|
|
|
|
nscoord aOffsetX,
|
|
|
|
nscoord aOffsetY,
|
|
|
|
PRBool aDoingSetClip);
|
|
|
|
|
2002-02-19 14:49:27 +03:00
|
|
|
nsresult ReflowPrintObject(PrintObject * aPO, PRBool aDoCalcShrink);
|
2002-01-12 15:31:05 +03:00
|
|
|
nsresult CalcPageFrameLocation(nsIPresShell * aPresShell,
|
2001-04-12 17:04:29 +04:00
|
|
|
PrintObject* aPO);
|
|
|
|
PrintObject * FindPrintObjectByWS(PrintObject* aPO, nsIWebShell * aWebShell);
|
|
|
|
void MapContentForPO(PrintObject* aRootObject,
|
|
|
|
nsIPresShell* aPresShell,
|
|
|
|
nsIContent* aContent);
|
|
|
|
void MapContentToWebShells(PrintObject* aRootPO, PrintObject* aPO);
|
2002-01-12 15:31:05 +03:00
|
|
|
nsresult MapSubDocFrameLocations(PrintObject* aPO);
|
2001-04-12 17:04:29 +04:00
|
|
|
PrintObject* FindPrintObjectByDOMWin(PrintObject* aParentObject, nsIDOMWindowInternal * aDOMWin);
|
|
|
|
void GetPresShellAndRootContent(nsIWebShell * aWebShell, nsIPresShell** aPresShell, nsIContent** aContent);
|
|
|
|
|
|
|
|
void CalcNumPrintableDocsAndPages(PRInt32& aNumDocs, PRInt32& aNumPages);
|
|
|
|
void DoProgressForAsIsFrames();
|
|
|
|
void DoProgressForSeparateFrames();
|
2002-01-01 15:58:53 +03:00
|
|
|
void DoPrintProgress(PRBool aIsForPrinting);
|
2002-02-12 16:33:39 +03:00
|
|
|
void SetDocAndURLIntoProgress(PrintObject* aPO, nsIPrintProgressParams* aParams);
|
2002-01-01 15:58:53 +03:00
|
|
|
nsresult CheckForPrinters(nsIPrintOptions* aPrintOptions,
|
|
|
|
nsIPrintSettings* aPrintSettings,
|
|
|
|
PRUint32 aErrorCode,
|
|
|
|
PRBool aIsPrinting);
|
2002-02-01 17:52:11 +03:00
|
|
|
void CleanupDocTitleArray(PRUnichar**& aArray, PRInt32& aCount);
|
2001-02-07 02:03:17 +03:00
|
|
|
|
|
|
|
// get the currently infocus frame for the document viewer
|
|
|
|
nsIDOMWindowInternal * FindFocusedDOMWindowInternal();
|
2001-04-12 17:04:29 +04:00
|
|
|
|
|
|
|
// get the DOMWindow for a given WebShell
|
|
|
|
nsIDOMWindowInternal * GetDOMWinForWebShell(nsIWebShell* aWebShell);
|
2000-01-19 00:06:10 +03:00
|
|
|
|
1999-09-22 11:34:31 +04:00
|
|
|
//
|
|
|
|
// The following three methods are used for printing...
|
|
|
|
//
|
2001-03-27 15:56:03 +04:00
|
|
|
nsresult DocumentReadyForPrinting();
|
2001-01-27 17:09:34 +03:00
|
|
|
//nsresult PrintSelection(nsIDeviceContextSpec * aDevSpec);
|
|
|
|
nsresult GetSelectionDocument(nsIDeviceContextSpec * aDevSpec, nsIDocument ** aNewDoc);
|
1999-09-22 11:34:31 +04:00
|
|
|
|
|
|
|
static void PR_CALLBACK HandlePLEvent(PLEvent* aEvent);
|
|
|
|
static void PR_CALLBACK DestroyPLEvent(PLEvent* aEvent);
|
|
|
|
|
2001-04-12 17:04:29 +04:00
|
|
|
nsresult SetupToPrintContent(nsIWebShell* aParent,
|
|
|
|
nsIDeviceContext* aDContext,
|
|
|
|
nsIDOMWindowInternal* aCurrentFocusedDOMWin);
|
|
|
|
nsresult EnablePOsForPrinting();
|
2002-02-19 14:49:27 +03:00
|
|
|
PrintObject* FindXMostPO();
|
|
|
|
void FindXMostFrameSize(nsIPresContext* aPresContext, nsIRenderingContext* aRC, nsIFrame* aFrame, nscoord aX, nscoord aY, PRInt32& aMaxWidth);
|
|
|
|
void FindXMostFrameInList(nsIPresContext* aPresContext, nsIRenderingContext* aRC, nsIAtom* aList, nsIFrame* aFrame,
|
|
|
|
nscoord aX, nscoord aY, PRInt32& aMaxWidth);
|
2001-04-12 17:04:29 +04:00
|
|
|
|
|
|
|
PRBool PrintDocContent(PrintObject* aPO, nsresult& aStatus);
|
|
|
|
nsresult DoPrint(PrintObject * aPO, PRBool aDoSyncPrinting, PRBool& aDonePrinting);
|
|
|
|
void SetPrintAsIs(PrintObject* aPO, PRBool aAsIs = PR_TRUE);
|
|
|
|
void SetPrintPO(PrintObject* aPO, PRBool aPrint);
|
2001-03-27 15:56:03 +04:00
|
|
|
|
2001-11-03 17:59:39 +03:00
|
|
|
#ifdef NS_PRINT_PREVIEW
|
|
|
|
nsresult ShowDocList(PrintObject* aPO, PRBool aShow);
|
|
|
|
void InstallNewPresentation();
|
2001-11-14 14:24:03 +03:00
|
|
|
void ReturnToGalleyPresentation();
|
2001-11-03 17:59:39 +03:00
|
|
|
void TurnScriptingOn(PRBool aDoTurnOn);
|
2002-03-26 14:43:40 +03:00
|
|
|
PRBool CheckDocumentForPPCaching();
|
2002-03-23 21:07:51 +03:00
|
|
|
void InstallPrintPreviewListener();
|
2001-11-03 17:59:39 +03:00
|
|
|
#endif
|
|
|
|
|
2001-03-27 15:56:03 +04:00
|
|
|
|
|
|
|
// Timer Methods
|
|
|
|
nsresult StartPagePrintTimer(nsIPresContext * aPresContext,
|
2002-01-01 15:58:53 +03:00
|
|
|
nsIPrintSettings* aPrintSettings,
|
|
|
|
PrintObject* aPO,
|
2001-03-27 15:56:03 +04:00
|
|
|
PRUint32 aDelay);
|
|
|
|
|
2001-05-25 12:49:03 +04:00
|
|
|
void PrepareToStartLoad(void);
|
2001-09-21 17:52:39 +04:00
|
|
|
|
|
|
|
// Misc
|
2002-01-08 04:17:40 +03:00
|
|
|
static void ShowPrintErrorDialog(nsresult printerror, PRBool aIsPrinting = PR_TRUE);
|
2001-05-25 12:49:03 +04:00
|
|
|
|
1999-05-06 23:25:40 +04:00
|
|
|
protected:
|
|
|
|
// IMPORTANT: The ownership implicit in the following member
|
|
|
|
// variables has been explicitly checked and set using nsCOMPtr
|
|
|
|
// for owning pointers and raw COM interface pointers for weak
|
|
|
|
// (ie, non owning) references. If you add any members to this
|
|
|
|
// class, please make the ownership explicit (pinkerton, scc).
|
|
|
|
|
1999-11-13 10:36:28 +03:00
|
|
|
nsISupports* mContainer; // [WEAK] it owns me!
|
1999-05-06 23:25:40 +04:00
|
|
|
nsCOMPtr<nsIDeviceContext> mDeviceContext; // ??? can't hurt, but...
|
|
|
|
nsIView* mView; // [WEAK] cleaned up by view mgr
|
|
|
|
|
2000-09-17 00:53:08 +04:00
|
|
|
// the following seven items are explicitly in this order
|
1999-05-06 23:25:40 +04:00
|
|
|
// so they will be destroyed in the reverse order (pinkerton, scc)
|
2000-09-02 19:32:28 +04:00
|
|
|
nsCOMPtr<nsITransformMediator> mTransformMediator;
|
1999-05-06 23:25:40 +04:00
|
|
|
nsCOMPtr<nsIDocument> mDocument;
|
|
|
|
nsCOMPtr<nsIWidget> mWindow; // ??? should we really own it?
|
|
|
|
nsCOMPtr<nsIViewManager> mViewManager;
|
|
|
|
nsCOMPtr<nsIPresContext> mPresContext;
|
|
|
|
nsCOMPtr<nsIPresShell> mPresShell;
|
|
|
|
|
|
|
|
nsCOMPtr<nsIStyleSheet> mUAStyleSheet;
|
1999-05-07 23:26:23 +04:00
|
|
|
|
2000-09-14 15:45:01 +04:00
|
|
|
nsCOMPtr<nsISelectionListener> mSelectionListener;
|
2000-04-22 01:40:28 +04:00
|
|
|
nsCOMPtr<nsIDOMFocusListener> mFocusListener;
|
2000-02-16 04:39:30 +03:00
|
|
|
|
2001-05-02 02:50:16 +04:00
|
|
|
nsCOMPtr<nsIContentViewer> mPreviousViewer;
|
|
|
|
|
2000-01-26 18:14:41 +03:00
|
|
|
PRBool mEnableRendering;
|
2001-04-25 23:52:49 +04:00
|
|
|
PRBool mStopped;
|
2001-05-02 02:50:16 +04:00
|
|
|
PRBool mLoaded;
|
1999-07-15 18:23:40 +04:00
|
|
|
PRInt16 mNumURLStarts;
|
2001-08-06 06:27:43 +04:00
|
|
|
PRInt16 mDestroyRefCount; // a second "refcount" for the document viewer's "destroy"
|
2001-03-27 15:56:03 +04:00
|
|
|
nsIPageSequenceFrame* mPageSeqFrame;
|
1999-07-15 18:23:40 +04:00
|
|
|
|
|
|
|
|
2001-04-12 17:04:29 +04:00
|
|
|
PRBool mIsPrinting;
|
|
|
|
PrintData* mPrt;
|
|
|
|
nsPagePrintTimer* mPagePrintTimer;
|
2001-11-03 17:59:39 +03:00
|
|
|
|
|
|
|
#ifdef NS_PRINT_PREVIEW
|
2001-11-14 14:24:03 +03:00
|
|
|
PRBool mIsDoingPrintPreview; // per DocumentViewer
|
|
|
|
nsIWidget* mParentWidget; // purposely won't be ref counted
|
2001-11-03 17:59:39 +03:00
|
|
|
PrintData* mPrtPreview;
|
2002-02-01 17:52:11 +03:00
|
|
|
PrintData* mOldPrtPreview;
|
2001-11-03 17:59:39 +03:00
|
|
|
#endif
|
|
|
|
|
2002-01-01 15:58:53 +03:00
|
|
|
#ifdef NS_DEBUG
|
|
|
|
FILE* mDebugFile;
|
|
|
|
#endif
|
|
|
|
|
2001-11-03 17:59:39 +03:00
|
|
|
// static memeber variables
|
2001-11-14 14:24:03 +03:00
|
|
|
static PRBool mIsCreatingPrintPreview;
|
2001-11-03 17:59:39 +03:00
|
|
|
static PRBool mIsDoingPrinting;
|
2001-03-27 15:56:03 +04:00
|
|
|
|
1999-11-19 10:35:27 +03:00
|
|
|
// document management data
|
|
|
|
// these items are specific to markup documents (html and xml)
|
|
|
|
// may consider splitting these out into a subclass
|
|
|
|
PRBool mAllowPlugins;
|
|
|
|
/* character set member data */
|
|
|
|
nsString mDefaultCharacterSet;
|
|
|
|
nsString mHintCharset;
|
2001-12-26 06:17:59 +03:00
|
|
|
PRInt32 mHintCharsetSource;
|
1999-11-19 10:35:27 +03:00
|
|
|
nsString mForceCharacterSet;
|
1999-05-06 23:25:40 +04:00
|
|
|
};
|
|
|
|
|
2001-03-27 15:56:03 +04:00
|
|
|
//---------------------------------------------------
|
2001-04-12 17:04:29 +04:00
|
|
|
//-- Page Timer Class
|
2001-03-27 15:56:03 +04:00
|
|
|
//---------------------------------------------------
|
|
|
|
class nsPagePrintTimer : public nsITimerCallback
|
|
|
|
{
|
|
|
|
public:
|
|
|
|
|
|
|
|
NS_DECL_ISUPPORTS
|
|
|
|
|
|
|
|
nsPagePrintTimer()
|
2002-01-01 15:58:53 +03:00
|
|
|
: mDocViewer(nsnull), mPresContext(nsnull), mPrintSettings(nsnull), mDelay(0)
|
2001-03-27 15:56:03 +04:00
|
|
|
{
|
|
|
|
NS_INIT_ISUPPORTS();
|
|
|
|
}
|
|
|
|
|
|
|
|
virtual ~nsPagePrintTimer()
|
|
|
|
{
|
|
|
|
if (mTimer) {
|
|
|
|
mTimer->Cancel();
|
|
|
|
}
|
2001-11-03 17:59:39 +03:00
|
|
|
DocumentViewerImpl::mIsDoingPrinting = PR_FALSE;
|
2001-08-06 06:27:43 +04:00
|
|
|
mDocViewer->Destroy();
|
|
|
|
NS_RELEASE(mDocViewer);
|
2001-03-27 15:56:03 +04:00
|
|
|
}
|
|
|
|
|
2001-04-11 18:06:39 +04:00
|
|
|
|
2002-02-12 16:33:39 +03:00
|
|
|
nsresult StartTimer(PRBool aUseDelay = PR_TRUE)
|
2001-04-11 18:06:39 +04:00
|
|
|
{
|
2001-04-12 17:04:29 +04:00
|
|
|
nsresult result;
|
2001-04-11 18:06:39 +04:00
|
|
|
mTimer = do_CreateInstance("@mozilla.org/timer;1", &result);
|
2001-04-12 17:04:29 +04:00
|
|
|
if (NS_FAILED(result)) {
|
2001-04-11 18:06:39 +04:00
|
|
|
NS_WARNING("unable to start the timer");
|
|
|
|
} else {
|
2002-02-12 16:33:39 +03:00
|
|
|
mTimer->Init(this, aUseDelay?mDelay:0, NS_PRIORITY_NORMAL, NS_TYPE_ONE_SHOT);
|
2001-04-11 18:06:39 +04:00
|
|
|
}
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
2001-03-27 15:56:03 +04:00
|
|
|
// nsITimerCallback
|
|
|
|
NS_IMETHOD_(void) Notify(nsITimer *timer)
|
|
|
|
{
|
|
|
|
if (mPresContext && mDocViewer) {
|
2001-04-13 16:32:18 +04:00
|
|
|
PRPackedBool initNewTimer = PR_TRUE;
|
2001-03-27 15:56:03 +04:00
|
|
|
// Check to see if we are done
|
|
|
|
// donePrinting will be true if it completed successfully or
|
|
|
|
// if the printing was cancelled
|
2002-02-12 16:33:39 +03:00
|
|
|
PRBool inRange;
|
|
|
|
PRBool donePrinting = mDocViewer->PrintPage(mPresContext, mPrintSettings, mPrintObj, inRange);
|
2001-03-27 15:56:03 +04:00
|
|
|
if (donePrinting) {
|
|
|
|
// now clean up print or print the next webshell
|
2001-04-12 17:04:29 +04:00
|
|
|
if (mDocViewer->DonePrintingPages(mPrintObj)) {
|
2001-04-13 17:44:16 +04:00
|
|
|
initNewTimer = PR_FALSE;
|
2001-03-27 15:56:03 +04:00
|
|
|
}
|
2001-04-13 16:32:18 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
Stop();
|
|
|
|
if (initNewTimer) {
|
2002-02-12 16:33:39 +03:00
|
|
|
nsresult result = StartTimer(inRange);
|
2001-04-12 17:04:29 +04:00
|
|
|
if (NS_FAILED(result)) {
|
2001-04-11 18:06:39 +04:00
|
|
|
donePrinting = PR_TRUE; // had a failure.. we are finished..
|
2001-11-03 17:59:39 +03:00
|
|
|
DocumentViewerImpl::mIsDoingPrinting = PR_FALSE;
|
2001-04-11 18:06:39 +04:00
|
|
|
}
|
2001-03-27 15:56:03 +04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void Init(DocumentViewerImpl* aDocViewerImpl,
|
|
|
|
nsIPresContext* aPresContext,
|
2002-01-01 15:58:53 +03:00
|
|
|
nsIPrintSettings* aPrintSettings,
|
2001-04-12 17:04:29 +04:00
|
|
|
PrintObject* aPO,
|
2001-03-27 15:56:03 +04:00
|
|
|
PRUint32 aDelay)
|
|
|
|
{
|
2001-08-06 06:27:43 +04:00
|
|
|
NS_IF_RELEASE(mDocViewer);
|
2001-03-27 15:56:03 +04:00
|
|
|
mDocViewer = aDocViewerImpl;
|
2001-08-06 06:27:43 +04:00
|
|
|
NS_ADDREF(mDocViewer);
|
|
|
|
|
2001-03-27 15:56:03 +04:00
|
|
|
mPresContext = aPresContext;
|
2002-01-01 15:58:53 +03:00
|
|
|
mPrintSettings = aPrintSettings;
|
2001-04-12 17:04:29 +04:00
|
|
|
mPrintObj = aPO;
|
2001-03-27 15:56:03 +04:00
|
|
|
mDelay = aDelay;
|
|
|
|
}
|
|
|
|
|
|
|
|
nsresult Start(DocumentViewerImpl* aDocViewerImpl,
|
|
|
|
nsIPresContext* aPresContext,
|
2002-01-01 15:58:53 +03:00
|
|
|
nsIPrintSettings* aPrintSettings,
|
2001-04-12 17:04:29 +04:00
|
|
|
PrintObject* aPO,
|
2001-03-27 15:56:03 +04:00
|
|
|
PRUint32 aDelay)
|
|
|
|
{
|
2002-01-01 15:58:53 +03:00
|
|
|
Init(aDocViewerImpl, aPresContext, aPrintSettings, aPO, aDelay);
|
2002-02-12 16:33:39 +03:00
|
|
|
return StartTimer(PR_FALSE);
|
2001-03-27 15:56:03 +04:00
|
|
|
}
|
|
|
|
|
2001-08-06 06:27:43 +04:00
|
|
|
|
|
|
|
void Stop()
|
|
|
|
{
|
|
|
|
if (mTimer) {
|
|
|
|
mTimer->Cancel();
|
|
|
|
mTimer = nsnull;
|
|
|
|
}
|
|
|
|
}
|
2001-03-27 15:56:03 +04:00
|
|
|
|
|
|
|
private:
|
2002-01-01 15:58:53 +03:00
|
|
|
DocumentViewerImpl* mDocViewer;
|
|
|
|
nsIPresContext* mPresContext;
|
|
|
|
nsCOMPtr<nsIPrintSettings> mPrintSettings;
|
|
|
|
nsCOMPtr<nsITimer> mTimer;
|
|
|
|
PRUint32 mDelay;
|
|
|
|
PrintObject * mPrintObj;
|
2001-03-27 15:56:03 +04:00
|
|
|
};
|
|
|
|
|
2001-08-01 07:15:50 +04:00
|
|
|
NS_IMPL_ISUPPORTS1(nsPagePrintTimer, nsITimerCallback)
|
2001-03-27 15:56:03 +04:00
|
|
|
|
2001-08-06 06:27:43 +04:00
|
|
|
static nsresult NS_NewUpdateTimer(nsPagePrintTimer **aResult)
|
2001-03-27 15:56:03 +04:00
|
|
|
{
|
|
|
|
|
2001-08-06 06:27:43 +04:00
|
|
|
NS_PRECONDITION(aResult, "null param");
|
|
|
|
|
|
|
|
nsPagePrintTimer* result = new nsPagePrintTimer;
|
2001-03-27 15:56:03 +04:00
|
|
|
|
2001-08-06 06:27:43 +04:00
|
|
|
if (!result) {
|
|
|
|
*aResult = nsnull;
|
2001-03-27 15:56:03 +04:00
|
|
|
return NS_ERROR_OUT_OF_MEMORY;
|
2001-08-06 06:27:43 +04:00
|
|
|
}
|
2001-03-27 15:56:03 +04:00
|
|
|
|
2001-08-06 06:27:43 +04:00
|
|
|
NS_ADDREF(result);
|
|
|
|
*aResult = result;
|
2001-03-27 15:56:03 +04:00
|
|
|
|
|
|
|
return NS_OK;
|
|
|
|
}
|
2001-04-12 17:04:29 +04:00
|
|
|
|
2001-03-27 15:56:03 +04:00
|
|
|
//---------------------------------------------------
|
2001-04-12 17:04:29 +04:00
|
|
|
//-- PrintData Class Impl
|
2001-03-27 15:56:03 +04:00
|
|
|
//---------------------------------------------------
|
2001-04-12 17:04:29 +04:00
|
|
|
PrintData::PrintData() :
|
2002-01-01 15:58:53 +03:00
|
|
|
mPrintView(nsnull), mDebugFilePtr(nsnull), mPrintObject(nsnull), mSelectedPO(nsnull),
|
|
|
|
mShowProgressDialog(PR_TRUE), mPrintDocList(nsnull), mIsIFrameSelected(PR_FALSE),
|
2002-02-19 14:49:27 +03:00
|
|
|
mIsParentAFrameSet(PR_FALSE), mPrintingAsIsSubDoc(PR_FALSE), mOnStartSent(PR_FALSE),
|
2002-03-23 19:48:58 +03:00
|
|
|
mIsAborted(PR_FALSE), mPreparingForPrint(PR_FALSE), mDocWasToBeDestroyed(PR_FALSE),
|
|
|
|
mShrinkToFit(PR_FALSE), mPrintFrameType(nsIPrintSettings::kFramesAsIs),
|
2002-02-12 16:33:39 +03:00
|
|
|
mNumPrintableDocs(0), mNumDocsPrinted(0), mNumPrintablePages(0), mNumPagesPrinted(0),
|
2002-03-26 14:43:40 +03:00
|
|
|
mShrinkRatio(1.0), mOrigDCScale(1.0), mPPEventListeners(NULL),
|
2002-03-27 06:02:42 +03:00
|
|
|
mIsCachingPresentation(PR_FALSE), mCachedPresObj(nsnull), mBrandName(nsnull)
|
2001-04-12 17:04:29 +04:00
|
|
|
{
|
|
|
|
#ifdef DEBUG_PRINTING
|
|
|
|
mDebugFD = fopen("printing.log", "w");
|
|
|
|
#endif
|
2002-03-27 06:02:42 +03:00
|
|
|
|
|
|
|
nsCOMPtr<nsIStringBundle> brandBundle;
|
|
|
|
nsCOMPtr<nsIStringBundleService> svc( do_GetService( NS_STRINGBUNDLE_CONTRACTID ) );
|
|
|
|
if (svc) {
|
|
|
|
svc->CreateBundle( "chrome://global/locale/brand.properties", getter_AddRefs( brandBundle ) );
|
|
|
|
if (brandBundle) {
|
|
|
|
brandBundle->GetStringFromName(NS_LITERAL_STRING("brandShortName").get(), &mBrandName );
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!mBrandName) {
|
|
|
|
mBrandName = ToNewUnicode(NS_LITERAL_STRING("Mozilla Document"));
|
|
|
|
}
|
|
|
|
|
2001-04-12 17:04:29 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
PrintData::~PrintData()
|
|
|
|
{
|
2002-03-26 14:43:40 +03:00
|
|
|
// removed any cached
|
|
|
|
if (mCachedPresObj) {
|
|
|
|
delete mCachedPresObj;
|
|
|
|
}
|
|
|
|
|
2002-03-23 21:07:51 +03:00
|
|
|
// remove the event listeners
|
|
|
|
if (mPPEventListeners) {
|
|
|
|
mPPEventListeners->RemoveListeners();
|
|
|
|
NS_RELEASE(mPPEventListeners);
|
|
|
|
}
|
|
|
|
|
2002-02-21 16:23:11 +03:00
|
|
|
// Only Send an OnEndPrinting if we have started printing
|
|
|
|
if (mOnStartSent) {
|
|
|
|
OnEndPrinting();
|
|
|
|
}
|
2001-04-12 17:04:29 +04:00
|
|
|
|
2002-02-13 23:01:42 +03:00
|
|
|
if (mPrintDC && !mDebugFilePtr) {
|
2001-04-12 17:04:29 +04:00
|
|
|
#ifdef DEBUG_PRINTING
|
|
|
|
fprintf(mDebugFD, "****************** End Document ************************\n");
|
|
|
|
#endif
|
2002-02-12 16:33:39 +03:00
|
|
|
PRBool isCancelled = PR_FALSE;
|
|
|
|
mPrintSettings->GetIsCancelled(&isCancelled);
|
|
|
|
|
|
|
|
nsresult rv = NS_OK;
|
|
|
|
if (!isCancelled && !mIsAborted) {
|
|
|
|
rv = mPrintDC->EndDocument();
|
|
|
|
} else {
|
|
|
|
rv = mPrintDC->AbortDocument();
|
|
|
|
}
|
2002-01-08 04:17:40 +03:00
|
|
|
if (NS_FAILED(rv)) {
|
2002-02-12 16:33:39 +03:00
|
|
|
DocumentViewerImpl::ShowPrintErrorDialog(rv);
|
2002-01-08 04:17:40 +03:00
|
|
|
}
|
2001-04-12 17:04:29 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
delete mPrintObject;
|
|
|
|
|
2002-01-01 15:58:53 +03:00
|
|
|
if (mPrintDocList != nsnull) {
|
|
|
|
mPrintDocList->Clear();
|
|
|
|
delete mPrintDocList;
|
|
|
|
}
|
2001-04-12 17:04:29 +04:00
|
|
|
|
2002-03-27 06:02:42 +03:00
|
|
|
if (mBrandName) {
|
|
|
|
nsCRT::free(mBrandName);
|
|
|
|
}
|
|
|
|
|
2001-04-12 17:04:29 +04:00
|
|
|
#ifdef DEBUG_PRINTING
|
|
|
|
fclose(mDebugFD);
|
|
|
|
#endif
|
2001-08-18 02:16:17 +04:00
|
|
|
|
2001-11-03 17:59:39 +03:00
|
|
|
DocumentViewerImpl::mIsDoingPrinting = PR_FALSE;
|
2002-01-01 15:58:53 +03:00
|
|
|
|
|
|
|
for (PRInt32 i=0;i<mPrintProgressListeners.Count();i++) {
|
|
|
|
nsIWebProgressListener* wpl = NS_STATIC_CAST(nsIWebProgressListener*, mPrintProgressListeners.ElementAt(i));
|
|
|
|
NS_ASSERTION(wpl, "nsIWebProgressListener is NULL!");
|
|
|
|
NS_RELEASE(wpl);
|
|
|
|
}
|
|
|
|
|
2001-04-12 17:04:29 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
void PrintData::OnStartPrinting()
|
|
|
|
{
|
2002-01-01 15:58:53 +03:00
|
|
|
if (!mOnStartSent) {
|
|
|
|
DoOnProgressChange(mPrintProgressListeners, 100, 100, PR_TRUE, nsIWebProgressListener::STATE_START|nsIWebProgressListener::STATE_IS_DOCUMENT);
|
2001-04-12 17:04:29 +04:00
|
|
|
mOnStartSent = PR_TRUE;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2002-02-21 16:23:11 +03:00
|
|
|
void PrintData::OnEndPrinting()
|
2001-04-12 17:04:29 +04:00
|
|
|
{
|
2002-01-01 15:58:53 +03:00
|
|
|
DoOnProgressChange(mPrintProgressListeners, 100, 100, PR_TRUE, nsIWebProgressListener::STATE_STOP|nsIWebProgressListener::STATE_IS_DOCUMENT);
|
|
|
|
if (mPrintProgress && mShowProgressDialog) {
|
|
|
|
mPrintProgress->CloseProgressDialog(PR_TRUE);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
PrintData::DoOnProgressChange(nsVoidArray& aListeners,
|
|
|
|
PRInt32 aProgess,
|
|
|
|
PRInt32 aMaxProgress,
|
|
|
|
PRBool aDoStartStop,
|
|
|
|
PRInt32 aFlag)
|
|
|
|
{
|
2002-02-12 16:33:39 +03:00
|
|
|
if (aProgess == 0) return;
|
|
|
|
|
2002-01-01 15:58:53 +03:00
|
|
|
for (PRInt32 i=0;i<aListeners.Count();i++) {
|
|
|
|
nsIWebProgressListener* wpl = NS_STATIC_CAST(nsIWebProgressListener*, aListeners.ElementAt(i));
|
|
|
|
NS_ASSERTION(wpl, "nsIWebProgressListener is NULL!");
|
|
|
|
wpl->OnProgressChange(nsnull, nsnull, aProgess, aMaxProgress, aProgess, aMaxProgress);
|
|
|
|
if (aDoStartStop) {
|
|
|
|
wpl->OnStateChange(nsnull, nsnull, aFlag, 0);
|
2001-04-12 17:04:29 +04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2001-03-27 15:56:03 +04:00
|
|
|
|
|
|
|
|
2001-04-12 17:04:29 +04:00
|
|
|
//---------------------------------------------------
|
|
|
|
//-- PrintObject Class Impl
|
|
|
|
//---------------------------------------------------
|
|
|
|
PrintObject::PrintObject() :
|
2002-02-19 14:49:27 +03:00
|
|
|
mFrameType(eFrame),
|
|
|
|
mRootView(nsnull), mContent(nsnull),
|
2001-04-12 17:04:29 +04:00
|
|
|
mSeqFrame(nsnull), mPageFrame(nsnull), mPageNum(-1),
|
|
|
|
mRect(0,0,0,0), mReflowRect(0,0,0,0),
|
|
|
|
mParent(nsnull), mHasBeenPrinted(PR_FALSE), mDontPrint(PR_TRUE),
|
2001-11-03 17:59:39 +03:00
|
|
|
mPrintAsIs(PR_FALSE), mSkippedPageEject(PR_FALSE), mSharedPresShell(PR_FALSE),
|
2001-11-14 14:24:03 +03:00
|
|
|
mClipRect(-1,-1, -1, -1),
|
2002-02-12 16:33:39 +03:00
|
|
|
mImgAnimationMode(imgIContainer::kNormalAnimMode),
|
2002-02-19 14:49:27 +03:00
|
|
|
mDocTitle(nsnull), mDocURL(nsnull), mShrinkRatio(1.0), mXMost(0)
|
2001-04-12 17:04:29 +04:00
|
|
|
{
|
|
|
|
}
|
2001-03-27 15:56:03 +04:00
|
|
|
|
2001-04-12 17:04:29 +04:00
|
|
|
PrintObject::~PrintObject()
|
|
|
|
{
|
2001-11-14 14:24:03 +03:00
|
|
|
if (mPresContext) {
|
|
|
|
mPresContext->SetImageAnimationMode(mImgAnimationMode);
|
|
|
|
}
|
|
|
|
|
2001-04-12 17:04:29 +04:00
|
|
|
for (PRInt32 i=0;i<mKids.Count();i++) {
|
|
|
|
PrintObject* po = (PrintObject*)mKids[i];
|
|
|
|
NS_ASSERTION(po, "PrintObject can't be null!");
|
|
|
|
delete po;
|
|
|
|
}
|
2002-02-12 16:33:39 +03:00
|
|
|
|
|
|
|
if (mPresShell && !mSharedPresShell) {
|
2001-08-01 07:15:50 +04:00
|
|
|
mPresShell->Destroy();
|
2002-02-12 16:33:39 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
if (mDocTitle) nsMemory::Free(mDocTitle);
|
|
|
|
if (mDocURL) nsMemory::Free(mDocURL);
|
|
|
|
|
2001-04-12 17:04:29 +04:00
|
|
|
}
|
2001-03-27 15:56:03 +04:00
|
|
|
|
2002-02-19 14:49:27 +03:00
|
|
|
//------------------------------------------------------------------
|
|
|
|
// Resets PO by destroying the presentation
|
|
|
|
void PrintObject::DestroyPresentation()
|
|
|
|
{
|
|
|
|
mWindow = nsnull;
|
|
|
|
mPresContext = nsnull;
|
|
|
|
mPresShell->Destroy();
|
|
|
|
mPresShell = nsnull;
|
|
|
|
mViewManager = nsnull;
|
|
|
|
mStyleSet = nsnull;
|
|
|
|
}
|
|
|
|
|
2001-04-12 17:04:29 +04:00
|
|
|
//------------------------------------------------------------------
|
|
|
|
// DocumentViewerImpl
|
|
|
|
//------------------------------------------------------------------
|
1999-05-07 23:26:23 +04:00
|
|
|
// Class IDs
|
1999-07-15 11:00:22 +04:00
|
|
|
static NS_DEFINE_CID(kViewManagerCID, NS_VIEW_MANAGER_CID);
|
|
|
|
static NS_DEFINE_CID(kWidgetCID, NS_CHILD_CID);
|
|
|
|
static NS_DEFINE_CID(kViewCID, NS_VIEW_CID);
|
1999-05-06 23:25:40 +04:00
|
|
|
|
2001-11-03 17:59:39 +03:00
|
|
|
// Data members
|
2001-11-14 14:24:03 +03:00
|
|
|
PRBool DocumentViewerImpl::mIsCreatingPrintPreview = PR_FALSE;
|
|
|
|
PRBool DocumentViewerImpl::mIsDoingPrinting = PR_FALSE;
|
2001-11-03 17:59:39 +03:00
|
|
|
|
2002-02-01 17:52:11 +03:00
|
|
|
//------------------------------------------------------------------
|
1999-05-06 23:25:40 +04:00
|
|
|
nsresult
|
|
|
|
NS_NewDocumentViewer(nsIDocumentViewer** aResult)
|
|
|
|
{
|
|
|
|
NS_PRECONDITION(aResult, "null OUT ptr");
|
|
|
|
if (!aResult) {
|
|
|
|
return NS_ERROR_NULL_POINTER;
|
|
|
|
}
|
|
|
|
DocumentViewerImpl* it = new DocumentViewerImpl();
|
|
|
|
if (nsnull == it) {
|
|
|
|
*aResult = nsnull;
|
|
|
|
return NS_ERROR_OUT_OF_MEMORY;
|
|
|
|
}
|
2001-08-01 07:15:50 +04:00
|
|
|
return CallQueryInterface(it, aResult);
|
1999-05-06 23:25:40 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
// Note: operator new zeros our memory
|
|
|
|
DocumentViewerImpl::DocumentViewerImpl()
|
|
|
|
{
|
2001-03-10 06:19:36 +03:00
|
|
|
NS_INIT_ISUPPORTS();
|
2001-05-25 12:49:03 +04:00
|
|
|
PrepareToStartLoad();
|
2001-11-14 14:24:03 +03:00
|
|
|
|
|
|
|
#ifdef NS_PRINT_PREVIEW
|
2001-11-03 17:59:39 +03:00
|
|
|
mParentWidget = nsnull;
|
2001-11-14 14:24:03 +03:00
|
|
|
#endif
|
2001-05-25 12:49:03 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
void DocumentViewerImpl::PrepareToStartLoad() {
|
2001-03-27 15:56:03 +04:00
|
|
|
mEnableRendering = PR_TRUE;
|
2001-04-25 23:52:49 +04:00
|
|
|
mStopped = PR_FALSE;
|
2001-05-02 02:50:16 +04:00
|
|
|
mLoaded = PR_FALSE;
|
2001-04-12 17:04:29 +04:00
|
|
|
mPrt = nsnull;
|
|
|
|
mIsPrinting = PR_FALSE;
|
2001-11-03 17:59:39 +03:00
|
|
|
|
|
|
|
#ifdef NS_PRINT_PREVIEW
|
2001-11-14 14:24:03 +03:00
|
|
|
mIsDoingPrintPreview = PR_FALSE;
|
|
|
|
mPrtPreview = nsnull;
|
2002-02-19 14:49:27 +03:00
|
|
|
mOldPrtPreview = nsnull;
|
2001-11-03 17:59:39 +03:00
|
|
|
#endif
|
2002-01-01 15:58:53 +03:00
|
|
|
|
|
|
|
#ifdef NS_DEBUG
|
|
|
|
mDebugFile = nsnull;
|
|
|
|
#endif
|
1999-05-06 23:25:40 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
DocumentViewerImpl::DocumentViewerImpl(nsIPresContext* aPresContext)
|
2001-08-01 07:15:50 +04:00
|
|
|
: mPresContext(aPresContext)
|
1999-05-06 23:25:40 +04:00
|
|
|
{
|
2001-03-10 06:19:36 +03:00
|
|
|
NS_INIT_ISUPPORTS();
|
1999-11-19 10:35:27 +03:00
|
|
|
mHintCharsetSource = kCharsetUninitialized;
|
2001-03-27 15:56:03 +04:00
|
|
|
mAllowPlugins = PR_TRUE;
|
2001-05-25 12:49:03 +04:00
|
|
|
PrepareToStartLoad();
|
1999-05-06 23:25:40 +04:00
|
|
|
}
|
|
|
|
|
2002-02-01 17:52:11 +03:00
|
|
|
NS_IMPL_ISUPPORTS6(DocumentViewerImpl,
|
2001-03-10 06:19:36 +03:00
|
|
|
nsIContentViewer,
|
|
|
|
nsIDocumentViewer,
|
|
|
|
nsIMarkupDocumentViewer,
|
|
|
|
nsIContentViewerFile,
|
2002-02-01 17:52:11 +03:00
|
|
|
nsIContentViewerEdit,
|
|
|
|
nsIWebBrowserPrint)
|
1999-05-06 23:25:40 +04:00
|
|
|
|
|
|
|
DocumentViewerImpl::~DocumentViewerImpl()
|
|
|
|
{
|
2001-08-01 07:15:50 +04:00
|
|
|
NS_ASSERTION(!mDocument, "User did not call nsIContentViewer::Close");
|
2001-07-27 00:53:21 +04:00
|
|
|
if (mDocument)
|
2001-08-01 07:15:50 +04:00
|
|
|
Close();
|
|
|
|
|
|
|
|
NS_ASSERTION(!mPresShell, "User did not call nsIContentViewer::Destroy");
|
|
|
|
if (mPresShell)
|
2001-07-27 00:53:21 +04:00
|
|
|
Destroy();
|
1999-05-06 23:25:40 +04:00
|
|
|
|
2001-08-01 07:15:50 +04:00
|
|
|
// XXX(?) Revoke pending invalidate events
|
|
|
|
|
2001-03-10 06:19:36 +03:00
|
|
|
// clear weak references before we go away
|
2000-02-03 02:40:22 +03:00
|
|
|
if (mPresContext) {
|
|
|
|
mPresContext->SetContainer(nsnull);
|
|
|
|
mPresContext->SetLinkHandler(nsnull);
|
|
|
|
}
|
1999-05-06 23:25:40 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* This method is called by the Document Loader once a document has
|
|
|
|
* been created for a particular data stream... The content viewer
|
|
|
|
* must cache this document for later use when Init(...) is called.
|
2001-05-25 12:49:03 +04:00
|
|
|
*
|
|
|
|
* This method is also called when an out of band document.write() happens.
|
|
|
|
* In that case, the document passed in is the same as the previous document.
|
1999-05-06 23:25:40 +04:00
|
|
|
*/
|
|
|
|
NS_IMETHODIMP
|
2001-05-25 12:49:03 +04:00
|
|
|
DocumentViewerImpl::LoadStart(nsISupports *aDoc)
|
1999-05-06 23:25:40 +04:00
|
|
|
{
|
|
|
|
#ifdef NOISY_VIEWER
|
2001-05-25 12:49:03 +04:00
|
|
|
printf("DocumentViewerImpl::LoadStart\n");
|
1999-05-06 23:25:40 +04:00
|
|
|
#endif
|
|
|
|
|
|
|
|
nsresult rv;
|
2001-05-25 12:49:03 +04:00
|
|
|
if (!mDocument) {
|
|
|
|
mDocument = do_QueryInterface(aDoc,&rv);
|
|
|
|
}
|
|
|
|
else if (mDocument == aDoc) {
|
|
|
|
// Reset the document viewer's state back to what it was
|
|
|
|
// when the document load started.
|
|
|
|
PrepareToStartLoad();
|
|
|
|
}
|
|
|
|
|
1999-05-06 23:25:40 +04:00
|
|
|
return rv;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
1999-11-14 13:12:21 +03:00
|
|
|
DocumentViewerImpl::SetContainer(nsISupports* aContainer)
|
1999-05-06 23:25:40 +04:00
|
|
|
{
|
|
|
|
mContainer = aContainer;
|
|
|
|
if (mPresContext) {
|
|
|
|
mPresContext->SetContainer(aContainer);
|
|
|
|
}
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
1999-11-14 13:12:21 +03:00
|
|
|
DocumentViewerImpl::GetContainer(nsISupports** aResult)
|
1999-05-06 23:25:40 +04:00
|
|
|
{
|
1999-11-14 13:12:21 +03:00
|
|
|
NS_ENSURE_ARG_POINTER(aResult);
|
|
|
|
|
|
|
|
*aResult = mContainer;
|
|
|
|
NS_IF_ADDREF(*aResult);
|
|
|
|
|
1999-11-13 10:36:28 +03:00
|
|
|
return NS_OK;
|
1999-05-06 23:25:40 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
2000-03-11 04:24:59 +03:00
|
|
|
DocumentViewerImpl::Init(nsIWidget* aParentWidget,
|
1999-05-06 23:25:40 +04:00
|
|
|
nsIDeviceContext* aDeviceContext,
|
2000-03-11 04:24:59 +03:00
|
|
|
const nsRect& aBounds)
|
2002-03-26 14:43:40 +03:00
|
|
|
{
|
|
|
|
return InitInternal(aParentWidget, aDeviceContext, aBounds, PR_TRUE);
|
|
|
|
}
|
|
|
|
|
|
|
|
//-----------------------------------------------
|
|
|
|
// This method can be used to initial the "presentation"
|
|
|
|
// The aDoCreation indicates whether it should create
|
|
|
|
// all the new objects or just initialize the existing ones
|
|
|
|
nsresult
|
|
|
|
DocumentViewerImpl::InitInternal(nsIWidget* aParentWidget,
|
|
|
|
nsIDeviceContext* aDeviceContext,
|
|
|
|
const nsRect& aBounds,
|
|
|
|
PRBool aDoCreation)
|
1999-05-06 23:25:40 +04:00
|
|
|
{
|
2002-02-20 00:33:26 +03:00
|
|
|
NS_ASSERTION(aParentWidget != nsnull, "Null aParentWidget");
|
|
|
|
|
2001-11-14 14:24:03 +03:00
|
|
|
#ifdef NS_PRINT_PREVIEW
|
|
|
|
mParentWidget = aParentWidget; // not ref counted
|
|
|
|
#endif
|
2001-11-03 17:59:39 +03:00
|
|
|
|
1999-05-06 23:25:40 +04:00
|
|
|
nsresult rv;
|
2001-03-10 06:19:36 +03:00
|
|
|
NS_ENSURE_TRUE(mDocument, NS_ERROR_NULL_POINTER);
|
1999-05-06 23:25:40 +04:00
|
|
|
|
|
|
|
mDeviceContext = dont_QueryInterface(aDeviceContext);
|
2001-11-03 17:59:39 +03:00
|
|
|
#ifdef NS_PRINT_PREVIEW
|
|
|
|
// Clear PrintPreview Alternate Device
|
|
|
|
if (mDeviceContext) {
|
|
|
|
mDeviceContext->SetAltDevice(nsnull);
|
2001-11-29 12:59:16 +03:00
|
|
|
mDeviceContext->SetCanonicalPixelScale(1.0);
|
2001-11-03 17:59:39 +03:00
|
|
|
}
|
|
|
|
#endif
|
1999-05-06 23:25:40 +04:00
|
|
|
|
|
|
|
PRBool makeCX = PR_FALSE;
|
2002-03-26 14:43:40 +03:00
|
|
|
if (aDoCreation) {
|
|
|
|
if (!mPresContext) {
|
|
|
|
// Create presentation context
|
|
|
|
if (mIsCreatingPrintPreview) {
|
|
|
|
mPresContext = do_CreateInstance(kPrintPreviewContextCID,&rv);
|
|
|
|
} else {
|
|
|
|
mPresContext = do_CreateInstance(kGalleyContextCID,&rv);
|
|
|
|
}
|
|
|
|
if (NS_FAILED(rv)) return rv;
|
1999-05-06 23:25:40 +04:00
|
|
|
|
2002-03-26 14:43:40 +03:00
|
|
|
mPresContext->Init(aDeviceContext);
|
2001-11-14 14:24:03 +03:00
|
|
|
#ifdef NS_PRINT_PREVIEW
|
2002-03-26 14:43:40 +03:00
|
|
|
makeCX = !mIsDoingPrintPreview; // needs to be true except when we are already in PP
|
2001-11-14 14:24:03 +03:00
|
|
|
#else
|
2002-03-26 14:43:40 +03:00
|
|
|
makeCX = PR_TRUE;
|
2001-11-14 14:24:03 +03:00
|
|
|
#endif
|
2002-03-26 14:43:40 +03:00
|
|
|
}
|
1999-05-06 23:25:40 +04:00
|
|
|
}
|
|
|
|
|
1999-11-13 10:36:28 +03:00
|
|
|
nsCOMPtr<nsIInterfaceRequestor> requestor(do_QueryInterface(mContainer));
|
|
|
|
if (requestor) {
|
|
|
|
nsCOMPtr<nsILinkHandler> linkHandler;
|
|
|
|
requestor->GetInterface(NS_GET_IID(nsILinkHandler),
|
|
|
|
getter_AddRefs(linkHandler));
|
1999-05-06 23:25:40 +04:00
|
|
|
mPresContext->SetContainer(mContainer);
|
|
|
|
mPresContext->SetLinkHandler(linkHandler);
|
|
|
|
|
2001-11-27 12:30:15 +03:00
|
|
|
if (!mIsDoingPrintPreview) {
|
|
|
|
// Set script-context-owner in the document
|
|
|
|
nsCOMPtr<nsIScriptGlobalObjectOwner> owner;
|
|
|
|
requestor->GetInterface(NS_GET_IID(nsIScriptGlobalObjectOwner),
|
|
|
|
getter_AddRefs(owner));
|
|
|
|
|
|
|
|
if (owner) {
|
|
|
|
nsCOMPtr<nsIScriptGlobalObject> global;
|
|
|
|
owner->GetScriptGlobalObject(getter_AddRefs(global));
|
|
|
|
|
|
|
|
if (global) {
|
|
|
|
mDocument->SetScriptGlobalObject(global);
|
|
|
|
nsCOMPtr<nsIDOMDocument> domdoc(do_QueryInterface(mDocument));
|
|
|
|
|
|
|
|
if (domdoc) {
|
|
|
|
global->SetNewDocument(domdoc, PR_TRUE);
|
|
|
|
}
|
1999-05-06 23:25:40 +04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2002-03-26 14:43:40 +03:00
|
|
|
if (aDoCreation) {
|
|
|
|
// Create the ViewManager and Root View...
|
|
|
|
rv = MakeWindow(aParentWidget, aBounds);
|
|
|
|
Hide();
|
2001-05-02 02:50:16 +04:00
|
|
|
|
2002-03-26 14:43:40 +03:00
|
|
|
if (NS_FAILED(rv)) return rv;
|
1999-05-06 23:25:40 +04:00
|
|
|
|
2002-03-26 14:43:40 +03:00
|
|
|
// Create the style set...
|
|
|
|
nsIStyleSet* styleSet;
|
|
|
|
rv = CreateStyleSet(mDocument, &styleSet);
|
|
|
|
if (NS_FAILED(rv)) return rv;
|
2000-01-19 00:06:10 +03:00
|
|
|
|
1999-05-06 23:25:40 +04:00
|
|
|
// Now make the shell for the document
|
|
|
|
rv = mDocument->CreateShell(mPresContext, mViewManager, styleSet,
|
|
|
|
getter_AddRefs(mPresShell));
|
|
|
|
NS_RELEASE(styleSet);
|
2002-03-26 14:43:40 +03:00
|
|
|
if (NS_FAILED(rv)) return rv;
|
2000-02-11 04:21:50 +03:00
|
|
|
|
2002-03-26 14:43:40 +03:00
|
|
|
mPresShell->BeginObservingDocument();
|
|
|
|
|
|
|
|
// Initialize our view manager
|
|
|
|
nsRect bounds;
|
|
|
|
mWindow->GetBounds(bounds);
|
|
|
|
nscoord width = bounds.width;
|
|
|
|
nscoord height = bounds.height;
|
|
|
|
float p2t;
|
|
|
|
mPresContext->GetPixelsToTwips(&p2t);
|
|
|
|
width = NSIntPixelsToTwips(width, p2t);
|
|
|
|
height = NSIntPixelsToTwips(height, p2t);
|
|
|
|
mViewManager->DisableRefresh();
|
|
|
|
mViewManager->SetWindowDimensions(width, height);
|
|
|
|
|
|
|
|
/* Setup default view manager background color */
|
|
|
|
/* This may be overridden by the docshell with the background color for the
|
|
|
|
last document loaded into the docshell */
|
|
|
|
nscolor bgcolor = NS_RGB(0, 0, 0);
|
|
|
|
mPresContext->GetDefaultBackgroundColor(&bgcolor);
|
|
|
|
mViewManager->SetDefaultBackgroundColor(bgcolor);
|
|
|
|
|
|
|
|
if (!makeCX) {
|
|
|
|
// Make shell an observer for next time
|
|
|
|
// XXX - we observe the docuement always, see above after preshell is created
|
|
|
|
// mPresShell->BeginObservingDocument();
|
|
|
|
|
|
|
|
//XXX I don't think this should be done *here*; and why paint nothing
|
|
|
|
//(which turns out to cause black flashes!)???
|
|
|
|
// Resize-reflow this time
|
|
|
|
mPresShell->InitialReflow(width, height);
|
|
|
|
|
|
|
|
// Now trigger a refresh
|
|
|
|
if (mEnableRendering) {
|
|
|
|
mViewManager->EnableRefresh(NS_VMREFRESH_IMMEDIATE);
|
1999-05-06 23:25:40 +04:00
|
|
|
}
|
2002-03-26 14:43:40 +03:00
|
|
|
}
|
|
|
|
} else {
|
|
|
|
mPresShell->BeginObservingDocument();
|
|
|
|
}
|
2000-01-19 00:06:10 +03:00
|
|
|
// now register ourselves as a selection listener, so that we get called
|
|
|
|
// when the selection changes in the window
|
2001-04-18 10:06:31 +04:00
|
|
|
nsDocViewerSelectionListener *selectionListener;
|
|
|
|
NS_NEWXPCOM(selectionListener, nsDocViewerSelectionListener);
|
2000-02-16 04:39:30 +03:00
|
|
|
if (!selectionListener) return NS_ERROR_OUT_OF_MEMORY;
|
|
|
|
selectionListener->Init(this);
|
|
|
|
|
|
|
|
// this is the owning reference. The nsCOMPtr will take care of releasing
|
|
|
|
// our ref to the listener on destruction.
|
|
|
|
NS_ADDREF(selectionListener);
|
2001-08-01 07:15:50 +04:00
|
|
|
mSelectionListener = do_QueryInterface(selectionListener);
|
2000-02-16 04:39:30 +03:00
|
|
|
NS_RELEASE(selectionListener);
|
|
|
|
if (NS_FAILED(rv)) return rv;
|
|
|
|
|
2000-09-14 15:45:01 +04:00
|
|
|
nsCOMPtr<nsISelection> selection;
|
2000-01-19 00:06:10 +03:00
|
|
|
rv = GetDocumentSelection(getter_AddRefs(selection));
|
|
|
|
if (NS_FAILED(rv)) return rv;
|
|
|
|
|
2000-09-14 15:45:01 +04:00
|
|
|
nsCOMPtr<nsISelectionPrivate> selPrivate(do_QueryInterface(selection));
|
|
|
|
rv = selPrivate->AddSelectionListener(mSelectionListener);
|
2000-01-19 00:06:10 +03:00
|
|
|
if (NS_FAILED(rv)) return rv;
|
|
|
|
|
2000-04-22 01:40:28 +04:00
|
|
|
//focus listener
|
|
|
|
// now register ourselves as a focus listener, so that we get called
|
|
|
|
// when the focus changes in the window
|
|
|
|
nsDocViewerFocusListener *focusListener;
|
|
|
|
NS_NEWXPCOM(focusListener, nsDocViewerFocusListener);
|
|
|
|
if (!focusListener) return NS_ERROR_OUT_OF_MEMORY;
|
|
|
|
focusListener->Init(this);
|
|
|
|
|
|
|
|
// this is the owning reference. The nsCOMPtr will take care of releasing
|
|
|
|
// our ref to the listener on destruction.
|
|
|
|
NS_ADDREF(focusListener);
|
2001-08-01 07:15:50 +04:00
|
|
|
mFocusListener = do_QueryInterface(focusListener);
|
2000-04-22 01:40:28 +04:00
|
|
|
NS_RELEASE(focusListener);
|
|
|
|
if (NS_FAILED(rv))
|
|
|
|
return rv;
|
|
|
|
|
|
|
|
if(mDocument)
|
|
|
|
{
|
|
|
|
// get the DOM event receiver
|
2001-08-01 07:15:50 +04:00
|
|
|
nsCOMPtr<nsIDOMEventReceiver> erP (do_QueryInterface(mDocument, &rv));
|
2001-10-24 08:50:37 +04:00
|
|
|
if(NS_FAILED(rv))
|
|
|
|
return rv;
|
|
|
|
if(!erP)
|
|
|
|
return NS_ERROR_FAILURE;
|
2000-04-22 01:40:28 +04:00
|
|
|
|
|
|
|
rv = erP->AddEventListenerByIID(mFocusListener, NS_GET_IID(nsIDOMFocusListener));
|
|
|
|
NS_ASSERTION(NS_SUCCEEDED(rv), "failed to register focus listener");
|
|
|
|
}
|
2001-03-27 15:56:03 +04:00
|
|
|
|
1999-05-06 23:25:40 +04:00
|
|
|
return rv;
|
|
|
|
}
|
|
|
|
|
2000-09-06 13:11:38 +04:00
|
|
|
//
|
|
|
|
// LoadComplete(aStatus)
|
|
|
|
//
|
|
|
|
// aStatus - The status returned from loading the document.
|
|
|
|
//
|
|
|
|
// This method is called by the container when the document has been
|
|
|
|
// completely loaded.
|
|
|
|
//
|
2000-06-22 09:38:07 +04:00
|
|
|
NS_IMETHODIMP
|
|
|
|
DocumentViewerImpl::LoadComplete(nsresult aStatus)
|
|
|
|
{
|
2000-11-28 02:23:28 +03:00
|
|
|
nsresult rv = NS_OK;
|
2001-03-10 06:19:36 +03:00
|
|
|
NS_ENSURE_TRUE(mDocument, NS_ERROR_NOT_AVAILABLE);
|
2000-09-06 13:11:38 +04:00
|
|
|
|
|
|
|
nsCOMPtr<nsIScriptGlobalObject> global;
|
|
|
|
|
|
|
|
// First, get the script global object from the document...
|
2001-03-10 06:19:36 +03:00
|
|
|
rv = mDocument->GetScriptGlobalObject(getter_AddRefs(global));
|
2000-09-06 13:11:38 +04:00
|
|
|
|
|
|
|
// Fail if no ScriptGlobalObject is available...
|
|
|
|
NS_ASSERTION(global, "nsIScriptGlobalObject not set for document!");
|
|
|
|
if (!global) return NS_ERROR_NULL_POINTER;
|
|
|
|
|
2001-05-02 02:50:16 +04:00
|
|
|
mLoaded = PR_TRUE;
|
|
|
|
|
2001-05-12 21:40:12 +04:00
|
|
|
/* We need to protect ourself against auto-destruction in case the window is closed
|
|
|
|
while processing the OnLoad event.
|
|
|
|
See bug http://bugzilla.mozilla.org/show_bug.cgi?id=78445 for more explanation.
|
|
|
|
*/
|
|
|
|
NS_ADDREF_THIS();
|
|
|
|
|
2000-09-06 13:11:38 +04:00
|
|
|
// Now, fire either an OnLoad or OnError event to the document...
|
|
|
|
if(NS_SUCCEEDED(aStatus)) {
|
|
|
|
nsEventStatus status = nsEventStatus_eIgnore;
|
|
|
|
nsEvent event;
|
|
|
|
|
|
|
|
event.eventStructType = NS_EVENT;
|
|
|
|
event.message = NS_PAGE_LOAD;
|
|
|
|
rv = global->HandleDOMEvent(mPresContext, &event, nsnull,
|
|
|
|
NS_EVENT_FLAG_INIT, &status);
|
2001-11-27 02:13:36 +03:00
|
|
|
#ifdef MOZ_TIMELINE
|
|
|
|
// if navigator.xul's load is complete, the main nav window is visible
|
|
|
|
// mark that point.
|
|
|
|
if (mDocument) {
|
|
|
|
//printf("DEBUG: getting uri from document (%p)\n", mDocument.get());
|
|
|
|
nsCOMPtr<nsIURI> uri;
|
|
|
|
mDocument->GetDocumentURL(getter_AddRefs(uri));
|
|
|
|
if (uri.get() != nsnull) {
|
|
|
|
//printf("DEBUG: getting spec fro uri (%p)\n", uri.get());
|
2002-03-06 10:48:55 +03:00
|
|
|
nsCAutoString spec;
|
|
|
|
uri->GetSpec(spec);
|
|
|
|
if (!strcmp(spec.get(), "chrome://navigator/content/navigator.xul")) {
|
2001-11-27 02:13:36 +03:00
|
|
|
NS_TIMELINE_MARK("Navigator Window visible now");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#endif /* MOZ_TIMELINE */
|
2000-09-06 13:11:38 +04:00
|
|
|
} else {
|
|
|
|
// XXX: Should fire error event to the document...
|
|
|
|
}
|
2001-04-25 23:52:49 +04:00
|
|
|
|
|
|
|
// Now that the document has loaded, we can tell the presshell
|
|
|
|
// to unsuppress painting.
|
2001-05-02 02:50:16 +04:00
|
|
|
if (mPresShell && !mStopped)
|
|
|
|
mPresShell->UnsuppressPainting();
|
2000-09-06 13:11:38 +04:00
|
|
|
|
2001-05-12 21:40:12 +04:00
|
|
|
NS_RELEASE_THIS();
|
|
|
|
|
2000-09-06 13:11:38 +04:00
|
|
|
return rv;
|
2000-06-22 09:38:07 +04:00
|
|
|
}
|
|
|
|
|
2001-07-18 00:17:38 +04:00
|
|
|
NS_IMETHODIMP
|
|
|
|
DocumentViewerImpl::Unload()
|
|
|
|
{
|
|
|
|
nsresult rv;
|
|
|
|
|
|
|
|
if (!mDocument) {
|
|
|
|
return NS_ERROR_NULL_POINTER;
|
|
|
|
}
|
|
|
|
|
|
|
|
// First, get the script global object from the document...
|
|
|
|
nsCOMPtr<nsIScriptGlobalObject> global;
|
|
|
|
|
|
|
|
rv = mDocument->GetScriptGlobalObject(getter_AddRefs(global));
|
|
|
|
if (!global) {
|
|
|
|
// Fail if no ScriptGlobalObject is available...
|
|
|
|
NS_ASSERTION(0, "nsIScriptGlobalObject not set for document!");
|
|
|
|
return NS_ERROR_NULL_POINTER;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Now, fire an Unload event to the document...
|
|
|
|
nsEventStatus status = nsEventStatus_eIgnore;
|
|
|
|
nsEvent event;
|
|
|
|
|
|
|
|
event.eventStructType = NS_EVENT;
|
|
|
|
event.message = NS_PAGE_UNLOAD;
|
|
|
|
rv = global->HandleDOMEvent(mPresContext, &event, nsnull,
|
|
|
|
NS_EVENT_FLAG_INIT, &status);
|
|
|
|
|
|
|
|
return rv;
|
|
|
|
}
|
|
|
|
|
2000-06-22 09:38:07 +04:00
|
|
|
NS_IMETHODIMP
|
2001-08-01 07:15:50 +04:00
|
|
|
DocumentViewerImpl::Close()
|
2000-06-22 09:38:07 +04:00
|
|
|
{
|
2001-08-01 07:15:50 +04:00
|
|
|
// All callers are supposed to call close to break circular
|
2001-03-10 06:19:36 +03:00
|
|
|
// references. If we do this stuff in the destructor, the
|
|
|
|
// destructor might never be called (especially if we're being
|
|
|
|
// used from JS.
|
|
|
|
|
2001-08-01 07:15:50 +04:00
|
|
|
// Close is also needed to disable scripts during paint suppression,
|
|
|
|
// since we transfer the existing global object to the new document
|
|
|
|
// that is loaded. In the future, the global object may become a proxy
|
|
|
|
// for an object that can be switched in and out so that we don't need
|
|
|
|
// to disable scripts during paint suppression.
|
|
|
|
|
2001-03-10 06:19:36 +03:00
|
|
|
nsresult rv;
|
|
|
|
|
|
|
|
if (mDocument) {
|
2001-11-03 17:59:39 +03:00
|
|
|
#ifdef NS_PRINT_PREVIEW
|
|
|
|
// Turn scripting back on
|
|
|
|
// after PrintPreview had turned it off
|
|
|
|
if (mPrtPreview) {
|
|
|
|
TurnScriptingOn(PR_TRUE);
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2001-03-10 06:19:36 +03:00
|
|
|
// Break global object circular reference on the document created
|
|
|
|
// in the DocViewer Init
|
|
|
|
nsCOMPtr<nsIScriptGlobalObject> globalObject;
|
|
|
|
mDocument->GetScriptGlobalObject(getter_AddRefs(globalObject));
|
|
|
|
if (globalObject) {
|
2001-10-02 04:54:44 +04:00
|
|
|
globalObject->SetNewDocument(nsnull, PR_TRUE);
|
2001-03-10 06:19:36 +03:00
|
|
|
}
|
|
|
|
// out of band cleanup of webshell
|
|
|
|
mDocument->SetScriptGlobalObject(nsnull);
|
|
|
|
if (mFocusListener) {
|
|
|
|
// get the DOM event receiver
|
2001-08-01 07:15:50 +04:00
|
|
|
nsCOMPtr<nsIDOMEventReceiver> erP( do_QueryInterface(mDocument, &rv) );
|
2001-03-10 06:19:36 +03:00
|
|
|
if(NS_SUCCEEDED(rv) && erP)
|
|
|
|
erP->RemoveEventListenerByIID(mFocusListener, NS_GET_IID(nsIDOMFocusListener));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2001-08-01 07:15:50 +04:00
|
|
|
mDocument = nsnull;
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
DocumentViewerImpl::Destroy()
|
|
|
|
{
|
2002-03-23 19:48:58 +03:00
|
|
|
// Here is where we check to see if the docment was still being prepared
|
|
|
|
// for printing when it was asked to be destroy from someone externally
|
|
|
|
// This usually happens if the document is unloaded while the user is in the Print Dialog
|
|
|
|
//
|
|
|
|
// So we flip the bool to remember that the document is going away
|
|
|
|
// and we can clean up and abort later after returning from the Print Dialog
|
|
|
|
if (mPrt && mPrt->mPreparingForPrint) {
|
|
|
|
mPrt->mDocWasToBeDestroyed = PR_TRUE;
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Don't let the document get unloaded while we are printing
|
|
|
|
// this could happen if we hit the back button during printing
|
2001-08-06 06:27:43 +04:00
|
|
|
if (mDestroyRefCount != 0) {
|
|
|
|
--mDestroyRefCount;
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2001-08-01 07:15:50 +04:00
|
|
|
// All callers are supposed to call destroy to break circular
|
|
|
|
// references. If we do this stuff in the destructor, the
|
|
|
|
// destructor might never be called (especially if we're being
|
|
|
|
// used from JS.
|
|
|
|
|
|
|
|
if (mPrt) {
|
|
|
|
delete mPrt;
|
|
|
|
mPrt = nsnull;
|
|
|
|
}
|
|
|
|
|
2001-11-03 17:59:39 +03:00
|
|
|
#ifdef NS_PRINT_PREVIEW
|
|
|
|
if (mPrtPreview) {
|
|
|
|
delete mPrtPreview;
|
|
|
|
mPrtPreview = nsnull;
|
|
|
|
}
|
2002-02-01 17:52:11 +03:00
|
|
|
|
|
|
|
// This is insruance
|
|
|
|
if (mOldPrtPreview) {
|
|
|
|
delete mOldPrtPreview;
|
|
|
|
mOldPrtPreview = nsnull;
|
|
|
|
}
|
2001-11-03 17:59:39 +03:00
|
|
|
#endif
|
|
|
|
|
2001-08-01 07:15:50 +04:00
|
|
|
// Avoid leaking the old viewer.
|
|
|
|
if (mPreviousViewer) {
|
|
|
|
mPreviousViewer->Destroy();
|
|
|
|
mPreviousViewer = nsnull;
|
|
|
|
}
|
|
|
|
|
2001-03-10 06:19:36 +03:00
|
|
|
if (mDeviceContext)
|
|
|
|
mDeviceContext->FlushFontCache();
|
|
|
|
|
|
|
|
if (mPresShell) {
|
|
|
|
// Break circular reference (or something)
|
|
|
|
mPresShell->EndObservingDocument();
|
|
|
|
nsCOMPtr<nsISelection> selection;
|
2001-08-01 07:15:50 +04:00
|
|
|
nsresult rv = GetDocumentSelection(getter_AddRefs(selection));
|
2001-03-10 06:19:36 +03:00
|
|
|
nsCOMPtr<nsISelectionPrivate> selPrivate(do_QueryInterface(selection));
|
|
|
|
if (NS_SUCCEEDED(rv) && selPrivate && mSelectionListener)
|
|
|
|
selPrivate->RemoveSelectionListener(mSelectionListener);
|
2001-08-01 07:15:50 +04:00
|
|
|
mPresShell->Destroy();
|
|
|
|
mPresShell = nsnull;
|
2001-03-10 06:19:36 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
return NS_OK;
|
2000-06-22 09:38:07 +04:00
|
|
|
}
|
|
|
|
|
1999-05-06 23:25:40 +04:00
|
|
|
NS_IMETHODIMP
|
|
|
|
DocumentViewerImpl::Stop(void)
|
|
|
|
{
|
2001-03-10 06:19:36 +03:00
|
|
|
NS_ASSERTION(mDocument, "Stop called too early or too late");
|
Landing changes Vidur made while the tree was closed for beta1 work, here's a list of the changes. r=me
[1] Cutting down the size of content. Made nsIJSScriptObject inherit from nsIScriptObjectOwner
[2] Cutting down the size of content. Made nsITextContent inherit from nsIContent.
[3] Cutting down the size of content. Moved implementation of nsIDOMReceiver to nsListenerManager. This is not true aggregation since it isn't transitive, but it's OK for now. It will be necessary for nsListenerManager to have a reference to its content in the future anyway, so the transitivity could be done.
dom/public/nsDOMPropEnums.h,v - bug 12559
dom/public/nsIJSScriptObject.h,v - [1]
dom/public/html/MANIFEST,v - bug 12559
dom/public/html/Makefile.in,v - bug 12559
dom/public/html/makefile.win,v - bug 12559
dom/public/html/nsIDOMHTMLInputElement.h,v - bug 17544
dom/public/idl/html/HTMLAnchorElement.idl,v - bug 12559
dom/public/idl/html/HTMLAreaElement.idl,v - bug 12559
dom/public/idl/html/HTMLInputElement.idl,v - bug 17544
dom/src/base/nsGlobalWindow.cpp,v - bug 30700
dom/src/base/nsGlobalWindow.h,v - [1]
dom/src/base/nsLocation.cpp,v - [1]
dom/src/html/nsJSHTMLAnchorElement.cpp,v - bug 12559
dom/src/html/nsJSHTMLAreaElement.cpp,v - bug 12559
dom/src/html/nsJSHTMLInputElement.cpp,v - bug 17544
layout/base/public/nsIDocument.h,v - bug 27953
layout/base/public/nsITextContent.h,v - [2]
layout/base/src/nsCommentNode.cpp,v - [2]
layout/base/src/nsDocument.cpp,v - bug 27953
layout/base/src/nsDocument.h,v - bug 27953
layout/base/src/nsDocumentViewer.cpp,v - bug 27953
layout/base/src/nsGenericDOMDataNode.cpp,v - [3]
layout/base/src/nsGenericDOMDataNode.h,v - [3]
layout/base/src/nsGenericElement.cpp,v - [3]
layout/base/src/nsGenericElement.h,v - [3]
layout/base/src/nsNameSpaceManager.cpp,v - bug 7834
layout/base/src/nsStyleContext.cpp,v - outline property shouldn't reflow
layout/base/src/nsTextNode.cpp,v - [2]
layout/events/src/nsEventListenerManager.cpp,v - [3]
layout/events/src/nsEventListenerManager.h,v - [3]
layout/html/base/src/nsGfxScrollFrame.cpp,v - nsString->nsAutoString
layout/html/content/src/nsAttributeContent.cpp,v - [2]
layout/html/content/src/nsHTMLAnchorElement.cpp,v - [1][3]
layout/html/content/src/nsHTMLAppletElement.cpp,v - [1][3]
layout/html/content/src/nsHTMLAreaElement.cpp,v - [1][3]
layout/html/content/src/nsHTMLBRElement.cpp,v - [1][3]
layout/html/content/src/nsHTMLBaseElement.cpp,v - [1][3]
layout/html/content/src/nsHTMLBaseFontElement.cpp,v - [1][3]
layout/html/content/src/nsHTMLBodyElement.cpp,v - [1][3]
layout/html/content/src/nsHTMLButtonElement.cpp,v - [1][3]
layout/html/content/src/nsHTMLDListElement.cpp,v - [1][3]
layout/html/content/src/nsHTMLDelElement.cpp,v - [1][3]
layout/html/content/src/nsHTMLDirectoryElement.cpp,v - [1][3]
layout/html/content/src/nsHTMLDivElement.cpp,v - [1][3]
layout/html/content/src/nsHTMLEmbedElement.cpp,v - [1][3]
layout/html/content/src/nsHTMLFieldSetElement.cpp,v - [1][3]
layout/html/content/src/nsHTMLFontElement.cpp,v - [1][3]
layout/html/content/src/nsHTMLFormElement.cpp,v - [1][3]
layout/html/content/src/nsHTMLFrameElement.cpp,v - [1][3]
layout/html/content/src/nsHTMLFrameSetElement.cpp,v - [1][3]
layout/html/content/src/nsHTMLHRElement.cpp,v - [1][3]
layout/html/content/src/nsHTMLHeadElement.cpp,v - [1][3]
layout/html/content/src/nsHTMLHeadingElement.cpp,v - [1][3]
layout/html/content/src/nsHTMLHtmlElement.cpp,v - [1][3]
layout/html/content/src/nsHTMLIFrameElement.cpp,v - [1][3]
layout/html/content/src/nsHTMLImageElement.cpp,v - [1][3]
layout/html/content/src/nsHTMLInputElement.cpp,v - [1][3]
layout/html/content/src/nsHTMLInsElement.cpp,v - [1][3]
layout/html/content/src/nsHTMLIsIndexElement.cpp,v - [1][3]
layout/html/content/src/nsHTMLLIElement.cpp,v - [1][3]
layout/html/content/src/nsHTMLLabelElement.cpp,v - [1][3]
layout/html/content/src/nsHTMLLayerElement.cpp,v - [1][3]
layout/html/content/src/nsHTMLLegendElement.cpp,v - [1][3]
layout/html/content/src/nsHTMLLinkElement.cpp,v - [1][3]
layout/html/content/src/nsHTMLMapElement.cpp,v - [1][3]
layout/html/content/src/nsHTMLMenuElement.cpp,v - [1][3]
layout/html/content/src/nsHTMLMetaElement.cpp,v - [1][3]
layout/html/content/src/nsHTMLModElement.cpp,v - [1][3]
layout/html/content/src/nsHTMLOListElement.cpp,v - [1][3]
layout/html/content/src/nsHTMLObjectElement.cpp,v - [1][3]
layout/html/content/src/nsHTMLOptGroupElement.cpp,v - [1][3]
layout/html/content/src/nsHTMLOptionElement.cpp,v - [1][3]
layout/html/content/src/nsHTMLParagraphElement.cpp,v - [1][3]
layout/html/content/src/nsHTMLParamElement.cpp,v - [1][3]
layout/html/content/src/nsHTMLPreElement.cpp,v - [1][3]
layout/html/content/src/nsHTMLQuoteElement.cpp,v - [1][3]
layout/html/content/src/nsHTMLScriptElement.cpp,v - [1][3]
layout/html/content/src/nsHTMLSelectElement.cpp,v - [1][3]
layout/html/content/src/nsHTMLSpacerElement.cpp,v - [1][3]
layout/html/content/src/nsHTMLSpanElement.cpp,v - [1][3]
layout/html/content/src/nsHTMLStyleElement.cpp,v - [1][3]
layout/html/content/src/nsHTMLTableCaptionElement.cpp,v - [1][3]
layout/html/content/src/nsHTMLTableCellElement.cpp,v - [1][3]
layout/html/content/src/nsHTMLTableColElement.cpp,v - [1][3]
layout/html/content/src/nsHTMLTableColGroupElement.cpp,v - [1][3]
layout/html/content/src/nsHTMLTableElement.cpp,v - [1][3]
layout/html/content/src/nsHTMLTableRowElement.cpp,v - [1][3]
layout/html/content/src/nsHTMLTableSectionElement.cpp,v - [1][3]
layout/html/content/src/nsHTMLTextAreaElement.cpp,v - [1][3]
layout/html/content/src/nsHTMLTitleElement.cpp,v - [1][3]
layout/html/content/src/nsHTMLUListElement.cpp,v - [1][3]
layout/html/content/src/nsHTMLWBRElement.cpp,v - [1][3]
layout/html/document/src/nsHTMLDocument.cpp,v - bug 27953
layout/html/document/src/nsHTMLDocument.h,v - bug 27953
layout/xml/content/src/nsXMLCDATASection.cpp,v - [1][2]
layout/xml/content/src/nsXMLDocumentType.cpp,v - [1][2]
layout/xml/content/src/nsXMLElement.h,v - [1][2]
layout/xml/content/src/nsXMLEntity.cpp,v - [1][2]
layout/xml/content/src/nsXMLNotation.cpp,v - [1][2]
layout/xml/content/src/nsXMLProcessingInstruction.cpp,v - [1][2]
layout/xul/base/src/nsBoxFrame.cpp,v - nsString->nsAutoString
layout/xul/base/src/nsSliderFrame.cpp,v - nsString->nsAutoString
netwerk/protocol/http/src/nsHTTPRequest.cpp,v - nsString->nsAutoString
rdf/content/src/nsXULDocument.cpp,v - bug 27953
rdf/content/src/nsXULDocument.h,v - bug 27953
rdf/content/src/nsXULElement.h,v - [1]
xpcom/base/IIDS.h,v - bug 12559
2000-03-17 16:27:00 +03:00
|
|
|
if (mDocument) {
|
|
|
|
mDocument->StopDocumentLoad();
|
|
|
|
}
|
|
|
|
|
2001-05-02 02:50:16 +04:00
|
|
|
mStopped = PR_TRUE;
|
|
|
|
|
|
|
|
if (!mLoaded && mPresShell) {
|
|
|
|
// Well, we might as well paint what we have so far.
|
|
|
|
mPresShell->UnsuppressPainting();
|
1999-05-06 23:25:40 +04:00
|
|
|
}
|
2001-04-25 23:52:49 +04:00
|
|
|
|
1999-05-06 23:25:40 +04:00
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2000-06-22 09:38:07 +04:00
|
|
|
NS_IMETHODIMP
|
|
|
|
DocumentViewerImpl::GetDOMDocument(nsIDOMDocument **aResult)
|
|
|
|
{
|
2001-03-10 06:19:36 +03:00
|
|
|
NS_ENSURE_TRUE(mDocument, NS_ERROR_NOT_AVAILABLE);
|
2000-06-22 09:38:07 +04:00
|
|
|
return CallQueryInterface(mDocument.get(), aResult);
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
DocumentViewerImpl::SetDOMDocument(nsIDOMDocument *aDocument)
|
|
|
|
{
|
2000-09-02 19:32:28 +04:00
|
|
|
// Assumptions:
|
|
|
|
//
|
|
|
|
// 1) this document viewer has been initialized with a call to Init().
|
|
|
|
// 2) the stylesheets associated with the document have been added to the document.
|
|
|
|
|
|
|
|
// XXX Right now, this method assumes that the layout of the current document
|
|
|
|
// hasn't started yet. More cleanup will probably be necessary to make this
|
|
|
|
// method work for the case when layout *has* occurred for the current document.
|
|
|
|
// That work can happen when and if it is needed.
|
|
|
|
|
|
|
|
nsresult rv;
|
|
|
|
if (nsnull == aDocument)
|
|
|
|
return NS_ERROR_NULL_POINTER;
|
|
|
|
|
|
|
|
nsCOMPtr<nsIDocument> newDoc = do_QueryInterface(aDocument, &rv);
|
|
|
|
if (NS_FAILED(rv)) return rv;
|
|
|
|
|
|
|
|
// 0) Replace the old document with the new one
|
|
|
|
mDocument = newDoc;
|
|
|
|
|
|
|
|
// 1) Set the script global object on the new document
|
|
|
|
nsCOMPtr<nsIInterfaceRequestor> requestor(do_QueryInterface(mContainer));
|
|
|
|
if (requestor) {
|
|
|
|
nsCOMPtr<nsIScriptGlobalObjectOwner> owner;
|
|
|
|
requestor->GetInterface(NS_GET_IID(nsIScriptGlobalObjectOwner),
|
|
|
|
getter_AddRefs(owner));
|
|
|
|
if (nsnull != owner) {
|
|
|
|
nsCOMPtr<nsIScriptGlobalObject> global;
|
|
|
|
rv = owner->GetScriptGlobalObject(getter_AddRefs(global));
|
|
|
|
if (NS_SUCCEEDED(rv) && (nsnull != global)) {
|
|
|
|
mDocument->SetScriptGlobalObject(global);
|
2001-10-02 04:54:44 +04:00
|
|
|
global->SetNewDocument(aDocument, PR_TRUE);
|
2000-09-02 19:32:28 +04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// 2) Create a new style set for the document
|
|
|
|
nsCOMPtr<nsIStyleSet> styleSet;
|
|
|
|
rv = CreateStyleSet(mDocument, getter_AddRefs(styleSet));
|
|
|
|
if (NS_FAILED(rv)) return rv;
|
|
|
|
|
|
|
|
// 3) Replace the current pres shell with a new shell for the new document
|
|
|
|
mPresShell->EndObservingDocument();
|
2001-08-01 07:15:50 +04:00
|
|
|
mPresShell->Destroy();
|
2000-09-02 19:32:28 +04:00
|
|
|
|
|
|
|
mPresShell = nsnull;
|
|
|
|
rv = newDoc->CreateShell(mPresContext, mViewManager, styleSet,
|
|
|
|
getter_AddRefs(mPresShell));
|
|
|
|
if (NS_FAILED(rv)) return rv;
|
|
|
|
|
|
|
|
mPresShell->BeginObservingDocument();
|
|
|
|
|
|
|
|
// 4) Register the focus listener on the new document
|
|
|
|
if(mDocument)
|
|
|
|
{
|
2001-08-01 07:15:50 +04:00
|
|
|
nsCOMPtr<nsIDOMEventReceiver> erP = do_QueryInterface(mDocument, &rv);
|
2000-09-02 19:32:28 +04:00
|
|
|
if(NS_FAILED(rv) || !erP)
|
|
|
|
return rv ? rv : NS_ERROR_FAILURE;
|
|
|
|
|
|
|
|
rv = erP->AddEventListenerByIID(mFocusListener, NS_GET_IID(nsIDOMFocusListener));
|
|
|
|
NS_ASSERTION(NS_SUCCEEDED(rv), "failed to register focus listener");
|
|
|
|
}
|
|
|
|
|
|
|
|
return rv;
|
2000-06-22 09:38:07 +04:00
|
|
|
}
|
|
|
|
|
1999-05-06 23:25:40 +04:00
|
|
|
NS_IMETHODIMP
|
|
|
|
DocumentViewerImpl::SetUAStyleSheet(nsIStyleSheet* aUAStyleSheet)
|
|
|
|
{
|
2002-01-22 08:36:50 +03:00
|
|
|
if (aUAStyleSheet) {
|
|
|
|
nsCOMPtr<nsICSSStyleSheet> sheet(do_QueryInterface(aUAStyleSheet));
|
|
|
|
nsCOMPtr<nsICSSStyleSheet> newSheet;
|
|
|
|
sheet->Clone(*getter_AddRefs(newSheet));
|
|
|
|
mUAStyleSheet = newSheet;
|
|
|
|
}
|
1999-05-06 23:25:40 +04:00
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
DocumentViewerImpl::GetDocument(nsIDocument*& aResult)
|
|
|
|
{
|
|
|
|
aResult = mDocument;
|
|
|
|
NS_IF_ADDREF(aResult);
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
DocumentViewerImpl::GetPresShell(nsIPresShell*& aResult)
|
|
|
|
{
|
|
|
|
aResult = mPresShell;
|
|
|
|
NS_IF_ADDREF(aResult);
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
DocumentViewerImpl::GetPresContext(nsIPresContext*& aResult)
|
|
|
|
{
|
|
|
|
aResult = mPresContext;
|
|
|
|
NS_IF_ADDREF(aResult);
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
DocumentViewerImpl::GetBounds(nsRect& aResult)
|
|
|
|
{
|
2001-03-10 06:19:36 +03:00
|
|
|
NS_ENSURE_TRUE(mDocument, NS_ERROR_NOT_AVAILABLE);
|
1999-05-06 23:25:40 +04:00
|
|
|
NS_PRECONDITION(mWindow, "null window");
|
|
|
|
if (mWindow) {
|
|
|
|
mWindow->GetBounds(aResult);
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
aResult.SetRect(0, 0, 0, 0);
|
|
|
|
}
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2001-05-02 02:50:16 +04:00
|
|
|
NS_IMETHODIMP
|
|
|
|
DocumentViewerImpl::GetPreviousViewer(nsIContentViewer** aViewer)
|
|
|
|
{
|
|
|
|
*aViewer = mPreviousViewer;
|
|
|
|
NS_IF_ADDREF(*aViewer);
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
DocumentViewerImpl::SetPreviousViewer(nsIContentViewer* aViewer)
|
|
|
|
{
|
2001-08-01 07:15:50 +04:00
|
|
|
// NOTE: |Show| sets |mPreviousViewer| to null without calling this
|
|
|
|
// function.
|
|
|
|
|
|
|
|
if (aViewer) {
|
|
|
|
NS_ASSERTION(!mPreviousViewer,
|
|
|
|
"can't set previous viewer when there already is one");
|
2001-05-02 02:50:16 +04:00
|
|
|
|
|
|
|
// In a multiple chaining situation (which occurs when running a thrashing
|
|
|
|
// test like i-bench or jrgm's tests with no delay), we can build up a
|
|
|
|
// whole chain of viewers. In order to avoid this, we always set our previous
|
|
|
|
// viewer to the MOST previous viewer in the chain, and then dump the intermediate
|
|
|
|
// link from the chain. This ensures that at most only 2 documents are alive
|
|
|
|
// and undestroyed at any given time (the one that is showing and the one that
|
|
|
|
// is loading with painting suppressed).
|
|
|
|
nsCOMPtr<nsIContentViewer> prevViewer;
|
|
|
|
aViewer->GetPreviousViewer(getter_AddRefs(prevViewer));
|
|
|
|
if (prevViewer) {
|
2001-08-01 07:15:50 +04:00
|
|
|
aViewer->SetPreviousViewer(nsnull);
|
|
|
|
aViewer->Destroy();
|
|
|
|
return SetPreviousViewer(prevViewer);
|
2001-05-02 02:50:16 +04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
mPreviousViewer = aViewer;
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
1999-05-06 23:25:40 +04:00
|
|
|
NS_IMETHODIMP
|
|
|
|
DocumentViewerImpl::SetBounds(const nsRect& aBounds)
|
|
|
|
{
|
2001-03-10 06:19:36 +03:00
|
|
|
NS_ENSURE_TRUE(mDocument, NS_ERROR_NOT_AVAILABLE);
|
1999-05-06 23:25:40 +04:00
|
|
|
NS_PRECONDITION(mWindow, "null window");
|
|
|
|
if (mWindow) {
|
|
|
|
// Don't have the widget repaint. Layout will generate repaint requests
|
|
|
|
// during reflow
|
|
|
|
mWindow->Resize(aBounds.x, aBounds.y, aBounds.width, aBounds.height,
|
|
|
|
PR_FALSE);
|
|
|
|
}
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
DocumentViewerImpl::Move(PRInt32 aX, PRInt32 aY)
|
|
|
|
{
|
2001-03-10 06:19:36 +03:00
|
|
|
NS_ENSURE_TRUE(mDocument, NS_ERROR_NOT_AVAILABLE);
|
1999-05-06 23:25:40 +04:00
|
|
|
NS_PRECONDITION(mWindow, "null window");
|
|
|
|
if (mWindow) {
|
|
|
|
mWindow->Move(aX, aY);
|
|
|
|
}
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
DocumentViewerImpl::Show(void)
|
|
|
|
{
|
2001-03-10 06:19:36 +03:00
|
|
|
NS_ENSURE_TRUE(mDocument, NS_ERROR_NOT_AVAILABLE);
|
1999-05-06 23:25:40 +04:00
|
|
|
NS_PRECONDITION(mWindow, "null window");
|
2001-08-01 07:15:50 +04:00
|
|
|
|
|
|
|
// We don't need the previous viewer anymore since we're not
|
|
|
|
// displaying it.
|
|
|
|
if (mPreviousViewer) {
|
|
|
|
// This little dance *may* only be to keep
|
|
|
|
// PresShell::EndObservingDocument happy, but I'm not sure.
|
|
|
|
nsCOMPtr<nsIContentViewer> prevViewer(mPreviousViewer);
|
|
|
|
mPreviousViewer = nsnull;
|
|
|
|
prevViewer->Destroy();
|
|
|
|
}
|
|
|
|
|
1999-05-06 23:25:40 +04:00
|
|
|
if (mWindow) {
|
|
|
|
mWindow->Show(PR_TRUE);
|
|
|
|
}
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
DocumentViewerImpl::Hide(void)
|
|
|
|
{
|
2001-03-10 06:19:36 +03:00
|
|
|
NS_ENSURE_TRUE(mDocument, NS_ERROR_NOT_AVAILABLE);
|
1999-05-06 23:25:40 +04:00
|
|
|
NS_PRECONDITION(mWindow, "null window");
|
|
|
|
if (mWindow) {
|
|
|
|
mWindow->Show(PR_FALSE);
|
|
|
|
}
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2000-09-22 18:42:13 +04:00
|
|
|
nsresult
|
|
|
|
DocumentViewerImpl::FindFrameSetWithIID(nsIContent * aParentContent, const nsIID& aIID)
|
|
|
|
{
|
|
|
|
PRInt32 numChildren;
|
|
|
|
aParentContent->ChildCount(numChildren);
|
|
|
|
|
|
|
|
// do a breadth search across all siblings
|
|
|
|
PRInt32 inx;
|
|
|
|
for (inx=0;inx<numChildren;inx++) {
|
|
|
|
nsCOMPtr<nsIContent> child;
|
|
|
|
if (NS_SUCCEEDED(aParentContent->ChildAt(inx, *getter_AddRefs(child))) && child) {
|
|
|
|
nsCOMPtr<nsISupports> temp;
|
|
|
|
if (NS_SUCCEEDED(child->QueryInterface(aIID, (void**)getter_AddRefs(temp)))) {
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
}
|
|
|
|
|
2001-04-12 17:04:29 +04:00
|
|
|
/** ---------------------------------------------------
|
|
|
|
* Helper function
|
|
|
|
*/
|
|
|
|
static nsIPresShell*
|
|
|
|
GetPresShellFor(nsIDocShell* aDocShell)
|
|
|
|
{
|
2002-03-26 14:43:40 +03:00
|
|
|
nsCOMPtr<nsIDOMDocument> domDoc(do_GetInterface(aDocShell));
|
|
|
|
if (!domDoc) return nsnull;
|
|
|
|
|
|
|
|
nsCOMPtr<nsIDocument> doc(do_QueryInterface(domDoc));
|
|
|
|
if (!doc) return nsnull;
|
|
|
|
|
2001-04-12 17:04:29 +04:00
|
|
|
nsIPresShell* shell = nsnull;
|
2002-03-26 14:43:40 +03:00
|
|
|
doc->GetShellAt(0, &shell);
|
|
|
|
|
2001-04-12 17:04:29 +04:00
|
|
|
return shell;
|
|
|
|
}
|
|
|
|
|
2001-01-27 17:09:34 +03:00
|
|
|
//---------------------------------------------------------------
|
|
|
|
//---------------------------------------------------------------
|
|
|
|
//-- Debug helper routines
|
|
|
|
//---------------------------------------------------------------
|
|
|
|
//---------------------------------------------------------------
|
2002-01-25 17:30:14 +03:00
|
|
|
#if defined(XP_PC) && defined(DEBUG_rods) && defined(DEBUG_PRINTING)
|
|
|
|
#include "windows.h"
|
|
|
|
#include "process.h"
|
|
|
|
#include "direct.h"
|
|
|
|
|
|
|
|
#define MY_FINDFIRST(a,b) FindFirstFile(a,b)
|
|
|
|
#define MY_FINDNEXT(a,b) FindNextFile(a,b)
|
|
|
|
#define ISDIR(a) (a.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
|
|
|
|
#define MY_FINDCLOSE(a) FindClose(a)
|
|
|
|
#define MY_FILENAME(a) a.cFileName
|
|
|
|
#define MY_FILESIZE(a) (a.nFileSizeHigh * MAXDWORD) + a.nFileSizeLow
|
|
|
|
|
|
|
|
int RemoveFilesInDir(const char * aDir)
|
|
|
|
{
|
|
|
|
WIN32_FIND_DATA data_ptr;
|
|
|
|
HANDLE find_handle;
|
|
|
|
|
|
|
|
char path[MAX_PATH];
|
|
|
|
|
|
|
|
strcpy(path, aDir);
|
|
|
|
|
|
|
|
// Append slash to the end of the directory names if not there
|
|
|
|
if (path[strlen(path)-1] != '\\')
|
|
|
|
strcat(path, "\\");
|
|
|
|
|
|
|
|
char findPath[MAX_PATH];
|
|
|
|
strcpy(findPath, path);
|
|
|
|
strcat(findPath, "*.*");
|
|
|
|
|
|
|
|
find_handle = MY_FINDFIRST(findPath, &data_ptr);
|
|
|
|
|
|
|
|
if (find_handle != INVALID_HANDLE_VALUE) {
|
|
|
|
do {
|
|
|
|
if (ISDIR(data_ptr)
|
|
|
|
&& (stricmp(MY_FILENAME(data_ptr),"."))
|
|
|
|
&& (stricmp(MY_FILENAME(data_ptr),".."))) {
|
|
|
|
// skip
|
|
|
|
}
|
|
|
|
else if (!ISDIR(data_ptr)) {
|
|
|
|
if (!strncmp(MY_FILENAME(data_ptr), "dump", 4)) {
|
|
|
|
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
|
|
|
|
|
2001-04-12 17:04:29 +04:00
|
|
|
#ifdef DEBUG_PRINTING
|
2001-01-27 17:09:34 +03:00
|
|
|
|
2002-02-19 14:49:27 +03:00
|
|
|
/** ---------------------------------------------------
|
|
|
|
* Dumps Frames for Printing
|
|
|
|
*/
|
|
|
|
static void RootFrameList(nsIPresContext* aPresContext, FILE* out, PRInt32 aIndent)
|
|
|
|
{
|
|
|
|
if((nsnull == aPresContext) || (nsnull == out))
|
|
|
|
return;
|
|
|
|
|
|
|
|
nsCOMPtr<nsIPresShell> shell;
|
|
|
|
aPresContext->GetShell(getter_AddRefs(shell));
|
|
|
|
if (nsnull != shell) {
|
|
|
|
nsIFrame* frame;
|
|
|
|
shell->GetRootFrame(&frame);
|
|
|
|
if(nsnull != frame) {
|
|
|
|
nsIFrameDebug* debugFrame;
|
|
|
|
nsresult rv;
|
|
|
|
rv = frame->QueryInterface(NS_GET_IID(nsIFrameDebug), (void**)&debugFrame);
|
|
|
|
if(NS_SUCCEEDED(rv))
|
|
|
|
debugFrame->List(aPresContext, out, aIndent);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2001-01-27 17:09:34 +03:00
|
|
|
/** ---------------------------------------------------
|
|
|
|
* Dumps Frames for Printing
|
|
|
|
*/
|
|
|
|
static void DumpFrames(FILE* out,
|
|
|
|
nsIPresContext* aPresContext,
|
|
|
|
nsIRenderingContext * aRendContext,
|
|
|
|
nsIFrame * aFrame,
|
|
|
|
PRInt32 aLevel)
|
|
|
|
{
|
2001-04-12 17:04:29 +04:00
|
|
|
NS_ASSERTION(out, "Pointer is null!");
|
|
|
|
NS_ASSERTION(aPresContext, "Pointer is null!");
|
|
|
|
NS_ASSERTION(aRendContext, "Pointer is null!");
|
|
|
|
NS_ASSERTION(aFrame, "Pointer is null!");
|
|
|
|
|
2001-01-27 17:09:34 +03:00
|
|
|
nsIFrame * child;
|
|
|
|
aFrame->FirstChild(aPresContext, nsnull, &child);
|
|
|
|
while (child != nsnull) {
|
|
|
|
for (PRInt32 i=0;i<aLevel;i++) {
|
|
|
|
fprintf(out, " ");
|
|
|
|
}
|
|
|
|
nsAutoString tmp;
|
|
|
|
nsIFrameDebug* frameDebug;
|
|
|
|
|
2001-08-01 07:15:50 +04:00
|
|
|
if (NS_SUCCEEDED(CallQueryInterface(child, &frameDebug))) {
|
2001-01-27 17:09:34 +03:00
|
|
|
frameDebug->GetFrameName(tmp);
|
|
|
|
}
|
2001-10-16 07:53:44 +04:00
|
|
|
fputs(NS_LossyConvertUCS2toASCII(tmp).get(), out);
|
2001-01-27 17:09:34 +03:00
|
|
|
nsFrameState state;
|
|
|
|
child->GetFrameState(&state);
|
|
|
|
PRBool isSelected;
|
|
|
|
if (NS_SUCCEEDED(child->IsVisibleForPainting(aPresContext, *aRendContext, PR_TRUE, &isSelected))) {
|
|
|
|
fprintf(out, " %p %s", child, isSelected?"VIS":"UVS");
|
|
|
|
nsRect rect;
|
|
|
|
child->GetRect(rect);
|
|
|
|
fprintf(out, "[%d,%d,%d,%d] ", rect.x, rect.y, rect.width, rect.height);
|
|
|
|
nsIView * view;
|
|
|
|
child->GetView(aPresContext, &view);
|
|
|
|
fprintf(out, "v: %p ", view);
|
|
|
|
fprintf(out, "\n");
|
|
|
|
DumpFrames(out, aPresContext, aRendContext, child, aLevel+1);
|
|
|
|
child->GetNextSibling(&child);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/** ---------------------------------------------------
|
|
|
|
* Dumps the Views from the DocShell
|
|
|
|
*/
|
|
|
|
static void
|
|
|
|
DumpViews(nsIDocShell* aDocShell, FILE* out)
|
|
|
|
{
|
2001-04-12 17:04:29 +04:00
|
|
|
NS_ASSERTION(aDocShell, "Pointer is null!");
|
|
|
|
NS_ASSERTION(out, "Pointer is null!");
|
|
|
|
|
2001-01-27 17:09:34 +03:00
|
|
|
if (nsnull != aDocShell) {
|
|
|
|
fprintf(out, "docshell=%p \n", aDocShell);
|
|
|
|
nsIPresShell* shell = GetPresShellFor(aDocShell);
|
|
|
|
if (nsnull != shell) {
|
|
|
|
nsCOMPtr<nsIViewManager> vm;
|
|
|
|
shell->GetViewManager(getter_AddRefs(vm));
|
|
|
|
if (vm) {
|
|
|
|
nsIView* root;
|
|
|
|
vm->GetRootView(root);
|
|
|
|
if (nsnull != root) {
|
|
|
|
root->List(out);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
NS_RELEASE(shell);
|
|
|
|
}
|
|
|
|
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
|
|
|
|
*/
|
2001-11-03 17:59:39 +03:00
|
|
|
void DumpLayoutData(char* aTitleStr,
|
|
|
|
char* aURLStr,
|
|
|
|
nsIPresContext* aPresContext,
|
2001-01-27 17:09:34 +03:00
|
|
|
nsIDeviceContext * aDC,
|
|
|
|
nsIFrame * aRootFrame,
|
2001-04-12 17:04:29 +04:00
|
|
|
nsIWebShell * aWebShell,
|
|
|
|
FILE* aFD = nsnull)
|
2001-01-27 17:09:34 +03:00
|
|
|
{
|
2001-04-12 17:04:29 +04:00
|
|
|
if (aPresContext == nsnull || aDC == nsnull) {
|
|
|
|
return;
|
|
|
|
}
|
2001-11-03 17:59:39 +03:00
|
|
|
|
|
|
|
#ifdef NS_PRINT_PREVIEW
|
|
|
|
nsCOMPtr<nsIPrintPreviewContext> ppContext = do_QueryInterface(aPresContext);
|
|
|
|
if (ppContext) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2001-04-12 17:04:29 +04:00
|
|
|
NS_ASSERTION(aRootFrame, "Pointer is null!");
|
|
|
|
NS_ASSERTION(aWebShell, "Pointer is null!");
|
|
|
|
|
2001-01-27 17:09:34 +03:00
|
|
|
// Dump all the frames and view to a a file
|
2001-11-03 17:59:39 +03:00
|
|
|
char filename[256];
|
|
|
|
sprintf(filename, "dump_layout_%d.txt", gDumpLOFileNameCnt++);
|
|
|
|
FILE * fd = aFD?aFD:fopen(filename, "w");
|
2001-01-27 17:09:34 +03:00
|
|
|
if (fd) {
|
2001-11-03 17:59:39 +03:00
|
|
|
fprintf(fd, "Title: %s\n", aTitleStr?aTitleStr:"");
|
|
|
|
fprintf(fd, "URL: %s\n", aURLStr?aURLStr:"");
|
|
|
|
fprintf(fd, "--------------- Frames ----------------\n");
|
2001-01-27 17:09:34 +03:00
|
|
|
fprintf(fd, "--------------- Frames ----------------\n");
|
|
|
|
nsCOMPtr<nsIRenderingContext> renderingContext;
|
|
|
|
aDC->CreateRenderingContext(*getter_AddRefs(renderingContext));
|
2002-02-19 14:49:27 +03:00
|
|
|
RootFrameList(aPresContext, fd, 0);
|
|
|
|
//DumpFrames(fd, aPresContext, renderingContext, aRootFrame, 0);
|
2001-01-27 17:09:34 +03:00
|
|
|
fprintf(fd, "---------------------------------------\n\n");
|
|
|
|
fprintf(fd, "--------------- Views From Root Frame----------------\n");
|
|
|
|
nsIView * v;
|
|
|
|
aRootFrame->GetView(aPresContext, &v);
|
|
|
|
if (v) {
|
|
|
|
v->List(fd);
|
|
|
|
} else {
|
|
|
|
printf("View is null!\n");
|
|
|
|
}
|
|
|
|
nsCOMPtr<nsIDocShell> docShell(do_QueryInterface(aWebShell));
|
|
|
|
if (docShell) {
|
|
|
|
fprintf(fd, "--------------- All Views ----------------\n");
|
|
|
|
DumpViews(docShell, fd);
|
|
|
|
fprintf(fd, "---------------------------------------\n\n");
|
|
|
|
}
|
2001-04-12 17:04:29 +04:00
|
|
|
if (aFD == nsnull) {
|
|
|
|
fclose(fd);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static void DumpPrintObjectsList(nsVoidArray * aDocList, FILE* aFD = nsnull)
|
|
|
|
{
|
|
|
|
NS_ASSERTION(aDocList, "Pointer is null!");
|
|
|
|
|
|
|
|
FILE * fd = aFD?aFD:stdout;
|
|
|
|
|
|
|
|
char * types[] = {"DC", "FR", "IF", "FS"};
|
|
|
|
fprintf(fd, "Doc List\n***************************************************\n");
|
|
|
|
fprintf(fd, "T P A H PO WebShell Seq Page Root Page# Rect\n");
|
|
|
|
PRInt32 cnt = aDocList->Count();
|
|
|
|
for (PRInt32 i=0;i<cnt;i++) {
|
|
|
|
PrintObject* po = (PrintObject*)aDocList->ElementAt(i);
|
|
|
|
NS_ASSERTION(po, "PrintObject can't be null!");
|
|
|
|
nsIFrame* rootFrame = nsnull;
|
|
|
|
if (po->mPresShell) {
|
|
|
|
po->mPresShell->GetRootFrame(&rootFrame);
|
|
|
|
while (rootFrame != nsnull) {
|
|
|
|
nsIPageSequenceFrame * sqf = nsnull;
|
2002-02-01 17:52:11 +03:00
|
|
|
if (NS_SUCCEEDED(CallQueryInterface(rootFrame, &sqf))) {
|
2001-04-12 17:04:29 +04:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
rootFrame->FirstChild(po->mPresContext, nsnull, &rootFrame);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
fprintf(fd, "%s %d %d %d %p %p %p %p %p %d %d,%d,%d,%d\n", types[po->mFrameType],
|
|
|
|
po->IsPrintable(), po->mPrintAsIs, po->mHasBeenPrinted, po, po->mWebShell, po->mSeqFrame,
|
|
|
|
po->mPageFrame, rootFrame, po->mPageNum, po->mRect.x, po->mRect.y, po->mRect.width, po->mRect.height);
|
|
|
|
if (fd != nsnull && fd != stdout) {
|
|
|
|
fprintf(stdout, "%s %d %d %d %p %p %p %p %p %d %d,%d,%d,%d\n", types[po->mFrameType],
|
|
|
|
po->IsPrintable(), po->mPrintAsIs, po->mHasBeenPrinted, po, po->mWebShell, po->mSeqFrame,
|
|
|
|
po->mPageFrame, rootFrame, po->mPageNum, po->mRect.x, po->mRect.y, po->mRect.width, po->mRect.height);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
static void DumpPrintObjectsTree(PrintObject * aPO, int aLevel= 0, FILE* aFD = nsnull)
|
|
|
|
{
|
|
|
|
NS_ASSERTION(aPO, "Pointer is null!");
|
|
|
|
|
|
|
|
FILE * fd = aFD?aFD:stdout;
|
|
|
|
char * types[] = {"DC", "FR", "IF", "FS"};
|
|
|
|
if (aLevel == 0) {
|
|
|
|
fprintf(fd, "DocTree\n***************************************************\n");
|
|
|
|
fprintf(fd, "T PO WebShell Seq Page Page# Rect\n");
|
|
|
|
}
|
|
|
|
PRInt32 cnt = aPO->mKids.Count();
|
|
|
|
for (PRInt32 i=0;i<cnt;i++) {
|
|
|
|
PrintObject* po = (PrintObject*)aPO->mKids.ElementAt(i);
|
|
|
|
NS_ASSERTION(po, "PrintObject can't be null!");
|
|
|
|
for (PRInt32 k=0;k<aLevel;k++) fprintf(fd, " ");
|
|
|
|
fprintf(fd, "%s %p %p %p %p %d %d,%d,%d,%d\n", types[po->mFrameType], po, po->mWebShell, po->mSeqFrame,
|
|
|
|
po->mPageFrame, po->mPageNum, po->mRect.x, po->mRect.y, po->mRect.width, po->mRect.height);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2001-11-03 17:59:39 +03:00
|
|
|
static void GetDocTitleAndURL(PrintObject* aPO, char *& aDocStr, char *& aURLStr)
|
|
|
|
{
|
|
|
|
aDocStr = nsnull;
|
|
|
|
aURLStr = nsnull;
|
|
|
|
|
2002-03-27 06:02:42 +03:00
|
|
|
PRUnichar * mozillaDoc = ToNewUnicode(NS_LITERAL_STRING("Mozilla Document"));
|
2002-02-12 16:33:39 +03:00
|
|
|
PRUnichar * docTitleStr;
|
|
|
|
PRUnichar * docURLStr;
|
2002-03-27 06:02:42 +03:00
|
|
|
DocumentViewerImpl::GetDisplayTitleAndURL(aPO, nsnull, mozillaDoc, &docTitleStr, &docURLStr, DocumentViewerImpl::eDocTitleDefURLDoc);
|
2002-02-12 16:33:39 +03:00
|
|
|
|
2001-11-03 17:59:39 +03:00
|
|
|
if (docTitleStr) {
|
|
|
|
nsAutoString strDocTitle(docTitleStr);
|
|
|
|
aDocStr = ToNewCString(strDocTitle);
|
|
|
|
nsMemory::Free(docTitleStr);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (docURLStr) {
|
|
|
|
nsAutoString strURL(docURLStr);
|
|
|
|
aURLStr = ToNewCString(strURL);
|
|
|
|
nsMemory::Free(docURLStr);
|
|
|
|
}
|
2002-03-27 06:02:42 +03:00
|
|
|
|
|
|
|
if (mozillaDoc) {
|
|
|
|
nsMemory::Free(mozillaDoc);
|
|
|
|
}
|
2001-11-03 17:59:39 +03:00
|
|
|
}
|
|
|
|
|
2001-04-12 17:04:29 +04:00
|
|
|
static void DumpPrintObjectsTreeLayout(PrintObject * aPO,
|
|
|
|
nsIDeviceContext * aDC,
|
|
|
|
int aLevel= 0, FILE * aFD = nsnull)
|
|
|
|
{
|
|
|
|
NS_ASSERTION(aPO, "Pointer is null!");
|
|
|
|
NS_ASSERTION(aDC, "Pointer is null!");
|
|
|
|
|
|
|
|
char * types[] = {"DC", "FR", "IF", "FS"};
|
|
|
|
FILE * fd = nsnull;
|
|
|
|
if (aLevel == 0) {
|
|
|
|
fd = fopen("tree_layout.txt", "w");
|
|
|
|
fprintf(fd, "DocTree\n***************************************************\n");
|
|
|
|
fprintf(fd, "***************************************************\n");
|
|
|
|
fprintf(fd, "T PO WebShell Seq Page Page# Rect\n");
|
|
|
|
} else {
|
|
|
|
fd = aFD;
|
|
|
|
}
|
|
|
|
if (fd) {
|
|
|
|
nsIFrame* rootFrame = nsnull;
|
2001-08-01 07:15:50 +04:00
|
|
|
if (aPO->mPresShell) {
|
2001-04-12 17:04:29 +04:00
|
|
|
aPO->mPresShell->GetRootFrame(&rootFrame);
|
|
|
|
}
|
|
|
|
for (PRInt32 k=0;k<aLevel;k++) fprintf(fd, " ");
|
|
|
|
fprintf(fd, "%s %p %p %p %p %d %d,%d,%d,%d\n", types[aPO->mFrameType], aPO, aPO->mWebShell, aPO->mSeqFrame,
|
|
|
|
aPO->mPageFrame, aPO->mPageNum, aPO->mRect.x, aPO->mRect.y, aPO->mRect.width, aPO->mRect.height);
|
2002-02-20 06:21:25 +03:00
|
|
|
if (aPO->IsPrintable()) {
|
|
|
|
char * docStr;
|
|
|
|
char * urlStr;
|
|
|
|
GetDocTitleAndURL(aPO, docStr, urlStr);
|
|
|
|
DumpLayoutData(docStr, urlStr, aPO->mPresContext, aDC, rootFrame, aPO->mWebShell, fd);
|
|
|
|
if (docStr) nsMemory::Free(docStr);
|
|
|
|
if (urlStr) nsMemory::Free(urlStr);
|
|
|
|
}
|
2001-04-12 17:04:29 +04:00
|
|
|
fprintf(fd, "<***************************************************>\n");
|
|
|
|
|
|
|
|
PRInt32 cnt = aPO->mKids.Count();
|
|
|
|
for (PRInt32 i=0;i<cnt;i++) {
|
|
|
|
PrintObject* po = (PrintObject*)aPO->mKids.ElementAt(i);
|
|
|
|
NS_ASSERTION(po, "PrintObject can't be null!");
|
|
|
|
DumpPrintObjectsTreeLayout(po, aDC, aLevel+1, fd);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (aLevel == 0 && fd) {
|
2001-01-27 17:09:34 +03:00
|
|
|
fclose(fd);
|
|
|
|
}
|
2001-04-12 17:04:29 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
static void DumpPrintObjectsListStart(char * aStr, nsVoidArray * aDocList, FILE* aFD = nsnull)
|
|
|
|
{
|
|
|
|
NS_ASSERTION(aStr, "Pointer is null!");
|
|
|
|
NS_ASSERTION(aDocList, "Pointer is null!");
|
|
|
|
|
|
|
|
FILE * fd = aFD?aFD:stdout;
|
|
|
|
fprintf(fd, "%s\n", aStr);
|
|
|
|
DumpPrintObjectsList(aDocList, aFD);
|
2001-01-27 17:09:34 +03:00
|
|
|
}
|
|
|
|
|
2001-04-12 17:04:29 +04:00
|
|
|
#define DUMP_DOC_LIST(_title) DumpPrintObjectsListStart((_title), mPrt->mPrintDocList, mPrt->mDebugFD);
|
|
|
|
#define DUMP_DOC_TREE DumpPrintObjectsTree(mPrt->mPrintObject);
|
|
|
|
#define DUMP_DOC_TREELAYOUT DumpPrintObjectsTreeLayout(mPrt->mPrintObject, mPrt->mPrintDC);
|
|
|
|
#else
|
2001-08-06 06:27:43 +04:00
|
|
|
#define DUMP_DOC_LIST(_title)
|
2001-04-12 17:04:29 +04:00
|
|
|
#define DUMP_DOC_TREE
|
|
|
|
#define DUMP_DOC_TREELAYOUT
|
2001-01-27 17:09:34 +03:00
|
|
|
#endif
|
2001-04-12 17:04:29 +04:00
|
|
|
|
2001-01-27 17:09:34 +03:00
|
|
|
//---------------------------------------------------------------
|
|
|
|
//---------------------------------------------------------------
|
|
|
|
//-- End of debug helper routines
|
|
|
|
//---------------------------------------------------------------
|
|
|
|
//---------------------------------------------------------------
|
|
|
|
|
|
|
|
/** ---------------------------------------------------
|
|
|
|
* Giving a child frame it searches "up" the tree until it
|
|
|
|
* finds a "Page" frame.
|
|
|
|
*/
|
|
|
|
static nsIFrame * GetPageFrame(nsIFrame * aFrame)
|
|
|
|
{
|
|
|
|
nsIFrame * frame = aFrame;
|
|
|
|
while (frame != nsnull) {
|
|
|
|
nsCOMPtr<nsIAtom> type;
|
|
|
|
frame->GetFrameType(getter_AddRefs(type));
|
|
|
|
if (type.get() == nsLayoutAtoms::pageFrame) {
|
|
|
|
return frame;
|
|
|
|
}
|
|
|
|
frame->GetParent(&frame);
|
|
|
|
}
|
|
|
|
return nsnull;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/** ---------------------------------------------------
|
|
|
|
* Find by checking content's tag type
|
|
|
|
*/
|
|
|
|
static nsIFrame * FindFrameByType(nsIPresContext* aPresContext,
|
|
|
|
nsIFrame * aParentFrame,
|
|
|
|
nsIAtom * aType,
|
|
|
|
nsRect& aRect,
|
|
|
|
nsRect& aChildRect)
|
|
|
|
{
|
2001-04-12 17:04:29 +04:00
|
|
|
NS_ASSERTION(aPresContext, "Pointer is null!");
|
|
|
|
NS_ASSERTION(aParentFrame, "Pointer is null!");
|
|
|
|
NS_ASSERTION(aType, "Pointer is null!");
|
|
|
|
|
2001-01-27 17:09:34 +03:00
|
|
|
nsIFrame * child;
|
|
|
|
nsRect rect;
|
|
|
|
aParentFrame->GetRect(rect);
|
|
|
|
aRect.x += rect.x;
|
|
|
|
aRect.y += rect.y;
|
|
|
|
aParentFrame->FirstChild(aPresContext, nsnull, &child);
|
|
|
|
while (child != nsnull) {
|
|
|
|
nsCOMPtr<nsIContent> content;
|
|
|
|
child->GetContent(getter_AddRefs(content));
|
|
|
|
if (content) {
|
|
|
|
nsCOMPtr<nsIAtom> type;
|
|
|
|
content->GetTag(*getter_AddRefs(type));
|
|
|
|
if (type.get() == aType) {
|
|
|
|
nsRect r;
|
|
|
|
child->GetRect(r);
|
|
|
|
aChildRect.SetRect(aRect.x + r.x, aRect.y + r.y, r.width, r.height);
|
|
|
|
aRect.x -= rect.x;
|
|
|
|
aRect.y -= rect.y;
|
|
|
|
return child;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
nsIFrame * fndFrame = FindFrameByType(aPresContext, child, aType, aRect, aChildRect);
|
|
|
|
if (fndFrame != nsnull) {
|
|
|
|
return fndFrame;
|
|
|
|
}
|
|
|
|
child->GetNextSibling(&child);
|
|
|
|
}
|
|
|
|
aRect.x -= rect.x;
|
|
|
|
aRect.y -= rect.y;
|
|
|
|
return nsnull;
|
|
|
|
}
|
|
|
|
|
|
|
|
/** ---------------------------------------------------
|
|
|
|
* Find by checking frames type
|
|
|
|
*/
|
|
|
|
static nsresult FindSelectionBounds(nsIPresContext* aPresContext,
|
|
|
|
nsIRenderingContext& aRC,
|
|
|
|
nsIFrame * aParentFrame,
|
|
|
|
nsRect& aRect,
|
|
|
|
nsIFrame *& aStartFrame,
|
|
|
|
nsRect& aStartRect,
|
|
|
|
nsIFrame *& aEndFrame,
|
|
|
|
nsRect& aEndRect)
|
|
|
|
{
|
2001-04-12 17:04:29 +04:00
|
|
|
NS_ASSERTION(aPresContext, "Pointer is null!");
|
|
|
|
NS_ASSERTION(aParentFrame, "Pointer is null!");
|
|
|
|
|
2001-01-27 17:09:34 +03:00
|
|
|
nsIFrame * child;
|
|
|
|
aParentFrame->FirstChild(aPresContext, nsnull, &child);
|
|
|
|
nsRect rect;
|
|
|
|
aParentFrame->GetRect(rect);
|
|
|
|
aRect.x += rect.x;
|
|
|
|
aRect.y += rect.y;
|
|
|
|
while (child != nsnull) {
|
|
|
|
nsFrameState state;
|
|
|
|
child->GetFrameState(&state);
|
|
|
|
// only leaf frames have this bit flipped
|
|
|
|
// then check the hard way
|
|
|
|
PRBool isSelected = (state & NS_FRAME_SELECTED_CONTENT) == NS_FRAME_SELECTED_CONTENT;
|
|
|
|
if (isSelected) {
|
|
|
|
if (NS_FAILED(child->IsVisibleForPainting(aPresContext, aRC, PR_TRUE, &isSelected))) {
|
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (isSelected) {
|
|
|
|
nsRect r;
|
|
|
|
child->GetRect(r);
|
|
|
|
if (aStartFrame == nsnull) {
|
|
|
|
aStartFrame = child;
|
|
|
|
aStartRect.SetRect(aRect.x + r.x, aRect.y + r.y, r.width, r.height);
|
|
|
|
} else {
|
|
|
|
child->GetRect(r);
|
|
|
|
aEndFrame = child;
|
|
|
|
aEndRect.SetRect(aRect.x + r.x, aRect.y + r.y, r.width, r.height);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
FindSelectionBounds(aPresContext, aRC, child, aRect, aStartFrame, aStartRect, aEndFrame, aEndRect);
|
|
|
|
child->GetNextSibling(&child);
|
|
|
|
}
|
|
|
|
aRect.x -= rect.x;
|
|
|
|
aRect.y -= rect.y;
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
/** ---------------------------------------------------
|
|
|
|
* This method finds the starting and ending page numbers
|
|
|
|
* of the selection and also returns rect for each where
|
|
|
|
* the x,y of the rect is relative to the very top of the
|
|
|
|
* frame tree (absolutely positioned)
|
|
|
|
*/
|
|
|
|
static nsresult GetPageRangeForSelection(nsIPresShell * aPresShell,
|
|
|
|
nsIPresContext* aPresContext,
|
|
|
|
nsIRenderingContext& aRC,
|
|
|
|
nsISelection* aSelection,
|
|
|
|
nsIPageSequenceFrame* aPageSeqFrame,
|
|
|
|
nsIFrame** aStartFrame,
|
|
|
|
PRInt32& aStartPageNum,
|
|
|
|
nsRect& aStartRect,
|
|
|
|
nsIFrame** aEndFrame,
|
|
|
|
PRInt32& aEndPageNum,
|
|
|
|
nsRect& aEndRect)
|
|
|
|
{
|
2001-04-12 17:04:29 +04:00
|
|
|
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!");
|
|
|
|
|
2001-01-27 17:09:34 +03:00
|
|
|
nsIFrame * seqFrame;
|
2001-08-01 07:15:50 +04:00
|
|
|
if (NS_FAILED(CallQueryInterface(aPageSeqFrame, &seqFrame))) {
|
2001-01-27 17:09:34 +03:00
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
}
|
|
|
|
|
|
|
|
nsIFrame * startFrame = nsnull;
|
|
|
|
nsIFrame * endFrame = nsnull;
|
|
|
|
nsRect rect;
|
|
|
|
seqFrame->GetRect(rect);
|
|
|
|
|
|
|
|
// start out with the sequence frame and search the entire frame tree
|
|
|
|
// capturing the the starting and ending child frames of the selection
|
|
|
|
// and their rects
|
|
|
|
FindSelectionBounds(aPresContext, aRC, seqFrame, rect, startFrame, aStartRect, endFrame, aEndRect);
|
|
|
|
|
2001-04-12 17:04:29 +04:00
|
|
|
#ifdef DEBUG_rodsX
|
2001-01-27 17:09:34 +03:00
|
|
|
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
|
|
|
|
startPageFrame = GetPageFrame(startFrame);
|
|
|
|
endPageFrame = startPageFrame;
|
|
|
|
aEndRect = aStartRect;
|
|
|
|
} else {
|
|
|
|
startPageFrame = GetPageFrame(startFrame);
|
|
|
|
endPageFrame = GetPageFrame(endFrame);
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
}
|
|
|
|
|
2001-04-12 17:04:29 +04:00
|
|
|
#ifdef DEBUG_rodsX
|
2001-01-27 17:09:34 +03:00
|
|
|
printf("Start Page: %p\n", startPageFrame);
|
|
|
|
printf("End Page: %p\n", endPageFrame);
|
|
|
|
|
|
|
|
// dump all the pages and their pointers
|
|
|
|
{
|
|
|
|
PRInt32 pageNum = 1;
|
|
|
|
nsIFrame * child;
|
|
|
|
seqFrame->FirstChild(aPresContext, nsnull, &child);
|
|
|
|
while (child != nsnull) {
|
|
|
|
printf("Page: %d - %p\n", pageNum, child);
|
|
|
|
pageNum++;
|
|
|
|
child->GetNextSibling(&child);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
// Now that we have the page frames
|
|
|
|
// find out what the page numbers are for each frame
|
|
|
|
PRInt32 pageNum = 1;
|
|
|
|
nsIFrame * page;
|
|
|
|
seqFrame->FirstChild(aPresContext, nsnull, &page);
|
|
|
|
while (page != nsnull) {
|
|
|
|
if (page == startPageFrame) {
|
|
|
|
aStartPageNum = pageNum;
|
|
|
|
}
|
|
|
|
if (page == endPageFrame) {
|
|
|
|
aEndPageNum = pageNum;
|
|
|
|
}
|
|
|
|
pageNum++;
|
|
|
|
page->GetNextSibling(&page);
|
|
|
|
}
|
|
|
|
|
2001-04-12 17:04:29 +04:00
|
|
|
#ifdef DEBUG_rodsX
|
2001-01-27 17:09:34 +03:00
|
|
|
printf("Start Page No: %d\n", aStartPageNum);
|
|
|
|
printf("End Page No: %d\n", aEndPageNum);
|
|
|
|
#endif
|
|
|
|
|
|
|
|
*aStartFrame = startPageFrame;
|
|
|
|
*aEndFrame = endPageFrame;
|
|
|
|
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
//-------------------------------------------------------
|
2001-02-07 02:03:17 +03:00
|
|
|
PRBool
|
2001-04-12 17:04:29 +04:00
|
|
|
DocumentViewerImpl::IsParentAFrameSet(nsIWebShell * aParent)
|
1999-05-14 18:40:59 +04:00
|
|
|
{
|
2001-04-12 17:04:29 +04:00
|
|
|
NS_ASSERTION(aParent, "Pointer is null!");
|
|
|
|
|
2000-09-22 18:42:13 +04:00
|
|
|
// See if if the incoming doc is the root document
|
|
|
|
nsCOMPtr<nsIDocShellTreeItem> parentAsItem(do_QueryInterface(aParent));
|
2001-04-12 17:04:29 +04:00
|
|
|
if (!parentAsItem) return PR_FALSE;
|
2000-09-22 18:42:13 +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
|
2001-04-12 17:04:29 +04:00
|
|
|
PRBool isFrameSet = PR_FALSE;
|
2000-09-22 18:42:13 +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
|
2001-04-12 17:04:29 +04:00
|
|
|
nsCOMPtr<nsIPresShell> shell;
|
|
|
|
mPresContext->GetShell(getter_AddRefs(shell));
|
|
|
|
if (shell) {
|
|
|
|
nsCOMPtr<nsIDocument> doc;
|
|
|
|
shell->GetDocument(getter_AddRefs(doc));
|
|
|
|
if (doc) {
|
2001-06-20 07:27:48 +04:00
|
|
|
nsCOMPtr<nsIContent> rootContent;
|
|
|
|
doc->GetRootContent(getter_AddRefs(rootContent));
|
2001-04-12 17:04:29 +04:00
|
|
|
if (rootContent) {
|
|
|
|
if (NS_SUCCEEDED(FindFrameSetWithIID(rootContent, NS_GET_IID(nsIDOMHTMLFrameSetElement)))) {
|
|
|
|
isFrameSet = PR_TRUE;
|
2000-09-22 18:42:13 +04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2001-04-12 17:04:29 +04:00
|
|
|
}
|
|
|
|
return isFrameSet;
|
|
|
|
}
|
|
|
|
|
|
|
|
//-------------------------------------------------------
|
|
|
|
PRBool
|
|
|
|
DocumentViewerImpl::IsWebShellAFrameSet(nsIWebShell * aWebShell)
|
|
|
|
{
|
|
|
|
NS_ASSERTION(aWebShell, "Pointer is null!");
|
|
|
|
|
|
|
|
PRBool doesContainFrameSet = PR_FALSE;
|
|
|
|
nsCOMPtr<nsIPresShell> presShell;
|
|
|
|
nsCOMPtr<nsIContent> rootContent;
|
|
|
|
GetPresShellAndRootContent(aWebShell, getter_AddRefs(presShell), getter_AddRefs(rootContent));
|
|
|
|
if (rootContent) {
|
|
|
|
if (NS_SUCCEEDED(FindFrameSetWithIID(rootContent, NS_GET_IID(nsIDOMHTMLFrameSetElement)))) {
|
|
|
|
doesContainFrameSet = PR_TRUE;
|
|
|
|
}
|
|
|
|
}
|
2001-02-07 02:03:17 +03:00
|
|
|
return doesContainFrameSet;
|
|
|
|
}
|
|
|
|
|
|
|
|
//-------------------------------------------------------
|
2001-04-12 17:04:29 +04:00
|
|
|
void
|
|
|
|
DocumentViewerImpl::GetWebShellTitleAndURL(nsIWebShell * aWebShell,
|
|
|
|
PRUnichar** aTitle,
|
|
|
|
PRUnichar** aURLStr)
|
2001-02-07 02:03:17 +03:00
|
|
|
{
|
2001-04-12 17:04:29 +04:00
|
|
|
NS_ASSERTION(aWebShell, "Pointer is null!");
|
|
|
|
NS_ASSERTION(aTitle, "Pointer is null!");
|
|
|
|
NS_ASSERTION(aURLStr, "Pointer is null!");
|
2001-02-07 02:03:17 +03:00
|
|
|
|
2001-04-12 17:04:29 +04:00
|
|
|
*aTitle = nsnull;
|
|
|
|
*aURLStr = nsnull;
|
2001-02-07 02:03:17 +03:00
|
|
|
|
2002-02-12 16:33:39 +03:00
|
|
|
// now get the actual values if the PrintSettings didn't have any
|
|
|
|
nsCOMPtr<nsIDocShell> docShell(do_QueryInterface(aWebShell));
|
|
|
|
if (!docShell) return;
|
|
|
|
|
|
|
|
nsCOMPtr<nsIPresShell> presShell;
|
|
|
|
docShell->GetPresShell(getter_AddRefs(presShell));
|
|
|
|
if (!presShell) return;
|
|
|
|
|
|
|
|
nsCOMPtr<nsIDocument> doc;
|
|
|
|
presShell->GetDocument(getter_AddRefs(doc));
|
|
|
|
if (!doc) return;
|
|
|
|
|
|
|
|
const nsString* docTitle = doc->GetDocumentTitle();
|
|
|
|
if (docTitle && !docTitle->IsEmpty()) {
|
|
|
|
*aTitle = ToNewUnicode(*docTitle);
|
|
|
|
}
|
|
|
|
|
|
|
|
nsCOMPtr<nsIURI> url;
|
|
|
|
doc->GetDocumentURL(getter_AddRefs(url));
|
|
|
|
if (!url) return;
|
|
|
|
|
2002-03-06 10:48:55 +03:00
|
|
|
nsCAutoString urlCStr;
|
|
|
|
url->GetSpec(urlCStr);
|
|
|
|
*aURLStr = ToNewUnicode(NS_ConvertUTF8toUCS2(urlCStr));
|
2002-02-12 16:33:39 +03: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
|
2002-03-27 06:02:42 +03:00
|
|
|
DocumentViewerImpl::GetDisplayTitleAndURL(PrintObject* aPO,
|
2002-02-12 16:33:39 +03:00
|
|
|
nsIPrintSettings* aPrintSettings,
|
2002-03-27 06:02:42 +03:00
|
|
|
const PRUnichar* aBrandName,
|
2002-02-12 16:33:39 +03:00
|
|
|
PRUnichar** aTitle,
|
|
|
|
PRUnichar** aURLStr,
|
|
|
|
eDocTitleDefault aDefType)
|
|
|
|
{
|
2002-03-27 06:02:42 +03:00
|
|
|
NS_ASSERTION(aBrandName, "Pointer is null!");
|
2002-02-12 16:33:39 +03:00
|
|
|
NS_ASSERTION(aPO, "Pointer is null!");
|
|
|
|
NS_ASSERTION(aTitle, "Pointer is null!");
|
|
|
|
NS_ASSERTION(aURLStr, "Pointer is null!");
|
|
|
|
|
|
|
|
*aTitle = nsnull;
|
|
|
|
*aURLStr = nsnull;
|
|
|
|
|
2002-01-08 04:17:40 +03: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;
|
2002-02-12 16:33:39 +03:00
|
|
|
if (aPrintSettings) {
|
2002-01-08 04:17:40 +03:00
|
|
|
aPrintSettings->GetTitle(&docTitleStrPS);
|
|
|
|
aPrintSettings->GetDocURL(&docURLStrPS);
|
|
|
|
|
2002-02-12 16:33:39 +03:00
|
|
|
if (docTitleStrPS && nsCRT::strlen(docTitleStrPS) > 0) {
|
2002-01-08 04:17:40 +03:00
|
|
|
*aTitle = docTitleStrPS;
|
|
|
|
}
|
|
|
|
|
2002-02-12 16:33:39 +03:00
|
|
|
if (docURLStrPS && nsCRT::strlen(docURLStrPS) > 0) {
|
2002-01-08 04:17:40 +03:00
|
|
|
*aURLStr = docURLStrPS;
|
|
|
|
}
|
|
|
|
|
|
|
|
// short circut
|
2002-02-12 16:33:39 +03:00
|
|
|
if (docTitleStrPS && docURLStrPS) {
|
2002-01-08 04:17:40 +03:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2002-02-12 16:33:39 +03:00
|
|
|
if (!docURLStrPS) {
|
|
|
|
if (aPO->mDocURL) {
|
|
|
|
*aURLStr = nsCRT::strdup(aPO->mDocURL);
|
|
|
|
}
|
|
|
|
}
|
2001-04-12 17:04:29 +04:00
|
|
|
|
2002-02-12 16:33:39 +03:00
|
|
|
if (!docTitleStrPS) {
|
|
|
|
if (aPO->mDocTitle) {
|
|
|
|
*aTitle = nsCRT::strdup(aPO->mDocTitle);
|
|
|
|
} else {
|
|
|
|
switch (aDefType) {
|
|
|
|
case eDocTitleDefBlank: *aTitle = ToNewUnicode(NS_LITERAL_STRING(""));
|
|
|
|
break;
|
|
|
|
|
2002-03-27 06:02:42 +03:00
|
|
|
case eDocTitleDefDocument: if (aBrandName) *aTitle = nsCRT::strdup(aBrandName);
|
2002-02-12 16:33:39 +03:00
|
|
|
break;
|
|
|
|
|
|
|
|
case eDocTitleDefURLDoc:
|
|
|
|
if (*aURLStr) {
|
|
|
|
*aTitle = nsCRT::strdup(*aURLStr);
|
|
|
|
} else {
|
2002-03-27 06:02:42 +03:00
|
|
|
if (aBrandName) *aTitle = nsCRT::strdup(aBrandName);
|
2001-04-12 17:04:29 +04:00
|
|
|
}
|
2002-02-12 16:33:39 +03:00
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
} // switch
|
2001-02-07 02:03:17 +03:00
|
|
|
}
|
|
|
|
}
|
2002-02-12 16:33:39 +03:00
|
|
|
|
2001-02-07 02:03:17 +03:00
|
|
|
}
|
|
|
|
|
2001-03-27 15:56:03 +04:00
|
|
|
|
|
|
|
//-------------------------------------------------------
|
|
|
|
PRBool
|
2001-04-12 17:04:29 +04:00
|
|
|
DocumentViewerImpl::DonePrintingPages(PrintObject* aPO)
|
2001-03-27 15:56:03 +04:00
|
|
|
{
|
2001-04-12 17:04:29 +04:00
|
|
|
//NS_ASSERTION(aPO, "Pointer is null!");
|
2001-10-06 18:07:28 +04:00
|
|
|
PRINT_DEBUG_MSG3("****** In DV::DonePrintingPages PO: %p (%s)\n", aPO, aPO?gFrameTypesStr[aPO->mFrameType]:"");
|
2001-03-27 15:56:03 +04:00
|
|
|
|
2001-04-12 17:04:29 +04:00
|
|
|
if (aPO != nsnull) {
|
|
|
|
aPO->mHasBeenPrinted = PR_TRUE;
|
|
|
|
nsresult rv;
|
|
|
|
PRBool didPrint = PrintDocContent(mPrt->mPrintObject, rv);
|
|
|
|
if (NS_SUCCEEDED(rv) && didPrint) {
|
|
|
|
PRINT_DEBUG_MSG4("****** In DV::DonePrintingPages PO: %p (%s) didPrint:%s (Not Done Printing)\n", aPO, gFrameTypesStr[aPO->mFrameType], PRT_YESNO(didPrint));
|
|
|
|
return PR_FALSE;
|
|
|
|
}
|
2001-03-27 15:56:03 +04:00
|
|
|
}
|
|
|
|
|
2001-04-12 17:04:29 +04:00
|
|
|
DoProgressForAsIsFrames();
|
|
|
|
DoProgressForSeparateFrames();
|
2001-03-27 15:56:03 +04:00
|
|
|
|
2001-11-03 17:59:39 +03:00
|
|
|
mIsDoingPrinting = PR_FALSE;
|
2001-04-12 17:04:29 +04:00
|
|
|
delete mPrt;
|
|
|
|
mPrt = nsnull;
|
2001-03-27 15:56:03 +04:00
|
|
|
|
2001-08-06 06:27:43 +04:00
|
|
|
NS_IF_RELEASE(mPagePrintTimer);
|
|
|
|
|
2001-03-27 15:56:03 +04:00
|
|
|
return PR_TRUE;
|
|
|
|
}
|
|
|
|
|
|
|
|
//-------------------------------------------------------
|
|
|
|
PRBool
|
2002-01-01 15:58:53 +03:00
|
|
|
DocumentViewerImpl::PrintPage(nsIPresContext* aPresContext,
|
|
|
|
nsIPrintSettings* aPrintSettings,
|
2002-02-12 16:33:39 +03:00
|
|
|
PrintObject* aPO,
|
|
|
|
PRBool& aInRange)
|
2001-03-27 15:56:03 +04:00
|
|
|
{
|
2002-03-26 14:43:40 +03:00
|
|
|
NS_ASSERTION(aPresContext, "aPresContext is null!");
|
|
|
|
NS_ASSERTION(aPrintSettings, "aPrintSettings is null!");
|
|
|
|
NS_ASSERTION(aPO, "aPO is null!");
|
|
|
|
NS_ASSERTION(mPageSeqFrame, "mPageSeqFrame is null!");
|
|
|
|
NS_ASSERTION(mPrt, "mPrt is null!");
|
|
|
|
|
|
|
|
// Although these should NEVER be NULL
|
|
|
|
// This is added insurance, to make sure we don't crash in optimized builds
|
|
|
|
if (!mPrt || !aPresContext || !aPrintSettings || !aPO || !mPageSeqFrame) {
|
|
|
|
ShowPrintErrorDialog(NS_ERROR_FAILURE);
|
|
|
|
return PR_TRUE; // means we are done printing
|
|
|
|
}
|
2001-04-12 17:04:29 +04:00
|
|
|
|
|
|
|
PRINT_DEBUG_MSG1("-----------------------------------\n");
|
|
|
|
PRINT_DEBUG_MSG3("------ In DV::PrintPage PO: %p (%s)\n", aPO, gFrameTypesStr[aPO->mFrameType]);
|
|
|
|
|
2002-02-12 16:33:39 +03:00
|
|
|
PRBool isCancelled = PR_FALSE;
|
|
|
|
|
|
|
|
// Check setting to see if someone request it be cancelled (programatically)
|
|
|
|
aPrintSettings->GetIsCancelled(&isCancelled);
|
|
|
|
if (!isCancelled) {
|
|
|
|
// If not, see if the user has cancelled it
|
|
|
|
if (mPrt->mPrintProgress) {
|
|
|
|
mPrt->mPrintProgress->GetProcessCanceledByUser(&isCancelled);
|
2002-01-01 15:58:53 +03:00
|
|
|
}
|
|
|
|
}
|
2002-02-12 16:33:39 +03:00
|
|
|
|
|
|
|
// DO NOT allow the print job to be cancelled if it is Print FrameAsIs
|
|
|
|
// because it is only printing one page.
|
|
|
|
if (isCancelled) {
|
|
|
|
if (mPrt->mPrintFrameType == nsIPrintSettings::kFramesAsIs) {
|
2002-01-01 15:58:53 +03:00
|
|
|
aPrintSettings->SetIsCancelled(PR_FALSE);
|
2002-02-12 16:33:39 +03:00
|
|
|
} else {
|
|
|
|
aPrintSettings->SetIsCancelled(PR_TRUE);
|
2001-03-27 15:56:03 +04:00
|
|
|
return PR_TRUE;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
PRInt32 pageNum;
|
|
|
|
PRInt32 curPage;
|
|
|
|
PRInt32 endPage;
|
|
|
|
mPageSeqFrame->GetCurrentPageNum(&pageNum);
|
|
|
|
|
|
|
|
PRBool donePrinting = PR_FALSE;
|
|
|
|
PRBool isDoingPrintRange;
|
|
|
|
mPageSeqFrame->IsDoingPrintRange(&isDoingPrintRange);
|
|
|
|
if (isDoingPrintRange) {
|
|
|
|
PRInt32 fromPage;
|
|
|
|
PRInt32 toPage;
|
2001-04-12 17:04:29 +04:00
|
|
|
PRInt32 numPages;
|
2001-03-27 15:56:03 +04:00
|
|
|
mPageSeqFrame->GetPrintRange(&fromPage, &toPage);
|
2001-04-12 17:04:29 +04:00
|
|
|
mPageSeqFrame->GetNumPages(&numPages);
|
|
|
|
if (fromPage > numPages) {
|
|
|
|
return PR_TRUE;
|
|
|
|
}
|
|
|
|
if (toPage > numPages) {
|
|
|
|
toPage = numPages;
|
|
|
|
}
|
|
|
|
|
|
|
|
PRINT_DEBUG_MSG4("****** Printing Page %d printing from %d to page %d\n", pageNum, fromPage, toPage);
|
|
|
|
|
2001-03-27 15:56:03 +04:00
|
|
|
donePrinting = pageNum >= toPage;
|
2002-02-12 16:33:39 +03:00
|
|
|
aInRange = pageNum >= fromPage && pageNum <= toPage;
|
|
|
|
PRInt32 pageInc = pageNum - fromPage + 1;
|
|
|
|
curPage = pageInc >= 0?pageInc+1:0;
|
|
|
|
endPage = (toPage - fromPage)+1;
|
2001-03-27 15:56:03 +04:00
|
|
|
} else {
|
|
|
|
PRInt32 numPages;
|
|
|
|
mPageSeqFrame->GetNumPages(&numPages);
|
2001-04-12 17:04:29 +04:00
|
|
|
|
|
|
|
PRINT_DEBUG_MSG3("****** Printing Page %d of %d page(s)\n", pageNum, numPages);
|
|
|
|
|
2001-03-27 15:56:03 +04:00
|
|
|
donePrinting = pageNum >= numPages;
|
2002-02-12 16:33:39 +03:00
|
|
|
curPage = pageNum+1;
|
2001-03-27 15:56:03 +04:00
|
|
|
endPage = numPages;
|
2002-02-12 16:33:39 +03:00
|
|
|
aInRange = PR_TRUE;
|
2001-03-27 15:56:03 +04:00
|
|
|
}
|
|
|
|
|
2001-04-12 17:04:29 +04:00
|
|
|
// NOTE: mPrt->mPrintFrameType gets set to "kFramesAsIs" when a
|
|
|
|
// plain document contains IFrames, so we need to override that case here
|
2002-01-01 15:58:53 +03:00
|
|
|
if (mPrt->mPrintFrameType == nsIPrintSettings::kEachFrameSep) {
|
|
|
|
DoProgressForSeparateFrames();
|
|
|
|
|
|
|
|
} else if (mPrt->mPrintFrameType != nsIPrintSettings::kFramesAsIs ||
|
|
|
|
mPrt->mPrintObject->mFrameType == eDoc && aPO == mPrt->mPrintObject) {
|
2002-02-12 16:33:39 +03:00
|
|
|
PrintData::DoOnProgressChange(mPrt->mPrintProgressListeners, curPage, endPage);
|
2001-03-27 15:56:03 +04:00
|
|
|
}
|
|
|
|
|
2001-04-12 17:04:29 +04:00
|
|
|
// Set Clip when Printing "AsIs" or
|
|
|
|
// when printing an IFrame for SelectedFrame or EachFrame
|
|
|
|
PRBool setClip = PR_FALSE;
|
|
|
|
switch (mPrt->mPrintFrameType) {
|
2001-03-27 15:56:03 +04:00
|
|
|
|
2002-01-01 15:58:53 +03:00
|
|
|
case nsIPrintSettings::kFramesAsIs:
|
2001-04-12 17:04:29 +04:00
|
|
|
setClip = PR_TRUE;
|
|
|
|
break;
|
|
|
|
|
2002-01-01 15:58:53 +03:00
|
|
|
case nsIPrintSettings::kSelectedFrame:
|
2001-04-12 17:04:29 +04:00
|
|
|
if (aPO->mPrintAsIs) {
|
|
|
|
if (aPO->mFrameType == eIFrame) {
|
|
|
|
setClip = aPO != mPrt->mSelectedPO;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
2002-01-01 15:58:53 +03:00
|
|
|
case nsIPrintSettings::kEachFrameSep:
|
2001-04-12 17:04:29 +04:00
|
|
|
if (aPO->mPrintAsIs) {
|
|
|
|
if (aPO->mFrameType == eIFrame) {
|
|
|
|
setClip = PR_TRUE;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
} //switch
|
|
|
|
|
|
|
|
if (setClip) {
|
2002-02-12 16:33:39 +03:00
|
|
|
// Always set the clip x,y to zero because it isn't going to have any margins
|
|
|
|
aPO->mClipRect.x = 0;
|
|
|
|
aPO->mClipRect.y = 0;
|
2001-04-12 17:04:29 +04:00
|
|
|
mPageSeqFrame->SetClipRect(aPO->mPresContext, &aPO->mClipRect);
|
|
|
|
}
|
|
|
|
|
|
|
|
// Print the Page
|
2001-10-04 03:28:38 +04:00
|
|
|
// if a print job was cancelled externally, an EndPage or BeginPage may
|
|
|
|
// fail and the failure is passed back here.
|
|
|
|
// Returning PR_TRUE means we are done printing.
|
2002-02-12 16:33:39 +03:00
|
|
|
//
|
|
|
|
// When rv == NS_ERROR_ABORT, it means we want out of the
|
|
|
|
// print job without displaying any error messages
|
2002-01-08 04:17:40 +03:00
|
|
|
nsresult rv = mPageSeqFrame->PrintNextPage(aPresContext);
|
|
|
|
if (NS_FAILED(rv)) {
|
2002-02-12 16:33:39 +03:00
|
|
|
if (rv != NS_ERROR_ABORT) {
|
|
|
|
ShowPrintErrorDialog(rv);
|
|
|
|
mPrt->mIsAborted = PR_TRUE;
|
|
|
|
}
|
2001-10-04 03:28:38 +04:00
|
|
|
return PR_TRUE;
|
|
|
|
}
|
2001-04-12 17:04:29 +04:00
|
|
|
|
|
|
|
// Now see if any of the SubDocs are on this page
|
|
|
|
if (aPO->mPrintAsIs) {
|
|
|
|
nsIPageSequenceFrame * curPageSeq = mPageSeqFrame;
|
|
|
|
aPO->mHasBeenPrinted = PR_TRUE;
|
|
|
|
PRInt32 cnt = aPO->mKids.Count();
|
|
|
|
for (PRInt32 i=0;i<cnt;i++) {
|
|
|
|
PrintObject* po = (PrintObject*)aPO->mKids[i];
|
|
|
|
NS_ASSERTION(po, "PrintObject can't be null!");
|
2002-02-20 06:21:25 +03:00
|
|
|
if (po->IsPrintable()) {
|
|
|
|
// Now verify that SubDoc's PageNum matches the
|
|
|
|
// page num of it's parent doc
|
|
|
|
curPageSeq->GetCurrentPageNum(&pageNum);
|
|
|
|
nsIFrame* fr;
|
|
|
|
CallQueryInterface(curPageSeq, &fr);
|
|
|
|
|
|
|
|
if (fr == po->mSeqFrame && pageNum == po->mPageNum) {
|
|
|
|
PRBool donePrintingSubDoc;
|
|
|
|
DoPrint(po, PR_TRUE, donePrintingSubDoc); // synchronous printing, it changes the value mPageSeqFrame
|
|
|
|
po->mHasBeenPrinted = PR_TRUE;
|
|
|
|
}
|
2001-04-12 17:04:29 +04:00
|
|
|
}
|
|
|
|
} // while
|
|
|
|
mPageSeqFrame = curPageSeq;
|
|
|
|
|
|
|
|
if (aPO->mParent == nsnull ||
|
|
|
|
(aPO->mParent != nsnull && !aPO->mParent->mPrintAsIs && aPO->mPrintAsIs)) {
|
|
|
|
mPageSeqFrame->DoPageEnd(aPresContext);
|
|
|
|
}
|
|
|
|
|
|
|
|
// XXX this is because PrintAsIs for FrameSets reflows to two pages
|
|
|
|
// not sure why, but this needs to be fixed.
|
2002-01-01 15:58:53 +03:00
|
|
|
if (aPO->mFrameType == eFrameSet && mPrt->mPrintFrameType == nsIPrintSettings::kFramesAsIs) {
|
2001-04-12 17:04:29 +04:00
|
|
|
return PR_TRUE;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return donePrinting;
|
|
|
|
}
|
|
|
|
|
|
|
|
//-------------------------------------------------------
|
|
|
|
// Recursively finds a PrintObject that has the aWebShell
|
|
|
|
PrintObject * DocumentViewerImpl::FindPrintObjectByWS(PrintObject* aPO, nsIWebShell * aWebShell)
|
|
|
|
{
|
|
|
|
NS_ASSERTION(aPO, "Pointer is null!");
|
|
|
|
NS_ASSERTION(aWebShell, "Pointer is null!");
|
|
|
|
|
|
|
|
if (aPO->mWebShell == aWebShell) {
|
|
|
|
return aPO;
|
|
|
|
}
|
|
|
|
PRInt32 cnt = aPO->mKids.Count();
|
|
|
|
for (PRInt32 i=0;i<cnt;i++) {
|
|
|
|
PrintObject* kid = (PrintObject*)aPO->mKids.ElementAt(i);
|
|
|
|
NS_ASSERTION(kid, "PrintObject can't be null!");
|
|
|
|
PrintObject* po = FindPrintObjectByWS(kid, aWebShell);
|
|
|
|
if (po != nsnull) {
|
|
|
|
return po;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return nsnull;
|
|
|
|
}
|
|
|
|
|
|
|
|
//-------------------------------------------------------
|
|
|
|
// Recursively build a list of of sub documents to be printed
|
|
|
|
// that mirrors the document tree
|
|
|
|
void
|
|
|
|
DocumentViewerImpl::BuildDocTree(nsIDocShellTreeNode * aParentNode,
|
|
|
|
nsVoidArray * aDocList,
|
|
|
|
PrintObject * aPO)
|
|
|
|
{
|
|
|
|
NS_ASSERTION(aParentNode, "Pointer is null!");
|
|
|
|
NS_ASSERTION(aDocList, "Pointer is null!");
|
|
|
|
NS_ASSERTION(aPO, "Pointer is null!");
|
|
|
|
|
2002-02-12 16:33:39 +03:00
|
|
|
// Get the Doc and Title String
|
|
|
|
GetWebShellTitleAndURL(aPO->mWebShell, &aPO->mDocTitle, &aPO->mDocURL);
|
|
|
|
|
2001-04-12 17:04:29 +04:00
|
|
|
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) {
|
|
|
|
nsCOMPtr<nsIWebShell> childWebShell(do_QueryInterface(child));
|
|
|
|
nsCOMPtr<nsIDocShellTreeNode> childNode(do_QueryInterface(child));
|
|
|
|
PrintObject * po = new PrintObject;
|
|
|
|
po->mWebShell = childWebShell;
|
|
|
|
po->mParent = aPO;
|
|
|
|
aPO->mKids.AppendElement(po);
|
|
|
|
aDocList->AppendElement(po);
|
|
|
|
BuildDocTree(childNode, aDocList, po);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
//-------------------------------------------------------
|
|
|
|
// Recursively sets the PO items to be printed "As Is"
|
|
|
|
// from the given item down into the tree
|
|
|
|
void
|
|
|
|
DocumentViewerImpl::SetPrintAsIs(PrintObject* aPO, PRBool aAsIs)
|
|
|
|
{
|
|
|
|
NS_ASSERTION(aPO, "Pointer is null!");
|
|
|
|
|
|
|
|
aPO->mPrintAsIs = aAsIs;
|
|
|
|
for (PRInt32 i=0;i<aPO->mKids.Count();i++) {
|
|
|
|
SetPrintAsIs((PrintObject*)aPO->mKids[i], aAsIs);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
//-------------------------------------------------------
|
|
|
|
// Recursively sets all the PO items to be printed
|
|
|
|
// from the given item down into the tree
|
|
|
|
void
|
|
|
|
DocumentViewerImpl::SetPrintPO(PrintObject* aPO, PRBool aPrint)
|
|
|
|
{
|
|
|
|
NS_ASSERTION(aPO, "Pointer is null!");
|
|
|
|
|
|
|
|
aPO->mDontPrint = !aPrint;
|
|
|
|
for (PRInt32 i=0;i<aPO->mKids.Count();i++) {
|
|
|
|
SetPrintPO((PrintObject*)aPO->mKids[i], aPrint);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
//-------------------------------------------------------
|
|
|
|
// Finds the Page Frame and the absolute location on the page
|
|
|
|
// for a Sub document.
|
|
|
|
//
|
|
|
|
// NOTE: This MUST be done after the sub-doc has been laid out
|
|
|
|
// This is called by "MapSubDocFrameLocations"
|
|
|
|
//
|
2002-01-12 15:31:05 +03:00
|
|
|
nsresult
|
|
|
|
DocumentViewerImpl::CalcPageFrameLocation(nsIPresShell * aPresShell,
|
|
|
|
PrintObject* aPO)
|
2001-04-12 17:04:29 +04:00
|
|
|
{
|
|
|
|
NS_ASSERTION(aPresShell, "Pointer is null!");
|
|
|
|
NS_ASSERTION(aPO, "Pointer is null!");
|
|
|
|
|
|
|
|
if (aPO != nsnull && aPO->mContent != nsnull) {
|
|
|
|
|
|
|
|
// Find that frame for the sub-doc's content element
|
|
|
|
// in the parent document
|
2002-01-12 15:31:05 +03:00
|
|
|
// if it comes back null it probably has the style
|
|
|
|
// set to "display:none"
|
2001-04-12 17:04:29 +04:00
|
|
|
nsIFrame * frame;
|
|
|
|
aPresShell->GetPrimaryFrameFor(aPO->mContent, &frame);
|
2002-01-12 15:31:05 +03:00
|
|
|
if (frame == nsnull) {
|
|
|
|
aPO->mDontPrint = PR_TRUE;
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2001-04-12 17:04:29 +04:00
|
|
|
nsMargin borderPadding(0, 0, 0, 0);
|
|
|
|
frame->CalcBorderPadding(borderPadding);
|
|
|
|
|
|
|
|
// Calc absolute position of the frame all the way up
|
|
|
|
// to the SimpleSeq frame
|
|
|
|
nsRect rect;
|
|
|
|
frame->GetRect(rect);
|
|
|
|
rect.Deflate(borderPadding);
|
|
|
|
|
|
|
|
rect.x = 0;
|
|
|
|
rect.y = 0;
|
|
|
|
nsIFrame * parent = frame;
|
|
|
|
nsIFrame * pageFrame = nsnull;
|
|
|
|
nsIFrame * seqFrame = nsnull;
|
|
|
|
while (parent != nsnull) {
|
|
|
|
nsRect rr;
|
|
|
|
parent->GetRect(rr);
|
|
|
|
rect.x += rr.x;
|
|
|
|
rect.y += rr.y;
|
|
|
|
nsIFrame * temp = parent;
|
|
|
|
temp->GetParent(&parent);
|
|
|
|
// Keep a pointer to the Seq and Page frames
|
|
|
|
nsIPageSequenceFrame * sqf = nsnull;
|
|
|
|
if (parent != nsnull &&
|
2001-08-01 07:15:50 +04:00
|
|
|
NS_SUCCEEDED(CallQueryInterface(parent, &sqf)) && sqf) {
|
2001-04-12 17:04:29 +04:00
|
|
|
pageFrame = temp;
|
|
|
|
seqFrame = parent;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
NS_ASSERTION(seqFrame, "The sequencer frame can't be null!");
|
|
|
|
NS_ASSERTION(pageFrame, "The page frame can't be null!");
|
2002-01-12 15:31:05 +03:00
|
|
|
if (seqFrame == nsnull || pageFrame == nsnull) return NS_ERROR_FAILURE;
|
2001-04-12 17:04:29 +04:00
|
|
|
|
|
|
|
// Remember the Frame location information for later
|
|
|
|
aPO->mRect = rect;
|
|
|
|
aPO->mSeqFrame = seqFrame;
|
|
|
|
aPO->mPageFrame = pageFrame;
|
|
|
|
|
|
|
|
// Calc the Page No it is on
|
|
|
|
PRInt32 pageNum = 1;
|
|
|
|
nsIFrame * child;
|
|
|
|
seqFrame->FirstChild(aPO->mPresContext, nsnull, &child);
|
|
|
|
while (child != nsnull) {
|
|
|
|
if (pageFrame == child) {
|
|
|
|
aPO->mPageNum = pageNum;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
pageNum++;
|
|
|
|
child->GetNextSibling(&child);
|
|
|
|
} // while
|
|
|
|
}
|
2002-01-12 15:31:05 +03:00
|
|
|
return NS_OK;
|
2001-04-12 17:04:29 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
//-------------------------------------------------------
|
|
|
|
// This recusively walks the PO tree calculating the
|
|
|
|
// the page location and the absolute frame location for
|
|
|
|
// a sub-doc.
|
|
|
|
//
|
|
|
|
// NOTE: This MUST be done after the sub-doc has been laid out
|
|
|
|
// This is called by "ReflowDocList"
|
|
|
|
//
|
2002-01-12 15:31:05 +03:00
|
|
|
nsresult
|
2001-04-12 17:04:29 +04:00
|
|
|
DocumentViewerImpl::MapSubDocFrameLocations(PrintObject* aPO)
|
|
|
|
{
|
|
|
|
NS_ASSERTION(aPO, "Pointer is null!");
|
|
|
|
|
|
|
|
if (aPO->mParent != nsnull && aPO->mParent->mPresShell) {
|
2002-01-12 15:31:05 +03:00
|
|
|
nsresult rv = CalcPageFrameLocation(aPO->mParent->mPresShell, aPO);
|
|
|
|
if (NS_FAILED(rv)) return rv;
|
2001-04-12 17:04:29 +04:00
|
|
|
}
|
|
|
|
|
2001-08-01 07:15:50 +04:00
|
|
|
if (aPO->mPresShell) {
|
2001-04-12 17:04:29 +04:00
|
|
|
for (PRInt32 i=0;i<aPO->mKids.Count();i++) {
|
2002-01-12 15:31:05 +03:00
|
|
|
nsresult rv = MapSubDocFrameLocations((PrintObject*)aPO->mKids[i]);
|
|
|
|
if (NS_FAILED(rv)) return rv;
|
2001-04-12 17:04:29 +04:00
|
|
|
}
|
|
|
|
}
|
2002-01-12 15:31:05 +03:00
|
|
|
return NS_OK;
|
2001-04-12 17:04:29 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
//-------------------------------------------------------
|
|
|
|
// This method is key to the entire print mechanism.
|
|
|
|
//
|
|
|
|
// This "maps" or figures out which sub-doc represents a
|
|
|
|
// given Frame or IFrame in it's parent sub-doc.
|
|
|
|
//
|
|
|
|
// So the Mcontent pointer in the child sub-doc points to the
|
|
|
|
// content in the it's parent document, that caused it to be printed.
|
|
|
|
// This is used later to (after reflow) to find the absolute location
|
|
|
|
// of the sub-doc on it's parent's page frame so it can be
|
|
|
|
// printed in the correct location.
|
|
|
|
//
|
|
|
|
// This method recursvely "walks" the content for a document finding
|
|
|
|
// all the Frames and IFrames, then sets the "mFrameType" data member
|
|
|
|
// which tells us what type of PO we have
|
|
|
|
void
|
|
|
|
DocumentViewerImpl::MapContentForPO(PrintObject* aRootObject,
|
|
|
|
nsIPresShell* aPresShell,
|
|
|
|
nsIContent* aContent)
|
|
|
|
{
|
|
|
|
NS_ASSERTION(aRootObject, "Pointer is null!");
|
|
|
|
NS_ASSERTION(aPresShell, "Pointer is null!");
|
|
|
|
NS_ASSERTION(aContent, "Pointer is null!");
|
|
|
|
|
|
|
|
nsCOMPtr<nsISupports> supps;
|
|
|
|
aPresShell->GetSubShellFor(aContent, getter_AddRefs(supps));
|
|
|
|
if (supps) {
|
|
|
|
nsCOMPtr<nsIWebShell> webShell(do_QueryInterface(supps));
|
|
|
|
if (webShell) {
|
|
|
|
PrintObject * po = FindPrintObjectByWS(aRootObject, webShell);
|
|
|
|
NS_ASSERTION(po, "PO can't be null!");
|
|
|
|
|
|
|
|
if (po != nsnull) {
|
|
|
|
po->mContent = aContent;
|
|
|
|
|
|
|
|
// Now, "type" the PO
|
|
|
|
nsCOMPtr<nsIDOMHTMLFrameSetElement> frameSet(do_QueryInterface(aContent));
|
|
|
|
if (frameSet) {
|
|
|
|
po->mFrameType = eFrameSet;
|
|
|
|
} else {
|
|
|
|
nsCOMPtr<nsIDOMHTMLFrameElement> frame(do_QueryInterface(aContent));
|
|
|
|
if (frame) {
|
|
|
|
po->mFrameType = eFrame;
|
|
|
|
} else {
|
2002-03-07 15:44:57 +03:00
|
|
|
nsCOMPtr<nsIDOMHTMLObjectElement> objElement(do_QueryInterface(aContent));
|
2001-04-12 17:04:29 +04:00
|
|
|
nsCOMPtr<nsIDOMHTMLIFrameElement> iFrame(do_QueryInterface(aContent));
|
2002-03-07 15:44:57 +03:00
|
|
|
if (iFrame || objElement) {
|
2001-04-12 17:04:29 +04:00
|
|
|
po->mFrameType = eIFrame;
|
|
|
|
po->mPrintAsIs = PR_TRUE;
|
|
|
|
if (po->mParent) {
|
|
|
|
po->mParent->mPrintAsIs = PR_TRUE;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// walk children content
|
|
|
|
PRInt32 count;
|
|
|
|
aContent->ChildCount(count);
|
|
|
|
for (PRInt32 i=0;i<count;i++) {
|
|
|
|
nsIContent* child;
|
|
|
|
aContent->ChildAt(i, child);
|
|
|
|
MapContentForPO(aRootObject, aPresShell, child);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
//-------------------------------------------------------
|
|
|
|
// 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
|
|
|
|
DocumentViewerImpl::MapContentToWebShells(PrintObject* aRootPO,
|
|
|
|
PrintObject* aPO)
|
|
|
|
{
|
|
|
|
NS_ASSERTION(aRootPO, "Pointer is null!");
|
|
|
|
NS_ASSERTION(aPO, "Pointer is null!");
|
|
|
|
|
|
|
|
// Recursively walk the content from the root item
|
|
|
|
nsCOMPtr<nsIPresShell> presShell;
|
|
|
|
nsCOMPtr<nsIContent> rootContent;
|
|
|
|
GetPresShellAndRootContent(aPO->mWebShell, getter_AddRefs(presShell), getter_AddRefs(rootContent));
|
|
|
|
if (presShell && rootContent) {
|
|
|
|
MapContentForPO(aRootPO, presShell, rootContent);
|
|
|
|
}
|
|
|
|
|
|
|
|
// Continue recursively walking the chilren of this PO
|
|
|
|
for (PRInt32 i=0;i<aPO->mKids.Count();i++) {
|
|
|
|
MapContentToWebShells(aRootPO, (PrintObject*)aPO->mKids[i]);
|
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
//-------------------------------------------------------
|
|
|
|
// This gets ref counted copies of the PresShell and Root Content
|
|
|
|
// for a given nsIWebShell
|
|
|
|
void
|
|
|
|
DocumentViewerImpl::GetPresShellAndRootContent(nsIWebShell * aWebShell,
|
|
|
|
nsIPresShell** aPresShell,
|
|
|
|
nsIContent** aContent)
|
|
|
|
{
|
|
|
|
NS_ASSERTION(aWebShell, "Pointer is null!");
|
|
|
|
NS_ASSERTION(aPresShell, "Pointer is null!");
|
|
|
|
NS_ASSERTION(aContent, "Pointer is null!");
|
|
|
|
|
|
|
|
*aContent = nsnull;
|
|
|
|
*aPresShell = nsnull;
|
|
|
|
|
|
|
|
nsCOMPtr<nsIDocShell> docShell(do_QueryInterface(aWebShell));
|
|
|
|
|
|
|
|
nsCOMPtr<nsIPresShell> presShell(getter_AddRefs(GetPresShellFor(docShell)));
|
|
|
|
if (!presShell) return;
|
|
|
|
|
|
|
|
nsCOMPtr<nsIDocument> doc;
|
|
|
|
presShell->GetDocument(getter_AddRefs(doc));
|
|
|
|
if (!doc) return;
|
|
|
|
|
2001-06-20 07:27:48 +04:00
|
|
|
doc->GetRootContent(aContent); // this addrefs
|
2001-04-12 17:04:29 +04:00
|
|
|
*aPresShell = presShell.get();
|
|
|
|
NS_ADDREF(*aPresShell);
|
|
|
|
}
|
|
|
|
|
|
|
|
//-------------------------------------------------------
|
|
|
|
// Recursively sets the clip rect on all thchildren
|
|
|
|
void
|
|
|
|
DocumentViewerImpl::SetClipRect(PrintObject* aPO,
|
|
|
|
const nsRect& aClipRect,
|
|
|
|
nscoord aOffsetX,
|
|
|
|
nscoord aOffsetY,
|
|
|
|
PRBool aDoingSetClip)
|
|
|
|
{
|
|
|
|
NS_ASSERTION(aPO, "Pointer is null!");
|
|
|
|
|
|
|
|
nsRect clipRect = aClipRect;
|
|
|
|
if (aDoingSetClip) {
|
|
|
|
nscoord width = (aPO->mRect.x+aPO->mRect.width) > aClipRect.width?aClipRect.width-aPO->mRect.x:aPO->mRect.width;
|
|
|
|
nscoord height = (aPO->mRect.y+aPO->mRect.height) > aClipRect.height?aClipRect.height-aPO->mRect.y:aPO->mRect.height;
|
|
|
|
aPO->mClipRect.SetRect(aPO->mRect.x, aPO->mRect.y, width, height);
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
PRBool doClip = aDoingSetClip;
|
|
|
|
|
2001-04-13 16:32:18 +04:00
|
|
|
if (aPO->mFrameType == eFrame) {
|
2001-04-12 17:04:29 +04:00
|
|
|
if (aDoingSetClip) {
|
|
|
|
aPO->mClipRect.SetRect(aOffsetX, aOffsetY, aPO->mClipRect.width, aPO->mClipRect.height);
|
2001-04-13 16:32:18 +04:00
|
|
|
clipRect = aPO->mClipRect;
|
2002-01-01 15:58:53 +03:00
|
|
|
} else if (mPrt->mPrintFrameType == nsIPrintSettings::kFramesAsIs) {
|
2001-04-12 17:04:29 +04:00
|
|
|
aPO->mClipRect.SetRect(aOffsetX, aOffsetY, aPO->mRect.width, aPO->mRect.height);
|
2001-04-13 16:32:18 +04:00
|
|
|
clipRect = aPO->mClipRect;
|
2001-04-12 17:04:29 +04:00
|
|
|
doClip = PR_TRUE;
|
|
|
|
}
|
2001-04-13 16:32:18 +04:00
|
|
|
|
|
|
|
} else if (aPO->mFrameType == eIFrame) {
|
|
|
|
|
|
|
|
if (aDoingSetClip) {
|
|
|
|
aPO->mClipRect.SetRect(aOffsetX, aOffsetY, aPO->mClipRect.width, aPO->mClipRect.height);
|
|
|
|
clipRect = aPO->mClipRect;
|
|
|
|
} else {
|
|
|
|
|
2002-01-01 15:58:53 +03:00
|
|
|
if (mPrt->mPrintFrameType == nsIPrintSettings::kSelectedFrame) {
|
2001-04-13 16:32:18 +04:00
|
|
|
if (aPO->mParent && aPO->mParent == mPrt->mSelectedPO) {
|
|
|
|
aPO->mClipRect.SetRect(aOffsetX, aOffsetY, aPO->mRect.width, aPO->mRect.height);
|
|
|
|
clipRect = aPO->mClipRect;
|
|
|
|
doClip = PR_TRUE;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
aPO->mClipRect.SetRect(aOffsetX, aOffsetY, aPO->mRect.width, aPO->mRect.height);
|
|
|
|
clipRect = aPO->mClipRect;
|
|
|
|
doClip = PR_TRUE;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2001-04-12 17:04:29 +04:00
|
|
|
}
|
|
|
|
|
2001-04-13 16:32:18 +04:00
|
|
|
|
2001-04-12 17:04:29 +04:00
|
|
|
PRINT_DEBUG_MSG3("In DV::SetClipRect PO: %p (%9s) ", aPO, gFrameTypesStr[aPO->mFrameType]);
|
|
|
|
PRINT_DEBUG_MSG5("%5d,%5d,%5d,%5d\n", aPO->mClipRect.x, aPO->mClipRect.y,aPO->mClipRect.width, aPO->mClipRect.height);
|
|
|
|
|
|
|
|
PRInt32 cnt = aPO->mKids.Count();
|
|
|
|
for (PRInt32 i=0;i<cnt;i++) {
|
|
|
|
SetClipRect((PrintObject *)aPO->mKids[i], clipRect,
|
|
|
|
aOffsetX+aPO->mRect.x, aOffsetY+aPO->mRect.y, doClip);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
//-------------------------------------------------------
|
|
|
|
// Recursively reflow each sub-doc and then calc
|
|
|
|
// all the frame locations of the sub-docs
|
|
|
|
nsresult
|
2002-02-19 14:49:27 +03:00
|
|
|
DocumentViewerImpl::ReflowDocList(PrintObject* aPO, PRBool aSetPixelScale, PRBool aDoCalcShrink)
|
2001-04-12 17:04:29 +04:00
|
|
|
{
|
|
|
|
NS_ASSERTION(aPO, "Pointer is null!");
|
|
|
|
|
2002-02-19 14:49:27 +03: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
|
|
|
|
}
|
|
|
|
mPrt->mPrintDC->SetCanonicalPixelScale(ratio*mPrt->mOrigDCScale);
|
|
|
|
}
|
|
|
|
|
2001-04-12 17:04:29 +04:00
|
|
|
// Reflow the PO
|
2002-02-19 14:49:27 +03:00
|
|
|
if (NS_FAILED(ReflowPrintObject(aPO, aDoCalcShrink))) {
|
2001-04-12 17:04:29 +04:00
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Calc the absolute poistion of the frames
|
2002-01-12 15:31:05 +03:00
|
|
|
if (NS_FAILED(MapSubDocFrameLocations(aPO))) {
|
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
}
|
2001-04-12 17:04:29 +04:00
|
|
|
|
|
|
|
PRInt32 cnt = aPO->mKids.Count();
|
|
|
|
for (PRInt32 i=0;i<cnt;i++) {
|
2002-02-19 14:49:27 +03:00
|
|
|
if (NS_FAILED(ReflowDocList((PrintObject *)aPO->mKids[i], aSetPixelScale, aDoCalcShrink))) {
|
2001-04-12 17:04:29 +04:00
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
//-------------------------------------------------------
|
|
|
|
// Reflow a PrintObject
|
|
|
|
nsresult
|
2002-02-19 14:49:27 +03:00
|
|
|
DocumentViewerImpl::ReflowPrintObject(PrintObject * aPO, PRBool aDoCalcShrink)
|
2001-04-12 17:04:29 +04:00
|
|
|
{
|
|
|
|
NS_ASSERTION(aPO, "Pointer is null!");
|
|
|
|
|
|
|
|
// Now locate the nsIDocument for the WebShell
|
|
|
|
nsCOMPtr<nsIDocShell> docShell(do_QueryInterface(aPO->mWebShell));
|
|
|
|
NS_ASSERTION(docShell, "The DocShell can't be NULL!");
|
|
|
|
|
|
|
|
nsCOMPtr<nsIPresShell> wsPresShell;
|
|
|
|
docShell->GetPresShell(getter_AddRefs(wsPresShell));
|
|
|
|
NS_ASSERTION(wsPresShell, "The PresShell can't be NULL!");
|
|
|
|
|
|
|
|
nsCOMPtr<nsIDocument> document;
|
|
|
|
wsPresShell->GetDocument(getter_AddRefs(document));
|
|
|
|
|
|
|
|
// create the PresContext
|
2001-11-03 17:59:39 +03:00
|
|
|
PRBool containerIsSet = PR_FALSE;
|
2001-04-12 17:04:29 +04:00
|
|
|
nsresult rv;
|
2001-11-14 14:24:03 +03:00
|
|
|
if (mIsCreatingPrintPreview) {
|
2002-01-01 15:58:53 +03:00
|
|
|
nsCOMPtr<nsIPrintPreviewContext> printPreviewCon(do_CreateInstance(kPrintPreviewContextCID, &rv));
|
2001-11-03 17:59:39 +03:00
|
|
|
if (NS_FAILED(rv)) {
|
|
|
|
return rv;
|
|
|
|
}
|
2002-01-01 15:58:53 +03:00
|
|
|
aPO->mPresContext = do_QueryInterface(printPreviewCon);
|
|
|
|
printPreviewCon->SetPrintSettings(mPrt->mPrintSettings);
|
2001-04-12 17:04:29 +04:00
|
|
|
} else {
|
2001-11-03 17:59:39 +03:00
|
|
|
nsCOMPtr<nsIPrintContext> printcon(do_CreateInstance(kPrintContextCID, &rv));
|
2001-04-12 17:04:29 +04:00
|
|
|
if (NS_FAILED(rv)) {
|
|
|
|
return rv;
|
|
|
|
}
|
2002-01-01 15:58:53 +03:00
|
|
|
aPO->mPresContext = do_QueryInterface(printcon);
|
|
|
|
printcon->SetPrintSettings(mPrt->mPrintSettings);
|
2001-04-12 17:04:29 +04:00
|
|
|
}
|
|
|
|
|
2002-02-15 17:48:12 +03:00
|
|
|
|
|
|
|
// set the presentation context to the value in the print settings
|
|
|
|
PRBool printBGColors;
|
|
|
|
mPrt->mPrintSettings->GetPrintBGColors(&printBGColors);
|
|
|
|
aPO->mPresContext->SetBackgroundColorDraw(printBGColors);
|
|
|
|
mPrt->mPrintSettings->GetPrintBGImages(&printBGColors);
|
|
|
|
aPO->mPresContext->SetBackgroundImageDraw(printBGColors);
|
|
|
|
|
|
|
|
|
2001-04-12 17:04:29 +04:00
|
|
|
// init it with the DC
|
|
|
|
(aPO->mPresContext)->Init(mPrt->mPrintDocDC);
|
|
|
|
|
2001-08-01 07:15:50 +04:00
|
|
|
CreateStyleSet(document, getter_AddRefs(aPO->mStyleSet));
|
2001-04-12 17:04:29 +04:00
|
|
|
|
2002-01-17 18:04:54 +03:00
|
|
|
aPO->mViewManager = do_CreateInstance(kViewManagerCID, &rv);
|
2001-04-12 17:04:29 +04:00
|
|
|
if (NS_FAILED(rv)) {
|
|
|
|
return rv;
|
|
|
|
}
|
|
|
|
|
2002-01-17 18:04:54 +03:00
|
|
|
rv = aPO->mViewManager->Init(mPrt->mPrintDocDC);
|
2001-04-12 17:04:29 +04:00
|
|
|
if (NS_FAILED(rv)) {
|
|
|
|
return rv;
|
|
|
|
}
|
2001-12-01 17:31:45 +03:00
|
|
|
|
2002-01-17 18:04:54 +03:00
|
|
|
rv = document->CreateShell(aPO->mPresContext, aPO->mViewManager, aPO->mStyleSet, getter_AddRefs(aPO->mPresShell));
|
2001-04-12 17:04:29 +04:00
|
|
|
if (NS_FAILED(rv)) {
|
|
|
|
return rv;
|
|
|
|
}
|
|
|
|
|
|
|
|
PRInt32 pageWidth, pageHeight;
|
|
|
|
mPrt->mPrintDocDC->GetDeviceSurfaceDimensions(pageWidth, pageHeight);
|
|
|
|
|
|
|
|
PRInt32 width, height;
|
|
|
|
if (aPO->mContent == nsnull || !aPO->mPrintAsIs ||
|
|
|
|
(aPO->mPrintAsIs && aPO->mParent != nsnull && !aPO->mParent->mPrintAsIs) ||
|
|
|
|
(aPO->mFrameType == eIFrame && aPO == mPrt->mSelectedPO)) {
|
|
|
|
width = pageWidth;
|
|
|
|
height = pageHeight;
|
|
|
|
} else {
|
|
|
|
width = aPO->mRect.width;
|
|
|
|
height = aPO->mRect.height;
|
|
|
|
}
|
|
|
|
|
|
|
|
PRINT_DEBUG_MSG5("In DV::ReflowPrintObject PO: %p (%9s) Setting w,h to %d,%d\n", aPO, gFrameTypesStr[aPO->mFrameType], width, height);
|
|
|
|
|
|
|
|
nsCOMPtr<nsIDOMWindowInternal> domWinIntl(do_QueryInterface(mPrt->mPrintDocDW));
|
|
|
|
// XXX - Hack Alert
|
|
|
|
// OK, so ther eis a selection, we will print the entire selection
|
|
|
|
// on one page and then crop the page.
|
|
|
|
// This means you can never print any selection that is longer than one page
|
|
|
|
// put it keeps it from page breaking in the middle of your print of the selection
|
|
|
|
// (see also nsSimplePageSequence.cpp)
|
2002-01-01 15:58:53 +03:00
|
|
|
PRInt16 printRangeType = nsIPrintSettings::kRangeAllPages;
|
|
|
|
if (mPrt->mPrintSettings != nsnull) {
|
|
|
|
mPrt->mPrintSettings->GetPrintRange(&printRangeType);
|
2001-04-12 17:04:29 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2002-01-01 15:58:53 +03:00
|
|
|
if (printRangeType == nsIPrintSettings::kRangeSelection && IsThereARangeSelection(domWinIntl)) {
|
2002-02-12 16:33:39 +03:00
|
|
|
height = NS_UNCONSTRAINEDSIZE;
|
2001-04-12 17:04:29 +04:00
|
|
|
}
|
|
|
|
nsRect tbounds = nsRect(0, 0, width, height);
|
|
|
|
|
|
|
|
// Create a child window of the parent that is our "root view/window"
|
2001-08-01 07:15:50 +04:00
|
|
|
rv = CallCreateInstance(kViewCID, &aPO->mRootView);
|
2001-04-12 17:04:29 +04:00
|
|
|
if (NS_FAILED(rv)) {
|
|
|
|
return rv;
|
|
|
|
}
|
|
|
|
rv = (aPO->mRootView)->Init(aPO->mViewManager, tbounds, nsnull);
|
|
|
|
if (NS_FAILED(rv)) {
|
|
|
|
return rv;
|
|
|
|
}
|
|
|
|
|
2001-11-03 17:59:39 +03:00
|
|
|
#ifdef NS_PRINT_PREVIEW
|
|
|
|
// Here we decide whether we need scrollbars and
|
|
|
|
// what the parent will be of the widget
|
2001-11-14 14:24:03 +03:00
|
|
|
if (mIsCreatingPrintPreview) {
|
2001-11-03 17:59:39 +03:00
|
|
|
PRBool canCreateScrollbars = PR_FALSE;
|
2001-11-14 14:24:03 +03:00
|
|
|
nsCOMPtr<nsIWidget> widget = mParentWidget;
|
2001-11-03 17:59:39 +03:00
|
|
|
// the top PrintObject's widget will always have scrollbars
|
|
|
|
if (aPO->mParent != nsnull && aPO->mContent) {
|
|
|
|
nsCOMPtr<nsIFrameManager> frameMan;
|
|
|
|
aPO->mParent->mPresShell->GetFrameManager(getter_AddRefs(frameMan));
|
|
|
|
NS_ASSERTION(frameMan, "No Frame manager!");
|
|
|
|
nsIFrame* frame;
|
|
|
|
frameMan->GetPrimaryFrameFor(aPO->mContent, &frame);
|
|
|
|
if (frame != nsnull && (aPO->mFrameType == eIFrame || aPO->mFrameType == eFrame)) {
|
|
|
|
frame->FirstChild(aPO->mParent->mPresContext, nsnull, &frame);
|
|
|
|
}
|
|
|
|
if (frame != nsnull) {
|
|
|
|
nsIView* view = nsnull;
|
|
|
|
frame->GetView(aPO->mParent->mPresContext, &view);
|
|
|
|
if (view != nsnull) {
|
2002-02-20 00:33:26 +03:00
|
|
|
nsCOMPtr<nsIWidget> w2;
|
|
|
|
view->GetWidget(*getter_AddRefs(w2));
|
|
|
|
if (nsnull != w2) {
|
|
|
|
widget = w2;
|
|
|
|
}
|
2001-11-03 17:59:39 +03:00
|
|
|
canCreateScrollbars = PR_FALSE;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
canCreateScrollbars = PR_TRUE;
|
|
|
|
}
|
|
|
|
rv = aPO->mRootView->CreateWidget(kWidgetCID, nsnull, widget->GetNativeData(NS_NATIVE_WIDGET));
|
|
|
|
aPO->mRootView->GetWidget(*getter_AddRefs(aPO->mWindow));
|
|
|
|
aPO->mPresContext->SetPaginatedScrolling(canCreateScrollbars);
|
|
|
|
}
|
|
|
|
#endif // NS_PRINT_PREVIEW
|
|
|
|
|
2001-04-12 17:04:29 +04:00
|
|
|
// Setup hierarchical relationship in view manager
|
|
|
|
aPO->mViewManager->SetRootView(aPO->mRootView);
|
2001-08-01 07:15:50 +04:00
|
|
|
aPO->mPresShell->Init(document, aPO->mPresContext,
|
|
|
|
aPO->mViewManager, aPO->mStyleSet);
|
2001-04-12 17:04:29 +04:00
|
|
|
|
|
|
|
nsCompatibility mode;
|
|
|
|
mPresContext->GetCompatibilityMode(&mode);
|
|
|
|
aPO->mPresContext->SetCompatibilityMode(mode);
|
2001-11-03 17:59:39 +03:00
|
|
|
if (!containerIsSet) {
|
|
|
|
nsCOMPtr<nsISupports> supps(do_QueryInterface(aPO->mWebShell));
|
|
|
|
aPO->mPresContext->SetContainer(supps);
|
|
|
|
}
|
2001-04-12 17:04:29 +04:00
|
|
|
|
|
|
|
// get the old history
|
|
|
|
nsCOMPtr<nsIPresShell> presShell;
|
|
|
|
nsCOMPtr<nsILayoutHistoryState> layoutState;
|
|
|
|
NS_ENSURE_SUCCESS(GetPresShell(*(getter_AddRefs(presShell))), NS_ERROR_FAILURE);
|
|
|
|
presShell->CaptureHistoryState(getter_AddRefs(layoutState),PR_TRUE);
|
|
|
|
|
2001-09-29 21:50:15 +04:00
|
|
|
// set it on the new pres shell
|
|
|
|
aPO->mPresShell->SetHistoryState(layoutState);
|
|
|
|
|
2001-11-14 14:24:03 +03:00
|
|
|
// turn off animated GIFs
|
|
|
|
if (aPO->mPresContext) {
|
|
|
|
aPO->mPresContext->GetImageAnimationMode(&aPO->mImgAnimationMode);
|
2001-11-14 17:03:09 +03:00
|
|
|
aPO->mPresContext->SetImageAnimationMode(imgIContainer::kDontAnimMode);
|
2001-11-14 14:24:03 +03:00
|
|
|
}
|
|
|
|
|
2001-04-12 17:04:29 +04:00
|
|
|
aPO->mPresShell->BeginObservingDocument();
|
|
|
|
|
|
|
|
nsMargin margin(0,0,0,0);
|
2002-01-01 15:58:53 +03:00
|
|
|
mPrt->mPrintSettings->GetMarginInTwips(margin);
|
2001-04-12 17:04:29 +04:00
|
|
|
|
|
|
|
// initialize it with the default/generic case
|
|
|
|
nsRect adjRect(aPO->mRect.x != 0?margin.left:0, aPO->mRect.y != 0?margin.top:0, width, height);
|
|
|
|
|
2001-04-13 16:32:18 +04:00
|
|
|
// XXX This is an arbitray height,
|
|
|
|
// but reflow somethimes gets upset when using max int
|
|
|
|
// basically, we want to reflow a single page that is large
|
|
|
|
// enough to fit any atomic object like an IFrame
|
2001-09-25 17:00:04 +04:00
|
|
|
const PRInt32 kFivePagesHigh = 5;
|
2001-04-13 16:32:18 +04:00
|
|
|
|
2001-04-12 17:04:29 +04:00
|
|
|
// now, change the value for special cases
|
2002-01-01 15:58:53 +03:00
|
|
|
if (mPrt->mPrintFrameType == nsIPrintSettings::kEachFrameSep) {
|
2001-04-12 17:04:29 +04:00
|
|
|
if (aPO->mFrameType == eFrame) {
|
|
|
|
adjRect.SetRect(0, 0, width, height);
|
|
|
|
} else if (aPO->mFrameType == eIFrame) {
|
2001-09-25 17:00:04 +04:00
|
|
|
height = pageHeight*kFivePagesHigh;
|
2001-04-12 17:04:29 +04:00
|
|
|
adjRect.SetRect(aPO->mRect.x != 0?margin.left:0, aPO->mRect.y != 0?margin.top:0, width, height);
|
|
|
|
}
|
|
|
|
|
2002-01-01 15:58:53 +03:00
|
|
|
} else if (mPrt->mPrintFrameType == nsIPrintSettings::kSelectedFrame) {
|
2001-11-03 17:59:39 +03:00
|
|
|
if (aPO->mFrameType == eFrame) {
|
|
|
|
adjRect.SetRect(0, 0, width, height);
|
|
|
|
} else if (aPO->mFrameType == eIFrame) {
|
2001-04-13 16:32:18 +04:00
|
|
|
if (aPO == mPrt->mSelectedPO) {
|
|
|
|
adjRect.x = 0;
|
|
|
|
adjRect.y = 0;
|
|
|
|
} else {
|
2001-09-25 17:00:04 +04:00
|
|
|
height = pageHeight*kFivePagesHigh;
|
2001-04-13 16:32:18 +04:00
|
|
|
adjRect.SetRect(aPO->mRect.x != 0?margin.left:0, aPO->mRect.y != 0?margin.top:0, width, height);
|
|
|
|
}
|
2001-04-12 17:04:29 +04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2002-02-20 06:21:25 +03:00
|
|
|
if (!adjRect.width || !adjRect.height) {
|
|
|
|
aPO->mDontPrint = PR_TRUE;
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2001-04-12 17:04:29 +04:00
|
|
|
aPO->mPresContext->SetPageDim(&adjRect);
|
2001-09-29 21:50:15 +04:00
|
|
|
rv = aPO->mPresShell->InitialReflow(width, height);
|
2001-04-12 17:04:29 +04:00
|
|
|
if (NS_SUCCEEDED(rv)) {
|
|
|
|
// Transfer Selection Ranges to the new Print PresShell
|
|
|
|
nsCOMPtr<nsISelection> selection;
|
|
|
|
nsCOMPtr<nsISelection> selectionPS;
|
|
|
|
nsresult rvv = GetDocumentSelection(getter_AddRefs(selection), wsPresShell);
|
|
|
|
if (NS_SUCCEEDED(rvv) && selection) {
|
|
|
|
rvv = GetDocumentSelection(getter_AddRefs(selectionPS), aPO->mPresShell);
|
|
|
|
if (NS_SUCCEEDED(rvv) && 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-02-19 14:49:27 +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) {
|
2002-03-04 15:55:20 +03:00
|
|
|
// First find the seq frame
|
2002-02-19 14:49:27 +03:00
|
|
|
nsIFrame* rootFrame;
|
|
|
|
aPO->mPresShell->GetRootFrame(&rootFrame);
|
|
|
|
NS_ASSERTION(rootFrame, "There has to be a root frame!");
|
|
|
|
if (rootFrame) {
|
2002-03-04 15:55:20 +03:00
|
|
|
nsIFrame* seqFrame;
|
|
|
|
rootFrame->FirstChild(aPO->mPresContext, nsnull, &seqFrame);
|
|
|
|
while (seqFrame) {
|
2002-02-19 14:49:27 +03:00
|
|
|
nsCOMPtr<nsIAtom> frameType;
|
2002-03-04 15:55:20 +03:00
|
|
|
seqFrame->GetFrameType(getter_AddRefs(frameType));
|
|
|
|
if (nsLayoutAtoms::sequenceFrame == frameType.get()) {
|
2002-02-19 14:49:27 +03:00
|
|
|
break;
|
|
|
|
}
|
2002-03-04 15:55:20 +03:00
|
|
|
seqFrame->FirstChild(aPO->mPresContext, nsnull, &seqFrame);
|
2002-02-19 14:49:27 +03:00
|
|
|
}
|
2002-03-04 15:55:20 +03:00
|
|
|
NS_ASSERTION(seqFrame, "There has to be a Sequence frame!");
|
|
|
|
if (seqFrame) {
|
|
|
|
// Get the first page of all the pages
|
|
|
|
nsIFrame* pageFrame;
|
|
|
|
seqFrame->FirstChild(aPO->mPresContext, nsnull, &pageFrame);
|
|
|
|
NS_ASSERTION(pageFrame, "There has to be a Page Frame!");
|
|
|
|
// loop thru all the Page Frames
|
|
|
|
nscoord overallMaxWidth = 0;
|
|
|
|
nscoord overMaxRectWidth = 0;
|
|
|
|
while (pageFrame) {
|
|
|
|
nsIFrame* child;
|
|
|
|
// Now get it's first child (for HTML docs it is an area frame)
|
|
|
|
// then gets it size which would be the size it is suppose to be to fit
|
|
|
|
pageFrame->FirstChild(aPO->mPresContext, nsnull, &child);
|
|
|
|
NS_ASSERTION(child, "There has to be a child frame!");
|
|
|
|
|
2002-02-19 14:49:27 +03:00
|
|
|
nsRect rect;
|
|
|
|
child->GetRect(rect);
|
|
|
|
// Create a RenderingContext and set the PresContext
|
|
|
|
// appropriately if we are printing selection
|
|
|
|
nsCOMPtr<nsIRenderingContext> rc;
|
|
|
|
if (nsIPrintSettings::kRangeSelection == printRangeType) {
|
|
|
|
aPO->mPresContext->SetIsRenderingOnlySelection(PR_TRUE);
|
|
|
|
mPrt->mPrintDocDC->CreateRenderingContext(*getter_AddRefs(rc));
|
|
|
|
}
|
|
|
|
// Find the Size of the XMost frame
|
|
|
|
// then calc the ratio for shrinkage
|
|
|
|
nscoord maxWidth = 0;
|
|
|
|
FindXMostFrameSize(aPO->mPresContext, rc, child, 0, 0, maxWidth);
|
2002-03-04 15:55:20 +03:00
|
|
|
if (maxWidth > overallMaxWidth) {
|
|
|
|
overallMaxWidth = maxWidth;
|
|
|
|
overMaxRectWidth = rect.width;
|
|
|
|
}
|
|
|
|
pageFrame->GetNextSibling(&pageFrame);
|
|
|
|
} // while
|
|
|
|
// Now calc the ratio from the widest frames from all the pages
|
|
|
|
float ratio = 1.0f;
|
|
|
|
NS_ASSERTION(overallMaxWidth, "Overall Max Width must be bigger than zero");
|
|
|
|
if (overallMaxWidth > 0) {
|
|
|
|
ratio = float(overMaxRectWidth) / float(overallMaxWidth);
|
|
|
|
aPO->mXMost = overallMaxWidth;
|
2002-02-19 14:49:27 +03:00
|
|
|
aPO->mShrinkRatio = PR_MIN(ratio, 1.0f);
|
|
|
|
#ifdef DEBUG_PRINTING
|
2002-03-04 15:55:20 +03:00
|
|
|
printf("PO %p ****** RW: %d MW: %d xMost %d width: %d %10.4f\n", aPO, overMaxRectWidth, overallMaxWidth, aPO->mXMost, overMaxRectWidth, ratio*100.0);
|
2002-02-19 14:49:27 +03:00
|
|
|
#endif
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2001-04-12 17:04:29 +04:00
|
|
|
}
|
2001-06-29 09:42:47 +04:00
|
|
|
|
2001-11-03 17:59:39 +03:00
|
|
|
#ifdef DEBUG_rods
|
|
|
|
{
|
|
|
|
char * docStr;
|
|
|
|
char * urlStr;
|
|
|
|
GetDocTitleAndURL(aPO, docStr, urlStr);
|
|
|
|
char filename[256];
|
|
|
|
sprintf(filename, "dump_%d.txt", gDumpFileNameCnt++);
|
|
|
|
// Dump all the frames and view to a a file
|
|
|
|
FILE * fd = fopen(filename, "w");
|
|
|
|
if (fd) {
|
2001-11-14 14:24:03 +03:00
|
|
|
nsIFrame *theRootFrame;
|
|
|
|
aPO->mPresShell->GetRootFrame(&theRootFrame);
|
2001-11-03 17:59:39 +03:00
|
|
|
fprintf(fd, "Title: %s\n", docStr?docStr:"");
|
|
|
|
fprintf(fd, "URL: %s\n", urlStr?urlStr:"");
|
|
|
|
fprintf(fd, "--------------- Frames ----------------\n");
|
|
|
|
nsCOMPtr<nsIRenderingContext> renderingContext;
|
|
|
|
mPrt->mPrintDocDC->CreateRenderingContext(*getter_AddRefs(renderingContext));
|
2002-02-19 14:49:27 +03:00
|
|
|
RootFrameList(aPO->mPresContext, fd, 0);
|
|
|
|
//DumpFrames(fd, aPO->mPresContext, renderingContext, theRootFrame, 0);
|
2001-11-14 14:24:03 +03:00
|
|
|
fprintf(fd, "---------------------------------------\n\n");
|
|
|
|
fprintf(fd, "--------------- Views From Root Frame----------------\n");
|
|
|
|
nsIView * v;
|
|
|
|
theRootFrame->GetView(aPO->mPresContext, &v);
|
|
|
|
if (v) {
|
|
|
|
v->List(fd);
|
|
|
|
} else {
|
|
|
|
printf("View is null!\n");
|
|
|
|
}
|
|
|
|
nsCOMPtr<nsIDocShell> docShell(do_QueryInterface(aPO->mWebShell));
|
|
|
|
if (docShell) {
|
|
|
|
fprintf(fd, "--------------- All Views ----------------\n");
|
|
|
|
DumpViews(docShell, fd);
|
|
|
|
fprintf(fd, "---------------------------------------\n\n");
|
|
|
|
}
|
2001-11-03 17:59:39 +03:00
|
|
|
fclose(fd);
|
|
|
|
}
|
|
|
|
if (docStr) nsMemory::Free(docStr);
|
|
|
|
if (urlStr) nsMemory::Free(urlStr);
|
2001-06-29 09:42:47 +04:00
|
|
|
}
|
|
|
|
#endif
|
2001-04-12 17:04:29 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
aPO->mPresShell->EndObservingDocument();
|
|
|
|
|
|
|
|
return rv;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
//-------------------------------------------------------
|
|
|
|
// Given a DOMWindow it recursively finds the PO object that matches
|
|
|
|
PrintObject*
|
|
|
|
DocumentViewerImpl::FindPrintObjectByDOMWin(PrintObject* aPO, nsIDOMWindowInternal * aDOMWin)
|
|
|
|
{
|
|
|
|
NS_ASSERTION(aPO, "Pointer is null!");
|
|
|
|
|
|
|
|
// Often the CurFocused DOMWindow is passed in
|
|
|
|
// andit is valid for it to be null, so short circut
|
|
|
|
if (aDOMWin == nsnull) {
|
|
|
|
return nsnull;
|
|
|
|
}
|
|
|
|
|
|
|
|
nsCOMPtr<nsIDOMWindowInternal> domWin(GetDOMWinForWebShell(aPO->mWebShell));
|
|
|
|
if (domWin != nsnull && domWin.get() == aDOMWin) {
|
|
|
|
return aPO;
|
|
|
|
}
|
|
|
|
|
|
|
|
PRInt32 cnt = aPO->mKids.Count();
|
|
|
|
for (PRInt32 i=0;i<cnt;i++) {
|
|
|
|
PrintObject* po = FindPrintObjectByDOMWin((PrintObject*)aPO->mKids[i], aDOMWin);
|
|
|
|
if (po != nsnull) {
|
|
|
|
return po;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return nsnull;
|
|
|
|
}
|
|
|
|
|
|
|
|
//-------------------------------------------------------
|
|
|
|
// return the DOMWindowInternal for a WebShell
|
|
|
|
nsIDOMWindowInternal *
|
|
|
|
DocumentViewerImpl::GetDOMWinForWebShell(nsIWebShell* aWebShell)
|
|
|
|
{
|
|
|
|
NS_ASSERTION(aWebShell, "Pointer is null!");
|
|
|
|
|
2002-03-26 14:43:40 +03:00
|
|
|
nsCOMPtr<nsIDOMWindow> domWin = do_GetInterface(aWebShell);
|
2001-04-12 17:04:29 +04:00
|
|
|
if (!domWin) return nsnull;
|
|
|
|
|
2002-03-26 14:43:40 +03:00
|
|
|
nsCOMPtr<nsIDOMWindowInternal> domWinInt(do_QueryInterface(domWin));
|
|
|
|
if (!domWinInt) return nsnull;
|
|
|
|
|
|
|
|
nsIDOMWindowInternal * dw = NS_STATIC_CAST(nsIDOMWindowInternal *, domWinInt.get());
|
2001-04-12 17:04:29 +04:00
|
|
|
NS_ADDREF(dw);
|
2002-03-26 14:43:40 +03:00
|
|
|
|
2001-04-12 17:04:29 +04:00
|
|
|
return dw;
|
|
|
|
}
|
|
|
|
|
|
|
|
//-------------------------------------------------------
|
|
|
|
nsresult
|
|
|
|
DocumentViewerImpl::EnablePOsForPrinting()
|
|
|
|
{
|
|
|
|
// NOTE: All POs have been "turned off" for printing
|
|
|
|
// this is where we decided which POs get printed.
|
|
|
|
mPrt->mSelectedPO = nsnull;
|
|
|
|
|
2002-01-01 15:58:53 +03:00
|
|
|
if (mPrt->mPrintSettings == nsnull) {
|
|
|
|
return NS_ERROR_FAILURE;
|
2001-04-12 17:04:29 +04:00
|
|
|
}
|
|
|
|
|
2002-01-01 15:58:53 +03:00
|
|
|
mPrt->mPrintFrameType = nsIPrintSettings::kNoFrames;
|
|
|
|
mPrt->mPrintSettings->GetPrintFrameType(&mPrt->mPrintFrameType);
|
2001-04-12 17:04:29 +04:00
|
|
|
|
2002-01-01 15:58:53 +03:00
|
|
|
PRInt16 printHowEnable = nsIPrintSettings::kFrameEnableNone;
|
|
|
|
mPrt->mPrintSettings->GetHowToEnableFrameUI(&printHowEnable);
|
2001-04-12 17:04:29 +04:00
|
|
|
|
2002-01-01 15:58:53 +03:00
|
|
|
PRInt16 printRangeType = nsIPrintSettings::kRangeAllPages;
|
|
|
|
mPrt->mPrintSettings->GetPrintRange(&printRangeType);
|
2001-04-12 17:04:29 +04:00
|
|
|
|
|
|
|
PRINT_DEBUG_MSG1("\n********* DocumentViewerImpl::EnablePOsForPrinting *********\n");
|
|
|
|
PRINT_DEBUG_MSG2("PrintFrameType: %s \n", gPrintFrameTypeStr[mPrt->mPrintFrameType]);
|
|
|
|
PRINT_DEBUG_MSG2("HowToEnableFrameUI: %s \n", gFrameHowToEnableStr[printHowEnable]);
|
|
|
|
PRINT_DEBUG_MSG2("PrintRange: %s \n", gPrintRangeStr[printRangeType]);
|
|
|
|
PRINT_DEBUG_MSG1("----\n");
|
|
|
|
PRINT_DEBUG_FLUSH
|
|
|
|
|
|
|
|
// ***** 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
|
2002-01-01 15:58:53 +03:00
|
|
|
if (printRangeType == nsIPrintSettings::kRangeSelection) {
|
|
|
|
mPrt->mPrintFrameType = nsIPrintSettings::kSelectedFrame;
|
|
|
|
printHowEnable = nsIPrintSettings::kFrameEnableNone;
|
2001-04-12 17:04:29 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
// 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
|
2002-01-01 15:58:53 +03:00
|
|
|
if (printHowEnable == nsIPrintSettings::kFrameEnableNone) {
|
2001-04-12 17:04:29 +04:00
|
|
|
|
|
|
|
// Print all the pages or a sub range of pages
|
2002-01-01 15:58:53 +03:00
|
|
|
if (printRangeType == nsIPrintSettings::kRangeAllPages ||
|
|
|
|
printRangeType == nsIPrintSettings::kRangeSpecifiedPageRange) {
|
2001-04-12 17:04:29 +04:00
|
|
|
SetPrintPO(mPrt->mPrintObject, PR_TRUE);
|
|
|
|
|
|
|
|
// Set the children so they are PrinAsIs
|
|
|
|
// In this case, the children are probably IFrames
|
|
|
|
if (mPrt->mPrintObject->mKids.Count() > 0) {
|
|
|
|
for (PRInt32 i=0;i<mPrt->mPrintObject->mKids.Count();i++) {
|
|
|
|
PrintObject* po = (PrintObject*)mPrt->mPrintObject->mKids[i];
|
|
|
|
NS_ASSERTION(po, "PrintObject can't be null!");
|
|
|
|
SetPrintAsIs(po);
|
|
|
|
}
|
|
|
|
|
|
|
|
// ***** Another override *****
|
2002-01-01 15:58:53 +03:00
|
|
|
mPrt->mPrintFrameType = nsIPrintSettings::kFramesAsIs;
|
2001-04-12 17:04:29 +04:00
|
|
|
}
|
|
|
|
PRINT_DEBUG_MSG2("PrintFrameType: %s \n", gPrintFrameTypeStr[mPrt->mPrintFrameType]);
|
|
|
|
PRINT_DEBUG_MSG2("HowToEnableFrameUI: %s \n", gFrameHowToEnableStr[printHowEnable]);
|
|
|
|
PRINT_DEBUG_MSG2("PrintRange: %s \n", gPrintRangeStr[printRangeType]);
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
// This means we are either printed a selected IFrame or
|
|
|
|
// we are printing the current selection
|
2002-01-01 15:58:53 +03:00
|
|
|
if (printRangeType == nsIPrintSettings::kRangeSelection) {
|
2001-04-12 17:04:29 +04:00
|
|
|
|
|
|
|
// If the currentFocusDOMWin can'r be null if something is selected
|
2001-05-31 05:06:33 +04:00
|
|
|
if (mPrt->mCurrentFocusWin) {
|
2001-04-12 17:04:29 +04:00
|
|
|
// Find the selected IFrame
|
2001-05-31 05:06:33 +04:00
|
|
|
PrintObject * po = FindPrintObjectByDOMWin(mPrt->mPrintObject, mPrt->mCurrentFocusWin);
|
2001-04-12 17:04:29 +04:00
|
|
|
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
|
|
|
|
SetPrintPO(po, PR_TRUE);
|
|
|
|
|
|
|
|
// check to see if we have a range selection,
|
|
|
|
// as oppose to a insert selection
|
|
|
|
// this means if the user just clicked on the IFrame then
|
|
|
|
// there will not be a selection so we want the entire page to print
|
|
|
|
//
|
|
|
|
// XXX this is sort of a hack right here to make the page
|
|
|
|
// not try to reposition itself when printing selection
|
|
|
|
nsCOMPtr<nsIDOMWindowInternal> domWin = getter_AddRefs(GetDOMWinForWebShell(po->mWebShell));
|
|
|
|
if (!IsThereARangeSelection(domWin)) {
|
2002-01-01 15:58:53 +03:00
|
|
|
printRangeType = nsIPrintSettings::kRangeAllPages;
|
|
|
|
mPrt->mPrintSettings->SetPrintRange(printRangeType);
|
2001-04-12 17:04:29 +04:00
|
|
|
}
|
|
|
|
PRINT_DEBUG_MSG2("PrintFrameType: %s \n", gPrintFrameTypeStr[mPrt->mPrintFrameType]);
|
|
|
|
PRINT_DEBUG_MSG2("HowToEnableFrameUI: %s \n", gFrameHowToEnableStr[printHowEnable]);
|
|
|
|
PRINT_DEBUG_MSG2("PrintRange: %s \n", gPrintRangeStr[printRangeType]);
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
for (PRInt32 i=0;i<mPrt->mPrintDocList->Count();i++) {
|
|
|
|
PrintObject* po = (PrintObject*)mPrt->mPrintDocList->ElementAt(i);
|
|
|
|
NS_ASSERTION(po, "PrintObject can't be null!");
|
|
|
|
nsCOMPtr<nsIDOMWindowInternal> domWin = getter_AddRefs(GetDOMWinForWebShell(po->mWebShell));
|
|
|
|
if (IsThereARangeSelection(domWin)) {
|
2002-01-01 15:58:53 +03:00
|
|
|
mPrt->mCurrentFocusWin = domWin;
|
2001-04-12 17:04:29 +04:00
|
|
|
SetPrintPO(po, PR_TRUE);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// check to see if there is a selection when a FrameSet is present
|
2002-01-01 15:58:53 +03:00
|
|
|
if (printRangeType == nsIPrintSettings::kRangeSelection) {
|
2001-04-12 17:04:29 +04:00
|
|
|
// If the currentFocusDOMWin can'r be null if something is selected
|
2001-05-31 05:06:33 +04:00
|
|
|
if (mPrt->mCurrentFocusWin) {
|
2001-04-12 17:04:29 +04:00
|
|
|
// Find the selected IFrame
|
2001-05-31 05:06:33 +04:00
|
|
|
PrintObject * po = FindPrintObjectByDOMWin(mPrt->mPrintObject, mPrt->mCurrentFocusWin);
|
2001-04-12 17:04:29 +04:00
|
|
|
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
|
|
|
|
SetPrintPO(po, PR_TRUE);
|
|
|
|
|
|
|
|
// check to see if we have a range selection,
|
|
|
|
// as oppose to a insert selection
|
|
|
|
// this means if the user just clicked on the IFrame then
|
|
|
|
// there will not be a selection so we want the entire page to print
|
|
|
|
//
|
|
|
|
// XXX this is sort of a hack right here to make the page
|
|
|
|
// not try to reposition itself when printing selection
|
|
|
|
nsCOMPtr<nsIDOMWindowInternal> domWin = getter_AddRefs(GetDOMWinForWebShell(po->mWebShell));
|
|
|
|
if (!IsThereARangeSelection(domWin)) {
|
2002-01-01 15:58:53 +03:00
|
|
|
printRangeType = nsIPrintSettings::kRangeAllPages;
|
|
|
|
mPrt->mPrintSettings->SetPrintRange(printRangeType);
|
2001-04-12 17:04:29 +04:00
|
|
|
}
|
|
|
|
PRINT_DEBUG_MSG2("PrintFrameType: %s \n", gPrintFrameTypeStr[mPrt->mPrintFrameType]);
|
|
|
|
PRINT_DEBUG_MSG2("HowToEnableFrameUI: %s \n", gFrameHowToEnableStr[printHowEnable]);
|
|
|
|
PRINT_DEBUG_MSG2("PrintRange: %s \n", gPrintRangeStr[printRangeType]);
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2001-03-27 15:56:03 +04:00
|
|
|
|
2001-04-12 17:04:29 +04:00
|
|
|
// If we are printing "AsIs" then sets all the POs to be printed as is
|
2002-01-01 15:58:53 +03:00
|
|
|
if (mPrt->mPrintFrameType == nsIPrintSettings::kFramesAsIs) {
|
2001-04-12 17:04:29 +04:00
|
|
|
SetPrintAsIs(mPrt->mPrintObject);
|
|
|
|
SetPrintPO(mPrt->mPrintObject, PR_TRUE);
|
|
|
|
return NS_OK;
|
2001-03-27 15:56:03 +04:00
|
|
|
}
|
|
|
|
|
2001-04-12 17:04:29 +04:00
|
|
|
// 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
|
2002-01-01 15:58:53 +03:00
|
|
|
if (mPrt->mPrintFrameType == nsIPrintSettings::kSelectedFrame) {
|
2001-04-12 17:04:29 +04:00
|
|
|
|
2001-05-31 05:06:33 +04:00
|
|
|
if ((mPrt->mIsParentAFrameSet && mPrt->mCurrentFocusWin) || mPrt->mIsIFrameSelected) {
|
|
|
|
PrintObject * po = FindPrintObjectByDOMWin(mPrt->mPrintObject, mPrt->mCurrentFocusWin);
|
2001-04-12 17:04:29 +04:00
|
|
|
if (po != nsnull) {
|
|
|
|
mPrt->mSelectedPO = po;
|
2001-09-20 16:13:48 +04:00
|
|
|
// NOTE: Calling this sets the "po" and
|
|
|
|
// we don't want to do this for documents that have no children,
|
|
|
|
// because then the "DoEndPage" gets called and it shouldn't
|
|
|
|
if (po->mKids.Count() > 0) {
|
|
|
|
// Makes sure that itself, and all of its children are printed "AsIs"
|
|
|
|
SetPrintAsIs(po);
|
|
|
|
}
|
2001-04-12 17:04:29 +04:00
|
|
|
|
|
|
|
// Now, only enable this POs (the selected PO) and all of its children
|
|
|
|
SetPrintPO(po, PR_TRUE);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
// If we are print each subdoc separately,
|
|
|
|
// then don't print any of the FraneSet Docs
|
2002-01-01 15:58:53 +03:00
|
|
|
if (mPrt->mPrintFrameType == nsIPrintSettings::kEachFrameSep) {
|
2001-04-12 17:04:29 +04:00
|
|
|
SetPrintPO(mPrt->mPrintObject, PR_TRUE);
|
|
|
|
PRInt32 cnt = mPrt->mPrintDocList->Count();
|
|
|
|
for (PRInt32 i=0;i<cnt;i++) {
|
|
|
|
PrintObject* po = (PrintObject*)mPrt->mPrintDocList->ElementAt(i);
|
|
|
|
NS_ASSERTION(po, "PrintObject can't be null!");
|
|
|
|
if (po->mFrameType == eFrameSet) {
|
|
|
|
po->mDontPrint = PR_TRUE;
|
2001-03-27 15:56:03 +04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2001-04-12 17:04:29 +04:00
|
|
|
return NS_OK;
|
2001-03-27 15:56:03 +04:00
|
|
|
}
|
|
|
|
|
2002-02-19 14:49:27 +03:00
|
|
|
//---------------------------------------------------
|
|
|
|
// Find the Frame in a Frame List that is XMost
|
|
|
|
void
|
|
|
|
DocumentViewerImpl::FindXMostFrameInList(nsIPresContext* aPresContext,
|
|
|
|
nsIRenderingContext* aRC,
|
|
|
|
nsIAtom* aList,
|
|
|
|
nsIFrame* aFrame,
|
|
|
|
nscoord aX,
|
|
|
|
nscoord aY,
|
|
|
|
PRInt32& aMaxWidth)
|
|
|
|
{
|
|
|
|
nsIFrame * child;
|
|
|
|
aFrame->FirstChild(aPresContext, aList, &child);
|
|
|
|
while (child) {
|
|
|
|
PRBool isVisible = PR_TRUE;
|
|
|
|
// If the aRC is nsnull, then we skip the more expensive check and
|
|
|
|
// just check visibility
|
|
|
|
if (aRC) {
|
|
|
|
child->IsVisibleForPainting(aPresContext, *aRC, PR_TRUE, &isVisible);
|
|
|
|
} else {
|
|
|
|
nsCOMPtr<nsIStyleContext> sc;
|
|
|
|
child->GetStyleContext(getter_AddRefs(sc));
|
|
|
|
if (sc) {
|
|
|
|
const nsStyleVisibility* vis = (const nsStyleVisibility*)sc->GetStyleData(eStyleStruct_Visibility);
|
|
|
|
isVisible = vis->IsVisible();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (isVisible) {
|
|
|
|
nsRect rect;
|
|
|
|
child->GetRect(rect);
|
|
|
|
rect.x += aX;
|
|
|
|
rect.y += aY;
|
|
|
|
nscoord xMost = rect.XMost();
|
2002-03-23 21:07:51 +03:00
|
|
|
// make sure we have a reasonable value
|
|
|
|
NS_ASSERTION(xMost < NS_UNCONSTRAINEDSIZE, "Some frame's size is bad.");
|
|
|
|
if (xMost >= NS_UNCONSTRAINEDSIZE) {
|
|
|
|
xMost = 0;
|
|
|
|
}
|
2002-02-19 14:49:27 +03:00
|
|
|
|
2002-03-16 16:08:45 +03:00
|
|
|
#ifdef DEBUG_PRINTING // keep this here but leave it turned off
|
2002-02-19 14:49:27 +03:00
|
|
|
nsAutoString tmp;
|
|
|
|
nsIFrameDebug* frameDebug;
|
|
|
|
if (NS_SUCCEEDED(CallQueryInterface(child, &frameDebug))) {
|
|
|
|
frameDebug->GetFrameName(tmp);
|
|
|
|
}
|
|
|
|
printf("%p - %d,%d,%d,%d %s (%d > %d)\n", child, rect.x, rect.y, rect.width, rect.height, NS_LossyConvertUCS2toASCII(tmp).get(), xMost, aMaxWidth);
|
|
|
|
#endif
|
|
|
|
|
|
|
|
if (xMost > aMaxWidth) {
|
|
|
|
aMaxWidth = xMost;
|
2002-03-16 16:08:45 +03:00
|
|
|
#ifdef DEBUG_PRINTING // keep this here but leave it turned off
|
2002-02-19 14:49:27 +03:00
|
|
|
printf("%p - %d %s ", child, aMaxWidth, NS_LossyConvertUCS2toASCII(tmp).get());
|
|
|
|
if (aList == nsLayoutAtoms::overflowList) printf(" nsLayoutAtoms::overflowList\n");
|
|
|
|
if (aList == nsLayoutAtoms::floaterList) printf(" nsLayoutAtoms::floaterList\n");
|
|
|
|
if (aList == nsLayoutAtoms::fixedList) printf(" nsLayoutAtoms::fixedList\n");
|
|
|
|
if (aList == nsLayoutAtoms::absoluteList) printf(" nsLayoutAtoms::absoluteList\n");
|
|
|
|
if (aList == nsnull) printf(" nsnull\n");
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
FindXMostFrameSize(aPresContext, aRC, child, rect.x, rect.y, aMaxWidth);
|
|
|
|
}
|
|
|
|
child->GetNextSibling(&child);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
//---------------------------------------------------
|
|
|
|
// Find the Frame that is XMost
|
|
|
|
void
|
|
|
|
DocumentViewerImpl::FindXMostFrameSize(nsIPresContext* aPresContext,
|
|
|
|
nsIRenderingContext* aRC,
|
|
|
|
nsIFrame* aFrame,
|
|
|
|
nscoord aX,
|
|
|
|
nscoord aY,
|
|
|
|
PRInt32& aMaxWidth)
|
|
|
|
{
|
|
|
|
NS_ASSERTION(aPresContext, "Pointer is null!");
|
|
|
|
NS_ASSERTION(aFrame, "Pointer is null!");
|
|
|
|
|
|
|
|
// loop thru named child lists
|
|
|
|
nsIAtom* childListName = nsnull;
|
|
|
|
PRInt32 childListIndex = 0;
|
|
|
|
do {
|
|
|
|
FindXMostFrameInList(aPresContext, aRC, childListName, aFrame, aX, aY, aMaxWidth);
|
|
|
|
NS_IF_RELEASE(childListName);
|
|
|
|
aFrame->GetAdditionalChildListName(childListIndex++, &childListName);
|
|
|
|
} while (childListName);
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
//-------------------------------------------------------
|
|
|
|
// Return the PrintObject with that is XMost (The widest frameset frame) AND
|
|
|
|
// contains the XMost (widest) layout frame
|
|
|
|
PrintObject*
|
|
|
|
DocumentViewerImpl::FindXMostPO()
|
|
|
|
{
|
|
|
|
nscoord xMostForPO = 0;
|
|
|
|
nscoord xMost = 0;
|
|
|
|
PrintObject* xMostPO = nsnull;
|
|
|
|
|
|
|
|
for (PRInt32 i=0;i<mPrt->mPrintDocList->Count();i++) {
|
|
|
|
PrintObject* po = (PrintObject*)mPrt->mPrintDocList->ElementAt(i);
|
|
|
|
NS_ASSERTION(po, "PrintObject can't be null!");
|
|
|
|
if (po->mFrameType != eFrameSet && po->mFrameType != eIFrame) {
|
|
|
|
if (po->mRect.XMost() >= xMostForPO) {
|
|
|
|
if (po->mRect.XMost() > xMostForPO || (po->mRect.XMost() == xMostForPO && po->mXMost > xMost)) {
|
|
|
|
xMostForPO = po->mRect.XMost();
|
|
|
|
xMost = po->mXMost;
|
|
|
|
xMostPO = po;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#ifdef DEBUG_PRINTING
|
|
|
|
if (xMostPO) printf("*PO: %p Type: %d XM: %d XM2: %d %10.3f\n", xMostPO, xMostPO->mFrameType, xMostPO->mRect.XMost(), xMostPO->mXMost, xMostPO->mShrinkRatio);
|
|
|
|
#endif
|
|
|
|
return xMostPO;
|
|
|
|
}
|
|
|
|
|
2001-02-07 02:03:17 +03:00
|
|
|
//-------------------------------------------------------
|
|
|
|
nsresult
|
2001-04-12 17:04:29 +04:00
|
|
|
DocumentViewerImpl::SetupToPrintContent(nsIWebShell* aParent,
|
|
|
|
nsIDeviceContext* aDContext,
|
|
|
|
nsIDOMWindowInternal* aCurrentFocusedDOMWin)
|
2001-03-27 15:56:03 +04:00
|
|
|
{
|
2001-02-07 02:03:17 +03:00
|
|
|
|
|
|
|
NS_ENSURE_ARG_POINTER(aParent);
|
|
|
|
NS_ENSURE_ARG_POINTER(aDContext);
|
2001-04-12 17:04:29 +04:00
|
|
|
// NOTE: aCurrentFocusedDOMWin may be null (which is OK)
|
2001-02-07 02:03:17 +03:00
|
|
|
|
2001-04-12 17:04:29 +04:00
|
|
|
mPrt->mPrintDocDC = aDContext;
|
2001-02-07 02:03:17 +03:00
|
|
|
|
2001-04-12 17:04:29 +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 PrintObject
|
|
|
|
// for printing
|
|
|
|
if (NS_FAILED(EnablePOsForPrinting())) {
|
|
|
|
return NS_ERROR_FAILURE;
|
2000-09-22 18:42:13 +04:00
|
|
|
}
|
2001-04-12 17:04:29 +04:00
|
|
|
DUMP_DOC_LIST("\nAfter Enable------------------------------------------");
|
2000-09-22 18:42:13 +04:00
|
|
|
|
2002-02-19 14:49:27 +03:00
|
|
|
// This is an Optimization
|
|
|
|
// If we are in PP then we already know all the shrinkage information
|
|
|
|
// so just transfer it to the PrintData and we will skip the extra shrinkage reflow
|
|
|
|
//
|
|
|
|
// doSetPixelScale tells Reflow whether to set the shrinkage value into the DC
|
|
|
|
// The first tru we do not want to do this, the second time thru we do
|
|
|
|
PRBool doSetPixelScale = PR_FALSE;
|
|
|
|
PRBool ppIsShrinkToFit = mPrtPreview && mPrtPreview->mShrinkToFit;
|
|
|
|
if (ppIsShrinkToFit) {
|
|
|
|
mPrt->mShrinkRatio = mPrtPreview->mShrinkRatio;
|
|
|
|
doSetPixelScale = PR_TRUE;
|
|
|
|
}
|
|
|
|
|
2001-04-12 17:04:29 +04:00
|
|
|
// Here we reflow all the PrintObjects
|
2002-02-19 14:49:27 +03:00
|
|
|
if (NS_FAILED(ReflowDocList(mPrt->mPrintObject, doSetPixelScale, mPrt->mShrinkToFit))) {
|
2001-04-12 17:04:29 +04:00
|
|
|
return NS_ERROR_FAILURE;
|
2000-09-22 18:42:13 +04:00
|
|
|
}
|
2001-03-27 15:56:03 +04:00
|
|
|
|
2002-02-19 14:49:27 +03:00
|
|
|
// 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) {
|
|
|
|
if (mPrt->mPrintDocList->Count() > 1 && mPrt->mPrintObject->mFrameType == eFrameSet) {
|
|
|
|
PrintObject* xMostPO = FindXMostPO();
|
|
|
|
NS_ASSERTION(xMostPO, "There must always be an XMost PO!");
|
|
|
|
if (xMostPO) {
|
|
|
|
// The margin is included in the PO's mRect so we need to subtract it
|
|
|
|
nsMargin margin(0,0,0,0);
|
|
|
|
mPrt->mPrintSettings->GetMarginInTwips(margin);
|
|
|
|
nsRect rect = xMostPO->mRect;
|
|
|
|
rect.x -= margin.left;
|
|
|
|
// Calc the shrinkage based on the entire content area
|
|
|
|
mPrt->mShrinkRatio = float(rect.XMost()) / float(rect.x + xMostPO->mXMost);
|
|
|
|
}
|
|
|
|
} 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 < 1.0f) {
|
|
|
|
for (PRInt32 i=0;i<mPrt->mPrintDocList->Count();i++) {
|
|
|
|
PrintObject* po = (PrintObject*)mPrt->mPrintDocList->ElementAt(i);
|
|
|
|
NS_ASSERTION(po, "PrintObject can't be null!");
|
|
|
|
// Wipe out the presentation before we reflow
|
|
|
|
po->DestroyPresentation();
|
|
|
|
}
|
|
|
|
|
|
|
|
// 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
|
|
|
|
if (NS_FAILED(ReflowDocList(mPrt->mPrintObject, PR_TRUE, PR_FALSE))) {
|
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2001-04-12 17:04:29 +04:00
|
|
|
DUMP_DOC_LIST("\nAfter Reflow------------------------------------------");
|
|
|
|
PRINT_DEBUG_MSG1("\n-------------------------------------------------------\n\n");
|
|
|
|
|
|
|
|
// Set up the clipping rectangle for all documents
|
|
|
|
// When frames are being printed as part of a frame set and also IFrames,
|
|
|
|
// they are reflowed with a very large page height. We need to setup the
|
|
|
|
// clipping so they do not rpint over top of anything else
|
|
|
|
PRINT_DEBUG_MSG1("SetClipRect-------------------------------------------------------\n");
|
|
|
|
nsRect clipRect(-1,-1,-1, -1);
|
|
|
|
SetClipRect(mPrt->mPrintObject, clipRect, 0, 0, PR_FALSE);
|
|
|
|
|
|
|
|
CalcNumPrintableDocsAndPages(mPrt->mNumPrintableDocs, mPrt->mNumPrintablePages);
|
|
|
|
|
|
|
|
PRINT_DEBUG_MSG3("--- Printing %d docs and %d pages\n", mPrt->mNumPrintableDocs, mPrt->mNumPrintablePages);
|
|
|
|
DUMP_DOC_TREELAYOUT;
|
|
|
|
PRINT_DEBUG_FLUSH;
|
|
|
|
|
2001-11-03 17:59:39 +03:00
|
|
|
#ifdef DEBUG_PRINTING_X
|
2001-04-12 17:04:29 +04:00
|
|
|
#if defined(XP_PC)
|
|
|
|
for (PRInt32 i=0;i<mPrt->mPrintDocList->Count();i++) {
|
|
|
|
PrintObject* po = (PrintObject*)mPrt->mPrintDocList->ElementAt(i);
|
|
|
|
NS_ASSERTION(po, "PrintObject can't be null!");
|
|
|
|
if (po->mPresShell) {
|
|
|
|
nsIPageSequenceFrame* pageSequence;
|
|
|
|
po->mPresShell->GetPageSequenceFrame(&pageSequence);
|
|
|
|
if (pageSequence != nsnull) {
|
|
|
|
// install the debugging file pointer
|
|
|
|
nsSimplePageSequenceFrame * sf = NS_STATIC_CAST(nsSimplePageSequenceFrame*, pageSequence);
|
|
|
|
sf->SetDebugFD(mPrt->mDebugFD);
|
|
|
|
}
|
|
|
|
}
|
2001-03-27 15:56:03 +04:00
|
|
|
}
|
2001-04-12 17:04:29 +04:00
|
|
|
#endif
|
|
|
|
#endif
|
2001-03-27 15:56:03 +04:00
|
|
|
|
2001-04-12 17:04:29 +04:00
|
|
|
mPrt->mPrintDocDW = aCurrentFocusedDOMWin;
|
2001-03-27 15:56:03 +04:00
|
|
|
|
|
|
|
// This will print the webshell document
|
|
|
|
// when it completes asynchronously in the DonePrintingPages method
|
|
|
|
// it will check to see if there are more webshells to be printed and
|
|
|
|
// then PrintDocContent will be called again.
|
|
|
|
|
2001-11-03 17:59:39 +03:00
|
|
|
nsresult rv = NS_OK;
|
|
|
|
if (mIsDoingPrinting) {
|
|
|
|
PrintDocContent(mPrt->mPrintObject, rv); // ignore return value
|
|
|
|
}
|
2001-04-12 17:04:29 +04:00
|
|
|
|
|
|
|
return rv;
|
2001-03-27 15:56:03 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
//-------------------------------------------------------
|
|
|
|
nsresult
|
2001-04-12 17:04:29 +04:00
|
|
|
DocumentViewerImpl::DoPrint(PrintObject * aPO, PRBool aDoSyncPrinting, PRBool& aDonePrinting)
|
2001-03-27 15:56:03 +04:00
|
|
|
{
|
2001-04-12 17:04:29 +04:00
|
|
|
NS_ASSERTION(mPrt->mPrintDocList, "Pointer is null!");
|
2001-03-27 15:56:03 +04:00
|
|
|
|
2001-04-12 17:04:29 +04:00
|
|
|
PRINT_DEBUG_MSG2("\n**************************** %s ****************************\n", gFrameTypesStr[aPO->mFrameType]);
|
|
|
|
PRINT_DEBUG_MSG3("****** In DV::DoPrint PO: %p aDoSyncPrinting: %s \n", aPO, PRT_YESNO(aDoSyncPrinting));
|
2001-03-27 15:56:03 +04:00
|
|
|
|
2001-11-03 17:59:39 +03:00
|
|
|
nsIWebShell* webShell = aPO->mWebShell.get();
|
2001-04-12 17:04:29 +04:00
|
|
|
nsIPresShell* poPresShell = aPO->mPresShell;
|
|
|
|
nsIPresContext* poPresContext = aPO->mPresContext;
|
|
|
|
nsIView* poRootView = aPO->mRootView;
|
2001-02-07 02:03:17 +03:00
|
|
|
|
2001-04-12 17:04:29 +04:00
|
|
|
nsCOMPtr<nsIWebShell> webContainer(do_QueryInterface(mContainer));
|
|
|
|
NS_ASSERTION(webShell, "The WebShell can't be NULL!");
|
2001-02-01 23:49:10 +03:00
|
|
|
|
2002-01-01 15:58:53 +03:00
|
|
|
if (mPrt->mPrintProgressParams) {
|
2002-02-12 16:33:39 +03:00
|
|
|
SetDocAndURLIntoProgress(aPO, mPrt->mPrintProgressParams);
|
2002-01-01 15:58:53 +03:00
|
|
|
}
|
|
|
|
|
2001-04-12 17:04:29 +04:00
|
|
|
if (webShell != nsnull) {
|
2001-02-07 02:03:17 +03:00
|
|
|
|
2002-01-01 15:58:53 +03:00
|
|
|
PRInt16 printRangeType = nsIPrintSettings::kRangeAllPages;
|
2001-04-12 17:04:29 +04:00
|
|
|
nsresult rv;
|
2002-01-01 15:58:53 +03:00
|
|
|
if (mPrt->mPrintSettings != nsnull) {
|
|
|
|
mPrt->mPrintSettings->GetPrintRange(&printRangeType);
|
2001-02-07 02:03:17 +03:00
|
|
|
}
|
|
|
|
|
2001-04-12 17:04:29 +04:00
|
|
|
// Ask the page sequence frame to print all the pages
|
|
|
|
nsIPageSequenceFrame* pageSequence;
|
|
|
|
poPresShell->GetPageSequenceFrame(&pageSequence);
|
|
|
|
NS_ASSERTION(nsnull != pageSequence, "no page sequence frame");
|
1999-05-07 23:26:23 +04:00
|
|
|
|
2001-04-12 17:04:29 +04:00
|
|
|
// Now, depending how we are printing and what type of doc we are printing
|
|
|
|
// we must configure the sequencer correctly.
|
|
|
|
// so we are about to be very explicit about the whole process
|
|
|
|
|
|
|
|
PRBool skipPageEjectOnly = PR_FALSE;
|
|
|
|
PRBool skipAllPageAdjustments = PR_FALSE;
|
|
|
|
PRBool doOffsetting = PR_FALSE;
|
|
|
|
PRBool doAddInParentsOffset = PR_TRUE;
|
|
|
|
PRBool skipSetTitle = PR_FALSE;
|
|
|
|
|
|
|
|
if (aPO->mFrameType == eFrame) {
|
|
|
|
switch (mPrt->mPrintFrameType) {
|
2002-01-01 15:58:53 +03:00
|
|
|
case nsIPrintSettings::kFramesAsIs:
|
2001-04-12 17:04:29 +04:00
|
|
|
skipAllPageAdjustments = PR_TRUE;
|
|
|
|
doOffsetting = PR_TRUE;
|
|
|
|
break;
|
|
|
|
|
2002-01-01 15:58:53 +03:00
|
|
|
case nsIPrintSettings::kSelectedFrame:
|
2001-04-12 17:04:29 +04:00
|
|
|
if (aPO->mKids.Count() > 0) {
|
|
|
|
skipPageEjectOnly = PR_TRUE;
|
|
|
|
}
|
|
|
|
break;
|
2001-01-27 17:09:34 +03:00
|
|
|
|
2002-01-01 15:58:53 +03:00
|
|
|
case nsIPrintSettings::kEachFrameSep:
|
2001-04-12 17:04:29 +04:00
|
|
|
if (aPO->mKids.Count() > 0) {
|
|
|
|
skipPageEjectOnly = PR_TRUE;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
} // switch
|
|
|
|
|
|
|
|
} else if (aPO->mFrameType == eIFrame) {
|
|
|
|
switch (mPrt->mPrintFrameType) {
|
2002-01-01 15:58:53 +03:00
|
|
|
case nsIPrintSettings::kFramesAsIs:
|
2001-04-12 17:04:29 +04:00
|
|
|
skipAllPageAdjustments = PR_TRUE;
|
|
|
|
doOffsetting = PR_TRUE;
|
|
|
|
skipSetTitle = PR_TRUE;
|
|
|
|
break;
|
|
|
|
|
2002-01-01 15:58:53 +03:00
|
|
|
case nsIPrintSettings::kSelectedFrame:
|
2001-04-12 17:04:29 +04:00
|
|
|
if (aPO != mPrt->mSelectedPO) {
|
|
|
|
skipAllPageAdjustments = PR_TRUE;
|
|
|
|
doOffsetting = PR_TRUE;
|
|
|
|
doAddInParentsOffset = aPO->mParent != nsnull && aPO->mParent->mFrameType == eIFrame && aPO->mParent != mPrt->mSelectedPO;
|
|
|
|
skipSetTitle = PR_TRUE;
|
|
|
|
} else {
|
2001-04-13 16:32:18 +04:00
|
|
|
skipPageEjectOnly = aPO->mKids.Count() > 0;
|
2001-04-12 17:04:29 +04:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
2002-01-01 15:58:53 +03:00
|
|
|
case nsIPrintSettings::kEachFrameSep:
|
2001-04-12 17:04:29 +04:00
|
|
|
skipAllPageAdjustments = PR_TRUE;
|
|
|
|
doOffsetting = PR_TRUE;
|
|
|
|
doAddInParentsOffset = aPO->mParent != nsnull && aPO->mParent->mFrameType == eIFrame;
|
|
|
|
skipSetTitle = PR_TRUE;
|
|
|
|
break;
|
|
|
|
} // switch
|
2001-01-08 23:26:05 +03:00
|
|
|
} else {
|
2001-04-12 17:04:29 +04:00
|
|
|
// FrameSets skip page eject only if printing AsIs
|
|
|
|
skipPageEjectOnly = aPO->mPrintAsIs;
|
1999-05-06 23:25:40 +04:00
|
|
|
}
|
|
|
|
|
2001-04-12 17:04:29 +04:00
|
|
|
// That we are all configured,
|
|
|
|
// let's set everything up to print
|
|
|
|
if (skipPageEjectOnly) {
|
|
|
|
pageSequence->SkipPageEnd();
|
|
|
|
aPO->mSkippedPageEject = PR_TRUE;
|
2000-10-20 01:49:12 +04:00
|
|
|
|
2001-04-12 17:04:29 +04:00
|
|
|
} else {
|
2001-01-27 17:09:34 +03:00
|
|
|
|
2001-04-12 17:04:29 +04:00
|
|
|
if (skipAllPageAdjustments) {
|
|
|
|
pageSequence->SuppressHeadersAndFooters(PR_TRUE);
|
|
|
|
pageSequence->SkipPageBegin();
|
|
|
|
pageSequence->SkipPageEnd();
|
|
|
|
aPO->mSkippedPageEject = PR_TRUE;
|
|
|
|
} else {
|
|
|
|
aPO->mSkippedPageEject = PR_FALSE;
|
|
|
|
}
|
1999-05-14 18:40:59 +04:00
|
|
|
|
2001-04-12 17:04:29 +04:00
|
|
|
if (doOffsetting) {
|
|
|
|
nscoord x = 0;
|
|
|
|
nscoord y = 0;
|
|
|
|
PrintObject * po = aPO;
|
|
|
|
while (po != nsnull) {
|
2002-01-01 15:58:53 +03:00
|
|
|
//if (mPrt->mPrintFrameType != nsIPrintSettings::kSelectedFrame || po != aPO->mParent) {
|
2001-04-12 17:04:29 +04:00
|
|
|
PRBool isParent = po == aPO->mParent;
|
|
|
|
if (!isParent || (isParent && doAddInParentsOffset)) {
|
|
|
|
x += po->mRect.x;
|
|
|
|
y += po->mRect.y;
|
2001-01-27 17:09:34 +03:00
|
|
|
}
|
2001-04-12 17:04:29 +04:00
|
|
|
po = po->mParent;
|
2001-01-27 17:09:34 +03:00
|
|
|
}
|
2001-04-12 17:04:29 +04:00
|
|
|
pageSequence->SetOffset(x, y);
|
2001-01-27 17:09:34 +03:00
|
|
|
}
|
|
|
|
}
|
2000-10-20 01:49:12 +04:00
|
|
|
|
2001-04-12 17:04:29 +04:00
|
|
|
PRINT_DEBUG_MSG5("*** skipPageEjectOnly: %s skipAllPageAdjustments: %s doOffsetting: %s doAddInParentsOffset: %s\n",
|
|
|
|
PRT_YESNO(skipPageEjectOnly), PRT_YESNO(skipAllPageAdjustments),
|
|
|
|
PRT_YESNO(doOffsetting), PRT_YESNO(doAddInParentsOffset));
|
1999-05-14 18:40:59 +04:00
|
|
|
|
2002-01-01 15:58:53 +03:00
|
|
|
// mPrt->mDebugFilePtr this is onlu non-null when compiled for debugging
|
|
|
|
if (nsnull != mPrt->mDebugFilePtr) {
|
|
|
|
#ifdef NS_DEBUG
|
2000-01-26 18:14:41 +03:00
|
|
|
// output the regression test
|
|
|
|
nsIFrameDebug* fdbg;
|
|
|
|
nsIFrame* root;
|
2001-04-12 17:04:29 +04:00
|
|
|
poPresShell->GetRootFrame(&root);
|
2000-01-26 18:14:41 +03:00
|
|
|
|
2001-08-01 07:15:50 +04:00
|
|
|
if (NS_SUCCEEDED(CallQueryInterface(root, &fdbg))) {
|
2002-01-01 15:58:53 +03:00
|
|
|
fdbg->DumpRegressionData(poPresContext, mPrt->mDebugFilePtr, 0, PR_TRUE);
|
2000-01-26 18:14:41 +03:00
|
|
|
}
|
2002-01-01 15:58:53 +03:00
|
|
|
fclose(mPrt->mDebugFilePtr);
|
|
|
|
#endif
|
2000-01-26 18:14:41 +03:00
|
|
|
} else {
|
2001-01-27 17:09:34 +03:00
|
|
|
nsIFrame* rootFrame;
|
2001-04-12 17:04:29 +04:00
|
|
|
poPresShell->GetRootFrame(&rootFrame);
|
2001-01-27 17:09:34 +03:00
|
|
|
|
2001-11-03 17:59:39 +03:00
|
|
|
#if defined(DEBUG_rods) || defined(DEBUG_dconeX)
|
2002-02-20 06:21:25 +03:00
|
|
|
if (aPO->IsPrintable()) {
|
2001-11-03 17:59:39 +03:00
|
|
|
char * docStr;
|
|
|
|
char * urlStr;
|
|
|
|
GetDocTitleAndURL(aPO, docStr, urlStr);
|
|
|
|
DumpLayoutData(docStr, urlStr, poPresContext, mPrt->mPrintDocDC, rootFrame, webShell);
|
|
|
|
if (docStr) nsMemory::Free(docStr);
|
|
|
|
if (urlStr) nsMemory::Free(urlStr);
|
|
|
|
}
|
2001-01-27 17:09:34 +03:00
|
|
|
#endif
|
|
|
|
|
2002-01-01 15:58:53 +03:00
|
|
|
if (mPrt->mPrintSettings) {
|
2001-04-12 17:04:29 +04:00
|
|
|
if (!skipSetTitle) {
|
|
|
|
PRUnichar * docTitleStr;
|
|
|
|
PRUnichar * docURLStr;
|
2002-03-27 06:02:42 +03:00
|
|
|
GetDisplayTitleAndURL(aPO, mPrt->mPrintSettings, mPrt->mBrandName, &docTitleStr, &docURLStr, eDocTitleDefBlank);
|
2001-07-10 02:43:17 +04:00
|
|
|
|
2002-02-12 16:33:39 +03:00
|
|
|
// Set them down into the PrintOptions so
|
|
|
|
// they can used by the DeviceContext
|
2001-04-12 17:04:29 +04:00
|
|
|
if (docTitleStr) {
|
2002-01-12 15:31:05 +03:00
|
|
|
mPrt->mPrintOptions->SetTitle(docTitleStr);
|
2001-04-12 17:04:29 +04:00
|
|
|
nsMemory::Free(docTitleStr);
|
|
|
|
}
|
2001-01-27 17:09:34 +03:00
|
|
|
|
2001-04-12 17:04:29 +04:00
|
|
|
if (docURLStr) {
|
2002-01-12 15:31:05 +03:00
|
|
|
mPrt->mPrintOptions->SetDocURL(docURLStr);
|
2001-04-12 17:04:29 +04:00
|
|
|
nsMemory::Free(docURLStr);
|
|
|
|
}
|
|
|
|
}
|
2001-01-27 17:09:34 +03:00
|
|
|
|
2002-01-01 15:58:53 +03:00
|
|
|
if (nsIPrintSettings::kRangeSelection == printRangeType) {
|
2001-04-12 17:04:29 +04:00
|
|
|
poPresContext->SetIsRenderingOnlySelection(PR_TRUE);
|
2001-01-27 17:09:34 +03:00
|
|
|
// temporarily creating rendering context
|
|
|
|
// which is needed to dinf the selection frames
|
|
|
|
nsCOMPtr<nsIRenderingContext> rc;
|
2001-04-12 17:04:29 +04:00
|
|
|
mPrt->mPrintDocDC->CreateRenderingContext(*getter_AddRefs(rc));
|
2001-01-27 17:09:34 +03:00
|
|
|
|
|
|
|
// find the starting and ending page numbers
|
|
|
|
// via the selection
|
|
|
|
nsIFrame* startFrame;
|
|
|
|
nsIFrame* endFrame;
|
|
|
|
PRInt32 startPageNum;
|
|
|
|
PRInt32 endPageNum;
|
|
|
|
nsRect startRect;
|
|
|
|
nsRect endRect;
|
2001-04-12 17:04:29 +04:00
|
|
|
|
|
|
|
nsCOMPtr<nsISelection> selectionPS;
|
|
|
|
nsresult rvv = GetDocumentSelection(getter_AddRefs(selectionPS), poPresShell);
|
|
|
|
if (NS_SUCCEEDED(rvv) && selectionPS) {
|
|
|
|
}
|
|
|
|
|
|
|
|
rv = GetPageRangeForSelection(poPresShell, poPresContext, *rc, selectionPS, pageSequence,
|
2001-01-27 17:09:34 +03:00
|
|
|
&startFrame, startPageNum, startRect,
|
|
|
|
&endFrame, endPageNum, endRect);
|
|
|
|
if (NS_SUCCEEDED(rv)) {
|
2002-01-01 15:58:53 +03:00
|
|
|
mPrt->mPrintSettings->SetStartPageRange(startPageNum);
|
|
|
|
mPrt->mPrintSettings->SetEndPageRange(endPageNum);
|
2001-04-12 17:04:29 +04:00
|
|
|
nsMargin margin(0,0,0,0);
|
2002-01-01 15:58:53 +03:00
|
|
|
mPrt->mPrintSettings->GetMarginInTwips(margin);
|
2001-04-12 17:04:29 +04:00
|
|
|
|
2001-01-27 17:09:34 +03:00
|
|
|
if (startPageNum == endPageNum) {
|
|
|
|
nsIFrame * seqFrame;
|
2001-08-01 07:15:50 +04:00
|
|
|
if (NS_FAILED(CallQueryInterface(pageSequence, &seqFrame))) {
|
2001-11-03 17:59:39 +03:00
|
|
|
mIsDoingPrinting = PR_FALSE;
|
2001-01-27 17:09:34 +03:00
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
}
|
|
|
|
nsRect rect(0,0,0,0);
|
|
|
|
nsRect areaRect;
|
2001-04-12 17:04:29 +04:00
|
|
|
nsIFrame * areaFrame = FindFrameByType(poPresContext, startFrame, nsHTMLAtoms::body, rect, areaRect);
|
2001-01-27 17:09:34 +03:00
|
|
|
if (areaFrame) {
|
2002-02-12 16:33:39 +03:00
|
|
|
nsRect areaRect;
|
|
|
|
areaFrame->GetRect(areaRect);
|
|
|
|
startRect.y -= margin.top+areaRect.y;
|
2001-11-03 17:59:39 +03:00
|
|
|
endRect.y -= margin.top;
|
2001-04-12 17:04:29 +04:00
|
|
|
areaRect.y -= startRect.y;
|
|
|
|
areaRect.x -= margin.left;
|
2001-11-03 17:59:39 +03:00
|
|
|
// XXX This is temporary fix for printing more than one page of a selection
|
|
|
|
pageSequence->SetSelectionHeight(startRect.y, endRect.y+endRect.height-startRect.y);
|
2002-02-12 16:33:39 +03:00
|
|
|
|
|
|
|
// calc total pages by getting calculating the selection's height
|
|
|
|
// and then dividing it by how page content frames will fit.
|
|
|
|
nscoord selectionHgt = endRect.y + endRect.height - startRect.y;
|
|
|
|
PRInt32 pageWidth, pageHeight;
|
|
|
|
mPrt->mPrintDocDC->GetDeviceSurfaceDimensions(pageWidth, pageHeight);
|
|
|
|
nsMargin margin(0,0,0,0);
|
|
|
|
mPrt->mPrintSettings->GetMarginInTwips(margin);
|
|
|
|
pageHeight -= margin.top + margin.bottom;
|
|
|
|
PRInt32 totalPages = PRInt32((float(selectionHgt) / float(pageHeight))+0.99);
|
|
|
|
pageSequence->SetTotalNumPages(totalPages);
|
2001-01-27 17:09:34 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2001-11-03 17:59:39 +03:00
|
|
|
nsCOMPtr<nsIPrintPreviewContext> ppContext = do_QueryInterface(poPresContext);
|
|
|
|
if (!ppContext) {
|
|
|
|
nsIFrame * seqFrame;
|
|
|
|
if (NS_FAILED(CallQueryInterface(pageSequence, &seqFrame))) {
|
|
|
|
mIsDoingPrinting = PR_FALSE;
|
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
}
|
2001-01-27 17:09:34 +03:00
|
|
|
|
2001-11-03 17:59:39 +03:00
|
|
|
nsRect srect;
|
|
|
|
seqFrame->GetRect(srect);
|
2001-01-27 17:09:34 +03:00
|
|
|
|
2001-11-03 17:59:39 +03:00
|
|
|
nsRect r;
|
|
|
|
poRootView->GetBounds(r);
|
2001-12-01 17:31:45 +03:00
|
|
|
r.x = r.y = 0;
|
2001-11-03 17:59:39 +03:00
|
|
|
r.height = srect.height;
|
2001-12-01 17:31:45 +03:00
|
|
|
aPO->mViewManager->ResizeView(poRootView, r, PR_FALSE);
|
2001-01-27 17:09:34 +03:00
|
|
|
|
2001-11-03 17:59:39 +03:00
|
|
|
rootFrame->GetRect(r);
|
2001-04-12 17:04:29 +04:00
|
|
|
|
2001-11-03 17:59:39 +03:00
|
|
|
r.height = srect.height;
|
|
|
|
rootFrame->SetRect(poPresContext, r);
|
2001-03-27 15:56:03 +04:00
|
|
|
|
2001-11-03 17:59:39 +03:00
|
|
|
mPageSeqFrame = pageSequence;
|
2002-01-01 15:58:53 +03:00
|
|
|
mPageSeqFrame->StartPrint(poPresContext, mPrt->mPrintSettings);
|
2001-04-12 17:04:29 +04:00
|
|
|
|
2001-11-03 17:59:39 +03:00
|
|
|
if (!aDoSyncPrinting) {
|
|
|
|
// Get the delay time in between the printing of each page
|
|
|
|
// this gives the user more time to press cancel
|
|
|
|
PRInt32 printPageDelay = 500;
|
2002-01-01 15:58:53 +03:00
|
|
|
mPrt->mPrintSettings->GetPrintPageDelay(&printPageDelay);
|
2001-04-12 17:04:29 +04:00
|
|
|
|
2002-03-23 19:48:58 +03:00
|
|
|
// We are done preparing for printing, so we can turn this off
|
|
|
|
mPrt->mPreparingForPrint = PR_FALSE;
|
|
|
|
|
2001-11-03 17:59:39 +03:00
|
|
|
// Schedule Page to Print
|
|
|
|
PRINT_DEBUG_MSG3("Scheduling Print of PO: %p (%s) \n", aPO, gFrameTypesStr[aPO->mFrameType]);
|
2002-01-01 15:58:53 +03:00
|
|
|
StartPagePrintTimer(poPresContext, mPrt->mPrintSettings, aPO, printPageDelay);
|
2001-11-03 17:59:39 +03:00
|
|
|
} else {
|
|
|
|
DoProgressForAsIsFrames();
|
|
|
|
// Print the page synchronously
|
|
|
|
PRINT_DEBUG_MSG3("Async Print of PO: %p (%s) \n", aPO, gFrameTypesStr[aPO->mFrameType]);
|
2002-02-12 16:33:39 +03:00
|
|
|
PRBool inRange;
|
|
|
|
aDonePrinting = PrintPage(poPresContext, mPrt->mPrintSettings, aPO, inRange);
|
2001-11-03 17:59:39 +03:00
|
|
|
}
|
2001-03-27 15:56:03 +04:00
|
|
|
}
|
2001-01-27 17:09:34 +03:00
|
|
|
} else {
|
|
|
|
// not sure what to do here!
|
2001-11-03 17:59:39 +03:00
|
|
|
mIsDoingPrinting = PR_FALSE;
|
2001-01-27 17:09:34 +03:00
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
}
|
2000-01-26 18:14:41 +03:00
|
|
|
}
|
2001-04-12 17:04:29 +04:00
|
|
|
} else {
|
|
|
|
aPO->mDontPrint = PR_TRUE;
|
|
|
|
aDonePrinting = PR_FALSE;
|
|
|
|
}
|
|
|
|
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
//-------------------------------------------------------
|
|
|
|
// Figure out how many documents and how many total pages we are printing
|
|
|
|
void
|
|
|
|
DocumentViewerImpl::CalcNumPrintableDocsAndPages(PRInt32& aNumDocs, PRInt32& aNumPages)
|
|
|
|
{
|
|
|
|
aNumPages = 0;
|
|
|
|
// Count the number of printable documents
|
|
|
|
// and printable pages
|
|
|
|
PRInt32 numOfPrintableDocs = 0;
|
|
|
|
PRInt32 i;
|
|
|
|
for (i=0;i<mPrt->mPrintDocList->Count();i++) {
|
|
|
|
PrintObject* po = (PrintObject*)mPrt->mPrintDocList->ElementAt(i);
|
|
|
|
NS_ASSERTION(po, "PrintObject can't be null!");
|
|
|
|
if (po->IsPrintable()) {
|
2001-08-01 07:15:50 +04:00
|
|
|
if (po->mPresShell &&
|
|
|
|
po->mFrameType != eIFrame &&
|
|
|
|
po->mFrameType != eFrameSet) {
|
2001-04-12 17:04:29 +04:00
|
|
|
nsIPageSequenceFrame* pageSequence;
|
|
|
|
po->mPresShell->GetPageSequenceFrame(&pageSequence);
|
|
|
|
nsIFrame * seqFrame;
|
2001-08-01 07:15:50 +04:00
|
|
|
if (NS_SUCCEEDED(CallQueryInterface(pageSequence, &seqFrame))) {
|
2001-04-12 17:04:29 +04:00
|
|
|
nsIFrame* frame;
|
|
|
|
seqFrame->FirstChild(po->mPresContext, nsnull, &frame);
|
|
|
|
while (frame) {
|
|
|
|
aNumPages++;
|
|
|
|
frame->GetNextSibling(&frame);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
numOfPrintableDocs++;
|
|
|
|
}
|
1999-09-22 11:34:31 +04:00
|
|
|
}
|
2001-04-12 17:04:29 +04:00
|
|
|
}
|
2001-02-07 02:03:17 +03:00
|
|
|
|
2001-04-12 17:04:29 +04:00
|
|
|
//-------------------------------------------------------
|
|
|
|
void
|
|
|
|
DocumentViewerImpl::DoProgressForAsIsFrames()
|
|
|
|
{
|
2002-01-01 15:58:53 +03:00
|
|
|
// mPrintFrameType is set to kFramesAsIs event though the Doc Type maybe eDoc
|
|
|
|
// this is done to make the printing of embedded IFrames easier
|
|
|
|
// NOTE: we don't want to advance the progress in that case, it is down elsewhere
|
|
|
|
if (mPrt->mPrintFrameType == nsIPrintSettings::kFramesAsIs && mPrt->mPrintObject->mFrameType != eDoc) {
|
|
|
|
mPrt->mNumDocsPrinted++;
|
|
|
|
PrintData::DoOnProgressChange(mPrt->mPrintProgressListeners, mPrt->mNumDocsPrinted, mPrt->mNumPrintableDocs);
|
2001-02-07 02:03:17 +03:00
|
|
|
}
|
2001-04-12 17:04:29 +04:00
|
|
|
}
|
2001-02-07 02:03:17 +03:00
|
|
|
|
2001-04-12 17:04:29 +04:00
|
|
|
//-------------------------------------------------------
|
|
|
|
void
|
|
|
|
DocumentViewerImpl::DoProgressForSeparateFrames()
|
|
|
|
{
|
2002-01-01 15:58:53 +03:00
|
|
|
if (mPrt->mPrintFrameType == nsIPrintSettings::kEachFrameSep) {
|
|
|
|
mPrt->mNumPagesPrinted++;
|
|
|
|
// notify the listener of printed docs
|
|
|
|
PrintData::DoOnProgressChange(mPrt->mPrintProgressListeners, mPrt->mNumPagesPrinted+1, mPrt->mNumPrintablePages);
|
2001-04-12 17:04:29 +04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
//-------------------------------------------------------
|
|
|
|
// Called for each WebShell that needs to be printed
|
|
|
|
PRBool
|
|
|
|
DocumentViewerImpl::PrintDocContent(PrintObject* aPO, nsresult& aStatus)
|
|
|
|
{
|
|
|
|
NS_ASSERTION(aPO, "Pointer is null!");
|
|
|
|
|
2001-08-06 06:27:43 +04:00
|
|
|
|
2001-04-12 17:04:29 +04:00
|
|
|
if (!aPO->mHasBeenPrinted && aPO->IsPrintable()) {
|
|
|
|
PRBool donePrinting;
|
|
|
|
// donePrinting is only valid when when doing synchronous printing
|
|
|
|
aStatus = DoPrint(aPO, PR_FALSE, donePrinting);
|
|
|
|
if (donePrinting) {
|
|
|
|
return PR_TRUE;
|
|
|
|
}
|
|
|
|
}
|
1999-05-12 17:32:09 +04:00
|
|
|
|
2001-04-12 17:04:29 +04:00
|
|
|
for (PRInt32 i=0;i<aPO->mKids.Count();i++) {
|
|
|
|
PrintObject* po = (PrintObject*)aPO->mKids[i];
|
|
|
|
PRBool printed = PrintDocContent(po, aStatus);
|
|
|
|
if (printed || NS_FAILED(aStatus)) {
|
|
|
|
return PR_TRUE;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return PR_FALSE;
|
1999-05-12 17:32:09 +04:00
|
|
|
}
|
|
|
|
|
1999-05-07 23:26:23 +04:00
|
|
|
NS_IMETHODIMP
|
|
|
|
DocumentViewerImpl::SetEnableRendering(PRBool aOn)
|
|
|
|
{
|
2001-03-10 06:19:36 +03:00
|
|
|
NS_ENSURE_TRUE(mDocument, NS_ERROR_NOT_AVAILABLE);
|
1999-05-07 23:26:23 +04:00
|
|
|
mEnableRendering = aOn;
|
|
|
|
if (mViewManager) {
|
|
|
|
if (aOn) {
|
2000-02-09 18:48:01 +03:00
|
|
|
mViewManager->EnableRefresh(NS_VMREFRESH_IMMEDIATE);
|
1999-05-14 00:27:47 +04:00
|
|
|
nsIView* view;
|
|
|
|
mViewManager->GetRootView(view); // views are not refCounted
|
|
|
|
if (view) {
|
1999-11-14 05:51:25 +03:00
|
|
|
mViewManager->UpdateView(view, NS_VMREFRESH_IMMEDIATE);
|
1999-05-14 00:27:47 +04:00
|
|
|
}
|
1999-05-07 23:26:23 +04:00
|
|
|
}
|
|
|
|
else {
|
|
|
|
mViewManager->DisableRefresh();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
DocumentViewerImpl::GetEnableRendering(PRBool* aResult)
|
|
|
|
{
|
2001-03-10 06:19:36 +03:00
|
|
|
NS_ENSURE_TRUE(mDocument, NS_ERROR_NOT_AVAILABLE);
|
1999-05-07 23:26:23 +04:00
|
|
|
NS_PRECONDITION(nsnull != aResult, "null OUT ptr");
|
|
|
|
if (aResult) {
|
|
|
|
*aResult = mEnableRendering;
|
|
|
|
}
|
1999-05-06 23:25:40 +04:00
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
1999-05-07 23:26:23 +04:00
|
|
|
void
|
|
|
|
DocumentViewerImpl::ForceRefresh()
|
1999-05-06 23:25:40 +04:00
|
|
|
{
|
|
|
|
mWindow->Invalidate(PR_TRUE);
|
|
|
|
}
|
|
|
|
|
|
|
|
nsresult
|
|
|
|
DocumentViewerImpl::CreateStyleSet(nsIDocument* aDocument,
|
|
|
|
nsIStyleSet** aStyleSet)
|
|
|
|
{
|
|
|
|
// this should eventually get expanded to allow for creating
|
|
|
|
// different sets for different media
|
|
|
|
nsresult rv;
|
|
|
|
|
|
|
|
if (!mUAStyleSheet) {
|
|
|
|
NS_WARNING("unable to load UA style sheet");
|
|
|
|
}
|
|
|
|
|
2001-08-01 07:15:50 +04:00
|
|
|
rv = CallCreateInstance(kStyleSetCID, aStyleSet);
|
1999-05-06 23:25:40 +04:00
|
|
|
if (NS_OK == rv) {
|
2001-06-20 07:27:48 +04:00
|
|
|
PRInt32 index = 0;
|
|
|
|
aDocument->GetNumberOfStyleSheets(&index);
|
1999-05-06 23:25:40 +04:00
|
|
|
|
|
|
|
while (0 < index--) {
|
2001-06-20 07:27:48 +04:00
|
|
|
nsCOMPtr<nsIStyleSheet> sheet;
|
|
|
|
aDocument->GetStyleSheetAt(index, getter_AddRefs(sheet));
|
1999-10-22 02:20:37 +04:00
|
|
|
|
|
|
|
/*
|
|
|
|
* GetStyleSheetAt will return all style sheets in the document but
|
|
|
|
* we're only interested in the ones that are enabled.
|
|
|
|
*/
|
|
|
|
|
|
|
|
PRBool styleEnabled;
|
|
|
|
sheet->GetEnabled(styleEnabled);
|
|
|
|
|
|
|
|
if (styleEnabled) {
|
|
|
|
(*aStyleSet)->AddDocStyleSheet(sheet, aDocument);
|
|
|
|
}
|
1999-05-06 23:25:40 +04:00
|
|
|
}
|
2000-04-29 03:32:51 +04:00
|
|
|
|
2001-07-25 11:54:28 +04:00
|
|
|
nsCOMPtr<nsIChromeRegistry> chromeRegistry =
|
|
|
|
do_GetService("@mozilla.org/chrome/chrome-registry;1", &rv);
|
2000-04-29 03:32:51 +04:00
|
|
|
if (NS_SUCCEEDED(rv) && chromeRegistry) {
|
|
|
|
nsCOMPtr<nsISupportsArray> sheets;
|
2000-08-29 12:07:22 +04:00
|
|
|
|
|
|
|
// Now handle the user sheets.
|
|
|
|
nsCOMPtr<nsIDocShellTreeItem> docShell(do_QueryInterface(mContainer));
|
|
|
|
PRInt32 shellType;
|
|
|
|
docShell->GetItemType(&shellType);
|
|
|
|
PRBool isChrome = (shellType == nsIDocShellTreeItem::typeChrome);
|
|
|
|
sheets = nsnull;
|
|
|
|
chromeRegistry->GetUserSheets(isChrome, getter_AddRefs(sheets));
|
|
|
|
if(sheets){
|
|
|
|
nsCOMPtr<nsICSSStyleSheet> sheet;
|
|
|
|
PRUint32 count;
|
|
|
|
sheets->Count(&count);
|
|
|
|
for(PRUint32 i=0; i<count; i++) {
|
|
|
|
sheets->GetElementAt(i, getter_AddRefs(sheet));
|
2001-11-06 13:04:05 +03:00
|
|
|
(*aStyleSet)->AppendUserStyleSheet(sheet);
|
2000-08-29 12:07:22 +04:00
|
|
|
}
|
|
|
|
}
|
2001-05-02 14:45:07 +04:00
|
|
|
|
|
|
|
// Append chrome sheets (scrollbars + forms).
|
|
|
|
nsCOMPtr<nsIDocShell> ds(do_QueryInterface(mContainer));
|
2001-11-06 13:04:05 +03:00
|
|
|
chromeRegistry->GetAgentSheets(ds, getter_AddRefs(sheets));
|
2001-05-02 14:45:07 +04:00
|
|
|
if(sheets){
|
|
|
|
nsCOMPtr<nsICSSStyleSheet> sheet;
|
|
|
|
PRUint32 count;
|
|
|
|
sheets->Count(&count);
|
|
|
|
for(PRUint32 i=0; i<count; i++) {
|
|
|
|
sheets->GetElementAt(i, getter_AddRefs(sheet));
|
2001-11-06 13:04:05 +03:00
|
|
|
(*aStyleSet)->AppendAgentStyleSheet(sheet);
|
2001-05-02 14:45:07 +04:00
|
|
|
}
|
|
|
|
}
|
2000-04-29 03:32:51 +04:00
|
|
|
}
|
2000-05-01 11:58:07 +04:00
|
|
|
|
|
|
|
if (mUAStyleSheet) {
|
2001-11-06 13:04:05 +03:00
|
|
|
(*aStyleSet)->AppendAgentStyleSheet(mUAStyleSheet);
|
2000-05-01 11:58:07 +04:00
|
|
|
}
|
1999-05-06 23:25:40 +04:00
|
|
|
}
|
2000-10-01 09:24:00 +04:00
|
|
|
return NS_OK;
|
1999-05-06 23:25:40 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
nsresult
|
2000-03-11 04:24:59 +03:00
|
|
|
DocumentViewerImpl::MakeWindow(nsIWidget* aParentWidget,
|
|
|
|
const nsRect& aBounds)
|
1999-05-06 23:25:40 +04:00
|
|
|
{
|
|
|
|
nsresult rv;
|
|
|
|
|
2001-08-01 07:15:50 +04:00
|
|
|
mViewManager = do_CreateInstance(kViewManagerCID, &rv);
|
|
|
|
if (NS_FAILED(rv))
|
|
|
|
return rv;
|
1999-05-06 23:25:40 +04:00
|
|
|
|
|
|
|
nsCOMPtr<nsIDeviceContext> dx;
|
|
|
|
mPresContext->GetDeviceContext(getter_AddRefs(dx));
|
|
|
|
|
2000-03-24 02:50:42 +03:00
|
|
|
|
1999-05-06 23:25:40 +04:00
|
|
|
nsRect tbounds = aBounds;
|
|
|
|
float p2t;
|
|
|
|
mPresContext->GetPixelsToTwips(&p2t);
|
|
|
|
tbounds *= p2t;
|
|
|
|
|
2001-08-01 07:15:50 +04:00
|
|
|
// Initialize the view manager with an offset. This allows the viewmanager
|
|
|
|
// to manage a coordinate space offset from (0,0)
|
2001-12-01 17:31:45 +03:00
|
|
|
rv = mViewManager->Init(dx);
|
|
|
|
if (NS_FAILED(rv))
|
|
|
|
return rv;
|
|
|
|
rv = mViewManager->SetWindowOffset(tbounds.x, tbounds.y);
|
2001-08-01 07:15:50 +04:00
|
|
|
if (NS_FAILED(rv))
|
2000-03-24 02:50:42 +03:00
|
|
|
return rv;
|
2001-08-01 07:15:50 +04:00
|
|
|
|
2000-03-24 02:50:42 +03:00
|
|
|
// Reset the bounds offset so the root view is set to 0,0. The offset is
|
|
|
|
// specified in nsIViewManager::Init above.
|
|
|
|
// Besides, layout will reset the root view to (0,0) during reflow,
|
|
|
|
// so changing it to 0,0 eliminates placing
|
|
|
|
// the root view in the wrong place initially.
|
|
|
|
tbounds.x = 0;
|
|
|
|
tbounds.y = 0;
|
|
|
|
|
1999-05-06 23:25:40 +04:00
|
|
|
// Create a child window of the parent that is our "root view/window"
|
|
|
|
// Create a view
|
2001-08-01 07:15:50 +04:00
|
|
|
rv = CallCreateInstance(kViewCID, &mView);
|
|
|
|
if (NS_FAILED(rv))
|
|
|
|
return rv;
|
2002-02-20 00:33:26 +03:00
|
|
|
|
|
|
|
// if aParentWidget has a view, we'll hook our view manager up to its view tree
|
|
|
|
void* clientData;
|
|
|
|
nsIView* containerView = nsnull;
|
|
|
|
if (NS_SUCCEEDED(aParentWidget->GetClientData(clientData))) {
|
|
|
|
nsISupports* data = (nsISupports*)clientData;
|
|
|
|
|
|
|
|
if (nsnull != data) {
|
|
|
|
data->QueryInterface(NS_GET_IID(nsIView), (void **)&containerView);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (nsnull != containerView) {
|
|
|
|
// see if the containerView has already been hooked into a foreign view manager hierarchy
|
|
|
|
// if it has, then we have to hook into the hierarchy too otherwise bad things will happen.
|
|
|
|
nsCOMPtr<nsIViewManager> containerVM;
|
|
|
|
containerView->GetViewManager(*getter_AddRefs(containerVM));
|
|
|
|
nsCOMPtr<nsIViewManager> checkVM;
|
|
|
|
nsIView* pView = containerView;
|
|
|
|
do {
|
|
|
|
pView->GetParent(pView);
|
|
|
|
} while (pView != nsnull
|
|
|
|
&& NS_SUCCEEDED(pView->GetViewManager(*getter_AddRefs(checkVM))) && checkVM == containerVM);
|
|
|
|
|
|
|
|
if (nsnull == pView) {
|
|
|
|
// OK, so the container is not already hooked up into a foreign view manager hierarchy.
|
|
|
|
// That means we can choose not to hook ourselves up.
|
|
|
|
//
|
|
|
|
// If the parent container is a chrome shell, or a frameset, then we won't hook into its view
|
|
|
|
// tree. This will improve performance a little bit (especially given scrolling/painting perf bugs)
|
|
|
|
// but is really just for peace of mind. This check can be removed if we want to support fancy
|
|
|
|
// chrome effects like transparent controls floating over content, transparent Web browsers, and
|
|
|
|
// things like that, and the perf bugs are fixed.
|
|
|
|
nsCOMPtr<nsIDocShellTreeItem> container(do_QueryInterface(mContainer));
|
|
|
|
nsCOMPtr<nsIDocShellTreeItem> parentContainer;
|
|
|
|
PRInt32 itemType;
|
|
|
|
if (nsnull == container
|
|
|
|
|| NS_FAILED(container->GetParent(getter_AddRefs(parentContainer)))
|
|
|
|
|| nsnull == parentContainer
|
|
|
|
|| NS_FAILED(parentContainer->GetItemType(&itemType))
|
|
|
|
|| itemType != nsIDocShellTreeItem::typeContent) {
|
|
|
|
containerView = nsnull;
|
|
|
|
} else {
|
|
|
|
nsCOMPtr<nsIWebShell> webShell(do_QueryInterface(parentContainer));
|
|
|
|
if (nsnull == webShell || IsWebShellAFrameSet(webShell)) {
|
|
|
|
containerView = nsnull;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
rv = mView->Init(mViewManager, tbounds, containerView);
|
2001-08-01 07:15:50 +04:00
|
|
|
if (NS_FAILED(rv))
|
1999-05-06 23:25:40 +04:00
|
|
|
return rv;
|
|
|
|
|
2001-10-31 08:06:31 +03:00
|
|
|
rv = mView->CreateWidget(kWidgetCID, nsnull,
|
|
|
|
aParentWidget->GetNativeData(NS_NATIVE_WIDGET),
|
|
|
|
PR_TRUE, PR_FALSE);
|
1999-05-06 23:25:40 +04:00
|
|
|
if (rv != NS_OK)
|
|
|
|
return rv;
|
|
|
|
|
|
|
|
// Setup hierarchical relationship in view manager
|
|
|
|
mViewManager->SetRootView(mView);
|
|
|
|
|
|
|
|
mView->GetWidget(*getter_AddRefs(mWindow));
|
|
|
|
|
|
|
|
// This SetFocus is necessary so the Arrow Key and Page Key events
|
|
|
|
// go to the scrolled view as soon as the Window is created instead of going to
|
|
|
|
// the browser window (this enables keyboard scrolling of the document)
|
1999-06-04 05:48:38 +04:00
|
|
|
// mWindow->SetFocus();
|
1999-05-06 23:25:40 +04:00
|
|
|
|
|
|
|
return rv;
|
|
|
|
}
|
|
|
|
|
2001-02-07 02:03:17 +03:00
|
|
|
nsresult DocumentViewerImpl::GetDocumentSelection(nsISelection **aSelection, nsIPresShell * aPresShell)
|
2000-01-19 00:06:10 +03:00
|
|
|
{
|
2001-02-07 02:03:17 +03:00
|
|
|
if (aPresShell == nsnull) {
|
|
|
|
if (!mPresShell) {
|
|
|
|
return NS_ERROR_NOT_INITIALIZED;
|
|
|
|
}
|
|
|
|
aPresShell = mPresShell;
|
|
|
|
}
|
2000-01-19 00:06:10 +03:00
|
|
|
if (!aSelection) return NS_ERROR_NULL_POINTER;
|
2001-01-27 17:09:34 +03:00
|
|
|
if (!aPresShell) return NS_ERROR_NULL_POINTER;
|
2001-02-07 02:03:17 +03:00
|
|
|
|
2000-04-27 11:37:12 +04:00
|
|
|
nsCOMPtr<nsISelectionController> selcon;
|
2001-01-27 17:09:34 +03:00
|
|
|
selcon = do_QueryInterface(aPresShell);
|
2000-04-27 11:37:12 +04:00
|
|
|
if (selcon)
|
|
|
|
return selcon->GetSelection(nsISelectionController::SELECTION_NORMAL, aSelection);
|
|
|
|
return NS_ERROR_FAILURE;
|
2000-01-19 00:06:10 +03:00
|
|
|
}
|
|
|
|
|
1999-05-06 23:25:40 +04:00
|
|
|
NS_IMETHODIMP
|
|
|
|
DocumentViewerImpl::CreateDocumentViewerUsing(nsIPresContext* aPresContext,
|
|
|
|
nsIDocumentViewer*& aResult)
|
|
|
|
{
|
|
|
|
if (!mDocument) {
|
|
|
|
// XXX better error
|
|
|
|
return NS_ERROR_NULL_POINTER;
|
|
|
|
}
|
|
|
|
if (nsnull == aPresContext) {
|
|
|
|
return NS_ERROR_NULL_POINTER;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Create new viewer
|
|
|
|
DocumentViewerImpl* viewer = new DocumentViewerImpl(aPresContext);
|
|
|
|
if (nsnull == viewer) {
|
|
|
|
return NS_ERROR_OUT_OF_MEMORY;
|
|
|
|
}
|
|
|
|
NS_ADDREF(viewer);
|
|
|
|
|
|
|
|
// XXX make sure the ua style sheet is used (for now; need to be
|
|
|
|
// able to specify an alternate)
|
|
|
|
viewer->SetUAStyleSheet(mUAStyleSheet);
|
|
|
|
|
|
|
|
// Bind the new viewer to the old document
|
2001-05-25 12:49:03 +04:00
|
|
|
nsresult rv = viewer->LoadStart(mDocument);
|
|
|
|
|
1999-05-06 23:25:40 +04:00
|
|
|
aResult = viewer;
|
|
|
|
|
|
|
|
return rv;
|
|
|
|
}
|
1999-09-22 11:34:31 +04:00
|
|
|
|
|
|
|
void PR_CALLBACK DocumentViewerImpl::HandlePLEvent(PLEvent* aEvent)
|
|
|
|
{
|
|
|
|
DocumentViewerImpl *viewer;
|
|
|
|
|
|
|
|
viewer = (DocumentViewerImpl*)PL_GetEventOwner(aEvent);
|
|
|
|
|
|
|
|
NS_ASSERTION(viewer, "The event owner is null.");
|
|
|
|
if (viewer) {
|
|
|
|
viewer->DocumentReadyForPrinting();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void PR_CALLBACK DocumentViewerImpl::DestroyPLEvent(PLEvent* aEvent)
|
|
|
|
{
|
|
|
|
DocumentViewerImpl *viewer;
|
|
|
|
|
|
|
|
viewer = (DocumentViewerImpl*)PL_GetEventOwner(aEvent);
|
|
|
|
NS_IF_RELEASE(viewer);
|
|
|
|
|
|
|
|
delete aEvent;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2001-03-27 15:56:03 +04:00
|
|
|
nsresult DocumentViewerImpl::DocumentReadyForPrinting()
|
1999-09-22 11:34:31 +04:00
|
|
|
{
|
2001-03-27 15:56:03 +04:00
|
|
|
nsresult rv = NS_ERROR_FAILURE;
|
|
|
|
nsCOMPtr<nsIWebShell> webContainer;
|
1999-09-22 11:34:31 +04:00
|
|
|
|
1999-11-14 13:12:21 +03:00
|
|
|
webContainer = do_QueryInterface(mContainer);
|
1999-09-22 11:34:31 +04:00
|
|
|
if(webContainer) {
|
|
|
|
//
|
|
|
|
// Send the document to the printer...
|
|
|
|
//
|
2001-05-31 05:06:33 +04:00
|
|
|
rv = SetupToPrintContent(webContainer, mPrt->mPrintDC, mPrt->mCurrentFocusWin);
|
2001-03-27 15:56:03 +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
|
2001-04-12 17:04:29 +04:00
|
|
|
DonePrintingPages(nsnull);
|
2001-03-27 15:56:03 +04:00
|
|
|
}
|
1999-09-22 11:34:31 +04:00
|
|
|
}
|
2001-03-27 15:56:03 +04:00
|
|
|
return rv;
|
1999-09-22 11:34:31 +04:00
|
|
|
}
|
|
|
|
|
2000-09-02 19:32:28 +04:00
|
|
|
NS_IMETHODIMP
|
|
|
|
DocumentViewerImpl::SetTransformMediator(nsITransformMediator* aMediator)
|
|
|
|
{
|
|
|
|
NS_ASSERTION(nsnull == mTransformMediator, "nsXMLDocument::SetTransformMediator(): \
|
|
|
|
Cannot set a second transform mediator\n");
|
|
|
|
mTransformMediator = aMediator;
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2000-01-19 00:06:10 +03:00
|
|
|
#ifdef XP_MAC
|
|
|
|
#pragma mark -
|
|
|
|
#endif
|
|
|
|
|
1999-11-19 10:35:27 +03:00
|
|
|
/* ========================================================================================
|
2000-01-19 00:06:10 +03:00
|
|
|
* nsIContentViewerEdit
|
1999-11-19 10:35:27 +03:00
|
|
|
* ======================================================================================== */
|
|
|
|
|
|
|
|
NS_IMETHODIMP DocumentViewerImpl::Search()
|
|
|
|
{
|
|
|
|
NS_ASSERTION(0, "NOT IMPLEMENTED");
|
|
|
|
return NS_ERROR_NOT_IMPLEMENTED;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP DocumentViewerImpl::GetSearchable(PRBool *aSearchable)
|
|
|
|
{
|
|
|
|
NS_ASSERTION(0, "NOT IMPLEMENTED");
|
|
|
|
return NS_ERROR_NOT_IMPLEMENTED;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP DocumentViewerImpl::ClearSelection()
|
|
|
|
{
|
2001-08-09 13:24:26 +04:00
|
|
|
nsresult rv;
|
|
|
|
nsCOMPtr<nsISelection> selection;
|
|
|
|
|
|
|
|
rv = GetDocumentSelection(getter_AddRefs(selection));
|
|
|
|
if (NS_FAILED(rv)) return rv;
|
|
|
|
|
|
|
|
return selection->CollapseToStart();
|
1999-11-19 10:35:27 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP DocumentViewerImpl::SelectAll()
|
|
|
|
{
|
2000-01-19 00:06:10 +03:00
|
|
|
// XXX this is a temporary implementation copied from nsWebShell
|
|
|
|
// for now. I think nsDocument and friends should have some helper
|
|
|
|
// functions to make this easier.
|
2000-09-14 15:45:01 +04:00
|
|
|
nsCOMPtr<nsISelection> selection;
|
2000-01-19 00:06:10 +03:00
|
|
|
nsresult rv;
|
|
|
|
rv = GetDocumentSelection(getter_AddRefs(selection));
|
|
|
|
if (NS_FAILED(rv)) return rv;
|
|
|
|
|
|
|
|
nsCOMPtr<nsIDOMHTMLDocument> htmldoc = do_QueryInterface(mDocument);
|
|
|
|
nsCOMPtr<nsIDOMNode> bodyNode;
|
|
|
|
|
|
|
|
if (htmldoc)
|
|
|
|
{
|
|
|
|
nsCOMPtr<nsIDOMHTMLElement>bodyElement;
|
|
|
|
rv = htmldoc->GetBody(getter_AddRefs(bodyElement));
|
|
|
|
if (NS_FAILED(rv) || !bodyElement) return rv;
|
|
|
|
|
|
|
|
bodyNode = do_QueryInterface(bodyElement);
|
|
|
|
}
|
|
|
|
else if (mDocument)
|
|
|
|
{
|
2001-06-20 07:27:48 +04:00
|
|
|
nsCOMPtr<nsIContent> rootContent;
|
|
|
|
mDocument->GetRootContent(getter_AddRefs(rootContent));
|
2000-01-19 00:06:10 +03:00
|
|
|
bodyNode = do_QueryInterface(rootContent);
|
|
|
|
}
|
|
|
|
if (!bodyNode) return NS_ERROR_FAILURE;
|
|
|
|
|
2000-09-14 15:45:01 +04:00
|
|
|
rv = selection->RemoveAllRanges();
|
2000-01-19 00:06:10 +03:00
|
|
|
if (NS_FAILED(rv)) return rv;
|
|
|
|
|
2001-10-31 09:14:11 +03:00
|
|
|
rv = selection->SelectAllChildren(bodyNode);
|
2000-01-19 00:06:10 +03:00
|
|
|
return rv;
|
1999-11-19 10:35:27 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP DocumentViewerImpl::CopySelection()
|
|
|
|
{
|
2001-04-18 10:06:31 +04:00
|
|
|
NS_ENSURE_TRUE(mPresShell, NS_ERROR_NOT_INITIALIZED);
|
2000-01-19 00:06:10 +03:00
|
|
|
return mPresShell->DoCopy();
|
1999-11-19 10:35:27 +03:00
|
|
|
}
|
|
|
|
|
2001-04-18 10:06:31 +04:00
|
|
|
NS_IMETHODIMP DocumentViewerImpl::CopyLinkLocation()
|
|
|
|
{
|
|
|
|
NS_ENSURE_TRUE(mPresShell, NS_ERROR_NOT_INITIALIZED);
|
|
|
|
nsCOMPtr<nsIDOMNode> node;
|
|
|
|
nsresult rv = GetPopupLinkNode(getter_AddRefs(node));
|
2001-04-20 01:47:17 +04:00
|
|
|
// make noise if we're not in a link
|
2001-04-18 10:06:31 +04:00
|
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
NS_ENSURE_TRUE(node, NS_ERROR_FAILURE);
|
|
|
|
return mPresShell->DoCopyLinkLocation(node);
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP DocumentViewerImpl::CopyImageLocation()
|
|
|
|
{
|
|
|
|
NS_ENSURE_TRUE(mPresShell, NS_ERROR_NOT_INITIALIZED);
|
|
|
|
nsCOMPtr<nsIDOMNode> node;
|
|
|
|
nsresult rv = GetPopupImageNode(getter_AddRefs(node));
|
2001-04-20 01:47:17 +04:00
|
|
|
// make noise if we're not in an image
|
2001-04-18 10:06:31 +04:00
|
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
NS_ENSURE_TRUE(node, NS_ERROR_FAILURE);
|
|
|
|
return mPresShell->DoCopyImageLocation(node);
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP DocumentViewerImpl::CopyImageContents()
|
|
|
|
{
|
|
|
|
NS_ENSURE_TRUE(mPresShell, NS_ERROR_NOT_INITIALIZED);
|
|
|
|
nsCOMPtr<nsIDOMNode> node;
|
|
|
|
nsresult rv = GetPopupImageNode(getter_AddRefs(node));
|
2001-04-20 01:47:17 +04:00
|
|
|
// make noise if we're not in an image
|
2001-04-18 10:06:31 +04:00
|
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
NS_ENSURE_TRUE(node, NS_ERROR_FAILURE);
|
|
|
|
return mPresShell->DoCopyImageContents(node);
|
|
|
|
}
|
|
|
|
|
1999-11-19 10:35:27 +03:00
|
|
|
NS_IMETHODIMP DocumentViewerImpl::GetCopyable(PRBool *aCopyable)
|
|
|
|
{
|
2000-09-14 15:45:01 +04:00
|
|
|
nsCOMPtr<nsISelection> selection;
|
2000-01-19 00:06:10 +03:00
|
|
|
nsresult rv;
|
|
|
|
rv = GetDocumentSelection(getter_AddRefs(selection));
|
|
|
|
if (NS_FAILED(rv)) return rv;
|
|
|
|
|
|
|
|
PRBool isCollapsed;
|
|
|
|
selection->GetIsCollapsed(&isCollapsed);
|
|
|
|
|
2000-02-16 04:39:30 +03:00
|
|
|
*aCopyable = !isCollapsed;
|
2000-01-19 00:06:10 +03:00
|
|
|
return NS_OK;
|
1999-11-19 10:35:27 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP DocumentViewerImpl::CutSelection()
|
|
|
|
{
|
|
|
|
NS_ASSERTION(0, "NOT IMPLEMENTED");
|
|
|
|
return NS_ERROR_NOT_IMPLEMENTED;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP DocumentViewerImpl::GetCutable(PRBool *aCutable)
|
|
|
|
{
|
2000-01-19 00:06:10 +03:00
|
|
|
*aCutable = PR_FALSE; // mm, will this ever be called for an editable document?
|
|
|
|
return NS_OK;
|
1999-11-19 10:35:27 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP DocumentViewerImpl::Paste()
|
|
|
|
{
|
|
|
|
NS_ASSERTION(0, "NOT IMPLEMENTED");
|
|
|
|
return NS_ERROR_NOT_IMPLEMENTED;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP DocumentViewerImpl::GetPasteable(PRBool *aPasteable)
|
|
|
|
{
|
2000-01-19 00:06:10 +03:00
|
|
|
*aPasteable = PR_FALSE;
|
|
|
|
return NS_OK;
|
1999-11-19 10:35:27 +03:00
|
|
|
}
|
|
|
|
|
2000-01-19 00:06:10 +03:00
|
|
|
#ifdef XP_MAC
|
|
|
|
#pragma mark -
|
|
|
|
#endif
|
|
|
|
|
1999-11-19 10:35:27 +03:00
|
|
|
static NS_DEFINE_IID(kDeviceContextSpecFactoryCID, NS_DEVICE_CONTEXT_SPEC_FACTORY_CID);
|
|
|
|
|
2001-01-27 17:09:34 +03:00
|
|
|
nsresult DocumentViewerImpl::GetSelectionDocument(nsIDeviceContextSpec * aDevSpec, nsIDocument ** aNewDoc)
|
|
|
|
{
|
|
|
|
//NS_ENSURE_ARG_POINTER(*aDevSpec);
|
|
|
|
NS_ENSURE_ARG_POINTER(aNewDoc);
|
|
|
|
|
|
|
|
// create document
|
|
|
|
nsCOMPtr<nsIDocument> doc;
|
|
|
|
nsresult rv = NS_NewHTMLDocument(getter_AddRefs(doc));
|
|
|
|
if (NS_FAILED(rv)) { return rv; }
|
|
|
|
if (!doc) { return NS_ERROR_NULL_POINTER; }
|
|
|
|
|
|
|
|
nsCOMPtr<nsINodeInfoManager> nimgr;
|
|
|
|
rv = doc->GetNodeInfoManager(*getter_AddRefs(nimgr));
|
|
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
|
|
|
|
nsCOMPtr<nsINodeInfo> nodeInfo;
|
|
|
|
nimgr->GetNodeInfo(nsHTMLAtoms::html, nsnull, kNameSpaceID_None,
|
|
|
|
*getter_AddRefs(nodeInfo));
|
|
|
|
|
|
|
|
// create document content
|
|
|
|
nsCOMPtr<nsIHTMLContent> htmlElement;
|
|
|
|
nsCOMPtr<nsIHTMLContent> headElement;
|
|
|
|
nsCOMPtr<nsIHTMLContent> bodyElement;
|
|
|
|
// create the root
|
|
|
|
rv = NS_NewHTMLHtmlElement(getter_AddRefs(htmlElement), nodeInfo);
|
|
|
|
if (NS_FAILED(rv)) { return rv; }
|
|
|
|
if (!htmlElement) { return NS_ERROR_NULL_POINTER; }
|
|
|
|
// create the head
|
|
|
|
|
2001-04-26 23:33:12 +04:00
|
|
|
nimgr->GetNodeInfo(NS_LITERAL_STRING("head"), nsnull,
|
2001-01-27 17:09:34 +03:00
|
|
|
kNameSpaceID_None, *getter_AddRefs(nodeInfo));
|
|
|
|
|
|
|
|
rv = NS_NewHTMLHeadElement(getter_AddRefs(headElement), nodeInfo);
|
|
|
|
if (NS_FAILED(rv)) { return rv; }
|
|
|
|
if (!headElement) { return NS_ERROR_NULL_POINTER; }
|
|
|
|
headElement->SetDocument(doc, PR_FALSE, PR_TRUE);
|
|
|
|
// create the body
|
|
|
|
|
|
|
|
nimgr->GetNodeInfo(nsHTMLAtoms::body, nsnull, kNameSpaceID_None,
|
|
|
|
*getter_AddRefs(nodeInfo));
|
|
|
|
|
|
|
|
rv = NS_NewHTMLBodyElement(getter_AddRefs(bodyElement), nodeInfo);
|
|
|
|
if (NS_FAILED(rv)) { return rv; }
|
|
|
|
if (!bodyElement) { return NS_ERROR_NULL_POINTER; }
|
|
|
|
bodyElement->SetDocument(doc, PR_FALSE, PR_TRUE);
|
|
|
|
// put the head and body into the root
|
2001-04-02 04:45:52 +04:00
|
|
|
rv = htmlElement->AppendChildTo(headElement, PR_FALSE, PR_FALSE);
|
2001-01-27 17:09:34 +03:00
|
|
|
if (NS_FAILED(rv)) { return rv; }
|
2001-04-02 04:45:52 +04:00
|
|
|
rv = htmlElement->AppendChildTo(bodyElement, PR_FALSE, PR_FALSE);
|
2001-01-27 17:09:34 +03:00
|
|
|
if (NS_FAILED(rv)) { return rv; }
|
|
|
|
|
|
|
|
// load the document into the docshell
|
|
|
|
nsCOMPtr<nsIDOMDocument> domDoc = do_QueryInterface(doc);
|
|
|
|
if (!domDoc) { return NS_ERROR_NULL_POINTER; }
|
|
|
|
nsCOMPtr<nsIDOMElement> htmlDOMElement = do_QueryInterface(htmlElement);
|
|
|
|
if (!htmlDOMElement) { return NS_ERROR_NULL_POINTER; }
|
|
|
|
|
|
|
|
//nsCOMPtr<nsIContent> rootContent(do_QueryInterface(htmlElement));
|
|
|
|
//doc->SetRootContent(rootContent);
|
|
|
|
|
|
|
|
*aNewDoc = doc.get();
|
|
|
|
NS_ADDREF(*aNewDoc);
|
|
|
|
|
|
|
|
return rv;
|
|
|
|
|
|
|
|
}
|
|
|
|
|
2001-04-12 17:04:29 +04:00
|
|
|
//------------------------------------------------------
|
2001-01-27 17:09:34 +03:00
|
|
|
PRBool
|
2001-02-07 02:03:17 +03:00
|
|
|
DocumentViewerImpl::IsThereAnIFrameSelected(nsIWebShell* aWebShell,
|
|
|
|
nsIDOMWindowInternal * aDOMWin,
|
2001-04-12 17:04:29 +04:00
|
|
|
PRPackedBool& aIsParentFrameSet)
|
2001-02-07 02:03:17 +03:00
|
|
|
{
|
2001-04-12 17:04:29 +04:00
|
|
|
aIsParentFrameSet = IsParentAFrameSet(aWebShell);
|
2001-02-07 02:03:17 +03:00
|
|
|
PRBool iFrameIsSelected = PR_FALSE;
|
2001-04-12 17:04:29 +04:00
|
|
|
#if 1
|
|
|
|
PrintObject* po = FindPrintObjectByDOMWin(mPrt->mPrintObject, aDOMWin);
|
|
|
|
iFrameIsSelected = po && po->mFrameType == eIFrame;
|
|
|
|
#else
|
2001-02-07 02:03:17 +03:00
|
|
|
// First, check to see if we are a frameset
|
2001-04-12 17:04:29 +04:00
|
|
|
if (!aIsParentFrameSet) {
|
2001-02-07 02:03:17 +03:00
|
|
|
// Check to see if there is a currenlt focused frame
|
|
|
|
// if so, it means the selected frame is either the main webshell
|
|
|
|
// or an IFRAME
|
|
|
|
if (aDOMWin != nsnull) {
|
|
|
|
// Get the main webshell's DOMWin to see if it matches
|
|
|
|
// the frame that is selected
|
2001-04-12 17:04:29 +04:00
|
|
|
nsCOMPtr<nsIDOMWindowInternal> domWin = getter_AddRefs(GetDOMWinForWebShell(aWebShell));
|
|
|
|
if (aDOMWin != nsnull && domWin != aDOMWin) {
|
|
|
|
iFrameIsSelected = PR_TRUE; // we have a selected IFRAME
|
2001-02-07 02:03:17 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2001-04-12 17:04:29 +04:00
|
|
|
#endif
|
2001-02-07 02:03:17 +03:00
|
|
|
return iFrameIsSelected;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2001-04-12 17:04:29 +04:00
|
|
|
//------------------------------------------------------
|
2001-02-07 02:03:17 +03:00
|
|
|
PRBool
|
2001-04-12 17:04:29 +04:00
|
|
|
DocumentViewerImpl::IsThereARangeSelection(nsIDOMWindowInternal * aDOMWin)
|
2001-01-27 17:09:34 +03:00
|
|
|
{
|
2001-02-07 02:03:17 +03:00
|
|
|
nsCOMPtr<nsIPresShell> presShell;
|
|
|
|
if (aDOMWin != nsnull) {
|
|
|
|
nsCOMPtr<nsIScriptGlobalObject> scriptObj(do_QueryInterface(aDOMWin));
|
|
|
|
nsCOMPtr<nsIDocShell> docShell;
|
|
|
|
scriptObj->GetDocShell(getter_AddRefs(docShell));
|
|
|
|
docShell->GetPresShell(getter_AddRefs(presShell));
|
|
|
|
}
|
|
|
|
|
2001-01-27 17:09:34 +03: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;
|
2001-02-07 02:03:17 +03:00
|
|
|
GetDocumentSelection(getter_AddRefs(selection), presShell);
|
2001-01-27 17:09:34 +03: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
|
|
|
|
PRBool isCollapsed;
|
|
|
|
selection->GetIsCollapsed(&isCollapsed);
|
|
|
|
return !isCollapsed;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return PR_FALSE;
|
|
|
|
}
|
2001-11-03 17:59:39 +03:00
|
|
|
|
|
|
|
#ifdef NS_PRINT_PREVIEW
|
|
|
|
//-------------------------------------------------------
|
|
|
|
// Recursively walks the PrintObject tree and installs the DocViewer
|
|
|
|
// as an event processor and it shows the window
|
|
|
|
nsresult
|
|
|
|
DocumentViewerImpl::ShowDocList(PrintObject* aPO, PRBool aShow)
|
|
|
|
{
|
|
|
|
NS_ASSERTION(aPO, "Pointer is null!");
|
|
|
|
|
2002-02-26 16:29:48 +03:00
|
|
|
if (aPO->IsPrintable()) {
|
|
|
|
PRBool donePrinting;
|
|
|
|
DoPrint(aPO, PR_FALSE, donePrinting);
|
2001-11-03 17:59:39 +03:00
|
|
|
|
2002-02-26 16:29:48 +03:00
|
|
|
if (aPO->mWindow != nsnull) {
|
|
|
|
aPO->mWindow->Show(aShow);
|
|
|
|
}
|
2001-11-03 17:59:39 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
PRInt32 cnt = aPO->mKids.Count();
|
|
|
|
for (PRInt32 i=0;i<cnt;i++) {
|
|
|
|
if (NS_FAILED(ShowDocList((PrintObject *)aPO->mKids[i], aShow))) {
|
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void
|
|
|
|
DocumentViewerImpl::TurnScriptingOn(PRBool aDoTurnOn)
|
|
|
|
{
|
|
|
|
NS_ASSERTION(mDocument, "We MUST have a document.");
|
|
|
|
|
|
|
|
// get the script global object
|
|
|
|
nsCOMPtr<nsIScriptGlobalObject> scriptGlobalObj;
|
|
|
|
nsresult rv = mDocument->GetScriptGlobalObject(getter_AddRefs(scriptGlobalObj));
|
|
|
|
NS_ASSERTION(NS_SUCCEEDED(rv) && scriptGlobalObj, "Can't get nsIScriptGlobalObject");
|
|
|
|
nsCOMPtr<nsIScriptContext> scx;
|
|
|
|
rv = scriptGlobalObj->GetContext(getter_AddRefs(scx));
|
|
|
|
NS_ASSERTION(NS_SUCCEEDED(rv) && scx, "Can't get nsIScriptContext");
|
2002-02-05 08:53:56 +03:00
|
|
|
scx->SetScriptsEnabled(aDoTurnOn, PR_TRUE);
|
2001-11-03 17:59:39 +03:00
|
|
|
}
|
|
|
|
|
2002-03-23 21:07:51 +03:00
|
|
|
//-------------------------------------------------------
|
|
|
|
// 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
|
|
|
|
DocumentViewerImpl::InstallPrintPreviewListener()
|
|
|
|
{
|
|
|
|
if (!mPrt->mPPEventListeners) {
|
|
|
|
nsCOMPtr<nsIDOMEventReceiver> evRec (do_QueryInterface(mDocument));
|
|
|
|
mPrt->mPPEventListeners = new nsPrintPreviewListener(evRec);
|
|
|
|
|
|
|
|
if (mPrt->mPPEventListeners) {
|
|
|
|
mPrt->mPPEventListeners->AddListeners();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2002-02-15 02:18:09 +03:00
|
|
|
//----------------------------------------------------------------------
|
|
|
|
static nsresult GetSeqFrameAndCountPages(PrintObject* aPO,
|
|
|
|
nsIFrame*& aSeqFrame,
|
|
|
|
PRInt32& aCount)
|
|
|
|
{
|
|
|
|
NS_ENSURE_ARG_POINTER(aPO);
|
|
|
|
|
|
|
|
// Finds the SimplePageSequencer frame
|
|
|
|
// in PP mPrtPreview->mPrintObject->mSeqFrame is null
|
|
|
|
nsIFrame* curFrame;
|
|
|
|
aSeqFrame = nsnull;
|
|
|
|
aPO->mPresShell->GetRootFrame(&curFrame);
|
|
|
|
while (curFrame != nsnull) {
|
|
|
|
nsIPageSequenceFrame * sqf = nsnull;
|
|
|
|
if (NS_SUCCEEDED(CallQueryInterface(curFrame, &sqf)) && sqf) {
|
|
|
|
aSeqFrame = curFrame;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
curFrame->FirstChild(aPO->mPresContext, nsnull, &curFrame);
|
|
|
|
}
|
|
|
|
if (aSeqFrame == nsnull) return NS_ERROR_FAILURE;
|
|
|
|
|
|
|
|
// first count the total number of pages
|
|
|
|
aCount = 0;
|
|
|
|
nsIFrame * pageFrame;
|
|
|
|
aSeqFrame->FirstChild(aPO->mPresContext, nsnull, &pageFrame);
|
|
|
|
while (pageFrame != nsnull) {
|
|
|
|
aCount++;
|
|
|
|
pageFrame->GetNextSibling(&pageFrame);
|
|
|
|
}
|
|
|
|
|
|
|
|
return NS_OK;
|
|
|
|
|
|
|
|
}
|
|
|
|
|
2002-02-01 17:52:11 +03:00
|
|
|
//----------------------------------------------------------------------
|
|
|
|
NS_IMETHODIMP
|
|
|
|
DocumentViewerImpl::PrintPreviewNavigate(PRInt16 aType, PRInt32 aPageNum)
|
|
|
|
{
|
2002-02-15 02:18:09 +03:00
|
|
|
#ifdef NS_PRINT_PREVIEW
|
|
|
|
if (!mPrtPreview) return NS_ERROR_FAILURE;
|
|
|
|
|
2002-02-01 17:52:11 +03:00
|
|
|
nsIScrollableView* scrollableView;
|
|
|
|
mViewManager->GetRootScrollableView(&scrollableView);
|
|
|
|
if (scrollableView == nsnull) return NS_OK;
|
|
|
|
|
|
|
|
// Check to see if we can short circut scrolling to the top
|
|
|
|
if (aType == nsIWebBrowserPrint::PRINTPREVIEW_HOME ||
|
|
|
|
(aType == nsIWebBrowserPrint::PRINTPREVIEW_GOTO_PAGENUM && aPageNum == 1)) {
|
|
|
|
scrollableView->ScrollTo(0, 0, PR_TRUE);
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Finds the SimplePageSequencer frame
|
|
|
|
// in PP mPrtPreview->mPrintObject->mSeqFrame is null
|
|
|
|
nsIFrame* seqFrame = nsnull;
|
2002-02-15 02:18:09 +03:00
|
|
|
PRInt32 pageCount = 0;
|
|
|
|
if (NS_FAILED(GetSeqFrameAndCountPages(mPrtPreview->mPrintObject, seqFrame, pageCount))) {
|
|
|
|
return NS_ERROR_FAILURE;
|
2002-02-01 17:52:11 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
// Figure where we are currently scrolled to
|
|
|
|
const nsIView * clippedView;
|
|
|
|
scrollableView->GetClipView(&clippedView);
|
|
|
|
nscoord x;
|
|
|
|
nscoord y;
|
|
|
|
scrollableView->GetScrollPosition(x, y);
|
|
|
|
|
|
|
|
PRInt32 pageNum = 1;
|
|
|
|
nsIFrame * fndPageFrame = nsnull;
|
|
|
|
nsIFrame * currentPage = nsnull;
|
|
|
|
|
|
|
|
// If it is "End" then just do a "goto" to the last page
|
|
|
|
if (aType == nsIWebBrowserPrint::PRINTPREVIEW_END) {
|
|
|
|
aType = nsIWebBrowserPrint::PRINTPREVIEW_GOTO_PAGENUM;
|
|
|
|
aPageNum = pageCount;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Now, locate the current page we are on and
|
|
|
|
// and the page of the page number
|
|
|
|
nscoord gap = 0;
|
2002-02-15 02:18:09 +03:00
|
|
|
nsIFrame * pageFrame;
|
2002-02-01 17:52:11 +03:00
|
|
|
seqFrame->FirstChild(mPresContext, nsnull, &pageFrame);
|
|
|
|
while (pageFrame != nsnull) {
|
|
|
|
nsRect pageRect;
|
|
|
|
pageFrame->GetRect(pageRect);
|
|
|
|
if (pageNum == 1) {
|
|
|
|
gap = pageRect.y;
|
|
|
|
}
|
|
|
|
pageRect.y -= gap;
|
|
|
|
if (pageRect.Contains(pageRect.x, y)) {
|
|
|
|
currentPage = pageFrame;
|
|
|
|
}
|
|
|
|
if (pageNum == aPageNum) {
|
|
|
|
fndPageFrame = pageFrame;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
pageNum++;
|
|
|
|
pageFrame->GetNextSibling(&pageFrame);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (aType == nsIWebBrowserPrint::PRINTPREVIEW_PREV_PAGE) {
|
|
|
|
if (currentPage) {
|
|
|
|
currentPage->GetPrevInFlow(&fndPageFrame);
|
|
|
|
if (!fndPageFrame) {
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
} else if (aType == nsIWebBrowserPrint::PRINTPREVIEW_NEXT_PAGE) {
|
|
|
|
if (currentPage) {
|
|
|
|
currentPage->GetNextInFlow(&fndPageFrame);
|
|
|
|
if (!fndPageFrame) {
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
} else { // If we get here we are doing "GoTo"
|
|
|
|
if (aPageNum < 0 || aPageNum > pageCount) {
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (fndPageFrame && scrollableView) {
|
|
|
|
// get the child rect
|
|
|
|
nsRect fRect;
|
|
|
|
fndPageFrame->GetRect(fRect);
|
|
|
|
// find offset from view
|
|
|
|
nsPoint pnt;
|
|
|
|
nsIView * view;
|
|
|
|
fndPageFrame->GetOffsetFromView(mPresContext, pnt, &view);
|
|
|
|
|
2002-02-15 02:18:09 +03:00
|
|
|
nscoord deadSpaceGap = 0;
|
|
|
|
nsIPageSequenceFrame * sqf;
|
|
|
|
if (NS_SUCCEEDED(CallQueryInterface(seqFrame, &sqf))) {
|
|
|
|
sqf->GetDeadSpaceValue(&deadSpaceGap);
|
|
|
|
}
|
|
|
|
|
|
|
|
// scroll so that top of page (plus the gray area) is at the top of the scroll area
|
|
|
|
scrollableView->ScrollTo(0, fRect.y-deadSpaceGap, PR_TRUE);
|
2002-02-01 17:52:11 +03:00
|
|
|
}
|
2002-02-15 02:18:09 +03:00
|
|
|
#endif // NS_PRINT_PREVIEW
|
|
|
|
|
2002-02-01 17:52:11 +03:00
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* readonly attribute boolean isFramesetDocument; */
|
|
|
|
NS_IMETHODIMP
|
|
|
|
DocumentViewerImpl::GetIsFramesetDocument(PRBool *aIsFramesetDocument)
|
|
|
|
{
|
|
|
|
nsCOMPtr<nsIWebShell> webContainer(do_QueryInterface(mContainer));
|
|
|
|
*aIsFramesetDocument = IsParentAFrameSet(webContainer);
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2002-03-25 06:19:32 +03:00
|
|
|
/* readonly attribute boolean isIFrameSelected; */
|
|
|
|
NS_IMETHODIMP
|
|
|
|
DocumentViewerImpl::GetIsIFrameSelected(PRBool *aIsIFrameSelected)
|
|
|
|
{
|
|
|
|
*aIsIFrameSelected = PR_FALSE;
|
|
|
|
|
|
|
|
// Get the webshell for this documentviewer
|
|
|
|
nsCOMPtr<nsIWebShell> webContainer(do_QueryInterface(mContainer));
|
|
|
|
// Get the currently focused window
|
|
|
|
nsCOMPtr<nsIDOMWindowInternal> currentFocusWin = getter_AddRefs(FindFocusedDOMWindowInternal());
|
|
|
|
if (currentFocusWin && webContainer) {
|
|
|
|
// Get whether the doc contains a frameset
|
|
|
|
// Also, check to see if the currently focus webshell
|
|
|
|
// is a child of this webshell
|
|
|
|
PRPackedBool isParentFrameSet;
|
|
|
|
*aIsIFrameSelected = IsThereAnIFrameSelected(webContainer, currentFocusWin, isParentFrameSet);
|
|
|
|
}
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* readonly attribute boolean isRangeSelection; */
|
|
|
|
NS_IMETHODIMP
|
|
|
|
DocumentViewerImpl::GetIsRangeSelection(PRBool *aIsRangeSelection)
|
|
|
|
{
|
|
|
|
// Get the currently focused window
|
|
|
|
nsCOMPtr<nsIDOMWindowInternal> currentFocusWin = getter_AddRefs(FindFocusedDOMWindowInternal());
|
|
|
|
*aIsRangeSelection = IsThereARangeSelection(currentFocusWin);
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* readonly attribute boolean isFramesetFrameSelected; */
|
|
|
|
NS_IMETHODIMP
|
|
|
|
DocumentViewerImpl::GetIsFramesetFrameSelected(PRBool *aIsFramesetFrameSelected)
|
|
|
|
{
|
|
|
|
// Get the currently focused window
|
|
|
|
nsCOMPtr<nsIDOMWindowInternal> currentFocusWin = getter_AddRefs(FindFocusedDOMWindowInternal());
|
|
|
|
*aIsFramesetFrameSelected = currentFocusWin != nsnull;
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2002-02-15 02:18:09 +03:00
|
|
|
/* readonly attribute long printPreviewNumPages; */
|
|
|
|
NS_IMETHODIMP
|
|
|
|
DocumentViewerImpl::GetPrintPreviewNumPages(PRInt32 *aPrintPreviewNumPages)
|
|
|
|
{
|
|
|
|
NS_ENSURE_ARG_POINTER(aPrintPreviewNumPages);
|
|
|
|
|
|
|
|
// Finds the SimplePageSequencer frame
|
|
|
|
// in PP mPrtPreview->mPrintObject->mSeqFrame is null
|
|
|
|
nsIFrame* seqFrame = nsnull;
|
|
|
|
*aPrintPreviewNumPages = 0;
|
|
|
|
if (NS_FAILED(GetSeqFrameAndCountPages(mPrtPreview->mPrintObject, seqFrame, *aPrintPreviewNumPages))) {
|
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
}
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2002-02-01 17:52:11 +03:00
|
|
|
/* void exitPrintPreview (); */
|
|
|
|
NS_IMETHODIMP
|
|
|
|
DocumentViewerImpl::ExitPrintPreview()
|
|
|
|
{
|
|
|
|
if (mIsDoingPrintPreview) {
|
|
|
|
ReturnToGalleyPresentation();
|
|
|
|
}
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2001-11-03 17:59:39 +03:00
|
|
|
void
|
|
|
|
DocumentViewerImpl::InstallNewPresentation()
|
|
|
|
{
|
|
|
|
// Get the current size of what is being viewed
|
|
|
|
nsRect area;
|
|
|
|
mPresContext->GetVisibleArea(area);
|
|
|
|
|
|
|
|
nsRect bounds;
|
|
|
|
mWindow->GetBounds(bounds);
|
|
|
|
|
|
|
|
// In case we have focus focus the parent DocShell
|
|
|
|
// which in this case should always be chrome
|
|
|
|
nsCOMPtr<nsIDocShellTreeItem> dstParentItem;
|
|
|
|
nsCOMPtr<nsIDocShellTreeItem> dstItem(do_QueryInterface(mContainer));
|
|
|
|
if (dstItem) {
|
|
|
|
dstItem->GetParent(getter_AddRefs(dstParentItem));
|
|
|
|
nsCOMPtr<nsIDocShell> docShell(do_QueryInterface(dstParentItem));
|
|
|
|
if (docShell) {
|
|
|
|
docShell->SetHasFocus(PR_TRUE);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// turn off selection painting
|
|
|
|
nsCOMPtr<nsISelectionController> selectionController = do_QueryInterface(mPresShell);
|
|
|
|
if (selectionController) {
|
|
|
|
selectionController->SetDisplaySelection(nsISelectionController::SELECTION_OFF);
|
|
|
|
}
|
|
|
|
|
|
|
|
// Start to kill off the old Presentation
|
|
|
|
// by cleaning up the PresShell
|
|
|
|
if (mPresShell) {
|
|
|
|
// Break circular reference (or something)
|
|
|
|
mPresShell->EndObservingDocument();
|
|
|
|
nsCOMPtr<nsISelection> selection;
|
|
|
|
nsresult rv = GetDocumentSelection(getter_AddRefs(selection));
|
|
|
|
nsCOMPtr<nsISelectionPrivate> selPrivate(do_QueryInterface(selection));
|
|
|
|
if (NS_SUCCEEDED(rv) && selPrivate && mSelectionListener)
|
|
|
|
selPrivate->RemoveSelectionListener(mSelectionListener);
|
2002-03-26 14:43:40 +03:00
|
|
|
|
|
|
|
// We need to destroy the PreShell if there is an existing PP
|
|
|
|
// or we are not caching the original Presentation
|
|
|
|
if (!mPrt->IsCachingPres() || mOldPrtPreview) {
|
|
|
|
mPresShell->Destroy();
|
|
|
|
}
|
2001-11-03 17:59:39 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
// clear weak references before we go away
|
|
|
|
if (mPresContext) {
|
|
|
|
mPresContext->SetContainer(nsnull);
|
|
|
|
mPresContext->SetLinkHandler(nsnull);
|
|
|
|
}
|
|
|
|
|
2002-03-26 14:43:40 +03:00
|
|
|
// See if we are suppose to be caching the old Presentation
|
|
|
|
// and then check to see if we already have.
|
|
|
|
if (mPrt->IsCachingPres() && !mPrt->HasCachedPres()) {
|
|
|
|
NS_ASSERTION(!mPrt->mCachedPresObj, "Should be null!");
|
|
|
|
// Cach old presentation
|
|
|
|
mPrt->mCachedPresObj = new CachedPresentationObj(mPresShell, mPresContext, mViewManager, mWindow);
|
|
|
|
mWindow->Show(PR_FALSE);
|
|
|
|
} else {
|
|
|
|
// Destroy the old Presentation
|
|
|
|
mPresShell = nsnull;
|
|
|
|
mPresContext = nsnull;
|
|
|
|
mViewManager = nsnull;
|
|
|
|
mWindow = nsnull;
|
|
|
|
}
|
2001-11-03 17:59:39 +03:00
|
|
|
|
2002-02-01 17:52:11 +03:00
|
|
|
// Default to the main Print Object
|
|
|
|
PrintObject * prtObjToDisplay = mPrt->mPrintObject;
|
|
|
|
|
|
|
|
// This is the new code for selecting the appropriate Frame of a Frameset
|
|
|
|
// for Print Preview. But it can't be turned on yet
|
|
|
|
#if 0
|
|
|
|
// If it is a Frameset then choose the selected one
|
|
|
|
// or select the one with the largest area
|
|
|
|
if (mPrt->mPrintObject->mFrameType == eFrameSet) {
|
|
|
|
if (mPrt->mCurrentFocusWin) {
|
|
|
|
PRInt32 cnt = mPrt->mPrintObject->mKids.Count();
|
|
|
|
// Start at "1" and skip the FrameSet document itself
|
|
|
|
for (PRInt32 i=1;i<cnt;i++) {
|
|
|
|
PrintObject* po = (PrintObject *)mPrt->mPrintObject->mKids[i];
|
|
|
|
nsCOMPtr<nsIDOMWindowInternal> domWin(getter_AddRefs(GetDOMWinForWebShell(po->mWebShell)));
|
|
|
|
if (domWin.get() == mPrt->mCurrentFocusWin.get()) {
|
|
|
|
prtObjToDisplay = po;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
PrintObject* largestPO = nsnull;
|
|
|
|
nscoord area = 0;
|
|
|
|
PRInt32 cnt = mPrt->mPrintObject->mKids.Count();
|
|
|
|
// Start at "1" and skip the FrameSet document itself
|
|
|
|
for (PRInt32 i=1;i<cnt;i++) {
|
|
|
|
PrintObject* po = (PrintObject *)mPrt->mPrintObject->mKids[i];
|
|
|
|
nsCOMPtr<nsIDOMWindowInternal> domWin(getter_AddRefs(GetDOMWinForWebShell(po->mWebShell)));
|
|
|
|
if (domWin.get() == mPrt->mCurrentFocusWin.get()) {
|
|
|
|
nscoord width;
|
|
|
|
nscoord height;
|
|
|
|
domWin->GetInnerWidth(&width);
|
|
|
|
domWin->GetInnerHeight(&height);
|
|
|
|
nscoord newArea = width * height;
|
|
|
|
if (newArea > area) {
|
|
|
|
largestPO = po;
|
|
|
|
area = newArea;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
// make sure we got one
|
|
|
|
if (largestPO) {
|
|
|
|
prtObjToDisplay = largestPO;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2002-03-23 21:07:51 +03:00
|
|
|
InstallPrintPreviewListener();
|
|
|
|
|
2001-11-03 17:59:39 +03:00
|
|
|
// Install the new Presentation
|
2002-02-01 17:52:11 +03:00
|
|
|
mPresShell = prtObjToDisplay->mPresShell;
|
|
|
|
mPresContext = prtObjToDisplay->mPresContext;
|
|
|
|
mViewManager = prtObjToDisplay->mViewManager;
|
|
|
|
mWindow = prtObjToDisplay->mWindow;
|
|
|
|
|
2002-03-26 14:43:40 +03:00
|
|
|
if (mIsDoingPrintPreview && mOldPrtPreview) {
|
2002-02-01 17:52:11 +03:00
|
|
|
delete mOldPrtPreview;
|
|
|
|
mOldPrtPreview = nsnull;
|
|
|
|
}
|
2001-11-03 17:59:39 +03:00
|
|
|
|
2002-02-01 17:52:11 +03:00
|
|
|
prtObjToDisplay->mSharedPresShell = PR_TRUE;
|
2001-11-03 17:59:39 +03:00
|
|
|
mPresShell->BeginObservingDocument();
|
|
|
|
|
|
|
|
nscoord width = bounds.width;
|
|
|
|
nscoord height = bounds.height;
|
|
|
|
float p2t;
|
|
|
|
mPresContext->GetPixelsToTwips(&p2t);
|
|
|
|
width = NSIntPixelsToTwips(width, p2t);
|
|
|
|
height = NSIntPixelsToTwips(height, p2t);
|
|
|
|
mViewManager->DisableRefresh();
|
|
|
|
mViewManager->SetWindowDimensions(width, height);
|
|
|
|
|
|
|
|
mDeviceContext->SetUseAltDC(kUseAltDCFor_FONTMETRICS, PR_FALSE);
|
2002-01-11 14:59:00 +03:00
|
|
|
mDeviceContext->SetUseAltDC(kUseAltDCFor_CREATERC_PAINT, PR_TRUE);
|
2001-11-03 17:59:39 +03:00
|
|
|
|
|
|
|
mViewManager->EnableRefresh(NS_VMREFRESH_NO_SYNC);
|
|
|
|
Show();
|
|
|
|
|
|
|
|
ShowDocList(mPrt->mPrintObject, PR_TRUE);
|
|
|
|
|
|
|
|
}
|
2001-11-14 14:24:03 +03:00
|
|
|
|
|
|
|
void
|
|
|
|
DocumentViewerImpl::ReturnToGalleyPresentation()
|
|
|
|
{
|
|
|
|
if (!mIsDoingPrintPreview) {
|
|
|
|
NS_ASSERTION(0, "Wow, we should never get here!");
|
|
|
|
return;
|
|
|
|
}
|
2002-03-26 14:43:40 +03:00
|
|
|
|
|
|
|
if (!mPrtPreview->HasCachedPres()) {
|
|
|
|
delete mPrtPreview;
|
|
|
|
mPrtPreview = nsnull;
|
|
|
|
}
|
2001-11-14 14:24:03 +03:00
|
|
|
|
|
|
|
// Get the current size of what is being viewed
|
|
|
|
nsRect area;
|
|
|
|
mPresContext->GetVisibleArea(area);
|
|
|
|
|
|
|
|
nsRect bounds;
|
|
|
|
mWindow->GetBounds(bounds);
|
|
|
|
|
|
|
|
// In case we have focus focus the parent DocShell
|
|
|
|
// which in this case should always be chrome
|
|
|
|
nsCOMPtr<nsIDocShellTreeItem> dstParentItem;
|
|
|
|
nsCOMPtr<nsIDocShellTreeItem> dstItem(do_QueryInterface(mContainer));
|
|
|
|
if (dstItem) {
|
|
|
|
dstItem->GetParent(getter_AddRefs(dstParentItem));
|
|
|
|
nsCOMPtr<nsIDocShell> docShell(do_QueryInterface(dstParentItem));
|
|
|
|
if (docShell) {
|
|
|
|
docShell->SetHasFocus(PR_TRUE);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Start to kill off the old Presentation
|
|
|
|
// by cleaning up the PresShell
|
|
|
|
if (mPresShell) {
|
|
|
|
// Break circular reference (or something)
|
|
|
|
mPresShell->EndObservingDocument();
|
|
|
|
nsCOMPtr<nsISelection> selection;
|
|
|
|
nsresult rv = GetDocumentSelection(getter_AddRefs(selection));
|
|
|
|
nsCOMPtr<nsISelectionPrivate> selPrivate(do_QueryInterface(selection));
|
|
|
|
if (NS_SUCCEEDED(rv) && selPrivate && mSelectionListener)
|
|
|
|
selPrivate->RemoveSelectionListener(mSelectionListener);
|
|
|
|
mPresShell->Destroy();
|
|
|
|
}
|
|
|
|
|
|
|
|
// clear weak references before we go away
|
|
|
|
if (mPresContext) {
|
|
|
|
mPresContext->SetContainer(nsnull);
|
|
|
|
mPresContext->SetLinkHandler(nsnull);
|
|
|
|
}
|
|
|
|
|
2002-03-26 14:43:40 +03:00
|
|
|
// wasCached will be used below to indicate whether the
|
|
|
|
// InitInternal should create all new objects or just
|
|
|
|
// initialize the existing ones
|
|
|
|
PRBool wasCached = PR_FALSE;
|
|
|
|
|
|
|
|
if (mPrtPreview && mPrtPreview->HasCachedPres()) {
|
|
|
|
NS_ASSERTION(mPrtPreview->mCachedPresObj, "mCachedPresObj can't be null!");
|
|
|
|
mPresShell = mPrtPreview->mCachedPresObj->mPresShell;
|
|
|
|
mPresContext = mPrtPreview->mCachedPresObj->mPresContext;
|
|
|
|
mViewManager = mPrtPreview->mCachedPresObj->mViewManager;
|
|
|
|
mWindow = mPrtPreview->mCachedPresObj->mWindow;
|
|
|
|
|
|
|
|
mWindow->Show(PR_TRUE);
|
|
|
|
|
|
|
|
// Very important! Turn On scripting
|
|
|
|
TurnScriptingOn(PR_TRUE);
|
|
|
|
|
|
|
|
delete mPrtPreview;
|
|
|
|
mPrtPreview = nsnull;
|
|
|
|
|
|
|
|
wasCached = PR_TRUE;
|
|
|
|
|
|
|
|
} else {
|
|
|
|
// Destroy the old Presentation
|
|
|
|
mPresShell = nsnull;
|
|
|
|
mPresContext = nsnull;
|
|
|
|
mViewManager = nsnull;
|
|
|
|
mWindow = nsnull;
|
|
|
|
}
|
2001-11-14 14:24:03 +03:00
|
|
|
|
|
|
|
// Very important! Turn On scripting
|
|
|
|
TurnScriptingOn(PR_TRUE);
|
|
|
|
|
2002-03-26 14:43:40 +03:00
|
|
|
InitInternal(mParentWidget, mDeviceContext, bounds, !wasCached);
|
2001-11-14 14:24:03 +03:00
|
|
|
|
|
|
|
// this needs to be set here not earlier,
|
|
|
|
// because it is needing when re-constructing the Galley Mode)
|
|
|
|
mIsDoingPrintPreview = PR_FALSE;
|
|
|
|
|
|
|
|
mViewManager->EnableRefresh(NS_VMREFRESH_NO_SYNC);
|
|
|
|
Show();
|
|
|
|
|
|
|
|
}
|
|
|
|
|
2001-11-03 17:59:39 +03:00
|
|
|
#endif // NS_PRINT_PREVIEW
|
|
|
|
|
2002-01-01 15:58:53 +03:00
|
|
|
//-----------------------------------------------------------------
|
|
|
|
// 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
|
|
|
|
DocumentViewerImpl::CheckForPrinters(nsIPrintOptions* aPrintOptions,
|
|
|
|
nsIPrintSettings* aPrintSettings,
|
|
|
|
PRUint32 aErrorCode,
|
|
|
|
PRBool aIsPrinting)
|
|
|
|
{
|
|
|
|
NS_ENSURE_ARG_POINTER(aPrintOptions);
|
|
|
|
NS_ENSURE_ARG_POINTER(aPrintSettings);
|
|
|
|
|
|
|
|
nsresult rv = NS_ERROR_FAILURE;
|
|
|
|
|
|
|
|
nsCOMPtr<nsISimpleEnumerator> simpEnum;
|
|
|
|
aPrintOptions->AvailablePrinters(getter_AddRefs(simpEnum));
|
|
|
|
if (simpEnum) {
|
2002-02-06 16:04:47 +03:00
|
|
|
PRBool fndPrinter = PR_FALSE;
|
|
|
|
simpEnum->HasMoreElements(&fndPrinter);
|
|
|
|
if (fndPrinter) {
|
|
|
|
// For now, it assumes the first item in the list
|
|
|
|
// is the default printer, but only set the
|
|
|
|
// printer name if there isn't one
|
2002-01-01 15:58:53 +03:00
|
|
|
nsCOMPtr<nsISupports> supps;
|
|
|
|
simpEnum->GetNext(getter_AddRefs(supps));
|
2002-02-06 16:04:47 +03:00
|
|
|
PRUnichar* defPrinterName;
|
|
|
|
aPrintSettings->GetPrinterName(&defPrinterName);
|
|
|
|
if (!defPrinterName || (defPrinterName && !*defPrinterName)) {
|
|
|
|
if (defPrinterName) nsMemory::Free(defPrinterName);
|
2002-01-01 15:58:53 +03:00
|
|
|
nsCOMPtr<nsISupportsWString> wStr = do_QueryInterface(supps);
|
|
|
|
if (wStr) {
|
|
|
|
PRUnichar* defPrinterName;
|
|
|
|
wStr->ToString(&defPrinterName);
|
|
|
|
aPrintSettings->SetPrinterName(defPrinterName);
|
|
|
|
nsMemory::Free(defPrinterName);
|
|
|
|
}
|
2002-02-06 16:04:47 +03:00
|
|
|
} else {
|
|
|
|
nsMemory::Free(defPrinterName);
|
2002-01-01 15:58:53 +03:00
|
|
|
}
|
2002-02-06 16:04:47 +03:00
|
|
|
rv = NS_OK;
|
|
|
|
} else {
|
2002-01-01 15:58:53 +03:00
|
|
|
// this means there were no printers
|
|
|
|
ShowPrintErrorDialog(aErrorCode, aIsPrinting);
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
// this means there were no printers
|
|
|
|
// XXX the ifdefs are temporary until they correctly implement Available Printers
|
2002-02-04 13:56:42 +03:00
|
|
|
#if defined(XP_MAC) || defined(XP_MACOSX)
|
2002-01-01 15:58:53 +03:00
|
|
|
rv = NS_OK;
|
|
|
|
#else
|
|
|
|
ShowPrintErrorDialog(aErrorCode, aIsPrinting);
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
return rv;
|
|
|
|
}
|
|
|
|
|
2002-03-26 14:43:40 +03:00
|
|
|
|
|
|
|
/** ---------------------------------------------------
|
|
|
|
* Check to see if the current Presentation should be cached
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
PRBool
|
|
|
|
DocumentViewerImpl::CheckDocumentForPPCaching()
|
|
|
|
{
|
|
|
|
// Here is where we determine if we need to cache the old presentation
|
|
|
|
PRBool cacheOldPres = PR_FALSE;
|
|
|
|
|
|
|
|
// Only check if it is the first time into PP
|
|
|
|
if (!mOldPrtPreview) {
|
|
|
|
// First check the Pref
|
|
|
|
nsCOMPtr<nsIPref> prefs (do_GetService(NS_PREF_CONTRACTID));
|
|
|
|
if (prefs) {
|
|
|
|
prefs->GetBoolPref("print.always_cache_old_pres", &cacheOldPres);
|
|
|
|
}
|
|
|
|
|
|
|
|
// Temp fix for FrameSet Print Preview Bugs
|
|
|
|
if (!cacheOldPres && mPrt->mPrintObject->mFrameType == eFrameSet) {
|
|
|
|
cacheOldPres = PR_TRUE;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!cacheOldPres) {
|
|
|
|
for (PRInt32 i=0;i<mPrt->mPrintDocList->Count();i++) {
|
|
|
|
PrintObject* po = (PrintObject*)mPrt->mPrintDocList->ElementAt(i);
|
|
|
|
NS_ASSERTION(po, "PrintObject can't be null!");
|
|
|
|
|
|
|
|
// Temp fix for FrameSet Print Preview Bugs
|
|
|
|
if (po->mFrameType == eIFrame) {
|
|
|
|
cacheOldPres = PR_TRUE;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
nsCOMPtr<nsIDocShell> docShell(do_QueryInterface(po->mWebShell));
|
|
|
|
NS_ASSERTION(docShell, "The DocShell can't be NULL!");
|
|
|
|
if (!docShell) continue;
|
|
|
|
|
|
|
|
nsCOMPtr<nsIPresShell> presShell;
|
|
|
|
docShell->GetPresShell(getter_AddRefs(presShell));
|
|
|
|
NS_ASSERTION(presShell, "The PresShell can't be NULL!");
|
|
|
|
if (!presShell) continue;
|
|
|
|
|
|
|
|
nsCOMPtr<nsIDocument> doc;
|
|
|
|
presShell->GetDocument(getter_AddRefs(doc));
|
|
|
|
NS_ASSERTION(doc, "The PresShell can't be NULL!");
|
|
|
|
if (!doc) continue;
|
|
|
|
|
|
|
|
// If we aren't caching because of prefs check embeds.
|
|
|
|
nsCOMPtr<nsIDOMNSHTMLDocument> nshtmlDoc = do_QueryInterface(doc);
|
|
|
|
if (nshtmlDoc) {
|
|
|
|
nsCOMPtr<nsIDOMHTMLCollection> applets;
|
|
|
|
nshtmlDoc->GetEmbeds(getter_AddRefs(applets));
|
|
|
|
if (applets) {
|
|
|
|
PRUint32 length = 0;
|
|
|
|
if (NS_SUCCEEDED(applets->GetLength(&length))) {
|
|
|
|
if (length > 0) {
|
|
|
|
cacheOldPres = PR_TRUE;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// If we aren't caching because of prefs or embeds check applets.
|
|
|
|
nsCOMPtr<nsIDOMHTMLDocument> htmldoc = do_QueryInterface(doc);
|
|
|
|
if (htmldoc) {
|
|
|
|
nsCOMPtr<nsIDOMHTMLCollection> embeds;
|
|
|
|
htmldoc->GetApplets(getter_AddRefs(embeds));
|
|
|
|
if (embeds) {
|
|
|
|
PRUint32 length = 0;
|
|
|
|
if (NS_SUCCEEDED(embeds->GetLength(&length))) {
|
|
|
|
if (length > 0) {
|
|
|
|
cacheOldPres = PR_TRUE;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return cacheOldPres;
|
|
|
|
|
|
|
|
}
|
|
|
|
|
2001-11-03 17:59:39 +03:00
|
|
|
/** ---------------------------------------------------
|
|
|
|
* See documentation above in the nsIContentViewerfile class definition
|
|
|
|
* @update 11/01/01 rods
|
|
|
|
*
|
|
|
|
* For a full and detailed understanding of the issues with
|
|
|
|
* PrintPreview: See the design spec that is attached to Bug 107562
|
|
|
|
*/
|
|
|
|
NS_IMETHODIMP
|
2002-01-01 15:58:53 +03:00
|
|
|
DocumentViewerImpl::PrintPreview(nsIPrintSettings* aPrintSettings)
|
2001-11-03 17:59:39 +03:00
|
|
|
{
|
2002-03-23 19:48:58 +03:00
|
|
|
// Get the webshell for this documentviewer
|
|
|
|
nsCOMPtr<nsIWebShell> webContainer(do_QueryInterface(mContainer));
|
|
|
|
// Get the DocShell and see if it is busy
|
|
|
|
// We can't Print or Print Preview this document if it is still busy
|
|
|
|
nsCOMPtr<nsIDocShell> docShell(do_QueryInterface(webContainer));
|
|
|
|
NS_ASSERTION(docShell.get(), "This has to be a docshell");
|
|
|
|
PRUint32 busyFlags = nsIDocShell::BUSY_FLAGS_NONE;
|
|
|
|
if (NS_FAILED(docShell->GetBusyFlags(&busyFlags)) || busyFlags != nsIDocShell::BUSY_FLAGS_NONE) {
|
|
|
|
ShowPrintErrorDialog(NS_ERROR_GFX_PRINTER_DOC_IS_BUSY_PP, PR_FALSE);
|
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
}
|
2001-11-03 17:59:39 +03:00
|
|
|
nsresult rv = NS_OK;
|
2002-03-23 19:48:58 +03:00
|
|
|
|
2002-01-25 17:30:14 +03:00
|
|
|
#if defined(XP_PC) && defined(DEBUG_rods) && defined(DEBUG_PRINTING)
|
|
|
|
if (!mIsDoingPrintPreview) {
|
|
|
|
RemoveFilesInDir(".\\");
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2001-11-03 17:59:39 +03:00
|
|
|
#ifdef NS_PRINT_PREVIEW
|
2002-02-01 17:52:11 +03:00
|
|
|
if (mIsDoingPrintPreview) {
|
|
|
|
mOldPrtPreview = mPrtPreview;
|
|
|
|
mPrtPreview = nsnull;
|
|
|
|
}
|
2001-11-03 17:59:39 +03:00
|
|
|
|
|
|
|
mPrt = new PrintData();
|
|
|
|
if (mPrt == nsnull) {
|
2001-11-14 14:24:03 +03:00
|
|
|
mIsCreatingPrintPreview = PR_FALSE;
|
2001-11-03 17:59:39 +03:00
|
|
|
return NS_ERROR_OUT_OF_MEMORY;
|
|
|
|
}
|
2002-01-01 15:58:53 +03:00
|
|
|
|
2002-03-26 14:43:40 +03:00
|
|
|
// maintain the the original presentation if it is there
|
|
|
|
// by transfering it over to the new PrintData object
|
|
|
|
if (mOldPrtPreview && mOldPrtPreview->HasCachedPres()) {
|
|
|
|
mPrt->mIsCachingPresentation = mOldPrtPreview->mIsCachingPresentation;
|
|
|
|
mPrt->mCachedPresObj = mOldPrtPreview->mCachedPresObj;
|
|
|
|
// don't want it to get deleted when the mOldPrtPreview is deleted
|
|
|
|
mOldPrtPreview->mIsCachingPresentation = PR_FALSE;
|
|
|
|
mOldPrtPreview->mCachedPresObj = nsnull;
|
|
|
|
}
|
|
|
|
|
2002-02-01 17:52:11 +03:00
|
|
|
// You have to have both a PrintOptions and a PrintSetting to call CheckForPrinters.
|
|
|
|
// The user can pass in a null PrintSettings,
|
|
|
|
// but you can only create one if you have a PrintOptions.
|
|
|
|
// So we we might as check to if we have a PrintOptions first,
|
|
|
|
// because we can't do anything below without it
|
|
|
|
// then inside we check to se if the printSettings is null to know if we need to create on.
|
2002-01-01 15:58:53 +03:00
|
|
|
mPrt->mPrintSettings = aPrintSettings;
|
2002-01-12 15:31:05 +03:00
|
|
|
mPrt->mPrintOptions = do_GetService(kPrintOptionsCID, &rv);
|
|
|
|
if (NS_SUCCEEDED(rv) && mPrt->mPrintOptions) {
|
2002-01-01 15:58:53 +03:00
|
|
|
// if they don't pass in a PrintSettings, then make one
|
|
|
|
if (mPrt->mPrintSettings == nsnull) {
|
2002-01-12 15:31:05 +03:00
|
|
|
mPrt->mPrintOptions->CreatePrintSettings(getter_AddRefs(mPrt->mPrintSettings));
|
2002-01-01 15:58:53 +03:00
|
|
|
}
|
|
|
|
NS_ASSERTION(mPrt->mPrintSettings, "You can't PrintPreview without a PrintSettings!");
|
|
|
|
|
|
|
|
// Get the default printer name and set it into the PrintSettings
|
2002-01-12 15:31:05 +03:00
|
|
|
if (NS_FAILED(CheckForPrinters(mPrt->mPrintOptions, mPrt->mPrintSettings, NS_ERROR_GFX_PRINTER_PRINTPREVIEW, PR_FALSE))) {
|
2002-01-01 15:58:53 +03:00
|
|
|
delete mPrt;
|
|
|
|
mPrt = nsnull;
|
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Let's print ...
|
|
|
|
mIsCreatingPrintPreview = PR_TRUE;
|
|
|
|
mIsDoingPrintPreview = PR_TRUE;
|
2002-03-22 17:49:29 +03:00
|
|
|
aPrintSettings->SetIsPrintPreview(mIsDoingPrintPreview);
|
2002-01-01 15:58:53 +03:00
|
|
|
|
2001-11-03 17:59:39 +03:00
|
|
|
// Very important! Turn Off scripting
|
|
|
|
TurnScriptingOn(PR_FALSE);
|
|
|
|
|
|
|
|
// Get the currently focused window and cache it
|
|
|
|
// because the Print Dialog will "steal" focus and later when you try
|
|
|
|
// to get the currently focused windows it will be NULL
|
|
|
|
mPrt->mCurrentFocusWin = getter_AddRefs(FindFocusedDOMWindowInternal());
|
|
|
|
|
|
|
|
// Check to see if there is a "regular" selection
|
|
|
|
PRBool isSelection = IsThereARangeSelection(mPrt->mCurrentFocusWin);
|
|
|
|
|
|
|
|
// Create a list for storing the WebShells that need to be printed
|
|
|
|
if (mPrt->mPrintDocList == nsnull) {
|
|
|
|
mPrt->mPrintDocList = new nsVoidArray();
|
|
|
|
if (mPrt->mPrintDocList == nsnull) {
|
2001-11-14 14:24:03 +03:00
|
|
|
mIsCreatingPrintPreview = PR_FALSE;
|
|
|
|
mIsDoingPrintPreview = PR_FALSE;
|
2002-03-22 17:49:29 +03:00
|
|
|
aPrintSettings->SetIsPrintPreview(mIsDoingPrintPreview);
|
2001-11-03 17:59:39 +03:00
|
|
|
TurnScriptingOn(PR_TRUE);
|
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
mPrt->mPrintDocList->Clear();
|
|
|
|
}
|
|
|
|
|
|
|
|
// Add Root Doc to Tree and List
|
|
|
|
mPrt->mPrintObject = new PrintObject;
|
|
|
|
mPrt->mPrintObject->mWebShell = webContainer;
|
|
|
|
mPrt->mPrintDocList->AppendElement(mPrt->mPrintObject);
|
|
|
|
|
|
|
|
mPrt->mIsParentAFrameSet = IsParentAFrameSet(webContainer);
|
|
|
|
mPrt->mPrintObject->mFrameType = mPrt->mIsParentAFrameSet?eFrameSet:eDoc;
|
|
|
|
|
|
|
|
// Build the "tree" of PrintObjects
|
|
|
|
nsCOMPtr<nsIDocShellTreeNode> parentAsNode(do_QueryInterface(webContainer));
|
|
|
|
BuildDocTree(parentAsNode, mPrt->mPrintDocList, mPrt->mPrintObject);
|
|
|
|
|
|
|
|
// Create the linkage from the suv-docs back to the content element
|
|
|
|
// in the parent document
|
|
|
|
MapContentToWebShells(mPrt->mPrintObject, mPrt->mPrintObject);
|
|
|
|
|
|
|
|
// Get whether the doc contains a frameset
|
|
|
|
// Also, check to see if the currently focus webshell
|
|
|
|
// is a child of this webshell
|
|
|
|
mPrt->mIsIFrameSelected = IsThereAnIFrameSelected(webContainer, mPrt->mCurrentFocusWin, mPrt->mIsParentAFrameSet);
|
|
|
|
|
|
|
|
|
|
|
|
DUMP_DOC_LIST("\nAfter Mapping------------------------------------------");
|
|
|
|
|
|
|
|
// Setup print options for UI
|
|
|
|
rv = NS_ERROR_FAILURE;
|
2002-01-01 15:58:53 +03:00
|
|
|
if (mPrt->mPrintSettings != nsnull) {
|
2002-02-19 14:49:27 +03:00
|
|
|
mPrt->mPrintSettings->GetShrinkToFit(&mPrt->mShrinkToFit);
|
|
|
|
|
2001-11-03 17:59:39 +03:00
|
|
|
if (mPrt->mIsParentAFrameSet) {
|
|
|
|
if (mPrt->mCurrentFocusWin) {
|
2002-01-01 15:58:53 +03:00
|
|
|
mPrt->mPrintSettings->SetHowToEnableFrameUI(nsIPrintSettings::kFrameEnableAll);
|
2001-11-03 17:59:39 +03:00
|
|
|
} else {
|
2002-01-01 15:58:53 +03:00
|
|
|
mPrt->mPrintSettings->SetHowToEnableFrameUI(nsIPrintSettings::kFrameEnableAsIsAndEach);
|
2001-11-03 17:59:39 +03:00
|
|
|
}
|
|
|
|
} else {
|
2002-01-01 15:58:53 +03:00
|
|
|
mPrt->mPrintSettings->SetHowToEnableFrameUI(nsIPrintSettings::kFrameEnableNone);
|
2001-11-03 17:59:39 +03:00
|
|
|
}
|
|
|
|
// Now determine how to set up the Frame print UI
|
2002-01-01 15:58:53 +03:00
|
|
|
mPrt->mPrintSettings->SetPrintOptions(nsIPrintSettings::kEnableSelectionRB, isSelection || mPrt->mIsIFrameSelected);
|
2001-11-03 17:59:39 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
#ifdef DEBUG_PRINTING
|
2002-01-01 15:58:53 +03:00
|
|
|
if (mPrt->mPrintSettings) {
|
|
|
|
PRInt16 printHowEnable = nsIPrintSettings::kFrameEnableNone;
|
|
|
|
mPrt->mPrintSettings->GetHowToEnableFrameUI(&printHowEnable);
|
2001-11-03 17:59:39 +03:00
|
|
|
PRBool val;
|
2002-01-01 15:58:53 +03:00
|
|
|
mPrt->mPrintSettings->GetPrintOptions(nsIPrintSettings::kEnableSelectionRB, &val);
|
2001-11-03 17:59:39 +03:00
|
|
|
|
|
|
|
PRINT_DEBUG_MSG1("********* DocumentViewerImpl::Print *********\n");
|
|
|
|
PRINT_DEBUG_MSG2("IsParentAFrameSet: %s \n", PRT_YESNO(mPrt->mIsParentAFrameSet));
|
|
|
|
PRINT_DEBUG_MSG2("IsIFrameSelected: %s \n", PRT_YESNO(mPrt->mIsIFrameSelected));
|
|
|
|
PRINT_DEBUG_MSG2("Main Doc Frame Type: %s \n", gFrameTypesStr[mPrt->mPrintObject->mFrameType]);
|
|
|
|
PRINT_DEBUG_MSG2("HowToEnableFrameUI: %s \n", gFrameHowToEnableStr[printHowEnable]);
|
|
|
|
PRINT_DEBUG_MSG2("EnableSelectionRB: %s \n", PRT_YESNO(val));
|
|
|
|
PRINT_DEBUG_MSG1("*********************************************\n");
|
|
|
|
PRINT_DEBUG_FLUSH
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
PRBool doSilent = PR_TRUE;
|
|
|
|
|
|
|
|
nscoord width = NS_INCHES_TO_TWIPS(8.5);
|
|
|
|
nscoord height = NS_INCHES_TO_TWIPS(11.0);
|
|
|
|
|
|
|
|
nsCOMPtr<nsIDeviceContext> ppDC;
|
|
|
|
nsCOMPtr<nsIDeviceContextSpecFactory> factory = do_CreateInstance(kDeviceContextSpecFactoryCID);
|
|
|
|
if (factory) {
|
2002-01-29 05:59:12 +03:00
|
|
|
nsCOMPtr<nsIDeviceContextSpec> devspec;
|
2001-11-03 17:59:39 +03:00
|
|
|
nsCOMPtr<nsIDeviceContext> dx;
|
2002-01-29 05:59:12 +03:00
|
|
|
nsresult rv = factory->CreateDeviceContextSpec(mWindow, aPrintSettings, *getter_AddRefs(devspec), doSilent);
|
|
|
|
if (NS_SUCCEEDED(rv)) {
|
|
|
|
rv = mDeviceContext->GetDeviceContextFor(devspec, *getter_AddRefs(ppDC));
|
2001-11-03 17:59:39 +03:00
|
|
|
if (NS_SUCCEEDED(rv)) {
|
|
|
|
mDeviceContext->SetAltDevice(ppDC);
|
2002-01-01 15:58:53 +03:00
|
|
|
if (mPrt->mPrintSettings != nsnull) {
|
2002-02-19 14:49:27 +03:00
|
|
|
// Shrink to Fit over rides and scaling values
|
|
|
|
if (!mPrt->mShrinkToFit) {
|
|
|
|
double scaling;
|
|
|
|
mPrt->mPrintSettings->GetScaling(&scaling);
|
2002-03-10 18:23:54 +03:00
|
|
|
mDeviceContext->SetCanonicalPixelScale(float(scaling)*mPrt->mOrigDCScale);
|
2001-11-29 12:59:16 +03:00
|
|
|
}
|
|
|
|
}
|
2001-11-03 17:59:39 +03:00
|
|
|
ppDC->GetDeviceSurfaceDimensions(width, height);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2002-01-01 15:58:53 +03:00
|
|
|
if (doSilent) {
|
|
|
|
mPrt->mPrintSettings->SetPrintFrameType(nsIPrintSettings::kFramesAsIs);
|
2001-11-03 17:59:39 +03:00
|
|
|
}
|
|
|
|
|
2002-02-06 16:04:47 +03:00
|
|
|
// override any UI that wants to PrintPreview any selection
|
|
|
|
PRInt16 printRangeType = nsIPrintSettings::kRangeAllPages;
|
|
|
|
mPrt->mPrintSettings->GetPrintRange(&printRangeType);
|
|
|
|
if (printRangeType == nsIPrintSettings::kRangeSelection) {
|
|
|
|
mPrt->mPrintSettings->SetPrintRange(nsIPrintSettings::kRangeAllPages);
|
|
|
|
}
|
|
|
|
|
2002-02-19 14:49:27 +03:00
|
|
|
mPrt->mPrintDC = mDeviceContext;
|
|
|
|
// Get the Original PixelScale incase we need to start changing it
|
|
|
|
mPrt->mPrintDC->GetCanonicalPixelScale(mPrt->mOrigDCScale);
|
2001-11-03 17:59:39 +03:00
|
|
|
|
|
|
|
if (mDeviceContext) {
|
|
|
|
mDeviceContext->SetUseAltDC(kUseAltDCFor_FONTMETRICS, PR_TRUE);
|
2002-01-11 14:59:00 +03:00
|
|
|
mDeviceContext->SetUseAltDC(kUseAltDCFor_CREATERC_REFLOW, PR_TRUE);
|
2001-11-03 17:59:39 +03:00
|
|
|
mDeviceContext->SetUseAltDC(kUseAltDCFor_SURFACE_DIM, PR_TRUE);
|
|
|
|
}
|
2002-03-26 14:43:40 +03:00
|
|
|
|
|
|
|
PRBool cacheOldPres = CheckDocumentForPPCaching();
|
|
|
|
|
|
|
|
// If we are caching the Presentation then
|
|
|
|
// end observing the document BEFORE we do any new reflows
|
|
|
|
if (cacheOldPres && !mPrt->HasCachedPres()) {
|
|
|
|
mPrt->SetCacheOldPres(PR_TRUE);
|
|
|
|
mPresShell->EndObservingDocument();
|
|
|
|
}
|
|
|
|
|
2001-11-03 17:59:39 +03:00
|
|
|
rv = DocumentReadyForPrinting();
|
|
|
|
|
2001-11-14 14:24:03 +03:00
|
|
|
mIsCreatingPrintPreview = PR_FALSE;
|
2001-11-03 17:59:39 +03:00
|
|
|
/* cleaup on failure + notify user */
|
|
|
|
if (NS_FAILED(rv)) {
|
|
|
|
if (mPrt) {
|
|
|
|
delete mPrt;
|
|
|
|
mPrt = nsnull;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* cleanup done, let's fire-up an error dialog to notify the user
|
|
|
|
* what went wrong...
|
|
|
|
*/
|
2002-02-12 16:33:39 +03:00
|
|
|
ShowPrintErrorDialog(rv, PR_FALSE);
|
2001-11-03 17:59:39 +03:00
|
|
|
TurnScriptingOn(PR_TRUE);
|
2001-11-14 14:24:03 +03:00
|
|
|
mIsCreatingPrintPreview = PR_FALSE;
|
|
|
|
mIsDoingPrintPreview = PR_FALSE;
|
2001-11-03 17:59:39 +03:00
|
|
|
return rv;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
// At this point we are done preparing everything
|
|
|
|
// before it is to be created
|
|
|
|
|
|
|
|
// Noew create the new Presentation and display it
|
|
|
|
InstallNewPresentation();
|
|
|
|
|
2001-11-14 14:24:03 +03:00
|
|
|
// PrintPreview was built using the mPrt (code reuse)
|
|
|
|
// then we assign it over
|
2001-11-03 17:59:39 +03:00
|
|
|
mPrtPreview = mPrt;
|
|
|
|
mPrt = nsnull;
|
|
|
|
|
|
|
|
#endif // NS_PRINT_PREVIEW
|
|
|
|
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2002-01-01 15:58:53 +03:00
|
|
|
|
|
|
|
void
|
2002-02-12 16:33:39 +03:00
|
|
|
DocumentViewerImpl::SetDocAndURLIntoProgress(PrintObject* aPO, nsIPrintProgressParams* aParams)
|
2002-01-01 15:58:53 +03:00
|
|
|
{
|
2002-02-12 16:33:39 +03:00
|
|
|
NS_ASSERTION(aPO, "Must have vaild PrintObject");
|
2002-01-01 15:58:53 +03:00
|
|
|
NS_ASSERTION(aParams, "Must have vaild nsIPrintProgressParams");
|
2002-02-12 16:33:39 +03:00
|
|
|
|
|
|
|
if (!aPO || !aPO->mWebShell || !aParams) {
|
2002-01-01 15:58:53 +03:00
|
|
|
return;
|
|
|
|
}
|
2002-01-11 14:59:00 +03:00
|
|
|
const PRInt32 kTitleLength = 64;
|
|
|
|
|
2002-01-01 15:58:53 +03:00
|
|
|
PRUnichar * docTitleStr;
|
|
|
|
PRUnichar * docURLStr;
|
2002-03-27 06:02:42 +03:00
|
|
|
GetDisplayTitleAndURL(aPO, mPrt->mPrintSettings, mPrt->mBrandName, &docTitleStr, &docURLStr, eDocTitleDefDocument);
|
2002-01-11 14:59:00 +03:00
|
|
|
|
|
|
|
// Make sure the URLS don't get too long for the progress dialog
|
2002-02-12 16:33:39 +03:00
|
|
|
if (docURLStr && nsCRT::strlen(docURLStr) > kTitleLength) {
|
2002-01-11 14:59:00 +03:00
|
|
|
PRUnichar * ptr = &docURLStr[nsCRT::strlen(docURLStr)-kTitleLength+3];
|
|
|
|
nsAutoString newURLStr;
|
|
|
|
newURLStr.AppendWithConversion("...");
|
|
|
|
newURLStr += ptr;
|
|
|
|
nsMemory::Free(docURLStr);
|
|
|
|
docURLStr = ToNewUnicode(newURLStr);
|
|
|
|
}
|
|
|
|
|
2002-01-01 15:58:53 +03:00
|
|
|
mPrt->mPrintProgressParams->SetDocTitle((const PRUnichar*) docTitleStr);
|
|
|
|
mPrt->mPrintProgressParams->SetDocURL((const PRUnichar*) docURLStr);
|
2002-01-11 14:59:00 +03:00
|
|
|
|
2002-01-01 15:58:53 +03:00
|
|
|
if (docTitleStr != nsnull) nsMemory::Free(docTitleStr);
|
|
|
|
if (docURLStr != nsnull) nsMemory::Free(docURLStr);
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
DocumentViewerImpl::DoPrintProgress(PRBool aIsForPrinting)
|
|
|
|
{
|
|
|
|
nsPrintProgress* prtProgress = new nsPrintProgress();
|
|
|
|
nsresult rv = prtProgress->QueryInterface(NS_GET_IID(nsIPrintProgress), (void**)getter_AddRefs(mPrt->mPrintProgress));
|
|
|
|
if (NS_FAILED(rv)) return;
|
|
|
|
|
|
|
|
|
|
|
|
rv = prtProgress->QueryInterface(NS_GET_IID(nsIWebProgressListener), (void**)getter_AddRefs(mPrt->mPrintProgressListener));
|
|
|
|
if (NS_FAILED(rv)) return;
|
|
|
|
// add to listener list
|
|
|
|
mPrt->mPrintProgressListeners.AppendElement((void*)mPrt->mPrintProgressListener);
|
|
|
|
nsIWebProgressListener* wpl = NS_STATIC_CAST(nsIWebProgressListener*, mPrt->mPrintProgressListener.get());
|
|
|
|
NS_ASSERTION(wpl, "nsIWebProgressListener is NULL!");
|
|
|
|
NS_ADDREF(wpl);
|
|
|
|
|
|
|
|
nsCOMPtr<nsIPref> prefs (do_GetService(NS_PREF_CONTRACTID));
|
|
|
|
if (prefs) {
|
|
|
|
prefs->GetBoolPref("print.show_print_progress", &mPrt->mShowProgressDialog);
|
|
|
|
if (mPrt->mShowProgressDialog) {
|
|
|
|
nsPrintProgressParams* prtProgressParams = new nsPrintProgressParams();
|
|
|
|
nsCOMPtr<nsIPrintProgressParams> params;
|
|
|
|
rv = prtProgressParams->QueryInterface(NS_GET_IID(nsIPrintProgressParams), (void**)getter_AddRefs(mPrt->mPrintProgressParams));
|
|
|
|
if (NS_SUCCEEDED(rv) && mPrt->mPrintProgressParams) {
|
2002-02-12 16:33:39 +03:00
|
|
|
SetDocAndURLIntoProgress(mPrt->mPrintObject, mPrt->mPrintProgressParams);
|
2002-01-01 15:58:53 +03:00
|
|
|
|
|
|
|
nsCOMPtr<nsIWindowWatcher> wwatch(do_GetService("@mozilla.org/embedcomp/window-watcher;1"));
|
|
|
|
if (wwatch) {
|
|
|
|
nsCOMPtr<nsIDOMWindow> active;
|
|
|
|
wwatch->GetActiveWindow(getter_AddRefs(active));
|
|
|
|
|
|
|
|
nsCOMPtr<nsIDOMWindowInternal> parent(do_QueryInterface(active));
|
|
|
|
mPrt->mPrintProgress->OpenProgressDialog(parent, "chrome://global/content/printProgress.xul", mPrt->mPrintProgressParams);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2002-02-01 17:52:11 +03:00
|
|
|
/* ========================================================================================
|
|
|
|
* nsIContentViewerFile
|
|
|
|
* ======================================================================================== */
|
2002-01-01 15:58:53 +03:00
|
|
|
/** ---------------------------------------------------
|
|
|
|
* See documentation above in the nsIContentViewerfile class definition
|
|
|
|
* @update 01/24/00 dwc
|
|
|
|
*/
|
|
|
|
NS_IMETHODIMP
|
|
|
|
DocumentViewerImpl::Print(PRBool aSilent,
|
|
|
|
FILE * aDebugFile,
|
|
|
|
nsIPrintSettings* aPrintSettings)
|
|
|
|
{
|
2002-02-01 17:52:11 +03:00
|
|
|
nsCOMPtr<nsIPrintSettings> printSettings;
|
|
|
|
#ifdef NS_DEBUG
|
|
|
|
nsresult rv = NS_ERROR_FAILURE;
|
|
|
|
|
2002-01-01 15:58:53 +03:00
|
|
|
mDebugFile = aDebugFile;
|
2002-02-01 17:52:11 +03:00
|
|
|
// if they don't pass in a PrintSettings, then make one
|
|
|
|
// it will have all the default values
|
|
|
|
printSettings = aPrintSettings;
|
|
|
|
nsCOMPtr<nsIPrintOptions> printOptions = do_GetService(kPrintOptionsCID, &rv);
|
|
|
|
if (NS_SUCCEEDED(rv)) {
|
|
|
|
// if they don't pass in a PrintSettings, then make one
|
|
|
|
if (printSettings == nsnull) {
|
|
|
|
printOptions->CreatePrintSettings(getter_AddRefs(printSettings));
|
|
|
|
}
|
|
|
|
NS_ASSERTION(printSettings, "You can't PrintPreview without a PrintSettings!");
|
|
|
|
}
|
|
|
|
if (printSettings) printSettings->SetPrintSilent(aSilent);
|
2002-01-01 15:58:53 +03:00
|
|
|
#endif
|
|
|
|
|
2002-03-22 17:49:29 +03:00
|
|
|
|
2002-02-01 17:52:11 +03:00
|
|
|
return Print(printSettings, nsnull);
|
2002-03-22 17:49:29 +03:00
|
|
|
|
2002-02-01 17:52:11 +03:00
|
|
|
}
|
|
|
|
|
1999-11-19 10:35:27 +03:00
|
|
|
/** ---------------------------------------------------
|
2002-02-01 17:52:11 +03:00
|
|
|
* From nsIWebBrowserPrint
|
1999-11-19 10:35:27 +03:00
|
|
|
*/
|
|
|
|
NS_IMETHODIMP
|
2002-02-01 17:52:11 +03:00
|
|
|
DocumentViewerImpl::Print(nsIPrintSettings* aPrintSettings,
|
2002-01-01 15:58:53 +03:00
|
|
|
nsIWebProgressListener* aWebProgressListener)
|
1999-11-19 10:35:27 +03:00
|
|
|
{
|
2001-11-03 17:59:39 +03:00
|
|
|
#ifdef DEBUG_PRINTING
|
|
|
|
// need for capturing result on each doc and sub-doc that is printed
|
|
|
|
gDumpFileNameCnt = 0;
|
|
|
|
gDumpLOFileNameCnt = 0;
|
|
|
|
#endif
|
|
|
|
|
2002-03-22 17:49:29 +03:00
|
|
|
|
2002-02-01 17:52:11 +03:00
|
|
|
nsresult rv = NS_ERROR_FAILURE;
|
2001-06-15 18:03:12 +04:00
|
|
|
|
2002-03-22 17:49:29 +03:00
|
|
|
|
2002-01-12 15:58:46 +03:00
|
|
|
if (mIsDoingPrintPreview) {
|
|
|
|
PRBool okToPrint = PR_FALSE;
|
|
|
|
nsCOMPtr<nsIPref> prefs(do_GetService(NS_PREF_CONTRACTID));
|
|
|
|
if (prefs) {
|
|
|
|
prefs->GetBoolPref("print.whileInPrintPreview", &okToPrint);
|
|
|
|
}
|
|
|
|
if (!okToPrint) {
|
|
|
|
ShowPrintErrorDialog(NS_ERROR_GFX_PRINTER_PRINT_WHILE_PREVIEW, PR_FALSE);
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2001-06-15 18:03:12 +04:00
|
|
|
// if we are printing another URL, then exit
|
|
|
|
// the reason we check here is because this method can be called while
|
|
|
|
// another is still in here (the printing dialog is a good example).
|
2001-08-06 06:27:43 +04:00
|
|
|
// the only time we can print more than one job at a time is the regression tests
|
2001-11-03 17:59:39 +03:00
|
|
|
if (mIsDoingPrinting) {
|
2001-09-21 17:52:39 +04:00
|
|
|
// Let the user know we are not ready to print.
|
|
|
|
rv = NS_ERROR_NOT_AVAILABLE;
|
|
|
|
ShowPrintErrorDialog(rv);
|
|
|
|
return rv;
|
2001-06-15 18:03:12 +04:00
|
|
|
}
|
2001-09-21 17:52:39 +04:00
|
|
|
|
2001-04-12 17:04:29 +04:00
|
|
|
mPrt = new PrintData();
|
|
|
|
if (mPrt == nsnull) {
|
|
|
|
return NS_ERROR_OUT_OF_MEMORY;
|
|
|
|
}
|
|
|
|
|
2002-01-01 15:58:53 +03:00
|
|
|
// if they don't pass in a PrintSettings, then make one
|
|
|
|
// it will have all the default values
|
|
|
|
mPrt->mPrintSettings = aPrintSettings;
|
2002-01-12 15:31:05 +03:00
|
|
|
mPrt->mPrintOptions = do_GetService(kPrintOptionsCID, &rv);
|
|
|
|
if (NS_SUCCEEDED(rv) && mPrt->mPrintOptions) {
|
2002-01-01 15:58:53 +03:00
|
|
|
// if they don't pass in a PrintSettings, then make one
|
|
|
|
if (mPrt->mPrintSettings == nsnull) {
|
2002-01-12 15:31:05 +03:00
|
|
|
mPrt->mPrintOptions->CreatePrintSettings(getter_AddRefs(mPrt->mPrintSettings));
|
2002-01-01 15:58:53 +03:00
|
|
|
}
|
|
|
|
NS_ASSERTION(mPrt->mPrintSettings, "You can't PrintPreview without a PrintSettings!");
|
|
|
|
|
|
|
|
// Get the default printer name and set it into the PrintSettings
|
2002-01-12 15:31:05 +03:00
|
|
|
if (NS_FAILED(CheckForPrinters(mPrt->mPrintOptions, mPrt->mPrintSettings, NS_ERROR_GFX_PRINTER_NO_PRINTER_AVAILABLE, PR_TRUE))) {
|
2002-01-01 15:58:53 +03:00
|
|
|
delete mPrt;
|
|
|
|
mPrt = nsnull;
|
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
}
|
2001-03-27 15:56:03 +04:00
|
|
|
}
|
2002-02-12 16:33:39 +03:00
|
|
|
mPrt->mPrintSettings->SetIsCancelled(PR_FALSE);
|
2002-02-19 14:49:27 +03:00
|
|
|
mPrt->mPrintSettings->GetShrinkToFit(&mPrt->mShrinkToFit);
|
2002-01-01 15:58:53 +03:00
|
|
|
|
|
|
|
// Let's print ...
|
|
|
|
mIsDoingPrinting = PR_TRUE;
|
2001-01-27 17:09:34 +03:00
|
|
|
|
2002-03-23 19:48:58 +03:00
|
|
|
// We need to make sure this document doesn't get unloaded
|
|
|
|
// before we have a chance to print, so this stops the Destroy from
|
|
|
|
// being called
|
|
|
|
mPrt->mPreparingForPrint = PR_TRUE;
|
|
|
|
|
2002-01-01 15:58:53 +03:00
|
|
|
if (aWebProgressListener != nsnull) {
|
|
|
|
mPrt->mPrintProgressListeners.AppendElement((void*)aWebProgressListener);
|
|
|
|
NS_ADDREF(aWebProgressListener);
|
|
|
|
}
|
|
|
|
|
2001-05-31 05:06:33 +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
|
|
|
|
mPrt->mCurrentFocusWin = getter_AddRefs(FindFocusedDOMWindowInternal());
|
|
|
|
|
|
|
|
// Check to see if there is a "regular" selection
|
|
|
|
PRBool isSelection = IsThereARangeSelection(mPrt->mCurrentFocusWin);
|
2001-04-12 17:04:29 +04:00
|
|
|
|
|
|
|
// Create a list for storing the WebShells that need to be printed
|
|
|
|
if (mPrt->mPrintDocList == nsnull) {
|
|
|
|
mPrt->mPrintDocList = new nsVoidArray();
|
|
|
|
if (mPrt->mPrintDocList == nsnull) {
|
2001-11-03 17:59:39 +03:00
|
|
|
mIsDoingPrinting = PR_FALSE;
|
2002-01-01 15:58:53 +03:00
|
|
|
delete mPrt;
|
|
|
|
mPrt = nsnull;
|
2001-04-12 17:04:29 +04:00
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
mPrt->mPrintDocList->Clear();
|
|
|
|
}
|
2001-02-07 02:03:17 +03:00
|
|
|
|
2002-03-22 03:42:48 +03:00
|
|
|
// Get the webshell for this documentviewer
|
|
|
|
nsCOMPtr<nsIWebShell> webContainer(do_QueryInterface(mContainer));
|
|
|
|
|
2001-04-12 17:04:29 +04:00
|
|
|
// Add Root Doc to Tree and List
|
|
|
|
mPrt->mPrintObject = new PrintObject;
|
|
|
|
mPrt->mPrintObject->mWebShell = webContainer;
|
|
|
|
mPrt->mPrintDocList->AppendElement(mPrt->mPrintObject);
|
|
|
|
|
|
|
|
mPrt->mIsParentAFrameSet = IsParentAFrameSet(webContainer);
|
|
|
|
mPrt->mPrintObject->mFrameType = mPrt->mIsParentAFrameSet?eFrameSet:eDoc;
|
|
|
|
|
|
|
|
// Build the "tree" of PrintObjects
|
|
|
|
nsCOMPtr<nsIDocShellTreeNode> parentAsNode(do_QueryInterface(webContainer));
|
|
|
|
BuildDocTree(parentAsNode, mPrt->mPrintDocList, mPrt->mPrintObject);
|
|
|
|
|
|
|
|
// Create the linkage from the suv-docs back to the content element
|
|
|
|
// in the parent document
|
|
|
|
MapContentToWebShells(mPrt->mPrintObject, mPrt->mPrintObject);
|
|
|
|
|
2001-02-07 02:03:17 +03:00
|
|
|
|
|
|
|
// Get whether the doc contains a frameset
|
|
|
|
// Also, check to see if the currently focus webshell
|
|
|
|
// is a child of this webshell
|
2001-05-31 05:06:33 +04:00
|
|
|
mPrt->mIsIFrameSelected = IsThereAnIFrameSelected(webContainer, mPrt->mCurrentFocusWin, mPrt->mIsParentAFrameSet);
|
2001-04-12 17:04:29 +04:00
|
|
|
|
|
|
|
DUMP_DOC_LIST("\nAfter Mapping------------------------------------------");
|
2001-02-07 02:03:17 +03:00
|
|
|
|
2001-06-15 18:03:12 +04:00
|
|
|
rv = NS_ERROR_FAILURE;
|
2002-01-01 15:58:53 +03:00
|
|
|
// Setup print options for UI
|
|
|
|
if (mPrt->mIsParentAFrameSet) {
|
|
|
|
if (mPrt->mCurrentFocusWin) {
|
|
|
|
mPrt->mPrintSettings->SetHowToEnableFrameUI(nsIPrintSettings::kFrameEnableAll);
|
2001-02-07 02:03:17 +03:00
|
|
|
} else {
|
2002-01-01 15:58:53 +03:00
|
|
|
mPrt->mPrintSettings->SetHowToEnableFrameUI(nsIPrintSettings::kFrameEnableAsIsAndEach);
|
2001-02-07 02:03:17 +03:00
|
|
|
}
|
2002-01-01 15:58:53 +03:00
|
|
|
} else {
|
|
|
|
mPrt->mPrintSettings->SetHowToEnableFrameUI(nsIPrintSettings::kFrameEnableNone);
|
2001-04-12 17:04:29 +04:00
|
|
|
}
|
2002-01-01 15:58:53 +03:00
|
|
|
// Now determine how to set up the Frame print UI
|
|
|
|
mPrt->mPrintSettings->SetPrintOptions(nsIPrintSettings::kEnableSelectionRB, isSelection || mPrt->mIsIFrameSelected);
|
2001-04-12 17:04:29 +04:00
|
|
|
|
|
|
|
#ifdef DEBUG_PRINTING
|
2002-01-01 15:58:53 +03:00
|
|
|
if (mPrt->mPrintSettings) {
|
|
|
|
PRInt16 printHowEnable = nsIPrintSettings::kFrameEnableNone;
|
|
|
|
mPrt->mPrintSettings->GetHowToEnableFrameUI(&printHowEnable);
|
2001-04-12 17:04:29 +04:00
|
|
|
PRBool val;
|
2002-01-01 15:58:53 +03:00
|
|
|
mPrt->mPrintSettings->GetPrintOptions(nsIPrintSettings::kEnableSelectionRB, &val);
|
2001-04-12 17:04:29 +04:00
|
|
|
|
|
|
|
PRINT_DEBUG_MSG1("********* DocumentViewerImpl::Print *********\n");
|
|
|
|
PRINT_DEBUG_MSG2("IsParentAFrameSet: %s \n", PRT_YESNO(mPrt->mIsParentAFrameSet));
|
2001-09-20 16:13:48 +04:00
|
|
|
PRINT_DEBUG_MSG2("IsIFrameSelected: %s \n", PRT_YESNO(mPrt->mIsIFrameSelected));
|
2001-04-12 17:04:29 +04:00
|
|
|
PRINT_DEBUG_MSG2("Main Doc Frame Type: %s \n", gFrameTypesStr[mPrt->mPrintObject->mFrameType]);
|
|
|
|
PRINT_DEBUG_MSG2("HowToEnableFrameUI: %s \n", gFrameHowToEnableStr[printHowEnable]);
|
|
|
|
PRINT_DEBUG_MSG2("EnableSelectionRB: %s \n", PRT_YESNO(val));
|
|
|
|
PRINT_DEBUG_MSG1("*********************************************\n");
|
|
|
|
PRINT_DEBUG_FLUSH
|
2001-01-27 17:09:34 +03:00
|
|
|
}
|
2001-04-12 17:04:29 +04:00
|
|
|
#endif
|
1999-11-19 10:35:27 +03:00
|
|
|
|
2001-09-21 17:52:39 +04:00
|
|
|
/* create factory (incl. create print dialog) */
|
2001-08-01 07:15:50 +04:00
|
|
|
nsCOMPtr<nsIDeviceContextSpecFactory> factory =
|
2001-09-21 17:52:39 +04:00
|
|
|
do_CreateInstance(kDeviceContextSpecFactoryCID, &rv);
|
|
|
|
|
|
|
|
if (NS_SUCCEEDED(rv)) {
|
1999-11-19 10:35:27 +03:00
|
|
|
#ifdef DEBUG_dcone
|
2000-10-29 02:17:53 +04:00
|
|
|
printf("PRINT JOB STARTING\n");
|
1999-11-19 10:35:27 +03:00
|
|
|
#endif
|
|
|
|
|
2002-01-29 05:59:12 +03:00
|
|
|
nsCOMPtr<nsIDeviceContextSpec> devspec;
|
1999-11-19 10:35:27 +03:00
|
|
|
nsCOMPtr<nsIDeviceContext> dx;
|
2001-08-01 07:15:50 +04:00
|
|
|
mPrt->mPrintDC = nsnull; // XXX why?
|
1999-11-19 10:35:27 +03:00
|
|
|
|
2002-01-01 15:58:53 +03:00
|
|
|
#ifdef NS_DEBUG
|
|
|
|
mPrt->mDebugFilePtr = mDebugFile;
|
|
|
|
#endif
|
|
|
|
|
2002-03-22 17:49:29 +03:00
|
|
|
// we have to turn off printpreview mode for now.. because this is a real request to print.
|
|
|
|
if ( mIsDoingPrintPreview == PR_TRUE) {
|
|
|
|
aPrintSettings->SetIsPrintPreview(PR_FALSE);
|
|
|
|
}
|
|
|
|
|
2002-01-01 15:58:53 +03:00
|
|
|
PRBool printSilently;
|
|
|
|
mPrt->mPrintSettings->GetPrintSilent(&printSilently);
|
2002-01-29 05:59:12 +03:00
|
|
|
rv = factory->CreateDeviceContextSpec(mWindow, mPrt->mPrintSettings, *getter_AddRefs(devspec), printSilently);
|
2002-03-23 19:48:58 +03:00
|
|
|
|
|
|
|
// If the page was intended to be destroyed while we were in the print dialog
|
|
|
|
// then we need to clean up and abort the printing.
|
|
|
|
if (mPrt->mDocWasToBeDestroyed) {
|
|
|
|
mPrt->mPreparingForPrint = PR_FALSE;
|
|
|
|
Destroy();
|
|
|
|
mIsDoingPrinting = PR_FALSE;
|
|
|
|
// If they hit cancel then rv will equal NS_ERROR_ABORT and
|
|
|
|
// then we don't want to display the message
|
|
|
|
if (rv != NS_ERROR_ABORT) {
|
|
|
|
ShowPrintErrorDialog(NS_ERROR_GFX_PRINTER_DOC_WAS_DESTORYED);
|
|
|
|
}
|
|
|
|
return NS_ERROR_ABORT;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (NS_SUCCEEDED(rv)) {
|
2001-09-21 17:52:39 +04:00
|
|
|
rv = mPresContext->GetDeviceContext(getter_AddRefs(dx));
|
1999-11-19 10:35:27 +03:00
|
|
|
if (NS_SUCCEEDED(rv)) {
|
2002-01-29 05:59:12 +03:00
|
|
|
rv = dx->GetDeviceContextFor(devspec, *getter_AddRefs(mPrt->mPrintDC));
|
|
|
|
if (NS_SUCCEEDED(rv)) {
|
2002-02-19 14:49:27 +03:00
|
|
|
// Get the Original PixelScale incase we need to start changing it
|
|
|
|
mPrt->mPrintDC->GetCanonicalPixelScale(mPrt->mOrigDCScale);
|
|
|
|
// Shrink to Fit over rides and scaling values
|
|
|
|
if (!mPrt->mShrinkToFit) {
|
|
|
|
double scaling;
|
|
|
|
mPrt->mPrintSettings->GetScaling(&scaling);
|
2002-03-10 18:23:54 +03:00
|
|
|
mPrt->mPrintDC->SetCanonicalPixelScale(float(scaling)*mPrt->mOrigDCScale);
|
2002-01-29 05:59:12 +03:00
|
|
|
}
|
1999-11-19 10:35:27 +03:00
|
|
|
|
2002-01-29 05:59:12 +03:00
|
|
|
if(webContainer) {
|
1999-11-19 10:35:27 +03:00
|
|
|
#ifdef DEBUG_dcone
|
2002-01-29 05:59:12 +03:00
|
|
|
float a1,a2;
|
|
|
|
PRInt32 i1,i2;
|
|
|
|
|
|
|
|
printf("CRITICAL PRINTING INFORMATION\n");
|
|
|
|
|
|
|
|
// DEVICE CONTEXT INFORMATION from PresContext
|
|
|
|
printf("DeviceContext of Presentation Context(%x)\n",dx);
|
|
|
|
dx->GetDevUnitsToTwips(a1);
|
|
|
|
dx->GetTwipsToDevUnits(a2);
|
|
|
|
printf(" DevToTwips = %f TwipToDev = %f\n",a1,a2);
|
|
|
|
dx->GetAppUnitsToDevUnits(a1);
|
|
|
|
dx->GetDevUnitsToAppUnits(a2);
|
|
|
|
printf(" AppUnitsToDev = %f DevUnitsToApp = %f\n",a1,a2);
|
|
|
|
dx->GetCanonicalPixelScale(a1);
|
|
|
|
printf(" GetCanonicalPixelScale = %f\n",a1);
|
|
|
|
dx->GetScrollBarDimensions(a1, a2);
|
|
|
|
printf(" ScrollBar x = %f y = %f\n",a1,a2);
|
|
|
|
dx->GetZoom(a1);
|
|
|
|
printf(" Zoom = %f\n",a1);
|
|
|
|
dx->GetDepth((PRUint32&)i1);
|
|
|
|
printf(" Depth = %d\n",i1);
|
|
|
|
dx->GetDeviceSurfaceDimensions(i1,i2);
|
|
|
|
printf(" DeviceDimension w = %d h = %d\n",i1,i2);
|
|
|
|
|
|
|
|
|
|
|
|
// DEVICE CONTEXT INFORMATION
|
|
|
|
printf("DeviceContext created for print(%x)\n",mPrt->mPrintDC);
|
|
|
|
mPrt->mPrintDC->GetDevUnitsToTwips(a1);
|
|
|
|
mPrt->mPrintDC->GetTwipsToDevUnits(a2);
|
|
|
|
printf(" DevToTwips = %f TwipToDev = %f\n",a1,a2);
|
|
|
|
mPrt->mPrintDC->GetAppUnitsToDevUnits(a1);
|
|
|
|
mPrt->mPrintDC->GetDevUnitsToAppUnits(a2);
|
|
|
|
printf(" AppUnitsToDev = %f DevUnitsToApp = %f\n",a1,a2);
|
|
|
|
mPrt->mPrintDC->GetCanonicalPixelScale(a1);
|
|
|
|
printf(" GetCanonicalPixelScale = %f\n",a1);
|
|
|
|
mPrt->mPrintDC->GetScrollBarDimensions(a1, a2);
|
|
|
|
printf(" ScrollBar x = %f y = %f\n",a1,a2);
|
|
|
|
mPrt->mPrintDC->GetZoom(a1);
|
|
|
|
printf(" Zoom = %f\n",a1);
|
|
|
|
mPrt->mPrintDC->GetDepth((PRUint32&)i1);
|
|
|
|
printf(" Depth = %d\n",i1);
|
|
|
|
mPrt->mPrintDC->GetDeviceSurfaceDimensions(i1,i2);
|
|
|
|
printf(" DeviceDimension w = %d h = %d\n",i1,i2);
|
1999-11-19 10:35:27 +03:00
|
|
|
|
2001-09-21 17:52:39 +04:00
|
|
|
#endif /* DEBUG_dcone */
|
2001-10-29 18:28:45 +03:00
|
|
|
|
2002-01-29 05:59:12 +03:00
|
|
|
// 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;
|
2002-01-01 15:58:53 +03:00
|
|
|
mPrt->mPrintSettings->SetPrintFrameType(mPrt->mPrintFrameType);
|
2002-01-29 05:59:12 +03:00
|
|
|
} 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
|
|
|
|
mPrt->mPrintFrameType = nsIPrintSettings::kEachFrameSep;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
} // switch
|
|
|
|
mPrt->mPrintSettings->SetPrintFrameType(mPrt->mPrintFrameType);
|
|
|
|
}
|
2002-01-01 15:58:53 +03:00
|
|
|
}
|
|
|
|
}
|
2001-10-29 18:28:45 +03:00
|
|
|
|
2002-01-29 05:59:12 +03:00
|
|
|
if (mPrt->mPrintOptions) {
|
|
|
|
// check to see if we are printing to a file
|
|
|
|
PRBool isPrintToFile = PR_FALSE;
|
|
|
|
mPrt->mPrintSettings->GetPrintToFile(&isPrintToFile);
|
|
|
|
if (isPrintToFile) {
|
|
|
|
// On some platforms The BeginDocument needs to know the name of the file
|
|
|
|
// and it uses the PrintService to get it, so we need to set it into the PrintService here
|
|
|
|
PRUnichar* fileName;
|
|
|
|
mPrt->mPrintSettings->GetToFileName(&fileName);
|
|
|
|
if (fileName != nsnull) {
|
|
|
|
mPrt->mPrintOptions->SetPrintToFile(PR_TRUE);
|
|
|
|
mPrt->mPrintOptions->SetToFileName(fileName);
|
|
|
|
nsMemory::Free(fileName);
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
mPrt->mPrintOptions->SetPrintToFile(PR_FALSE);
|
|
|
|
mPrt->mPrintOptions->SetToFileName(nsnull);
|
2002-01-01 15:58:53 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2002-02-12 16:33:39 +03:00
|
|
|
PRUnichar * docTitleStr;
|
|
|
|
PRUnichar * docURLStr;
|
2002-03-27 06:02:42 +03:00
|
|
|
GetDisplayTitleAndURL(mPrt->mPrintObject, mPrt->mPrintSettings, mPrt->mBrandName, &docTitleStr, &docURLStr, eDocTitleDefURLDoc);
|
2002-01-01 15:58:53 +03:00
|
|
|
|
2002-02-12 16:33:39 +03: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
|
|
|
|
rv = mPrt->mDebugFilePtr ? NS_OK: mPrt->mPrintDC->BeginDocument(docTitleStr);
|
|
|
|
PRINT_DEBUG_MSG1("****************** Begin Document ************************\n");
|
2000-03-15 04:47:36 +03:00
|
|
|
|
2002-02-12 16:33:39 +03:00
|
|
|
if (docTitleStr) nsMemory::Free(docTitleStr);
|
|
|
|
if (docURLStr) nsMemory::Free(docURLStr);
|
|
|
|
|
|
|
|
if (NS_SUCCEEDED(rv)) {
|
|
|
|
|
|
|
|
DoPrintProgress(PR_TRUE);
|
|
|
|
|
|
|
|
// Print listener setup...
|
|
|
|
if (mPrt != nsnull) {
|
|
|
|
mPrt->OnStartPrinting();
|
|
|
|
}
|
|
|
|
|
|
|
|
//
|
|
|
|
// The mIsPrinting flag is set when the ImageGroup observer is
|
|
|
|
// notified that images must be loaded as a result of the
|
|
|
|
// InitialReflow...
|
|
|
|
//
|
|
|
|
if(!mIsPrinting || mPrt->mDebugFilePtr) {
|
|
|
|
rv = DocumentReadyForPrinting();
|
|
|
|
PRINT_DEBUG_MSG1("PRINT JOB ENDING, OBSERVER WAS NOT CALLED\n");
|
|
|
|
} else {
|
|
|
|
// use the observer mechanism to finish the printing
|
|
|
|
PRINT_DEBUG_MSG1("PRINTING OBSERVER STARTED\n");
|
|
|
|
}
|
2002-01-29 05:59:12 +03:00
|
|
|
}
|
1999-11-19 10:35:27 +03:00
|
|
|
}
|
|
|
|
}
|
2002-01-29 05:59:12 +03:00
|
|
|
}
|
2002-01-12 15:31:05 +03:00
|
|
|
} else {
|
|
|
|
mPrt->mPrintSettings->SetIsCancelled(PR_TRUE);
|
|
|
|
mPrt->mPrintOptions->SetIsCancelled(PR_TRUE);
|
|
|
|
}
|
2002-03-22 17:49:29 +03:00
|
|
|
|
|
|
|
// Set that we are once again in print preview
|
|
|
|
if ( mIsDoingPrintPreview == PR_TRUE) {
|
|
|
|
aPrintSettings->SetIsPrintPreview(PR_TRUE);
|
|
|
|
}
|
2001-09-21 17:52:39 +04:00
|
|
|
}
|
2002-01-25 17:30:14 +03:00
|
|
|
|
2002-03-22 17:49:29 +03:00
|
|
|
|
|
|
|
|
2001-09-21 17:52:39 +04:00
|
|
|
/* cleaup on failure + notify user */
|
|
|
|
if (NS_FAILED(rv)) {
|
|
|
|
/* cleanup... */
|
|
|
|
if (mPagePrintTimer) {
|
|
|
|
mPagePrintTimer->Stop();
|
|
|
|
NS_RELEASE(mPagePrintTimer);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (mPrt) {
|
2001-04-12 17:04:29 +04:00
|
|
|
delete mPrt;
|
|
|
|
mPrt = nsnull;
|
2000-08-30 06:04:02 +04:00
|
|
|
}
|
2001-11-03 17:59:39 +03:00
|
|
|
mIsDoingPrinting = PR_FALSE;
|
2001-02-07 02:03:17 +03:00
|
|
|
|
2001-09-21 17:52:39 +04:00
|
|
|
/* cleanup done, let's fire-up an error dialog to notify the user
|
|
|
|
* what went wrong...
|
2002-02-12 16:33:39 +03:00
|
|
|
*
|
|
|
|
* When rv == NS_ERROR_ABORT, it means we want out of the
|
|
|
|
* print job without displaying any error messages
|
2001-10-11 23:10:26 +04:00
|
|
|
*/
|
2002-02-01 17:52:11 +03:00
|
|
|
if (rv != NS_ERROR_ABORT) {
|
2001-10-11 23:10:26 +04:00
|
|
|
ShowPrintErrorDialog(rv);
|
2002-02-01 17:52:11 +03:00
|
|
|
}
|
1999-11-19 10:35:27 +03:00
|
|
|
}
|
2001-09-21 17:52:39 +04:00
|
|
|
|
2001-03-27 15:56:03 +04:00
|
|
|
return rv;
|
1999-11-19 10:35:27 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2001-09-21 17:52:39 +04:00
|
|
|
void
|
2002-01-01 15:58:53 +03:00
|
|
|
DocumentViewerImpl::ShowPrintErrorDialog(nsresult aPrintError, PRBool aIsPrinting)
|
2001-09-21 17:52:39 +04:00
|
|
|
{
|
|
|
|
nsresult rv;
|
|
|
|
|
|
|
|
static NS_DEFINE_CID(kCStringBundleServiceCID, NS_STRINGBUNDLESERVICE_CID);
|
|
|
|
nsCOMPtr<nsIStringBundleService> stringBundleService = do_GetService(kCStringBundleServiceCID);
|
|
|
|
|
|
|
|
if (!stringBundleService) {
|
|
|
|
NS_WARNING("ERROR: Failed to get StringBundle Service instance.\n");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
nsCOMPtr<nsIStringBundle> myStringBundle;
|
|
|
|
rv = stringBundleService->CreateBundle(NS_ERROR_GFX_PRINTER_BUNDLE_URL, getter_AddRefs(myStringBundle));
|
|
|
|
if (NS_FAILED(rv))
|
|
|
|
return;
|
|
|
|
|
2002-02-23 18:32:03 +03:00
|
|
|
nsXPIDLString msg,
|
|
|
|
title;
|
|
|
|
nsAutoString stringName;
|
2001-09-21 17:52:39 +04:00
|
|
|
|
2002-01-01 15:58:53 +03:00
|
|
|
switch(aPrintError)
|
2001-09-21 17:52:39 +04:00
|
|
|
{
|
|
|
|
#define NS_ERROR_TO_LOCALIZED_PRINT_ERROR_MSG(nserr) case nserr: stringName = NS_LITERAL_STRING(#nserr); break;
|
|
|
|
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)
|
2002-01-01 15:58:53 +03:00
|
|
|
NS_ERROR_TO_LOCALIZED_PRINT_ERROR_MSG(NS_ERROR_GFX_PRINTER_NO_PRINTER_AVAILABLE)
|
2001-09-21 17:52:39 +04:00
|
|
|
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)
|
2002-01-01 15:58:53 +03:00
|
|
|
NS_ERROR_TO_LOCALIZED_PRINT_ERROR_MSG(NS_ERROR_GFX_PRINTER_PRINTPREVIEW)
|
2001-09-21 17:52:39 +04:00
|
|
|
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)
|
2002-01-08 04:17:40 +03:00
|
|
|
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)
|
2002-01-12 15:58:46 +03:00
|
|
|
NS_ERROR_TO_LOCALIZED_PRINT_ERROR_MSG(NS_ERROR_GFX_PRINTER_PRINT_WHILE_PREVIEW)
|
2002-01-29 06:03:56 +03:00
|
|
|
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)
|
2002-02-23 18:32:03 +03:00
|
|
|
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_XPRINT_BROKEN_XPRT)
|
2002-03-23 19:48:58 +03:00
|
|
|
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)
|
2002-01-29 06:03:56 +03:00
|
|
|
|
2001-09-21 17:52:39 +04:00
|
|
|
default:
|
|
|
|
NS_ERROR_TO_LOCALIZED_PRINT_ERROR_MSG(NS_ERROR_FAILURE)
|
|
|
|
#undef NS_ERROR_TO_LOCALIZED_PRINT_ERROR_MSG
|
|
|
|
}
|
2002-01-01 15:58:53 +03:00
|
|
|
|
2002-02-23 18:32:03 +03:00
|
|
|
myStringBundle->GetStringFromName(stringName.get(), getter_Copies(msg));
|
2002-01-01 15:58:53 +03:00
|
|
|
if (aIsPrinting) {
|
2002-02-23 18:32:03 +03:00
|
|
|
myStringBundle->GetStringFromName(NS_LITERAL_STRING("print_error_dialog_title").get(), getter_Copies(title));
|
2002-01-01 15:58:53 +03:00
|
|
|
} else {
|
2002-02-23 18:32:03 +03:00
|
|
|
myStringBundle->GetStringFromName(NS_LITERAL_STRING("printpreview_error_dialog_title").get(), getter_Copies(title));
|
2002-01-01 15:58:53 +03:00
|
|
|
}
|
|
|
|
|
2001-09-21 17:52:39 +04:00
|
|
|
if (!msg)
|
|
|
|
return;
|
|
|
|
|
2002-02-23 18:32:03 +03:00
|
|
|
nsCOMPtr<nsIWindowWatcher> wwatch = do_GetService("@mozilla.org/embedcomp/window-watcher;1", &rv);
|
|
|
|
if (NS_FAILED(rv))
|
|
|
|
return;
|
|
|
|
|
|
|
|
nsCOMPtr<nsIDOMWindow> active;
|
|
|
|
wwatch->GetActiveWindow(getter_AddRefs(active));
|
2001-09-21 17:52:39 +04:00
|
|
|
|
2002-02-23 18:32:03 +03:00
|
|
|
nsCOMPtr<nsIDOMWindowInternal> parent = do_QueryInterface(active, &rv);
|
|
|
|
if (NS_FAILED(rv))
|
|
|
|
return;
|
|
|
|
|
|
|
|
nsCOMPtr<nsIPrompt> dialog;
|
|
|
|
parent->GetPrompter(getter_AddRefs(dialog));
|
|
|
|
if (!dialog)
|
|
|
|
return;
|
2001-09-21 17:52:39 +04:00
|
|
|
|
2002-02-23 18:32:03 +03:00
|
|
|
dialog->Alert(title, msg);
|
2001-09-21 17:52:39 +04:00
|
|
|
}
|
|
|
|
|
2002-02-01 17:52:11 +03:00
|
|
|
// nsIContentViewerFile interface
|
1999-11-19 10:35:27 +03:00
|
|
|
NS_IMETHODIMP
|
|
|
|
DocumentViewerImpl::GetPrintable(PRBool *aPrintable)
|
|
|
|
{
|
|
|
|
NS_ENSURE_ARG_POINTER(aPrintable);
|
|
|
|
|
2001-08-18 02:16:17 +04:00
|
|
|
|
2001-11-03 17:59:39 +03:00
|
|
|
if(mIsDoingPrinting==PR_TRUE){
|
2001-08-18 02:16:17 +04:00
|
|
|
*aPrintable = PR_FALSE;
|
|
|
|
} else {
|
|
|
|
*aPrintable = PR_TRUE;
|
|
|
|
}
|
|
|
|
|
1999-11-19 10:35:27 +03:00
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2000-01-19 00:06:10 +03:00
|
|
|
#ifdef XP_MAC
|
|
|
|
#pragma mark -
|
|
|
|
#endif
|
1999-11-19 10:35:27 +03:00
|
|
|
|
|
|
|
//*****************************************************************************
|
|
|
|
// nsIMarkupDocumentViewer
|
|
|
|
//*****************************************************************************
|
|
|
|
|
|
|
|
NS_IMETHODIMP DocumentViewerImpl::ScrollToNode(nsIDOMNode* aNode)
|
|
|
|
{
|
|
|
|
NS_ENSURE_ARG(aNode);
|
2001-03-10 06:19:36 +03:00
|
|
|
NS_ENSURE_TRUE(mDocument, NS_ERROR_NOT_AVAILABLE);
|
1999-11-19 10:35:27 +03:00
|
|
|
nsCOMPtr<nsIPresShell> presShell;
|
|
|
|
NS_ENSURE_SUCCESS(GetPresShell(*(getter_AddRefs(presShell))), NS_ERROR_FAILURE);
|
|
|
|
|
|
|
|
// Get the nsIContent interface, because that's what we need to
|
|
|
|
// get the primary frame
|
|
|
|
|
|
|
|
nsCOMPtr<nsIContent> content(do_QueryInterface(aNode));
|
|
|
|
NS_ENSURE_TRUE(content, NS_ERROR_FAILURE);
|
|
|
|
|
|
|
|
// Get the primary frame
|
|
|
|
nsIFrame* frame; // Remember Frames aren't ref-counted. They are in their
|
|
|
|
// own special little world.
|
|
|
|
|
|
|
|
NS_ENSURE_SUCCESS(presShell->GetPrimaryFrameFor(content, &frame),
|
|
|
|
NS_ERROR_FAILURE);
|
|
|
|
|
|
|
|
// tell the pres shell to scroll to the frame
|
|
|
|
NS_ENSURE_SUCCESS(presShell->ScrollFrameIntoView(frame,
|
|
|
|
NS_PRESSHELL_SCROLL_TOP,
|
|
|
|
NS_PRESSHELL_SCROLL_ANYWHERE),
|
|
|
|
NS_ERROR_FAILURE);
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP DocumentViewerImpl::GetAllowPlugins(PRBool* aAllowPlugins)
|
|
|
|
{
|
|
|
|
NS_ENSURE_ARG_POINTER(aAllowPlugins);
|
|
|
|
|
|
|
|
*aAllowPlugins = mAllowPlugins;
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP DocumentViewerImpl::SetAllowPlugins(PRBool aAllowPlugins)
|
|
|
|
{
|
|
|
|
mAllowPlugins = aAllowPlugins;
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2000-04-03 01:52:17 +04:00
|
|
|
nsresult
|
|
|
|
DocumentViewerImpl::CallChildren(CallChildFunc aFunc, void* aClosure)
|
|
|
|
{
|
|
|
|
nsCOMPtr<nsIDocShellTreeNode> docShellNode(do_QueryInterface(mContainer));
|
|
|
|
if (docShellNode)
|
|
|
|
{
|
|
|
|
PRInt32 i;
|
|
|
|
PRInt32 n;
|
|
|
|
docShellNode->GetChildCount(&n);
|
|
|
|
for (i=0; i < n; i++)
|
|
|
|
{
|
|
|
|
nsCOMPtr<nsIDocShellTreeItem> child;
|
|
|
|
docShellNode->GetChildAt(i, getter_AddRefs(child));
|
|
|
|
nsCOMPtr<nsIDocShell> childAsShell(do_QueryInterface(child));
|
|
|
|
NS_ASSERTION(childAsShell, "null child in docshell");
|
|
|
|
if (childAsShell)
|
|
|
|
{
|
|
|
|
nsCOMPtr<nsIContentViewer> childCV;
|
|
|
|
childAsShell->GetContentViewer(getter_AddRefs(childCV));
|
|
|
|
if (childCV)
|
|
|
|
{
|
|
|
|
nsCOMPtr<nsIMarkupDocumentViewer> markupCV = do_QueryInterface(childCV);
|
|
|
|
if (markupCV) {
|
|
|
|
(*aFunc)(markupCV, aClosure);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
struct TextZoomInfo
|
|
|
|
{
|
|
|
|
float mTextZoom;
|
|
|
|
};
|
|
|
|
|
|
|
|
static void
|
|
|
|
SetChildTextZoom(nsIMarkupDocumentViewer* aChild, void* aClosure)
|
|
|
|
{
|
|
|
|
struct TextZoomInfo* textZoomInfo = (struct TextZoomInfo*) aClosure;
|
|
|
|
aChild->SetTextZoom(textZoomInfo->mTextZoom);
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP DocumentViewerImpl::SetTextZoom(float aTextZoom)
|
|
|
|
{
|
|
|
|
if (mDeviceContext) {
|
|
|
|
mDeviceContext->SetTextZoom(aTextZoom);
|
|
|
|
if (mPresContext) {
|
2001-07-25 10:33:06 +04:00
|
|
|
mPresContext->ClearStyleDataAndReflow();
|
2000-04-03 01:52:17 +04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// now set the text zoom on all children of mContainer
|
|
|
|
struct TextZoomInfo textZoomInfo = { aTextZoom };
|
|
|
|
return CallChildren(SetChildTextZoom, &textZoomInfo);
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP DocumentViewerImpl::GetTextZoom(float* aTextZoom)
|
|
|
|
{
|
|
|
|
NS_ENSURE_ARG_POINTER(aTextZoom);
|
|
|
|
|
|
|
|
if (mDeviceContext) {
|
|
|
|
return mDeviceContext->GetTextZoom(*aTextZoom);
|
|
|
|
}
|
|
|
|
|
|
|
|
*aTextZoom = 1.0;
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
1999-11-19 10:35:27 +03:00
|
|
|
// XXX: SEMANTIC CHANGE!
|
|
|
|
// returns a copy of the string. Caller is responsible for freeing result
|
|
|
|
// using Recycle(aDefaultCharacterSet)
|
|
|
|
NS_IMETHODIMP DocumentViewerImpl::GetDefaultCharacterSet(PRUnichar** aDefaultCharacterSet)
|
|
|
|
{
|
|
|
|
NS_ENSURE_ARG_POINTER(aDefaultCharacterSet);
|
|
|
|
NS_ENSURE_STATE(mContainer);
|
|
|
|
|
2002-01-24 05:03:19 +03:00
|
|
|
if (mDefaultCharacterSet.IsEmpty())
|
1999-11-19 10:35:27 +03:00
|
|
|
{
|
2001-11-03 03:06:51 +03:00
|
|
|
nsXPIDLString defCharset;
|
|
|
|
|
|
|
|
nsCOMPtr<nsIWebShell> webShell;
|
|
|
|
webShell = do_QueryInterface(mContainer);
|
|
|
|
if (webShell)
|
|
|
|
{
|
|
|
|
nsCOMPtr<nsIPref> prefs(do_GetService(NS_PREF_CONTRACTID));
|
|
|
|
if (prefs)
|
|
|
|
prefs->GetLocalizedUnicharPref("intl.charset.default", getter_Copies(defCharset));
|
|
|
|
}
|
|
|
|
|
2002-01-24 05:03:19 +03:00
|
|
|
if (!defCharset.IsEmpty())
|
2001-11-03 03:06:51 +03:00
|
|
|
mDefaultCharacterSet.Assign(defCharset.get());
|
1999-11-19 10:35:27 +03:00
|
|
|
else
|
2001-11-03 03:06:51 +03:00
|
|
|
mDefaultCharacterSet.Assign(NS_LITERAL_STRING("ISO-8859-1"));
|
1999-11-19 10:35:27 +03:00
|
|
|
}
|
2001-09-29 12:28:41 +04:00
|
|
|
*aDefaultCharacterSet = ToNewUnicode(mDefaultCharacterSet);
|
1999-11-19 10:35:27 +03:00
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2000-04-03 01:52:17 +04:00
|
|
|
static void
|
|
|
|
SetChildDefaultCharacterSet(nsIMarkupDocumentViewer* aChild, void* aClosure)
|
|
|
|
{
|
|
|
|
aChild->SetDefaultCharacterSet((PRUnichar*) aClosure);
|
|
|
|
}
|
|
|
|
|
1999-11-19 10:35:27 +03:00
|
|
|
NS_IMETHODIMP DocumentViewerImpl::SetDefaultCharacterSet(const PRUnichar* aDefaultCharacterSet)
|
|
|
|
{
|
|
|
|
mDefaultCharacterSet = aDefaultCharacterSet; // this does a copy of aDefaultCharacterSet
|
|
|
|
// now set the default char set on all children of mContainer
|
2000-04-03 01:52:17 +04:00
|
|
|
return CallChildren(SetChildDefaultCharacterSet,
|
|
|
|
(void*) aDefaultCharacterSet);
|
1999-11-19 10:35:27 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
// XXX: SEMANTIC CHANGE!
|
|
|
|
// returns a copy of the string. Caller is responsible for freeing result
|
|
|
|
// using Recycle(aForceCharacterSet)
|
|
|
|
NS_IMETHODIMP DocumentViewerImpl::GetForceCharacterSet(PRUnichar** aForceCharacterSet)
|
|
|
|
{
|
|
|
|
NS_ENSURE_ARG_POINTER(aForceCharacterSet);
|
|
|
|
|
|
|
|
nsAutoString emptyStr;
|
|
|
|
if (mForceCharacterSet.Equals(emptyStr)) {
|
|
|
|
*aForceCharacterSet = nsnull;
|
|
|
|
}
|
|
|
|
else {
|
2001-09-29 12:28:41 +04:00
|
|
|
*aForceCharacterSet = ToNewUnicode(mForceCharacterSet);
|
1999-11-19 10:35:27 +03:00
|
|
|
}
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2000-04-03 01:52:17 +04:00
|
|
|
static void
|
|
|
|
SetChildForceCharacterSet(nsIMarkupDocumentViewer* aChild, void* aClosure)
|
|
|
|
{
|
|
|
|
aChild->SetForceCharacterSet((PRUnichar*) aClosure);
|
|
|
|
}
|
|
|
|
|
1999-11-19 10:35:27 +03:00
|
|
|
NS_IMETHODIMP DocumentViewerImpl::SetForceCharacterSet(const PRUnichar* aForceCharacterSet)
|
|
|
|
{
|
|
|
|
mForceCharacterSet = aForceCharacterSet;
|
|
|
|
// now set the force char set on all children of mContainer
|
2000-04-03 01:52:17 +04:00
|
|
|
return CallChildren(SetChildForceCharacterSet, (void*) aForceCharacterSet);
|
1999-11-19 10:35:27 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
// XXX: SEMANTIC CHANGE!
|
|
|
|
// returns a copy of the string. Caller is responsible for freeing result
|
|
|
|
// using Recycle(aHintCharacterSet)
|
|
|
|
NS_IMETHODIMP DocumentViewerImpl::GetHintCharacterSet(PRUnichar * *aHintCharacterSet)
|
|
|
|
{
|
|
|
|
NS_ENSURE_ARG_POINTER(aHintCharacterSet);
|
|
|
|
|
|
|
|
if(kCharsetUninitialized == mHintCharsetSource) {
|
|
|
|
*aHintCharacterSet = nsnull;
|
|
|
|
} else {
|
2001-09-29 12:28:41 +04:00
|
|
|
*aHintCharacterSet = ToNewUnicode(mHintCharset);
|
1999-11-19 10:35:27 +03:00
|
|
|
// this can't possibly be right. we can't set a value just because somebody got a related value!
|
|
|
|
//mHintCharsetSource = kCharsetUninitialized;
|
|
|
|
}
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP DocumentViewerImpl::GetHintCharacterSetSource(PRInt32 *aHintCharacterSetSource)
|
|
|
|
{
|
|
|
|
NS_ENSURE_ARG_POINTER(aHintCharacterSetSource);
|
|
|
|
|
|
|
|
*aHintCharacterSetSource = mHintCharsetSource;
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2000-04-03 01:52:17 +04:00
|
|
|
static void
|
|
|
|
SetChildHintCharacterSetSource(nsIMarkupDocumentViewer* aChild, void* aClosure)
|
|
|
|
{
|
2001-08-14 11:59:59 +04:00
|
|
|
aChild->SetHintCharacterSetSource(NS_PTR_TO_INT32(aClosure));
|
2000-04-03 01:52:17 +04:00
|
|
|
}
|
1999-11-19 10:35:27 +03:00
|
|
|
|
|
|
|
NS_IMETHODIMP DocumentViewerImpl::SetHintCharacterSetSource(PRInt32 aHintCharacterSetSource)
|
|
|
|
{
|
2001-12-26 06:17:59 +03:00
|
|
|
mHintCharsetSource = aHintCharacterSetSource;
|
2000-04-03 01:52:17 +04:00
|
|
|
// now set the hint char set source on all children of mContainer
|
|
|
|
return CallChildren(SetChildHintCharacterSetSource,
|
|
|
|
(void*) aHintCharacterSetSource);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
SetChildHintCharacterSet(nsIMarkupDocumentViewer* aChild, void* aClosure)
|
|
|
|
{
|
|
|
|
aChild->SetHintCharacterSet((PRUnichar*) aClosure);
|
1999-11-19 10:35:27 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP DocumentViewerImpl::SetHintCharacterSet(const PRUnichar* aHintCharacterSet)
|
|
|
|
{
|
|
|
|
mHintCharset = aHintCharacterSet;
|
2000-04-03 01:52:17 +04:00
|
|
|
// now set the hint char set on all children of mContainer
|
|
|
|
return CallChildren(SetChildHintCharacterSet, (void*) aHintCharacterSet);
|
1999-11-19 10:35:27 +03:00
|
|
|
}
|
|
|
|
|
2001-04-13 03:35:24 +04:00
|
|
|
#ifdef IBMBIDI
|
|
|
|
static void
|
|
|
|
SetChildBidiOptions(nsIMarkupDocumentViewer* aChild, void* aClosure)
|
|
|
|
{
|
2001-08-14 11:59:59 +04:00
|
|
|
aChild->SetBidiOptions(NS_PTR_TO_INT32(aClosure));
|
2001-04-13 03:35:24 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
#endif // IBMBIDI
|
|
|
|
|
|
|
|
NS_IMETHODIMP DocumentViewerImpl::SetBidiTextDirection(PRUint8 aTextDirection)
|
|
|
|
{
|
|
|
|
#ifdef IBMBIDI
|
|
|
|
PRUint32 bidiOptions;
|
|
|
|
|
|
|
|
GetBidiOptions(&bidiOptions);
|
|
|
|
SET_BIDI_OPTION_DIRECTION(bidiOptions, aTextDirection);
|
|
|
|
SetBidiOptions(bidiOptions);
|
|
|
|
#endif
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP DocumentViewerImpl::GetBidiTextDirection(PRUint8* aTextDirection)
|
|
|
|
{
|
|
|
|
#ifdef IBMBIDI
|
|
|
|
PRUint32 bidiOptions;
|
|
|
|
|
|
|
|
if (aTextDirection) {
|
|
|
|
GetBidiOptions(&bidiOptions);
|
|
|
|
*aTextDirection = GET_BIDI_OPTION_DIRECTION(bidiOptions);
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP DocumentViewerImpl::SetBidiTextType(PRUint8 aTextType)
|
|
|
|
{
|
|
|
|
#ifdef IBMBIDI
|
|
|
|
PRUint32 bidiOptions;
|
|
|
|
|
|
|
|
GetBidiOptions(&bidiOptions);
|
|
|
|
SET_BIDI_OPTION_TEXTTYPE(bidiOptions, aTextType);
|
|
|
|
SetBidiOptions(bidiOptions);
|
|
|
|
#endif
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP DocumentViewerImpl::GetBidiTextType(PRUint8* aTextType)
|
|
|
|
{
|
|
|
|
#ifdef IBMBIDI
|
|
|
|
PRUint32 bidiOptions;
|
|
|
|
|
|
|
|
if (aTextType) {
|
|
|
|
GetBidiOptions(&bidiOptions);
|
|
|
|
*aTextType = GET_BIDI_OPTION_TEXTTYPE(bidiOptions);
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP DocumentViewerImpl::SetBidiControlsTextMode(PRUint8 aControlsTextMode)
|
|
|
|
{
|
|
|
|
#ifdef IBMBIDI
|
|
|
|
PRUint32 bidiOptions;
|
|
|
|
|
|
|
|
GetBidiOptions(&bidiOptions);
|
|
|
|
SET_BIDI_OPTION_CONTROLSTEXTMODE(bidiOptions, aControlsTextMode);
|
|
|
|
SetBidiOptions(bidiOptions);
|
|
|
|
#endif
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP DocumentViewerImpl::GetBidiControlsTextMode(PRUint8* aControlsTextMode)
|
|
|
|
{
|
|
|
|
#ifdef IBMBIDI
|
|
|
|
PRUint32 bidiOptions;
|
|
|
|
|
|
|
|
if (aControlsTextMode) {
|
|
|
|
GetBidiOptions(&bidiOptions);
|
|
|
|
*aControlsTextMode = GET_BIDI_OPTION_CONTROLSTEXTMODE(bidiOptions);
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP DocumentViewerImpl::SetBidiClipboardTextMode(PRUint8 aClipboardTextMode)
|
|
|
|
{
|
|
|
|
#ifdef IBMBIDI
|
|
|
|
PRUint32 bidiOptions;
|
|
|
|
|
|
|
|
GetBidiOptions(&bidiOptions);
|
|
|
|
SET_BIDI_OPTION_CLIPBOARDTEXTMODE(bidiOptions, aClipboardTextMode);
|
|
|
|
SetBidiOptions(bidiOptions);
|
|
|
|
#endif
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP DocumentViewerImpl::GetBidiClipboardTextMode(PRUint8* aClipboardTextMode)
|
|
|
|
{
|
|
|
|
#ifdef IBMBIDI
|
|
|
|
PRUint32 bidiOptions;
|
|
|
|
|
|
|
|
if (aClipboardTextMode) {
|
|
|
|
GetBidiOptions(&bidiOptions);
|
|
|
|
*aClipboardTextMode = GET_BIDI_OPTION_CLIPBOARDTEXTMODE(bidiOptions);
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP DocumentViewerImpl::SetBidiNumeral(PRUint8 aNumeral)
|
|
|
|
{
|
|
|
|
#ifdef IBMBIDI
|
|
|
|
PRUint32 bidiOptions;
|
|
|
|
|
|
|
|
GetBidiOptions(&bidiOptions);
|
|
|
|
SET_BIDI_OPTION_NUMERAL(bidiOptions, aNumeral);
|
|
|
|
SetBidiOptions(bidiOptions);
|
|
|
|
#endif
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP DocumentViewerImpl::GetBidiNumeral(PRUint8* aNumeral)
|
|
|
|
{
|
|
|
|
#ifdef IBMBIDI
|
|
|
|
PRUint32 bidiOptions;
|
|
|
|
|
|
|
|
if (aNumeral) {
|
|
|
|
GetBidiOptions(&bidiOptions);
|
|
|
|
*aNumeral = GET_BIDI_OPTION_NUMERAL(bidiOptions);
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP DocumentViewerImpl::SetBidiSupport(PRUint8 aSupport)
|
|
|
|
{
|
|
|
|
#ifdef IBMBIDI
|
|
|
|
PRUint32 bidiOptions;
|
|
|
|
|
|
|
|
GetBidiOptions(&bidiOptions);
|
|
|
|
SET_BIDI_OPTION_SUPPORT(bidiOptions, aSupport);
|
|
|
|
SetBidiOptions(bidiOptions);
|
|
|
|
#endif
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP DocumentViewerImpl::GetBidiSupport(PRUint8* aSupport)
|
|
|
|
{
|
|
|
|
#ifdef IBMBIDI
|
|
|
|
PRUint32 bidiOptions;
|
|
|
|
|
|
|
|
if (aSupport) {
|
|
|
|
GetBidiOptions(&bidiOptions);
|
|
|
|
*aSupport = GET_BIDI_OPTION_SUPPORT(bidiOptions);
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP DocumentViewerImpl::SetBidiCharacterSet(PRUint8 aCharacterSet)
|
|
|
|
{
|
|
|
|
#ifdef IBMBIDI
|
|
|
|
PRUint32 bidiOptions;
|
|
|
|
|
|
|
|
GetBidiOptions(&bidiOptions);
|
|
|
|
SET_BIDI_OPTION_CHARACTERSET(bidiOptions, aCharacterSet);
|
|
|
|
SetBidiOptions(bidiOptions);
|
|
|
|
#endif
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP DocumentViewerImpl::GetBidiCharacterSet(PRUint8* aCharacterSet)
|
|
|
|
{
|
|
|
|
#ifdef IBMBIDI
|
|
|
|
PRUint32 bidiOptions;
|
|
|
|
|
|
|
|
if (aCharacterSet) {
|
|
|
|
GetBidiOptions(&bidiOptions);
|
|
|
|
*aCharacterSet = GET_BIDI_OPTION_CHARACTERSET(bidiOptions);
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP DocumentViewerImpl::SetBidiOptions(PRUint32 aBidiOptions)
|
|
|
|
{
|
|
|
|
#ifdef IBMBIDI
|
|
|
|
if (mPresContext) {
|
2001-05-15 16:13:57 +04:00
|
|
|
#if 1
|
|
|
|
// forcing reflow will cause bug 80352. Temp turn off force reflow and
|
|
|
|
// wait for simon@softel.co.il to find the real solution
|
|
|
|
mPresContext->SetBidi(aBidiOptions, PR_FALSE);
|
|
|
|
#else
|
2001-04-13 03:35:24 +04:00
|
|
|
mPresContext->SetBidi(aBidiOptions, PR_TRUE); // force reflow
|
2001-05-15 16:13:57 +04:00
|
|
|
#endif
|
2001-04-13 03:35:24 +04:00
|
|
|
}
|
|
|
|
// now set bidi on all children of mContainer
|
|
|
|
CallChildren(SetChildBidiOptions, (void*) aBidiOptions);
|
|
|
|
#endif // IBMBIDI
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP DocumentViewerImpl::GetBidiOptions(PRUint32* aBidiOptions)
|
|
|
|
{
|
|
|
|
#ifdef IBMBIDI
|
|
|
|
if (aBidiOptions) {
|
|
|
|
if (mPresContext) {
|
|
|
|
mPresContext->GetBidi(aBidiOptions);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
*aBidiOptions = IBMBIDI_DEFAULT_BIDI_OPTIONS;
|
|
|
|
}
|
|
|
|
#endif // IBMBIDI
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
1999-11-19 10:35:27 +03:00
|
|
|
NS_IMETHODIMP DocumentViewerImpl::SizeToContent()
|
|
|
|
{
|
2001-03-10 06:19:36 +03:00
|
|
|
NS_ENSURE_TRUE(mDocument, NS_ERROR_NOT_AVAILABLE);
|
|
|
|
|
2000-02-08 18:49:14 +03:00
|
|
|
nsCOMPtr<nsIDocShellTreeItem> docShellAsItem(do_QueryInterface(mContainer));
|
|
|
|
NS_ENSURE_TRUE(docShellAsItem, NS_ERROR_FAILURE);
|
1999-11-19 10:35:27 +03:00
|
|
|
|
2000-02-08 18:49:14 +03:00
|
|
|
nsCOMPtr<nsIDocShellTreeItem> docShellParent;
|
|
|
|
docShellAsItem->GetSameTypeParent(getter_AddRefs(docShellParent));
|
1999-11-19 10:35:27 +03:00
|
|
|
|
2000-02-08 18:49:14 +03:00
|
|
|
// It's only valid to access this from a top frame. Doesn't work from
|
|
|
|
// sub-frames.
|
2000-02-11 11:35:20 +03:00
|
|
|
NS_ENSURE_TRUE(!docShellParent, NS_ERROR_FAILURE);
|
1999-11-19 10:35:27 +03:00
|
|
|
|
2000-02-08 18:49:14 +03:00
|
|
|
nsCOMPtr<nsIPresShell> presShell;
|
|
|
|
GetPresShell(*getter_AddRefs(presShell));
|
|
|
|
NS_ENSURE_TRUE(presShell, NS_ERROR_FAILURE);
|
|
|
|
|
|
|
|
NS_ENSURE_SUCCESS(presShell->ResizeReflow(NS_UNCONSTRAINEDSIZE,
|
|
|
|
NS_UNCONSTRAINEDSIZE), NS_ERROR_FAILURE);
|
|
|
|
|
|
|
|
nsCOMPtr<nsIPresContext> presContext;
|
|
|
|
GetPresContext(*getter_AddRefs(presContext));
|
|
|
|
NS_ENSURE_TRUE(presContext, NS_ERROR_FAILURE);
|
|
|
|
|
|
|
|
nsRect shellArea;
|
|
|
|
PRInt32 width, height;
|
|
|
|
float pixelScale;
|
|
|
|
|
|
|
|
// so how big is it?
|
|
|
|
presContext->GetVisibleArea(shellArea);
|
|
|
|
presContext->GetTwipsToPixels(&pixelScale);
|
|
|
|
width = PRInt32((float)shellArea.width*pixelScale);
|
|
|
|
height = PRInt32((float)shellArea.height*pixelScale);
|
1999-11-19 10:35:27 +03:00
|
|
|
|
2000-02-08 18:49:14 +03:00
|
|
|
nsCOMPtr<nsIDocShellTreeOwner> treeOwner;
|
|
|
|
docShellAsItem->GetTreeOwner(getter_AddRefs(treeOwner));
|
|
|
|
NS_ENSURE_TRUE(treeOwner, NS_ERROR_FAILURE);
|
|
|
|
|
2001-05-11 04:47:38 +04:00
|
|
|
/* presContext's size was calculated in twips and has already been
|
|
|
|
rounded to the equivalent pixels (so the width/height calculation
|
|
|
|
we just performed was probably exact, though it was based on
|
|
|
|
values already rounded during ResizeReflow). In a surprising
|
|
|
|
number of instances, this rounding makes a window which for want
|
|
|
|
of one extra pixel's width ends up wrapping the longest line of
|
|
|
|
text during actual window layout. This makes the window too short,
|
|
|
|
generally clipping the OK/Cancel buttons. Here we add one pixel
|
|
|
|
to the calculated width, to circumvent this problem. */
|
|
|
|
NS_ENSURE_SUCCESS(treeOwner->SizeShellTo(docShellAsItem, width+1, height),
|
2000-02-08 18:49:14 +03:00
|
|
|
NS_ERROR_FAILURE);
|
|
|
|
|
|
|
|
return NS_OK;
|
1999-11-19 10:35:27 +03:00
|
|
|
}
|
2000-02-16 04:39:30 +03:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
#ifdef XP_MAC
|
|
|
|
#pragma mark -
|
|
|
|
#endif
|
|
|
|
|
2001-08-01 07:15:50 +04:00
|
|
|
NS_IMPL_ISUPPORTS1(nsDocViewerSelectionListener, nsISelectionListener);
|
2000-02-16 04:39:30 +03:00
|
|
|
|
2001-04-18 10:06:31 +04:00
|
|
|
nsresult nsDocViewerSelectionListener::Init(DocumentViewerImpl *aDocViewer)
|
2000-02-16 04:39:30 +03:00
|
|
|
{
|
|
|
|
mDocViewer = aDocViewer;
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2001-04-18 10:06:31 +04:00
|
|
|
/*
|
|
|
|
* GetPopupNode, GetPopupLinkNode and GetPopupImageNode are helpers
|
|
|
|
* for the cmd_copyLink / cmd_copyImageLocation / cmd_copyImageContents family
|
|
|
|
* of commands. The focus controller stores the popup node, these retrieve
|
|
|
|
* them and munge appropriately. Note that we have to store the popup node
|
|
|
|
* rather than retrieving it from EventStateManager::GetFocusedContent because
|
|
|
|
* not all content (images included) can receive focus.
|
|
|
|
*/
|
|
|
|
|
|
|
|
nsresult
|
|
|
|
DocumentViewerImpl::GetPopupNode(nsIDOMNode** aNode)
|
|
|
|
{
|
|
|
|
NS_ENSURE_ARG_POINTER(aNode);
|
|
|
|
|
|
|
|
nsresult rv;
|
|
|
|
|
|
|
|
// get the document
|
|
|
|
nsCOMPtr<nsIDocument> document;
|
|
|
|
rv = GetDocument(*getter_AddRefs(document));
|
|
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
NS_ENSURE_TRUE(document, NS_ERROR_FAILURE);
|
|
|
|
|
|
|
|
// get the script global object
|
|
|
|
nsCOMPtr<nsIScriptGlobalObject> global;
|
|
|
|
rv = document->GetScriptGlobalObject(getter_AddRefs(global));
|
|
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
NS_ENSURE_TRUE(global, NS_ERROR_FAILURE);
|
|
|
|
|
|
|
|
// get the internal dom window
|
|
|
|
nsCOMPtr<nsIDOMWindowInternal> internalWin(do_QueryInterface(global, &rv));
|
|
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
NS_ENSURE_TRUE(internalWin, NS_ERROR_FAILURE);
|
|
|
|
|
|
|
|
// get the private dom window
|
|
|
|
nsCOMPtr<nsPIDOMWindow> privateWin(do_QueryInterface(internalWin, &rv));
|
|
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
NS_ENSURE_TRUE(privateWin, NS_ERROR_FAILURE);
|
|
|
|
|
|
|
|
// get the focus controller
|
|
|
|
nsCOMPtr<nsIFocusController> focusController;
|
|
|
|
rv = privateWin->GetRootFocusController(getter_AddRefs(focusController));
|
|
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
NS_ENSURE_TRUE(focusController, NS_ERROR_FAILURE);
|
|
|
|
|
|
|
|
// get the popup node
|
|
|
|
rv = focusController->GetPopupNode(aNode); // addref happens here
|
|
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
|
|
|
|
return rv;
|
|
|
|
}
|
|
|
|
|
2001-04-20 01:47:17 +04:00
|
|
|
// GetPopupLinkNode: return popup link node or fail
|
2001-04-18 10:06:31 +04:00
|
|
|
nsresult
|
|
|
|
DocumentViewerImpl::GetPopupLinkNode(nsIDOMNode** aNode)
|
|
|
|
{
|
|
|
|
NS_ENSURE_ARG_POINTER(aNode);
|
|
|
|
|
|
|
|
// you get null unless i say so
|
|
|
|
*aNode = nsnull;
|
|
|
|
|
|
|
|
// find popup node
|
|
|
|
nsCOMPtr<nsIDOMNode> node;
|
|
|
|
nsresult rv = GetPopupNode(getter_AddRefs(node));
|
|
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
|
2001-09-13 03:31:37 +04:00
|
|
|
// find out if we have a link in our ancestry
|
2001-04-18 10:06:31 +04:00
|
|
|
while (node) {
|
|
|
|
|
|
|
|
// are we an anchor?
|
2001-09-13 03:31:37 +04:00
|
|
|
nsCOMPtr<nsIDOMHTMLAnchorElement> anchor(do_QueryInterface(node));
|
|
|
|
nsCOMPtr<nsIDOMHTMLAreaElement> area;
|
|
|
|
nsCOMPtr<nsIDOMHTMLLinkElement> link;
|
|
|
|
nsAutoString xlinkType;
|
|
|
|
if (!anchor) {
|
|
|
|
// area?
|
|
|
|
area = do_QueryInterface(node);
|
|
|
|
if (!area) {
|
|
|
|
// link?
|
|
|
|
link = do_QueryInterface(node);
|
|
|
|
if (!link) {
|
|
|
|
// XLink?
|
|
|
|
nsCOMPtr<nsIDOMElement> element(do_QueryInterface(node));
|
|
|
|
if (element) {
|
|
|
|
element->GetAttributeNS(NS_LITERAL_STRING("http://www.w3.org/1999/xlink"),NS_LITERAL_STRING("type"),xlinkType);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2001-12-16 14:58:03 +03:00
|
|
|
if (anchor || area || link || xlinkType.Equals(NS_LITERAL_STRING("simple"))) {
|
2001-04-18 10:06:31 +04:00
|
|
|
*aNode = node;
|
|
|
|
NS_IF_ADDREF(*aNode); // addref
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
// if not, get our parent and keep trying...
|
|
|
|
nsCOMPtr<nsIDOMNode> parentNode;
|
|
|
|
node->GetParentNode(getter_AddRefs(parentNode));
|
|
|
|
node = parentNode;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// if we have no node, fail
|
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
}
|
|
|
|
|
2001-04-20 01:47:17 +04:00
|
|
|
// GetPopupLinkNode: return popup image node or fail
|
2001-04-18 10:06:31 +04:00
|
|
|
nsresult
|
|
|
|
DocumentViewerImpl::GetPopupImageNode(nsIDOMNode** aNode)
|
|
|
|
{
|
|
|
|
NS_ENSURE_ARG_POINTER(aNode);
|
|
|
|
|
|
|
|
// you get null unless i say so
|
|
|
|
*aNode = nsnull;
|
|
|
|
|
|
|
|
// find popup node
|
|
|
|
nsCOMPtr<nsIDOMNode> node;
|
|
|
|
nsresult rv = GetPopupNode(getter_AddRefs(node));
|
|
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
|
2001-09-13 03:31:37 +04:00
|
|
|
// XXX find out if we're an image. this really ought to look for objects
|
|
|
|
// XXX with type "image/...", but this is good enough for now.
|
2001-04-18 10:06:31 +04:00
|
|
|
nsCOMPtr<nsIDOMHTMLImageElement> img(do_QueryInterface(node, &rv));
|
2001-04-20 01:47:17 +04:00
|
|
|
if (NS_FAILED(rv)) return rv;
|
2001-04-18 10:06:31 +04:00
|
|
|
NS_ENSURE_TRUE(img, NS_ERROR_FAILURE);
|
|
|
|
|
|
|
|
// if we made it here, we're an image.
|
|
|
|
*aNode = node;
|
|
|
|
NS_IF_ADDREF(*aNode); // addref
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* XXX dr
|
|
|
|
* ------
|
|
|
|
* These two functions -- GetInLink and GetInImage -- are kind of annoying
|
|
|
|
* in that they only get called from the controller (in
|
|
|
|
* nsDOMWindowController::IsCommandEnabled). The actual construction of the
|
|
|
|
* context menus in communicator (nsContextMenu.js) has its own, redundant
|
|
|
|
* tests. No big deal, but good to keep in mind if we ever clean context
|
|
|
|
* menus.
|
|
|
|
*/
|
|
|
|
|
|
|
|
NS_IMETHODIMP DocumentViewerImpl::GetInLink(PRBool* aInLink)
|
|
|
|
{
|
|
|
|
#ifdef DEBUG_dr
|
|
|
|
printf("dr :: DocumentViewerImpl::GetInLink\n");
|
|
|
|
#endif
|
|
|
|
|
|
|
|
NS_ENSURE_ARG_POINTER(aInLink);
|
|
|
|
|
|
|
|
// we're not in a link unless i say so
|
|
|
|
*aInLink = PR_FALSE;
|
|
|
|
|
|
|
|
// get the popup link
|
|
|
|
nsCOMPtr<nsIDOMNode> node;
|
|
|
|
nsresult rv = GetPopupLinkNode(getter_AddRefs(node));
|
2001-04-20 01:47:17 +04:00
|
|
|
if (NS_FAILED(rv)) return rv;
|
2001-04-18 10:06:31 +04:00
|
|
|
NS_ENSURE_TRUE(node, NS_ERROR_FAILURE);
|
|
|
|
|
|
|
|
// if we made it here, we're in a link
|
|
|
|
*aInLink = PR_TRUE;
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP DocumentViewerImpl::GetInImage(PRBool* aInImage)
|
|
|
|
{
|
|
|
|
#ifdef DEBUG_dr
|
|
|
|
printf("dr :: DocumentViewerImpl::GetInImage\n");
|
|
|
|
#endif
|
|
|
|
|
|
|
|
NS_ENSURE_ARG_POINTER(aInImage);
|
|
|
|
|
|
|
|
// we're not in an image unless i say so
|
|
|
|
*aInImage = PR_FALSE;
|
|
|
|
|
|
|
|
// get the popup image
|
|
|
|
nsCOMPtr<nsIDOMNode> node;
|
|
|
|
nsresult rv = GetPopupImageNode(getter_AddRefs(node));
|
2001-04-20 01:47:17 +04:00
|
|
|
if (NS_FAILED(rv)) return rv;
|
2001-04-18 10:06:31 +04:00
|
|
|
NS_ENSURE_TRUE(node, NS_ERROR_FAILURE);
|
|
|
|
|
|
|
|
// if we made it here, we're in an image
|
|
|
|
*aInImage = PR_TRUE;
|
|
|
|
return NS_OK;
|
|
|
|
}
|
2000-02-16 04:39:30 +03:00
|
|
|
|
2001-04-18 10:06:31 +04:00
|
|
|
NS_IMETHODIMP nsDocViewerSelectionListener::NotifySelectionChanged(nsIDOMDocument *, nsISelection *, short)
|
2000-01-19 00:06:10 +03:00
|
|
|
{
|
2000-02-16 04:39:30 +03:00
|
|
|
NS_ASSERTION(mDocViewer, "Should have doc viewer!");
|
|
|
|
|
|
|
|
// get the selection state
|
2000-09-14 15:45:01 +04:00
|
|
|
nsCOMPtr<nsISelection> selection;
|
2000-02-16 04:39:30 +03:00
|
|
|
nsresult rv = mDocViewer->GetDocumentSelection(getter_AddRefs(selection));
|
|
|
|
if (NS_FAILED(rv)) return rv;
|
|
|
|
|
|
|
|
PRBool selectionCollapsed;
|
|
|
|
selection->GetIsCollapsed(&selectionCollapsed);
|
|
|
|
// we only call UpdateCommands when the selection changes from collapsed
|
|
|
|
// to non-collapsed or vice versa. We might need another update string
|
|
|
|
// for simple selection changes, but that would be expenseive.
|
|
|
|
if (!mGotSelectionState || mSelectionWasCollapsed != selectionCollapsed)
|
|
|
|
{
|
|
|
|
nsCOMPtr<nsIDocument> theDoc;
|
|
|
|
mDocViewer->GetDocument(*getter_AddRefs(theDoc));
|
|
|
|
if (!theDoc) return NS_ERROR_FAILURE;
|
|
|
|
|
|
|
|
nsCOMPtr<nsIScriptGlobalObject> scriptGlobalObject;
|
|
|
|
theDoc->GetScriptGlobalObject(getter_AddRefs(scriptGlobalObject));
|
|
|
|
|
2000-09-01 05:54:35 +04:00
|
|
|
nsCOMPtr<nsIDOMWindowInternal> domWindow = do_QueryInterface(scriptGlobalObject);
|
2000-02-16 04:39:30 +03:00
|
|
|
if (!domWindow) return NS_ERROR_FAILURE;
|
|
|
|
|
2001-03-27 15:17:17 +04:00
|
|
|
domWindow->UpdateCommands(NS_LITERAL_STRING("select"));
|
2000-02-16 04:39:30 +03:00
|
|
|
mGotSelectionState = PR_TRUE;
|
|
|
|
mSelectionWasCollapsed = selectionCollapsed;
|
|
|
|
}
|
|
|
|
|
2000-01-19 00:06:10 +03:00
|
|
|
return NS_OK;
|
|
|
|
}
|
2000-02-10 07:35:51 +03:00
|
|
|
|
2000-04-22 01:40:28 +04:00
|
|
|
//nsDocViewerFocusListener
|
2001-08-01 07:15:50 +04:00
|
|
|
NS_IMPL_ISUPPORTS1(nsDocViewerFocusListener, nsIDOMFocusListener);
|
2000-04-22 01:40:28 +04:00
|
|
|
|
|
|
|
nsDocViewerFocusListener::nsDocViewerFocusListener()
|
|
|
|
:mDocViewer(nsnull)
|
|
|
|
{
|
|
|
|
NS_INIT_REFCNT();
|
|
|
|
}
|
|
|
|
|
|
|
|
nsDocViewerFocusListener::~nsDocViewerFocusListener(){}
|
|
|
|
|
|
|
|
nsresult
|
|
|
|
nsDocViewerFocusListener::HandleEvent(nsIDOMEvent* aEvent)
|
|
|
|
{
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
Landing the XPCDOM_20010329_BRANCH branch, changes mostly done by jband@netscape.com and jst@netscape.com, also some changes done by shaver@mozilla.org, peterv@netscape.com and markh@activestate.com. r= and sr= by vidur@netscape.com, jband@netscape.com, jst@netscpae.com, danm@netscape.com, hyatt@netscape.com, shaver@mozilla.org, dbradley@netscape.com, rpotts@netscape.com.
2001-05-08 20:46:42 +04:00
|
|
|
NS_IMETHODIMP
|
2000-04-22 01:40:28 +04:00
|
|
|
nsDocViewerFocusListener::Focus(nsIDOMEvent* aEvent)
|
|
|
|
{
|
2000-04-28 10:21:31 +04:00
|
|
|
nsCOMPtr<nsIPresShell> shell;
|
2000-04-22 01:40:28 +04:00
|
|
|
if(!mDocViewer)
|
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
|
2000-04-28 10:21:31 +04:00
|
|
|
nsresult result = mDocViewer->GetPresShell(*getter_AddRefs(shell));//deref once cause it take a ptr ref
|
|
|
|
if(NS_FAILED(result) || !shell)
|
2000-04-22 01:40:28 +04:00
|
|
|
return result?result:NS_ERROR_FAILURE;
|
2000-04-28 10:21:31 +04:00
|
|
|
nsCOMPtr<nsISelectionController> selCon;
|
|
|
|
selCon = do_QueryInterface(shell);
|
|
|
|
PRInt16 selectionStatus;
|
|
|
|
selCon->GetDisplaySelection( &selectionStatus);
|
2000-04-22 01:40:28 +04:00
|
|
|
|
2000-04-28 10:21:31 +04:00
|
|
|
//if selection was nsISelectionController::SELECTION_OFF, do nothing
|
2000-05-11 08:25:43 +04:00
|
|
|
//otherwise re-enable it.
|
2001-04-28 01:11:03 +04:00
|
|
|
if(selectionStatus == nsISelectionController::SELECTION_DISABLED ||
|
|
|
|
selectionStatus == nsISelectionController::SELECTION_HIDDEN)
|
2000-04-22 01:40:28 +04:00
|
|
|
{
|
2000-04-28 10:21:31 +04:00
|
|
|
selCon->SetDisplaySelection(nsISelectionController::SELECTION_ON);
|
|
|
|
selCon->RepaintSelection(nsISelectionController::SELECTION_NORMAL);
|
2000-04-22 01:40:28 +04:00
|
|
|
}
|
|
|
|
return result;
|
|
|
|
}
|
Landing the XPCDOM_20010329_BRANCH branch, changes mostly done by jband@netscape.com and jst@netscape.com, also some changes done by shaver@mozilla.org, peterv@netscape.com and markh@activestate.com. r= and sr= by vidur@netscape.com, jband@netscape.com, jst@netscpae.com, danm@netscape.com, hyatt@netscape.com, shaver@mozilla.org, dbradley@netscape.com, rpotts@netscape.com.
2001-05-08 20:46:42 +04:00
|
|
|
|
|
|
|
NS_IMETHODIMP
|
2000-04-22 01:40:28 +04:00
|
|
|
nsDocViewerFocusListener::Blur(nsIDOMEvent* aEvent)
|
|
|
|
{
|
2000-04-28 10:21:31 +04:00
|
|
|
nsCOMPtr<nsIPresShell> shell;
|
2000-05-11 08:25:43 +04:00
|
|
|
if(!mDocViewer)
|
2000-04-22 01:40:28 +04:00
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
|
2000-04-28 10:21:31 +04:00
|
|
|
nsresult result = mDocViewer->GetPresShell(*getter_AddRefs(shell));//deref once cause it take a ptr ref
|
|
|
|
if(NS_FAILED(result) || !shell)
|
2000-04-22 01:40:28 +04:00
|
|
|
return result?result:NS_ERROR_FAILURE;
|
2000-04-28 10:21:31 +04:00
|
|
|
nsCOMPtr<nsISelectionController> selCon;
|
|
|
|
selCon = do_QueryInterface(shell);
|
|
|
|
PRInt16 selectionStatus;
|
|
|
|
selCon->GetDisplaySelection(&selectionStatus);
|
2000-04-22 01:40:28 +04:00
|
|
|
|
2000-04-28 10:21:31 +04:00
|
|
|
//if selection was nsISelectionController::SELECTION_OFF, do nothing
|
2000-04-22 01:40:28 +04:00
|
|
|
//otherwise re-enable it.
|
2000-04-28 10:21:31 +04:00
|
|
|
if(selectionStatus == nsISelectionController::SELECTION_ON)
|
2000-04-22 01:40:28 +04:00
|
|
|
{
|
2000-04-28 10:21:31 +04:00
|
|
|
selCon->SetDisplaySelection(nsISelectionController::SELECTION_DISABLED);
|
|
|
|
selCon->RepaintSelection(nsISelectionController::SELECTION_NORMAL);
|
2000-04-22 01:40:28 +04:00
|
|
|
}
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
nsresult
|
|
|
|
nsDocViewerFocusListener::Init(DocumentViewerImpl *aDocViewer)
|
|
|
|
{
|
|
|
|
mDocViewer = aDocViewer;
|
|
|
|
return NS_OK;
|
2000-04-22 02:17:14 +04:00
|
|
|
}
|
|
|
|
|
2001-02-01 23:49:10 +03:00
|
|
|
|
2001-02-07 02:03:17 +03:00
|
|
|
PRBool
|
|
|
|
DocumentViewerImpl::IsWindowsInOurSubTree(nsIDOMWindowInternal * aDOMWindow)
|
|
|
|
{
|
|
|
|
PRBool found = PR_FALSE;
|
|
|
|
if(aDOMWindow) {
|
|
|
|
// now check to make sure it is in "our" tree of webshells
|
|
|
|
nsCOMPtr<nsIScriptGlobalObject> scriptObj(do_QueryInterface(aDOMWindow));
|
|
|
|
if (scriptObj) {
|
|
|
|
nsCOMPtr<nsIDocShell> docShell;
|
|
|
|
scriptObj->GetDocShell(getter_AddRefs(docShell));
|
|
|
|
if (docShell) {
|
|
|
|
nsCOMPtr<nsIDocShellTreeItem> docShellAsItem(do_QueryInterface(docShell));
|
|
|
|
if (docShellAsItem) {
|
|
|
|
// get this DocViewer webshell
|
|
|
|
nsCOMPtr<nsIWebShell> thisDVWebShell(do_QueryInterface(mContainer));
|
|
|
|
while (!found) {
|
|
|
|
nsCOMPtr<nsIDocShellTreeItem> docShellParent;
|
|
|
|
docShellAsItem->GetSameTypeParent(getter_AddRefs(docShellParent));
|
|
|
|
if (docShellParent) {
|
|
|
|
nsCOMPtr<nsIWebShell> parentWebshell(do_QueryInterface(docShellParent));
|
|
|
|
if (parentWebshell) {
|
|
|
|
if (parentWebshell.get() == thisDVWebShell.get()) {
|
|
|
|
found = PR_TRUE;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
break; // at top of tree
|
|
|
|
}
|
|
|
|
docShellAsItem = docShellParent;
|
|
|
|
} // while
|
|
|
|
}
|
|
|
|
} // docshell
|
|
|
|
} // scriptobj
|
|
|
|
} // domWindow
|
|
|
|
|
|
|
|
return found;
|
|
|
|
}
|
|
|
|
|
2002-02-01 17:52:11 +03:00
|
|
|
|
|
|
|
//----------------------------------------------------------------------------------
|
|
|
|
void
|
|
|
|
DocumentViewerImpl::CleanupDocTitleArray(PRUnichar**& aArray, PRInt32& aCount)
|
|
|
|
{
|
|
|
|
for (PRInt32 i = aCount - 1; i >= 0; i--) {
|
|
|
|
nsMemory::Free(aArray[i]);
|
|
|
|
}
|
|
|
|
nsMemory::Free(aArray);
|
|
|
|
aArray = NULL;
|
|
|
|
aCount = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
//----------------------------------------------------------------------------------
|
|
|
|
// Enumerate all the documents for their titles
|
|
|
|
NS_IMETHODIMP
|
|
|
|
DocumentViewerImpl::EnumerateDocumentNames(PRUint32* aCount,
|
|
|
|
PRUnichar*** aResult)
|
|
|
|
{
|
|
|
|
NS_ENSURE_ARG(aCount);
|
|
|
|
NS_ENSURE_ARG_POINTER(aResult);
|
|
|
|
|
|
|
|
*aCount = 0;
|
|
|
|
*aResult = nsnull;
|
|
|
|
|
|
|
|
PRInt32 numDocs = mPrt->mPrintDocList->Count();
|
|
|
|
PRUnichar** array = (PRUnichar**) nsMemory::Alloc(numDocs * sizeof(PRUnichar*));
|
|
|
|
if (!array)
|
|
|
|
return NS_ERROR_OUT_OF_MEMORY;
|
|
|
|
|
|
|
|
for (PRInt32 i=0;i<numDocs;i++) {
|
|
|
|
PrintObject* po = (PrintObject*)mPrt->mPrintDocList->ElementAt(i);
|
|
|
|
NS_ASSERTION(po, "PrintObject can't be null!");
|
|
|
|
PRUnichar * docTitleStr;
|
|
|
|
PRUnichar * docURLStr;
|
2002-02-12 16:33:39 +03:00
|
|
|
GetWebShellTitleAndURL(po->mWebShell, &docTitleStr, &docURLStr);
|
2002-02-01 17:52:11 +03:00
|
|
|
|
|
|
|
// Use the URL if the doc is empty
|
|
|
|
if (!docTitleStr || !*docTitleStr) {
|
|
|
|
if (docURLStr && nsCRT::strlen(docURLStr) > 0) {
|
|
|
|
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 newPrintSettings; */
|
|
|
|
NS_IMETHODIMP
|
|
|
|
DocumentViewerImpl::GetNewPrintSettings(nsIPrintSettings * *aNewPrintSettings)
|
|
|
|
{
|
|
|
|
NS_ENSURE_ARG_POINTER(aNewPrintSettings);
|
|
|
|
|
|
|
|
nsresult rv = NS_ERROR_FAILURE;
|
|
|
|
nsCOMPtr<nsIPrintOptions> printService = do_GetService(kPrintOptionsCID, &rv);
|
|
|
|
if (NS_SUCCEEDED(rv)) {
|
|
|
|
rv = printService->CreatePrintSettings(aNewPrintSettings);
|
2002-02-20 06:18:33 +03:00
|
|
|
InitPrintSettingsFromPrinter(nsnull, *aNewPrintSettings);
|
2002-02-01 17:52:11 +03:00
|
|
|
}
|
|
|
|
return rv;
|
|
|
|
}
|
|
|
|
|
2002-02-13 16:58:41 +03:00
|
|
|
/* readonly attribute wstring defaultPrinterName; */
|
|
|
|
NS_IMETHODIMP
|
|
|
|
DocumentViewerImpl::GetDefaultPrinterName(PRUnichar * *aDefaultPrinterName)
|
|
|
|
{
|
|
|
|
NS_ENSURE_ARG_POINTER(aDefaultPrinterName);
|
|
|
|
|
|
|
|
nsresult rv;
|
|
|
|
nsCOMPtr<nsIPrinterEnumerator> prtEnum = do_GetService(kPrinterEnumeratorCID, &rv);
|
|
|
|
if (prtEnum) {
|
|
|
|
prtEnum->GetDefaultPrinterName(aDefaultPrinterName);
|
|
|
|
}
|
|
|
|
return rv;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* void initPrintSettingsFromPrinter (in wstring aPrinterName, in nsIPrintSettings aPrintSettings); */
|
|
|
|
NS_IMETHODIMP
|
|
|
|
DocumentViewerImpl::InitPrintSettingsFromPrinter(const PRUnichar *aPrinterName, nsIPrintSettings *aPrintSettings)
|
|
|
|
{
|
|
|
|
NS_ENSURE_ARG_POINTER(aPrintSettings);
|
|
|
|
|
2002-02-20 06:18:33 +03:00
|
|
|
PRUnichar* printerName = nsnull;
|
|
|
|
if (!aPrinterName) {
|
|
|
|
GetDefaultPrinterName(&printerName);
|
|
|
|
if (!printerName || !*printerName) return NS_OK;
|
|
|
|
}
|
2002-02-13 16:58:41 +03:00
|
|
|
nsresult rv;
|
|
|
|
nsCOMPtr<nsIPrinterEnumerator> prtEnum = do_GetService(kPrinterEnumeratorCID, &rv);
|
|
|
|
if (prtEnum) {
|
2002-02-20 06:18:33 +03:00
|
|
|
prtEnum->InitPrintSettingsFromPrinter(aPrinterName?aPrinterName:printerName, aPrintSettings);
|
|
|
|
}
|
|
|
|
if (printerName) {
|
|
|
|
nsMemory::Free(printerName);
|
2002-02-13 16:58:41 +03:00
|
|
|
}
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2002-02-01 17:52:11 +03:00
|
|
|
/* readonly attribute nsIPrintSettings globalPrintSettings; */
|
|
|
|
NS_IMETHODIMP
|
|
|
|
DocumentViewerImpl::GetGlobalPrintSettings(nsIPrintSettings * *aGlobalPrintSettings)
|
|
|
|
{
|
|
|
|
NS_ENSURE_ARG_POINTER(aGlobalPrintSettings);
|
|
|
|
|
|
|
|
nsresult rv = NS_ERROR_FAILURE;
|
|
|
|
nsCOMPtr<nsIPrintOptions> printService = do_GetService(kPrintOptionsCID, &rv);
|
|
|
|
if (NS_SUCCEEDED(rv)) {
|
|
|
|
rv = printService->GetGlobalPrintSettings(aGlobalPrintSettings);
|
|
|
|
}
|
|
|
|
return rv;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* readonly attribute boolean doingPrintPreview; */
|
|
|
|
NS_IMETHODIMP
|
|
|
|
DocumentViewerImpl::GetDoingPrintPreview(PRBool *aDoingPrintPreview)
|
|
|
|
{
|
|
|
|
NS_ENSURE_ARG_POINTER(aDoingPrintPreview);
|
|
|
|
*aDoingPrintPreview = mIsDoingPrintPreview;
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2002-03-07 15:57:33 +03:00
|
|
|
/* readonly attribute nsIPrintSettings currentPrintSettings; */
|
|
|
|
NS_IMETHODIMP
|
|
|
|
DocumentViewerImpl::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;
|
|
|
|
}
|
|
|
|
|
2002-03-16 16:08:45 +03:00
|
|
|
/* void cancel (); */
|
2002-02-01 17:52:11 +03:00
|
|
|
NS_IMETHODIMP
|
2002-03-16 16:08:45 +03:00
|
|
|
DocumentViewerImpl::Cancel()
|
2002-02-01 17:52:11 +03:00
|
|
|
{
|
2002-03-16 16:08:45 +03:00
|
|
|
nsresult rv;
|
|
|
|
nsCOMPtr<nsIPrintOptions> printService = do_GetService(kPrintOptionsCID, &rv);
|
|
|
|
if (NS_SUCCEEDED(rv) && printService) {
|
|
|
|
return printService->SetIsCancelled(PR_TRUE);
|
2002-02-01 17:52:11 +03:00
|
|
|
}
|
2002-03-16 16:08:45 +03:00
|
|
|
return NS_OK;
|
2002-02-01 17:52:11 +03:00
|
|
|
}
|
|
|
|
|
2002-03-16 16:08:45 +03:00
|
|
|
/* void initPrintSettingsFromPrefs (in nsIPrintSettings aPrintSettings, in boolean aUsePrinterNamePrefix, in unsigned long aFlags); */
|
2002-02-01 17:52:11 +03:00
|
|
|
NS_IMETHODIMP
|
2002-03-16 16:08:45 +03:00
|
|
|
DocumentViewerImpl::InitPrintSettingsFromPrefs(nsIPrintSettings *aPrintSettings, PRBool aUsePrinterNamePrefix, PRUint32 aFlags)
|
2002-02-01 17:52:11 +03:00
|
|
|
{
|
2002-03-16 16:08:45 +03:00
|
|
|
nsresult rv;
|
2002-02-01 17:52:11 +03:00
|
|
|
nsCOMPtr<nsIPrintOptions> printService = do_GetService(kPrintOptionsCID, &rv);
|
2002-03-16 16:08:45 +03:00
|
|
|
if (NS_SUCCEEDED(rv) && printService) {
|
|
|
|
return printService->InitPrintSettingsFromPrefs(aPrintSettings, aUsePrinterNamePrefix, aFlags);
|
2002-02-01 17:52:11 +03:00
|
|
|
}
|
2002-03-16 16:08:45 +03:00
|
|
|
return NS_OK;
|
2002-02-01 17:52:11 +03:00
|
|
|
}
|
|
|
|
|
2002-03-16 16:08:45 +03:00
|
|
|
/* void savePrintSettingsToPrefs (in nsIPrintSettings aPrintSettings, in boolean aUsePrinterNamePrefix, in unsigned long aFlags); */
|
2002-02-01 17:52:11 +03:00
|
|
|
NS_IMETHODIMP
|
2002-03-16 16:08:45 +03:00
|
|
|
DocumentViewerImpl::SavePrintSettingsToPrefs(nsIPrintSettings *aPrintSettings, PRBool aUsePrinterNamePrefix, PRUint32 aFlags)
|
2002-02-01 17:52:11 +03:00
|
|
|
{
|
|
|
|
nsresult rv;
|
|
|
|
nsCOMPtr<nsIPrintOptions> printService = do_GetService(kPrintOptionsCID, &rv);
|
|
|
|
if (NS_SUCCEEDED(rv) && printService) {
|
2002-03-16 16:08:45 +03:00
|
|
|
return printService->SavePrintSettingsToPrefs(aPrintSettings, aUsePrinterNamePrefix, aFlags);
|
2002-02-01 17:52:11 +03:00
|
|
|
}
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2001-02-01 23:49:10 +03:00
|
|
|
/** ---------------------------------------------------
|
|
|
|
* Get the Focused Frame for a documentviewer
|
|
|
|
*
|
|
|
|
*/
|
2001-02-07 02:03:17 +03:00
|
|
|
nsIDOMWindowInternal*
|
|
|
|
DocumentViewerImpl::FindFocusedDOMWindowInternal()
|
2001-02-01 23:49:10 +03:00
|
|
|
{
|
2001-02-07 02:03:17 +03:00
|
|
|
nsCOMPtr<nsIDOMWindowInternal> theDOMWin;
|
|
|
|
nsCOMPtr<nsIDocument> theDoc;
|
|
|
|
nsCOMPtr<nsIScriptGlobalObject> theSGO;
|
|
|
|
nsCOMPtr<nsIFocusController> focusController;
|
|
|
|
nsIDOMWindowInternal * domWin = nsnull;
|
2001-02-01 23:49:10 +03:00
|
|
|
|
|
|
|
this->GetDocument(*getter_AddRefs(theDoc));
|
|
|
|
if(theDoc){
|
|
|
|
theDoc->GetScriptGlobalObject(getter_AddRefs(theSGO));
|
|
|
|
if(theSGO){
|
|
|
|
nsCOMPtr<nsPIDOMWindow> theDOMWindow = do_QueryInterface(theSGO);
|
|
|
|
if(theDOMWindow){
|
|
|
|
theDOMWindow->GetRootFocusController(getter_AddRefs(focusController));
|
|
|
|
if(focusController){
|
|
|
|
focusController->GetFocusedWindow(getter_AddRefs(theDOMWin));
|
2001-02-07 02:03:17 +03:00
|
|
|
domWin = theDOMWin.get();
|
|
|
|
if(domWin != nsnull) {
|
|
|
|
if (IsWindowsInOurSubTree(domWin)){
|
|
|
|
NS_ADDREF(domWin);
|
|
|
|
} else {
|
|
|
|
domWin = nsnull;
|
|
|
|
}
|
2001-02-01 23:49:10 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2001-02-07 02:03:17 +03:00
|
|
|
return domWin;
|
2001-02-01 23:49:10 +03:00
|
|
|
}
|
|
|
|
|
2001-03-27 15:56:03 +04:00
|
|
|
/*=============== Timer Related Code ======================*/
|
|
|
|
nsresult
|
|
|
|
DocumentViewerImpl::StartPagePrintTimer(nsIPresContext * aPresContext,
|
2002-01-01 15:58:53 +03:00
|
|
|
nsIPrintSettings* aPrintSettings,
|
2001-04-12 17:04:29 +04:00
|
|
|
PrintObject* aPOect,
|
2001-03-27 15:56:03 +04:00
|
|
|
PRUint32 aDelay)
|
|
|
|
{
|
|
|
|
nsresult result;
|
|
|
|
|
|
|
|
if (!mPagePrintTimer) {
|
|
|
|
result = NS_NewUpdateTimer(&mPagePrintTimer);
|
|
|
|
|
|
|
|
if (NS_FAILED(result))
|
|
|
|
return result;
|
2001-08-06 06:27:43 +04:00
|
|
|
|
|
|
|
++mDestroyRefCount;
|
2001-03-27 15:56:03 +04:00
|
|
|
}
|
|
|
|
|
2002-01-01 15:58:53 +03:00
|
|
|
return mPagePrintTimer->Start(this, aPresContext, aPrintSettings, aPOect, aDelay);
|
2001-03-27 15:56:03 +04:00
|
|
|
}
|
|
|
|
|