mirror of
https://github.com/classilla/tenfourfox.git
synced 2024-07-07 10:29:03 +00:00
623 lines
23 KiB
JavaScript
623 lines
23 KiB
JavaScript
// -*- tab-width: 2; indent-tabs-mode: nil; js-indent-level: 2 -*-
|
|
|
|
/* This Source Code Form is subject to the terms of the Mozilla Public
|
|
* License, v. 2.0. If a copy of the MPL was not distributed with this
|
|
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
|
|
|
|
/**
|
|
* PrintUtils is a utility for front-end code to trigger common print
|
|
* operations (printing, show print preview, show page settings).
|
|
*
|
|
* Unfortunately, likely due to inconsistencies in how different operating
|
|
* systems do printing natively, our XPCOM-level printing interfaces
|
|
* are a bit confusing and the method by which we do something basic
|
|
* like printing a page is quite circuitous.
|
|
*
|
|
* To compound that, we need to support remote browsers, and that means
|
|
* kicking off the print jobs in the content process. This means we send
|
|
* messages back and forth to that process. browser-content.js contains
|
|
* the object that listens and responds to the messages that PrintUtils
|
|
* sends.
|
|
*
|
|
* This also means that <xul:browser>'s that hope to use PrintUtils must have
|
|
* their type attribute set to either "content", "content-targetable", or
|
|
* "content-primary".
|
|
*
|
|
* PrintUtils sends messages at different points in its implementation, but
|
|
* their documentation is consolidated here for ease-of-access.
|
|
*
|
|
*
|
|
* Messages sent:
|
|
*
|
|
* Printing:Print
|
|
* Kick off a print job for a nsIDOMWindow, passing the outer window ID as
|
|
* windowID.
|
|
*
|
|
* Printing:Preview:Enter
|
|
* This message is sent to put content into print preview mode. We pass
|
|
* the content window of the browser we're showing the preview of, and
|
|
* the target of the message is the browser that we'll be showing the
|
|
* preview in.
|
|
*
|
|
* Printing:Preview:Exit
|
|
* This message is sent to take content out of print preview mode.
|
|
*
|
|
*
|
|
* Messages Received
|
|
*
|
|
* Printing:Preview:Entered
|
|
* This message is sent by the content process once it has completed
|
|
* putting the content into print preview mode. We must wait for that to
|
|
* to complete before switching the chrome UI to print preview mode,
|
|
* otherwise we have layout issues.
|
|
*
|
|
* Printing:Preview:StateChange, Printing:Preview:ProgressChange
|
|
* Due to a timing issue resulting in a main-process crash, we have to
|
|
* manually open the progress dialog for print preview. The progress
|
|
* dialog is opened here in PrintUtils, and then we listen for update
|
|
* messages from the child. Bug 1088061 has been filed to investigate
|
|
* other solutions.
|
|
*
|
|
*/
|
|
|
|
var gPrintSettingsAreGlobal = false;
|
|
var gSavePrintSettings = false;
|
|
var gFocusedElement = null;
|
|
|
|
var PrintUtils = {
|
|
init() {
|
|
window.messageManager.addMessageListener("Printing:Error", this);
|
|
},
|
|
|
|
get bundle() {
|
|
let stringService = Components.classes["@mozilla.org/intl/stringbundle;1"]
|
|
.getService(Components.interfaces.nsIStringBundleService);
|
|
delete this.bundle;
|
|
return this.bundle = stringService.createBundle("chrome://global/locale/printing.properties");
|
|
},
|
|
|
|
/**
|
|
* Shows the page setup dialog, and saves any settings changed in
|
|
* that dialog if print.save_print_settings is set to true.
|
|
*
|
|
* @return true on success, false on failure
|
|
*/
|
|
showPageSetup: function () {
|
|
try {
|
|
var printSettings = this.getPrintSettings();
|
|
var PRINTPROMPTSVC = Components.classes["@mozilla.org/embedcomp/printingprompt-service;1"]
|
|
.getService(Components.interfaces.nsIPrintingPromptService);
|
|
PRINTPROMPTSVC.showPageSetup(window, printSettings, null);
|
|
if (gSavePrintSettings) {
|
|
// Page Setup data is a "native" setting on the Mac
|
|
var PSSVC = Components.classes["@mozilla.org/gfx/printsettings-service;1"]
|
|
.getService(Components.interfaces.nsIPrintSettingsService);
|
|
PSSVC.savePrintSettingsToPrefs(printSettings, true, printSettings.kInitSaveNativeData);
|
|
}
|
|
} catch (e) {
|
|
dump("showPageSetup "+e+"\n");
|
|
return false;
|
|
}
|
|
return true;
|
|
},
|
|
|
|
/**
|
|
* Starts the process of printing the contents of a window.
|
|
*
|
|
* @param aWindowID
|
|
* The outer window ID of the nsIDOMWindow to print.
|
|
* @param aBrowser
|
|
* The <xul:browser> that the nsIDOMWindow for aWindowID belongs to.
|
|
*/
|
|
printWindow: function (aWindowID, aBrowser)
|
|
{
|
|
let mm = aBrowser.messageManager;
|
|
mm.sendAsyncMessage("Printing:Print", {
|
|
windowID: aWindowID,
|
|
});
|
|
},
|
|
|
|
/**
|
|
* Deprecated.
|
|
*
|
|
* Starts the process of printing the contents of window.content.
|
|
*
|
|
*/
|
|
print: function ()
|
|
{
|
|
if (gBrowser) {
|
|
return this.printWindow(gBrowser.selectedBrowser.outerWindowID,
|
|
gBrowser.selectedBrowser);
|
|
}
|
|
|
|
if (this.usingRemoteTabs) {
|
|
throw new Error("PrintUtils.print cannot be run in windows running with " +
|
|
"remote tabs. Use PrintUtils.printWindow instead.");
|
|
}
|
|
|
|
let domWindow = window.content;
|
|
let ifReq = domWindow.QueryInterface(Components.interfaces.nsIInterfaceRequestor);
|
|
let browser = ifReq.getInterface(Components.interfaces.nsIWebNavigation)
|
|
.QueryInterface(Components.interfaces.nsIDocShell)
|
|
.chromeEventHandler;
|
|
if (!browser) {
|
|
throw new Error("PrintUtils.print could not resolve content window " +
|
|
"to a browser.");
|
|
}
|
|
|
|
let windowID = ifReq.getInterface(Components.interfaces.nsIDOMWindowUtils)
|
|
.outerWindowID;
|
|
|
|
let Deprecated = Components.utils.import("resource://gre/modules/Deprecated.jsm", {}).Deprecated;
|
|
let msg = "PrintUtils.print is now deprecated. Please use PrintUtils.printWindow.";
|
|
let url = "https://developer.mozilla.org/en-US/docs/Mozilla/Tech/XUL/Printing";
|
|
Deprecated.warning(msg, url);
|
|
|
|
this.printWindow(windowID, browser);
|
|
},
|
|
|
|
/**
|
|
* Initializes print preview.
|
|
*
|
|
* @param aListenerObj
|
|
* An object that defines the following functions:
|
|
*
|
|
* getPrintPreviewBrowser:
|
|
* Returns the <xul:browser> to display the print preview in. This
|
|
* <xul:browser> must have its type attribute set to "content",
|
|
* "content-targetable", or "content-primary".
|
|
*
|
|
* getSourceBrowser:
|
|
* Returns the <xul:browser> that contains the document being
|
|
* printed. This <xul:browser> must have its type attribute set to
|
|
* "content", "content-targetable", or "content-primary".
|
|
*
|
|
* getNavToolbox:
|
|
* Returns the primary toolbox for this window.
|
|
*
|
|
* onEnter:
|
|
* Called upon entering print preview.
|
|
*
|
|
* onExit:
|
|
* Called upon exiting print preview.
|
|
*
|
|
* These methods must be defined. printPreview can be called
|
|
* with aListenerObj as null iff this window is already displaying
|
|
* print preview (in which case, the previous aListenerObj passed
|
|
* to it will be used).
|
|
*/
|
|
printPreview: function (aListenerObj)
|
|
{
|
|
// if we're already in PP mode, don't set the listener; chances
|
|
// are it is null because someone is calling printPreview() to
|
|
// get us to refresh the display.
|
|
if (!this.inPrintPreview) {
|
|
this._listener = aListenerObj;
|
|
this._sourceBrowser = aListenerObj.getSourceBrowser();
|
|
this._originalTitle = this._sourceBrowser.contentTitle;
|
|
this._originalURL = this._sourceBrowser.currentURI.spec;
|
|
} else {
|
|
// collapse the browser here -- it will be shown in
|
|
// enterPrintPreview; this forces a reflow which fixes display
|
|
// issues in bug 267422.
|
|
this._sourceBrowser = this._listener.getPrintPreviewBrowser();
|
|
this._sourceBrowser.collapsed = true;
|
|
}
|
|
|
|
this._webProgressPP = {};
|
|
let ppParams = {};
|
|
let notifyOnOpen = {};
|
|
let printSettings = this.getPrintSettings();
|
|
// Here we get the PrintingPromptService so we can display the PP Progress from script
|
|
// For the browser implemented via XUL with the PP toolbar we cannot let it be
|
|
// automatically opened from the print engine because the XUL scrollbars in the PP window
|
|
// will layout before the content window and a crash will occur.
|
|
// Doing it all from script, means it lays out before hand and we can let printing do its own thing
|
|
let PPROMPTSVC = Components.classes["@mozilla.org/embedcomp/printingprompt-service;1"]
|
|
.getService(Components.interfaces.nsIPrintingPromptService);
|
|
// just in case we are already printing,
|
|
// an error code could be returned if the Progress Dialog is already displayed
|
|
try {
|
|
PPROMPTSVC.showProgress(window, null, printSettings, this._obsPP, false,
|
|
this._webProgressPP, ppParams, notifyOnOpen);
|
|
if (ppParams.value) {
|
|
ppParams.value.docTitle = this._originalTitle;
|
|
ppParams.value.docURL = this._originalURL;
|
|
}
|
|
|
|
// this tells us whether we should continue on with PP or
|
|
// wait for the callback via the observer
|
|
if (!notifyOnOpen.value.valueOf() || this._webProgressPP.value == null) {
|
|
this.enterPrintPreview();
|
|
}
|
|
} catch (e) {
|
|
this.enterPrintPreview();
|
|
}
|
|
},
|
|
|
|
/**
|
|
* Returns the nsIWebBrowserPrint associated with some content window.
|
|
* This method is being kept here for compatibility reasons, but should not
|
|
* be called by code hoping to support e10s / remote browsers.
|
|
*
|
|
* @param aWindow
|
|
* The window from which to get the nsIWebBrowserPrint from.
|
|
* @return nsIWebBrowserPrint
|
|
*/
|
|
getWebBrowserPrint: function (aWindow)
|
|
{
|
|
let Deprecated = Components.utils.import("resource://gre/modules/Deprecated.jsm", {}).Deprecated;
|
|
let text = "getWebBrowserPrint is now deprecated, and fully unsupported for " +
|
|
"multi-process browsers. Please use a frame script to get " +
|
|
"access to nsIWebBrowserPrint from content.";
|
|
let url = "https://developer.mozilla.org/en-US/docs/Printing_from_a_XUL_App";
|
|
Deprecated.warning(text, url);
|
|
|
|
if (this.usingRemoteTabs) {
|
|
return {};
|
|
}
|
|
|
|
var contentWindow = aWindow || window.content;
|
|
return contentWindow.QueryInterface(Components.interfaces.nsIInterfaceRequestor)
|
|
.getInterface(Components.interfaces.nsIWebBrowserPrint);
|
|
},
|
|
|
|
/**
|
|
* Returns the nsIWebBrowserPrint from the print preview browser's docShell.
|
|
* This method is being kept here for compatibility reasons, but should not
|
|
* be called by code hoping to support e10s / remote browsers.
|
|
*
|
|
* @return nsIWebBrowserPrint
|
|
*/
|
|
getPrintPreview: function() {
|
|
let Deprecated = Components.utils.import("resource://gre/modules/Deprecated.jsm", {}).Deprecated;
|
|
let text = "getPrintPreview is now deprecated, and fully unsupported for " +
|
|
"multi-process browsers. Please use a frame script to get " +
|
|
"access to nsIWebBrowserPrint from content.";
|
|
let url = "https://developer.mozilla.org/en-US/docs/Printing_from_a_XUL_App";
|
|
Deprecated.warning(text, url);
|
|
|
|
if (this.usingRemoteTabs) {
|
|
return {};
|
|
}
|
|
|
|
return this._listener.getPrintPreviewBrowser().docShell.printPreview;
|
|
},
|
|
|
|
get inPrintPreview() {
|
|
return document.getElementById("print-preview-toolbar") != null;
|
|
},
|
|
|
|
////////////////////////////////////////////////////
|
|
// "private" methods and members. Don't use them. //
|
|
///////////////////////////////////////////////////
|
|
|
|
_listener: null,
|
|
_closeHandlerPP: null,
|
|
_webProgressPP: null,
|
|
_sourceBrowser: null,
|
|
_originalTitle: "",
|
|
_originalURL: "",
|
|
|
|
get usingRemoteTabs() {
|
|
// We memoize this, since it's highly unlikely to change over the lifetime
|
|
// of the window.
|
|
let usingRemoteTabs =
|
|
window.QueryInterface(Components.interfaces.nsIInterfaceRequestor)
|
|
.getInterface(Components.interfaces.nsIWebNavigation)
|
|
.QueryInterface(Components.interfaces.nsILoadContext)
|
|
.useRemoteTabs;
|
|
delete this.usingRemoteTabs;
|
|
return this.usingRemoteTabs = usingRemoteTabs;
|
|
},
|
|
|
|
displayPrintingError(nsresult, isPrinting) {
|
|
// The nsresults from a printing error are mapped to strings that have
|
|
// similar names to the errors themselves. For example, for error
|
|
// NS_ERROR_GFX_PRINTER_NO_PRINTER_AVAILABLE, the name of the string
|
|
// for the error message is: PERR_GFX_PRINTER_NO_PRINTER_AVAILABLE. What's
|
|
// more, if we're in the process of doing a print preview, it's possible
|
|
// that there are strings specific for print preview for these errors -
|
|
// if so, the names of those strings have _PP as a suffix. It's possible
|
|
// that no print preview specific strings exist, in which case it is fine
|
|
// to fall back to the original string name.
|
|
const MSG_CODES = [
|
|
"GFX_PRINTER_NO_PRINTER_AVAILABLE",
|
|
"GFX_PRINTER_NAME_NOT_FOUND",
|
|
"GFX_PRINTER_COULD_NOT_OPEN_FILE",
|
|
"GFX_PRINTER_STARTDOC",
|
|
"GFX_PRINTER_ENDDOC",
|
|
"GFX_PRINTER_STARTPAGE",
|
|
"GFX_PRINTER_DOC_IS_BUSY",
|
|
"ABORT",
|
|
"NOT_AVAILABLE",
|
|
"NOT_IMPLEMENTED",
|
|
"OUT_OF_MEMORY",
|
|
"UNEXPECTED",
|
|
];
|
|
|
|
// PERR_FAILURE is the catch-all error message if we've gotten one that
|
|
// we don't recognize.
|
|
msgName = "PERR_FAILURE";
|
|
|
|
for (let code of MSG_CODES) {
|
|
let nsErrorResult = "NS_ERROR_" + code;
|
|
if (Components.results[nsErrorResult] == nsresult) {
|
|
msgName = "PERR_" + code;
|
|
break;
|
|
}
|
|
}
|
|
|
|
let msg, title;
|
|
|
|
if (!isPrinting) {
|
|
// Try first with _PP suffix.
|
|
let ppMsgName = msgName + "_PP";
|
|
try {
|
|
msg = this.bundle.GetStringFromName(ppMsgName);
|
|
} catch(e) {
|
|
// We allow localizers to not have the print preview error string,
|
|
// and just fall back to the printing error string.
|
|
}
|
|
}
|
|
|
|
if (!msg) {
|
|
msg = this.bundle.GetStringFromName(msgName);
|
|
}
|
|
|
|
title = this.bundle.GetStringFromName(isPrinting ? "print_error_dialog_title"
|
|
: "printpreview_error_dialog_title");
|
|
|
|
let promptSvc = Components.classes["@mozilla.org/embedcomp/prompt-service;1"]
|
|
.getService(Components.interfaces.nsIPromptService);
|
|
promptSvc.alert(window, title, msg);
|
|
},
|
|
|
|
receiveMessage(aMessage) {
|
|
if (aMessage.name == "Printing:Error") {
|
|
this.displayPrintingError(aMessage.data.nsresult,
|
|
aMessage.data.isPrinting);
|
|
return;
|
|
}
|
|
|
|
// If we got here, then the message we've received must involve
|
|
// updating the print progress UI.
|
|
if (!this._webProgressPP.value) {
|
|
// We somehow didn't get a nsIWebProgressListener to be updated...
|
|
// I guess there's nothing to do.
|
|
return;
|
|
}
|
|
|
|
let listener = this._webProgressPP.value;
|
|
let mm = aMessage.target.messageManager;
|
|
let data = aMessage.data;
|
|
|
|
switch (aMessage.name) {
|
|
case "Printing:Preview:ProgressChange": {
|
|
return listener.onProgressChange(null, null,
|
|
data.curSelfProgress,
|
|
data.maxSelfProgress,
|
|
data.curTotalProgress,
|
|
data.maxTotalProgress);
|
|
break;
|
|
}
|
|
|
|
case "Printing:Preview:StateChange": {
|
|
if (data.stateFlags & Components.interfaces.nsIWebProgressListener.STATE_STOP) {
|
|
// Strangely, the printing engine sends 2 STATE_STOP messages when
|
|
// print preview is finishing. One has the STATE_IS_DOCUMENT flag,
|
|
// the other has the STATE_IS_NETWORK flag. However, the webProgressPP
|
|
// listener stops listening once the first STATE_STOP is sent.
|
|
// Any subsequent messages result in NS_ERROR_FAILURE errors getting
|
|
// thrown. This should all get torn out once bug 1088061 is fixed.
|
|
mm.removeMessageListener("Printing:Preview:StateChange", this);
|
|
mm.removeMessageListener("Printing:Preview:ProgressChange", this);
|
|
}
|
|
|
|
return listener.onStateChange(null, null,
|
|
data.stateFlags,
|
|
data.status);
|
|
break;
|
|
}
|
|
}
|
|
},
|
|
|
|
setPrinterDefaultsForSelectedPrinter: function (aPSSVC, aPrintSettings)
|
|
{
|
|
if (!aPrintSettings.printerName)
|
|
aPrintSettings.printerName = aPSSVC.defaultPrinterName;
|
|
|
|
// First get any defaults from the printer
|
|
aPSSVC.initPrintSettingsFromPrinter(aPrintSettings.printerName, aPrintSettings);
|
|
// now augment them with any values from last time
|
|
aPSSVC.initPrintSettingsFromPrefs(aPrintSettings, true, aPrintSettings.kInitSaveAll);
|
|
},
|
|
|
|
getPrintSettings: function ()
|
|
{
|
|
var pref = Components.classes["@mozilla.org/preferences-service;1"]
|
|
.getService(Components.interfaces.nsIPrefBranch);
|
|
if (pref) {
|
|
gPrintSettingsAreGlobal = pref.getBoolPref("print.use_global_printsettings", false);
|
|
gSavePrintSettings = pref.getBoolPref("print.save_print_settings", false);
|
|
}
|
|
|
|
var printSettings;
|
|
try {
|
|
var PSSVC = Components.classes["@mozilla.org/gfx/printsettings-service;1"]
|
|
.getService(Components.interfaces.nsIPrintSettingsService);
|
|
if (gPrintSettingsAreGlobal) {
|
|
printSettings = PSSVC.globalPrintSettings;
|
|
this.setPrinterDefaultsForSelectedPrinter(PSSVC, printSettings);
|
|
} else {
|
|
printSettings = PSSVC.newPrintSettings;
|
|
}
|
|
} catch (e) {
|
|
dump("getPrintSettings: "+e+"\n");
|
|
}
|
|
return printSettings;
|
|
},
|
|
|
|
// This observer is called once the progress dialog has been "opened"
|
|
_obsPP:
|
|
{
|
|
observe: function(aSubject, aTopic, aData)
|
|
{
|
|
// delay the print preview to show the content of the progress dialog
|
|
setTimeout(function () { PrintUtils.enterPrintPreview(); }, 0);
|
|
},
|
|
|
|
QueryInterface : function(iid)
|
|
{
|
|
if (iid.equals(Components.interfaces.nsIObserver) ||
|
|
iid.equals(Components.interfaces.nsISupportsWeakReference) ||
|
|
iid.equals(Components.interfaces.nsISupports))
|
|
return this;
|
|
throw Components.results.NS_NOINTERFACE;
|
|
}
|
|
},
|
|
|
|
enterPrintPreview: function ()
|
|
{
|
|
// Send a message to the print preview browser to initialize
|
|
// print preview. If we happen to have gotten a print preview
|
|
// progress listener from nsIPrintingPromptService.showProgress
|
|
// in printPreview, we add listeners to feed that progress
|
|
// listener.
|
|
let ppBrowser = this._listener.getPrintPreviewBrowser();
|
|
let mm = ppBrowser.messageManager;
|
|
mm.sendAsyncMessage("Printing:Preview:Enter", {
|
|
windowID: this._sourceBrowser.outerWindowID,
|
|
});
|
|
|
|
if (this._webProgressPP.value) {
|
|
mm.addMessageListener("Printing:Preview:StateChange", this);
|
|
mm.addMessageListener("Printing:Preview:ProgressChange", this);
|
|
}
|
|
|
|
let onEntered = (message) => {
|
|
mm.removeMessageListener("Printing:PrintPreview:Entered", onEntered);
|
|
|
|
if (message.data.failed) {
|
|
// Something went wrong while putting the document into print preview
|
|
// mode. Bail out.
|
|
this._listener.onEnter();
|
|
this._listener.onExit();
|
|
return;
|
|
}
|
|
|
|
// Stash the focused element so that we can return to it after exiting
|
|
// print preview.
|
|
gFocusedElement = document.commandDispatcher.focusedElement;
|
|
|
|
let printPreviewTB = document.getElementById("print-preview-toolbar");
|
|
if (printPreviewTB) {
|
|
printPreviewTB.updateToolbar();
|
|
ppBrowser.collapsed = false;
|
|
ppBrowser.focus();
|
|
return;
|
|
}
|
|
|
|
// Set the original window as an active window so any mozPrintCallbacks can
|
|
// run without delayed setTimeouts.
|
|
this._sourceBrowser.docShellIsActive = true;
|
|
|
|
// show the toolbar after we go into print preview mode so
|
|
// that we can initialize the toolbar with total num pages
|
|
const XUL_NS =
|
|
"http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul";
|
|
printPreviewTB = document.createElementNS(XUL_NS, "toolbar");
|
|
printPreviewTB.setAttribute("printpreview", true);
|
|
printPreviewTB.id = "print-preview-toolbar";
|
|
|
|
let navToolbox = this._listener.getNavToolbox();
|
|
navToolbox.parentNode.insertBefore(printPreviewTB, navToolbox);
|
|
printPreviewTB.initialize(ppBrowser);
|
|
|
|
// copy the window close handler
|
|
if (document.documentElement.hasAttribute("onclose"))
|
|
this._closeHandlerPP = document.documentElement.getAttribute("onclose");
|
|
else
|
|
this._closeHandlerPP = null;
|
|
document.documentElement.setAttribute("onclose", "PrintUtils.exitPrintPreview(); return false;");
|
|
|
|
// disable chrome shortcuts...
|
|
window.addEventListener("keydown", this.onKeyDownPP, true);
|
|
window.addEventListener("keypress", this.onKeyPressPP, true);
|
|
|
|
ppBrowser.collapsed = false;
|
|
ppBrowser.focus();
|
|
// on Enter PP Call back
|
|
this._listener.onEnter();
|
|
};
|
|
|
|
mm.addMessageListener("Printing:Preview:Entered", onEntered);
|
|
},
|
|
|
|
exitPrintPreview: function ()
|
|
{
|
|
let ppBrowser = this._listener.getPrintPreviewBrowser();
|
|
let browserMM = ppBrowser.messageManager;
|
|
browserMM.sendAsyncMessage("Printing:Preview:Exit");
|
|
window.removeEventListener("keydown", this.onKeyDownPP, true);
|
|
window.removeEventListener("keypress", this.onKeyPressPP, true);
|
|
|
|
// restore the old close handler
|
|
document.documentElement.setAttribute("onclose", this._closeHandlerPP);
|
|
this._closeHandlerPP = null;
|
|
|
|
// remove the print preview toolbar
|
|
let printPreviewTB = document.getElementById("print-preview-toolbar");
|
|
this._listener.getNavToolbox().parentNode.removeChild(printPreviewTB);
|
|
|
|
let fm = Components.classes["@mozilla.org/focus-manager;1"]
|
|
.getService(Components.interfaces.nsIFocusManager);
|
|
if (gFocusedElement)
|
|
fm.setFocus(gFocusedElement, fm.FLAG_NOSCROLL);
|
|
else
|
|
this._sourceBrowser.focus();
|
|
gFocusedElement = null;
|
|
|
|
this._listener.onExit();
|
|
},
|
|
|
|
onKeyDownPP: function (aEvent)
|
|
{
|
|
// Esc exits the PP
|
|
if (aEvent.keyCode == aEvent.DOM_VK_ESCAPE) {
|
|
PrintUtils.exitPrintPreview();
|
|
}
|
|
},
|
|
|
|
onKeyPressPP: function (aEvent)
|
|
{
|
|
var closeKey;
|
|
try {
|
|
closeKey = document.getElementById("key_close")
|
|
.getAttribute("key");
|
|
closeKey = aEvent["DOM_VK_"+closeKey];
|
|
} catch (e) {}
|
|
var isModif = aEvent.ctrlKey || aEvent.metaKey;
|
|
// Ctrl-W exits the PP
|
|
if (isModif &&
|
|
(aEvent.charCode == closeKey || aEvent.charCode == closeKey + 32)) {
|
|
PrintUtils.exitPrintPreview();
|
|
}
|
|
else if (isModif) {
|
|
var printPreviewTB = document.getElementById("print-preview-toolbar");
|
|
var printKey = document.getElementById("printKb").getAttribute("key").toUpperCase();
|
|
var pressedKey = String.fromCharCode(aEvent.charCode).toUpperCase();
|
|
if (printKey == pressedKey) {
|
|
printPreviewTB.print();
|
|
}
|
|
}
|
|
// cancel shortkeys
|
|
if (isModif) {
|
|
aEvent.preventDefault();
|
|
aEvent.stopPropagation();
|
|
}
|
|
}
|
|
}
|
|
|
|
PrintUtils.init();
|