pjs/browser/base/content/browser.js

4126 строки
136 KiB
JavaScript
Исходник Обычный вид История

# -*- Mode: Java; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
# ***** BEGIN LICENSE BLOCK *****
# Version: NPL 1.1/GPL 2.0/LGPL 2.1
#
# The contents of this file are subject to the Netscape Public License
# Version 1.1 (the "License"); you may not use this file except in
# compliance with the License. You may obtain a copy of the License at
# http://www.mozilla.org/NPL/
#
# 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 <blaker@netscape.com>
# David Hyatt <hyatt@mozilla.org>
# Peter Annema <disttsc@bart.nl>
# Dean Tessman <dean_tessman@hotmail.com>
# Kevin Puetz (puetzk@iastate.edu)
# Ben Goodger <ben@netscape.com>
# Pierre Chanial <chanial@noos.fr>
# Jason Eager <jce2@po.cwru.edu>
# Joe Hewitt <hewitt@netscape.com>
# Alec Flett <alecf@netscape.com>
#
# Alternatively, the contents of this file may be used under the terms of
# either the GNU General Public License Version 2 or later (the "GPL"), or
# the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
# in which case the provisions of the GPL or the LGPL are applicable instead
# of those above. If you wish to allow use of your version of this file only
# under the terms of either the GPL or the LGPL, and not to allow others to
# use your version of this file under the terms of the NPL, indicate your
# decision by deleting the provisions above and replace them with the notice
# and other provisions required by the GPL or the LGPL. If you do not delete
# the provisions above, a recipient may use your version of this file under
# the terms of any one of the NPL, the GPL or the LGPL.
#
# ***** END LICENSE BLOCK *****
2002-08-04 06:53:09 +04:00
2002-10-13 09:23:24 +04:00
const NS_ERROR_MODULE_NETWORK = 2152398848;
const NS_NET_STATUS_READ_FROM = NS_ERROR_MODULE_NETWORK + 8;
const NS_NET_STATUS_WROTE_TO = NS_ERROR_MODULE_NETWORK + 9;
const kXULNS =
"http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul";
2002-10-13 09:23:24 +04:00
2002-10-13 20:28:34 +04:00
const nsIWebNavigation = Components.interfaces.nsIWebNavigation;
2002-10-13 09:23:24 +04:00
const MAX_HISTORY_MENU_ITEMS = 15;
var gRDF = null;
var gGlobalHistory = null;
var gURIFixup = null;
2002-12-07 23:44:19 +03:00
var gReportButton = null;
var gPageThemeButton = null;
var gCharsetMenu = null;
var gLastBrowserCharset = null;
2002-10-14 02:22:38 +04:00
var gPrevCharset = null;
2002-08-04 06:53:09 +04:00
var gURLBar = null;
var gProxyButton = null;
var gProxyFavIcon = null;
var gProxyDeck = null;
var gNavigatorBundle = null;
var gIsLoadingBlank = false;
2002-08-04 06:53:09 +04:00
var gLastValidURLStr = "";
var gLastValidURL = null;
var gHaveUpdatedToolbarState = false;
#ifdef XP_WIN
2002-09-18 23:42:41 +04:00
var gClickSelectsAll = true;
#else
var gClickSelectsAll = true;
#endif
2002-08-04 06:53:09 +04:00
var gIgnoreFocus = false;
var gIgnoreClick = false;
2002-09-20 07:52:36 +04:00
var gToolbarMode = "icons";
var gIconSize = "";
2002-09-29 02:55:58 +04:00
var gMustLoadSidebar = false;
var gProgressMeterPanel = null;
var gProgressCollapseTimer = null;
2002-09-19 00:11:30 +04:00
var gPrefService = null;
2002-08-04 06:53:09 +04:00
var appCore = null;
var gBrowser = null;
// Global variable that holds the nsContextMenu instance.
var gContextMenu = null;
var gChromeState = null; // chrome state before we went into print preview
var gFormHistory = null;
var gFormFillEnabled = true;
2002-08-04 06:53:09 +04:00
/**
* We can avoid adding multiple load event listeners and save some time by adding
* one listener that calls all real handlers.
*/
function loadEventHandlers(event)
{
// Filter out events that are not about the document load we are interested in
if (event.originalTarget == _content.document) {
UpdateBookmarksLastVisitedDate(event);
checkForDirectoryListing();
charsetLoadListener(event);
updatePageTheme();
2002-08-04 06:53:09 +04:00
}
}
/**
* Determine whether or not the content area is displaying a page with frames,
* and if so, toggle the display of the 'save frame as' menu item.
**/
function getContentAreaFrameCount()
{
2002-08-10 06:58:38 +04:00
var saveFrameItem = document.getElementById("menu_saveFrame");
2002-11-05 02:46:43 +03:00
if (!content || !_content.frames.length || !isDocumentFrame(document.commandDispatcher.focusedWindow))
2002-08-04 06:53:09 +04:00
saveFrameItem.setAttribute("hidden", "true");
else
saveFrameItem.removeAttribute("hidden");
}
//////////////////////////////// BOOKMARKS ////////////////////////////////////
function UpdateBookmarksLastVisitedDate(event)
{
var url = getWebNavigation().currentURI.spec;
if (url) {
// if the URL is bookmarked, update its "Last Visited" date
2002-09-13 07:15:57 +04:00
BMSVC.updateLastVisitedDate(url, _content.document.characterSet);
2002-08-04 06:53:09 +04:00
}
}
function HandleBookmarkIcon(iconURL, addFlag)
{
var url = getWebNavigation().currentURI.spec
if (url) {
// update URL with new icon reference
2002-09-13 07:15:57 +04:00
if (addFlag)
BMSVC.updateBookmarkIcon(url, iconURL);
else
BMSVC.removeBookmarkIcon(url, iconURL);
2002-08-04 06:53:09 +04:00
}
}
function UpdateBackForwardButtons()
{
2002-08-09 05:41:39 +04:00
var backBroadcaster = document.getElementById("Browser:Back");
var forwardBroadcaster = document.getElementById("Browser:Forward");
2002-11-02 03:32:53 +03:00
var webNavigation = gBrowser.webNavigation;
2002-08-04 06:53:09 +04:00
// Avoid setting attributes on broadcasters if the value hasn't changed!
// Remember, guys, setting attributes on elements is expensive! They
// get inherited into anonymous content, broadcast to other widgets, etc.!
// Don't do it if the value hasn't changed! - dwh
2002-11-09 04:21:19 +03:00
var backDisabled = backBroadcaster.hasAttribute("disabled");
var forwardDisabled = forwardBroadcaster.hasAttribute("disabled");
if (backDisabled == webNavigation.canGoBack) {
if (backDisabled)
backBroadcaster.removeAttribute("disabled");
else
backBroadcaster.setAttribute("disabled", true);
2002-08-04 06:53:09 +04:00
}
2002-11-02 03:32:53 +03:00
2002-11-09 04:21:19 +03:00
if (forwardDisabled == webNavigation.canGoForward) {
if (forwardDisabled)
forwardBroadcaster.removeAttribute("disabled");
else
forwardBroadcaster.setAttribute("disabled", true);
2002-08-04 06:53:09 +04:00
}
}
2002-10-09 03:14:45 +04:00
function UpdatePageReport(event)
{
if (!gReportButton)
2002-11-08 04:09:32 +03:00
gReportButton = document.getElementById("page-report-button");
2002-10-09 03:14:45 +04:00
2002-10-09 05:26:47 +04:00
if (gBrowser.mCurrentBrowser.pageReport) {
2002-10-09 03:14:45 +04:00
gReportButton.setAttribute("blocked", "true");
2002-10-13 20:28:34 +04:00
if (gPrefService && gPrefService.getBoolPref("privacy.popups.firstTime")) {
2002-10-09 05:26:47 +04:00
displayPageReportFirstTime();
2002-10-09 05:41:08 +04:00
// Now set the pref.
gPrefService.setBoolPref("privacy.popups.firstTime", "false");
2002-10-09 05:26:47 +04:00
}
}
2002-10-09 03:14:45 +04:00
else
gReportButton.removeAttribute("blocked");
}
2002-10-14 02:22:38 +04:00
#ifdef MOZ_ENABLE_XREMOTE
function RegisterTabOpenObserver()
{
const observer = {
observe: function(subject, topic, data)
{
if (topic != "open-new-tab-request" || subject != window)
return;
delayedOpenTab(data);
}
};
const service = Components.classes["@mozilla.org/observer-service;1"]
.getService(Components.interfaces.nsIObserverService);
service.addObserver(observer, "open-new-tab-request", false);
}
2002-10-14 02:22:38 +04:00
#endif
2002-08-04 06:53:09 +04:00
function Startup()
{
gBrowser = document.getElementById("content");
var uriToLoad = null;
// Check for window.arguments[0]. If present, use that for uriToLoad.
if ("arguments" in window && window.arguments.length >= 1 && window.arguments[0])
uriToLoad = window.arguments[0];
gIsLoadingBlank = uriToLoad == "about:blank";
2002-09-13 07:15:57 +04:00
if (!gIsLoadingBlank) {
prepareForStartup();
2002-08-04 06:53:09 +04:00
}
2002-10-14 02:22:38 +04:00
#ifdef ENABLE_PAGE_CYCLER
appCore.startPageCycler();
#else
2002-08-04 06:53:09 +04:00
// only load url passed in when we're not page cycling
if (uriToLoad && !gIsLoadingBlank) {
if ("arguments" in window && window.arguments.length >= 3)
2002-10-14 02:22:38 +04:00
loadURI(uriToLoad, window.arguments[2]);
else
loadOneOrMoreURIs(uriToLoad);
2002-10-14 02:22:38 +04:00
}
2002-10-14 01:25:16 +04:00
#ifdef MOZ_ENABLE_XREMOTE
2002-10-14 02:22:38 +04:00
// hook up remote support
var remoteService;
2002-10-14 03:48:03 +04:00
remoteService = Components.classes["@mozilla.org/browser/xremoteservice;1"]
2002-10-14 02:22:38 +04:00
.getService(Components.interfaces.nsIXRemoteService);
remoteService.addBrowserInstance(window);
2002-08-04 06:53:09 +04:00
2002-10-14 02:22:38 +04:00
RegisterTabOpenObserver();
#endif
2002-10-14 00:04:05 +04:00
#endif
2003-01-29 10:42:59 +03:00
var sidebarSplitter;
2002-09-29 02:55:58 +04:00
if (window.opener) {
var openerSidebarBox = window.opener.document.getElementById("sidebar-box");
// The opener can be the hidden window too, if we're coming from the state
// where no windows are open, and the hidden window has no sidebar box.
if (openerSidebarBox && !openerSidebarBox.hidden) {
2002-11-08 07:56:15 +03:00
var sidebarBox = document.getElementById("sidebar-box");
2002-09-29 02:55:58 +04:00
var sidebarTitle = document.getElementById("sidebar-title");
sidebarTitle.setAttribute("value", window.opener.document.getElementById("sidebar-title").getAttribute("value"));
sidebarBox.setAttribute("width", openerSidebarBox.boxObject.width);
2002-09-30 05:58:19 +04:00
var sidebarCmd = openerSidebarBox.getAttribute("sidebarcommand");
sidebarBox.setAttribute("sidebarcommand", sidebarCmd);
sidebarBox.setAttribute("src", window.opener.document.getElementById("sidebar").getAttribute("src"));
2002-11-06 22:27:16 +03:00
gMustLoadSidebar = true;
sidebarBox.hidden = false;
2003-01-29 10:42:59 +03:00
sidebarSplitter = document.getElementById("sidebar-splitter");
2002-11-06 22:27:16 +03:00
sidebarSplitter.hidden = false;
document.getElementById(sidebarCmd).setAttribute("checked", "true");
2002-11-06 22:27:16 +03:00
}
}
2002-11-07 05:25:18 +03:00
else {
2002-11-08 07:56:15 +03:00
var box = document.getElementById("sidebar-box");
if (box.hasAttribute("sidebarcommand")) {
var cmd = box.getAttribute("sidebarcommand");
if (cmd != "") {
gMustLoadSidebar = true;
2002-11-08 07:56:15 +03:00
box.hidden = false;
2003-01-29 10:42:59 +03:00
sidebarSplitter = document.getElementById("sidebar-splitter");
sidebarSplitter.hidden = false;
document.getElementById(cmd).setAttribute("checked", "true");
}
}
2002-11-07 05:25:18 +03:00
}
setTimeout(delayedStartup, 0);
2002-09-18 23:51:28 +04:00
}
function prepareForStartup()
2002-09-18 23:51:28 +04:00
{
gURLBar = document.getElementById("urlbar");
gNavigatorBundle = document.getElementById("bundle_browser");
gProgressMeterPanel = document.getElementById("statusbar-progresspanel");
gBrowser.addEventListener("DOMUpdatePageReport", UpdatePageReport, false);
2002-11-08 07:52:37 +03:00
var webNavigation;
try {
// Create the browser instance component.
appCore = Components.classes["@mozilla.org/appshell/component/browser/instance;1"]
.createInstance(Components.interfaces.nsIBrowserInstance);
if (!appCore)
throw "couldn't create a browser instance";
webNavigation = getWebNavigation();
if (!webNavigation)
throw "no XBL binding for browser";
} catch (e) {
alert("Error launching browser window:" + e);
window.close(); // Give up.
return;
}
// initialize observers and listeners
window.XULBrowserWindow = new nsBrowserStatusHandler();
window.browserContentListener =
new nsBrowserContentListener(window, gBrowser);
// set default character set if provided
if ("arguments" in window && window.arguments.length > 1 && window.arguments[1]) {
if (window.arguments[1].indexOf("charset=") != -1) {
var arrayArgComponents = window.arguments[1].split("=");
if (arrayArgComponents) {
//we should "inherit" the charset menu setting in a new window
getMarkupDocumentViewer().defaultCharacterSet = arrayArgComponents[1];
}
}
}
2002-11-08 07:51:05 +03:00
// Initialize browser instance..
appCore.setWebShellWindow(window);
// Wire up session and global history before any possible
// progress notifications for back/forward button updating
2002-11-08 07:58:40 +03:00
webNavigation.sessionHistory = Components.classes["@mozilla.org/browser/shistory;1"]
.createInstance(Components.interfaces.nsISHistory);
// wire up global history. the same applies here.
var globalHistory = Components.classes["@mozilla.org/browser/global-history;1"]
.getService(Components.interfaces.nsIGlobalHistory);
gBrowser.docShell.QueryInterface(Components.interfaces.nsIDocShellHistory).globalHistory = globalHistory;
const selectedBrowser = gBrowser.selectedBrowser;
if (selectedBrowser.securityUI)
selectedBrowser.securityUI.init(selectedBrowser.contentWindow);
// hook up UI through progress listener
gBrowser.addProgressListener(window.XULBrowserWindow, Components.interfaces.nsIWebProgress.NOTIFY_ALL);
}
function delayedStartup()
{
gPrefService = Components.classes["@mozilla.org/preferences-service;1"]
.getService(Components.interfaces.nsIPrefService);
gPrefService = gPrefService.getBranch(null);
BrowserOffline.init();
if (gIsLoadingBlank)
prepareForStartup();
2002-10-14 05:26:08 +04:00
// loads the services
initServices();
initBMService();
gBrowser.addEventListener("load", function(evt) { setTimeout(loadEventHandlers, 0, evt); }, true);
window.addEventListener("keypress", ctrlNumberTabSelection, false);
2002-09-29 02:55:58 +04:00
if (gMustLoadSidebar) {
var sidebar = document.getElementById("sidebar");
var sidebarBox = document.getElementById("sidebar-box");
sidebar.setAttribute("src", sidebarBox.getAttribute("src"));
2002-09-29 02:55:58 +04:00
}
#ifdef XP_WIN
2002-09-18 23:51:28 +04:00
// Perform default browser checking (after window opens).
try {
var dialogShown = Components.classes["@mozilla.org/winhooks;1"]
.getService(Components.interfaces.nsIWindowsHooks)
.checkSettings(window);
} catch(e) {
}
#endif
2002-09-19 00:07:55 +04:00
// now load bookmarks
BMSVC.readBookmarks();
var bt = document.getElementById("bookmarks-ptf");
if (bt) {
var btf = BMSVC.getBookmarksToolbarFolder().Value;
bt.ref = btf;
document.getElementById("bookmarks-chevron").ref = btf;
bt.database.AddObserver(BookmarksToolbarRDFObserver);
}
window.addEventListener("resize", BookmarksToolbar.resizeFunc, false);
controllers.appendController(BookmarksMenuController);
2002-09-18 23:51:28 +04:00
// called when we go into full screen, even if it is
// initiated by a web page script
window.addEventListener("fullscreen", onFullScreen, false);
var element;
if (gIsLoadingBlank && gURLBar && !gURLBar.hidden && !gURLBar.parentNode.parentNode.collapsed)
element = gURLBar;
else
element = _content;
// This is a redo of the fix for jag bug 91884
2002-08-04 06:53:09 +04:00
var ww = Components.classes["@mozilla.org/embedcomp/window-watcher;1"]
.getService(Components.interfaces.nsIWindowWatcher);
if (window == ww.activeWindow) {
element.focus();
} else {
// set the element in command dispatcher so focus will restore properly
// when the window does become active
if (element instanceof Components.interfaces.nsIDOMWindow) {
2002-08-04 06:53:09 +04:00
document.commandDispatcher.focusedWindow = element;
document.commandDispatcher.focusedElement = null;
} else if (element instanceof Components.interfaces.nsIDOMElement) {
document.commandDispatcher.focusedWindow = element.ownerDocument.defaultView;
document.commandDispatcher.focusedElement = element;
}
2002-08-04 06:53:09 +04:00
}
SetPageProxyState("invalid", null);
var toolbox = document.getElementById("navigator-toolbox");
toolbox.customizeDone = BrowserToolboxCustomizeDone;
// Enable/Disable Form Fill
var pbi = gPrefService.QueryInterface(Components.interfaces.nsIPrefBranchInternal);
pbi.addObserver(gFormFillPrefListener.domain, gFormFillPrefListener, false);
// Initialize
gFormFillPrefListener.toggleFormFill();
pbi.addObserver(gHomeButton.prefDomain, gHomeButton, false);
gHomeButton.updateTooltip();
// Initialize Plugin Overrides
2003-08-11 07:54:41 +04:00
const kOverridePref = "browser.download.pluginOverrideTypes";
if (gPrefService.prefHasUserValue(kOverridePref)) {
var types = gPrefService.getCharPref(kOverridePref);
types = types.split(",");
const kPluginOverrideTypesNotHandled = "browser.download.pluginOverrideTypesNotHandled";
var catman = Components.classes["@mozilla.org/categorymanager;1"].getService(Components.interfaces.nsICategoryManager);
var typesNotHandled = "";
for (var i = 0; i < types.length; ++i) {
// Keep track of all overrides for plugins that aren't actually installed,
// so we know not to show them in the plugin configuration dialog BUT
// don't delete the overrides such that when the user actually installs the
// plugin in this build their preferences are remembered.
try {
var catEntry = catman.getCategoryEntry("Gecko-Content-Viewers", types[i]);
}
catch (e) {
catEntry = "";
}
if (catEntry == "")
typesNotHandled += types[i] + ",";
catman.deleteCategoryEntry("Gecko-Content-Viewers", types[i], false);
}
if (typesNotHandled != "") {
typesNotHandled = typesNotHandled.substr(0, typesNotHandled.length - 1);
gPrefService.setCharPref(kPluginOverrideTypesNotHandled, typesNotHandled);
}
else if (gPrefService.prefHasUserValue(kPluginOverrideTypesNotHandled))
gPrefService.clearUserPref(kPluginOverrideTypesNotHandled);
}
clearObsoletePrefs();
2002-08-04 06:53:09 +04:00
}
function Shutdown()
{
2002-10-14 01:25:16 +04:00
#ifdef MOZ_ENABLE_XREMOTE
2002-08-04 06:53:09 +04:00
// remove remote support
2002-10-14 01:25:16 +04:00
var remoteService;
2002-10-14 03:48:03 +04:00
remoteService = Components.classes["@mozilla.org/browser/xremoteservice;1"]
2002-10-14 01:25:16 +04:00
.getService(Components.interfaces.nsIXRemoteService);
remoteService.removeBrowserInstance(window);
#endif
2002-08-04 06:53:09 +04:00
try {
2002-09-19 00:00:30 +04:00
gBrowser.removeProgressListener(window.XULBrowserWindow);
2002-08-04 06:53:09 +04:00
} catch (ex) {
}
BrowserOffline.uninit();
var windowManager = Components.classes['@mozilla.org/appshell/window-mediator;1'].getService();
var windowManagerInterface = windowManager.QueryInterface(Components.interfaces.nsIWindowMediator);
var enumerator = windowManagerInterface.getEnumerator(null);
enumerator.getNext();
if (!enumerator.hasMoreElements()) {
document.persist("sidebar-box", "sidebarcommand");
document.persist("sidebar-box", "width");
document.persist("sidebar-box", "src");
document.persist("sidebar-title", "value");
}
2002-08-04 06:53:09 +04:00
window.XULBrowserWindow.destroy();
window.XULBrowserWindow = null;
window.browserContentListener.close();
// Close the app core.
if (appCore)
appCore.close();
}
const gFormFillPrefListener =
{
domain: "browser.formfill.enable",
observe: function (aSubject, aTopic, aPrefName)
{
if (aTopic != "nsPref:changed" || aPrefName != this.domain)
return;
this.toggleFormFill();
},
toggleFormFill: function ()
{
try {
gFormFillEnabled = gPrefService.getBoolPref(this.domain);
}
catch (e) {
}
if (gFormFillEnabled)
gBrowser.attachFormFill();
else
gBrowser.detachFormFill();
2003-08-08 04:52:33 +04:00
gBrowser.setAttribute("autocompleteenabled", gFormFillEnabled);
var searchBar = document.getElementById("search-bar");
2003-08-08 04:52:33 +04:00
if (searchBar) {
if (gFormFillEnabled)
searchBar.removeAttribute("disableautocomplete");
else
searchBar.setAttribute("disableautocomplete", "true");
}
}
}
function ctrlNumberTabSelection(event)
{
if (event.altKey && event.keyCode == KeyEvent.DOM_VK_RETURN) {
2002-10-20 07:52:52 +04:00
// Don't let winxp beep on ALT+ENTER, since the URL bar uses it.
event.preventDefault();
return;
2002-10-20 07:52:52 +04:00
}
#ifdef XP_MACOSX
if (!event.metaKey)
#else
if (!event.ctrlKey)
#endif
return;
var index = event.charCode - 49;
if (index < 0 || index > 8)
return;
if (index >= gBrowser.mTabContainer.childNodes.length)
return;
var oldTab = gBrowser.selectedTab;
var newTab = gBrowser.mTabContainer.childNodes[index];
if (newTab != oldTab) {
oldTab.selected = false;
gBrowser.selectedTab = newTab;
}
event.preventDefault();
event.preventBubble();
event.preventCapture();
event.stopPropagation();
}
2002-08-04 06:53:09 +04:00
function gotoHistoryIndex(aEvent)
{
var index = aEvent.target.getAttribute("index");
if (!index)
return false;
try {
getWebNavigation().gotoIndex(index);
}
catch(ex) {
return false;
}
return true;
}
function BrowserBack()
{
try {
getWebNavigation().goBack();
}
catch(ex) {
}
}
#ifdef XP_WIN
function BrowserHandleBackspace()
{
// The order of seeing keystrokes is this:
// 1) Chrome, 2) Typeahead, 3) [platform]HTMLBindings.xml
// Rather than have typeaheadfind responsible for making VK_BACK
// go back in history, we handle backspace it here as follows:
// When backspace is pressed, it might mean back
// in typeaheadfind if that's active, or it might mean back in history
var typeAhead = null;
const TYPE_AHEAD_FIND_CONTRACTID = "@mozilla.org/typeaheadfind;1";
if (TYPE_AHEAD_FIND_CONTRACTID in Components.classes) {
typeAhead = Components.classes[TYPE_AHEAD_FIND_CONTRACTID]
.getService(Components.interfaces.nsITypeAheadFind);
}
if (!typeAhead || !typeAhead.backOneChar()) {
BrowserBack();
}
}
#endif
2002-08-04 06:53:09 +04:00
function BrowserForward()
{
try {
getWebNavigation().goForward();
}
catch(ex) {
}
}
function BrowserBackMenu(event)
{
return FillHistoryMenu(event.target, "back");
}
function BrowserForwardMenu(event)
{
return FillHistoryMenu(event.target, "forward");
}
function BrowserStop()
{
try {
const stopFlags = nsIWebNavigation.STOP_ALL;
getWebNavigation().stop(stopFlags);
}
catch(ex) {
}
}
function BrowserReload()
{
const reloadFlags = nsIWebNavigation.LOAD_FLAGS_NONE;
return BrowserReloadWithFlags(reloadFlags);
}
function BrowserReloadSkipCache()
{
// Bypass proxy and cache.
const reloadFlags = nsIWebNavigation.LOAD_FLAGS_BYPASS_PROXY | nsIWebNavigation.LOAD_FLAGS_BYPASS_CACHE;
return BrowserReloadWithFlags(reloadFlags);
}
function BrowserHome()
{
var homePage = gHomeButton.getHomePage();
loadOneOrMoreURIs(homePage);
}
function loadOneOrMoreURIs(aURIString)
{
if (aURIString.indexOf("|") != -1) {
var urls = aURIString.split("|");
loadURI(urls[0]);
for (var i = 1; i < urls.length; ++i)
gBrowser.addTab(urls[i]);
}
else
loadURI(aURIString);
2002-08-04 06:53:09 +04:00
}
2002-10-07 02:54:24 +04:00
function constructGoMenuItem(goMenu, beforeItem, url, title)
2002-10-07 01:11:50 +04:00
{
2002-10-07 02:54:24 +04:00
var menuitem = document.createElementNS(kXULNS, "menuitem");
2003-08-13 07:21:37 +04:00
menuitem.setAttribute("statustext", url);
2002-10-07 02:54:24 +04:00
menuitem.setAttribute("label", title);
goMenu.insertBefore(menuitem, beforeItem);
return menuitem;
}
function onGoMenuHidden()
{
setTimeout("destroyGoMenuItems(document.getElementById('goPopup'));", 0);
}
function destroyGoMenuItems(goMenu) {
var startSeparator = document.getElementById("startHistorySeparator");
var endSeparator = document.getElementById("endHistorySeparator");
endSeparator.hidden = true;
// Destroy the items.
var destroy = false;
for (var i = 0; i < goMenu.childNodes.length; i++) {
var item = goMenu.childNodes[i];
if (item == endSeparator)
break;
if (destroy) {
i--;
goMenu.removeChild(item);
}
if (item == startSeparator)
destroy = true;
}
}
function updateGoMenu(goMenu)
{
2002-10-07 05:58:28 +04:00
// In case the timer didn't fire.
destroyGoMenuItems(goMenu);
2002-10-07 02:54:24 +04:00
var history = document.getElementById("hiddenHistoryTree");
2002-10-09 03:14:45 +04:00
if (history.hidden) {
2002-10-07 02:54:24 +04:00
history.hidden = false;
2002-10-09 03:14:45 +04:00
var globalHistory = Components.classes["@mozilla.org/browser/global-history;1"]
.getService(Components.interfaces.nsIGlobalHistory);
var dataSource = globalHistory.QueryInterface(Components.interfaces.nsIRDFDataSource);
history.database.AddDataSource(dataSource);
}
2002-10-07 02:54:24 +04:00
if (!history.ref)
history.ref = "NC:HistoryRoot";
var count = history.treeBoxObject.view.rowCount;
if (count > 10)
count = 10;
if (count == 0)
return;
const NC_NS = "http://home.netscape.com/NC-rdf#";
2002-10-07 01:11:50 +04:00
2002-10-07 02:54:24 +04:00
if (!gRDF)
gRDF = Components.classes["@mozilla.org/rdf/rdf-service;1"]
.getService(Components.interfaces.nsIRDFService);
var builder = history.builder.QueryInterface(Components.interfaces.nsIXULTreeBuilder);
var beforeItem = document.getElementById("endHistorySeparator");
2002-10-11 22:59:47 +04:00
2002-10-07 02:54:24 +04:00
var nameResource = gRDF.GetResource(NC_NS + "Name");
2002-10-11 22:59:47 +04:00
var endSep = beforeItem;
var showSep = false;
2002-10-07 02:54:24 +04:00
for (var i = count-1; i >= 0; i--) {
var res = builder.getResourceAtIndex(i);
var url = res.Value;
var titleRes = history.database.GetTarget(res, nameResource, true);
2002-10-11 22:56:05 +04:00
if (!titleRes)
continue;
2002-10-11 22:59:47 +04:00
showSep = true;
2002-10-07 02:54:24 +04:00
var titleLiteral = titleRes.QueryInterface(Components.interfaces.nsIRDFLiteral);
beforeItem = constructGoMenuItem(goMenu, beforeItem, url, titleLiteral.Value);
}
2002-10-11 22:59:47 +04:00
if (showSep)
endSep.hidden = false;
2002-10-07 01:11:50 +04:00
}
function addBookmarkAs(aBrowser, aIsWebPanel)
2002-08-04 06:53:09 +04:00
{
const browsers = aBrowser.browsers;
if (browsers && browsers.length > 1)
addBookmarkForTabBrowser(aBrowser);
2002-08-04 06:53:09 +04:00
else
addBookmarkForBrowser(aBrowser.webNavigation, aIsWebPanel);
}
function addBookmarkForTabBrowser(aTabBrowser, aSelect)
{
var tabsInfo = [];
var currentTabInfo = { name: "", url: "", charset: null };
const activeBrowser = aTabBrowser.selectedBrowser;
const browsers = aTabBrowser.browsers;
for (var i = 0; i < browsers.length; ++i) {
var webNav = browsers[i].webNavigation;
var url = webNav.currentURI.spec;
var name = "";
var charSet;
try {
var doc = webNav.document;
name = doc.title || url;
charSet = doc.characterSet;
} catch (e) {
name = url;
}
tabsInfo[i] = { name: name, url: url, charset: charSet };
if (browsers[i] == activeBrowser)
currentTabInfo = tabsInfo[i];
}
openDialog("chrome://browser/content/bookmarks/addBookmark2.xul", "",
"centerscreen,chrome,dialog,resizable,dependent",
currentTabInfo.name, currentTabInfo.url, null,
currentTabInfo.charset, "addGroup" + (aSelect ? ",group" : ""), tabsInfo);
}
function addBookmarkForBrowser(aDocShell, aIsWebPanel)
{
// Bug 52536: We obtain the URL and title from the nsIWebNavigation
// associated with a <browser/> rather than from a DOMWindow.
// This is because when a full page plugin is loaded, there is
// no DOMWindow (?) but information about the loaded document
// may still be obtained from the webNavigation.
var url = aDocShell.currentURI.spec;
var title, charSet = null;
try {
title = aDocShell.document.title || url;
charSet = aDocShell.document.characterSet;
}
catch (e) {
title = url;
}
BookmarksUtils.addBookmark(url, title, charSet, aIsWebPanel);
2002-08-04 06:53:09 +04:00
}
2002-09-20 07:52:36 +04:00
function openLocation()
2002-08-04 06:53:09 +04:00
{
if (gURLBar && !gURLBar.parentNode.parentNode.collapsed) {
2002-09-20 07:52:36 +04:00
gURLBar.focus();
gURLBar.select();
}
else {
#ifdef XP_MACOSX
if (window.location.href == "chrome://browser/content/hiddenWindow.xul") {
// If no windows are active, open a new one.
window.openDialog("chrome://browser/content/", "_blank", "chrome,all,dialog=no", "about:blank");
}
else
#endif
openDialog("chrome://browser/content/openLocation.xul", "_blank", "chrome,modal,titlebar", window);
2002-09-20 07:52:36 +04:00
}
2002-08-04 06:53:09 +04:00
}
function BrowserOpenTab()
{
gBrowser.selectedTab = gBrowser.addTab('about:blank');
if (gURLBar)
setTimeout("gURLBar.focus();", 0);
2002-08-04 06:53:09 +04:00
}
/* Called from the openLocation dialog. This allows that dialog to instruct
its opener to open a new window and then step completely out of the way.
Anything less byzantine is causing horrible crashes, rather believably,
though oddly only on Linux. */
function delayedOpenWindow(chrome,flags,url)
{
setTimeout("openDialog('"+chrome+"','_blank','"+flags+"','"+url+"')", 10);
}
/* Required because the tab needs time to set up its content viewers and get the load of
the URI kicked off before becoming the active content area. */
function delayedOpenTab(url)
{
setTimeout(function(aTabElt) { gBrowser.selectedTab = aTabElt; }, 0, gBrowser.addTab(url));
2002-08-04 06:53:09 +04:00
}
function BrowserOpenFileWindow()
{
// Get filepicker component.
try {
const nsIFilePicker = Components.interfaces.nsIFilePicker;
var fp = Components.classes["@mozilla.org/filepicker;1"].createInstance(nsIFilePicker);
fp.init(window, gNavigatorBundle.getString("openFile"), nsIFilePicker.modeOpen);
fp.appendFilters(nsIFilePicker.filterAll | nsIFilePicker.filterText | nsIFilePicker.filterImages |
nsIFilePicker.filterXML | nsIFilePicker.filterHTML);
if (fp.show() == nsIFilePicker.returnOK)
openTopWin(fp.fileURL.spec);
} catch (ex) {
}
}
function BrowserCloseTabOrWindow()
{
if (gBrowser.localName == 'tabbrowser' && gBrowser.mTabContainer.childNodes.length > 1) {
2002-08-04 06:53:09 +04:00
// Just close up a tab.
gBrowser.removeCurrentTab();
2002-08-04 06:53:09 +04:00
return;
}
BrowserCloseWindow();
}
function BrowserCloseWindow()
{
// This code replicates stuff in Shutdown(). It is here because
// window.screenX and window.screenY have real values. We need
// to fix this eventually but by replicating the code here, we
// provide a means of saving position (it just requires that the
// user close the window via File->Close (vs. close box).
// Get the current window position/size.
var x = window.screenX;
var y = window.screenY;
var h = window.outerHeight;
var w = window.outerWidth;
// Store these into the window attributes (for persistence).
var win = document.getElementById( "main-window" );
win.setAttribute( "x", x );
win.setAttribute( "y", y );
win.setAttribute( "height", h );
win.setAttribute( "width", w );
closeWindow(true);
2002-08-04 06:53:09 +04:00
}
function loadURI(uri, referrer)
{
try {
getWebNavigation().loadURI(uri, nsIWebNavigation.LOAD_FLAGS_NONE, referrer, null, null);
} catch (e) {
}
}
function BrowserLoadURL(aTriggeringEvent)
{
var url = gURLBar.value;
if (url.match(/^view-source:/)) {
BrowserViewSourceOfURL(url.replace(/^view-source:/, ""), null, null);
} else {
if (gBrowser.localName == "tabbrowser" &&
2002-10-20 07:52:52 +04:00
aTriggeringEvent && 'altKey' in aTriggeringEvent &&
aTriggeringEvent.altKey) {
_content.focus();
var t = gBrowser.addTab(url); // open link in new tab
gBrowser.selectedTab = t;
2002-10-20 07:52:52 +04:00
gURLBar.value = url;
event.preventDefault();
event.preventBubble();
event.preventCapture();
event.stopPropagation();
2002-08-04 06:53:09 +04:00
}
else
loadURI(url);
2002-08-04 06:53:09 +04:00
_content.focus();
}
}
function getShortcutOrURI(url)
{
// rjc: added support for URL shortcuts (3/30/1999)
try {
2002-09-13 07:15:57 +04:00
var shortcutURL = BMSVC.resolveKeyword(url);
2002-08-04 06:53:09 +04:00
if (!shortcutURL) {
// rjc: add support for string substitution with shortcuts (4/4/2000)
// (see bug # 29871 for details)
var aOffset = url.indexOf(" ");
if (aOffset > 0) {
var cmd = url.substr(0, aOffset);
var text = url.substr(aOffset+1);
2002-09-13 07:15:57 +04:00
shortcutURL = BMSVC.resolveKeyword(cmd);
2002-08-04 06:53:09 +04:00
if (shortcutURL && text) {
aOffset = shortcutURL.indexOf("%s");
if (aOffset >= 0)
shortcutURL = shortcutURL.substr(0, aOffset) + text + shortcutURL.substr(aOffset+2);
else
shortcutURL = null;
}
}
}
if (shortcutURL)
url = shortcutURL;
} catch (ex) {
}
return url;
}
function readFromClipboard()
{
var url;
try {
// Get clipboard.
var clipboard = Components.classes["@mozilla.org/widget/clipboard;1"]
.getService(Components.interfaces.nsIClipboard);
// Create tranferable that will transfer the text.
var trans = Components.classes["@mozilla.org/widget/transferable;1"]
.createInstance(Components.interfaces.nsITransferable);
trans.addDataFlavor("text/unicode");
clipboard.getData(trans, clipboard.kSelectionClipboard);
var data = {};
var dataLen = {};
trans.getTransferData("text/unicode", data, dataLen);
if (data) {
2002-11-05 02:12:08 +03:00
data = data.value.QueryInterface(Components.interfaces.nsISupportsString);
2002-08-04 06:53:09 +04:00
url = data.data.substring(0, dataLen.value / 2);
}
} catch (ex) {
}
return url;
}
function BrowserViewSourceOfDocument(aDocument)
{
var docCharset;
var pageCookie;
var webNav;
// Get the document charset
docCharset = "charset=" + aDocument.characterSet;
// Get the nsIWebNavigation associated with the document
try {
var win;
var ifRequestor;
// Get the DOMWindow for the requested document. If the DOMWindow
// cannot be found, then just use the _content window...
//
// XXX: This is a bit of a hack...
win = aDocument.defaultView;
if (win == window) {
win = _content;
}
ifRequestor = win.QueryInterface(Components.interfaces.nsIInterfaceRequestor);
webNav = ifRequestor.getInterface(nsIWebNavigation);
2002-08-04 06:53:09 +04:00
} catch(err) {
// If nsIWebNavigation cannot be found, just get the one for the whole
// window...
webNav = getWebNavigation();
}
//
// Get the 'PageDescriptor' for the current document. This allows the
// view-source to access the cached copy of the content rather than
// refetching it from the network...
//
try{
var PageLoader = webNav.QueryInterface(Components.interfaces.nsIWebPageDescriptor);
pageCookie = PageLoader.currentDescriptor;
} catch(err) {
// If no page descriptor is available, just use the view-source URL...
}
BrowserViewSourceOfURL(webNav.currentURI.spec, docCharset, pageCookie);
}
function BrowserViewSourceOfURL(url, charset, pageCookie)
{
// try to open a view-source window while inheriting the charset (if any)
openDialog("chrome://global/content/viewSource.xul",
2002-08-04 06:53:09 +04:00
"_blank",
"scrollbars,resizable,chrome,dialog=no",
url, charset, pageCookie);
}
// doc=null for regular page info, doc=owner document for frame info.
function BrowserPageInfo(doc)
{
2002-12-08 02:19:45 +03:00
window.openDialog("chrome://browser/content/pageInfo.xul",
2002-08-04 06:53:09 +04:00
"_blank",
"chrome,dialog=no",
doc);
}
2002-10-13 09:23:24 +04:00
#ifdef DEBUG
2002-08-04 06:53:09 +04:00
// Initialize the LeakDetector class.
function LeakDetector(verbose)
{
this.verbose = verbose;
}
const NS_LEAKDETECTOR_CONTRACTID = "@mozilla.org/xpcom/leakdetector;1";
if (NS_LEAKDETECTOR_CONTRACTID in Components.classes) {
try {
LeakDetector.prototype = Components.classes[NS_LEAKDETECTOR_CONTRACTID]
.createInstance(Components.interfaces.nsILeakDetector);
} catch (err) {
LeakDetector.prototype = Object.prototype;
}
} else {
LeakDetector.prototype = Object.prototype;
}
var leakDetector = new LeakDetector(false);
// Dumps current set of memory leaks.
function dumpMemoryLeaks()
{
leakDetector.dumpLeaks();
}
// Traces all objects reachable from the chrome document.
function traceChrome()
{
leakDetector.traceObject(document, leakDetector.verbose);
}
// Traces all objects reachable from the content document.
function traceDocument()
{
// keep the chrome document out of the dump.
leakDetector.markObject(document, true);
leakDetector.traceObject(_content, leakDetector.verbose);
leakDetector.markObject(document, false);
}
// Controls whether or not we do verbose tracing.
function traceVerbose(verbose)
{
leakDetector.verbose = (verbose == "true");
}
2002-10-13 09:23:24 +04:00
#endif
2002-08-04 06:53:09 +04:00
function checkForDirectoryListing()
{
if ( "HTTPIndex" in _content &&
_content.HTTPIndex instanceof Components.interfaces.nsIHTTPIndex ) {
_content.defaultCharacterset = getMarkupDocumentViewer().defaultCharacterSet;
}
}
function URLBarFocusHandler(aEvent, aElt)
2002-08-04 06:53:09 +04:00
{
if (gIgnoreFocus)
gIgnoreFocus = false;
else if (gClickSelectsAll)
aElt.select();
2002-08-04 06:53:09 +04:00
}
function URLBarMouseDownHandler(aEvent, aElt)
2002-08-04 06:53:09 +04:00
{
if (aElt.hasAttribute("focused")) {
2002-08-04 06:53:09 +04:00
gIgnoreClick = true;
} else {
gIgnoreFocus = true;
gIgnoreClick = false;
aElt.setSelectionRange(0, 0);
2002-08-04 06:53:09 +04:00
}
}
function URLBarClickHandler(aEvent, aElt)
2002-08-04 06:53:09 +04:00
{
if (!gIgnoreClick && gClickSelectsAll && aElt.selectionStart == aElt.selectionEnd)
aElt.select();
2002-08-04 06:53:09 +04:00
}
// If "ESC" is pressed in the url bar, we replace the urlbar's value with the url of the page
// and highlight it, unless it is about:blank, where we reset it to "".
function handleURLBarRevert()
{
var url = getWebNavigation().currentURI.spec;
var throbberElement = document.getElementById("navigator-throbber");
2002-09-28 10:25:03 +04:00
var isScrolling = gURLBar.popupOpen;
2002-08-04 06:53:09 +04:00
// don't revert to last valid url unless page is NOT loading
// and user is NOT key-scrolling through autocomplete list
if ((!throbberElement || !throbberElement.hasAttribute("busy")) && !isScrolling) {
2002-08-04 06:53:09 +04:00
if (url != "about:blank") {
gURLBar.value = url;
gURLBar.select();
SetPageProxyState("valid", null); // XXX Build a URI and pass it in here.
} else { //if about:blank, urlbar becomes ""
gURLBar.value = "";
}
}
gBrowser.userTypedValue = null;
2002-08-04 06:53:09 +04:00
// tell widget to revert to last typed text only if the user
// was scrolling when they hit escape
2002-09-28 10:25:03 +04:00
return !isScrolling;
2002-08-04 06:53:09 +04:00
}
2002-09-28 10:25:03 +04:00
function handleURLBarCommand(aTriggeringEvent)
2002-08-04 06:53:09 +04:00
{
canonizeUrl(aTriggeringEvent);
2002-08-04 06:53:09 +04:00
try {
addToUrlbarHistory();
} catch (ex) {
// Things may go wrong when adding url to session history,
// but don't let that interfere with the loading of the url.
}
BrowserLoadURL(aTriggeringEvent);
}
function canonizeUrl(aTriggeringEvent)
{
if (!gURLBar)
return;
var url = gURLBar.value;
// Prevent suffix when already exists www , http , /
if (url.match(/^(www|http)|\/\s*$/i))
return;
if (aTriggeringEvent && 'ctrlKey' in aTriggeringEvent &&
aTriggeringEvent.ctrlKey && 'shiftKey' in aTriggeringEvent &&
aTriggeringEvent.shiftKey)
// Tack http://www. and .org on.
url = "http://www." + url + ".org/";
else if (aTriggeringEvent && 'ctrlKey' in aTriggeringEvent &&
aTriggeringEvent.ctrlKey)
// Tack www. and .com on.
url = "http://www." + url + ".com/";
else if (aTriggeringEvent && 'shiftKey' in aTriggeringEvent &&
aTriggeringEvent.shiftKey)
// Tack www. and .org on.
url = "http://www." + url + ".net/";
gURLBar.value = getShortcutOrURI(url);
}
2002-08-04 06:53:09 +04:00
function UpdatePageProxyState()
{
if (gURLBar && gURLBar.value != gLastValidURLStr)
2002-08-04 06:53:09 +04:00
SetPageProxyState("invalid", null);
}
function SetPageProxyState(aState, aURI)
{
if (!gURLBar)
return;
2002-08-04 06:53:09 +04:00
if (!gProxyButton)
gProxyButton = document.getElementById("page-proxy-button");
if (!gProxyFavIcon)
gProxyFavIcon = document.getElementById("page-proxy-favicon");
if (!gProxyDeck)
gProxyDeck = document.getElementById("page-proxy-deck");
gProxyButton.setAttribute("pageproxystate", aState);
if (aState == "valid") {
gLastValidURLStr = gURLBar.value;
gURLBar.addEventListener("input", UpdatePageProxyState, false);
if (gBrowser.shouldLoadFavIcon(aURI)) {
var favStr = gBrowser.buildFavIconString(aURI);
if (favStr != gProxyFavIcon.src) {
gBrowser.loadFavIcon(aURI, "src", gProxyFavIcon);
gProxyDeck.selectedIndex = 0;
}
else gProxyDeck.selectedIndex = 1;
}
else {
gProxyDeck.selectedIndex = 0;
gProxyFavIcon.removeAttribute("src");
}
} else if (aState == "invalid") {
gURLBar.removeEventListener("input", UpdatePageProxyState, false);
gProxyDeck.selectedIndex = 0;
}
}
function PageProxyDragGesture(aEvent)
{
if (gProxyButton.getAttribute("pageproxystate") == "valid") {
nsDragAndDrop.startDrag(aEvent, proxyIconDNDObserver);
return true;
}
return false;
}
function SearchBarPopupShowing(aEvent)
{
var currItem = document.getElementById("miAddEngines");
if (currItem)
aEvent.target.removeChild(currItem);
var browserBundle = document.getElementById("bundle_browser");
var menuitem = document.createElementNS(kXULNS, "menuitem");
menuitem.setAttribute("label", browserBundle.getString("addEngines"));
menuitem.id = "miAddEngines";
aEvent.target.appendChild(menuitem);
}
function SearchBarPopupCommand(aEvent)
{
if (!aEvent.target.id)
return;
if (aEvent.target.id == "miAddEngines") {
var regionBundle = document.getElementById("bundle_browser_region");
loadURI(regionBundle.getString("searchEnginesURL"));
return;
}
document.getElementById("search-bar").currentEngine = aEvent.target.id;
}
function showSearchEnginePopup()
{
var searchEnginePopup = document.getElementById("SearchBarPopup");
var searchEngineButton = document.getElementById("search-proxy-button");
searchEnginePopup.showPopup(searchEngineButton);
}
function quickFindInPage(aValue)
{
var focusedWindow = document.commandDispatcher.focusedWindow;
if (!focusedWindow || focusedWindow == window)
focusedWindow = window._content;
var findInst = gBrowser.webBrowserFind;
var findInFrames = findInst.QueryInterface(Components.interfaces.nsIWebBrowserFindInFrames);
findInFrames.rootSearchFrame = _content;
findInFrames.currentSearchFrame = focusedWindow;
var findService = Components.classes["@mozilla.org/find/find_service;1"]
.getService(Components.interfaces.nsIFindService);
findInst.searchString = aValue;
findInst.matchCase = findService.matchCase;
findInst.wrapFind = true;
findInst.entireWord = findService.entireWord;
findInst.findBackwards = false;
findInst.findNext();
}
2002-08-04 06:53:09 +04:00
function updateToolbarStates(toolbarMenuElt)
{
if (!gHaveUpdatedToolbarState) {
var mainWindow = document.getElementById("main-window");
if (mainWindow.hasAttribute("chromehidden")) {
gHaveUpdatedToolbarState = true;
var i;
for (i = 0; i < toolbarMenuElt.childNodes.length; ++i)
document.getElementById(toolbarMenuElt.childNodes[i].getAttribute("observes")).removeAttribute("checked");
var toolbars = document.getElementsByTagName("toolbar");
2002-10-20 12:03:51 +04:00
// Start i at 1, since we skip the menubar.
for (i = 1; i < toolbars.length; ++i) {
2002-08-04 06:53:09 +04:00
if (toolbars[i].getAttribute("class").indexOf("chromeclass") != -1)
toolbars[i].setAttribute("collapsed", "true");
2002-08-04 06:53:09 +04:00
}
var statusbars = document.getElementsByTagName("statusbar");
2002-10-20 12:03:51 +04:00
for (i = 1; i < statusbars.length; ++i) {
2002-08-04 06:53:09 +04:00
if (statusbars[i].getAttribute("class").indexOf("chromeclass") != -1)
statusbars[i].setAttribute("collapsed", "true");
2002-08-04 06:53:09 +04:00
}
mainWindow.removeAttribute("chromehidden");
}
}
}
function BrowserFullScreen()
{
window.fullScreen = !window.fullScreen;
}
function onFullScreen()
{
FullScreen.toggle();
}
function getWebNavigation()
{
try {
return gBrowser.webNavigation;
2002-08-04 06:53:09 +04:00
} catch (e) {
return null;
}
}
function BrowserReloadWithFlags(reloadFlags)
{
/* First, we'll try to use the session history object to reload so
* that framesets are handled properly. If we're in a special
* window (such as view-source) that has no session history, fall
* back on using the web navigation's reload method.
*/
var webNav = getWebNavigation();
try {
var sh = webNav.sessionHistory;
if (sh)
webNav = sh.QueryInterface(nsIWebNavigation);
2002-08-04 06:53:09 +04:00
} catch (e) {
}
try {
webNav.reload(reloadFlags);
} catch (e) {
}
}
function toggleAffectedChrome(aHide)
{
// chrome to toggle includes:
// (*) menubar
// (*) navigation bar
// (*) bookmarks toolbar
// (*) sidebar
2002-08-04 06:53:09 +04:00
var navToolbox = document.getElementById("navigator-toolbox");
navToolbox.hidden = aHide;
if (aHide)
{
gChromeState = {};
var sidebar = document.getElementById("sidebar-box");
gChromeState.sidebarOpen = !sidebar.hidden;
2002-08-04 06:53:09 +04:00
}
if (gChromeState.sidebarOpen)
toggleSidebar(); //pch doesn't work.
2002-08-04 06:53:09 +04:00
}
function onEnterPrintPreview()
2002-08-04 06:53:09 +04:00
{
toggleAffectedChrome(true);
}
function onExitPrintPreview()
{
2002-08-04 06:53:09 +04:00
// restore chrome to original state
toggleAffectedChrome(false);
}
function getMarkupDocumentViewer()
{
return gBrowser.markupDocumentViewer;
2002-08-04 06:53:09 +04:00
}
/**
* Content area tooltip.
* XXX - this must move into XBL binding/equiv! Do not want to pollute
2002-09-19 00:00:30 +04:00
* browser.js with functionality that can be encapsulated into
2002-08-04 06:53:09 +04:00
* browser widget. TEMPORARY!
*
* NOTE: Any changes to this routine need to be mirrored in ChromeListener::FindTitleText()
* (located in mozilla/embedding/browser/webBrowser/nsDocShellTreeOwner.cpp)
* which performs the same function, but for embedded clients that
* don't use a XUL/JS layer. It is important that the logic of
* these two routines be kept more or less in sync.
* (pinkerton)
**/
function FillInHTMLTooltip(tipElement)
{
var retVal = false;
if (tipElement.namespaceURI == "http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul")
return retVal;
const XLinkNS = "http://www.w3.org/1999/xlink";
var titleText = null;
var XLinkTitleText = null;
while (!titleText && !XLinkTitleText && tipElement) {
if (tipElement.nodeType == Node.ELEMENT_NODE) {
titleText = tipElement.getAttribute("title");
XLinkTitleText = tipElement.getAttributeNS(XLinkNS, "title");
}
tipElement = tipElement.parentNode;
}
var texts = [titleText, XLinkTitleText];
var tipNode = document.getElementById("aHTMLTooltip");
for (var i = 0; i < texts.length; ++i) {
var t = texts[i];
if (t && t.search(/\S/) >= 0) {
tipNode.setAttribute("label", t);
retVal = true;
}
}
return retVal;
}
var proxyIconDNDObserver = {
onDragStart: function (aEvent, aXferData, aDragAction)
{
2002-10-14 02:50:26 +04:00
var value = gURLBar.value;
2002-08-04 06:53:09 +04:00
// XXX - do we want to allow the user to set a blank page to their homepage?
// if so then we want to modify this a little to set about:blank as
// the homepage in the event of an empty urlbar.
2002-10-14 02:50:26 +04:00
if (!value) return;
2002-08-04 06:53:09 +04:00
2002-10-14 02:50:26 +04:00
var urlString = value + "\n" + window._content.document.title;
var htmlString = "<a href=\"" + value + "\">" + value + "</a>";
2002-08-04 06:53:09 +04:00
aXferData.data = new TransferData();
aXferData.data.addDataForFlavour("text/x-moz-url", urlString);
2002-10-14 02:50:26 +04:00
aXferData.data.addDataForFlavour("text/unicode", value);
2002-08-04 06:53:09 +04:00
aXferData.data.addDataForFlavour("text/html", htmlString);
}
}
var homeButtonObserver = {
onDrop: function (aEvent, aXferData, aDragSession)
{
var url = transferUtils.retrieveURLFromData(aXferData.data, aXferData.flavour.contentType);
setTimeout(openHomeDialog, 0, url);
},
onDragOver: function (aEvent, aFlavour, aDragSession)
{
var statusTextFld = document.getElementById("statusbar-display");
statusTextFld.label = gNavigatorBundle.getString("droponhomebutton");
aDragSession.dragAction = Components.interfaces.nsIDragService.DRAGDROP_ACTION_LINK;
},
onDragExit: function (aEvent, aDragSession)
{
var statusTextFld = document.getElementById("statusbar-display");
statusTextFld.label = "";
},
getSupportedFlavours: function ()
{
var flavourSet = new FlavourSet();
flavourSet.appendFlavour("application/x-moz-file", "nsIFile");
flavourSet.appendFlavour("text/x-moz-url");
flavourSet.appendFlavour("text/unicode");
return flavourSet;
}
}
function openHomeDialog(aURL)
{
var promptService = Components.classes["@mozilla.org/embedcomp/prompt-service;1"].getService(Components.interfaces.nsIPromptService);
var promptTitle = gNavigatorBundle.getString("droponhometitle");
var promptMsg = gNavigatorBundle.getString("droponhomemsg");
var pressedVal = promptService.confirmEx(window, promptTitle, promptMsg,
(promptService.BUTTON_TITLE_YES * promptService.BUTTON_POS_0) +
(promptService.BUTTON_TITLE_NO * promptService.BUTTON_POS_1),
null, null, null, null, {value:0});
2002-08-04 06:53:09 +04:00
if (pressedVal == 0) {
try {
var str = Components.classes["@mozilla.org/supports-string;1"]
.createInstance(Components.interfaces.nsISupportsString);
str.data = aURL;
gPrefService.setComplexValue("browser.startup.homepage",
Components.interfaces.nsISupportsString, str);
var homeButton = document.getElementById("home-button");
homeButton.setAttribute("tooltiptext", aURL);
} catch (ex) {
dump("Failed to set the home page.\n"+ex+"\n");
}
2002-08-04 06:53:09 +04:00
}
}
var goButtonObserver = {
onDragOver: function(aEvent, aFlavour, aDragSession)
{
aEvent.target.setAttribute("dragover", "true");
return true;
},
onDragExit: function (aEvent, aDragSession)
{
aEvent.target.removeAttribute("dragover");
},
onDrop: function (aEvent, aXferData, aDragSession)
{
var xferData = aXferData.data.split("\n");
var uri = xferData[0] ? xferData[0] : xferData[1];
if (uri)
loadURI(uri);
},
getSupportedFlavours: function ()
{
var flavourSet = new FlavourSet();
flavourSet.appendFlavour("application/x-moz-file", "nsIFile");
flavourSet.appendFlavour("text/x-moz-url");
flavourSet.appendFlavour("text/unicode");
return flavourSet;
}
}
2003-12-01 09:33:00 +03:00
var DownloadsButtonDNDObserver = {
/////////////////////////////////////////////////////////////////////////////
// nsDragAndDrop
onDragOver: function (aEvent, aFlavour, aDragSession)
{
aDragSession.canDrop = (aFlavour.contentType == "text/x-moz-url" ||
aFlavour.contentType == "text/unicode");
},
onDrop: function (aEvent, aXferData, aDragSession)
{
var split = aXferData.data.split("\n");
var url = split[0];
if (url != aXferData.data) { //do nothing, not a valid URL
var name = split[1];
saveURL(url, name, null, true, true);
}
},
getSupportedFlavours: function ()
{
var flavourSet = new FlavourSet();
flavourSet.appendFlavour("text/x-moz-url");
flavourSet.appendFlavour("text/unicode");
return flavourSet;
}
}
function focusSearchBar()
2002-09-21 01:56:57 +04:00
{
var searchBar = document.getElementById("search-bar");
if (searchBar) {
searchBar.select();
searchBar.focus();
2002-09-21 01:56:57 +04:00
}
}
function OpenSearch(tabName, searchStr, newTabFlag)
2002-09-21 01:56:57 +04:00
{
//This function needs to be split up someday.
//XXXnoririty I don't want any prefs switching open by tabs to window
//XXXpch: this routine needs to be cleaned up.
2002-09-21 01:56:57 +04:00
var defaultSearchURL = null;
var navigatorRegionBundle = document.getElementById("bundle_browser_region");
var fallbackDefaultSearchURL = navigatorRegionBundle.getString("fallbackDefaultSearchURL");
2002-09-21 01:56:57 +04:00
//Check to see if search string contains "://" or "ftp." or white space.
//If it does treat as url and match for pattern
var urlmatch= /(:\/\/|^ftp\.)[^ \S]+$/
var forceAsURL = urlmatch.test(searchStr);
try {
2002-10-13 20:28:34 +04:00
defaultSearchURL = gPrefService.getComplexValue("browser.search.defaulturl",
2002-09-21 01:56:57 +04:00
Components.interfaces.nsIPrefLocalizedString).data;
} catch (ex) {
}
// Fallback to a default url (one that we can get sidebar search results for)
if (!defaultSearchURL)
defaultSearchURL = fallbackDefaultSearchURL;
if (!searchStr) {
BrowserSearchInternet();
} else {
//Check to see if location bar field is a url
//If it is a url go to URL. A Url is "://" or "." as commented above
//Otherwise search on entry
if (forceAsURL) {
BrowserLoadURL()
} else {
if (searchStr) {
var escapedSearchStr = encodeURIComponent(searchStr);
defaultSearchURL += escapedSearchStr;
var searchDS = Components.classes["@mozilla.org/rdf/datasource;1?name=internetsearch"]
.getService(Components.interfaces.nsIInternetSearchService);
2002-09-21 01:56:57 +04:00
searchDS.RememberLastSearchText(escapedSearchStr);
try {
var searchEngineURI = gPrefService.getCharPref("browser.search.defaultengine");
if (searchEngineURI) {
var searchURL = getSearchUrl("actionButton");
if (searchURL) {
defaultSearchURL = searchURL + escapedSearchStr;
} else {
searchURL = searchDS.GetInternetSearchURL(searchEngineURI, escapedSearchStr, 0, 0, {value:0});
if (searchURL)
defaultSearchURL = searchURL;
2002-09-21 01:56:57 +04:00
}
}
} catch (ex) {
2002-09-21 01:56:57 +04:00
}
if (!newTabFlag) {
loadURI(defaultSearchURL);
}
else {
var newTab = getBrowser().addTab(defaultSearchURL);
if (!pref.getBoolPref("browser.tabs.loadInBackground"))
getBrowser().selectedTab = newTab;
}
2002-09-21 01:56:57 +04:00
}
}
}
}
2002-08-04 06:53:09 +04:00
function FillHistoryMenu(aParent, aMenu)
{
// Remove old entries if any
deleteHistoryItems(aParent);
var sessionHistory = getWebNavigation().sessionHistory;
var count = sessionHistory.count;
var index = sessionHistory.index;
var end;
var j;
var entry;
switch (aMenu)
{
case "back":
end = (index > MAX_HISTORY_MENU_ITEMS) ? index - MAX_HISTORY_MENU_ITEMS : 0;
if ((index - 1) < end) return false;
for (j = index - 1; j >= end; j--)
{
entry = sessionHistory.getEntryAtIndex(j, false);
if (entry)
createMenuItem(aParent, j, entry.title);
}
break;
case "forward":
end = ((count-index) > MAX_HISTORY_MENU_ITEMS) ? index + MAX_HISTORY_MENU_ITEMS : count;
if ((index + 1) >= end) return false;
for (j = index + 1; j < end; j++)
{
entry = sessionHistory.getEntryAtIndex(j, false);
if (entry)
createMenuItem(aParent, j, entry.title);
}
break;
case "go":
aParent.lastChild.hidden = (count == 0);
end = count > MAX_HISTORY_MENU_ITEMS ? count - MAX_HISTORY_MENU_ITEMS : 0;
for (j = count - 1; j >= end; j--)
{
entry = sessionHistory.getEntryAtIndex(j, false);
if (entry)
createRadioMenuItem(aParent, j, entry.title, j==index);
}
break;
}
return true;
}
function addToUrlbarHistory()
{
var urlToAdd = gURLBar.value;
if (!urlToAdd)
return;
if (urlToAdd.search(/[\x00-\x1F]/) != -1) // don't store bad URLs
return;
if (!gGlobalHistory)
gGlobalHistory = Components.classes["@mozilla.org/browser/global-history;1"]
.getService(Components.interfaces.nsIBrowserHistory);
if (!gURIFixup)
gURIFixup = Components.classes["@mozilla.org/docshell/urifixup;1"]
.getService(Components.interfaces.nsIURIFixup);
try {
if (urlToAdd.indexOf(" ") == -1) {
var fixedUpURI = gURIFixup.createFixupURI(urlToAdd, 0);
gGlobalHistory.markPageAsTyped(fixedUpURI.spec);
}
}
catch(ex) {
}
2002-08-04 06:53:09 +04:00
}
function createMenuItem( aParent, aIndex, aLabel)
{
var menuitem = document.createElement( "menuitem" );
menuitem.setAttribute( "label", aLabel );
menuitem.setAttribute( "index", aIndex );
aParent.appendChild( menuitem );
}
function createRadioMenuItem( aParent, aIndex, aLabel, aChecked)
{
var menuitem = document.createElement( "menuitem" );
menuitem.setAttribute( "type", "radio" );
menuitem.setAttribute( "label", aLabel );
menuitem.setAttribute( "index", aIndex );
if (aChecked==true)
menuitem.setAttribute( "checked", "true" );
aParent.appendChild( menuitem );
}
function deleteHistoryItems(aParent)
{
var children = aParent.childNodes;
for (var i = 0; i < children.length; i++)
{
var index = children[i].getAttribute("index");
if (index)
aParent.removeChild(children[i]);
}
}
2002-08-04 06:53:09 +04:00
function toJavaScriptConsole()
{
toOpenWindowByType("global:console", "chrome://global/content/console.xul");
2002-08-04 06:53:09 +04:00
}
2003-12-01 09:33:00 +03:00
function toOpenWindowByType(inType, uri, features)
2002-08-04 06:53:09 +04:00
{
var windowManager = Components.classes['@mozilla.org/appshell/window-mediator;1'].getService();
2002-10-14 03:48:03 +04:00
var windowManagerInterface = windowManager.QueryInterface(Components.interfaces.nsIWindowMediator);
var topWindow = windowManagerInterface.getMostRecentWindow(inType);
2002-08-04 06:53:09 +04:00
2003-12-01 09:33:00 +03:00
if (topWindow)
2002-08-04 06:53:09 +04:00
topWindow.focus();
2003-12-01 09:33:00 +03:00
else if (features)
window.open(uri, "_blank", features);
2002-08-04 06:53:09 +04:00
else
window.open(uri, "_blank", "chrome,extrachrome,menubar,resizable,scrollbars,status,toolbar");
}
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 startpage = handler.defaultArgs;
var url = handler.chromeUrlForTask;
2002-08-04 06:53:09 +04:00
var wintype = document.firstChild.getAttribute('windowtype');
// 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);
}
}
2002-09-18 06:10:04 +04:00
function openAboutDialog()
2002-08-04 06:53:09 +04:00
{
2002-09-18 05:15:02 +04:00
window.openDialog("chrome://browser/content/aboutDialog.xul", "About", "modal,centerscreen,chrome,resizable=no");
2002-08-04 06:53:09 +04:00
}
2002-08-05 13:18:01 +04:00
function BrowserCustomizeToolbar()
{
2002-10-20 12:03:51 +04:00
// Disable the toolbar context menu items
var menubar = document.getElementById("main-menubar");
for (var i = 0; i < menubar.childNodes.length; ++i)
menubar.childNodes[i].setAttribute("disabled", true);
var cmd = document.getElementById("cmd_CustomizeToolbars");
cmd.setAttribute("disabled", "true");
window.openDialog("chrome://global/content/customizeToolbar.xul", "CustomizeToolbar",
"chrome,all,dependent", document.getElementById("navigator-toolbox"));
}
function BrowserToolboxCustomizeDone(aToolboxChanged)
{
// Update global UI elements that may have been added or removed
if (aToolboxChanged) {
gURLBar = document.getElementById("urlbar");
gProxyButton = document.getElementById("page-proxy-button");
gProxyFavIcon = document.getElementById("page-proxy-favicon");
gProxyDeck = document.getElementById("page-proxy-deck");
gHomeButton.updateTooltip();
window.XULBrowserWindow.init();
}
// Update the urlbar
var url = getWebNavigation().currentURI.spec;
if (gURLBar) {
gURLBar.value = url;
var uri = Components.classes["@mozilla.org/network/standard-url;1"]
.createInstance(Components.interfaces.nsIURI);
uri.spec = url;
SetPageProxyState("valid", uri);
}
// Re-enable parts of the UI we disabled during the dialog
var menubar = document.getElementById("main-menubar");
for (var i = 0; i < menubar.childNodes.length; ++i)
menubar.childNodes[i].setAttribute("disabled", false);
var cmd = document.getElementById("cmd_CustomizeToolbars");
cmd.removeAttribute("disabled");
// XXX Shouldn't have to do this, but I do
window.focus();
2002-08-05 13:18:01 +04:00
}
var FullScreen =
{
toggle: function()
{
// show/hide all menubars, toolbars, and statusbars (except the full screen toolbar)
this.showXULChrome("toolbar", window.fullScreen);
this.showXULChrome("statusbar", window.fullScreen);
},
showXULChrome: function(aTag, aShow)
{
var XULNS = "http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul";
var els = document.getElementsByTagNameNS(XULNS, aTag);
var i;
for (i = 0; i < els.length; ++i) {
// XXX don't interfere with previously collapsed toolbars
if (els[i].getAttribute("fullscreentoolbar") == "true") {
2002-09-20 07:52:36 +04:00
if (!aShow) {
gToolbarMode = els[i].getAttribute("mode");
gIconSize = els[i].getAttribute("iconsize");
// It's okay to display full screen in text mode.
// Otherwise we'll switch to small icons.
if (gToolbarMode != "text") {
els[i].setAttribute("mode", "icons");
els[i].setAttribute("iconsize", "small");
}
2002-09-20 07:52:36 +04:00
}
else {
els[i].setAttribute("mode", gToolbarMode);
els[i].setAttribute("iconsize", gIconSize);
}
} else {
// use moz-collapsed so it doesn't persist hidden/collapsed,
// so that new windows don't have missing toolbars
if (aShow)
els[i].removeAttribute("moz-collapsed");
else
els[i].setAttribute("moz-collapsed", "true");
}
}
var controls = document.getElementsByAttribute("fullscreencontrol", "true");
for (i = 0; i < controls.length; ++i)
controls[i].hidden = aShow;
// XXXBlake
var toolbox = document.getElementById("navigator-toolbox");
if (!aShow && gToolbarMode != "text") {
toolbox.setAttribute("mode", "icons");
toolbox.setAttribute("iconsize", "small");
}
else if (aShow) {
toolbox.setAttribute("mode", gToolbarMode);
toolbox.setAttribute("iconsize", gIconSize);
}
2002-10-18 14:05:47 +04:00
}
};
2002-08-09 05:41:39 +04:00
function nsBrowserStatusHandler()
{
this.init();
}
nsBrowserStatusHandler.prototype =
{
// Stored Status, Link and Loading values
status : "",
defaultStatus : "",
jsStatus : "",
jsDefaultStatus : "",
overLink : "",
startTime : 0,
2002-10-13 06:22:40 +04:00
statusText: "",
2002-08-09 05:41:39 +04:00
statusTimeoutInEffect : false,
QueryInterface : function(aIID)
{
if (aIID.equals(Components.interfaces.nsIWebProgressListener) ||
aIID.equals(Components.interfaces.nsISupportsWeakReference) ||
aIID.equals(Components.interfaces.nsIXULBrowserWindow) ||
aIID.equals(Components.interfaces.nsISupports))
return this;
throw Components.results.NS_NOINTERFACE;
},
init : function()
{
this.throbberElement = document.getElementById("navigator-throbber");
this.statusMeter = document.getElementById("statusbar-icon");
this.stopCommand = document.getElementById("Browser:Stop");
this.statusTextField = document.getElementById("statusbar-display");
this.securityButton = document.getElementById("security-button");
// Initialize the security button's state and tooltip text
const nsIWebProgressListener = Components.interfaces.nsIWebProgressListener;
this.onSecurityChange(null, null, nsIWebProgressListener.STATE_IS_INSECURE);
},
destroy : function()
{
// XXXjag to avoid leaks :-/, see bug 60729
this.throbberElement = null;
this.statusMeter = null;
this.stopCommand = null;
this.statusTextField = null;
this.securityButton = null;
2002-10-13 06:22:40 +04:00
this.statusText = null;
2002-08-09 05:41:39 +04:00
},
setJSStatus : function(status)
{
this.jsStatus = status;
this.updateStatusField();
},
setJSDefaultStatus : function(status)
{
this.jsDefaultStatus = status;
this.updateStatusField();
},
setDefaultStatus : function(status)
{
this.defaultStatus = status;
this.updateStatusField();
},
setOverLink : function(link, b)
{
this.overLink = link;
this.updateStatusField();
},
updateStatusField : function()
{
var text = this.overLink || this.status || this.jsStatus || this.jsDefaultStatus || this.defaultStatus;
// check the current value so we don't trigger an attribute change
// and cause needless (slow!) UI updates
2002-10-13 06:22:40 +04:00
if (this.statusText != text) {
2002-08-09 05:41:39 +04:00
this.statusTextField.label = text;
2002-10-13 06:22:40 +04:00
this.statusText = text;
}
2002-08-09 05:41:39 +04:00
},
onLinkIconAvailable : function(aHref)
{
var browser = getBrowser()
2002-09-19 00:11:30 +04:00
if (gProxyFavIcon) {
if (browser.userTypedValue === null)
gProxyFavIcon.setAttribute("src", aHref);
2002-08-09 05:41:39 +04:00
}
},
onProgressChange : function (aWebProgress, aRequest,
aCurSelfProgress, aMaxSelfProgress,
aCurTotalProgress, aMaxTotalProgress)
{
if (aMaxTotalProgress > 0) {
// This is highly optimized. Don't touch this code unless
// you are intimately familiar with the cost of setting
// attrs on XUL elements. -- hyatt
var percentage = (aCurTotalProgress * 100) / aMaxTotalProgress;
this.statusMeter.value = percentage;
}
},
onStateChange : function(aWebProgress, aRequest, aStateFlags, aStatus)
{
const nsIWebProgressListener = Components.interfaces.nsIWebProgressListener;
const nsIChannel = Components.interfaces.nsIChannel;
if (aStateFlags & nsIWebProgressListener.STATE_START) {
// This (thanks to the filter) is a network start or the first
// stray request (the first request outside of the document load),
// initialize the throbber and his friends.
2002-08-09 05:41:39 +04:00
// Call start document load listeners (only if this is a network load)
if (aStateFlags & nsIWebProgressListener.STATE_IS_NETWORK &&
aRequest && aWebProgress.DOMWindow == content)
this.startDocumentLoad(aRequest);
2002-10-13 06:22:40 +04:00
if (this.throbberElement) {
// Turn the throbber on.
this.throbberElement.setAttribute("busy", "true");
}
2002-08-09 05:41:39 +04:00
// Turn the status meter on.
this.statusMeter.value = 0; // be sure to clear the progress bar
if (gProgressCollapseTimer) {
window.clearTimeout(gProgressCollapseTimer);
gProgressCollapseTimer = null;
}
else
this.statusMeter.parentNode.collapsed = false;
2002-08-09 05:41:39 +04:00
// XXX: This needs to be based on window activity...
2002-08-10 04:55:06 +04:00
this.stopCommand.removeAttribute("disabled");
2002-08-09 05:41:39 +04:00
}
else if (aStateFlags & nsIWebProgressListener.STATE_STOP) {
if (aStateFlags & nsIWebProgressListener.STATE_IS_NETWORK) {
if (aRequest) {
if (aWebProgress.DOMWindow == content)
this.endDocumentLoad(aRequest, aStatus);
}
}
// This (thanks to the filter) is a network stop or the last
// request stop outside of loading the document, stop throbbers
// and progress bars and such
if (aRequest) {
var msg = "";
// Get the channel if the request is a channel
var channel;
try {
channel = aRequest.QueryInterface(nsIChannel);
}
catch(e) { };
2002-08-09 05:41:39 +04:00
if (channel) {
var location = channel.URI.spec;
if (location != "about:blank") {
const kErrorBindingAborted = 0x804B0002;
const kErrorNetTimeout = 0x804B000E;
2002-08-09 05:41:39 +04:00
switch (aStatus) {
case kErrorBindingAborted:
msg = gNavigatorBundle.getString("nv_stopped");
break;
case kErrorNetTimeout:
msg = gNavigatorBundle.getString("nv_timeout");
break;
}
}
}
// If msg is false then we did not have an error (channel may have
// been null, in the case of a stray image load).
if (!msg) {
msg = gNavigatorBundle.getString("nv_done");
}
this.status = "";
this.setDefaultStatus(msg);
}
// Turn the progress meter and throbber off.
gProgressCollapseTimer = window.setTimeout("gProgressMeterPanel.collapsed = true; gProgressCollapseTimer = null;",
100);
if (this.throbberElement)
this.throbberElement.removeAttribute("busy");
2002-08-09 05:41:39 +04:00
this.stopCommand.setAttribute("disabled", "true");
}
},
onLocationChange : function(aWebProgress, aRequest, aLocation)
{
this.setOverLink("", null);
var location = aLocation.spec;
if (location == "about:blank")
location = "";
2002-08-09 05:41:39 +04:00
// We should probably not do this if the value has changed since the user
// searched
// Update urlbar only if a new page was loaded on the primary content area
// Do not update urlbar if there was a subframe navigation
var browser = getBrowser().selectedBrowser;
2002-08-09 05:41:39 +04:00
if (aWebProgress.DOMWindow == content) {
2002-09-20 07:52:36 +04:00
//XXXBlake don't we have to reinit this.urlBar, etc.
// when the toolbar changes?
var userTypedValue = browser.userTypedValue;
if (gURLBar && !userTypedValue) {
2002-08-09 05:41:39 +04:00
// If the url has "wyciwyg://" as the protocol, strip it off.
// Nobody wants to see it on the urlbar for dynamically generated
// pages.
if (/^\s*wyciwyg:\/\/\d+\//.test(location))
location = RegExp.rightContext;
2002-10-13 08:52:35 +04:00
setTimeout(function(loc, aloc) { gURLBar.value = loc; SetPageProxyState("valid", aloc);}, 0, location, aLocation);
// Setting the urlBar value in some cases causes userTypedValue to
// become set because of oninput, so reset it to its old value.
browser.userTypedValue = userTypedValue;
} else {
gURLBar.value = userTypedValue;
SetPageProxyState("invalid", null);
2002-08-09 05:41:39 +04:00
}
}
UpdateBackForwardButtons();
setTimeout("updatePageTheme();", 0);
2002-08-09 05:41:39 +04:00
},
onStatusChange : function(aWebProgress, aRequest, aStatus, aMessage)
{
this.status = aMessage;
this.updateStatusField();
},
onSecurityChange : function(aWebProgress, aRequest, aState)
{
const wpl = Components.interfaces.nsIWebProgressListener;
switch (aState) {
case wpl.STATE_IS_SECURE | wpl.STATE_SECURE_HIGH:
this.securityButton.setAttribute("level", "high");
break;
case wpl.STATE_IS_SECURE | wpl.STATE_SECURE_LOW:
this.securityButton.setAttribute("level", "low");
break;
case wpl.STATE_IS_BROKEN:
this.securityButton.setAttribute("level", "broken");
break;
case wpl.STATE_IS_INSECURE:
default:
this.securityButton.removeAttribute("level");
break;
}
var securityUI = gBrowser.securityUI;
2002-08-09 05:41:39 +04:00
if (securityUI)
this.securityButton.setAttribute("tooltiptext", securityUI.tooltipText);
else
this.securityButton.removeAttribute("tooltiptext");
},
startDocumentLoad : function(aRequest)
{
// Reset so we can see if the user typed between the document load
2002-08-09 05:41:39 +04:00
// starting and the location changing.
getBrowser().userTypedValue = null;
2002-08-09 05:41:39 +04:00
const nsIChannel = Components.interfaces.nsIChannel;
var urlStr = aRequest.QueryInterface(nsIChannel).URI.spec;
var observerService = Components.classes["@mozilla.org/observer-service;1"]
.getService(Components.interfaces.nsIObserverService);
try {
observerService.notifyObservers(_content, "StartDocumentLoad", urlStr);
} catch (e) {
}
},
endDocumentLoad : function(aRequest, aStatus)
{
const nsIChannel = Components.interfaces.nsIChannel;
var urlStr = aRequest.QueryInterface(nsIChannel).originalURI.spec;
var observerService = Components.classes["@mozilla.org/observer-service;1"]
.getService(Components.interfaces.nsIObserverService);
var notification = Components.isSuccessCode(aStatus) ? "EndDocumentLoad" : "FailDocumentLoad";
try {
observerService.notifyObservers(_content, notification, urlStr);
} catch (e) {
}
}
}
function onViewToolbarsPopupShowing(aEvent)
{
var popup = aEvent.target;
2002-10-18 14:05:47 +04:00
var i;
// Empty the menu
2002-10-18 14:05:47 +04:00
for (i = popup.childNodes.length-1; i >= 0; --i) {
var deadItem = popup.childNodes[i];
if (deadItem.hasAttribute("toolbarindex"))
popup.removeChild(deadItem);
}
var firstMenuItem = popup.firstChild;
var toolbox = document.getElementById("navigator-toolbox");
2002-10-18 14:05:47 +04:00
for (i = 0; i < toolbox.childNodes.length; ++i) {
var toolbar = toolbox.childNodes[i];
var toolbarName = toolbar.getAttribute("toolbarname");
2002-10-20 12:03:51 +04:00
var type = toolbar.getAttribute("type");
if (toolbarName && type != "menubar") {
var menuItem = document.createElement("menuitem");
menuItem.setAttribute("toolbarindex", i);
menuItem.setAttribute("type", "checkbox");
menuItem.setAttribute("label", toolbarName);
menuItem.setAttribute("accesskey", toolbar.getAttribute("accesskey"));
menuItem.setAttribute("checked", toolbar.getAttribute("collapsed") != "true");
popup.insertBefore(menuItem, firstMenuItem);
menuItem.addEventListener("command", onViewToolbarCommand, false);
}
toolbar = toolbar.nextSibling;
}
}
function onViewToolbarCommand(aEvent)
{
var toolbox = document.getElementById("navigator-toolbox");
var index = aEvent.originalTarget.getAttribute("toolbarindex");
var toolbar = toolbox.childNodes[index];
2003-08-10 08:28:02 +04:00
toolbar.collapsed = aEvent.originalTarget.getAttribute("checked") != "true";
document.persist(toolbar.id, "collapsed");
}
2002-08-09 05:41:39 +04:00
function displayPageInfo()
{
window.openDialog("chrome://browser/content/pageInfo.xul", "_blank",
2002-08-09 05:41:39 +04:00
"dialog=no", null, "securityTab");
}
2002-10-09 05:26:47 +04:00
function displayPageReportFirstTime()
{
window.openDialog("chrome://browser/content/pageReportFirstTime.xul", "_blank",
"modal");
}
2002-10-09 03:14:45 +04:00
function displayPageReport()
{
window.openDialog("chrome://browser/content/pageReport.xul", "_blank",
"dialog,modal,resizable");
2002-10-09 03:14:45 +04:00
}
2002-08-11 03:36:50 +04:00
function nsBrowserContentListener(toplevelWindow, contentWindow)
{
// this one is not as easy as you would hope.
// need to convert toplevelWindow to an XPConnected object, instead
// of a DOM-based object, to be able to QI() it to nsIXULWindow
this.init(toplevelWindow, contentWindow);
}
/* implements nsIURIContentListener */
nsBrowserContentListener.prototype =
{
init: function(toplevelWindow, contentWindow)
{
2002-10-14 03:48:03 +04:00
const nsIWebBrowserChrome = Components.interfaces.nsIWebBrowserChrome;
2002-08-11 03:36:50 +04:00
this.toplevelWindow = toplevelWindow;
this.contentWindow = contentWindow;
// hook up the whole parent chain thing
var windowDocShell = this.convertWindowToDocShell(toplevelWindow);
if (windowDocShell)
windowDocshell.parentURIContentListener = this;
var registerWindow = false;
try {
var treeItem = contentWindow.docShell.QueryInterface(Components.interfaces.nsIDocShellTreeItem);
var treeOwner = treeItem.treeOwner;
var interfaceRequestor = treeOwner.QueryInterface(Components.interfaces.nsIInterfaceRequestor);
var webBrowserChrome = interfaceRequestor.getInterface(nsIWebBrowserChrome);
if (webBrowserChrome)
{
var chromeFlags = webBrowserChrome.chromeFlags;
var res = chromeFlags & nsIWebBrowserChrome.CHROME_ALL;
var res2 = chromeFlags & nsIWebBrowserChrome.CHROME_DEFAULT;
if ( res == nsIWebBrowserChrome.CHROME_ALL || res2 == nsIWebBrowserChrome.CHROME_DEFAULT)
{
registerWindow = true;
}
}
} catch (ex) {}
// register ourselves
if (registerWindow)
{
var uriLoader = Components.classes["@mozilla.org/uriloader;1"].getService(Components.interfaces.nsIURILoader);
uriLoader.registerContentListener(this);
}
},
close: function()
{
this.contentWindow = null;
var uriLoader = Components.classes["@mozilla.org/uriloader;1"].getService(Components.interfaces.nsIURILoader);
uriLoader.unRegisterContentListener(this);
},
QueryInterface: function(iid)
{
if (iid.equals(Components.interfaces.nsIURIContentListener) ||
iid.equals(Components.interfaces.nsISupportsWeakReference) ||
iid.equals(Components.interfaces.nsISupports))
return this;
2002-08-11 03:36:50 +04:00
throw Components.results.NS_NOINTERFACE;
},
onStartURIOpen: function(uri)
{
// ignore and don't abort
return false;
},
doContent: function(contentType, isContentPreferred, request, contentHandler)
{
// forward the doContent to our content area webshell
var docShell = this.contentWindow.docShell;
var contentListener;
try {
contentListener =
docShell.QueryInterface(Components.interfaces.nsIInterfaceRequestor)
.getInterface(Components.interfaces.nsIURIContentListener);
} catch (ex) {
dump(ex);
}
if (!contentListener) return false;
return contentListener.doContent(contentType, isContentPreferred, request, contentHandler);
},
isPreferred: function(contentType, desiredContentType)
{
// seems like we should be getting this from helper apps or something
switch(contentType) {
case "text/html":
case "text/xul":
case "text/rdf":
case "text/xml":
case "text/css":
case "image/gif":
case "image/jpeg":
case "image/png":
case "text/plain":
case "application/http-index-format":
return true;
}
return false;
},
canHandleContent: function(contentType, isContentPreferred, desiredContentType)
{
var docShell = this.contentWindow.docShell;
var contentListener;
try {
contentListener =
docShell.QueryInterface(Components.interfaces.nsIInterfaceRequestor).getInterface(Components.interfaces.nsIURIContentListener);
} catch (ex) {
dump(ex);
}
if (!contentListener) return false;
return contentListener.canHandleContent(contentType, isContentPreferred, desiredContentType);
},
convertWindowToDocShell: function(win) {
// don't know how to do this
return null;
},
loadCookie: null,
parentContentListener: null
}
2002-08-09 05:41:39 +04:00
// |forceOpen| is a bool that indicates that the sidebar should be forced open. In other words
// the toggle won't be allowed to close the sidebar.
function toggleSidebar(aCommandID, forceOpen) {
2002-09-29 02:55:58 +04:00
var sidebarBox = document.getElementById("sidebar-box");
2002-09-30 08:03:00 +04:00
if (!aCommandID)
aCommandID = sidebarBox.getAttribute("sidebarcommand");
var elt = document.getElementById(aCommandID);
var sidebar = document.getElementById("sidebar");
2002-09-29 02:55:58 +04:00
var sidebarTitle = document.getElementById("sidebar-title");
var sidebarSplitter = document.getElementById("sidebar-splitter");
2002-09-30 05:58:19 +04:00
if (elt.getAttribute("checked") == "true") {
if (!forceOpen) {
elt.removeAttribute("checked");
sidebarBox.setAttribute("sidebarcommand", "");
sidebarTitle.setAttribute("value", "");
sidebarBox.hidden = true;
sidebarSplitter.hidden = true;
}
return;
}
2002-09-30 05:58:19 +04:00
var elts = document.getElementsByAttribute("group", "sidebar");
for (var i = 0; i < elts.length; ++i)
elts[i].removeAttribute("checked");
elt.setAttribute("checked", "true");;
2002-09-29 02:55:58 +04:00
if (sidebarBox.hidden) {
sidebarBox.hidden = false;
sidebarSplitter.hidden = false;
}
2002-09-29 02:55:58 +04:00
2002-09-30 05:58:19 +04:00
var url = elt.getAttribute("sidebarurl");
var title = elt.getAttribute("sidebartitle");
2002-09-29 02:55:58 +04:00
if (!title)
2002-09-30 05:58:19 +04:00
title = elt.getAttribute("label");
sidebar.setAttribute("src", url);
sidebarBox.setAttribute("src", url);
2002-09-30 05:58:19 +04:00
sidebarBox.setAttribute("sidebarcommand", elt.id);
2002-09-29 02:55:58 +04:00
sidebarTitle.setAttribute("value", title);
}
function openPreferences()
{
openDialog("chrome://browser/content/pref/pref.xul","PrefWindow",
"chrome,titlebar,resizable,modal");
}
var gHomeButton = {
prefDomain: "browser.startup.homepage",
observe: function (aSubject, aTopic, aPrefName)
{
if (aTopic != "nsPref:changed" || aPrefName != this.prefDomain)
return;
this.updateTooltip();
},
updateTooltip: function ()
{
var homeButton = document.getElementById("home-button");
if (homeButton) {
var homePage = this.getHomePage();
homePage = homePage.replace(/\|/g,', ');
homeButton.setAttribute("tooltiptext", homePage);
}
},
getHomePage: function ()
{
var url;
try {
url = gPrefService.getComplexValue(this.prefDomain,
Components.interfaces.nsIPrefLocalizedString).data;
} catch (e) {
}
// use this if we can't find the pref
if (!url) {
var navigatorRegionBundle = document.getElementById("bundle_browser_region");
url = navigatorRegionBundle.getString("homePageDefault");
}
return url;
}
};
function nsContextMenu( xulMenu ) {
this.target = null;
this.menu = null;
this.onTextInput = false;
this.onImage = 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();
// 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.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.showItem( "context-sendpage", !( this.inDirList || this.isTextSelected || this.onTextInput || this.onLink ));
// 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.onImage );
this.showItem( "context-sendimage", this.onImage );
// Send link depends on whether we're in a link.
this.showItem( "context-sendlink", this.onSaveableLink );
},
initViewItems : function () {
// View source is always OK, unless in directory listing.
this.showItem( "context-viewpartialsource-selection", this.isTextSelected );
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.onImage );
if( isWin && this.onImage )
// 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 );
// View Image depends on whether an image was clicked on.
this.showItem( "context-viewimage", this.onImage );
// 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.onLink ) );
this.showItem( "context-bookmarklink", this.onLink && !this.onMailtoLink );
this.showItem( "context-searchselect", this.isTextSelected );
this.showItem( "frame", this.inFrame );
this.showItem( "frame-sep", this.inFrame );
this.showItem( "context-blockimage", this.onImage);
if (this.onImage) {
var blockImage = document.getElementById("context-blockimage");
var uri = Components.classes['@mozilla.org/network/standard-url;1'].createInstance(Components.interfaces.nsIURI);
uri.spec = this.imageURL;
var shortenedUriHost = uri.host.replace(/^www\./i,"");
if (shortenedUriHost.length > 15)
shortenedUriHost = shortenedUriHost.substr(0,15) + "...";
blockImage.label = gNavigatorBundle.getFormattedString ("blockImages", [shortenedUriHost]);
if (this.isImageBlocked()) {
blockImage.setAttribute("checked", "true");
}
else
blockImage.removeAttribute("checked");
}
},
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-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 );
2003-09-02 01:31:57 +04:00
this.showItem( "context-selectall", this.isTextSelected || this.onTextInput );
this.showItem( "context-sep-selectall", this.isTextSelected );
// 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 && this.onImage);
// 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.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.localName.toUpperCase() == "IMG" ) {
this.onImage = true;
this.imageURL = this.target.src;
// Look for image map.
var mapName = this.target.getAttribute( "usemap" );
if ( mapName ) {
// Find map.
var map = this.target.ownerDocument.getElementById( mapName.substr(1) );
if ( map ) {
// Search child <area>s for a match.
var areas = map.childNodes;
//XXX Client side image maps are too hard for now!
areas.length = 0;
for ( var i = 0; i < areas.length && !this.onLink; i++ ) {
var area = areas[i];
if ( area.nodeType == Node.ELEMENT_NODE
&&
area.localName.toUpperCase() == "AREA" ) {
// Get type (rect/circle/polygon/default).
var type = area.getAttribute( "type" );
var coords = this.parseCoords( area );
switch ( type.toUpperCase() ) {
case "RECT":
case "RECTANGLE":
break;
case "CIRC":
case "CIRCLE":
break;
case "POLY":
case "POLYGON":
break;
case "DEFAULT":
// Default matches entire image.
this.onLink = true;
this.link = area;
this.onSaveableLink = this.isLinkSaveable( this.link );
break;
}
}
}
}
}
} else if ( this.target.localName.toUpperCase() == "OBJECT"
&&
// See if object tag is for an image.
this.objectIsImage( this.target ) ) {
// This is an image.
this.onImage = true;
// URL must be constructed.
this.imageURL = this.objectImageURL( this.target );
} else if ( this.target.localName.toUpperCase() == "INPUT") {
type = this.target.getAttribute("type");
if(type && type.toUpperCase() == "IMAGE") {
this.onImage = true;
// Convert src attribute to absolute URL.
2002-10-14 03:52:36 +04:00
this.imageURL = makeURLAbsolute( this.target.baseURI,
this.target.src );
} else /* if (this.target.getAttribute( "type" ).toUpperCase() == "TEXT") */ {
this.onTextInput = this.isTargetATextBox(this.target);
}
} else if ( this.target.localName.toUpperCase() == "TEXTAREA" ) {
this.onTextInput = true;
} else if ( this.target.localName.toUpperCase() == "HTML" ) {
// pages with multiple <body>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;
2002-10-14 03:52:36 +04:00
this.bgImageURL = 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 ) {
var localname = elem.localName.toUpperCase();
// Link?
if ( !this.onLink &&
( (localname === "A" && elem.href) ||
localname === "AREA" ||
localname === "LINK" ||
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 ( ( localname === "BLOCKQUOTE" && 'cite' in elem && elem.cite) ||
( localname === "Q" && 'cite' in elem && elem.cite) ||
( localname === "TABLE" && 'summary' in elem && elem.summary) ||
( ( localname === "INS" || localname === "DEL" ) &&
( ( 'cite' in elem && elem.cite ) ||
( 'dateTime' in elem && elem.dateTime ) ) ) ||
( 'title' in elem && elem.title ) ||
( 'lang' in elem && 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;
2002-10-14 03:52:36 +04:00
this.bgImageURL = makeURLAbsolute( elem.baseURI,
bgImgUrl );
}
}
}
elem = elem.parentNode;
}
},
// 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;
}
},
// Open linked-to URL in a new window.
openLink : function () {
// Determine linked-to URL.
openNewWindowWith(this.linkURL(), this.link, true);
},
// Open linked-to URL in a new tab.
openLinkInTab : function () {
// Determine linked-to URL.
openNewTabWith(this.linkURL(), this.link, null, true);
},
// Open frame in a new tab.
openFrameInTab : function () {
// Determine linked-to URL.
openNewTabWith(this.target.ownerDocument.location.href, null, null, 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, null, true);
},
// 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.__proto__.getSelection.call(focusedWindow);
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://global/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);
},
// Change current window to the URL of the image.
viewImage : function () {
openTopWin( this.imageURL );
},
// 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, true );
},
sendLink : function () {
sendLink( this.linkURL(), "" ); // we don't know the title of the link so pass in an empty string
},
// Save URL of clicked-on image.
saveImage : function () {
saveURL( this.imageURL, null, "SaveImageTitle", false );
},
sendImage : function () {
sendImage(this.imageURL);
},
toggleImageBlocking : function (aBlock) {
var nsIPermissionManager = Components.interfaces.nsIPermissionManager;
var permissionmanager =
Components.classes["@mozilla.org/permissionmanager;1"]
.getService(nsIPermissionManager);
var uri = Components.classes["@mozilla.org/network/standard-url;1"]
.createInstance(Components.interfaces.nsIURI);
uri.spec = this.imageURL;
permissionmanager.add(uri, "image",
aBlock ? nsIPermissionManager.DENY_ACTION : nsIPermissionManager.ALLOW_ACTION);
},
isImageBlocked : function() {
var nsIPermissionManager = Components.interfaces.nsIPermissionManager;
var permissionmanager =
Components.classes["@mozilla.org/permissionmanager;1"]
.getService(Components.interfaces.nsIPermissionManager);
var uri = Components.classes["@mozilla.org/network/standard-url;1"]
.createInstance(Components.interfaces.nsIURI);
uri.spec = this.imageURL;
return permissionmanager.testPermission(uri, "image") == nsIPermissionManager.DENY_ACTION;
},
// 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.
var url = this.linkURL();
var qmark = url.indexOf( "?" );
var addresses;
if ( qmark > 7 ) { // 7 == length of "mailto:"
addresses = url.substring( 7, qmark );
} else {
addresses = url.substr( 7 );
}
var clipboard = this.getService( "@mozilla.org/widget/clipboardhelper;1",
Components.interfaces.nsIClipboardHelper );
clipboard.copyString(addresses);
},
addBookmark : function() {
var docshell = document.getElementById( "content" ).webNavigation;
BookmarksUtils.addBookmark( docshell.currentURI.spec,
docshell.document.title,
docshell.document.charset);
},
addBookmarkForFrame : function() {
var doc = this.target.ownerDocument;
var uri = doc.location.href;
var title = doc.title;
if ( !title )
title = uri;
BookmarksUtils.addBookmark(uri, title, doc.charset);
},
// Open Metadata window for node
showMetadata : function () {
window.openDialog( "chrome://browser/content/metaData.xul",
"_blank",
"scrollbars,resizable,chrome,dialog=no",
this.target);
},
///////////////
// 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
}
2002-10-14 03:52:36 +04:00
href = 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/)) {
2002-10-14 03:52:36 +04:00
text = 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(16);
var searchSelectText;
if (selection != "") {
searchSelectText = selection.toString();
if (searchSelectText.length > 15)
searchSelectText = searchSelectText.substr(0,15) + "...";
result = true;
// format "Search for <selection>" string to show in menu
searchSelectText = gNavigatorBundle.getFormattedString("searchText", [searchSelectText]);
this.setItemAttr("context-searchselect", "label", searchSelectText);
}
return result;
},
searchSelected : function( charlen ) {
var focusedWindow = document.commandDispatcher.focusedWindow;
var searchStr = focusedWindow.__proto__.getSelection.call(focusedWindow);
searchStr = searchStr.toString();
// searching for more than 150 chars makes no sense
if (!charlen)
charlen = 150;
if (charlen < searchStr.length) {
// only use the first charlen important chars. see bug 221361
var pattern = new RegExp("^(?:\\s*.){0," + charlen + "}");
pattern.test(searchStr);
searchStr = RegExp.lastMatch;
}
searchStr = searchStr.replace(/\s*(.*?)\s*$/, "$1");
searchStr = searchStr.replace(/\s+/g, " ");
return searchStr;
},
// Determine if target <object> is an image.
objectIsImage : function ( objElem ) {
var result = false;
// Get type and data attributes.
var type = objElem.getAttribute( "type" );
var data = objElem.getAttribute( "data" );
// Presume any mime type of the form "image/..." is an image.
// There must be a data= attribute with an URL, also.
if ( type.substring( 0, 6 ) == "image/" && data && data != "" ) {
result = true;
}
return result;
},
// Extract image URL from <object> tag.
objectImageURL : function ( objElem ) {
// Extract url from data= attribute.
var data = objElem.getAttribute( "data" );
// Make it absolute.
2002-10-14 03:52:36 +04:00
return makeURLAbsolute( objElem.baseURI, data );
},
// Parse coords= attribute and return array.
parseCoords : function ( area ) {
return [];
},
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.nodeType != Node.ELEMENT_NODE)
return false;
if (node.localName.toUpperCase() == "INPUT") {
var attrib = "";
var type = node.getAttribute("type");
if (type)
attrib = type.toUpperCase();
return( (attrib != "IMAGE") &&
(attrib != "CHECKBOX") &&
(attrib != "RADIO") &&
(attrib != "SUBMIT") &&
(attrib != "RESET") &&
(attrib != "FILE") &&
(attrib != "HIDDEN") &&
(attrib != "RESET") &&
(attrib != "BUTTON") );
} else {
return(node.localName.toUpperCase() == "TEXTAREA");
}
},
// 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;
}
}
var gWebPanelURI;
function openWebPanel(aTitle, aURI)
{
// Ensure that the web panels sidebar is open.
toggleSidebar('viewWebPanelsSidebar', true);
// Set the title of the panel.
document.getElementById("sidebar-title").value = aTitle;
// Tell the Web Panels sidebar to load the bookmark.
var sidebar = document.getElementById("sidebar");
if (sidebar.contentDocument && sidebar.contentDocument.getElementById('web-panels-browser')) {
sidebar.contentWindow.loadWebPanel(aURI);
if (gWebPanelURI) {
gWebPanelURI = "";
sidebar.removeEventListener("load", asyncOpenWebPanel, true);
}
}
else {
// The panel is still being constructed. Attach an onload handler.
if (!gWebPanelURI)
sidebar.addEventListener("load", asyncOpenWebPanel, true);
gWebPanelURI = aURI;
}
}
function asyncOpenWebPanel(event)
{
var sidebar = document.getElementById("sidebar");
if (gWebPanelURI && sidebar.contentDocument && sidebar.contentDocument.getElementById('web-panels-browser'))
sidebar.contentWindow.loadWebPanel(gWebPanelURI);
gWebPanelURI = "";
sidebar.removeEventListener("load", asyncOpenWebPanel, true);
}
/*
* - [ Dependencies ] ---------------------------------------------------------
* utilityOverlay.js:
* - gatherTextUnder
*/
2002-10-14 03:52:36 +04:00
// 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
2003-08-02 11:48:07 +04:00
function contentAreaClick(event, fieldNormalClicks)
2002-10-14 03:52:36 +04:00
{
var target = event.target;
var linkNode;
var local_name = target.localName;
if (local_name) {
local_name = local_name.toLowerCase();
}
switch (local_name) {
case "a":
case "area":
case "link":
if (target.hasAttribute("href"))
linkNode = target;
break;
default:
linkNode = findParentNode(event.originalTarget, "a");
// <a> cannot be nested. So if we find an anchor without an
// href, there is no useful <a> around the target
if (linkNode && !linkNode.hasAttribute("href"))
linkNode = null;
break;
}
if (linkNode) {
if (event.button == 0 && !event.ctrlKey && !event.shiftKey &&
!event.altKey && !event.metaKey) {
// A Web panel's links should target the main content area. Do this
// if no modifier keys are down and if there's no target or the target equals
// _main (the IE convention) or _content (the Mozilla convention).
// The only reason we field _main and _content here is for the markLinkVisited
// hack.
target = linkNode.getAttribute("target");
if (fieldNormalClicks &&
(!target || target == "_content" || target == "_main"))
// IE uses _main, SeaMonkey uses _content, we support both
{
2003-08-09 13:07:46 +04:00
if (!linkNode.href) return true;
if (linkNode.getAttribute("onclick")) return true;
var url = getShortcutOrURI(linkNode.href);
if (!url)
2003-08-09 13:07:46 +04:00
return true;
markLinkVisited(linkNode.href, linkNode);
loadURI(url);
event.preventDefault();
return false;
}
else if (linkNode.getAttribute("rel") == "sidebar") {
// This is the Opera convention for a special link that - when clicked - allows
// you to add a sidebar panel. We support the Opera convention here. The link's
// title attribute contains the title that should be used for the sidebar panel.
openDialog("chrome://browser/content/bookmarks/addBookmark2.xul", "",
"centerscreen,chrome,dialog,resizable,dependent",
linkNode.getAttribute("title"),
linkNode.href, null, null, null, null, true);
event.preventDefault();
2003-08-02 11:48:07 +04:00
return false;
}
else if (target == "_search") {
// Used in WinIE as a way of transiently loading pages in a sidebar. We
// mimic that WinIE functionality here and also load the page transiently.
openWebPanel(gNavigatorBundle.getString("webPanels"), linkNode.href);
event.preventDefault();
return false;
}
2003-08-02 11:48:07 +04:00
}
else
handleLinkClick(event, linkNode.href, linkNode);
2002-10-14 03:52:36 +04:00
return true;
} else {
// Try simple XLink
var href;
linkNode = target;
while (linkNode) {
if (linkNode.nodeType == Node.ELEMENT_NODE) {
href = linkNode.getAttributeNS("http://www.w3.org/1999/xlink", "href");
break;
}
linkNode = linkNode.parentNode;
}
if (href && href != "") {
href = makeURLAbsolute(target.baseURI,href);
handleLinkClick(event, href, null);
return true;
}
}
if (event.button == 1 &&
2002-10-14 03:52:36 +04:00
!findParentNode(event.originalTarget, "scrollbar") &&
gPrefService.getBoolPref("middlemouse.contentLoadURL")) {
if (middleMousePaste(event)) {
event.preventBubble();
}
}
return true;
}
function handleLinkClick(event, href, linkNode)
{
switch (event.button) {
case 0:
#ifdef XP_MACOSX
if (event.metaKey) {
#else
if (event.ctrlKey) {
#endif
openNewTabWith(href, linkNode, event, true);
event.preventBubble();
return true;
}
// if left button clicked
if (event.shiftKey) {
openNewWindowWith(href, linkNode, true);
event.preventBubble();
return true;
}
if (event.altKey) {
saveURL(href, linkNode ? gatherTextUnder(linkNode) : "", null, true, true);
return true;
}
2002-10-14 03:52:36 +04:00
return false;
case 1: // if middle button clicked
var tab;
try {
tab = gPrefService.getBoolPref("browser.tabs.opentabfor.middleclick")
}
catch(ex) {
tab = true;
}
if (tab)
openNewTabWith(href, linkNode, event, true);
else
openNewWindowWith(href, linkNode, true);
event.preventBubble();
return true;
}
2002-10-14 03:52:36 +04:00
return false;
}
function middleMousePaste(event)
2002-10-14 03:52:36 +04:00
{
var url = readFromClipboard();
if (!url)
return false;
url = getShortcutOrURI(url);
if (!url)
return false;
// On ctrl-middleclick, open in new tab.
#ifdef XP_MACOSX
if (event.metaKey)
#else
if (event.ctrlKey)
#endif
openNewTabWith(url, null, event, true);
2002-10-14 03:52:36 +04:00
// If ctrl wasn't down, then just load the url in the current win/tab.
loadURI(url);
event.preventBubble();
return true;
}
2002-10-14 03:52:36 +04:00
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);
2002-10-14 03:52:36 +04:00
return ioService.newURI(baseURI.resolve(url), null, null).spec;
}
function findParentNode(node, parentNode)
{
if (node && node.nodeType == Node.TEXT_NODE) {
node = node.parentNode;
}
while (node) {
var nodeName = node.localName;
if (!nodeName)
return null;
nodeName = nodeName.toLowerCase();
if (nodeName == "body" || nodeName == "html" ||
nodeName == "#document") {
return null;
}
if (nodeName == parentNode)
return node;
node = node.parentNode;
}
return null;
}
function saveFrameDocument()
{
var focusedWindow = document.commandDispatcher.focusedWindow;
if (isContentFrame(focusedWindow))
saveDocument(focusedWindow.document);
}
2002-12-07 23:44:19 +03:00
/*
* Note that most of this routine has been moved into C++ in order to
* be available for all <browser> 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 so bail out
if (!url || !url.length || url.indexOf(" ", 0) != -1)
return;
switch (document.firstChild.getAttribute('windowtype')) {
case "navigator:browser":
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;
}
};
// For extensions
function getBrowser()
{
2002-12-07 23:44:19 +03:00
if (!gBrowser)
gBrowser = document.getElementById("content");
return gBrowser;
}
function MultiplexHandler(event)
{ try {
var node = event.target;
var name = node.getAttribute('name');
if (name == 'detectorGroup') {
2002-12-07 23:44:19 +03:00
SetForcedDetector(true);
SelectDetector(event, false);
} else if (name == 'charsetGroup') {
var charset = node.getAttribute('id');
charset = charset.substring('charset.'.length, charset.length)
SetForcedCharset(charset);
SetDefaultCharacterSet(charset);
} else if (name == 'charsetCustomize') {
//do nothing - please remove this else statement, once the charset prefs moves to the pref window
} else {
SetForcedCharset(node.getAttribute('id'));
SetDefaultCharacterSet(node.getAttribute('id'));
}
2002-12-07 23:44:19 +03:00
} catch(ex) { alert(ex); }
}
function SetDefaultCharacterSet(charset)
{
BrowserSetDefaultCharacterSet(charset);
}
function SelectDetector(event, doReload)
{
var uri = event.target.getAttribute("id");
var prefvalue = uri.substring('chardet.'.length, uri.length);
if ("off" == prefvalue) { // "off" is special value to turn off the detectors
prefvalue = "";
}
try {
2002-12-07 23:44:19 +03:00
var pref = Components.classes["@mozilla.org/preferences-service;1"]
.getService(Components.interfaces.nsIPrefBranch);
var str = Components.classes["@mozilla.org/supports-string;1"]
.createInstance(Components.interfaces.nsISupportsString);
str.data = prefvalue;
2002-12-07 23:44:19 +03:00
pref.setComplexValue("intl.charset.detector",
2002-10-13 21:23:14 +04:00
Components.interfaces.nsISupportsString, str);
if (doReload) window._content.location.reload();
}
catch (ex) {
2002-12-07 23:44:19 +03:00
dump("Failed to set the intl.charset.detector preference.\n");
}
}
2002-12-07 23:44:19 +03:00
function SetForcedDetector(doReload)
{
BrowserSetForcedDetector(doReload);
}
function SetForcedCharset(charset)
{
BrowserSetForcedCharacterSet(charset);
}
2002-12-07 23:44:19 +03:00
function BrowserSetDefaultCharacterSet(aCharset)
{
// no longer needed; set when setting Force; see bug 79608
}
function BrowserSetForcedCharacterSet(aCharset)
{
var docCharset = getBrowser().docShell.QueryInterface(
Components.interfaces.nsIDocCharset);
docCharset.charset = aCharset;
BrowserReloadWithFlags(nsIWebNavigation.LOAD_FLAGS_CHARSET_CHANGE);
}
function BrowserSetForcedDetector(doReload)
{
getBrowser().documentCharsetInfo.forcedDetector = true;
if (doReload)
BrowserReloadWithFlags(nsIWebNavigation.LOAD_FLAGS_CHARSET_CHANGE);
}
function UpdateCurrentCharset()
{
var menuitem = null;
// exctract the charset from DOM
var wnd = document.commandDispatcher.focusedWindow;
if ((window == wnd) || (wnd == null)) wnd = window._content;
menuitem = document.getElementById('charset.' + wnd.document.characterSet);
if (menuitem) {
// uncheck previously checked item to workaround Mac checkmark problem
// bug 98625
if (gPrevCharset) {
var pref_item = document.getElementById('charset.' + gPrevCharset);
if (pref_item)
pref_item.setAttribute('checked', 'false');
}
menuitem.setAttribute('checked', 'true');
}
}
function UpdateCharsetDetector()
{
var prefvalue;
try {
2002-12-07 23:44:19 +03:00
var pref = Components.classes["@mozilla.org/preferences-service;1"]
.getService(Components.interfaces.nsIPrefBranch);
prefvalue = pref.getComplexValue("intl.charset.detector",
Components.interfaces.nsIPrefLocalizedString).data;
}
catch (ex) {
prefvalue = "";
}
if (prefvalue == "") prefvalue = "off";
dump("intl.charset.detector = "+ prefvalue + "\n");
prefvalue = 'chardet.' + prefvalue;
var menuitem = document.getElementById(prefvalue);
if (menuitem) {
menuitem.setAttribute('checked', 'true');
}
}
function UpdateMenus(event)
{
// use setTimeout workaround to delay checkmark the menu
// when onmenucomplete is ready then use it instead of oncreate
// see bug 78290 for the detail
UpdateCurrentCharset();
setTimeout("UpdateCurrentCharset()", 0);
UpdateCharsetDetector();
setTimeout("UpdateCharsetDetector()", 0);
}
function CreateMenu(node)
{
var observerService = Components.classes["@mozilla.org/observer-service;1"].getService(Components.interfaces.nsIObserverService);
observerService.notifyObservers(null, "charsetmenu-selected", node);
}
function charsetLoadListener (event)
{
var charset = window._content.document.characterSet;
if (charset.length > 0 && (charset != gLastBrowserCharset)) {
if (!gCharsetMenu)
2002-12-07 23:44:19 +03:00
gCharsetMenu = Components.classes['@mozilla.org/rdf/datasource;1?name=charset-menu'].getService().QueryInterface(Components.interfaces.nsICurrentCharsetListener);
gCharsetMenu.SetCurrentCharset(charset);
gPrevCharset = gLastBrowserCharset;
gLastBrowserCharset = charset;
}
}
// a generic method which can be used to pass arbitrary urls to the operating system.
// aURL --> a nsIURI which represents the url to launch
function launchExternalUrl(aURL)
{
var extProtocolSvc = Components.classes["@mozilla.org/uriloader/external-protocol-service;1"].getService(Components.interfaces.nsIExternalProtocolService);
if (extProtocolSvc)
extProtocolSvc.loadUrl(aURL);
}
function sendLink(url, title)
{
// generate a mailto url based on the url and the url's title
var mailtoUrl = url ? "mailto:?body=" + url + "&subject=" + encodeURIComponent(title) : "mailto:";
var ioService = Components.classes["@mozilla.org/network/io-service;1"].getService(Components.interfaces.nsIIOService);
var uri = ioService.newURI(mailtoUrl, null, null);
// now pass this url to the operating system
launchExternalUrl(uri);
}
#ifdef XP_MACOSX
const nsIWindowDataSource = Components.interfaces.nsIWindowDataSource;
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 toOpenWindow( aWindow )
{
aWindow.document.commandDispatcher.focusedWindow.focus();
}
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);
}
}
#endif
/* Begin Page Theme Functions */
function getStyleSheetArray(frame)
{
var styleSheets = frame.document.styleSheets;
var styleSheetsArray = new Array(styleSheets.length);
for (var i = 0; i < styleSheets.length; i++) {
styleSheetsArray[i] = styleSheets[i];
}
return styleSheetsArray;
}
function getAllStyleSheets(frameset)
{
var styleSheetsArray = getStyleSheetArray(frameset);
for (var i = 0; i < frameset.frames.length; i++) {
var frameSheets = getAllStyleSheets(frameset.frames[i]);
styleSheetsArray = styleSheetsArray.concat(frameSheets);
}
return styleSheetsArray;
}
function stylesheetFillPopup(menuPopup)
{
var plainStyle = menuPopup.firstChild;
var normalStyle = plainStyle.nextSibling;
var sep = normalStyle.nextSibling;
while (sep.nextSibling)
menuPopup.removeChild(sep.nextSibling);
var noOptionalStyles = true;
var styleSheets = getAllStyleSheets(window._content);
var currentStyleSheets = [];
var allDisabled = true;
var haveAltSheets = false;
var haveAnyNonAltSheets = false;
for (var i = 0; i < styleSheets.length; ++i) {
var currentStyleSheet = styleSheets[i];
// Skip any stylesheets that don't match the screen media type.
var media = currentStyleSheet.media.mediaText.toLowerCase();
if (media && (media.indexOf("screen") == -1) && (media.indexOf("all") == -1))
continue;
if (!currentStyleSheet.disabled)
allDisabled = false;
if (currentStyleSheet.title) {
if (!currentStyleSheet.disabled)
noOptionalStyles = false;
haveAltSheets = true;
var lastWithSameTitle = null;
if (currentStyleSheet.title in currentStyleSheets)
lastWithSameTitle = currentStyleSheets[currentStyleSheet.title];
if (!lastWithSameTitle) {
var menuItem = document.createElement("menuitem");
menuItem.setAttribute("type", "radio");
menuItem.setAttribute("label", currentStyleSheet.title);
menuItem.setAttribute("data", currentStyleSheet.title);
menuItem.setAttribute("checked", !currentStyleSheet.disabled);
menuPopup.appendChild(menuItem);
currentStyleSheets[currentStyleSheet.title] = menuItem;
} else {
if (currentStyleSheet.disabled)
lastWithSameTitle.removeAttribute("checked");
}
}
else
haveAnyNonAltSheets = true;
}
normalStyle.setAttribute("checked", noOptionalStyles && (!haveAnyNonAltSheets || !allDisabled));
plainStyle.setAttribute("checked", allDisabled && haveAnyNonAltSheets);
plainStyle.hidden = !haveAnyNonAltSheets;
sep.hidden = !haveAltSheets;
}
function stylesheetInFrame(frame, title) {
var docStyleSheets = frame.document.styleSheets;
for (var i = 0; i < docStyleSheets.length; ++i) {
if (docStyleSheets[i].title == title)
return true;
}
return false;
}
function stylesheetSwitchFrame(frame, title) {
var docStyleSheets = frame.document.styleSheets;
for (var i = 0; i < docStyleSheets.length; ++i) {
var docStyleSheet = docStyleSheets[i];
if (title == "_nostyle")
docStyleSheet.disabled = true;
else if (docStyleSheet.title)
docStyleSheet.disabled = (docStyleSheet.title != title);
else if (docStyleSheet.disabled)
docStyleSheet.disabled = false;
}
}
function stylesheetSwitchAll(frameset, title) {
if (!title || title == "_nostyle" || stylesheetInFrame(frameset, title)) {
stylesheetSwitchFrame(frameset, title);
}
for (var i = 0; i < frameset.frames.length; i++) {
stylesheetSwitchAll(frameset.frames[i], title);
}
}
function updatePageTheme(evt)
{
if (!gPageThemeButton)
gPageThemeButton = document.getElementById("page-theme-button");
var hasThemes = false;
var stylesheets = window._content.document.styleSheets;
for (var i = 0; i < stylesheets.length; ++i) {
var currentStyleSheet = stylesheets[i];
if (currentStyleSheet.title) {
// Skip any stylesheets that don't match the screen media type.
var media = currentStyleSheet.media.mediaText.toLowerCase();
if (media && (media.indexOf("screen") == -1) && (media.indexOf("all") == -1))
continue;
hasThemes = true;
break;
}
}
if (hasThemes) {
gPageThemeButton.setAttribute("themes", "true");
// FIXME: Do a first-time explanation of page themes here perhaps?
// Avoid for now since Firebird's default home page has an alt sheet.
}
else
gPageThemeButton.removeAttribute("themes");
}
/* End of the Page Theme functions */
function clearObsoletePrefs()
{
// removed 10/03/2003
try {
PREF.clearUserPref("timebomb.first_launch_time");
} catch (e) {}
// removed 10/16/2003
// migrate firebird cookie prefs, if they exist.
try {
PREF.clearUserPref("network.cookie.enable");
// No error: it means this pref was not the default one, cookie were disabled.
PREF.SetIntPref("network.cookie.cookieBehavior", 2);
} catch (e) {
try {
PREF.clearUserPref("network.cookie.enableForOriginatingWebsiteOnly");
// No error: it means that enableForOriginatingWebsiteOnly was true.
PREF.SetIntPref("network.cookie.cookieBehavior", 1);
} catch (e) {
// here, either we already have migrated the cookie pref
// or the new and old behavior are the same (0). In any case: nothing to do.
}
}
// removed 10/22/2003
try {
PREF.clearUserPref("browser.search.defaultengine");
} catch (e) {}
// removed 11/01/2003
try {
PREF.clearUserPref("print.use_global_printsettings");
} catch (e) {}
try {
PREF.clearUserPref("print.save_print_settings");
} catch (e) {}
}
var BrowserOffline = {
/////////////////////////////////////////////////////////////////////////////
// BrowserOffline Public Methods
init: function ()
{
var os = Components.classes["@mozilla.org/observer-service;1"].getService(Components.interfaces.nsIObserverService);
os.addObserver(this, "network:offline-status-changed", false);
if (!this._uiElement)
this._uiElement = document.getElementById("goOfflineMenuitem");
// set the initial state
var ioService = Components.classes["@mozilla.org/network/io-service;1"].getService(Components.interfaces.nsIIOService);
var isOffline = false;
try {
isOffline = gPrefService.getBoolPref("browser.offline");
}
catch (e) { }
ioService.offline = isOffline;
this._updateOfflineUI(isOffline);
},
uninit: function ()
{
var os = Components.classes["@mozilla.org/observer-service;1"].getService(Components.interfaces.nsIObserverService);
os.removeObserver(this, "network:offline-status-changed");
},
toggleOfflineStatus: function ()
{
if (!this._canGoOffline()) {
this._updateOfflineUI(false);
return;
}
var ioService = Components.classes["@mozilla.org/network/io-service;1"].getService(Components.interfaces.nsIIOService);
ioService.offline = !ioService.offline;
gPrefService.setBoolPref("browser.offline", ioService.offline);
},
/////////////////////////////////////////////////////////////////////////////
// nsIObserver
observe: function (aSubject, aTopic, aState)
{
if (aTopic != "network:offline-status-changed")
return;
this._updateOfflineUI(aState == "offline");
},
/////////////////////////////////////////////////////////////////////////////
// BrowserOffline Implementation Methods
_canGoOffline: function ()
{
var os = Components.classes["@mozilla.org/observer-service;1"].getService(Components.interfaces.nsIObserverService);
if (os) {
try {
var cancelGoOffline = Components.classes["@mozilla.org/supports-PRBool;1"].createInstance(Components.interfaces.nsISupportsPRBool);
os.notifyObservers(cancelGoOffline, "offline-requested", null);
// Something aborted the quit process.
if (cancelGoOffline.data)
return false;
}
catch (ex) {
}
}
return true;
},
_uiElement: null,
_updateOfflineUI: function (aOffline)
{
var offlineLocked = gPrefService.prefIsLocked("network.online");
if (offlineLocked)
this._uiElement.setAttribute("disabled", "true");
this._uiElement.setAttribute("checked", aOffline);
}
};