PK
f-3w i6 6 # content/xbl-marquee/xbl-marquee.xml
6
if (this.hasAttribute("scrollamount"))
return this.getAttribute("scrollamount");
return this.defaultScrollAmount; //default value is 6 pixels
this.setAttribute("scrollamount", val);
85
this.setAttribute("scrolldelay", val);
// since we changed the scrolldelay, restart the marquee
this._doMove(false);
"left"
return this.directionField;
// if val is false, don't change anything
if (val) {
// in case direction is swapped between horizontal/vertical, use
// setAttribute to make the xbl bindings change.
this.setAttribute("direction", val);
// since we changed the direction, set startNewDirection to true
this.startNewDirection = true;
this.directionField = val.toLowerCase();
// pass in aSkipSettingNewPosition as true
this._doMove(true);
}
"left""scroll"
return this.behaviorField;
this.behaviorField = val ? val.toLowerCase() : this.defaultBehavior;
"scroll"100000true"0.9.7"
this.stopAt) ||
(this.dirsign == -1 && this.newPosition < this.stopAt))
{
if (this.behaviorField == "alternate")
{
// lets start afresh
this.startNewDirection = true;
// swap direction
const swap = {left: "right", down: "up", up: "down", right: "left"};
this.directionField = swap[this.directionField];
}
else
{
this.newPosition = this.startAt;
}
}
if (!this.startNewDirection) {
if ((this.directionField == "up") || (this.directionField == "down"))
this.outerDiv.scrollTop = this.newPosition;
else
this.outerDiv.scrollLeft = this.newPosition;
}
var myThis = this;
var lambda = function myTimeOutFunction(){myThis.start();}
this.runId = window.setTimeout(lambda, this.scrollDelay);
]]>
PK
q2WL L # content/xbl-marquee/xbl-marquee.css/* ***** BEGIN LICENSE BLOCK *****
* Version: MPL 1.1/GPL 2.0/LGPL 2.1
*
* The contents of this file are subject to the Mozilla Public License Version
* 1.1 (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
* http://www.mozilla.org/MPL/
*
* Software distributed under the License is distributed on an "AS IS" basis,
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
* for the specific language governing rights and limitations under the
* License.
*
* The Original Code is mozilla.org code.
*
* 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.
*
* Contributor(s):
*
* Alternatively, the contents of this file may be used under the terms of
* either of the GNU General Public License Version 2 or later (the "GPL"),
* or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
* 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 MPL, 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 MPL, the GPL or the LGPL.
*
* ***** END LICENSE BLOCK ***** */
/* Marquees with a height attr that actually specifies a height should have
auto CSS height here. Note that this rule has the same specificity as the
preceding one, so it has to come later in the sheet to work. */
marquee[height*="1"], marquee[height*="2"], marquee[height*="3"],
marquee[height*="4"], marquee[height*="5"], marquee[height*="6"],
marquee[height*="7"], marquee[height*="8"], marquee[height*="9"] {
height: auto;
}
/* PRINT ONLY rules follow */
@media print {
marquee > * > * {
margin: 0 !important;
padding: 0 !important;
} /* This hack is needed until bug 119078 gets fixed */
}
PK
w\,}Ť % content/communicator/communicator.css/* ***** BEGIN LICENSE BLOCK *****
* Version: MPL 1.1/GPL 2.0/LGPL 2.1
*
* The contents of this file are subject to the Mozilla Public License Version
* 1.1 (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
* http://www.mozilla.org/MPL/
*
* Software distributed under the License is distributed on an "AS IS" basis,
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
* for the specific language governing rights and limitations under the
* License.
*
* The Original Code is mozilla.org code.
*
* The Initial Developer of the Original Code is
* Netscape Communications Corporation.
* Portions created by the Initial Developer are Copyright (C) 2002
* the Initial Developer. All Rights Reserved.
*
* Contributor(s):
* Samir Gehani
*
* 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 MPL, 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 MPL, the GPL or the LGPL.
*
* ***** END LICENSE BLOCK ***** */
@namespace url("http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul");
/* ::::: print preview toolbar ::::: */
toolbar[printpreview="true"] {
-moz-binding: url("chrome://communicator/content/printPreviewBindings.xml#printpreviewtoolbar");
}
PK
(2~ , content/communicator/communicatorOverlay.xul
PK
g5z{ { ' content/communicator/utilityOverlay.xul
%brandDTD;
%globalRegionDTD;
%utilityDTD;
]>
PK
!a6 + & content/communicator/utilityOverlay.js/* -*- Mode: Java; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/* ***** BEGIN LICENSE BLOCK *****
* Version: MPL 1.1/GPL 2.0/LGPL 2.1
*
* The contents of this file are subject to the Mozilla Public License Version
* 1.1 (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
* http://www.mozilla.org/MPL/
*
* Software distributed under the License is distributed on an "AS IS" basis,
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
* for the specific language governing rights and limitations under the
* License.
*
* The Original Code is mozilla.org code.
*
* 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.
*
* Contributor(s):
* Alec Flett
*
* Alternatively, the contents of this file may be used under the terms of
* either of the GNU General Public License Version 2 or later (the "GPL"),
* or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
* 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 MPL, 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 MPL, the GPL or the LGPL.
*
* ***** END LICENSE BLOCK ***** */
/**
* Communicator Shared Utility Library
* for shared application glue for the Communicator suite of applications
**/
/*
Note: All Editor/Composer-related methods have been moved to editorApplicationOverlay.js,
so app windows that require those must include editorNavigatorOverlay.xul
*/
var gShowBiDi = false;
function GetStringPref(name)
{
try {
return pref.getComplexValue(name, Components.interfaces.nsISupportsString).data;
} catch (e) {}
return "";
}
var goPrefWindow = 0;
function getBrowserURL() {
try {
var prefs = Components.classes["@mozilla.org/preferences-service;1"]
.getService(Components.interfaces.nsIPrefBranch);
var url = prefs.getCharPref("browser.chromeURL");
if (url)
return url;
} catch(e) {
}
return "chrome://navigator/content/navigator.xul";
}
// update menu items that rely on focus
function goUpdateGlobalEditMenuItems()
{
goUpdateCommand('cmd_undo');
goUpdateCommand('cmd_redo');
goUpdateCommand('cmd_cut');
goUpdateCommand('cmd_copy');
goUpdateCommand('cmd_paste');
goUpdateCommand('cmd_selectAll');
goUpdateCommand('cmd_delete');
if (gShowBiDi)
goUpdateCommand('cmd_switchTextDirection');
}
// update menu items that rely on the current selection
function goUpdateSelectEditMenuItems()
{
goUpdateCommand('cmd_cut');
goUpdateCommand('cmd_copy');
goUpdateCommand('cmd_delete');
goUpdateCommand('cmd_selectAll');
}
// update menu items that relate to undo/redo
function goUpdateUndoEditMenuItems()
{
goUpdateCommand('cmd_undo');
goUpdateCommand('cmd_redo');
}
// update menu items that depend on clipboard contents
function goUpdatePasteMenuItems()
{
goUpdateCommand('cmd_paste');
}
// update Find As You Type menu items, they rely on focus
function goUpdateFindTypeMenuItems()
{
goUpdateCommand('cmd_findTypeText');
goUpdateCommand('cmd_findTypeLinks');
}
// Gather all descendent text under given document node.
function gatherTextUnder ( root )
{
var text = "";
var node = root.firstChild;
var depth = 1;
while ( node && depth > 0 ) {
// See if this node is text.
if ( node.nodeType == Node.TEXT_NODE ) {
// Add this text to our collection.
text += " " + node.data;
} else if ( node instanceof HTMLImageElement ) {
// If it has an alt= attribute, add that.
var altText = node.getAttribute( "alt" );
if ( altText && altText != "" ) {
text += " " + altText;
}
}
// Find next node to test.
// First, see if this node has children.
if ( node.hasChildNodes() ) {
// Go to first child.
node = node.firstChild;
depth++;
} else {
// No children, try next sibling.
if ( node.nextSibling ) {
node = node.nextSibling;
} else {
// Last resort is a sibling of an ancestor.
while ( node && depth > 0 ) {
node = node.parentNode;
depth--;
if ( node.nextSibling ) {
node = node.nextSibling;
break;
}
}
}
}
}
// Strip leading whitespace.
text = text.replace( /^\s+/, "" );
// Strip trailing whitespace.
text = text.replace( /\s+$/, "" );
// Compress remaining whitespace.
text = text.replace( /\s+/g, " " );
return text;
}
function GenerateValidFilename(filename, extension)
{
if (filename) // we have a title; let's see if it's usable
{
// clean up the filename to make it usable and
// then trim whitespace from beginning and end
filename = validateFileName(filename).replace(/^\s+|\s+$/g, "");
if (filename.length > 0)
return filename + extension;
}
return null;
}
function validateFileName(aFileName)
{
var re = /[\/]+/g;
if (navigator.appVersion.indexOf("Windows") != -1) {
re = /[\\\/\|]+/g;
aFileName = aFileName.replace(/[\"]+/g, "'");
aFileName = aFileName.replace(/[\*\:\?]+/g, " ");
aFileName = aFileName.replace(/[\<]+/g, "(");
aFileName = aFileName.replace(/[\>]+/g, ")");
}
else if (navigator.appVersion.indexOf("Macintosh") != -1)
re = /[\:\/]+/g;
return aFileName.replace(re, "_");
}
function goToggleToolbar( id, elementID )
{
var toolbar = document.getElementById( id );
var element = document.getElementById( elementID );
if ( toolbar )
{
var isHidden = toolbar.getAttribute("hidden") == "true";
toolbar.setAttribute("hidden", !isHidden);
if ( element )
element.setAttribute("checked", isHidden)
document.persist(id, 'hidden');
document.persist(elementID, 'checked');
}
}
PK
5j/ $ content/communicator/openLocation.js/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
*
* ***** BEGIN LICENSE BLOCK *****
* Version: MPL 1.1/GPL 2.0/LGPL 2.1
*
* The contents of this file are subject to the Mozilla Public License Version
* 1.1 (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
* http://www.mozilla.org/MPL/
*
* Software distributed under the License is distributed on an "AS IS" basis,
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
* for the specific language governing rights and limitations under the
* License.
*
* The Original Code is Mozilla Communicator client code, released
* March 31, 1998.
*
* 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.
*
* Contributor(s):
* Michael Lowe
* Blake Ross
*
* Alternatively, the contents of this file may be used under the terms of
* either of the GNU General Public License Version 2 or later (the "GPL"),
* or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
* 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 MPL, 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 MPL, the GPL or the LGPL.
*
* ***** END LICENSE BLOCK ***** */
var browser;
var dialog = {};
var pref = null;
try {
pref = Components.classes["@mozilla.org/preferences-service;1"]
.getService(Components.interfaces.nsIPrefBranch);
} catch (ex) {
// not critical, remain silent
}
function onLoad()
{
dialog.input = document.getElementById("dialog.input");
dialog.open = document.documentElement.getButton("accept");
dialog.openAppList = document.getElementById("openAppList");
dialog.openTopWindow = document.getElementById("currentWindow");
dialog.openNewWindow = document.getElementById("newWindow");
dialog.openEditWindow = document.getElementById("editWindow");
dialog.openNewTab = document.getElementById("newTab");
dialog.bundle = document.getElementById("openLocationBundle");
browser = window.arguments[0].browser;
if (!browser) {
// No browser supplied - we are calling from Composer
dialog.openAppList.selectedItem = dialog.openEditWindow;
// Change string to make more sense for Composer
dialog.openTopWindow.setAttribute("label", dialog.bundle.getString("existingNavigatorWindow"));
// Find most recent browser window
var windowManager = Components.classes['@mozilla.org/appshell/window-mediator;1'].getService();
var windowManagerInterface = windowManager.QueryInterface( Components.interfaces.nsIWindowMediator);
if (windowManagerInterface)
browser = windowManagerInterface.getMostRecentWindow( "navigator:browser" );
// Disable "current browser" item if no browser is open
if (!browser) {
dialog.openTopWindow.setAttribute("disabled", "true");
dialog.openNewTab.setAttribute("disabled", "true");
}
}
else {
dialog.openAppList.selectedItem = dialog.openTopWindow;
}
if (pref) {
try {
dialog.openAppList.value = pref.getIntPref("general.open_location.last_window_choice");
dialog.input.value = pref.getComplexValue("general.open_location.last_url",
Components.interfaces.nsISupportsString).data;
}
catch(ex) {
}
if (dialog.input.value)
dialog.input.select(); // XXX should probably be done automatically
}
doEnabling();
}
function doEnabling()
{
dialog.open.disabled = !dialog.input.value;
}
function open()
{
var params = window.arguments[0];
params.url = dialog.input.value;
params.action = dialog.openAppList.value;
if (!browser && params.action != "2")
params.action = "1";
if (pref) {
var str = Components.classes["@mozilla.org/supports-string;1"]
.createInstance(Components.interfaces.nsISupportsString);
str.data = dialog.input.value;
pref.setComplexValue("general.open_location.last_url",
Components.interfaces.nsISupportsString, str);
pref.setIntPref("general.open_location.last_window_choice", dialog.openAppList.value);
}
}
const nsIFilePicker = Components.interfaces.nsIFilePicker;
function onChooseFile()
{
try {
var fp = Components.classes["@mozilla.org/filepicker;1"].createInstance(nsIFilePicker);
fp.init(window, dialog.bundle.getString("chooseFileDialogTitle"), nsIFilePicker.modeOpen);
if (dialog.openAppList.value == "2") {
// When loading into Composer, direct user to prefer HTML files and text files,
// so we call separately to control the order of the filter list
fp.appendFilters(nsIFilePicker.filterHTML | nsIFilePicker.filterText);
fp.appendFilters(nsIFilePicker.filterText);
fp.appendFilters(nsIFilePicker.filterAll);
}
else {
fp.appendFilters(nsIFilePicker.filterHTML | nsIFilePicker.filterText |
nsIFilePicker.filterAll | nsIFilePicker.filterImages | nsIFilePicker.filterXML);
}
if (fp.show() == nsIFilePicker.returnOK && fp.fileURL.spec && fp.fileURL.spec.length > 0)
dialog.input.value = fp.fileURL.spec;
}
catch(ex) {
}
doEnabling();
}
function useUBHistoryItem(aMenuItem)
{
var urlbar = document.getElementById("dialog.input");
urlbar.value = aMenuItem.getAttribute("label");
urlbar.focus();
doEnabling();
}
PK
5@|fQ Q % content/communicator/openLocation.xul
%brandDTD;
%openDialogDTD;
]>
PK
Rq3N#" " $ content/communicator/tasksOverlay.js/* -*- Mode: Java; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* ***** BEGIN LICENSE BLOCK *****
* Version: MPL 1.1/GPL 2.0/LGPL 2.1
*
* The contents of this file are subject to the Mozilla Public License Version
* 1.1 (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
* http://www.mozilla.org/MPL/
*
* Software distributed under the License is distributed on an "AS IS" basis,
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
* for the specific language governing rights and limitations under the
* License.
*
* The Original Code is mozilla.org code.
*
* 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.
*
* Contributor(s):
* Peter Annema
*
* Alternatively, the contents of this file may be used under the terms of
* either of the GNU General Public License Version 2 or later (the "GPL"),
* or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
* 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 MPL, 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 MPL, the GPL or the LGPL.
*
* ***** END LICENSE BLOCK ***** */
const nsIDOMWindowInternal = Components.interfaces.nsIDOMWindowInternal;
const nsIWindowMediator = Components.interfaces.nsIWindowMediator;
const nsIWindowDataSource = Components.interfaces.nsIWindowDataSource;
function toNavigator()
{
if (!CycleWindow("navigator:browser"))
OpenBrowserWindow();
}
function toDownloadManager()
{
var dlmgr = Components.classes['@mozilla.org/download-manager;1'].getService();
dlmgr = dlmgr.QueryInterface(Components.interfaces.nsIDownloadManager);
var windowMediator = Components.classes['@mozilla.org/appshell/window-mediator;1'].getService();
windowMediator = windowMediator.QueryInterface(nsIWindowMediator);
var dlmgrWindow = windowMediator.getMostRecentWindow("Download:Manager");
if (dlmgrWindow) {
dlmgrWindow.focus();
}
else {
dlmgr.open(window, null);
}
}
function toJavaScriptConsole()
{
toOpenWindowByType("global:console", "chrome://global/content/console.xul");
}
function javaItemEnabling()
{
var element = document.getElementById("java");
if (navigator.javaEnabled())
element.removeAttribute("disabled");
else
element.setAttribute("disabled", "true");
}
function toJavaConsole()
{
var jvmMgr = Components.classes['@mozilla.org/oji/jvm-mgr;1']
.getService(Components.interfaces.nsIJVMManager)
jvmMgr.showJavaConsole();
}
function toOpenWindow( aWindow )
{
try {
// Try to focus the previously focused window e.g. message compose body
aWindow.document.commandDispatcher.focusedWindow.focus();
} catch (e) {
// e.g. full-page plugin or non-XUL document; just raise the top window
aWindow.focus();
}
}
function toOpenWindowByType( inType, uri )
{
// Recently opened one.
if (uri in window)
return;
var windowManager = Components.classes['@mozilla.org/appshell/window-mediator;1'].getService(nsIWindowMediator);
var topWindow = windowManager.getMostRecentWindow( inType );
if ( topWindow )
toOpenWindow( topWindow );
else
{
function newWindowLoaded(event) {
delete window[uri];
}
window[uri] = window.openDialog(uri, "", "all,dialog=no");
window[uri].addEventListener("load", newWindowLoaded, false);
}
}
function OpenBrowserWindow()
{
var charsetArg = new String();
var handler = Components.classes['@mozilla.org/commandlinehandler/general-startup;1?type=browser'];
handler = handler.getService();
handler = handler.QueryInterface(Components.interfaces.nsICmdLineHandler);
var url = handler.chromeUrlForTask;
var wintype = document.documentElement.getAttribute('windowtype');
var windowMediator = Components.classes["@mozilla.org/appshell/window-mediator;1"].getService(Components.interfaces.nsIWindowMediator);
var browserWin = windowMediator.getMostRecentWindow("navigator:browser");
// if a browser window already exists then set startpage to null so
// navigator.js can check pref for how new window should be opened
var startpage = browserWin ? null : handler.defaultArgs;
// if and only if the current window is a browser window and it has a document with a character
// set, then extract the current charset menu setting from the current document and use it to
// initialize the new browser window...
if (window && (wintype == "navigator:browser") && window.content && window.content.document)
{
var DocCharset = window.content.document.characterSet;
charsetArg = "charset="+DocCharset;
//we should "inherit" the charset menu setting in a new window
window.openDialog(url, "_blank", "chrome,all,dialog=no", startpage, charsetArg);
}
else // forget about the charset information.
{
window.openDialog(url, "_blank", "chrome,all,dialog=no", startpage);
}
}
function CycleWindow( aType )
{
var windowManager = Components.classes['@mozilla.org/appshell/window-mediator;1'].getService();
var windowManagerInterface = windowManager.QueryInterface(nsIWindowMediator);
var topWindowOfType = windowManagerInterface.getMostRecentWindow( aType );
var topWindow = windowManagerInterface.getMostRecentWindow( null );
if ( topWindowOfType == null )
return null;
if ( topWindowOfType != topWindow ) {
toOpenWindow(topWindowOfType);
return topWindowOfType;
}
var enumerator = windowManagerInterface.getEnumerator( aType );
var firstWindow = enumerator.getNext().QueryInterface(nsIDOMWindowInternal);
var iWindow = firstWindow;
while (iWindow != topWindow && enumerator.hasMoreElements())
iWindow = enumerator.getNext().QueryInterface(nsIDOMWindowInternal);
if (enumerator.hasMoreElements()) {
iWindow = enumerator.getNext().QueryInterface(nsIDOMWindowInternal);
toOpenWindow(iWindow);
return iWindow;
}
if (firstWindow == topWindow) // Only one window
return null;
toOpenWindow(firstWindow);
return firstWindow;
}
function ShowWindowFromResource( node )
{
var windowManagerDS = Components.classes['@mozilla.org/rdf/datasource;1?name=window-mediator'].getService(nsIWindowDataSource);
var desiredWindow = null;
var url = node.getAttribute('id');
desiredWindow = windowManagerDS.getWindowForResource( url );
if ( desiredWindow )
{
toOpenWindow(desiredWindow);
}
}
function OpenTaskURL( inURL )
{
window.open( inURL );
}
function ShowUpdateFromResource( node )
{
var url = node.getAttribute('url');
// hack until I get a new interface on xpiflash to do a
// look up on the name/url pair.
OpenTaskURL( "http://www.mozilla.org/binaries.html");
}
function checkFocusedWindow()
{
var windowManagerDS = Components.classes['@mozilla.org/rdf/datasource;1?name=window-mediator'].getService(nsIWindowDataSource);
var sep = document.getElementById("sep-window-list");
// Using double parens to avoid warning
while ((sep = sep.nextSibling)) {
var url = sep.getAttribute('id');
var win = windowManagerDS.getWindowForResource(url);
if (win == window) {
sep.setAttribute("checked", "true");
break;
}
}
}
function toProfileManager()
{
const wm = Components.classes["@mozilla.org/appshell/window-mediator;1"]
.getService(Components.interfaces.nsIWindowMediator);
var promgrWin = wm.getMostRecentWindow( "mozilla:profileSelection" );
if (promgrWin) {
promgrWin.focus();
} else {
var params = Components.classes["@mozilla.org/embedcomp/dialogparam;1"]
.createInstance(Components.interfaces.nsIDialogParamBlock);
params.SetNumberStrings(1);
params.SetString(0, "menu");
window.openDialog("chrome://communicator/content/profile/profileSelection.xul",
"",
"centerscreen,chrome,titlebar",
params);
}
// Here, we don't care about the result code
// that was returned in the param block.
}
// This function is used by mac's platformCommunicatorOverlay
function ZoomCurrentWindow()
{
if (window.windowState == STATE_NORMAL)
window.maximize();
else
window.restore();
}
PK
m45[
% content/communicator/tasksOverlay.xul
%tasksDTD;
]>
PK
|n+Qg ( content/communicator/browserBindings.xul
PK
du*i՚| ' content/communicator/editorBindings.xul
PK
̡b+CV" 0 content/communicator/platformBrowserBindings.xul
PK
͡b+S / content/communicator/platformEditorBindings.xul
PK
92o? 4 content/communicator/platformCommunicatorOverlay.xul
%platformCommunicatorDTD;
%utilityDTD;
]>
PK
0w- # content/communicator/builtinURLs.js// the rdf service
var gRDFService;
var gTitleArc;
var gContentArc;
var gBuiltinUrlsDataSource;
var gDataSourceState;
var gDataSourceLoaded;
var gSinkObserverRegistered;
var SinkObserver =
{
onBeginLoad: function( aSink) {
gDataSourceState = (gDataSourceState | 1);
debug_dump("\n-> SinkObserver:onBeginLoad: " + aSink + ", gDataSourceState=" + gDataSourceState + "\n");
},
onInterrupt: function( aSink) {
gDataSourceState = (gDataSourceState | 2);
debug_dump("\n-> SinkObserver:onInterrupt: " + aSink + ", gDataSourceState=" + gDataSourceState + "\n");
},
onResume: function( aSink) {
gDataSourceState = (gDataSourceState & ~2);
debug_dump("\n-> SinkObserver:onResume: " + aSink + ", gDataSourceState=" + gDataSourceState + "\n");
},
onEndLoad: function( aSink) {
gDataSourceState = (gDataSourceState | 4);
gDataSourceLoaded = (gDataSourceState == 5);
debug_dump("\n-> onEndLoad: " + aSink + ", gDataSourceState=" + gDataSourceState + ", gDataSourceLoaded=" + gDataSourceLoaded + "\n");
if (!gDataSourceLoaded) {
debug_dump("\n-> builtin URLs not loaded!\n");
return;
}
gBuiltinUrlsDataSource = aSink.QueryInterface(Components.interfaces.nsIRDFDataSource);
debug_dump("Got gBuiltinUrlsDataSource " + gBuiltinUrlsDataSource + " with gTitleArc " + gTitleArc + " and gContentArc " + gContentArc + "\n");
},
onError: function( aSink, aStatus, aErrMsg) {
gDataSourceState = (gDataSourceState | 8);
debug_dump("\n-> SinkObserver:onError: " + aSink + ", status=" + aStatus +
", errMsg=" + aErrMsg + ", gDataSourceState=" + gDataSourceState + "\n");
}
};
function debug_dump(msg)
{
}
/*
function debug_dump(msg)
{
dump(msg);
}
*/
function loadDS()
{
debug_dump("\n-->loadDS() called for " + window.document + " <--\n");
if (gBuiltinUrlsDataSource && gDataSourceLoaded) {
debug_dump("\n-->loadDS(): gBuiltinUrlsDataSource=" + gBuiltinUrlsDataSource + ", gDataSourceLoaded=" + gDataSourceLoaded + ", returning! <--\n");
return;
}
if (gSinkObserverRegistered)
{
debug_dump("Already registered SinkObserver in loadDS()\n");
return;
}
// initialize
gRDFService = Components.classes['@mozilla.org/rdf/rdf-service;1'].getService();
gRDFService = gRDFService.QueryInterface(Components.interfaces.nsIRDFService);
if (!gRDFService) {
debug_dump("\n-->loadDS(): gRDFService service is null!\n");
return;
}
gTitleArc = gRDFService.GetResource("http://home.netscape.com/NC-rdf#title");
gContentArc = gRDFService.GetResource("http://home.netscape.com/NC-rdf#content");
var ds_uri = "chrome://global-region/locale/builtinURLs.rdf";
var url_ds = gRDFService.GetDataSource(ds_uri); // return nsIRDFDataSource
if (!url_ds) {
debug_dump("\n >>Can't get " + ds_uri + "<-\n");
return;
}
if (url_ds.QueryInterface(Components.interfaces.nsIRDFRemoteDataSource).loaded)
{
ds_uri = "chrome://global-region/locale/builtinURLs.rdf";
gBuiltinUrlsDataSource = gRDFService.GetDataSource(ds_uri); // return nsIRDFDataSource
gDataSourceLoaded = (gBuiltinUrlsDataSource != null);
}
else
{
var rdfXMLSink = url_ds.QueryInterface( Components.interfaces.nsIRDFXMLSink );
if (rdfXMLSink) {
gBuiltinUrlsDataSource = null;
gDataSourceState = 0x0; // init.
gDataSourceLoaded = false;
gSinkObserverRegistered = true;
rdfXMLSink.addXMLSinkObserver(SinkObserver);
}
else
{
debug_dump("rdfXMLSink is null\n");
}
}
}
function xlateURL(key)
{
debug_dump("\n>> xlateURL(" + key + "): gBuiltinUrlsDataSource=" + gBuiltinUrlsDataSource + ", gDataSourceLoaded=" + gDataSourceLoaded + "\n");
if (!gBuiltinUrlsDataSource || !gDataSourceLoaded) {
throw("urn translation data source not loaded");
}
// get data
var srcNode = gRDFService.GetResource(key);
var titleTarget = gBuiltinUrlsDataSource.GetTarget(srcNode, gTitleArc, true);
if (titleTarget) {
titleTarget =
titleTarget.QueryInterface(Components.interfaces.nsIRDFLiteral);
debug_dump("\n-> " + key + "::title=" + titleTarget.Value);
}
else {
debug_dump("\n title target=" + titleTarget + "\n");
}
var contentTarget = gBuiltinUrlsDataSource.GetTarget(srcNode, gContentArc, true);
if (contentTarget) {
contentTarget =
contentTarget.QueryInterface(Components.interfaces.nsIRDFLiteral);
debug_dump("\n-> " + key + "::content=" + contentTarget.Value + "\n");
return contentTarget.Value;
}
else {
debug_dump("\n content target=" + contentTarget + "\n");
throw("urn not found in datasource");
}
// not reached
return "";
}
function loadXURL(key)
{
debug_dump("loadXURL call with " + key + "\n");
var url = xlateURL(key);
//check to see if this is a browser window before opening.
var winType = document.documentElement.getAttribute("windowtype");
if (window.content && winType == "navigator:browser")
window.content.location.href = url;
else
window.open(url); // on mac, there maybe no open windows: see bug 83329
}
loadDS();
PK
b5uk]| ]| ( content/communicator/contentAreaUtils.js/* -*- Mode: Java; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* ***** BEGIN LICENSE BLOCK *****
* Version: MPL 1.1/GPL 2.0/LGPL 2.1
*
* The contents of this file are subject to the Mozilla Public License Version
* 1.1 (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
* http://www.mozilla.org/MPL/
*
* Software distributed under the License is distributed on an "AS IS" basis,
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
* for the specific language governing rights and limitations under the
* License.
*
* The Original Code is mozilla.org code.
*
* 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.
*
* Contributor(s):
* Ben Goodger (Save File)
*
* Alternatively, the contents of this file may be used under the terms of
* either of the GNU General Public License Version 2 or later (the "GPL"),
* or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
* 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 MPL, 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 MPL, the GPL or the LGPL.
*
* ***** END LICENSE BLOCK ***** */
const kExistingWindow = Components.interfaces.nsIBrowserDOMWindow.OPEN_CURRENTWINDOW;
const kNewWindow = Components.interfaces.nsIBrowserDOMWindow.OPEN_NEWWINDOW;
const kNewTab = Components.interfaces.nsIBrowserDOMWindow.OPEN_NEWTAB;
/**
* Determine whether or not a given focused DOMWindow is in the content
* area.
**/
function isContentFrame(aFocusedWindow)
{
if (!aFocusedWindow)
return false;
return (aFocusedWindow.top == window.content);
}
function urlSecurityCheck(url, doc)
{
// URL Loading Security Check
var focusedWindow = doc.commandDispatcher.focusedWindow;
var sourceURL = getContentFrameURI(focusedWindow);
const nsIScriptSecurityManager = Components.interfaces.nsIScriptSecurityManager;
var secMan = Components.classes["@mozilla.org/scriptsecuritymanager;1"]
.getService(nsIScriptSecurityManager);
try {
secMan.checkLoadURIStr(sourceURL, url, nsIScriptSecurityManager.STANDARD);
} catch (e) {
throw "Load of " + url + " denied.";
}
}
function getContentFrameURI(aFocusedWindow)
{
var contentFrame = isContentFrame(aFocusedWindow) ? aFocusedWindow : window.content;
return contentFrame.location.href;
}
function getContentFrameDocument(aFocusedWindow)
{
var contentFrame = isContentFrame(aFocusedWindow) ?
aFocusedWindow : window.content;
return contentFrame.document;
}
function getReferrer(doc)
{
var focusedWindow = doc.commandDispatcher.focusedWindow;
var sourceDocument = getContentFrameDocument(focusedWindow);
try {
return makeURI(sourceDocument.location.href, sourceDocument.characterSet);
} catch (e) {
return null;
}
}
function openAsExternal(aURL)
{
openNewTabWindowOrExistingWith(pref.getIntPref("browser.link.open_external"),
aURL, false, false);
}
function openNewWindowWith(aURL, aSendReferrer)
{
openNewTabWindowOrExistingWith(kNewWindow, aURL, aSendReferrer, false);
}
function openNewTabWith(aURL, aSendReferrer, aReverseBackgroundPref)
{
openNewTabWindowOrExistingWith(kNewTab, aURL, aSendReferrer, aReverseBackgroundPref);
}
function openNewTabWindowOrExistingWith(aType, aURL, aSendReferrer, aReverseBackgroundPref)
{
// Make sure we are allowed to open this url
urlSecurityCheck(aURL, document);
// get referrer, if as external should be null
var referrer = aSendReferrer ? getReferrer(document) : null;
var browserWin;
// if we're not opening a new window, try and find existing window
if (aType != kNewWindow)
browserWin = getTopWin();
// Where appropiate we want to pass the charset of the
// current document over to a new tab / window.
var originCharset = null;
if (aType != kExistingWindow) {
var wintype = document.documentElement.getAttribute('windowtype');
if (wintype == "navigator:browser")
originCharset = window.content.document.characterSet;
}
// We want to open in a new window or no existing window can be found.
if (!browserWin) {
var charsetArg = null;
if (originCharset)
charsetArg = "charset=" + originCharset;
window.openDialog(getBrowserURL(), "_blank", "chrome,all,dialog=no",
aURL, charsetArg, referrer);
return;
}
// Get the existing browser object
var browser = browserWin.getBrowser();
// Open link in an existing window.
if (aType == kExistingWindow) {
browser.loadURI(aURL);
browserWin.content.focus();
return;
}
// open link in new tab
var loadInBackground = false;
if (pref) {
loadInBackground = pref.getBoolPref("browser.tabs.loadInBackground");
if (aReverseBackgroundPref)
loadInBackground = !loadInBackground;
}
browser.addTab(aURL, referrer, originCharset, !loadInBackground);
}
// Clientelle: (Make sure you don't break any of these)
// - File -> Save Page/Frame As...
// - Context -> Save Page/Frame As...
// - Context -> Save Link As...
// - Shift-Click Save Link As
//
// Try saving each of these types:
// - A complete webpage using File->Save Page As, and Context->Save Page As
// - A webpage as HTML only using the above methods
// - A webpage as Text only using the above methods
// - An image with an extension (e.g. .jpg) in its file name, using
// Context->Save Image As...
// - An image without an extension (e.g. a banner ad on cnn.com) using
// the above method.
// - A linked document using Save Link As...
// - A linked document using shift-click Save Link As...
//
function saveURL(aURL, aFileName, aFilePickerTitleKey, aShouldBypassCache,
aReferrer)
{
internalSave(aURL, null, aFileName, null, null, aShouldBypassCache,
aFilePickerTitleKey, null, aReferrer);
}
// Just like saveURL, but will get some info off the image before
// calling internalSave
// Clientelle: (Make sure you don't break any of these)
// - Context -> Save Image As...
const imgICache = Components.interfaces.imgICache;
const nsISupportsCString = Components.interfaces.nsISupportsCString;
function saveImageURL(aURL, aFileName, aFilePickerTitleKey, aShouldBypassCache,
aReferrer)
{
var contentType = null;
var contentDisposition = null;
if (!aShouldBypassCache) {
try {
var imageCache = Components.classes["@mozilla.org/image/cache;1"]
.getService(imgICache);
var props =
imageCache.findEntryProperties(makeURI(aURL, getCharsetforSave(null)));
if (props) {
contentType = props.get("type", nsISupportsCString);
contentDisposition = props.get("content-disposition",
nsISupportsCString);
}
} catch (e) {
// Failure to get type and content-disposition off the image is non-fatal
}
}
internalSave(aURL, null, aFileName, contentDisposition, contentType,
aShouldBypassCache, aFilePickerTitleKey, null, aReferrer);
}
function saveFrameDocument()
{
var focusedWindow = document.commandDispatcher.focusedWindow;
if (isContentFrame(focusedWindow))
saveDocument(focusedWindow.document);
}
function saveDocument(aDocument)
{
if (!aDocument) {
throw "Must have a document when calling saveDocument";
}
// We want to use cached data because the document is currently visible.
var dispHeader = null;
try {
dispHeader =
aDocument.defaultView
.QueryInterface(Components.interfaces.nsIInterfaceRequestor)
.getInterface(Components.interfaces.nsIDOMWindowUtils)
.getDocumentMetadata("content-disposition");
} catch (ex) {
// Failure to get a content-disposition is ok
}
internalSave(aDocument.location.href, aDocument, null, dispHeader,
aDocument.contentType, false, null, null);
}
const SAVETYPE_COMPLETE_PAGE = 0x00;
const SAVETYPE_TEXT_ONLY = 0x02;
/**
* internalSave: Used when saving a document or URL. This method:
* - Determines a local target filename to use (unless parameter
* aChosenData is non-null)
* - Determines content-type if possible
* - Prompts the user to confirm the destination filename and save mode
* (content-type affects this)
* - Creates a 'Persist' object (which will perform the saving in the
* background) and then starts it.
*
* @param aURL The String representation of the URL of the document being saved
* @param aDocument The document to be saved
* @param aDefaultFileName The caller-provided suggested filename if we don't
* find a better one
* @param aContentDisposition The caller-provided content-disposition header
* to use.
* @param aContentType The caller-provided content-type to use
* @param aShouldBypassCache If true, the document will always be refetched
* from the server
* @param aFilePickerTitleKey Alternate title for the file picker
* @param aChosenData If non-null this contains an instance of object AutoChosen
* (see below) which holds pre-determined data so that the user does not
* need to be prompted for a target filename.
* @param aReferrer the referrer URI object (not URL string) to use, or null
if no referrer should be sent.
*/
function internalSave(aURL, aDocument, aDefaultFileName, aContentDisposition,
aContentType, aShouldBypassCache, aFilePickerTitleKey,
aChosenData, aReferrer)
{
// Note: aDocument == null when this code is used by save-link-as...
var saveMode = GetSaveModeForContentType(aContentType);
var isDocument = aDocument != null && saveMode != SAVEMODE_FILEONLY;
var saveAsType = SAVETYPE_COMPLETE_PAGE;
var file, fileURL;
// Find the URI object for aURL and the FileName/Extension to use when saving.
// FileName/Extension will be ignored if aChosenData supplied.
var fileInfo = new FileInfo(aDefaultFileName);
if (aChosenData)
file = aChosenData.file;
else {
var charset = null;
if (aDocument)
charset = aDocument.characterSet;
else if (aReferrer)
charset = aReferrer.originCharset;
initFileInfo(fileInfo, aURL, charset, aDocument,
aContentType, aContentDisposition);
var fpParams = {
fpTitleKey: aFilePickerTitleKey,
isDocument: isDocument,
fileInfo: fileInfo,
contentType: aContentType,
saveMode: saveMode,
saveAsType: saveAsType,
file: file,
fileURL: fileURL
};
if (!poseFilePicker(fpParams))
// If the method returned false this is because the user cancelled from
// the save file picker dialog.
return;
saveAsType = fpParams.saveAsType;
saveMode = fpParams.saveMode;
file = fpParams.file;
fileURL = fpParams.fileURL;
}
if (!fileURL)
fileURL = makeFileURI(file);
// XXX We depend on the following holding true in appendFiltersForContentType():
// If we should save as a complete page, the saveAsType is SAVETYPE_COMPLETE_PAGE.
// If we should save as text, the saveAsType is SAVETYPE_TEXT_ONLY.
var useSaveDocument = isDocument &&
(((saveMode & SAVEMODE_COMPLETE_DOM) && (saveAsType == SAVETYPE_COMPLETE_PAGE)) ||
((saveMode & SAVEMODE_COMPLETE_TEXT) && (saveAsType == SAVETYPE_TEXT_ONLY)));
// If we're saving a document, and are saving either in complete mode or
// as converted text, pass the document to the web browser persist component.
// If we're just saving the HTML (second option in the list), send only the URI.
var source = useSaveDocument ? aDocument : fileInfo.uri;
var persistArgs = {
source : source,
contentType : (!aChosenData && useSaveDocument &&
saveAsType == SAVETYPE_TEXT_ONLY) ?
"text/plain" : aContentType,
target : fileURL,
postData : isDocument ? getPostData() : null,
bypassCache : aShouldBypassCache
};
var persist = makeWebBrowserPersist();
// Calculate persist flags.
const nsIWBP = Components.interfaces.nsIWebBrowserPersist;
const flags = nsIWBP.PERSIST_FLAGS_REPLACE_EXISTING_FILES;
if (aShouldBypassCache)
persist.persistFlags = flags | nsIWBP.PERSIST_FLAGS_BYPASS_CACHE;
else
persist.persistFlags = flags | nsIWBP.PERSIST_FLAGS_FROM_CACHE;
// Leave it to WebBrowserPersist to discover the encoding type (or lack thereof):
persist.persistFlags |= nsIWBP.PERSIST_FLAGS_AUTODETECT_APPLY_CONVERSION;
// Create download and initiate it (below)
var tr = Components.classes["@mozilla.org/transfer;1"].createInstance(Components.interfaces.nsITransfer);
if (useSaveDocument) {
// Saving a Document, not a URI:
var filesFolder = null;
if (persistArgs.contentType != "text/plain") {
// Create the local directory into which to save associated files.
filesFolder = file.clone();
var nameWithoutExtension = filesFolder.leafName.replace(/\.[^.]*$/, "");
var filesFolderLeafName = getStringBundle().formatStringFromName("filesFolder",
[nameWithoutExtension],
1);
filesFolder.leafName = filesFolderLeafName;
}
var encodingFlags = 0;
if (persistArgs.contentType == "text/plain") {
encodingFlags |= nsIWBP.ENCODE_FLAGS_FORMATTED;
encodingFlags |= nsIWBP.ENCODE_FLAGS_ABSOLUTE_LINKS;
encodingFlags |= nsIWBP.ENCODE_FLAGS_NOFRAMES_CONTENT;
}
else {
encodingFlags |= nsIWBP.ENCODE_FLAGS_ENCODE_BASIC_ENTITIES;
}
const kWrapColumn = 80;
tr.init((aChosenData ? aChosenData.uri : fileInfo.uri),
persistArgs.target, "", null, null, null, persist);
persist.progressListener = tr;
persist.saveDocument(persistArgs.source, persistArgs.target, filesFolder,
persistArgs.contentType, encodingFlags, kWrapColumn);
} else {
tr.init((aChosenData ? aChosenData.uri : source),
persistArgs.target, "", null, null, null, persist);
persist.progressListener = tr;
persist.saveURI((aChosenData ? aChosenData.uri : source),
null, aReferrer, persistArgs.postData, null,
persistArgs.target);
}
}
/**
* Structure for holding info about automatically supplied parameters for
* internalSave(...). This allows parameters to be supplied so the user does not
* need to be prompted for file info.
* @param aFileAutoChosen This is an nsILocalFile object that has been
* pre-determined as the filename for the target to save to
* @param aUriAutoChosen This is the nsIURI object for the target
*/
function AutoChosen(aFileAutoChosen, aUriAutoChosen) {
this.file = aFileAutoChosen;
this.uri = aUriAutoChosen;
}
/**
* Structure for holding info about a URL and the target filename it should be
* saved to. This structure is populated by initFileInfo(...).
* @param aSuggestedFileName This is used by initFileInfo(...) when it
* cannot 'discover' the filename from the url
* @param aFileName The target filename
* @param aFileBaseName The filename without the file extension
* @param aFileExt The extension of the filename
* @param aUri An nsIURI object for the url that is being saved
*/
function FileInfo(aSuggestedFileName, aFileName, aFileBaseName, aFileExt, aUri) {
this.suggestedFileName = aSuggestedFileName;
this.fileName = aFileName;
this.fileBaseName = aFileBaseName;
this.fileExt = aFileExt;
this.uri = aUri;
}
/**
* Determine what the 'default' filename string is, its file extension and the
* filename without the extension. This filename is used when prompting the user
* for confirmation in the file picker dialog.
* @param aFI A FileInfo structure into which we'll put the results of this method.
* @param aURL The String representation of the URL of the document being saved
* @param aURLCharset The charset of aURL.
* @param aDocument The document to be saved
* @param aContentType The content type we're saving, if it could be
* determined by the caller.
* @param aContentDisposition The content-disposition header for the object
* we're saving, if it could be determined by the caller.
*/
function initFileInfo(aFI, aURL, aURLCharset, aDocument,
aContentType, aContentDisposition)
{
try {
// Get an nsIURI object from aURL if possible:
try {
aFI.uri = makeURI(aURL, aURLCharset);
// Assuming nsiUri is valid, calling QueryInterface(...) on it will
// populate extra object fields (eg filename and file extension).
var url = aFI.uri.QueryInterface(Components.interfaces.nsIURL);
aFI.fileExt = url.fileExtension;
} catch (e) {
}
// Get the default filename:
aFI.fileName = getDefaultFileName((aFI.suggestedFileName || aFI.fileName),
aFI.uri, aDocument, aContentDisposition);
// If aFI.fileExt is still blank, consider: aFI.suggestedFileName is supplied
// if saveURL(...) was the original caller (hence both aContentType and
// aDocument are blank). If they were saving a link to a website then make
// the extension .htm .
if (!aFI.fileExt && !aDocument && !aContentType && (/^http(s?):\/\//i.test(aURL))) {
aFI.fileExt = "htm";
aFI.fileBaseName = aFI.fileName;
} else {
aFI.fileExt = getDefaultExtension(aFI.fileName, aFI.uri, aContentType);
aFI.fileBaseName = getFileBaseName(aFI.fileName, aFI.fileExt);
}
} catch (e) {
}
}
/**
* Given the Filepicker Parameters (aFpP), show the file picker dialog,
* prompting the user to confirm (or change) the fileName.
* @param aFpP a structure (see definition in internalSave(...) method)
* containing all the data used within this method.
* @return true if the user confirmed a filename in the picker; false if they
* dismissed the picker.
*/
function poseFilePicker(aFpP)
{
const nsILocalFile = Components.interfaces.nsILocalFile;
const kDownloadDirPref = "dir";
var branch = getPrefsBrowserDownload("browser.download.");
var dir = null;
// Try and pull in download directory pref
try {
dir = branch.getComplexValue(kDownloadDirPref, nsILocalFile);
} catch (e) { }
var autoDownload = branch.getBoolPref("autoDownload");
if (autoDownload && dir && dir.exists()) {
dir.append(getNormalizedLeafName(aFpP.fileInfo.fileName, aFpP.fileInfo.fileExt));
aFpP.file = uniqueFile(dir);
return true;
}
// Show the file picker that allows the user to confirm the target filename:
var fp = makeFilePicker();
var titleKey = aFpP.fpTitleKey || "SaveLinkTitle";
var bundle = getStringBundle();
fp.init(window, bundle.GetStringFromName(titleKey),
Components.interfaces.nsIFilePicker.modeSave);
try {
if (dir.exists())
fp.displayDirectory = dir;
} catch (e) { }
fp.defaultExtension = aFpP.fileInfo.fileExt;
fp.defaultString = getNormalizedLeafName(aFpP.fileInfo.fileName,
aFpP.fileInfo.fileExt);
appendFiltersForContentType(fp, aFpP.contentType, aFpP.fileInfo.fileExt,
aFpP.saveMode);
if (aFpP.isDocument) {
try {
fp.filterIndex = branch.getIntPref("save_converter_index");
}
catch (e) {
}
}
if (fp.show() == Components.interfaces.nsIFilePicker.returnCancel || !fp.file)
return false;
if (aFpP.isDocument)
branch.setIntPref("save_converter_index", fp.filterIndex);
// Now that the user has had a chance to change the directory and/or filename,
// re-read those values...
if (branch.getBoolPref("lastLocation") || autoDownload) {
var directory = fp.file.parent.QueryInterface(nsILocalFile);
branch.setComplexValue(kDownloadDirPref, nsILocalFile, directory);
}
fp.file.leafName = validateFileName(fp.file.leafName);
aFpP.saveAsType = fp.filterIndex;
aFpP.file = fp.file;
aFpP.fileURL = fp.fileURL;
return true;
}
// Since we're automatically downloading, we don't get the file picker's
// logic to check for existing files, so we need to do that here.
//
// Note - this code is identical to that in nsHelperAppDlg.js.
// If you are updating this code, update that code too! We can't share code
// here since that code is called in a js component.
function uniqueFile(aLocalFile)
{
while (aLocalFile.exists()) {
parts = /(-\d+)?(\.[^.]+)?$/.test(aLocalFile.leafName);
aLocalFile.leafName = RegExp.leftContext + (RegExp.$1 - 1) + RegExp.$2;
}
return aLocalFile;
}
// We have no DOM, and can only save the URL as is.
const SAVEMODE_FILEONLY = 0x00;
// We have a DOM and can save as complete.
const SAVEMODE_COMPLETE_DOM = 0x01;
// We have a DOM which we can serialize as text.
const SAVEMODE_COMPLETE_TEXT = 0x02;
// If we are able to save a complete DOM, the 'save as complete' filter
// must be the first filter appended. The 'save page only' counterpart
// must be the second filter appended. And the 'save as complete text'
// filter must be the third filter appended.
function appendFiltersForContentType(aFilePicker, aContentType, aFileExtension, aSaveMode)
{
var bundle = getStringBundle();
// The bundle name for saving only a specific content type.
var bundleName;
// The corresponding filter string for a specific content type.
var filterString;
// XXX all the cases that are handled explicitly here MUST be handled
// in GetSaveModeForContentType to return a non-fileonly filter.
switch (aContentType) {
case "text/html":
bundleName = "WebPageHTMLOnlyFilter";
filterString = "*.htm; *.html";
break;
case "application/xhtml+xml":
bundleName = "WebPageXHTMLOnlyFilter";
filterString = "*.xht; *.xhtml";
break;
case "text/xml":
case "application/xml":
bundleName = "WebPageXMLOnlyFilter";
filterString = "*.xml";
break;
default:
if (aSaveMode != SAVEMODE_FILEONLY) {
throw "Invalid save mode for type '" + aContentType + "'";
}
var mimeInfo = getMIMEInfoForType(aContentType, aFileExtension);
if (mimeInfo) {
var extEnumerator = mimeInfo.getFileExtensions();
var extString = "";
while (extEnumerator.hasMore()) {
var extension = extEnumerator.getNext();
if (extString)
extString += "; "; // If adding more than one extension,
// separate by semi-colon
extString += "*." + extension;
}
if (extString) {
aFilePicker.appendFilter(mimeInfo.description, extString);
}
}
break;
}
if (aSaveMode & SAVEMODE_COMPLETE_DOM) {
aFilePicker.appendFilter(bundle.GetStringFromName("WebPageCompleteFilter"), filterString);
// We should always offer a choice to save document only if
// we allow saving as complete.
aFilePicker.appendFilter(bundle.GetStringFromName(bundleName), filterString);
}
if (aSaveMode & SAVEMODE_COMPLETE_TEXT) {
aFilePicker.appendFilters(Components.interfaces.nsIFilePicker.filterText);
}
// Always append the all files (*) filter
aFilePicker.appendFilters(Components.interfaces.nsIFilePicker.filterAll);
}
function getPostData()
{
try {
var sessionHistory = getWebNavigation().sessionHistory;
return sessionHistory.getEntryAtIndex(sessionHistory.index, false)
.QueryInterface(Components.interfaces.nsISHEntry)
.postData;
}
catch (e) {
}
return null;
}
function getStringBundle()
{
const bundleURL = "chrome://communicator/locale/contentAreaCommands.properties";
const sbsContractID = "@mozilla.org/intl/stringbundle;1";
const sbsIID = Components.interfaces.nsIStringBundleService;
const sbs = Components.classes[sbsContractID].getService(sbsIID);
const lsContractID = "@mozilla.org/intl/nslocaleservice;1";
const lsIID = Components.interfaces.nsILocaleService;
const ls = Components.classes[lsContractID].getService(lsIID);
var appLocale = ls.getApplicationLocale();
return sbs.createBundle(bundleURL, appLocale);
}
// Get the preferences branch ("browser.download." for normal 'save' mode)...
function getPrefsBrowserDownload(branch)
{
const prefSvcContractID = "@mozilla.org/preferences-service;1";
const prefSvcIID = Components.interfaces.nsIPrefService;
return Components.classes[prefSvcContractID].getService(prefSvcIID).getBranch(branch);
}
function makeWebBrowserPersist()
{
const persistContractID = "@mozilla.org/embedding/browser/nsWebBrowserPersist;1";
const persistIID = Components.interfaces.nsIWebBrowserPersist;
return Components.classes[persistContractID].createInstance(persistIID);
}
/**
* Constructs a new URI, using nsIIOService.
* @param aURL The URI spec.
* @param aOriginCharset The charset of the URI.
* @return an nsIURI object based on aURL.
*/
function makeURI(aURL, aOriginCharset)
{
var ioService = Components.classes["@mozilla.org/network/io-service;1"]
.getService(Components.interfaces.nsIIOService);
return ioService.newURI(aURL, aOriginCharset, null);
}
function makeFileURI(aFile)
{
var ioService = Components.classes["@mozilla.org/network/io-service;1"]
.getService(Components.interfaces.nsIIOService);
return ioService.newFileURI(aFile);
}
function makeFilePicker()
{
const fpContractID = "@mozilla.org/filepicker;1";
const fpIID = Components.interfaces.nsIFilePicker;
return Components.classes[fpContractID].createInstance(fpIID);
}
function getMIMEService()
{
const mimeSvcContractID = "@mozilla.org/mime;1";
const mimeSvcIID = Components.interfaces.nsIMIMEService;
const mimeSvc = Components.classes[mimeSvcContractID].getService(mimeSvcIID);
return mimeSvc;
}
// Given aFileName, find the fileName without the extension on the end.
function getFileBaseName(aFileName, aFileExt)
{
// Remove the file extension from aFileName:
return aFileName.replace(/\.[^.]*$/, "");
}
function getMIMETypeForURI(aURI)
{
try {
return getMIMEService().getTypeFromURI(aURI);
}
catch (e) {
}
return null;
}
function getMIMEInfoForType(aMIMEType, aExtension)
{
if (aMIMEType || aExtension) {
try {
return getMIMEService().getFromTypeAndExtension(aMIMEType, aExtension);
}
catch (e) {
}
}
return null;
}
function getDefaultFileName(aDefaultFileName, aURI, aDocument,
aContentDisposition)
{
// 1) look for a filename in the content-disposition header, if any
if (aContentDisposition) {
const mhpContractID = "@mozilla.org/network/mime-hdrparam;1";
const mhpIID = Components.interfaces.nsIMIMEHeaderParam;
const mhp = Components.classes[mhpContractID].getService(mhpIID);
var dummy = { value: null }; // Need an out param...
var charset = getCharsetforSave(aDocument);
var fileName = null;
try {
fileName = mhp.getParameter(aContentDisposition, "filename", charset,
true, dummy);
}
catch (e) {
try {
fileName = mhp.getParameter(aContentDisposition, "name", charset, true,
dummy);
}
catch (e) {
}
}
if (fileName) {
return fileName;
}
}
try {
var url = aURI.QueryInterface(Components.interfaces.nsIURL);
if (url.fileName != "") {
// 2) Use the actual file name, if present
var textToSubURI = Components.classes["@mozilla.org/intl/texttosuburi;1"]
.getService(Components.interfaces.nsITextToSubURI);
return validateFileName(textToSubURI.unEscapeURIForUI(url.originCharset || "UTF-8", url.fileName));
}
} catch (e) {
// This is something like a data: and so forth URI... no filename here.
}
if (aDocument) {
var docTitle = GenerateValidFilename(aDocument.title, "");
if (docTitle) {
// 3) Use the document title
return docTitle;
}
}
if (aDefaultFileName)
// 4) Use the caller-provided name, if any
return validateFileName(aDefaultFileName);
// 5) If this is a directory, use the last directory name
var path = aURI.path.match(/\/([^\/]+)\/$/);
if (path && path.length > 1) {
return validateFileName(path[1]);
}
try {
if (aURI.host)
// 6) Use the host.
return aURI.host;
} catch (e) {
// Some files have no information at all, like Javascript generated pages
}
try {
// 7) Use the default file name
return getStringBundle().GetStringFromName("DefaultSaveFileName");
} catch (e) {
//in case localized string cannot be found
}
// 8) If all else fails, use "index"
return "index";
}
function getNormalizedLeafName(aFile, aDefaultExtension)
{
if (!aDefaultExtension)
return aFile;
// Remove trailing dots and spaces on windows
if (/Win/.test(navigator.platform))
aFile = aFile.replace(/[\s.]+$/, "");
// Fix up the file name we're saving to to include the default extension
var i = aFile.lastIndexOf(".");
if (aFile.substr(i + 1) != aDefaultExtension)
return aFile + "." + aDefaultExtension;
return aFile;
}
function getDefaultExtension(aFilename, aURI, aContentType)
{
if (aContentType == "text/plain" || aContentType == "application/octet-stream" || aURI.scheme == "ftp")
return ""; // temporary fix for bug 120327
// First try the extension from the filename
const stdURLContractID = "@mozilla.org/network/standard-url;1";
const stdURLIID = Components.interfaces.nsIURL;
var url = Components.classes[stdURLContractID].createInstance(stdURLIID);
url.filePath = aFilename;
var ext = url.fileExtension;
// This mirrors some code in nsExternalHelperAppService::DoContent
// Use the filename first and then the URI if that fails
var mimeInfo = getMIMEInfoForType(aContentType, ext);
if (ext && mimeInfo && mimeInfo.extensionExists(ext)) {
return ext;
}
// Well, that failed. Now try the extension from the URI
var urlext;
try {
url = aURI.QueryInterface(Components.interfaces.nsIURL);
urlext = url.fileExtension;
} catch (e) {
}
if (urlext && mimeInfo && mimeInfo.extensionExists(urlext)) {
return urlext;
}
else {
try {
return mimeInfo.primaryExtension;
}
catch (e) {
// Fall back on the extensions in the filename and URI for lack
// of anything better.
return ext || urlext;
}
}
}
function GetSaveModeForContentType(aContentType)
{
var saveMode = SAVEMODE_FILEONLY;
switch (aContentType) {
case "text/html":
case "application/xhtml+xml":
saveMode |= SAVEMODE_COMPLETE_TEXT;
// Fall through
case "text/xml":
case "application/xml":
saveMode |= SAVEMODE_COMPLETE_DOM;
break;
}
return saveMode;
}
function getCharsetforSave(aDocument)
{
if (aDocument)
return aDocument.characterSet;
if (document.commandDispatcher.focusedWindow)
return document.commandDispatcher.focusedWindow.document.characterSet;
return window.content.document.characterSet;
}
PK
e&4p
% content/communicator/contentAreaDD.js/* -*- Mode: Java; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* ***** BEGIN LICENSE BLOCK *****
* Version: MPL 1.1/GPL 2.0/LGPL 2.1
*
* The contents of this file are subject to the Mozilla Public License Version
* 1.1 (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
* http://www.mozilla.org/MPL/
*
* Software distributed under the License is distributed on an "AS IS" basis,
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
* for the specific language governing rights and limitations under the
* License.
*
* The Original Code is mozilla.org code.
*
* 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.
*
* Contributor(s):
* Alec Flett
* Ben Goodger
* Mike Pinkerton
* Blake Ross
*
* Alternatively, the contents of this file may be used under the terms of
* either of the GNU General Public License Version 2 or later (the "GPL"),
* or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
* 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 MPL, 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 MPL, the GPL or the LGPL.
*
* ***** END LICENSE BLOCK ***** */
/*
* Note that most of this routine has been moved into C++ in order to
* be available for all tags as well as gecko embedding. See
* mozilla/content/base/src/nsContentAreaDragDrop.cpp.
*
* Do not add any new fuctionality here other than what is needed for
* a standalone product.
*/
var contentAreaDNDObserver = {
onDrop: function (aEvent, aXferData, aDragSession)
{
var url = transferUtils.retrieveURLFromData(aXferData.data, aXferData.flavour.contentType);
// valid urls don't contain spaces ' '; if we have a space it
// isn't a valid url, or if it's a javascript: or data: url,
// bail out
if (!url || !url.length || url.indexOf(" ", 0) != -1 ||
/^\s*(javascript|data):/.test(url))
return;
switch (document.documentElement.getAttribute('windowtype')) {
case "navigator:browser":
// Perform a security check before loading the URI
nsDragAndDrop.dragDropSecurityCheck(aEvent, aDragSession, url);
loadURI(getShortcutOrURI(url));
break;
case "navigator:view-source":
viewSource(url);
break;
}
// keep the event from being handled by the dragDrop listeners
// built-in to gecko if they happen to be above us.
aEvent.preventDefault();
},
getSupportedFlavours: function ()
{
var flavourSet = new FlavourSet();
flavourSet.appendFlavour("text/x-moz-url");
flavourSet.appendFlavour("text/unicode");
flavourSet.appendFlavour("application/x-moz-file", "nsIFile");
return flavourSet;
}
};
PK
m*6zd֢ ( content/communicator/contentAreaClick.js//@line 41 "/builds/tinderbox/Tb-Mozilla1.8-Release/Linux_2.4.18-14_Depend/mozilla/mail/base/content/contentAreaClick.js"
/*
* - [ Dependencies ] ---------------------------------------------------------
* utilityOverlay.js:
* - gatherTextUnder
*/
var pref = Components.classes["@mozilla.org/preferences-service;1"].getService(Components.interfaces.nsIPrefBranch);
/**
* extract the href from the link click event.
* We look for HTMLAnchorElement, HTMLAreaElement, HTMLLinkElement,
* HTMLInputElement.form.action, and nested anchor tags.
*
* @return href for the url being clicked
*/
function hRefForClickEvent(event)
{
var target = event.target;
var href;
var isKeyPress = (event.type == "keypress");
if (target instanceof HTMLAnchorElement ||
target instanceof HTMLAreaElement ||
target instanceof HTMLLinkElement)
{
if (target.hasAttribute("href"))
href = target.href;
}
else if (target instanceof HTMLInputElement)
{
if (target.form && target.form.action)
href = target.form.action;
}
else
{
// we may be nested inside of a link node
linkNode = event.originalTarget;
while (linkNode && !(linkNode instanceof HTMLAnchorElement))
linkNode = linkNode.parentNode;
if (linkNode)
href = linkNode.href;
}
return href;
}
// Called whenever the user clicks in the content area,
// except when left-clicking on links (special case)
// should always return true for click to go through
function contentAreaClick(event)
{
var href = hRefForClickEvent(event);
if (href)
{
handleLinkClick(event, href, null);
if (!event.button) // left click only
return gPhishingDetector.warnOnSuspiciousLinkClick(href); // let the phishing detector check the link
}
return true;
}
function openNewTabOrWindow(event, href, sendReferrer)
{
// always return false for stand alone mail (MOZ_THUNDERBIRD)
// let someone else deal with it
return false;
}
function getContentFrameURI(aFocusedWindow)
{
var contentFrame = isContentFrame(aFocusedWindow) ? aFocusedWindow : window.content;
return contentFrame.location.href;
}
function handleLinkClick(event, href, linkNode)
{
// Make sure we are allowed to open this URL
var focusedWindow = document.commandDispatcher.focusedWindow;
var sourceURL = getContentFrameURI(focusedWindow);
urlSecurityCheck(href, sourceURL);
return false;
}
function middleMousePaste( event )
{
return false;
}
function makeURLAbsolute( base, url )
{
// Construct nsIURL.
var ioService = Components.classes["@mozilla.org/network/io-service;1"]
.getService(Components.interfaces.nsIIOService);
var baseURI = ioService.newURI(base, null, null);
return ioService.newURI(baseURI.resolve(url), null, null).spec;
}
PK
95E
9
9 2 content/communicator/contentAreaContextOverlay.xul
PK
@4d % content/communicator/nsContextMenu.js//@line 41 "/builds/tinderbox/Tb-Mozilla1.8-Release/Linux_2.4.18-14_Depend/mozilla/mail/base/content/nsContextMenu.js"
/*------------------------------ nsContextMenu ---------------------------------
| This JavaScript "class" is used to implement the browser's content-area |
| context menu. |
| |
| For usage, see references to this class in navigator.xul. |
| |
| Currently, this code is relatively useless for any other purpose. In the |
| longer term, this code will be restructured to make it more reusable. |
------------------------------------------------------------------------------*/
function nsContextMenu( xulMenu ) {
this.target = null;
this.menu = null;
this.popupURL = null;
this.onTextInput = false;
this.onImage = false;
this.onLoadedImage = false;
this.onLink = false;
this.onMailtoLink = false;
this.onSaveableLink = false;
this.onMetaDataItem = false;
this.onMathML = false;
this.link = false;
this.inFrame = false;
this.hasBGImage = false;
this.isTextSelected = false;
this.inDirList = false;
this.shouldDisplay = true;
// Initialize new menu.
this.initMenu( xulMenu );
}
// Prototype for nsContextMenu "class."
nsContextMenu.prototype = {
// onDestroy is a no-op at this point.
onDestroy : function () {
},
// Initialize context menu.
initMenu : function ( popup ) {
// Save menu.
this.menu = popup;
// Get contextual info.
this.setTarget( document.popupNode );
this.isTextSelected = this.isTextSelection();
this.initPopupURL();
// Initialize (disable/remove) menu items.
this.initItems();
},
initItems : function () {
this.initOpenItems();
this.initNavigationItems();
this.initViewItems();
this.initMiscItems();
this.initSaveItems();
this.initClipboardItems();
this.initMetadataItems();
},
initOpenItems : function () {
// this.showItem( "context-openlink", this.onSaveableLink || ( this.inDirList && this.onLink ) );
this.showItem( "context-openlinkintab", this.onSaveableLink || ( this.inDirList && this.onLink ) );
this.showItem( "context-sep-open", this.onSaveableLink || ( this.inDirList && this.onLink ) );
},
initNavigationItems : function () {
// Back determined by canGoBack broadcaster.
this.setItemAttrFromNode( "context-back", "disabled", "canGoBack" );
// Forward determined by canGoForward broadcaster.
this.setItemAttrFromNode( "context-forward", "disabled", "canGoForward" );
this.showItem( "context-back", !( this.isTextSelected || this.onLink || this.onImage || this.onTextInput ) );
this.showItem( "context-forward", !( this.isTextSelected || this.onLink || this.onImage || this.onTextInput ) );
this.showItem( "context-reload", !( this.isTextSelected || this.onLink || this.onImage || this.onTextInput ) );
this.showItem( "context-stop", !( this.isTextSelected || this.onLink || this.onImage || this.onTextInput ) );
this.showItem( "context-sep-stop", !( this.isTextSelected || this.onLink || this.onImage || this.onTextInput ) );
// XXX: Stop is determined in navigator.js; the canStop broadcaster is broken
//this.setItemAttrFromNode( "context-stop", "disabled", "canStop" );
},
initSaveItems : function () {
this.showItem( "context-savepage", !( this.inDirList || this.isTextSelected || this.onTextInput ) && !( this.onLink && this.onImage ) );
// Save link depends on whether we're in a link.
this.showItem( "context-savelink", this.onSaveableLink );
// Save image depends on whether there is one.
this.showItem( "context-saveimage", this.onLoadedImage );
this.showItem( "context-sendimage", this.onImage );
},
initViewItems : function () {
// View source is always OK, unless in directory listing.
this.showItem( "context-viewpartialsource-selection", this.isTextSelected && !this.onTextInput );
this.showItem( "context-viewpartialsource-mathml", this.onMathML && !this.isTextSelected );
this.showItem( "context-viewsource", !( this.inDirList || this.onImage || this.isTextSelected || this.onLink || this.onTextInput ) );
this.showItem( "context-viewinfo", !( this.inDirList || this.onImage || this.isTextSelected || this.onLink || this.onTextInput ) );
this.showItem( "context-sep-properties", !( this.inDirList || this.isTextSelected || this.onTextInput ) );
// Set As Wallpaper depends on whether an image was clicked on, and only works on Windows.
var isWin = navigator.appVersion.indexOf("Windows") != -1;
this.showItem( "context-setWallpaper", isWin && this.onLoadedImage );
this.showItem( "context-sep-image", this.onImage );
if( isWin && this.onLoadedImage )
// Disable the Set As Wallpaper menu item if we're still trying to load the image
this.setItemAttr( "context-setWallpaper", "disabled", (("complete" in this.target) && !this.target.complete) ? "true" : null );
this.showItem( "context-fitimage", this.onStandaloneImage && _content.document.imageResizingEnabled );
if ( this.onStandaloneImage && _content.document.imageResizingEnabled ) {
this.setItemAttr( "context-fitimage", "disabled", _content.document.imageIsOverflowing ? null : "true");
this.setItemAttr( "context-fitimage", "checked", _content.document.imageIsResized ? "true" : null);
}
// View Image depends on whether an image was clicked on.
this.showItem( "context-viewimage", this.onImage && !this.onStandaloneImage);
// View background image depends on whether there is one.
this.showItem( "context-viewbgimage", !( this.inDirList || this.onImage || this.isTextSelected || this.onLink || this.onTextInput ) );
this.showItem( "context-sep-viewbgimage", !( this.inDirList || this.onImage || this.isTextSelected || this.onLink || this.onTextInput ) );
this.setItemAttr( "context-viewbgimage", "disabled", this.hasBGImage ? null : "true");
},
initMiscItems : function () {
// Use "Bookmark This Link" if on a link.
this.showItem( "context-bookmarkpage", !( this.isTextSelected || this.onTextInput ) );
this.showItem( "context-bookmarklink", this.onLink && !this.onMailtoLink );
this.showItem( "context-searchselect", this.isTextSelected && !this.onTextInput );
this.showItem( "frame", this.inFrame );
this.showItem( "frame-sep", this.inFrame );
var blocking = true;
if (this.popupURL)
try {
const PM = Components.classes["@mozilla.org/PopupWindowManager;1"]
.getService(Components.interfaces.nsIPopupWindowManager);
blocking = PM.testPermission(this.popupURL) ==
Components.interfaces.nsIPopupWindowManager.DENY_POPUP;
} catch (e) {
}
this.showItem( "popupwindow-reject", this.popupURL && !blocking);
this.showItem( "popupwindow-allow", this.popupURL && blocking);
this.showItem( "context-sep-popup", this.popupURL);
},
initClipboardItems : function () {
// Copy depends on whether there is selected text.
// Enabling this context menu item is now done through the global
// command updating system
// this.setItemAttr( "context-copy", "disabled", !this.isTextSelected() );
goUpdateGlobalEditMenuItems();
this.showItem( "context-undo", this.onTextInput );
this.showItem( "context-redo", this.onTextInput );
this.showItem( "context-sep-undo", this.onTextInput );
this.showItem( "context-cut", this.onTextInput );
this.showItem( "context-copy", this.isTextSelected || this.onTextInput);
this.showItem( "context-paste", this.onTextInput );
this.showItem( "context-delete", this.onTextInput );
this.showItem( "context-sep-paste", this.onTextInput );
this.showItem( "context-selectall", true );
this.showItem( "context-sep-selectall", this.isTextSelected && !this.onTextInput );
// In a text area there will be nothing after select all, so we don't want a sep
// Otherwise, if there's text selected then there are extra menu items
// (search for selection and view selection source), so we do want a sep
// XXX dr
// ------
// nsDocumentViewer.cpp has code to determine whether we're
// on a link or an image. we really ought to be using that...
// Copy email link depends on whether we're on an email link.
this.showItem( "context-copyemail", this.onMailtoLink );
// Copy link location depends on whether we're on a link.
this.showItem( "context-copylink", this.onLink );
this.showItem( "context-sep-copylink", this.onLink );
// Copy image location depends on whether we're on an image.
this.showItem( "context-copyimage", this.onImage );
this.showItem( "context-sep-copyimage", this.onImage );
},
initMetadataItems : function () {
// Show if user clicked on something which has metadata.
this.showItem( "context-metadata", this.onMetaDataItem );
},
// Set various context menu attributes based on the state of the world.
setTarget : function ( node ) {
const xulNS = "http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul";
if ( node.namespaceURI == xulNS ) {
this.shouldDisplay = false;
return;
}
// Initialize contextual info.
this.onImage = false;
this.onLoadedImage = false;
this.onStandaloneImage = false;
this.onMetaDataItem = false;
this.onTextInput = false;
this.imageURL = "";
this.onLink = false;
this.onMathML = false;
this.inFrame = false;
this.hasBGImage = false;
this.bgImageURL = "";
// Remember the node that was clicked.
this.target = node;
// See if the user clicked on an image.
if ( this.target.nodeType == Node.ELEMENT_NODE ) {
if ( this.target instanceof Components.interfaces.nsIImageLoadingContent && this.target.currentURI ) {
this.onImage = true;
var request = this.target.getRequest( Components.interfaces.nsIImageLoadingContent.CURRENT_REQUEST );
if (request && (request.imageStatus & request.STATUS_SIZE_AVAILABLE))
this.onLoadedImage = true;
this.imageURL = this.target.currentURI.spec;
if ( this.target.ownerDocument instanceof ImageDocument )
this.onStandaloneImage = true;
} else if ( this.target instanceof HTMLInputElement) {
type = this.target.getAttribute("type");
this.onTextInput = this.isTargetATextBox(this.target);
} else if ( this.target instanceof HTMLTextAreaElement ) {
this.onTextInput = true;
} else if ( this.target instanceof HTMLHtmlElement ) {
// pages with multiple s are lame. we'll teach them a lesson.
var bodyElt = this.target.ownerDocument.getElementsByTagName("body")[0];
if ( bodyElt ) {
var computedURL = this.getComputedURL( bodyElt, "background-image" );
if ( computedURL ) {
this.hasBGImage = true;
this.bgImageURL = this.makeURLAbsolute( bodyElt.baseURI,
computedURL );
}
}
} else if ( "HTTPIndex" in _content &&
_content.HTTPIndex instanceof Components.interfaces.nsIHTTPIndex ) {
this.inDirList = true;
// Bubble outward till we get to an element with URL attribute
// (which should be the href).
var root = this.target;
while ( root && !this.link ) {
if ( root.tagName == "tree" ) {
// Hit root of tree; must have clicked in empty space;
// thus, no link.
break;
}
if ( root.getAttribute( "URL" ) ) {
// Build pseudo link object so link-related functions work.
this.onLink = true;
this.link = { href : root.getAttribute("URL"),
getAttribute: function (attr) {
if (attr == "title") {
return root.firstChild.firstChild.getAttribute("label");
} else {
return "";
}
}
};
// If element is a directory, then you can't save it.
if ( root.getAttribute( "container" ) == "true" ) {
this.onSaveableLink = false;
} else {
this.onSaveableLink = true;
}
} else {
root = root.parentNode;
}
}
}
}
// We have meta data on images.
this.onMetaDataItem = this.onImage;
// See if the user clicked on MathML
const NS_MathML = "http://www.w3.org/1998/Math/MathML";
if ((this.target.nodeType == Node.TEXT_NODE &&
this.target.parentNode.namespaceURI == NS_MathML)
|| (this.target.namespaceURI == NS_MathML))
this.onMathML = true;
// See if the user clicked in a frame.
if ( this.target.ownerDocument != window._content.document ) {
this.inFrame = true;
}
// Bubble out, looking for items of interest
var elem = this.target;
while ( elem ) {
if ( elem.nodeType == Node.ELEMENT_NODE ) {
// Link?
if ( !this.onLink &&
( (elem instanceof HTMLAnchorElement && elem.href) ||
elem instanceof HTMLAreaElement ||
elem instanceof HTMLLinkElement ||
elem.getAttributeNS( "http://www.w3.org/1999/xlink", "type") == "simple" ) ) {
// Clicked on a link.
this.onLink = true;
this.onMetaDataItem = true;
// Remember corresponding element.
this.link = elem;
this.onMailtoLink = this.isLinkType( "mailto:", this.link );
// Remember if it is saveable.
this.onSaveableLink = this.isLinkSaveable( this.link );
}
// Text input?
if ( !this.onTextInput ) {
// Clicked on a link.
this.onTextInput = this.isTargetATextBox(elem);
}
// Metadata item?
if ( !this.onMetaDataItem ) {
// We currently display metadata on anything which fits
// the below test.
if ( ( elem instanceof HTMLQuoteElement && elem.cite) ||
( elem instanceof HTMLTableElement && elem.summary) ||
( elem instanceof HTMLModElement &&
( elem.cite || elem.dateTime ) ) ||
( elem instanceof HTMLElement &&
( elem.title || elem.lang ) ) ) {
this.onMetaDataItem = true;
}
}
// Background image? Don't bother if we've already found a
// background image further down the hierarchy. Otherwise,
// we look for the computed background-image style.
if ( !this.hasBGImage ) {
var bgImgUrl = this.getComputedURL( elem, "background-image" );
if ( bgImgUrl ) {
this.hasBGImage = true;
this.bgImageURL = this.makeURLAbsolute( elem.baseURI,
bgImgUrl );
}
}
}
elem = elem.parentNode;
}
},
initPopupURL: function() {
// quick check: if no opener, it can't be a popup
if (!window.content.opener)
return;
try {
var show = false;
// is it a popup window?
const CI = Components.interfaces;
var xulwin = window
.QueryInterface(CI.nsIInterfaceRequestor)
.getInterface(CI.nsIWebNavigation)
.QueryInterface(CI.nsIDocShellTreeItem)
.treeOwner
.QueryInterface(CI.nsIInterfaceRequestor)
.getInterface(CI.nsIXULWindow);
if (xulwin.contextFlags &
CI.nsIWindowCreator2.PARENT_IS_LOADING_OR_RUNNING_TIMEOUT) {
// do the pref settings allow site-by-site popup management?
const PB = Components.classes["@mozilla.org/preferences-service;1"]
.getService(CI.nsIPrefBranch);
show = !PB.getBoolPref("dom.disable_open_during_load");
}
if (show) {
// initialize popupURL
const IOS = Components.classes["@mozilla.org/network/io-service;1"]
.getService(CI.nsIIOService);
var spec = Components.lookupMethod(window.content.opener, "location")
.call();
this.popupURL = IOS.newURI(spec, null, null);
// but cancel if it's an unsuitable URL
const PM = Components.classes["@mozilla.org/PopupWindowManager;1"]
.getService(CI.nsIPopupWindowManager);
}
} catch(e) {
}
},
// Returns the computed style attribute for the given element.
getComputedStyle: function( elem, prop ) {
return elem.ownerDocument.defaultView.getComputedStyle( elem, '' ).getPropertyValue( prop );
},
// Returns a "url"-type computed style attribute value, with the url() stripped.
getComputedURL: function( elem, prop ) {
var url = elem.ownerDocument.defaultView.getComputedStyle( elem, '' ).getPropertyCSSValue( prop );
return ( url.primitiveType == CSSPrimitiveValue.CSS_URI ) ? url.getStringValue() : null;
},
// Returns true iff clicked on link is saveable.
isLinkSaveable : function ( link ) {
// We don't do the Right Thing for news/snews yet, so turn them off
// until we do.
return !(this.isLinkType( "mailto:" , link ) ||
this.isLinkType( "javascript:" , link ) ||
this.isLinkType( "news:", link ) ||
this.isLinkType( "snews:", link ) );
},
// Returns true iff clicked on link is of type given.
isLinkType : function ( linktype, link ) {
try {
// Test for missing protocol property.
if ( !link.protocol ) {
// We must resort to testing the URL string :-(.
var protocol;
if ( link.href ) {
protocol = link.href.substr( 0, linktype.length );
} else {
protocol = link.getAttributeNS("http://www.w3.org/1999/xlink","href");
if ( protocol ) {
protocol = protocol.substr( 0, linktype.length );
}
}
return protocol.toLowerCase() === linktype;
} else {
// Presume all but javascript: urls are saveable.
return link.protocol.toLowerCase() === linktype;
}
} catch (e) {
// something was wrong with the link,
// so we won't be able to save it anyway
return false;
}
},
// Block popup windows
rejectPopupWindows: function(andClose) {
const PM = Components.classes["@mozilla.org/PopupWindowManager;1"]
.getService(Components.interfaces.nsIPopupWindowManager);
PM.add(this.popupURL, false);
if (andClose) {
const OS = Components.classes["@mozilla.org/observer-service;1"]
.getService(Components.interfaces.nsIObserverService);
OS.notifyObservers(window, "popup-perm-close", this.popupURL.spec);
}
},
// Unblock popup windows
allowPopupWindows: function() {
const PM = Components.classes["@mozilla.org/PopupWindowManager;1"]
.getService(Components.interfaces.nsIPopupWindowManager);
PM.add(this.popupURL, true);
},
// Reload clicked-in frame.
reloadFrame : function () {
this.target.ownerDocument.location.reload();
},
// Open clicked-in frame in its own window.
openFrame : function () {
openNewWindowWith( this.target.ownerDocument.location.href );
},
// Open clicked-in frame in the same window
showOnlyThisFrame : function () {
window.loadURI(this.target.ownerDocument.location.href);
},
// View Partial Source
viewPartialSource : function ( context ) {
var focusedWindow = document.commandDispatcher.focusedWindow;
if (focusedWindow == window)
focusedWindow = _content;
var docCharset = null;
if (focusedWindow)
docCharset = "charset=" + focusedWindow.document.characterSet;
// "View Selection Source" and others such as "View MathML Source"
// are mutually exclusive, with the precedence given to the selection
// when there is one
var reference = null;
if (context == "selection")
reference = focusedWindow.getSelection();
else if (context == "mathml")
reference = this.target;
else
throw "not reached";
var docUrl = null; // unused (and play nice for fragments generated via XSLT too)
window.openDialog("chrome://navigator/content/viewPartialSource.xul",
"_blank", "scrollbars,resizable,chrome,dialog=no",
docUrl, docCharset, reference, context);
},
// Open new "view source" window with the frame's URL.
viewFrameSource : function () {
BrowserViewSourceOfDocument(this.target.ownerDocument);
},
viewInfo : function () {
BrowserPageInfo();
},
viewFrameInfo : function () {
BrowserPageInfo(this.target.ownerDocument);
},
toggleImageSize : function () {
_content.document.toggleImageSize();
},
// Change current window to the URL of the image.
viewImage : function () {
// we don't really want to open the url in a top level window because we don't have a
// browser window...for now do nothing
},
// Change current window to the URL of the background image.
viewBGImage : function () {
openTopWin( this.bgImageURL );
},
setWallpaper: function() {
var winhooks = Components.classes[ "@mozilla.org/winhooks;1" ].
getService(Components.interfaces.nsIWindowsHooks);
winhooks.setImageAsWallpaper(this.target, false);
},
// Save URL of clicked-on frame.
saveFrame : function () {
saveDocument( this.target.ownerDocument );
},
// Save URL of clicked-on link.
saveLink : function () {
saveURL( this.linkURL(), this.linkText(), null, true );
},
// Save URL of clicked-on image.
saveImage : function () {
saveURL( this.imageURL, null, "SaveImageTitle", false );
},
// Generate email address and put it on clipboard.
copyEmail : function () {
// Copy the comma-separated list of email addresses only.
// There are other ways of embedding email addresses in a mailto:
// link, but such complex parsing is beyond us.
const kMailToLength = 7; // length of "mailto:"
var url = this.linkURL();
var qmark = url.indexOf( "?" );
var addresses;
if ( qmark > kMailToLength ) {
addresses = url.substring( kMailToLength, qmark );
} else {
addresses = url.substr( kMailToLength );
}
// Let's try to unescape it using a character set
try {
var ownerDocument = new XPCNativeWrapper(this.target, "ownerDocument").ownerDocument;
var characterSet = new XPCNativeWrapper(ownerDocument, "characterSet").characterSet;
const textToSubURI = Components.classes["@mozilla.org/intl/texttosuburi;1"]
.getService(Components.interfaces.nsITextToSubURI);
addresses = textToSubURI.unEscapeURIForUI(characterSet, addresses);
}
catch(ex) {
// Do nothing.
}
var clipboard = this.getService( "@mozilla.org/widget/clipboardhelper;1",
Components.interfaces.nsIClipboardHelper );
clipboard.copyString(addresses);
},
///////////////
// Utilities //
///////////////
// Create instance of component given contractId and iid (as string).
createInstance : function ( contractId, iidName ) {
var iid = Components.interfaces[ iidName ];
return Components.classes[ contractId ].createInstance( iid );
},
// Get service given contractId and iid (as string).
getService : function ( contractId, iidName ) {
var iid = Components.interfaces[ iidName ];
return Components.classes[ contractId ].getService( iid );
},
// Show/hide one item (specified via name or the item element itself).
showItem : function ( itemOrId, show ) {
var item = itemOrId.constructor == String ? document.getElementById(itemOrId) : itemOrId;
if (item)
item.hidden = !show;
},
// Set given attribute of specified context-menu item. If the
// value is null, then it removes the attribute (which works
// nicely for the disabled attribute).
setItemAttr : function ( id, attr, val ) {
var elem = document.getElementById( id );
if ( elem ) {
if ( val == null ) {
// null indicates attr should be removed.
elem.removeAttribute( attr );
} else {
// Set attr=val.
elem.setAttribute( attr, val );
}
}
},
// Set context menu attribute according to like attribute of another node
// (such as a broadcaster).
setItemAttrFromNode : function ( item_id, attr, other_id ) {
var elem = document.getElementById( other_id );
if ( elem && elem.getAttribute( attr ) == "true" ) {
this.setItemAttr( item_id, attr, "true" );
} else {
this.setItemAttr( item_id, attr, null );
}
},
// Temporary workaround for DOM api not yet implemented by XUL nodes.
cloneNode : function ( item ) {
// Create another element like the one we're cloning.
var node = document.createElement( item.tagName );
// Copy attributes from argument item to the new one.
var attrs = item.attributes;
for ( var i = 0; i < attrs.length; i++ ) {
var attr = attrs.item( i );
node.setAttribute( attr.nodeName, attr.nodeValue );
}
// Voila!
return node;
},
// Generate fully-qualified URL for clicked-on link.
linkURL : function () {
if (this.link.href) {
return this.link.href;
}
var href = this.link.getAttributeNS("http://www.w3.org/1999/xlink","href");
if (!href || !href.match(/\S/)) {
throw "Empty href"; // Without this we try to save as the current doc, for example, HTML case also throws if empty
}
href = this.makeURLAbsolute(this.link.baseURI,href);
return href;
},
// Get text of link.
linkText : function () {
var text = gatherTextUnder( this.link );
if (!text || !text.match(/\S/)) {
text = this.link.getAttribute("title");
if (!text || !text.match(/\S/)) {
text = this.link.getAttribute("alt");
if (!text || !text.match(/\S/)) {
if (this.link.href) {
text = this.link.href;
} else {
text = getAttributeNS("http://www.w3.org/1999/xlink", "href");
if (text && text.match(/\S/)) {
text = this.makeURLAbsolute(this.link.baseURI, text);
}
}
}
}
}
return text;
},
//Get selected object and convert it to a string to get
//selected text. Only use the first 15 chars.
isTextSelection : function() {
var result = false;
var selection = this.searchSelected();
var bundle = srGetStrBundle("chrome://communicator/locale/contentAreaCommands.properties");
var searchSelectText;
if (selection != "") {
searchSelectText = selection.toString();
if (searchSelectText.length > 15)
searchSelectText = searchSelectText.substr(0,15) + "...";
result = true;
// format "Search for " string to show in menu
searchSelectText = bundle.formatStringFromName("searchText",
[searchSelectText], 1);
this.setItemAttr("context-searchselect", "label", searchSelectText);
}
return result;
},
searchSelected : function() {
var focusedWindow = document.commandDispatcher.focusedWindow;
var searchStr = focusedWindow.getSelection();;
searchStr = searchStr.toString();
searchStr = searchStr.replace( /^\s+/, "" );
searchStr = searchStr.replace(/(\n|\r|\t)+/g, " ");
searchStr = searchStr.replace(/\s+$/,"");
return searchStr;
},
// Convert relative URL to absolute, using document's .
makeURLAbsolute : function ( base, url ) {
// Construct nsIURL.
var ioService = Components.classes["@mozilla.org/network/io-service;1"]
.getService(Components.interfaces.nsIIOService);
var baseURI = ioService.newURI(base, null, null);
return ioService.newURI(baseURI.resolve(url), null, null).spec;
},
toString : function () {
return "contextMenu.target = " + this.target + "\n" +
"contextMenu.onImage = " + this.onImage + "\n" +
"contextMenu.onLink = " + this.onLink + "\n" +
"contextMenu.link = " + this.link + "\n" +
"contextMenu.inFrame = " + this.inFrame + "\n" +
"contextMenu.hasBGImage = " + this.hasBGImage + "\n";
},
isTargetATextBox : function ( node )
{
if (node instanceof HTMLInputElement)
return (node.type == "text" || node.type == "password")
return (node instanceof HTMLTextAreaElement);
},
// Determines whether or not the separator with the specified ID should be
// shown or not by determining if there are any non-hidden items between it
// and the previous separator.
shouldShowSeparator : function ( aSeparatorID )
{
var separator = document.getElementById(aSeparatorID);
if (separator) {
var sibling = separator.previousSibling;
while (sibling && sibling.localName != "menuseparator") {
if (sibling.getAttribute("hidden") != "true")
return true;
sibling = sibling.previousSibling;
}
}
return false;
}
};
PK
hN0XS ( content/communicator/viewZoomOverlay.xul
PK
hN0 $ $ ' content/communicator/viewZoomOverlay.js/* -*- Mode: Java; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
* ***** BEGIN LICENSE BLOCK *****
* Version: MPL 1.1/GPL 2.0/LGPL 2.1
*
* The contents of this file are subject to the Mozilla Public License Version
* 1.1 (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
* http://www.mozilla.org/MPL/
*
* Software distributed under the License is distributed on an "AS IS" basis,
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
* for the specific language governing rights and limitations under the
* License.
*
* The Original Code is this file as it was released upon January 6, 2001.
*
* The Initial Developer of the Original Code is
* Peter Annema.
* Portions created by the Initial Developer are Copyright (C) 2000
* the Initial Developer. All Rights Reserved.
*
* Contributor(s):
* Peter Annema (Original Author)
* Jonas Sicking
*
* Alternatively, the contents of this file may be used under the terms of
* either of the GNU General Public License Version 2 or later (the "GPL"),
* or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
* 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 MPL, 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 MPL, the GPL or the LGPL.
*
* ***** END LICENSE BLOCK ***** */
/** Document Zoom Management Code
*
* To use this, you'll need to have a
* and a getMarkupDocumentViewer() function which returns a
* nsIMarkupDocumentViewer.
*
**/
function ZoomManager() {
this.bundle = document.getElementById("bundle_viewZoom");
// factorAnchor starts on factorOther
this.factorOther = parseInt(this.bundle.getString("valueOther"));
this.factorAnchor = this.factorOther;
}
ZoomManager.prototype = {
instance : null,
getInstance : function() {
if (!ZoomManager.prototype.instance)
ZoomManager.prototype.instance = new ZoomManager();
return ZoomManager.prototype.instance;
},
MIN : 1,
MAX : 2000,
bundle : null,
zoomFactorsString : "", // cache
zoomFactors : null,
factorOther : 300,
factorAnchor : 300,
steps : 0,
get textZoom() {
var currentZoom;
try {
currentZoom = Math.round(getMarkupDocumentViewer().textZoom * 100);
if (this.indexOf(currentZoom) == -1) {
if (currentZoom != this.factorOther) {
this.factorOther = currentZoom;
this.factorAnchor = this.factorOther;
}
}
} catch (e) {
currentZoom = 100;
}
return currentZoom;
},
set textZoom(aZoom) {
if (aZoom < this.MIN || aZoom > this.MAX)
throw Components.results.NS_ERROR_INVALID_ARG;
getMarkupDocumentViewer().textZoom = aZoom / 100;
},
enlarge : function() {
this.jump(1);
},
reduce : function() {
this.jump(-1);
},
reset : function() {
this.textZoom = 100;
},
getZoomFactors : function() {
this.ensureZoomFactors();
return this.zoomFactors;
},
indexOf : function(aZoom) {
this.ensureZoomFactors();
var index = -1;
if (this.isZoomInRange(aZoom)) {
index = this.zoomFactors.length - 1;
while (index >= 0 && this.zoomFactors[index] != aZoom)
--index;
}
return index;
},
/***** internal helper functions below here *****/
ensureZoomFactors : function() {
var zoomFactorsString = this.bundle.getString("values");
if (this.zoomFactorsString != zoomFactorsString) {
this.zoomFactorsString = zoomFactorsString;
this.zoomFactors = zoomFactorsString.split(",");
for (var i = 0; i= 0 && aLevel < this.zoomFactors.length);
},
isZoomInRange : function(aZoom) {
return (aZoom >= this.zoomFactors[0] && aZoom <= this.zoomFactors[this.zoomFactors.length - 1]);
},
jump : function(aDirection) {
if (aDirection != -1 && aDirection != 1)
throw Components.results.NS_ERROR_INVALID_ARG;
this.ensureZoomFactors();
var currentZoom = this.textZoom;
var insertIndex = -1;
var stepFactor = parseFloat(this.bundle.getString("stepFactor"));
// temporarily add factorOther to list
if (this.isZoomInRange(this.factorOther)) {
insertIndex = 0;
while (this.zoomFactors[insertIndex] < this.factorOther)
++insertIndex;
if (this.zoomFactors[insertIndex] != this.factorOther)
this.zoomFactors.splice(insertIndex, 0, this.factorOther);
}
var factor;
var done = false;
if (this.isZoomInRange(currentZoom)) {
var index = this.indexOf(currentZoom);
if (aDirection == -1 && index == 0 ||
aDirection == 1 && index == this.zoomFactors.length - 1) {
this.steps = 0;
this.factorAnchor = this.zoomFactors[index];
} else {
factor = this.zoomFactors[index + aDirection];
done = true;
}
}
if (!done) {
this.steps += aDirection;
factor = this.factorAnchor * Math.pow(stepFactor, this.steps);
if (factor < this.MIN || factor > this.MAX) {
this.steps -= aDirection;
factor = this.factorAnchor * Math.pow(stepFactor, this.steps);
}
factor = Math.round(factor);
if (this.isZoomInRange(factor))
factor = this.snap(factor);
else
this.factorOther = factor;
}
if (insertIndex != -1)
this.zoomFactors.splice(insertIndex, 1);
this.textZoom = factor;
},
snap : function(aZoom) {
if (this.isZoomInRange(aZoom)) {
var level = 0;
while (this.zoomFactors[level + 1] < aZoom)
++level;
// if aZoom closer to [level + 1] than [level], snap to [level + 1]
if ((this.zoomFactors[level + 1] - aZoom) < (aZoom - this.zoomFactors[level]))
++level;
aZoom = this.zoomFactors[level];
}
return aZoom;
}
}
/***** init and helper functions for viewZoomOverlay.xul *****/
window.addEventListener("load", registerZoomManager, false);
function registerZoomManager()
{
var textZoomMenu = document.getElementById("menu_textZoom");
var zoom = ZoomManager.prototype.getInstance();
var parentMenu = textZoomMenu.parentNode;
parentMenu.addEventListener("popupshowing", updateViewMenu, false);
var insertBefore = document.getElementById("menu_textZoomInsertBefore");
var popup = insertBefore.parentNode;
var accessKeys = zoom.bundle.getString("accessKeys").split(",");
var zoomFactors = zoom.getZoomFactors();
for (var i = 0; i < zoomFactors.length; ++i) {
var menuItem = document.createElement("menuitem");
menuItem.setAttribute("type", "radio");
menuItem.setAttribute("name", "textZoom");
var label;
if (zoomFactors[i] == 100) {
label = zoom.bundle.getString("labelOriginal");
menuItem.setAttribute("key", "key_textZoomReset");
}
else
label = zoom.bundle.getString("label");
menuItem.setAttribute("label", label.replace(/%zoom%/, zoomFactors[i]));
menuItem.setAttribute("accesskey", accessKeys[i]);
menuItem.setAttribute("oncommand", "ZoomManager.prototype.getInstance().textZoom = this.value;");
menuItem.setAttribute("value", zoomFactors[i]);
popup.insertBefore(menuItem, insertBefore);
}
}
function updateViewMenu()
{
var zoom = ZoomManager.prototype.getInstance();
var textZoomMenu = document.getElementById("menu_textZoom");
var menuLabel = zoom.bundle.getString("menuLabel").replace(/%zoom%/, zoom.textZoom);
textZoomMenu.setAttribute("label", menuLabel);
}
function updateTextZoomMenu()
{
var zoom = ZoomManager.prototype.getInstance();
var currentZoom = zoom.textZoom;
var textZoomOther = document.getElementById("menu_textZoomOther");
var label = zoom.bundle.getString("labelOther");
textZoomOther.setAttribute("label", label.replace(/%zoom%/, zoom.factorOther));
textZoomOther.setAttribute("value", zoom.factorOther);
var popup = document.getElementById("menu_textZoomPopup");
var item = popup.firstChild;
while (item) {
if (item.getAttribute("name") == "textZoom") {
if (item.getAttribute("value") == currentZoom)
item.setAttribute("checked","true");
else
item.removeAttribute("checked");
}
item = item.nextSibling;
}
}
function setTextZoomOther()
{
var zoom = ZoomManager.prototype.getInstance();
// open dialog and ask for new value
var o = {value: zoom.factorOther, zoomMin: zoom.MIN, zoomMax: zoom.MAX};
window.openDialog("chrome://communicator/content/askViewZoom.xul", "AskViewZoom", "chrome,modal,titlebar", o);
if (o.zoomOK)
zoom.textZoom = o.value;
}
PK
hN0-Z $ content/communicator/askViewZoom.xul
PK
hN0qy
y
# content/communicator/askViewZoom.js/* -*- Mode: Java; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
* ***** BEGIN LICENSE BLOCK *****
* Version: MPL 1.1/GPL 2.0/LGPL 2.1
*
* The contents of this file are subject to the Mozilla Public License Version
* 1.1 (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
* http://www.mozilla.org/MPL/
*
* Software distributed under the License is distributed on an "AS IS" basis,
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
* for the specific language governing rights and limitations under the
* License.
*
* The Original Code is this file as it was released upon September 7, 2000.
*
* The Initial Developer of the Original Code is
* Peter Annema.
* Portions created by the Initial Developer are Copyright (C) 2000
* the Initial Developer. All Rights Reserved.
*
* Contributor(s):
* Peter Annema (Original Author)
*
* Alternatively, the contents of this file may be used under the terms of
* either of the GNU General Public License Version 2 or later (the "GPL"),
* or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
* 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 MPL, 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 MPL, the GPL or the LGPL.
*
* ***** END LICENSE BLOCK ***** */
var dialog;
var args;
function onLoad() {
args = window.arguments[0];
args.zoomOK = false;
dialog = {};
dialog.OKButton = document.documentElement.getButton("accept");
dialog.input = document.getElementById("zoomValue");
dialog.input.value = args.value;
dialog.input.select();
dialog.input.focus();
moveToAlertPosition();
doEnabling();
}
function onAccept() {
var zoom = parseFloat(dialog.input.value);
if (!isNaN(zoom) && zoom >= args.zoomMin && zoom <= args.zoomMax) {
args.value = zoom;
args.zoomOK = true;
}
return args.zoomOK;
}
function doEnabling() {
var enable = false;
if (dialog.input.value) {
var zoom = parseFloat(dialog.input.value);
if (!isNaN(zoom) && zoom >= args.zoomMin && zoom <= args.zoomMax)
enable = true;
}
dialog.OKButton.disabled = !enable;
}
PK
<0άnS S ! content/communicator/findUtils.js/* -*- Mode: Java; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* ***** BEGIN LICENSE BLOCK *****
* Version: MPL 1.1/GPL 2.0/LGPL 2.1
*
* The contents of this file are subject to the Mozilla Public License Version
* 1.1 (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
* http://www.mozilla.org/MPL/
*
* Software distributed under the License is distributed on an "AS IS" basis,
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
* for the specific language governing rights and limitations under the
* License.
*
* The Original Code is mozilla.org code.
*
* 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.
*
* Contributor(s):
* Simon Fraser
* Dean Tessman
*
* Alternatively, the contents of this file may be used under the terms of
* either of the GNU General Public License Version 2 or later (the "GPL"),
* or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
* 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 MPL, 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 MPL, the GPL or the LGPL.
*
* ***** END LICENSE BLOCK ***** */
var gPromptService;
var gFindBundle;
function nsFindInstData() {}
nsFindInstData.prototype =
{
// set the next three attributes on your object to override the defaults
browser : null,
get rootSearchWindow() { return this._root || this.window.content; },
set rootSearchWindow(val) { this._root = val; },
get currentSearchWindow() {
if (this._current)
return this._current;
var focusedWindow = this.window.document.commandDispatcher.focusedWindow;
if (!focusedWindow || focusedWindow == this.window)
focusedWindow = this.window.content;
return focusedWindow;
},
set currentSearchWindow(val) { this._current = val; },
get webBrowserFind() { return this.browser.webBrowserFind; },
init : function() {
var findInst = this.webBrowserFind;
// set up the find to search the focussedWindow, bounded by the content window.
var findInFrames = findInst.QueryInterface(Components.interfaces.nsIWebBrowserFindInFrames);
findInFrames.rootSearchFrame = this.rootSearchWindow;
findInFrames.currentSearchFrame = this.currentSearchWindow;
// always search in frames for now. We could add a checkbox to the dialog for this.
findInst.searchFrames = true;
},
window : window,
_root : null,
_current : null
}
// browser is the element
// rootSearchWindow is the window to constrain the search to (normally window.content)
// currentSearchWindow is the frame to start searching (can be, and normally, rootSearchWindow)
function findInPage(findInstData)
{
// is the dialog up already?
if ("findDialog" in window && window.findDialog)
window.findDialog.focus();
else
{
findInstData.init();
window.findDialog = window.openDialog("chrome://global/content/finddialog.xul", "_blank", "chrome,resizable=no,dependent=yes", findInstData);
}
}
function findAgainInPage(findInstData, reverse)
{
// get the find service, which stores global find state, and init the
// nsIWebBrowser find with it. We don't assume that there was a previous
// Find that set this up.
var findService = Components.classes["@mozilla.org/find/find_service;1"]
.getService(Components.interfaces.nsIFindService);
var searchString = findService.searchString;
if (searchString.length == 0) {
// no previous find text
findInPage(findInstData);
return;
}
findInstData.init();
var findInst = findInstData.webBrowserFind;
findInst.searchString = searchString;
findInst.matchCase = findService.matchCase;
findInst.wrapFind = findService.wrapFind;
findInst.entireWord = findService.entireWord;
findInst.findBackwards = findService.findBackwards ^ reverse;
var found = findInst.findNext();
if (!found) {
if (!gPromptService)
gPromptService = Components.classes["@mozilla.org/embedcomp/prompt-service;1"].getService()
.QueryInterface(Components.interfaces.nsIPromptService);
if (!gFindBundle)
gFindBundle = document.getElementById("findBundle");
gPromptService.alert(window, gFindBundle.getString("notFoundTitle"), gFindBundle.getString("notFoundWarning"));
}
// Reset to normal value, otherwise setting can get changed in find dialog
findInst.findBackwards = findService.findBackwards;
}
function canFindAgainInPage()
{
var findService = Components.classes["@mozilla.org/find/find_service;1"]
.getService(Components.interfaces.nsIFindService);
return (findService.searchString.length > 0);
}
PK
|*4j.oFB FB - content/communicator/printPreviewBindings.xml
false
document.getAnonymousNodes(this)[0]
document.getAnonymousNodes(this)[5].firstChild
document.getAnonymousNodes(this)[5].lastChild
document.getAnonymousNodes(this)[9].firstChild
document.getAnonymousNodes(this)[10].firstChild
document.getAnonymousNodes(this)[12]
this.mOrientButtonsBox.childNodes[0]
this.mOrientButtonsBox.childNodes[1]
document.getAnonymousNodes(this)[15].firstChild
0 && newPageNum <= total)
{
this.mPageTextBox.value = newPageNum;
print.printPreviewNavigate(
print.PRINTPREVIEW_GOTO_PAGENUM, newPageNum);
validInput = true;
}
}
else
{
total = print.printPreviewNumPages;
// bounds check potentially user-entered number
if (aPageNum > 0 && aPageNum <= total)
{
print.printPreviewNavigate(
print.PRINTPREVIEW_GOTO_PAGENUM, aPageNum);
validInput = true;
}
}
if (validInput)
{
// store the valid page number for future use to replace
// the textbox value if erroneous input made it in
this.mPageTextBox.setAttribute(
"lastvalid", this.mPageTextBox.value);
}
else
{
// restore last known valid value in place of erroneous input
this.mPageTextBox.value =
this.mPageTextBox.getAttribute("lastvalid");
}
]]>
= 10) {
aValue /= 100;
} else {
this.mScaleCombobox.selectedIndex = this.mScaleCombobox.getAttribute('lastValidInx');
return;
}
}
this.setScaleCombobox(aValue);
this.mScaleCombobox.setAttribute('lastValidInx', this.mScaleCombobox.selectedIndex);
if (settings.scaling != aValue)
{
settings.shrinkToFit = false;
settings.scaling = aValue;
this.savePrintSettings(settings, settings.kInitSaveShrinkToFit | settings.kInitSaveScaling);
PrintUtils.printPreview();
}
]]>
PK
ye4-_. . content/communicator/printing.js/* -*- Mode: Java; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* ***** BEGIN LICENSE BLOCK *****
* Version: MPL 1.1/GPL 2.0/LGPL 2.1
*
* The contents of this file are subject to the Mozilla Public License Version
* 1.1 (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
* http://www.mozilla.org/MPL/
*
* Software distributed under the License is distributed on an "AS IS" basis,
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
* for the specific language governing rights and limitations under the
* License.
*
* The Original Code is mozilla.org code.
*
* 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.
*
* Contributor(s):
* Blake Ross
* Peter Annema
* Samir Gehani
*
* Alternatively, the contents of this file may be used under the terms of
* either of the GNU General Public License Version 2 or later (the "GPL"),
* or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
* 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 MPL, 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 MPL, the GPL or the LGPL.
*
* ***** END LICENSE BLOCK ***** */
var gPrintSettingsAreGlobal = false;
var gSavePrintSettings = false;
var PrintUtils = {
showPageSetup: function ()
{
try {
var printSettings = this.getPrintSettings();
var printingPromptService = Components.classes["@mozilla.org/embedcomp/printingprompt-service;1"]
.getService(Components.interfaces.nsIPrintingPromptService);
printingPromptService.showPageSetup(window, printSettings, null);
if (gSavePrintSettings) {
// Page Setup data is a "native" setting on the Mac
var printService = Components.classes["@mozilla.org/gfx/printsettings-service;1"]
.getService(Components.interfaces.nsIPrintSettingsService);
printService.savePrintSettingsToPrefs(printSettings, true,
printSettings.kInitSaveNativeData);
}
} catch (e) {
dump("showPageSetup "+e+"\n");
return false;
}
return true;
},
print: function ()
{
var webBrowserPrint = this.getWebBrowserPrint();
var printSettings = this.getPrintSettings();
try {
webBrowserPrint.print(printSettings, null);
if (gPrintSettingsAreGlobal && gSavePrintSettings) {
var printService = Components.classes["@mozilla.org/gfx/printsettings-service;1"]
.getService(Components.interfaces.nsIPrintSettingsService);
printService.savePrintSettingsToPrefs(printSettings, true,
printSettings.kInitSaveAll);
printService.savePrintSettingsToPrefs(printSettings, false,
printSettings.kInitSavePrinterName);
}
} catch (e) {
// Pressing cancel is expressed as an NS_ERROR_ABORT return value,
// causing an exception to be thrown which we catch here.
// Unfortunately this will also consume helpful failures, so add a
// dump("print: "+e+"\n"); // if you need to debug
}
},
printPreview: function (aEnterPPCallback, aExitPPCallback)
{
// if we're already in PP mode, don't set the callbacks; chances
// are they're null because someone is calling printPreview() to
// get us to refresh the display.
var pptoolbar = document.getElementById("print-preview-toolbar");
if (!pptoolbar) {
this._onEnterPP = aEnterPPCallback;
this._onExitPP = aExitPPCallback;
} else {
// collapse the browser - it will be shown in
// onEnterPrintPreview; this forces a reflow which fixes display
// issues in bug 267422.
var browser = getPPBrowser();
if (browser)
browser.collapsed = true;
}
this._webProgressPP = {};
var ppParams = {};
var notifyOnOpen = {};
var webBrowserPrint = this.getWebBrowserPrint();
var 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 it's own thing
var printingPromptService = 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 {
printingPromptService.showProgress(this, webBrowserPrint, printSettings, this._obsPP, false,
this._webProgressPP, ppParams, notifyOnOpen);
if (ppParams.value) {
var webNav = getWebNavigation();
ppParams.value.docTitle = webNav.document.title;
ppParams.value.docURL = webNav.currentURI.spec;
}
// 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();
}
},
getWebBrowserPrint: function ()
{
return getEngineWebBrowserPrint();
},
////////////////////////////////////////
// "private" methods. Don't use them. //
////////////////////////////////////////
setPrinterDefaultsForSelectedPrinter: function (aPrintService, aPrintSettings)
{
if (!aPrintSettings.printerName)
aPrintSettings.printerName = aPrintService.defaultPrinterName;
// First get any defaults from the printer
aPrintService.initPrintSettingsFromPrinter(aPrintSettings.printerName, aPrintSettings);
// now augment them with any values from last time
aPrintService.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 printService = Components.classes["@mozilla.org/gfx/printsettings-service;1"]
.getService(Components.interfaces.nsIPrintSettingsService);
if (gPrintSettingsAreGlobal) {
printSettings = printService.globalPrintSettings;
this.setPrinterDefaultsForSelectedPrinter(printService, printSettings);
} else {
printSettings = printService.newPrintSettings;
}
} catch (e) {
dump("getPrintSettings: "+e+"\n");
}
return printSettings;
},
_chromeState: {},
_closeHandlerPP: null,
_webProgressPP: null,
_onEnterPP: null,
_onExitPP: null,
// 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 ()
{
var webBrowserPrint = this.getWebBrowserPrint();
var printSettings = this.getPrintSettings();
try {
webBrowserPrint.printPreview(printSettings, null, this._webProgressPP.value);
} catch (e) {
// Pressing cancel is expressed as an NS_ERROR_ABORT return value,
// causing an exception to be thrown which we catch here.
// Unfortunately this will also consume helpful failures, so add a
// dump(e); // if you need to debug
return;
}
var printPreviewTB = document.getElementById("print-preview-toolbar");
if (printPreviewTB) {
printPreviewTB.updateToolbar();
var browser = getPPBrowser();
if (browser)
browser.collapsed = false;
return;
}
// 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.setAttribute("id", "print-preview-toolbar");
var navToolbox = getNavToolbox();
navToolbox.parentNode.insertBefore(printPreviewTB, navToolbox);
// 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("keypress", this.onKeyPressPP, true);
// _content.focus();
navToolbox.focus();
// on Enter PP Call back
if (this._onEnterPP) {
this._onEnterPP();
this._onEnterPP = null;
}
},
exitPrintPreview: function ()
{
window.removeEventListener("keypress", this.onKeyPressPP, true);
// restore the old close handler
document.documentElement.setAttribute("onclose", this._closeHandlerPP);
this._closeHandlerPP = null;
var webBrowserPrint = this.getWebBrowserPrint();
webBrowserPrint.exitPrintPreview();
// remove the print preview toolbar
var navToolbox = getNavToolbox();
var printPreviewTB = document.getElementById("print-preview-toolbar");
navToolbox.parentNode.removeChild(printPreviewTB);
// _content.focus();
navToolbox.focus();
// on Exit PP Call back
if (this._onExitPP) {
this._onExitPP();
this._onExitPP = null;
}
},
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;
// ESC and Ctrl-W exits the PP
if (aEvent.keyCode == aEvent.DOM_VK_ESCAPE || isModif &&
(aEvent.charCode == closeKey || aEvent.charCode == closeKey + 32))
PrintUtils.exitPrintPreview();
// cancel shortkeys
if (isModif) {
aEvent.preventDefault();
aEvent.stopPropagation();
}
}
}
function NSPrintSetup()
{
PrintUtils.showPageSetup();
}
function NSPrint()
{
PrintUtils.print();
}
PK
U09 ) content/wallet/walletNavigatorOverlay.xul
PK
nI51uE{ { % content/wallet/walletTasksOverlay.xul
PK
,F ' content/wallet/walletContextOverlay.xul
PK
y0
] % content/wallet/walletPrefsOverlay.xul
PK
nj4=p
content/wallet/pref-wallet.xul
%brandDTD;
%prefWalletDTD;
]>