2011-10-26 11:32:14 -07:00
|
|
|
// -*- Mode: js2; tab-width: 2; indent-tabs-mode: nil; js2-basic-offset: 2; js2-skip-preprocessor-directives: t; -*-
|
|
|
|
/*
|
|
|
|
* ***** BEGIN LICENSE BLOCK *****
|
|
|
|
* Version: MPL 1.1/GPL 2.0/LGPL 2.1
|
|
|
|
*
|
|
|
|
* The contents of this file are subject to the Mozilla Public License Version
|
|
|
|
* 1.1 (the "License"); you may not use this file except in compliance with
|
|
|
|
* the License. You may obtain a copy of the License at
|
|
|
|
* http://www.mozilla.org/MPL/
|
|
|
|
*
|
|
|
|
* Software distributed under the License is distributed on an "AS IS" basis,
|
|
|
|
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
|
|
|
|
* for the specific language governing rights and limitations under the
|
|
|
|
* License.
|
|
|
|
*
|
|
|
|
* The Original Code is Mozilla Mobile Browser.
|
|
|
|
*
|
|
|
|
* The Initial Developer of the Original Code is
|
|
|
|
* Mozilla Corporation.
|
|
|
|
* Portions created by the Initial Developer are Copyright (C) 2011
|
|
|
|
* the Initial Developer. All Rights Reserved.
|
|
|
|
*
|
|
|
|
* Contributor(s):
|
|
|
|
*
|
|
|
|
* Alternatively, the contents of this file may be used under the terms of
|
|
|
|
* either the GNU General Public License Version 2 or later (the "GPL"), or
|
|
|
|
* the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
|
|
|
|
* in which case the provisions of the GPL or the LGPL are applicable instead
|
|
|
|
* of those above. If you wish to allow use of your version of this file only
|
|
|
|
* under the terms of either the GPL or the LGPL, and not to allow others to
|
|
|
|
* use your version of this file under the terms of the MPL, indicate your
|
|
|
|
* decision by deleting the provisions above and replace them with the notice
|
|
|
|
* and other provisions required by the GPL or the LGPL. If you do not delete
|
|
|
|
* the provisions above, a recipient may use your version of this file under
|
|
|
|
* the terms of any one of the MPL, the GPL or the LGPL.
|
|
|
|
*
|
|
|
|
* ***** END LICENSE BLOCK ***** */
|
2011-11-07 17:10:59 -08:00
|
|
|
"use strict";
|
2011-10-26 11:32:14 -07:00
|
|
|
|
2009-03-16 21:27:29 -07:00
|
|
|
let Cc = Components.classes;
|
|
|
|
let Ci = Components.interfaces;
|
|
|
|
let Cu = Components.utils;
|
2010-11-11 10:48:00 -08:00
|
|
|
let Cr = Components.results;
|
2008-04-18 06:41:49 -07:00
|
|
|
|
2011-10-10 17:40:17 -07:00
|
|
|
Cu.import("resource://gre/modules/XPCOMUtils.jsm");
|
|
|
|
Cu.import("resource://gre/modules/NetUtil.jsm");
|
|
|
|
Cu.import("resource://gre/modules/Services.jsm")
|
2010-05-21 10:00:27 -07:00
|
|
|
|
2011-10-26 11:32:14 -07:00
|
|
|
XPCOMUtils.defineLazyServiceGetter(this, "URIFixup",
|
|
|
|
"@mozilla.org/docshell/urifixup;1", "nsIURIFixup");
|
|
|
|
|
2011-10-19 09:17:59 -07:00
|
|
|
// TODO: Take into account ppi in these units?
|
|
|
|
|
2011-10-17 12:02:27 -07:00
|
|
|
// The ratio of velocity that is retained every ms.
|
|
|
|
const kPanDeceleration = 0.999;
|
|
|
|
|
|
|
|
// The number of ms to consider events over for a swipe gesture.
|
2011-10-19 09:17:59 -07:00
|
|
|
const kSwipeLength = 500;
|
|
|
|
|
|
|
|
// The number of pixels to move before we consider a drag to be more than
|
|
|
|
// just a click with jitter.
|
|
|
|
const kDragThreshold = 10;
|
|
|
|
|
|
|
|
// The number of pixels to move to break out of axis-lock
|
|
|
|
const kLockBreakThreshold = 100;
|
2011-10-17 12:02:27 -07:00
|
|
|
|
|
|
|
// Minimum speed to move during kinetic panning. 0.015 pixels/ms is roughly
|
|
|
|
// equivalent to a pixel every 4 frames at 60fps.
|
|
|
|
const kMinKineticSpeed = 0.015;
|
|
|
|
|
2011-10-19 09:17:59 -07:00
|
|
|
// Maximum kinetic panning speed. 9 pixels/ms is equivalent to 150 pixels per
|
2011-10-17 12:02:27 -07:00
|
|
|
// frame at 60fps.
|
2011-10-19 09:17:59 -07:00
|
|
|
const kMaxKineticSpeed = 9;
|
2011-10-17 12:02:27 -07:00
|
|
|
|
|
|
|
// The maximum magnitude of disparity allowed between axes acceleration. If
|
|
|
|
// it's larger than this, lock the slow-moving axis.
|
|
|
|
const kAxisLockRatio = 5;
|
|
|
|
|
2011-11-09 17:39:29 -08:00
|
|
|
// The element tag names that are considered to receive input. Mouse-down
|
|
|
|
// events directed to one of these are allowed to go through.
|
|
|
|
const kElementsReceivingInput = {
|
|
|
|
applet: true,
|
|
|
|
audio: true,
|
|
|
|
button: true,
|
|
|
|
embed: true,
|
|
|
|
input: true,
|
|
|
|
map: true,
|
|
|
|
select: true,
|
|
|
|
textarea: true,
|
|
|
|
video: true
|
|
|
|
};
|
|
|
|
|
2011-10-10 17:40:17 -07:00
|
|
|
function dump(a) {
|
2011-10-12 14:31:04 -07:00
|
|
|
Cc["@mozilla.org/consoleservice;1"].getService(Ci.nsIConsoleService).logStringMessage(a);
|
|
|
|
}
|
|
|
|
|
2011-10-13 13:47:29 -07:00
|
|
|
function sendMessageToJava(aMessage) {
|
2011-10-12 14:31:04 -07:00
|
|
|
let bridge = Cc["@mozilla.org/android/bridge;1"].getService(Ci.nsIAndroidBridge);
|
2011-10-24 10:05:18 -07:00
|
|
|
return bridge.handleGeckoMessage(JSON.stringify(aMessage));
|
2009-07-17 16:17:57 -07:00
|
|
|
}
|
|
|
|
|
2011-10-25 05:29:30 -07:00
|
|
|
#ifdef MOZ_CRASHREPORTER
|
|
|
|
Cu.import("resource://gre/modules/XPCOMUtils.jsm");
|
2010-05-21 10:00:27 -07:00
|
|
|
XPCOMUtils.defineLazyServiceGetter(this, "CrashReporter",
|
|
|
|
"@mozilla.org/xre/app-info;1", "nsICrashReporter");
|
|
|
|
#endif
|
|
|
|
|
2011-10-24 14:08:21 -07:00
|
|
|
function resolveGeckoURI(aURI) {
|
|
|
|
if (aURI.indexOf("chrome://") == 0) {
|
|
|
|
let registry = Cc['@mozilla.org/chrome/chrome-registry;1'].getService(Ci["nsIChromeRegistry"]);
|
|
|
|
return registry.convertChromeURL(Services.io.newURI(aURI, null, null)).spec;
|
|
|
|
} else if (aURI.indexOf("resource://") == 0) {
|
|
|
|
let handler = Services.io.getProtocolHandler("resource").QueryInterface(Ci.nsIResProtocolHandler);
|
|
|
|
return handler.resolveURI(Services.io.newURI(aURI, null, null));
|
|
|
|
}
|
|
|
|
return aURI;
|
|
|
|
}
|
2011-10-13 13:06:41 -07:00
|
|
|
|
2011-10-26 13:21:51 -07:00
|
|
|
/**
|
|
|
|
* Cache of commonly used string bundles.
|
|
|
|
*/
|
|
|
|
var Strings = {};
|
|
|
|
[
|
|
|
|
["brand", "chrome://branding/locale/brand.properties"],
|
|
|
|
["browser", "chrome://browser/locale/browser.properties"]
|
|
|
|
].forEach(function (aStringBundle) {
|
|
|
|
let [name, bundle] = aStringBundle;
|
|
|
|
XPCOMUtils.defineLazyGetter(Strings, name, function() {
|
|
|
|
return Services.strings.createBundle(bundle);
|
|
|
|
});
|
|
|
|
});
|
|
|
|
|
2011-10-13 13:06:41 -07:00
|
|
|
var BrowserApp = {
|
|
|
|
_tabs: [],
|
|
|
|
_selectedTab: null,
|
|
|
|
|
|
|
|
deck: null,
|
2011-10-31 13:25:21 -07:00
|
|
|
vertScroller: null,
|
|
|
|
horizScroller: null,
|
2011-10-13 13:06:41 -07:00
|
|
|
|
|
|
|
startup: function startup() {
|
|
|
|
window.QueryInterface(Ci.nsIDOMChromeWindow).browserDOMWindow = new nsBrowserAccess();
|
|
|
|
dump("zerdatime " + Date.now() + " - browser chrome startup finished.");
|
|
|
|
|
|
|
|
this.deck = document.getElementById("browsers");
|
2011-10-31 13:25:21 -07:00
|
|
|
this.vertScroller = document.getElementById("vertical-scroller");
|
|
|
|
this.horizScroller = document.getElementById("horizontal-scroller");
|
2011-10-13 13:06:41 -07:00
|
|
|
BrowserEventHandler.init();
|
|
|
|
|
2011-10-24 12:20:27 -07:00
|
|
|
Services.obs.addObserver(this, "Tab:Add", false);
|
|
|
|
Services.obs.addObserver(this, "Tab:Load", false);
|
|
|
|
Services.obs.addObserver(this, "Tab:Select", false);
|
|
|
|
Services.obs.addObserver(this, "Tab:Close", false);
|
2011-10-31 08:02:34 -07:00
|
|
|
Services.obs.addObserver(this, "Session:Back", false);
|
|
|
|
Services.obs.addObserver(this, "Session:Forward", false);
|
|
|
|
Services.obs.addObserver(this, "Session:Reload", false);
|
2011-11-16 16:23:22 -08:00
|
|
|
Services.obs.addObserver(this, "Session:Stop", false);
|
2011-10-25 08:51:23 -07:00
|
|
|
Services.obs.addObserver(this, "SaveAs:PDF", false);
|
2011-11-09 17:31:09 -08:00
|
|
|
Services.obs.addObserver(this, "Browser:Quit", false);
|
2011-10-14 12:48:02 -07:00
|
|
|
Services.obs.addObserver(this, "Preferences:Get", false);
|
|
|
|
Services.obs.addObserver(this, "Preferences:Set", false);
|
2011-10-26 11:30:48 -07:00
|
|
|
Services.obs.addObserver(this, "ScrollTo:FocusedInput", false);
|
2011-10-27 21:55:15 -07:00
|
|
|
Services.obs.addObserver(this, "Sanitize:ClearAll", false);
|
2011-11-09 17:39:29 -08:00
|
|
|
Services.obs.addObserver(this, "PanZoom:PanZoom", false);
|
2011-11-08 10:36:04 -08:00
|
|
|
Services.obs.addObserver(this, "FullScreen:Exit", false);
|
2011-10-13 13:06:41 -07:00
|
|
|
|
2011-10-26 13:21:51 -07:00
|
|
|
Services.obs.addObserver(XPInstallObserver, "addon-install-blocked", false);
|
|
|
|
Services.obs.addObserver(XPInstallObserver, "addon-install-started", false);
|
|
|
|
|
2011-11-15 12:30:58 -08:00
|
|
|
function showFullScreenWarning() {
|
|
|
|
NativeWindow.toast.show(Strings.browser.GetStringFromName("alertFullScreenToast"), "short");
|
|
|
|
}
|
|
|
|
|
2011-11-08 10:36:04 -08:00
|
|
|
window.addEventListener("fullscreen", function() {
|
|
|
|
sendMessageToJava({
|
|
|
|
gecko: {
|
|
|
|
type: window.fullScreen ? "ToggleChrome:Show" : "ToggleChrome:Hide"
|
|
|
|
}
|
|
|
|
});
|
2011-11-08 10:36:06 -08:00
|
|
|
|
|
|
|
if (!window.fullScreen)
|
2011-11-15 12:30:58 -08:00
|
|
|
showFullScreenWarning();
|
2011-11-08 10:36:04 -08:00
|
|
|
}, false);
|
|
|
|
|
2011-11-15 12:30:58 -08:00
|
|
|
// When a restricted key is pressed in DOM full-screen mode, we should display
|
|
|
|
// the "Press ESC to exit" warning message.
|
|
|
|
window.addEventListener("MozShowFullScreenWarning", showFullScreenWarning, true);
|
|
|
|
|
2011-10-20 22:50:04 -07:00
|
|
|
NativeWindow.init();
|
2011-10-26 21:29:46 -07:00
|
|
|
Downloads.init();
|
2011-11-11 08:02:10 -08:00
|
|
|
OfflineApps.init();
|
2011-11-15 14:45:10 -08:00
|
|
|
IndexedDB.init();
|
2011-10-26 21:29:46 -07:00
|
|
|
|
|
|
|
// Init LoginManager
|
|
|
|
Cc["@mozilla.org/login-manager;1"].getService(Ci.nsILoginManager);
|
2011-10-20 22:50:04 -07:00
|
|
|
|
2011-10-13 13:06:41 -07:00
|
|
|
let uri = "about:support";
|
2011-10-15 13:27:03 -07:00
|
|
|
if ("arguments" in window && window.arguments[0])
|
|
|
|
uri = window.arguments[0];
|
|
|
|
|
2011-10-13 13:06:41 -07:00
|
|
|
// XXX maybe we don't do this if the launch was kicked off from external
|
|
|
|
Services.io.offline = false;
|
|
|
|
let newTab = this.addTab(uri);
|
|
|
|
newTab.active = true;
|
2011-10-19 11:17:00 -07:00
|
|
|
|
2011-10-24 17:34:17 -07:00
|
|
|
// Broadcast a UIReady message so add-ons know we are finished with startup
|
|
|
|
let event = document.createEvent("Events");
|
|
|
|
event.initEvent("UIReady", true, false);
|
|
|
|
window.dispatchEvent(event);
|
2011-10-25 16:12:44 -07:00
|
|
|
|
|
|
|
// notify java that gecko has loaded
|
|
|
|
sendMessageToJava({
|
|
|
|
gecko: {
|
|
|
|
type: "Gecko:Ready"
|
|
|
|
}
|
|
|
|
});
|
2011-11-11 12:31:16 -08:00
|
|
|
|
|
|
|
let telemetryPrompted = false;
|
|
|
|
try {
|
|
|
|
telemetryPrompted = Services.prefs.getBoolPref("toolkit.telemetry.prompted");
|
|
|
|
} catch (e) {
|
|
|
|
// optional
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!telemetryPrompted) {
|
|
|
|
let buttons = [
|
|
|
|
{
|
|
|
|
label: Strings.browser.GetStringFromName("telemetry.optin.yes"),
|
|
|
|
callback: function () {
|
|
|
|
Services.prefs.setBoolPref("toolkit.telemetry.prompted", true);
|
|
|
|
Services.prefs.setBoolPref("toolkit.telemetry.enabled", true);
|
|
|
|
}
|
|
|
|
},
|
|
|
|
{
|
|
|
|
label: Strings.browser.GetStringFromName("telemetry.optin.no"),
|
|
|
|
callback: function () {
|
|
|
|
Services.prefs.setBoolPref("toolkit.telemetry.prompted", true);
|
|
|
|
Services.prefs.setBoolPref("toolkit.telemetry.enabled", false);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
];
|
|
|
|
let brandShortName = Strings.brand.GetStringFromName("brandShortName");
|
|
|
|
let message = Strings.browser.formatStringFromName("telemetry.optin.message", [brandShortName], 1);
|
|
|
|
NativeWindow.doorhanger.show(message, "telemetry-optin", buttons);
|
|
|
|
}
|
|
|
|
|
2011-10-13 11:13:41 -07:00
|
|
|
},
|
|
|
|
|
2011-10-13 13:06:41 -07:00
|
|
|
shutdown: function shutdown() {
|
2011-10-20 22:50:04 -07:00
|
|
|
NativeWindow.uninit();
|
2011-11-11 08:02:10 -08:00
|
|
|
OfflineApps.uninit();
|
2011-11-15 14:45:10 -08:00
|
|
|
IndexedDB.uninit();
|
2011-10-26 13:21:51 -07:00
|
|
|
|
|
|
|
Services.obs.removeObserver(XPInstallObserver, "addon-install-blocked");
|
|
|
|
Services.obs.removeObserver(XPInstallObserver, "addon-install-started");
|
2011-10-13 11:13:41 -07:00
|
|
|
},
|
|
|
|
|
2011-10-13 13:06:41 -07:00
|
|
|
get tabs() {
|
|
|
|
return this._tabs;
|
|
|
|
},
|
2011-10-10 17:40:17 -07:00
|
|
|
|
2011-10-13 13:06:41 -07:00
|
|
|
get selectedTab() {
|
|
|
|
return this._selectedTab;
|
|
|
|
},
|
2011-10-10 17:40:17 -07:00
|
|
|
|
2011-10-13 13:06:41 -07:00
|
|
|
set selectedTab(aTab) {
|
|
|
|
this._selectedTab = aTab;
|
|
|
|
if (!aTab)
|
|
|
|
return;
|
2010-09-22 16:27:11 -07:00
|
|
|
|
2011-10-13 13:06:41 -07:00
|
|
|
this.deck.selectedPanel = aTab.browser;
|
|
|
|
},
|
2009-08-05 14:06:38 -07:00
|
|
|
|
2011-10-13 13:06:41 -07:00
|
|
|
get selectedBrowser() {
|
|
|
|
if (this._selectedTab)
|
|
|
|
return this._selectedTab.browser;
|
|
|
|
return null;
|
|
|
|
},
|
2010-11-01 16:36:07 -07:00
|
|
|
|
2011-10-14 22:35:15 -07:00
|
|
|
getTabForId: function getTabForId(aId) {
|
|
|
|
let tabs = this._tabs;
|
|
|
|
for (let i=0; i < tabs.length; i++) {
|
|
|
|
if (tabs[i].id == aId)
|
|
|
|
return tabs[i];
|
|
|
|
}
|
|
|
|
return null;
|
|
|
|
},
|
|
|
|
|
2011-10-13 13:06:41 -07:00
|
|
|
getTabForBrowser: function getTabForBrowser(aBrowser) {
|
|
|
|
let tabs = this._tabs;
|
|
|
|
for (let i = 0; i < tabs.length; i++) {
|
|
|
|
if (tabs[i].browser == aBrowser)
|
|
|
|
return tabs[i];
|
|
|
|
}
|
|
|
|
return null;
|
|
|
|
},
|
|
|
|
|
|
|
|
getBrowserForWindow: function getBrowserForWindow(aWindow) {
|
|
|
|
let tabs = this._tabs;
|
|
|
|
for (let i = 0; i < tabs.length; i++) {
|
|
|
|
if (tabs[i].browser.contentWindow == aWindow)
|
|
|
|
return tabs[i].browser;
|
|
|
|
}
|
|
|
|
return null;
|
|
|
|
},
|
|
|
|
|
|
|
|
getBrowserForDocument: function getBrowserForDocument(aDocument) {
|
|
|
|
let tabs = this._tabs;
|
|
|
|
for (let i = 0; i < tabs.length; i++) {
|
|
|
|
if (tabs[i].browser.contentDocument == aDocument)
|
|
|
|
return tabs[i].browser;
|
|
|
|
}
|
|
|
|
return null;
|
|
|
|
},
|
2010-11-16 14:50:34 -08:00
|
|
|
|
2011-10-13 13:06:41 -07:00
|
|
|
loadURI: function loadURI(aURI, aParams) {
|
|
|
|
let browser = this.selectedBrowser;
|
|
|
|
if (!browser)
|
|
|
|
return;
|
2010-11-16 14:50:34 -08:00
|
|
|
|
2011-10-13 13:06:41 -07:00
|
|
|
let flags = aParams.flags || Ci.nsIWebNavigation.LOAD_FLAGS_NONE;
|
|
|
|
let postData = ("postData" in aParams && aParams.postData) ? aParams.postData.value : null;
|
|
|
|
let referrerURI = "referrerURI" in aParams ? aParams.referrerURI : null;
|
|
|
|
let charset = "charset" in aParams ? aParams.charset : null;
|
|
|
|
browser.loadURIWithFlags(aURI, flags, referrerURI, charset, postData);
|
|
|
|
},
|
|
|
|
|
2011-11-08 12:49:25 -08:00
|
|
|
addTab: function addTab(aURI, aParams) {
|
|
|
|
let newTab = new Tab(aURI, aParams);
|
2011-10-13 13:06:41 -07:00
|
|
|
this._tabs.push(newTab);
|
|
|
|
return newTab;
|
|
|
|
},
|
|
|
|
|
|
|
|
closeTab: function closeTab(aTab) {
|
|
|
|
if (aTab == this.selectedTab)
|
|
|
|
this.selectedTab = null;
|
|
|
|
|
|
|
|
aTab.destroy();
|
|
|
|
this._tabs.splice(this._tabs.indexOf(aTab), 1);
|
|
|
|
},
|
|
|
|
|
2011-10-24 12:20:27 -07:00
|
|
|
selectTab: function selectTab(aTab) {
|
|
|
|
if (aTab != null) {
|
|
|
|
this.selectedTab = aTab;
|
|
|
|
aTab.active = true;
|
|
|
|
let message = {
|
|
|
|
gecko: {
|
|
|
|
type: "Tab:Selected",
|
|
|
|
tabID: aTab.id
|
|
|
|
}
|
|
|
|
};
|
2011-10-20 22:50:04 -07:00
|
|
|
|
2011-10-24 12:20:27 -07:00
|
|
|
sendMessageToJava(message);
|
2011-10-14 23:22:25 -07:00
|
|
|
}
|
2011-10-14 22:35:15 -07:00
|
|
|
},
|
|
|
|
|
2011-11-16 14:33:43 -08:00
|
|
|
quit: function quit() {
|
|
|
|
window.QueryInterface(Ci.nsIDOMChromeWindow).minimize();
|
|
|
|
window.close();
|
|
|
|
},
|
|
|
|
|
2011-10-25 08:51:23 -07:00
|
|
|
saveAsPDF: function saveAsPDF(aBrowser) {
|
|
|
|
// Create the final destination file location
|
|
|
|
let ContentAreaUtils = {};
|
|
|
|
Services.scriptloader.loadSubScript("chrome://global/content/contentAreaUtils.js", ContentAreaUtils);
|
|
|
|
let fileName = ContentAreaUtils.getDefaultFileName(aBrowser.contentTitle, aBrowser.documentURI, null, null);
|
|
|
|
fileName = fileName.trim() + ".pdf";
|
|
|
|
|
|
|
|
let dm = Cc["@mozilla.org/download-manager;1"].getService(Ci.nsIDownloadManager);
|
|
|
|
let downloadsDir = dm.defaultDownloadsDirectory;
|
|
|
|
|
|
|
|
let file = downloadsDir.clone();
|
|
|
|
file.append(fileName);
|
2011-11-07 17:10:59 -08:00
|
|
|
file.createUnique(file.NORMAL_FILE_TYPE, parseInt("666", 8));
|
2011-10-25 08:51:23 -07:00
|
|
|
fileName = file.leafName;
|
|
|
|
|
|
|
|
// We must manually add this to the download system
|
|
|
|
let db = dm.DBConnection;
|
|
|
|
|
|
|
|
let stmt = db.createStatement(
|
|
|
|
"INSERT INTO moz_downloads (name, source, target, startTime, endTime, state, referrer) " +
|
|
|
|
"VALUES (:name, :source, :target, :startTime, :endTime, :state, :referrer)"
|
|
|
|
);
|
|
|
|
|
|
|
|
let current = aBrowser.currentURI.spec;
|
|
|
|
stmt.params.name = fileName;
|
|
|
|
stmt.params.source = current;
|
|
|
|
stmt.params.target = Services.io.newFileURI(file).spec;
|
|
|
|
stmt.params.startTime = Date.now() * 1000;
|
|
|
|
stmt.params.endTime = Date.now() * 1000;
|
|
|
|
stmt.params.state = Ci.nsIDownloadManager.DOWNLOAD_NOTSTARTED;
|
|
|
|
stmt.params.referrer = current;
|
|
|
|
stmt.execute();
|
|
|
|
stmt.finalize();
|
|
|
|
|
|
|
|
let newItemId = db.lastInsertRowID;
|
|
|
|
let download = dm.getDownload(newItemId);
|
|
|
|
try {
|
|
|
|
DownloadsView.downloadStarted(download);
|
|
|
|
}
|
|
|
|
catch(e) {}
|
|
|
|
Services.obs.notifyObservers(download, "dl-start", null);
|
|
|
|
|
|
|
|
let printSettings = Cc["@mozilla.org/gfx/printsettings-service;1"].getService(Ci.nsIPrintSettingsService).newPrintSettings;
|
|
|
|
printSettings.printSilent = true;
|
|
|
|
printSettings.showPrintProgress = false;
|
|
|
|
printSettings.printBGImages = true;
|
|
|
|
printSettings.printBGColors = true;
|
|
|
|
printSettings.printToFile = true;
|
|
|
|
printSettings.toFileName = file.path;
|
|
|
|
printSettings.printFrameType = Ci.nsIPrintSettings.kFramesAsIs;
|
|
|
|
printSettings.outputFormat = Ci.nsIPrintSettings.kOutputFormatPDF;
|
|
|
|
|
|
|
|
//XXX we probably need a preference here, the header can be useful
|
|
|
|
printSettings.footerStrCenter = "";
|
|
|
|
printSettings.footerStrLeft = "";
|
|
|
|
printSettings.footerStrRight = "";
|
|
|
|
printSettings.headerStrCenter = "";
|
|
|
|
printSettings.headerStrLeft = "";
|
|
|
|
printSettings.headerStrRight = "";
|
|
|
|
|
|
|
|
let listener = {
|
|
|
|
onStateChange: function(aWebProgress, aRequest, aStateFlags, aStatus) {},
|
|
|
|
onProgressChange : function(aWebProgress, aRequest, aCurSelfProgress, aMaxSelfProgress, aCurTotalProgress, aMaxTotalProgress) {},
|
|
|
|
|
|
|
|
// stubs for the nsIWebProgressListener interfaces which nsIWebBrowserPrint doesn't use.
|
|
|
|
onLocationChange : function() {},
|
|
|
|
onStatusChange: function() {},
|
|
|
|
onSecurityChange : function() {}
|
|
|
|
};
|
|
|
|
|
|
|
|
let webBrowserPrint = content.QueryInterface(Ci.nsIInterfaceRequestor).getInterface(Ci.nsIWebBrowserPrint);
|
|
|
|
webBrowserPrint.print(printSettings, listener);
|
|
|
|
},
|
|
|
|
|
2011-10-14 12:48:02 -07:00
|
|
|
getPreferences: function getPreferences(aPrefNames) {
|
|
|
|
try {
|
|
|
|
let json = JSON.parse(aPrefNames);
|
|
|
|
let prefs = [];
|
|
|
|
|
|
|
|
for each (let prefName in json) {
|
|
|
|
let pref = {
|
2011-10-25 19:51:44 -07:00
|
|
|
name: prefName
|
2011-10-14 12:48:02 -07:00
|
|
|
};
|
|
|
|
|
2011-10-25 14:31:55 -07:00
|
|
|
try {
|
|
|
|
switch (Services.prefs.getPrefType(prefName)) {
|
|
|
|
case Ci.nsIPrefBranch.PREF_BOOL:
|
|
|
|
pref.type = "bool";
|
|
|
|
pref.value = Services.prefs.getBoolPref(prefName);
|
|
|
|
break;
|
|
|
|
case Ci.nsIPrefBranch.PREF_INT:
|
|
|
|
pref.type = "int";
|
|
|
|
pref.value = Services.prefs.getIntPref(prefName);
|
|
|
|
break;
|
|
|
|
case Ci.nsIPrefBranch.PREF_STRING:
|
|
|
|
default:
|
|
|
|
pref.type = "string";
|
|
|
|
pref.value = Services.prefs.getComplexValue(prefName, Ci.nsISupportsString).data;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
} catch (e) {
|
|
|
|
// preference does not exist; do not send it
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
// some preferences use integers or strings instead of booleans for
|
|
|
|
// indicating enabled/disabled. since the java ui uses the type to
|
|
|
|
// determine which ui elements to show, we need to normalize these
|
|
|
|
// preferences to be actual booleans.
|
|
|
|
switch (prefName) {
|
|
|
|
case "network.cookie.cookieBehavior":
|
2011-10-14 12:48:02 -07:00
|
|
|
pref.type = "bool";
|
2011-10-25 14:31:55 -07:00
|
|
|
pref.value = pref.value == 0;
|
2011-10-14 12:48:02 -07:00
|
|
|
break;
|
2011-10-25 14:31:55 -07:00
|
|
|
case "permissions.default.image":
|
|
|
|
pref.type = "bool";
|
|
|
|
pref.value = pref.value == 1;
|
2011-10-14 12:48:02 -07:00
|
|
|
break;
|
2011-10-25 14:31:55 -07:00
|
|
|
case "browser.menu.showCharacterEncoding":
|
|
|
|
pref.type = "bool";
|
|
|
|
pref.value = pref.value == "true";
|
2011-10-14 12:48:02 -07:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
prefs.push(pref);
|
|
|
|
}
|
|
|
|
|
|
|
|
sendMessageToJava({
|
|
|
|
gecko: {
|
|
|
|
type: "Preferences:Data",
|
|
|
|
preferences: prefs
|
|
|
|
}
|
|
|
|
});
|
|
|
|
} catch (e) {}
|
|
|
|
},
|
|
|
|
|
|
|
|
setPreferences: function setPreferences(aPref) {
|
|
|
|
let json = JSON.parse(aPref);
|
|
|
|
|
2011-10-25 14:31:55 -07:00
|
|
|
// when sending to java, we normalized special preferences that use
|
|
|
|
// integers and strings to represent booleans. here, we convert them back
|
|
|
|
// to their actual types so we can store them.
|
|
|
|
switch (json.name) {
|
|
|
|
case "network.cookie.cookieBehavior":
|
|
|
|
json.type = "int";
|
|
|
|
json.value = (json.value ? 0 : 2);
|
|
|
|
break;
|
|
|
|
case "permissions.default.image":
|
|
|
|
json.type = "int";
|
|
|
|
json.value = (json.value ? 1 : 2);
|
|
|
|
break;
|
|
|
|
case "browser.menu.showCharacterEncoding":
|
|
|
|
json.type = "string";
|
|
|
|
json.value = (json.value ? "true" : "false");
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2011-10-14 12:48:02 -07:00
|
|
|
if (json.type == "bool")
|
|
|
|
Services.prefs.setBoolPref(json.name, json.value);
|
|
|
|
else if (json.type == "int")
|
|
|
|
Services.prefs.setIntPref(json.name, json.value);
|
2011-10-25 14:31:55 -07:00
|
|
|
else {
|
|
|
|
let pref = Cc["@mozilla.org/pref-localizedstring;1"].createInstance(Ci.nsIPrefLocalizedString);
|
|
|
|
pref.data = json.value;
|
|
|
|
Services.prefs.setComplexValue(json.name, Ci.nsISupportsString, pref);
|
|
|
|
}
|
2011-10-14 12:48:02 -07:00
|
|
|
},
|
|
|
|
|
2011-10-26 11:30:48 -07:00
|
|
|
scrollToFocusedInput: function(aBrowser) {
|
|
|
|
let doc = aBrowser.contentDocument;
|
|
|
|
if (!doc)
|
|
|
|
return;
|
|
|
|
let focused = doc.activeElement;
|
|
|
|
if ((focused instanceof HTMLInputElement && focused.mozIsTextField(false)) || (focused instanceof HTMLTextAreaElement))
|
|
|
|
focused.scrollIntoView(false);
|
|
|
|
},
|
|
|
|
|
2011-11-09 17:39:29 -08:00
|
|
|
panZoom: function(aData) {
|
|
|
|
let data = JSON.parse(aData);
|
|
|
|
let browser = this.selectedBrowser;
|
|
|
|
browser.contentWindow.scrollTo(data.x, data.y);
|
|
|
|
|
2011-11-15 08:58:23 -08:00
|
|
|
/* TODO (bug 695449): Scale. */
|
|
|
|
|
2011-11-09 17:39:29 -08:00
|
|
|
sendMessageToJava({ gecko: { type: "PanZoom:Ack", rect: data } });
|
|
|
|
},
|
|
|
|
|
2011-10-31 13:25:21 -07:00
|
|
|
updateScrollbarsFor: function(aElement) {
|
|
|
|
// only draw the scrollbars if we're scrolling the root content element
|
|
|
|
let doc = this.selectedBrowser.contentDocument;
|
|
|
|
if (aElement != doc.documentElement && aElement != doc.body)
|
|
|
|
return;
|
|
|
|
|
|
|
|
// draw the vertical scrollbar as needed
|
|
|
|
let scrollMax = aElement.scrollHeight;
|
|
|
|
let viewSize = aElement.clientHeight;
|
|
|
|
if (scrollMax > viewSize) {
|
|
|
|
let scrollPos = aElement.scrollTop;
|
|
|
|
let scrollerSize = this.selectedBrowser.clientHeight;
|
|
|
|
// scrollerSize may not equal viewSize if the user has zoomed
|
|
|
|
let barStart = Math.round(scrollerSize * scrollPos / scrollMax);
|
|
|
|
let barEnd = Math.round(scrollerSize * (scrollPos + viewSize) / scrollMax);
|
|
|
|
this.vertScroller.height = (barEnd - barStart);
|
|
|
|
this.vertScroller.style.MozTransform = "translateY(" + barStart + "px)";
|
|
|
|
this.vertScroller.setAttribute("panning", "true");
|
|
|
|
}
|
|
|
|
|
|
|
|
// draw the horizontal scrollbar as needed
|
|
|
|
scrollMax = aElement.scrollWidth;
|
|
|
|
viewSize = aElement.clientWidth;
|
|
|
|
if (scrollMax > viewSize) {
|
|
|
|
let scrollPos = aElement.scrollLeft;
|
|
|
|
let scrollerSize = this.selectedBrowser.clientWidth;
|
|
|
|
// scrollerSize may not equal viewSize if the user has zoomed
|
|
|
|
let barStart = Math.round(scrollerSize * scrollPos / scrollMax);
|
|
|
|
let barEnd = Math.round(scrollerSize * (scrollPos + viewSize) / scrollMax);
|
|
|
|
this.horizScroller.width = (barEnd - barStart);
|
|
|
|
this.horizScroller.style.MozTransform = "translateX(" + barStart + "px)";
|
|
|
|
this.horizScroller.setAttribute("panning", "true");
|
|
|
|
}
|
|
|
|
},
|
|
|
|
|
|
|
|
hideScrollbars: function() {
|
|
|
|
this.vertScroller.setAttribute("panning", "");
|
|
|
|
this.horizScroller.setAttribute("panning", "");
|
|
|
|
},
|
|
|
|
|
2011-10-13 13:06:41 -07:00
|
|
|
observe: function(aSubject, aTopic, aData) {
|
|
|
|
let browser = this.selectedBrowser;
|
|
|
|
if (!browser)
|
|
|
|
return;
|
|
|
|
|
2011-10-31 08:02:34 -07:00
|
|
|
if (aTopic == "Session:Back") {
|
2011-10-13 13:06:41 -07:00
|
|
|
browser.goBack();
|
2011-10-31 08:02:34 -07:00
|
|
|
} else if (aTopic == "Session:Forward") {
|
2011-10-31 08:02:34 -07:00
|
|
|
browser.goForward();
|
2011-10-31 08:02:34 -07:00
|
|
|
} else if (aTopic == "Session:Reload") {
|
2011-10-13 13:06:41 -07:00
|
|
|
browser.reload();
|
2011-11-16 16:23:22 -08:00
|
|
|
} else if (aTopic == "Session:Stop") {
|
|
|
|
browser.stop();
|
2011-10-26 11:32:14 -07:00
|
|
|
} else if (aTopic == "Tab:Add") {
|
|
|
|
let uri = URIFixup.createFixupURI(aData, Ci.nsIURIFixup.FIXUP_FLAG_ALLOW_KEYWORD_LOOKUP);
|
|
|
|
let newTab = this.addTab(uri ? uri.spec : aData);
|
2011-10-14 22:35:15 -07:00
|
|
|
newTab.active = true;
|
2011-10-26 11:32:14 -07:00
|
|
|
} else if (aTopic == "Tab:Load") {
|
|
|
|
let uri = URIFixup.createFixupURI(aData, Ci.nsIURIFixup.FIXUP_FLAG_ALLOW_KEYWORD_LOOKUP);
|
|
|
|
browser.loadURI(uri ? uri.spec : aData);
|
|
|
|
} else if (aTopic == "Tab:Select") {
|
2011-10-24 12:20:27 -07:00
|
|
|
this.selectTab(this.getTabForId(parseInt(aData)));
|
2011-10-26 11:32:14 -07:00
|
|
|
} else if (aTopic == "Tab:Close") {
|
2011-10-24 12:20:27 -07:00
|
|
|
this.closeTab(this.getTabForId(parseInt(aData)));
|
2011-11-16 14:33:43 -08:00
|
|
|
} else if (aTopic == "Browser:Quit") {
|
|
|
|
this.quit();
|
2011-10-27 21:55:15 -07:00
|
|
|
} else if (aTopic == "SaveAs:PDF") {
|
2011-10-25 08:51:23 -07:00
|
|
|
this.saveAsPDF(browser);
|
2011-10-26 11:32:14 -07:00
|
|
|
} else if (aTopic == "Preferences:Get") {
|
2011-10-14 12:48:02 -07:00
|
|
|
this.getPreferences(aData);
|
2011-10-26 11:32:14 -07:00
|
|
|
} else if (aTopic == "Preferences:Set") {
|
2011-10-14 12:48:02 -07:00
|
|
|
this.setPreferences(aData);
|
2011-10-26 11:30:48 -07:00
|
|
|
} else if (aTopic == "ScrollTo:FocusedInput") {
|
|
|
|
this.scrollToFocusedInput(browser);
|
2011-10-27 21:55:15 -07:00
|
|
|
} else if (aTopic == "Sanitize:ClearAll") {
|
|
|
|
Sanitizer.sanitize();
|
2011-11-09 17:39:29 -08:00
|
|
|
} else if (aTopic == "PanZoom:PanZoom") {
|
|
|
|
this.panZoom(aData);
|
2011-11-08 10:36:04 -08:00
|
|
|
} else if (aTopic == "FullScreen:Exit") {
|
|
|
|
browser.contentDocument.mozCancelFullScreen();
|
2011-10-26 11:32:14 -07:00
|
|
|
}
|
2011-10-13 13:06:41 -07:00
|
|
|
}
|
2011-10-10 17:40:17 -07:00
|
|
|
}
|
2008-11-21 21:12:25 -08:00
|
|
|
|
2011-10-20 22:50:04 -07:00
|
|
|
var NativeWindow = {
|
|
|
|
init: function() {
|
|
|
|
Services.obs.addObserver(this, "Menu:Clicked", false);
|
2011-10-26 13:21:42 -07:00
|
|
|
Services.obs.addObserver(this, "Doorhanger:Reply", false);
|
2011-11-03 15:09:37 -07:00
|
|
|
this.contextmenus.init();
|
2011-10-20 22:50:04 -07:00
|
|
|
},
|
|
|
|
|
|
|
|
uninit: function() {
|
|
|
|
Services.obs.removeObserver(this, "Menu:Clicked");
|
2011-10-26 13:21:42 -07:00
|
|
|
Services.obs.removeObserver(this, "Doorhanger:Reply");
|
2011-11-03 15:09:37 -07:00
|
|
|
this.contextmenus.uninit();
|
2011-10-20 22:50:04 -07:00
|
|
|
},
|
|
|
|
|
2011-10-25 19:51:44 -07:00
|
|
|
toast: {
|
|
|
|
show: function(aMessage, aDuration) {
|
|
|
|
sendMessageToJava({
|
|
|
|
gecko: {
|
|
|
|
type: "Toast:Show",
|
|
|
|
message: aMessage,
|
|
|
|
duration: aDuration
|
|
|
|
}
|
|
|
|
});
|
|
|
|
}
|
|
|
|
},
|
|
|
|
|
2011-10-20 22:50:04 -07:00
|
|
|
menu: {
|
|
|
|
_callbacks: [],
|
|
|
|
_menuId: 0,
|
|
|
|
add: function(aName, aIcon, aCallback) {
|
2011-10-25 19:51:44 -07:00
|
|
|
sendMessageToJava({
|
|
|
|
gecko: {
|
|
|
|
type: "Menu:Add",
|
|
|
|
name: aName,
|
|
|
|
icon: aIcon,
|
|
|
|
id: this._menuId
|
|
|
|
}
|
|
|
|
});
|
2011-10-20 22:50:04 -07:00
|
|
|
this._callbacks[this._menuId] = aCallback;
|
|
|
|
this._menuId++;
|
|
|
|
return this._menuId - 1;
|
|
|
|
},
|
|
|
|
|
|
|
|
remove: function(aId) {
|
|
|
|
sendMessageToJava({ gecko: {type: "Menu:Remove", id: aId }});
|
|
|
|
}
|
|
|
|
},
|
|
|
|
|
2011-10-26 13:21:42 -07:00
|
|
|
doorhanger: {
|
2011-11-01 13:02:56 -07:00
|
|
|
_callbacks: {},
|
2011-10-26 13:21:42 -07:00
|
|
|
_callbacksId: 0,
|
|
|
|
_promptId: 0,
|
2011-11-11 13:43:38 -08:00
|
|
|
|
2011-11-11 13:44:09 -08:00
|
|
|
/**
|
|
|
|
* @param aOptions
|
|
|
|
* An options JavaScript object holding additional properties for the
|
|
|
|
* notification. The following properties are currently supported:
|
|
|
|
* persistence: An integer. The notification will not automatically
|
2011-11-15 12:30:54 -08:00
|
|
|
* dismiss for this many page loads. If persistence is set
|
|
|
|
* to -1, the doorhanger will never automatically dismiss.
|
2011-11-11 13:44:09 -08:00
|
|
|
* timeout: A time in milliseconds. The notification will not
|
|
|
|
* automatically dismiss before this time.
|
|
|
|
*/
|
|
|
|
show: function(aMessage, aValue, aButtons, aTabID, aOptions) {
|
2011-10-26 13:21:42 -07:00
|
|
|
aButtons.forEach((function(aButton) {
|
|
|
|
this._callbacks[this._callbacksId] = { cb: aButton.callback, prompt: this._promptId };
|
|
|
|
aButton.callback = this._callbacksId;
|
|
|
|
this._callbacksId++;
|
|
|
|
}).bind(this));
|
|
|
|
|
|
|
|
this._promptId++;
|
|
|
|
let json = {
|
|
|
|
gecko: {
|
|
|
|
type: "Doorhanger:Add",
|
|
|
|
message: aMessage,
|
2011-11-11 13:43:38 -08:00
|
|
|
value: aValue,
|
2011-10-26 13:21:42 -07:00
|
|
|
buttons: aButtons,
|
2011-11-11 13:43:38 -08:00
|
|
|
// use the current tab if none is provided
|
2011-11-11 13:44:09 -08:00
|
|
|
tabID: aTabID || BrowserApp.selectedTab.id,
|
|
|
|
options: aOptions || {}
|
2011-10-26 13:21:42 -07:00
|
|
|
}
|
|
|
|
};
|
|
|
|
sendMessageToJava(json);
|
2011-11-15 14:45:54 -08:00
|
|
|
},
|
|
|
|
|
|
|
|
hide: function(aValue, aTabID) {
|
|
|
|
sendMessageToJava({
|
|
|
|
type: "Doorhanger:Remove",
|
|
|
|
value: aValue,
|
|
|
|
tabID: aTabID
|
|
|
|
});
|
2011-10-26 13:21:42 -07:00
|
|
|
}
|
|
|
|
},
|
2011-11-01 13:02:56 -07:00
|
|
|
|
2011-10-20 22:50:04 -07:00
|
|
|
observe: function(aSubject, aTopic, aData) {
|
2011-10-26 13:21:42 -07:00
|
|
|
if (aTopic == "Menu:Clicked") {
|
|
|
|
if (this.menu._callbacks[aData])
|
|
|
|
this.menu._callbacks[aData]();
|
|
|
|
} else if (aTopic == "Doorhanger:Reply") {
|
2011-11-03 23:54:47 -07:00
|
|
|
let reply_id = aData;
|
|
|
|
if (this.doorhanger._callbacks[reply_id]) {
|
|
|
|
let prompt = this.doorhanger._callbacks[reply_id].prompt;
|
|
|
|
this.doorhanger._callbacks[reply_id].cb();
|
|
|
|
for (let id in this.doorhanger._callbacks) {
|
|
|
|
if (this.doorhanger._callbacks[id].prompt == prompt) {
|
|
|
|
delete this.doorhanger._callbacks[id];
|
2011-11-01 13:02:56 -07:00
|
|
|
}
|
2011-10-26 13:21:42 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2011-11-03 15:09:37 -07:00
|
|
|
},
|
|
|
|
contextmenus: {
|
|
|
|
items: {}, // a list of context menu items that we may show
|
|
|
|
textContext: null, // saved selector for text input areas
|
|
|
|
linkContext: null, // saved selector for links
|
|
|
|
_contextId: 0, // id to assign to new context menu items if they are added
|
|
|
|
|
|
|
|
init: function() {
|
|
|
|
this.textContext = this.SelectorContext("input[type='text'],input[type='password'],textarea");
|
|
|
|
this.linkContext = this.SelectorContext("a:not([href='']),area:not([href='']),link");
|
|
|
|
Services.obs.addObserver(this, "Gesture:LongPress", false);
|
|
|
|
|
|
|
|
// TODO: These should eventually move into more appropriate classes
|
|
|
|
this.add(Strings.browser.GetStringFromName("contextmenu.openInNewTab"),
|
|
|
|
this.linkContext,
|
|
|
|
function(aTarget) {
|
|
|
|
let url = NativeWindow.contextmenus._getLinkURL(aTarget);
|
2011-11-08 12:49:25 -08:00
|
|
|
BrowserApp.addTab(url, {selected: false});
|
2011-11-03 15:09:37 -07:00
|
|
|
});
|
|
|
|
|
|
|
|
this.add(Strings.browser.GetStringFromName("contextmenu.changeInputMethod"),
|
|
|
|
this.textContext,
|
|
|
|
function(aTarget) {
|
|
|
|
Cc["@mozilla.org/imepicker;1"].getService(Ci.nsIIMEPicker).show();
|
|
|
|
});
|
2011-11-08 10:36:04 -08:00
|
|
|
|
|
|
|
this.add(Strings.browser.GetStringFromName("contextmenu.fullScreen"),
|
2011-11-11 15:51:12 -08:00
|
|
|
this.SelectorContext("video:not(:-moz-full-screen)"),
|
2011-11-08 10:36:04 -08:00
|
|
|
function(aTarget) {
|
|
|
|
aTarget.mozRequestFullScreen();
|
|
|
|
});
|
2011-11-03 15:09:37 -07:00
|
|
|
},
|
|
|
|
|
|
|
|
uninit: function() {
|
|
|
|
Services.obs.removeObserver(this, "Gesture:LongPress");
|
|
|
|
},
|
|
|
|
|
|
|
|
add: function(aName, aSelector, aCallback) {
|
|
|
|
if (!aName)
|
|
|
|
throw "Menu items must have a name";
|
|
|
|
|
|
|
|
let item = {
|
|
|
|
name: aName,
|
|
|
|
context: aSelector,
|
|
|
|
callback: aCallback,
|
|
|
|
matches: function(aElt) {
|
|
|
|
return this.context.matches(aElt);
|
|
|
|
},
|
|
|
|
getValue: function() {
|
|
|
|
return {
|
|
|
|
label: this.name,
|
|
|
|
id: this.id
|
|
|
|
}
|
|
|
|
}
|
|
|
|
};
|
|
|
|
item.id = this._contextId++;
|
|
|
|
this.items[item.id] = item;
|
|
|
|
return item.id;
|
|
|
|
},
|
|
|
|
|
|
|
|
remove: function(aId) {
|
|
|
|
this.items[aId] = null;
|
|
|
|
},
|
|
|
|
|
|
|
|
SelectorContext: function(aSelector) {
|
|
|
|
return {
|
|
|
|
matches: function(aElt) {
|
|
|
|
if (aElt.mozMatchesSelector)
|
|
|
|
return aElt.mozMatchesSelector(aSelector);
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
},
|
|
|
|
|
|
|
|
_sendToContent: function(aX, aY) {
|
|
|
|
// initially we look for nearby clickable elements. If we don't find one we fall back to using whatever this click was on
|
|
|
|
let rootElement = ElementTouchHelper.elementFromPoint(BrowserApp.selectedBrowser.contentWindow, aX, aY);
|
|
|
|
if (!rootElement)
|
|
|
|
rootElement = ElementTouchHelper.anyElementFromPoint(BrowserApp.selectedBrowser.contentWindow, aX, aY)
|
|
|
|
|
|
|
|
this.menuitems = null;
|
|
|
|
let element = rootElement;
|
|
|
|
if (!element)
|
|
|
|
return;
|
|
|
|
|
|
|
|
while (element) {
|
|
|
|
for each (let item in this.items) {
|
|
|
|
// since we'll have to spin through this for each element, check that
|
|
|
|
// it is not already in the list
|
|
|
|
if ((!this.menuitems || !this.menuitems[item.id]) && item.matches(element)) {
|
|
|
|
if (!this.menuitems)
|
|
|
|
this.menuitems = {};
|
|
|
|
this.menuitems[item.id] = item;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (this.linkContext.matches(element) || this.textContext.matches(element))
|
|
|
|
break;
|
|
|
|
element = element.parentNode;
|
|
|
|
}
|
|
|
|
|
|
|
|
// only send the contextmenu event to content if we are planning to show a context menu (i.e. not on every long tap)
|
|
|
|
if (this.menuitems) {
|
|
|
|
BrowserEventHandler.blockClick = true;
|
|
|
|
let event = rootElement.ownerDocument.createEvent("MouseEvent");
|
|
|
|
event.initMouseEvent("contextmenu", true, true, content,
|
|
|
|
0, aX, aY, aX, aY, false, false, false, false,
|
|
|
|
0, null);
|
|
|
|
rootElement.ownerDocument.defaultView.addEventListener("contextmenu", this, false);
|
|
|
|
rootElement.dispatchEvent(event);
|
|
|
|
}
|
|
|
|
},
|
|
|
|
|
|
|
|
_show: function(aEvent) {
|
|
|
|
if (aEvent.getPreventDefault())
|
|
|
|
return;
|
|
|
|
|
|
|
|
let popupNode = aEvent.originalTarget;
|
|
|
|
let title = "";
|
|
|
|
if ((popupNode instanceof Ci.nsIDOMHTMLAnchorElement && popupNode.href) ||
|
|
|
|
(popupNode instanceof Ci.nsIDOMHTMLAreaElement && popupNode.href)) {
|
|
|
|
title = this._getLinkURL(popupNode);
|
|
|
|
} else if (popupNode instanceof Ci.nsIImageLoadingContent && popupNode.currentURI) {
|
|
|
|
title = popupNode.currentURI.spec;
|
|
|
|
} else if (popupNode instanceof Ci.nsIDOMHTMLMediaElement) {
|
2011-11-07 09:00:52 -08:00
|
|
|
title = (popupNode.currentSrc || popupNode.src);
|
2011-11-03 15:09:37 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
// convert this.menuitems object to an array for sending to native code
|
|
|
|
let itemArray = [];
|
|
|
|
for each (let item in this.menuitems) {
|
|
|
|
itemArray.push(item.getValue());
|
|
|
|
}
|
|
|
|
|
|
|
|
let msg = {
|
|
|
|
gecko: {
|
|
|
|
type: "Prompt:Show",
|
|
|
|
title: title,
|
|
|
|
listitems: itemArray
|
|
|
|
}
|
|
|
|
};
|
|
|
|
let data = JSON.parse(sendMessageToJava(msg));
|
|
|
|
let selectedId = itemArray[data.button].id;
|
|
|
|
let selectedItem = this.menuitems[selectedId];
|
|
|
|
|
|
|
|
if (selectedItem && selectedItem.callback) {
|
|
|
|
while (popupNode) {
|
|
|
|
if (selectedItem.matches(popupNode)) {
|
|
|
|
selectedItem.callback.call(selectedItem, popupNode);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
popupNode = popupNode.parentNode;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
this.menuitems = null;
|
|
|
|
},
|
|
|
|
|
|
|
|
handleEvent: function(aEvent) {
|
|
|
|
aEvent.target.ownerDocument.defaultView.removeEventListener("contextmenu", this, false);
|
|
|
|
this._show(aEvent);
|
|
|
|
},
|
|
|
|
|
|
|
|
observe: function(aSubject, aTopic, aData) {
|
|
|
|
let data = JSON.parse(aData);
|
|
|
|
// content gets first crack at cancelling context menus
|
|
|
|
this._sendToContent(data.x, data.y);
|
|
|
|
},
|
|
|
|
|
|
|
|
// XXX - These are stolen from Util.js, we should remove them if we bring it back
|
|
|
|
makeURLAbsolute: function makeURLAbsolute(base, url) {
|
|
|
|
// Note: makeURI() will throw if url is not a valid URI
|
|
|
|
return this.makeURI(url, null, this.makeURI(base)).spec;
|
|
|
|
},
|
|
|
|
|
|
|
|
makeURI: function makeURI(aURL, aOriginCharset, aBaseURI) {
|
|
|
|
return Services.io.newURI(aURL, aOriginCharset, aBaseURI);
|
|
|
|
},
|
|
|
|
|
|
|
|
_getLinkURL: function ch_getLinkURL(aLink) {
|
|
|
|
let href = aLink.href;
|
|
|
|
if (href)
|
|
|
|
return href;
|
|
|
|
|
|
|
|
href = aLink.getAttributeNS(kXLinkNamespace, "href");
|
|
|
|
if (!href || !href.match(/\S/)) {
|
|
|
|
// Without this we try to save as the current doc,
|
|
|
|
// for example, HTML case also throws if empty
|
|
|
|
throw "Empty href";
|
|
|
|
}
|
|
|
|
|
|
|
|
return Util.makeURLAbsolute(aLink.baseURI, href);
|
|
|
|
}
|
2011-10-20 22:50:04 -07:00
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2010-03-26 08:11:03 -07:00
|
|
|
|
2011-10-12 14:31:04 -07:00
|
|
|
function nsBrowserAccess() {
|
2011-10-10 17:40:17 -07:00
|
|
|
}
|
2010-06-09 16:07:12 -07:00
|
|
|
|
2011-10-10 17:40:17 -07:00
|
|
|
nsBrowserAccess.prototype = {
|
|
|
|
openURI: function browser_openURI(aURI, aOpener, aWhere, aContext) {
|
2011-10-27 17:25:34 -07:00
|
|
|
let isExternal = (aContext == Ci.nsIBrowserDOMWindow.OPEN_EXTERNAL);
|
|
|
|
|
2011-10-12 14:31:04 -07:00
|
|
|
dump("nsBrowserAccess::openURI");
|
2011-10-13 13:06:41 -07:00
|
|
|
let browser = BrowserApp.selectedBrowser;
|
2011-10-27 17:25:34 -07:00
|
|
|
if (!browser || isExternal) {
|
|
|
|
let tab = BrowserApp.addTab("about:blank");
|
|
|
|
BrowserApp.selectTab(tab);
|
|
|
|
browser = tab.browser;
|
|
|
|
}
|
2011-10-12 14:31:04 -07:00
|
|
|
|
|
|
|
// Why does returning the browser.contentWindow not work here?
|
|
|
|
Services.io.offline = false;
|
|
|
|
browser.loadURI(aURI.spec, null, null);
|
|
|
|
return null;
|
2009-01-08 22:51:13 -08:00
|
|
|
},
|
|
|
|
|
2011-10-10 17:40:17 -07:00
|
|
|
openURIInFrame: function browser_openURIInFrame(aURI, aOpener, aWhere, aContext) {
|
2011-10-12 14:31:04 -07:00
|
|
|
dump("nsBrowserAccess::openURIInFrame");
|
|
|
|
return null;
|
2011-03-02 06:13:25 -08:00
|
|
|
},
|
|
|
|
|
2011-10-10 17:40:17 -07:00
|
|
|
isTabContentWindow: function(aWindow) {
|
2011-10-13 13:06:41 -07:00
|
|
|
return BrowserApp.getBrowserForWindow(aWindow) != null;
|
2008-07-11 11:51:28 -07:00
|
|
|
},
|
|
|
|
|
2011-10-12 14:31:04 -07:00
|
|
|
QueryInterface: XPCOMUtils.generateQI([Ci.nsIBrowserDOMWindow])
|
2011-10-10 17:40:17 -07:00
|
|
|
};
|
2008-04-18 06:41:49 -07:00
|
|
|
|
2011-10-14 23:22:25 -07:00
|
|
|
|
|
|
|
let gTabIDFactory = 0;
|
|
|
|
|
2011-11-08 12:49:25 -08:00
|
|
|
function Tab(aURL, aParams) {
|
2011-10-13 13:06:41 -07:00
|
|
|
this.browser = null;
|
2011-10-14 23:22:25 -07:00
|
|
|
this.id = 0;
|
2011-11-08 12:49:25 -08:00
|
|
|
this.create(aURL, aParams);
|
2011-10-10 17:40:17 -07:00
|
|
|
}
|
2009-11-30 12:19:24 -08:00
|
|
|
|
2011-10-13 13:06:41 -07:00
|
|
|
Tab.prototype = {
|
2011-11-08 12:49:25 -08:00
|
|
|
create: function(aURL, aParams) {
|
2011-10-13 13:06:41 -07:00
|
|
|
if (this.browser)
|
|
|
|
return;
|
|
|
|
|
|
|
|
this.browser = document.createElement("browser");
|
|
|
|
this.browser.setAttribute("type", "content");
|
2011-11-09 17:39:29 -08:00
|
|
|
this.browser.setAttribute("width", "980");
|
|
|
|
this.browser.setAttribute("height", "480");
|
2011-10-13 13:06:41 -07:00
|
|
|
BrowserApp.deck.appendChild(this.browser);
|
2011-11-15 08:58:23 -08:00
|
|
|
|
|
|
|
let frameLoader = this.browser.QueryInterface(Ci.nsIFrameLoaderOwner).frameLoader;
|
|
|
|
frameLoader.clipSubdocument = false;
|
|
|
|
|
2011-10-13 13:06:41 -07:00
|
|
|
this.browser.stop();
|
|
|
|
|
2011-10-14 23:22:25 -07:00
|
|
|
this.id = ++gTabIDFactory;
|
2011-11-08 12:49:25 -08:00
|
|
|
let aParams = aParams || { selected: true };
|
2011-10-14 22:35:15 -07:00
|
|
|
let message = {
|
|
|
|
gecko: {
|
2011-10-24 12:20:27 -07:00
|
|
|
type: "Tab:Added",
|
2011-10-14 23:22:25 -07:00
|
|
|
tabID: this.id,
|
2011-11-08 12:49:25 -08:00
|
|
|
uri: aURL,
|
|
|
|
selected: ("selected" in aParams) ? aParams.selected : true
|
2011-10-14 22:35:15 -07:00
|
|
|
}
|
|
|
|
};
|
|
|
|
sendMessageToJava(message);
|
2011-11-02 21:27:57 -07:00
|
|
|
|
|
|
|
let flags = Ci.nsIWebProgress.NOTIFY_STATE_ALL |
|
2011-11-03 15:53:34 -07:00
|
|
|
Ci.nsIWebProgress.NOTIFY_LOCATION |
|
|
|
|
Ci.nsIWebProgress.NOTIFY_SECURITY;
|
2011-11-02 21:27:57 -07:00
|
|
|
this.browser.addProgressListener(this, flags);
|
|
|
|
this.browser.sessionHistory.addSHistoryListener(this);
|
|
|
|
this.browser.loadURI(aURL);
|
2011-10-13 13:06:41 -07:00
|
|
|
},
|
|
|
|
|
|
|
|
destroy: function() {
|
|
|
|
if (!this.browser)
|
|
|
|
return;
|
|
|
|
|
|
|
|
this.browser.removeProgressListener(this);
|
|
|
|
BrowserApp.deck.removeChild(this.browser);
|
|
|
|
this.browser = null;
|
2011-10-24 12:20:27 -07:00
|
|
|
let message = {
|
|
|
|
gecko: {
|
|
|
|
type: "Tab:Closed",
|
|
|
|
tabID: this.id
|
|
|
|
}
|
|
|
|
};
|
2011-10-20 22:50:04 -07:00
|
|
|
|
2011-10-24 12:20:27 -07:00
|
|
|
sendMessageToJava(message);
|
2011-10-13 13:06:41 -07:00
|
|
|
},
|
|
|
|
|
|
|
|
set active(aActive) {
|
|
|
|
if (!this.browser)
|
|
|
|
return;
|
|
|
|
|
|
|
|
if (aActive) {
|
|
|
|
this.browser.setAttribute("type", "content-primary");
|
2011-10-20 15:48:26 -07:00
|
|
|
this.browser.focus();
|
2011-10-13 13:06:41 -07:00
|
|
|
BrowserApp.selectedTab = this;
|
|
|
|
} else {
|
|
|
|
this.browser.setAttribute("type", "content");
|
|
|
|
}
|
|
|
|
},
|
|
|
|
|
|
|
|
get active() {
|
|
|
|
if (!this.browser)
|
|
|
|
return false;
|
|
|
|
return this.browser.getAttribute("type") == "content-primary";
|
|
|
|
},
|
|
|
|
|
2011-10-12 14:31:04 -07:00
|
|
|
onStateChange: function(aWebProgress, aRequest, aStateFlags, aStatus) {
|
2011-10-24 19:00:52 -07:00
|
|
|
if (aStateFlags & Ci.nsIWebProgressListener.STATE_IS_DOCUMENT) {
|
|
|
|
// Filter optimization: Only really send DOCUMENT state changes to Java listener
|
|
|
|
let browser = BrowserApp.getBrowserForWindow(aWebProgress.DOMWindow);
|
|
|
|
let uri = "";
|
|
|
|
if (browser)
|
|
|
|
uri = browser.currentURI.spec;
|
|
|
|
|
|
|
|
let message = {
|
|
|
|
gecko: {
|
2011-11-03 15:53:34 -07:00
|
|
|
type: "Content:StateChange",
|
2011-10-24 19:00:52 -07:00
|
|
|
tabID: this.id,
|
|
|
|
uri: uri,
|
|
|
|
state: aStateFlags
|
|
|
|
}
|
|
|
|
};
|
2011-11-09 17:39:29 -08:00
|
|
|
|
2011-10-24 19:00:52 -07:00
|
|
|
sendMessageToJava(message);
|
|
|
|
}
|
2011-10-12 14:31:04 -07:00
|
|
|
},
|
2011-10-10 17:40:17 -07:00
|
|
|
|
2011-10-12 14:31:04 -07:00
|
|
|
onLocationChange: function(aWebProgress, aRequest, aLocationURI) {
|
2011-10-25 15:01:20 -07:00
|
|
|
let contentWin = aWebProgress.DOMWindow;
|
|
|
|
if (contentWin != contentWin.top)
|
|
|
|
return;
|
|
|
|
|
|
|
|
let browser = BrowserApp.getBrowserForWindow(contentWin);
|
2011-10-14 13:07:17 -07:00
|
|
|
let uri = browser.currentURI.spec;
|
|
|
|
|
|
|
|
let message = {
|
|
|
|
gecko: {
|
2011-11-03 15:53:34 -07:00
|
|
|
type: "Content:LocationChange",
|
2011-10-14 23:22:25 -07:00
|
|
|
tabID: this.id,
|
2011-10-14 13:07:17 -07:00
|
|
|
uri: uri
|
|
|
|
}
|
|
|
|
};
|
2011-10-12 14:31:04 -07:00
|
|
|
|
2011-10-14 13:07:17 -07:00
|
|
|
sendMessageToJava(message);
|
2011-10-12 14:31:04 -07:00
|
|
|
},
|
|
|
|
|
2011-11-03 15:53:34 -07:00
|
|
|
onSecurityChange: function(aWebProgress, aRequest, aState) {
|
|
|
|
let mode = "unknown";
|
|
|
|
if (aState & Ci.nsIWebProgressListener.STATE_IDENTITY_EV_TOPLEVEL)
|
|
|
|
mode = "identified";
|
|
|
|
else if (aState & Ci.nsIWebProgressListener.STATE_SECURE_HIGH)
|
|
|
|
mode = "verified";
|
|
|
|
else if (aState & Ci.nsIWebProgressListener.STATE_IS_BROKEN)
|
|
|
|
mode = "mixed";
|
|
|
|
else
|
|
|
|
mode = "unknown";
|
|
|
|
|
|
|
|
let message = {
|
|
|
|
gecko: {
|
|
|
|
type: "Content:SecurityChange",
|
|
|
|
tabID: this.id,
|
|
|
|
mode: mode
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
sendMessageToJava(message);
|
2011-10-12 14:31:04 -07:00
|
|
|
},
|
|
|
|
|
|
|
|
onProgressChange: function(aWebProgress, aRequest, aCurSelfProgress, aMaxSelfProgress, aCurTotalProgress, aMaxTotalProgress) {
|
|
|
|
},
|
2011-10-24 19:00:52 -07:00
|
|
|
|
2011-10-12 14:31:04 -07:00
|
|
|
onStatusChange: function(aBrowser, aWebProgress, aRequest, aStatus, aMessage) {
|
|
|
|
},
|
|
|
|
|
2011-10-31 08:02:20 -07:00
|
|
|
_sendHistoryEvent: function(aMessage, aIndex, aUri) {
|
|
|
|
let message = {
|
|
|
|
gecko: {
|
|
|
|
type: "SessionHistory:" + aMessage,
|
|
|
|
tabID: this.id,
|
|
|
|
}
|
|
|
|
};
|
|
|
|
if (aIndex != -1) {
|
|
|
|
message.gecko.index = aIndex;
|
|
|
|
}
|
|
|
|
if (aUri != null) {
|
|
|
|
message.gecko.uri = aUri;
|
|
|
|
}
|
|
|
|
sendMessageToJava(message);
|
|
|
|
},
|
|
|
|
|
|
|
|
OnHistoryNewEntry: function(aUri) {
|
|
|
|
this._sendHistoryEvent("New", -1, aUri.spec);
|
|
|
|
},
|
|
|
|
|
|
|
|
OnHistoryGoBack: function(aUri) {
|
|
|
|
this._sendHistoryEvent("Back", -1, null);
|
|
|
|
return true;
|
|
|
|
},
|
|
|
|
|
|
|
|
OnHistoryGoForward: function(aUri) {
|
|
|
|
this._sendHistoryEvent("Forward", -1, null);
|
|
|
|
return true;
|
|
|
|
},
|
|
|
|
|
|
|
|
OnHistoryReload: function(aUri, aFlags) {
|
|
|
|
// we don't do anything with this, so don't propagate it
|
|
|
|
// for now anyway
|
|
|
|
return true;
|
|
|
|
},
|
|
|
|
|
|
|
|
OnHistoryGotoIndex: function(aIndex, aUri) {
|
|
|
|
this._sendHistoryEvent("Goto", aIndex, null);
|
|
|
|
return true;
|
|
|
|
},
|
|
|
|
|
|
|
|
OnHistoryPurge: function(aNumEntries) {
|
|
|
|
this._sendHistoryEvent("Purge", -1, null);
|
|
|
|
return true;
|
|
|
|
},
|
|
|
|
|
|
|
|
QueryInterface: XPCOMUtils.generateQI([Ci.nsIWebProgressListener, Ci.nsISHistoryListener, Ci.nsISupportsWeakReference])
|
2011-10-10 17:40:17 -07:00
|
|
|
};
|
2010-04-08 07:43:04 -07:00
|
|
|
|
2009-08-12 14:40:43 -07:00
|
|
|
|
2011-10-13 13:06:41 -07:00
|
|
|
var BrowserEventHandler = {
|
|
|
|
init: function init() {
|
|
|
|
window.addEventListener("click", this, true);
|
2011-11-07 14:17:01 -08:00
|
|
|
window.addEventListener("mousedown", this, true);
|
2011-10-13 13:06:41 -07:00
|
|
|
window.addEventListener("mouseup", this, true);
|
2011-11-07 14:17:01 -08:00
|
|
|
window.addEventListener("mousemove", this, true);
|
2011-10-13 13:06:41 -07:00
|
|
|
|
|
|
|
BrowserApp.deck.addEventListener("DOMContentLoaded", this, true);
|
2011-10-14 13:07:17 -07:00
|
|
|
BrowserApp.deck.addEventListener("DOMLinkAdded", this, true);
|
|
|
|
BrowserApp.deck.addEventListener("DOMTitleChanged", this, true);
|
2011-11-03 23:54:47 -07:00
|
|
|
BrowserApp.deck.addEventListener("DOMUpdatePageReport", PopupBlockerObserver.onUpdatePageReport, false);
|
2011-11-09 17:39:29 -08:00
|
|
|
BrowserApp.deck.addEventListener("MozScrolledAreaChanged", this, true);
|
2011-10-13 13:06:41 -07:00
|
|
|
},
|
|
|
|
|
2011-10-12 14:31:04 -07:00
|
|
|
handleEvent: function(aEvent) {
|
|
|
|
switch (aEvent.type) {
|
2011-10-13 13:06:41 -07:00
|
|
|
case "DOMContentLoaded": {
|
|
|
|
let browser = BrowserApp.getBrowserForDocument(aEvent.target);
|
2011-11-11 20:20:21 -08:00
|
|
|
if (!browser)
|
|
|
|
return;
|
2011-10-14 22:35:15 -07:00
|
|
|
let tabID = BrowserApp.getTabForBrowser(browser).id;
|
2011-10-14 11:23:41 -07:00
|
|
|
|
2011-10-13 13:47:29 -07:00
|
|
|
sendMessageToJava({
|
2011-10-12 14:31:04 -07:00
|
|
|
gecko: {
|
|
|
|
type: "DOMContentLoaded",
|
2011-10-14 22:35:15 -07:00
|
|
|
tabID: tabID,
|
2011-10-12 14:31:04 -07:00
|
|
|
windowID: 0,
|
2011-10-23 21:11:29 -07:00
|
|
|
uri: browser.currentURI.spec,
|
2011-10-13 13:06:41 -07:00
|
|
|
title: browser.contentTitle
|
2011-10-12 14:31:04 -07:00
|
|
|
}
|
|
|
|
});
|
2011-10-27 21:55:12 -07:00
|
|
|
|
|
|
|
// Attach a listener to watch for "click" events bubbling up from error
|
|
|
|
// pages and other similar page. This lets us fix bugs like 401575 which
|
|
|
|
// require error page UI to do privileged things, without letting error
|
|
|
|
// pages have any privilege themselves.
|
|
|
|
if (/^about:/.test(aEvent.originalTarget.documentURI)) {
|
|
|
|
let browser = BrowserApp.getBrowserForDocument(aEvent.originalTarget);
|
|
|
|
browser.addEventListener("click", ErrorPageEventHandler, false);
|
2011-11-07 17:10:59 -08:00
|
|
|
browser.addEventListener("pagehide", function listener() {
|
2011-10-27 21:55:12 -07:00
|
|
|
browser.removeEventListener("click", ErrorPageEventHandler, false);
|
2011-11-07 17:10:59 -08:00
|
|
|
browser.removeEventListener("pagehide", listener, true);
|
2011-10-27 21:55:12 -07:00
|
|
|
}, true);
|
|
|
|
}
|
2011-11-09 17:39:29 -08:00
|
|
|
|
2011-10-12 14:31:04 -07:00
|
|
|
break;
|
2011-10-13 13:06:41 -07:00
|
|
|
}
|
2011-10-14 13:07:17 -07:00
|
|
|
|
2011-10-14 22:35:15 -07:00
|
|
|
case "DOMLinkAdded": {
|
2011-10-14 13:07:17 -07:00
|
|
|
let target = aEvent.originalTarget;
|
|
|
|
if (!target.href || target.disabled)
|
|
|
|
return;
|
2011-10-20 22:50:04 -07:00
|
|
|
|
2011-11-11 20:20:21 -08:00
|
|
|
let browser = BrowserApp.getBrowserForDocument(target.ownerDocument);
|
|
|
|
if (!browser)
|
|
|
|
return;
|
2011-10-24 12:20:27 -07:00
|
|
|
let tabID = BrowserApp.getTabForBrowser(browser).id;
|
|
|
|
|
2011-10-14 13:07:17 -07:00
|
|
|
let json = {
|
|
|
|
type: "DOMLinkAdded",
|
2011-10-24 12:20:27 -07:00
|
|
|
tabID: tabID,
|
2011-10-24 14:08:21 -07:00
|
|
|
href: resolveGeckoURI(target.href),
|
2011-10-14 13:07:17 -07:00
|
|
|
charset: target.ownerDocument.characterSet,
|
|
|
|
title: target.title,
|
|
|
|
rel: target.rel
|
|
|
|
};
|
|
|
|
|
|
|
|
// rel=icon can also have a sizes attribute
|
|
|
|
if (target.hasAttribute("sizes"))
|
|
|
|
json.sizes = target.getAttribute("sizes");
|
|
|
|
|
|
|
|
sendMessageToJava({ gecko: json });
|
|
|
|
break;
|
2011-10-14 22:35:15 -07:00
|
|
|
}
|
2011-10-14 13:07:17 -07:00
|
|
|
|
2011-10-14 22:35:15 -07:00
|
|
|
case "DOMTitleChanged": {
|
2011-10-25 08:49:22 -07:00
|
|
|
if (!aEvent.isTrusted)
|
|
|
|
return;
|
|
|
|
|
|
|
|
let contentWin = aEvent.target.defaultView;
|
|
|
|
if (contentWin != contentWin.top)
|
|
|
|
return;
|
|
|
|
|
2011-10-14 22:35:15 -07:00
|
|
|
let browser = BrowserApp.getBrowserForDocument(aEvent.target);
|
2011-10-25 08:49:22 -07:00
|
|
|
if (!browser)
|
|
|
|
return;
|
2011-10-14 22:35:15 -07:00
|
|
|
let tabID = BrowserApp.getTabForBrowser(browser).id;
|
2011-11-11 20:20:21 -08:00
|
|
|
|
2011-10-14 13:07:17 -07:00
|
|
|
sendMessageToJava({
|
|
|
|
gecko: {
|
|
|
|
type: "DOMTitleChanged",
|
2011-10-14 22:35:15 -07:00
|
|
|
tabID: tabID,
|
2011-10-14 13:07:17 -07:00
|
|
|
title: aEvent.target.title
|
|
|
|
}
|
|
|
|
});
|
|
|
|
break;
|
2011-10-14 22:35:15 -07:00
|
|
|
}
|
2011-10-14 13:07:17 -07:00
|
|
|
|
2011-10-12 14:31:04 -07:00
|
|
|
case "click":
|
|
|
|
if (this.blockClick) {
|
|
|
|
aEvent.stopPropagation();
|
|
|
|
aEvent.preventDefault();
|
2011-10-28 11:49:19 -07:00
|
|
|
} else {
|
2011-10-28 17:10:31 -07:00
|
|
|
let closest = ElementTouchHelper.elementFromPoint(BrowserApp.selectedBrowser.contentWindow, aEvent.clientX, aEvent.clientY);
|
|
|
|
if (closest) {
|
|
|
|
aEvent.stopPropagation();
|
|
|
|
aEvent.preventDefault();
|
|
|
|
this._sendMouseEvent("mousedown", closest, aEvent.clientX, aEvent.clientY);
|
|
|
|
this._sendMouseEvent("mouseup", closest, aEvent.clientX, aEvent.clientY);
|
|
|
|
} else {
|
|
|
|
FormAssistant.handleClick(aEvent);
|
|
|
|
}
|
2011-10-10 17:40:17 -07:00
|
|
|
}
|
2011-10-12 14:31:04 -07:00
|
|
|
break;
|
2011-10-14 13:07:17 -07:00
|
|
|
|
2011-10-12 14:31:04 -07:00
|
|
|
case "mousedown":
|
|
|
|
this.startX = aEvent.clientX;
|
|
|
|
this.startY = aEvent.clientY;
|
|
|
|
this.blockClick = false;
|
2011-10-19 09:17:59 -07:00
|
|
|
|
2011-10-15 14:44:05 -07:00
|
|
|
this.firstMovement = true;
|
2011-10-19 09:17:59 -07:00
|
|
|
this.edx = 0;
|
|
|
|
this.edy = 0;
|
|
|
|
this.lockXaxis = false;
|
|
|
|
this.lockYaxis = false;
|
2011-10-17 12:02:27 -07:00
|
|
|
|
|
|
|
this.motionBuffer = [];
|
2011-10-15 14:44:05 -07:00
|
|
|
this._updateLastPosition(aEvent.clientX, aEvent.clientY, 0, 0);
|
|
|
|
this.panElement = this._findScrollableElement(aEvent.originalTarget,
|
|
|
|
true);
|
|
|
|
|
|
|
|
if (this.panElement)
|
|
|
|
this.panning = true;
|
2011-11-09 17:39:29 -08:00
|
|
|
if (!this._elementReceivesInput(aEvent.target))
|
|
|
|
aEvent.preventDefault(); // Stops selection.
|
2011-10-20 15:48:26 -07:00
|
|
|
break;
|
2011-10-13 08:13:59 -07:00
|
|
|
|
2011-10-20 15:48:26 -07:00
|
|
|
case "mousemove":
|
2011-10-12 14:31:04 -07:00
|
|
|
aEvent.stopPropagation();
|
|
|
|
aEvent.preventDefault();
|
2011-10-14 13:07:17 -07:00
|
|
|
|
2011-10-15 14:44:05 -07:00
|
|
|
if (!this.panning)
|
|
|
|
break;
|
|
|
|
|
2011-10-19 09:17:59 -07:00
|
|
|
this.edx += aEvent.clientX - this.lastX;
|
|
|
|
this.edy += aEvent.clientY - this.lastY;
|
2011-10-15 14:44:05 -07:00
|
|
|
|
|
|
|
// If this is the first panning motion, check if we can
|
|
|
|
// move in the given direction. If we can't, find an
|
|
|
|
// ancestor that can.
|
|
|
|
// We do this per-axis, as often the very first movement doesn't
|
|
|
|
// reflect the direction of movement for both axes.
|
|
|
|
if (this.firstMovement &&
|
2011-10-19 09:17:59 -07:00
|
|
|
(Math.abs(this.edx) > kDragThreshold ||
|
|
|
|
Math.abs(this.edy) > kDragThreshold)) {
|
2011-10-15 14:44:05 -07:00
|
|
|
this.firstMovement = false;
|
|
|
|
let originalElement = this.panElement;
|
|
|
|
|
2011-10-19 09:17:59 -07:00
|
|
|
// Decide if we want to lock an axis while scrolling
|
|
|
|
if (Math.abs(this.edx) > Math.abs(this.edy) * kAxisLockRatio)
|
|
|
|
this.lockYaxis = true;
|
|
|
|
else if (Math.abs(this.edy) > Math.abs(this.edx) * kAxisLockRatio)
|
|
|
|
this.lockXaxis = true;
|
|
|
|
|
2011-10-15 14:44:05 -07:00
|
|
|
// See if we've reached the extents of this element and if so,
|
|
|
|
// find an element above it that can be scrolled.
|
|
|
|
while (this.panElement &&
|
|
|
|
!this._elementCanScroll(this.panElement,
|
2011-10-19 09:17:59 -07:00
|
|
|
-this.edx,
|
|
|
|
-this.edy)) {
|
2011-10-15 14:44:05 -07:00
|
|
|
this.panElement =
|
|
|
|
this._findScrollableElement(this.panElement, false);
|
|
|
|
}
|
|
|
|
|
|
|
|
// If there are no scrollable elements above the element whose
|
|
|
|
// extents we've reached, let that element be scrolled.
|
|
|
|
if (!this.panElement)
|
|
|
|
this.panElement = originalElement;
|
|
|
|
}
|
|
|
|
|
2011-10-19 09:17:59 -07:00
|
|
|
// Only scroll once we've moved past the drag threshold
|
|
|
|
if (!this.firstMovement) {
|
|
|
|
this._scrollElementBy(this.panElement,
|
|
|
|
this.lockXaxis ? 0 : -this.edx,
|
|
|
|
this.lockYaxis ? 0 : -this.edy);
|
|
|
|
|
|
|
|
// Note, it's important that this happens after the scrollElementBy,
|
|
|
|
// as this will modify the clientX/clientY to be relative to the
|
|
|
|
// correct element.
|
|
|
|
this._updateLastPosition(aEvent.clientX, aEvent.clientY,
|
|
|
|
this.lockXaxis ? 0 : this.edx,
|
|
|
|
this.lockYaxis ? 0 : this.edy);
|
|
|
|
|
|
|
|
// Allow breaking out of axis lock if we move past a certain threshold
|
|
|
|
if (this.lockXaxis) {
|
|
|
|
if (Math.abs(this.edx) > kLockBreakThreshold)
|
|
|
|
this.lockXaxis = false;
|
|
|
|
} else {
|
|
|
|
this.edx = 0;
|
|
|
|
}
|
2011-10-15 14:44:05 -07:00
|
|
|
|
2011-10-19 09:17:59 -07:00
|
|
|
if (this.lockYaxis) {
|
|
|
|
if (Math.abs(this.edy) > kLockBreakThreshold)
|
|
|
|
this.lockYaxis = false;
|
|
|
|
} else {
|
|
|
|
this.edy = 0;
|
|
|
|
}
|
|
|
|
}
|
2011-10-12 14:31:04 -07:00
|
|
|
break;
|
2011-10-14 13:07:17 -07:00
|
|
|
|
2011-10-12 14:31:04 -07:00
|
|
|
case "mouseup":
|
2011-10-13 08:13:59 -07:00
|
|
|
this.panning = false;
|
|
|
|
|
2011-10-31 13:25:21 -07:00
|
|
|
// hide the scrollbars in case we're done scrolling. if the
|
|
|
|
// kinetic scrolling kicks in, it will re-enable the scrollbars
|
|
|
|
// anyway by calling _scrollElementBy below
|
|
|
|
BrowserApp.hideScrollbars();
|
|
|
|
|
2011-10-19 09:17:59 -07:00
|
|
|
if (Math.abs(aEvent.clientX - this.startX) > kDragThreshold ||
|
|
|
|
Math.abs(aEvent.clientY - this.startY) > kDragThreshold) {
|
2011-10-12 14:31:04 -07:00
|
|
|
this.blockClick = true;
|
2011-10-15 14:44:05 -07:00
|
|
|
aEvent.stopPropagation();
|
|
|
|
aEvent.preventDefault();
|
2011-10-13 08:13:59 -07:00
|
|
|
|
2011-10-19 09:17:59 -07:00
|
|
|
// Calculate a regression line for the last few motion events in
|
|
|
|
// the same direction to estimate the velocity. This ought to do a
|
|
|
|
// reasonable job of accounting for jitter/bad events.
|
|
|
|
this.panLastTime = Date.now();
|
|
|
|
|
|
|
|
// Variables required for calculating regression on each axis
|
|
|
|
// 'p' will be sum of positions
|
|
|
|
// 't' will be sum of times
|
|
|
|
// 'tp' will be sum of times * positions
|
|
|
|
// 'tt' will be sum of time^2's
|
|
|
|
// 'n' is the number of data-points
|
|
|
|
let xSums = { p: 0, t: 0, tp: 0, tt: 0, n: 0 };
|
|
|
|
let ySums = { p: 0, t: 0, tp: 0, tt: 0, n: 0 };
|
|
|
|
let lastDx = 0;
|
|
|
|
let lastDy = 0;
|
|
|
|
|
|
|
|
// Variables to find the absolute x,y (relative to the first event)
|
|
|
|
let edx = 0; // Sum of x changes
|
|
|
|
let edy = 0; // Sum of y changes
|
|
|
|
|
|
|
|
// For convenience
|
|
|
|
let mb = this.motionBuffer;
|
|
|
|
|
|
|
|
// First collect the variables necessary to calculate the line
|
|
|
|
for (let i = 0; i < mb.length; i++) {
|
|
|
|
|
|
|
|
// Sum up total movement so far
|
|
|
|
let dx = edx + mb[i].dx;
|
|
|
|
let dy = edy + mb[i].dy;
|
|
|
|
edx += mb[i].dx;
|
|
|
|
edy += mb[i].dy;
|
|
|
|
|
|
|
|
// Don't consider events before direction changes
|
|
|
|
if ((xSums.n > 0) &&
|
|
|
|
((mb[i].dx < 0 && lastDx > 0) ||
|
|
|
|
(mb[i].dx > 0 && lastDx < 0))) {
|
|
|
|
xSums = { p: 0, t: 0, tp: 0, tt: 0, n: 0 };
|
|
|
|
}
|
|
|
|
if ((ySums.n > 0) &&
|
|
|
|
((mb[i].dy < 0 && lastDy > 0) ||
|
|
|
|
(mb[i].dy > 0 && lastDy < 0))) {
|
|
|
|
ySums = { p: 0, t: 0, tp: 0, tt: 0, n: 0 };
|
|
|
|
}
|
|
|
|
|
|
|
|
if (mb[i].dx != 0)
|
|
|
|
lastDx = mb[i].dx;
|
|
|
|
if (mb[i].dy != 0)
|
|
|
|
lastDy = mb[i].dy;
|
|
|
|
|
|
|
|
// Only consider events that happened in the last kSwipeLength ms
|
|
|
|
let timeDelta = this.panLastTime - mb[i].time;
|
|
|
|
if (timeDelta > kSwipeLength)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
xSums.p += dx;
|
|
|
|
xSums.t += timeDelta;
|
|
|
|
xSums.tp += timeDelta * dx;
|
|
|
|
xSums.tt += timeDelta * timeDelta;
|
|
|
|
xSums.n ++;
|
|
|
|
|
|
|
|
ySums.p += dy;
|
|
|
|
ySums.t += timeDelta;
|
|
|
|
ySums.tp += timeDelta * dy;
|
|
|
|
ySums.tt += timeDelta * timeDelta;
|
|
|
|
ySums.n ++;
|
2011-10-13 08:13:59 -07:00
|
|
|
}
|
2011-10-19 09:17:59 -07:00
|
|
|
|
|
|
|
// If we don't have enough usable motion events, bail out
|
|
|
|
if (xSums.n < 2 && ySums.n < 2)
|
2011-10-17 12:02:27 -07:00
|
|
|
break;
|
|
|
|
|
2011-10-19 09:17:59 -07:00
|
|
|
// Calculate the slope of the regression line.
|
|
|
|
// The intercept of the regression line is commented for reference.
|
|
|
|
let sx = 0;
|
|
|
|
if (xSums.n > 1)
|
|
|
|
sx = ((xSums.n * xSums.tp) - (xSums.t * xSums.p)) /
|
|
|
|
((xSums.n * xSums.tt) - (xSums.t * xSums.t));
|
|
|
|
//let ix = (xSums.p - (sx * xSums.t)) / xSums.n;
|
|
|
|
|
|
|
|
let sy = 0;
|
|
|
|
if (ySums.n > 1)
|
|
|
|
sy = ((ySums.n * ySums.tp) - (ySums.t * ySums.p)) /
|
|
|
|
((ySums.n * ySums.tt) - (ySums.t * ySums.t));
|
|
|
|
//let iy = (ySums.p - (sy * ySums.t)) / ySums.n;
|
|
|
|
|
|
|
|
// The slope of the regression line is the projected acceleration
|
|
|
|
this.panX = -sx;
|
|
|
|
this.panY = -sy;
|
|
|
|
|
2011-10-17 12:02:27 -07:00
|
|
|
if (Math.abs(this.panX) > kMaxKineticSpeed)
|
|
|
|
this.panX = (this.panX > 0) ? kMaxKineticSpeed : -kMaxKineticSpeed;
|
|
|
|
if (Math.abs(this.panY) > kMaxKineticSpeed)
|
|
|
|
this.panY = (this.panY > 0) ? kMaxKineticSpeed : -kMaxKineticSpeed;
|
|
|
|
|
|
|
|
// If we have (near) zero acceleration, bail out.
|
|
|
|
if (Math.abs(this.panX) < kMinKineticSpeed &&
|
|
|
|
Math.abs(this.panY) < kMinKineticSpeed)
|
2011-10-15 14:44:05 -07:00
|
|
|
break;
|
|
|
|
|
|
|
|
// Check if this element can scroll - if not, let's bail out.
|
|
|
|
if (!this.panElement || !this._elementCanScroll(
|
|
|
|
this.panElement, -this.panX, -this.panY))
|
|
|
|
break;
|
|
|
|
|
|
|
|
// Fire off the first kinetic panning event
|
|
|
|
this._scrollElementBy(this.panElement, -this.panX, -this.panY);
|
2011-10-13 08:13:59 -07:00
|
|
|
|
|
|
|
// TODO: Use the kinetic scrolling prefs
|
|
|
|
this.panAccumulatedDeltaX = 0;
|
|
|
|
this.panAccumulatedDeltaY = 0;
|
|
|
|
|
|
|
|
let self = this;
|
2011-10-15 14:44:05 -07:00
|
|
|
let panElement = this.panElement;
|
2011-10-13 08:13:59 -07:00
|
|
|
let callback = {
|
|
|
|
onBeforePaint: function kineticPanCallback(timeStamp) {
|
2011-10-15 14:44:05 -07:00
|
|
|
if (self.panning || self.panElement != panElement)
|
2011-10-13 08:13:59 -07:00
|
|
|
return;
|
|
|
|
|
|
|
|
let timeDelta = timeStamp - self.panLastTime;
|
|
|
|
self.panLastTime = timeStamp;
|
|
|
|
|
|
|
|
// Adjust deceleration
|
2011-10-17 12:02:27 -07:00
|
|
|
self.panX *= Math.pow(kPanDeceleration, timeDelta);
|
|
|
|
self.panY *= Math.pow(kPanDeceleration, timeDelta);
|
2011-10-13 08:13:59 -07:00
|
|
|
|
|
|
|
// Calculate panning motion
|
|
|
|
let dx = self.panX * timeDelta;
|
|
|
|
let dy = self.panY * timeDelta;
|
|
|
|
|
|
|
|
// We only want to set integer scroll coordinates
|
|
|
|
self.panAccumulatedDeltaX += dx - Math.floor(dx);
|
|
|
|
self.panAccumulatedDeltaY += dy - Math.floor(dy);
|
|
|
|
|
|
|
|
dx = Math.floor(dx);
|
|
|
|
dy = Math.floor(dy);
|
|
|
|
|
|
|
|
if (Math.abs(self.panAccumulatedDeltaX) >= 1.0) {
|
|
|
|
let adx = Math.floor(self.panAccumulatedDeltaX);
|
|
|
|
dx += adx;
|
|
|
|
self.panAccumulatedDeltaX -= adx;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (Math.abs(self.panAccumulatedDeltaY) >= 1.0) {
|
|
|
|
let ady = Math.floor(self.panAccumulatedDeltaY);
|
|
|
|
dy += ady;
|
|
|
|
self.panAccumulatedDeltaY -= ady;
|
|
|
|
}
|
|
|
|
|
2011-10-31 13:27:29 -07:00
|
|
|
if (!self._elementCanScroll(panElement, -dx, -dy)) {
|
|
|
|
BrowserApp.hideScrollbars();
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2011-10-15 14:44:05 -07:00
|
|
|
self._scrollElementBy(panElement, -dx, -dy);
|
2011-10-13 08:13:59 -07:00
|
|
|
|
2011-10-17 12:02:27 -07:00
|
|
|
if (Math.abs(self.panX) >= kMinKineticSpeed ||
|
|
|
|
Math.abs(self.panY) >= kMinKineticSpeed)
|
2011-10-13 08:13:59 -07:00
|
|
|
window.mozRequestAnimationFrame(this);
|
2011-10-31 13:25:21 -07:00
|
|
|
else
|
|
|
|
BrowserApp.hideScrollbars();
|
|
|
|
}
|
2011-10-13 08:13:59 -07:00
|
|
|
};
|
|
|
|
|
2011-10-17 12:02:27 -07:00
|
|
|
// If one axis is moving a lot slower than the other, lock it.
|
|
|
|
if (Math.abs(this.panX) < Math.abs(this.panY) / kAxisLockRatio)
|
2011-10-13 08:13:59 -07:00
|
|
|
this.panX = 0;
|
2011-10-17 12:02:27 -07:00
|
|
|
else if (Math.abs(this.panY) < Math.abs(this.panX) / kAxisLockRatio)
|
2011-10-13 08:13:59 -07:00
|
|
|
this.panY = 0;
|
|
|
|
|
2011-10-15 14:44:05 -07:00
|
|
|
// Start the panning animation
|
|
|
|
window.mozRequestAnimationFrame(callback);
|
2011-10-12 14:31:04 -07:00
|
|
|
}
|
|
|
|
break;
|
2011-10-14 13:07:17 -07:00
|
|
|
|
2011-11-09 17:39:29 -08:00
|
|
|
case "MozScrolledAreaChanged":
|
|
|
|
let browser = BrowserApp.getBrowserForDocument(aEvent.target);
|
2011-11-15 08:58:26 -08:00
|
|
|
if (browser != BrowserApp.selectedBrowser)
|
2011-11-09 17:39:29 -08:00
|
|
|
return;
|
|
|
|
|
|
|
|
sendMessageToJava({
|
|
|
|
gecko: {
|
|
|
|
type: "PanZoom:Resize",
|
2011-11-15 08:58:26 -08:00
|
|
|
size: { width: aEvent.width, height: aEvent.height }
|
2011-11-09 17:39:29 -08:00
|
|
|
}
|
|
|
|
});
|
2011-10-12 14:31:04 -07:00
|
|
|
break;
|
2010-09-21 07:21:00 -07:00
|
|
|
}
|
2011-10-12 14:31:04 -07:00
|
|
|
},
|
2009-10-23 21:04:51 -07:00
|
|
|
|
2011-10-15 14:44:05 -07:00
|
|
|
_updateLastPosition: function(x, y, dx, dy) {
|
2011-10-12 14:31:04 -07:00
|
|
|
this.lastX = x;
|
|
|
|
this.lastY = y;
|
2011-10-13 08:13:59 -07:00
|
|
|
this.lastTime = Date.now();
|
|
|
|
|
2011-10-19 09:17:59 -07:00
|
|
|
this.motionBuffer.push({ dx: dx, dy: dy, time: this.lastTime });
|
2011-10-15 14:44:05 -07:00
|
|
|
},
|
|
|
|
|
2011-10-28 17:10:31 -07:00
|
|
|
_sendMouseEvent: function _sendMouseEvent(aName, aElement, aX, aY, aButton) {
|
|
|
|
// the element can be out of the aX/aY point because of the touch radius
|
|
|
|
// if outside, we gracefully move the touch point to the center of the element
|
|
|
|
if (!(aElement instanceof HTMLHtmlElement)) {
|
|
|
|
let isTouchClick = true;
|
|
|
|
let rects = ElementTouchHelper.getContentClientRects(aElement);
|
|
|
|
for (let i = 0; i < rects.length; i++) {
|
|
|
|
let rect = rects[i];
|
|
|
|
// We might be able to deal with fractional pixels, but mouse events won't.
|
|
|
|
// Deflate the bounds in by 1 pixel to deal with any fractional scroll offset issues.
|
|
|
|
let inBounds =
|
|
|
|
(aX > rect.left + 1 && aX < (rect.left + rect.width - 1)) &&
|
|
|
|
(aY > rect.top + 1 && aY < (rect.top + rect.height - 1));
|
|
|
|
if (inBounds) {
|
|
|
|
isTouchClick = false;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (isTouchClick) {
|
|
|
|
let rect = {x: rects[0].left, y: rects[0].top, w: rects[0].width, h: rects[0].height};
|
|
|
|
if (rect.w == 0 && rect.h == 0)
|
|
|
|
return;
|
|
|
|
|
|
|
|
let point = { x: rect.x + rect.w/2, y: rect.y + rect.h/2 };
|
|
|
|
aX = point.x;
|
|
|
|
aY = point.y;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
let cwu = aElement.ownerDocument.defaultView.QueryInterface(Ci.nsIInterfaceRequestor).getInterface(Ci.nsIDOMWindowUtils);
|
|
|
|
aButton = aButton || 0;
|
|
|
|
cwu.sendMouseEventToWindow(aName, Math.round(aX), Math.round(aY), aButton, 1, 0, true);
|
|
|
|
},
|
|
|
|
|
2011-10-15 14:44:05 -07:00
|
|
|
_findScrollableElement: function(elem, checkElem) {
|
|
|
|
// Walk the DOM tree until we find a scrollable element
|
|
|
|
let scrollable = false;
|
|
|
|
while (elem) {
|
|
|
|
/* Element is scrollable if its scroll-size exceeds its client size, and:
|
|
|
|
* - It has overflow 'auto' or 'scroll'
|
|
|
|
* - It's a textarea
|
2011-11-09 17:39:29 -08:00
|
|
|
* We don't consider HTML/BODY nodes here, since Java pans those.
|
2011-10-15 14:44:05 -07:00
|
|
|
*/
|
|
|
|
if (checkElem) {
|
|
|
|
if (((elem.scrollHeight > elem.clientHeight) ||
|
|
|
|
(elem.scrollWidth > elem.clientWidth)) &&
|
|
|
|
(elem.style.overflow == 'auto' ||
|
|
|
|
elem.style.overflow == 'scroll' ||
|
2011-11-09 17:39:29 -08:00
|
|
|
elem.localName == 'textarea')) {
|
2011-10-15 14:44:05 -07:00
|
|
|
scrollable = true;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
checkElem = true;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Propagate up iFrames
|
|
|
|
if (!elem.parentNode && elem.documentElement &&
|
|
|
|
elem.documentElement.ownerDocument)
|
|
|
|
elem = elem.documentElement.ownerDocument.defaultView.frameElement;
|
|
|
|
else
|
|
|
|
elem = elem.parentNode;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!scrollable)
|
|
|
|
return null;
|
|
|
|
|
|
|
|
return elem;
|
|
|
|
},
|
|
|
|
|
2011-11-09 17:39:29 -08:00
|
|
|
_elementReceivesInput: function(aElement) {
|
|
|
|
return aElement instanceof Element &&
|
|
|
|
(kElementsReceivingInput.hasOwnProperty(aElement.tagName.toLowerCase()) ||
|
|
|
|
aElement.contentEditable === "true" || aElement.contentEditable === "");
|
|
|
|
},
|
|
|
|
|
2011-10-15 14:44:05 -07:00
|
|
|
_scrollElementBy: function(elem, x, y) {
|
|
|
|
elem.scrollTop = elem.scrollTop + y;
|
|
|
|
elem.scrollLeft = elem.scrollLeft + x;
|
2011-10-31 13:25:21 -07:00
|
|
|
BrowserApp.updateScrollbarsFor(elem);
|
2011-10-15 14:44:05 -07:00
|
|
|
},
|
|
|
|
|
|
|
|
_elementCanScroll: function(elem, x, y) {
|
|
|
|
let scrollX = true;
|
|
|
|
let scrollY = true;
|
|
|
|
|
|
|
|
if (x < 0) {
|
|
|
|
if (elem.scrollLeft <= 0) {
|
|
|
|
scrollX = false;
|
|
|
|
}
|
|
|
|
} else if (elem.scrollLeft >= (elem.scrollWidth - elem.clientWidth)) {
|
|
|
|
scrollX = false;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (y < 0) {
|
|
|
|
if (elem.scrollTop <= 0) {
|
|
|
|
scrollY = false;
|
|
|
|
}
|
|
|
|
} else if (elem.scrollTop >= (elem.scrollHeight - elem.clientHeight)) {
|
|
|
|
scrollY = false;
|
|
|
|
}
|
|
|
|
|
|
|
|
return scrollX || scrollY;
|
2011-10-12 14:31:04 -07:00
|
|
|
}
|
2010-12-29 07:40:51 -08:00
|
|
|
};
|
2011-10-26 13:21:51 -07:00
|
|
|
|
2011-10-28 17:10:31 -07:00
|
|
|
const kReferenceDpi = 240; // standard "pixel" size used in some preferences
|
|
|
|
|
|
|
|
const ElementTouchHelper = {
|
2011-11-03 15:09:37 -07:00
|
|
|
anyElementFromPoint: function(aWindow, aX, aY) {
|
|
|
|
let cwu = aWindow.QueryInterface(Ci.nsIInterfaceRequestor).getInterface(Ci.nsIDOMWindowUtils);
|
|
|
|
let elem = cwu.elementFromPoint(aX, aY, false, true);
|
|
|
|
|
|
|
|
while (elem && (elem instanceof HTMLIFrameElement || elem instanceof HTMLFrameElement)) {
|
|
|
|
let rect = elem.getBoundingClientRect();
|
|
|
|
aX -= rect.left;
|
|
|
|
aY -= rect.top;
|
|
|
|
cwu = elem.contentDocument.defaultView.QueryInterface(Ci.nsIInterfaceRequestor).getInterface(Ci.nsIDOMWindowUtils);
|
|
|
|
elem = cwu.elementFromPoint(aX, aY, false, true);
|
|
|
|
}
|
|
|
|
|
|
|
|
return elem;
|
|
|
|
},
|
|
|
|
|
2011-10-28 17:10:31 -07:00
|
|
|
elementFromPoint: function(aWindow, aX, aY) {
|
|
|
|
// browser's elementFromPoint expect browser-relative client coordinates.
|
|
|
|
// subtract browser's scroll values to adjust
|
|
|
|
let cwu = aWindow.QueryInterface(Ci.nsIInterfaceRequestor).getInterface(Ci.nsIDOMWindowUtils);
|
|
|
|
let elem = this.getClosest(cwu, aX, aY);
|
|
|
|
|
|
|
|
// step through layers of IFRAMEs and FRAMES to find innermost element
|
|
|
|
while (elem && (elem instanceof HTMLIFrameElement || elem instanceof HTMLFrameElement)) {
|
|
|
|
// adjust client coordinates' origin to be top left of iframe viewport
|
|
|
|
let rect = elem.getBoundingClientRect();
|
|
|
|
aX -= rect.left;
|
|
|
|
aY -= rect.top;
|
|
|
|
cwu = elem.contentDocument.defaultView.QueryInterface(Ci.nsIInterfaceRequestor).getInterface(Ci.nsIDOMWindowUtils);
|
|
|
|
elem = ElementTouchHelper.getClosest(cwu, aX, aY);
|
|
|
|
}
|
|
|
|
|
|
|
|
return elem;
|
|
|
|
},
|
|
|
|
|
|
|
|
get radius() {
|
|
|
|
let prefs = Services.prefs;
|
|
|
|
delete this.radius;
|
|
|
|
return this.radius = { "top": prefs.getIntPref("browser.ui.touch.top"),
|
|
|
|
"right": prefs.getIntPref("browser.ui.touch.right"),
|
|
|
|
"bottom": prefs.getIntPref("browser.ui.touch.bottom"),
|
|
|
|
"left": prefs.getIntPref("browser.ui.touch.left")
|
|
|
|
};
|
|
|
|
},
|
|
|
|
|
|
|
|
get weight() {
|
|
|
|
delete this.weight;
|
|
|
|
return this.weight = { "visited": Services.prefs.getIntPref("browser.ui.touch.weight.visited") };
|
|
|
|
},
|
|
|
|
|
|
|
|
/* Retrieve the closest element to a point by looking at borders position */
|
|
|
|
getClosest: function getClosest(aWindowUtils, aX, aY) {
|
|
|
|
if (!this.dpiRatio)
|
|
|
|
this.dpiRatio = aWindowUtils.displayDPI / kReferenceDpi;
|
|
|
|
|
|
|
|
let dpiRatio = this.dpiRatio;
|
|
|
|
|
|
|
|
let target = aWindowUtils.elementFromPoint(aX, aY,
|
|
|
|
true, /* ignore root scroll frame*/
|
|
|
|
false); /* don't flush layout */
|
|
|
|
|
|
|
|
// return null if the click is over a clickable element
|
|
|
|
if (this._isElementClickable(target))
|
|
|
|
return null;
|
|
|
|
let target = null;
|
|
|
|
let nodes = aWindowUtils.nodesFromRect(aX, aY, this.radius.top * dpiRatio,
|
|
|
|
this.radius.right * dpiRatio,
|
|
|
|
this.radius.bottom * dpiRatio,
|
|
|
|
this.radius.left * dpiRatio, true, false);
|
|
|
|
|
|
|
|
let threshold = Number.POSITIVE_INFINITY;
|
|
|
|
for (let i = 0; i < nodes.length; i++) {
|
|
|
|
let current = nodes[i];
|
|
|
|
if (!current.mozMatchesSelector || !this._isElementClickable(current))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
let rect = current.getBoundingClientRect();
|
|
|
|
let distance = this._computeDistanceFromRect(aX, aY, rect);
|
|
|
|
|
|
|
|
// increase a little bit the weight for already visited items
|
|
|
|
if (current && current.mozMatchesSelector("*:visited"))
|
|
|
|
distance *= (this.weight.visited / 100);
|
|
|
|
|
|
|
|
if (distance < threshold) {
|
|
|
|
target = current;
|
|
|
|
threshold = distance;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return target;
|
|
|
|
},
|
|
|
|
|
|
|
|
_isElementClickable: function _isElementClickable(aElement) {
|
|
|
|
const selector = "a,:link,:visited,[role=button],button,input,select,textarea,label";
|
|
|
|
for (let elem = aElement; elem; elem = elem.parentNode) {
|
|
|
|
if (this._hasMouseListener(elem))
|
|
|
|
return true;
|
|
|
|
if (elem.mozMatchesSelector && elem.mozMatchesSelector(selector))
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
return false;
|
|
|
|
},
|
|
|
|
|
|
|
|
_computeDistanceFromRect: function _computeDistanceFromRect(aX, aY, aRect) {
|
|
|
|
let x = 0, y = 0;
|
|
|
|
let xmost = aRect.left + aRect.width;
|
|
|
|
let ymost = aRect.top + aRect.height;
|
|
|
|
|
|
|
|
// compute horizontal distance from left/right border depending if X is
|
|
|
|
// before/inside/after the element's rectangle
|
|
|
|
if (aRect.left < aX && aX < xmost)
|
|
|
|
x = Math.min(xmost - aX, aX - aRect.left);
|
|
|
|
else if (aX < aRect.left)
|
|
|
|
x = aRect.left - aX;
|
|
|
|
else if (aX > xmost)
|
|
|
|
x = aX - xmost;
|
|
|
|
|
|
|
|
// compute vertical distance from top/bottom border depending if Y is
|
|
|
|
// above/inside/below the element's rectangle
|
|
|
|
if (aRect.top < aY && aY < ymost)
|
|
|
|
y = Math.min(ymost - aY, aY - aRect.top);
|
|
|
|
else if (aY < aRect.top)
|
|
|
|
y = aRect.top - aY;
|
|
|
|
if (aY > ymost)
|
|
|
|
y = aY - ymost;
|
|
|
|
|
|
|
|
return Math.sqrt(Math.pow(x, 2) + Math.pow(y, 2));
|
|
|
|
},
|
|
|
|
|
|
|
|
_els: Cc["@mozilla.org/eventlistenerservice;1"].getService(Ci.nsIEventListenerService),
|
|
|
|
_clickableEvents: ["mousedown", "mouseup", "click"],
|
|
|
|
_hasMouseListener: function _hasMouseListener(aElement) {
|
|
|
|
let els = this._els;
|
|
|
|
let listeners = els.getListenerInfoFor(aElement, {});
|
|
|
|
for (let i = 0; i < listeners.length; i++) {
|
|
|
|
if (this._clickableEvents.indexOf(listeners[i].type) != -1)
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
return false;
|
|
|
|
},
|
|
|
|
getContentClientRects: function(aElement) {
|
|
|
|
let offset = {x: 0, y: 0};
|
|
|
|
|
|
|
|
let nativeRects = aElement.getClientRects();
|
|
|
|
// step out of iframes and frames, offsetting scroll values
|
|
|
|
for (let frame = aElement.ownerDocument.defaultView; frame != content; frame = frame.parent) {
|
|
|
|
// adjust client coordinates' origin to be top left of iframe viewport
|
|
|
|
let rect = frame.frameElement.getBoundingClientRect();
|
|
|
|
let left = frame.getComputedStyle(frame.frameElement, "").borderLeftWidth;
|
|
|
|
let top = frame.getComputedStyle(frame.frameElement, "").borderTopWidth;
|
|
|
|
offset.x += rect.left + parseInt(left);
|
|
|
|
offset.y += rect.top + parseInt(top);
|
|
|
|
}
|
|
|
|
|
|
|
|
let result = [];
|
|
|
|
for (let i = nativeRects.length - 1; i >= 0; i--) {
|
|
|
|
let r = nativeRects[i];
|
|
|
|
result.push({ left: r.left + offset.x,
|
|
|
|
top: r.top + offset.y,
|
|
|
|
width: r.width,
|
|
|
|
height: r.height
|
|
|
|
});
|
|
|
|
}
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
};
|
2011-10-27 21:55:12 -07:00
|
|
|
|
|
|
|
var ErrorPageEventHandler = {
|
|
|
|
handleEvent: function(aEvent) {
|
|
|
|
switch (aEvent.type) {
|
|
|
|
case "click": {
|
|
|
|
// Don't trust synthetic events
|
|
|
|
if (!aEvent.isTrusted)
|
|
|
|
return;
|
|
|
|
|
|
|
|
let target = aEvent.originalTarget;
|
|
|
|
let errorDoc = target.ownerDocument;
|
|
|
|
|
|
|
|
// If the event came from an ssl error page, it is probably either the "Add
|
|
|
|
// Exception…" or "Get me out of here!" button
|
|
|
|
if (/^about:certerror\?e=nssBadCert/.test(errorDoc.documentURI)) {
|
|
|
|
let perm = errorDoc.getElementById("permanentExceptionButton");
|
|
|
|
let temp = errorDoc.getElementById("temporaryExceptionButton");
|
|
|
|
if (target == temp || target == perm) {
|
|
|
|
// Handle setting an cert exception and reloading the page
|
|
|
|
try {
|
|
|
|
// Add a new SSL exception for this URL
|
|
|
|
let uri = Services.io.newURI(errorDoc.location.href, null, null);
|
|
|
|
let sslExceptions = new SSLExceptions();
|
|
|
|
|
|
|
|
if (target == perm)
|
|
|
|
sslExceptions.addPermanentException(uri);
|
|
|
|
else
|
|
|
|
sslExceptions.addTemporaryException(uri);
|
|
|
|
} catch (e) {
|
|
|
|
dump("Failed to set cert exception: " + e + "\n");
|
|
|
|
}
|
|
|
|
errorDoc.location.reload();
|
|
|
|
} else if (target == errorDoc.getElementById("getMeOutOfHereButton")) {
|
|
|
|
errorDoc.location = this.getFallbackSafeURL();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
},
|
|
|
|
|
|
|
|
getFallbackSafeURL: function getFallbackSafeURL() {
|
|
|
|
// Get the start page from the *default* pref branch, not the user's
|
|
|
|
let prefs = Cc["@mozilla.org/preferences-service;1"].getService(Ci.nsIPrefService).getDefaultBranch(null);
|
|
|
|
let url = "about:home";
|
|
|
|
try {
|
|
|
|
url = prefs.getComplexValue("browser.startup.homepage", Ci.nsIPrefLocalizedString).data;
|
|
|
|
// If url is a pipe-delimited set of pages, just take the first one.
|
|
|
|
if (url.indexOf("|") != -1)
|
|
|
|
url = url.split("|")[0];
|
|
|
|
} catch(e) {
|
|
|
|
Cu.reportError("Couldn't get homepage pref: " + e);
|
|
|
|
}
|
|
|
|
return url;
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2011-10-28 11:49:19 -07:00
|
|
|
|
|
|
|
var FormAssistant = {
|
|
|
|
show: function(aList, aElement) {
|
|
|
|
let data = JSON.parse(sendMessageToJava({ gecko: aList }));
|
|
|
|
let selected = data.button;
|
|
|
|
if (!(selected instanceof Array)) {
|
|
|
|
let temp = [];
|
|
|
|
for (let i = 0; i < aList.listitems.length; i++) {
|
|
|
|
temp[i] = (i == selected);
|
|
|
|
}
|
|
|
|
selected = temp;
|
|
|
|
}
|
|
|
|
this.forOptions(aElement, function(aNode, aIndex) {
|
|
|
|
aNode.selected = selected[aIndex];
|
|
|
|
});
|
2011-11-07 11:43:33 -08:00
|
|
|
this.fireOnChange(aElement);
|
2011-10-28 11:49:19 -07:00
|
|
|
},
|
|
|
|
|
|
|
|
handleClick: function(aEvent) {
|
|
|
|
let target = aEvent.target;
|
|
|
|
while (target) {
|
|
|
|
if (this._isSelectElement(target)) {
|
|
|
|
let list = this.getListForElement(target);
|
|
|
|
this.show(list, target);
|
|
|
|
target = null;
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
if (target)
|
|
|
|
target = target.parentNode;
|
|
|
|
}
|
|
|
|
return false;
|
|
|
|
},
|
|
|
|
|
2011-11-07 11:43:33 -08:00
|
|
|
fireOnChange: function(aElement) {
|
|
|
|
let evt = aElement.ownerDocument.createEvent("Events");
|
|
|
|
evt.initEvent("change", true, true, aElement.defaultView, 0,
|
|
|
|
false, false,
|
|
|
|
false, false, null);
|
|
|
|
setTimeout(function() {
|
|
|
|
aElement.dispatchEvent(evt);
|
|
|
|
}, 0);
|
|
|
|
},
|
|
|
|
|
2011-10-28 11:49:19 -07:00
|
|
|
_isSelectElement: function(aElement) {
|
|
|
|
return (aElement instanceof HTMLSelectElement);
|
|
|
|
},
|
|
|
|
|
|
|
|
_isOptionElement: function(aElement) {
|
|
|
|
return aElement instanceof HTMLOptionElement;
|
|
|
|
},
|
|
|
|
|
|
|
|
_isOptionGroupElement: function(aElement) {
|
|
|
|
return aElement instanceof HTMLOptGroupElement;
|
|
|
|
},
|
|
|
|
|
|
|
|
getListForElement: function(aElement) {
|
|
|
|
let result = {
|
|
|
|
type: "Prompt:Show",
|
|
|
|
multiple: aElement.multiple,
|
|
|
|
selected: [],
|
|
|
|
listitems: []
|
|
|
|
};
|
|
|
|
|
|
|
|
if (aElement.multiple) {
|
|
|
|
result.buttons = [
|
|
|
|
{ label: Strings.browser.GetStringFromName("selectHelper.closeMultipleSelectDialog") },
|
|
|
|
];
|
|
|
|
}
|
|
|
|
|
|
|
|
this.forOptions(aElement, function(aNode, aIndex) {
|
|
|
|
result.listitems[aIndex] = {
|
|
|
|
label: aNode.text || aNode.label,
|
|
|
|
isGroup: this._isOptionGroupElement(aNode),
|
|
|
|
inGroup: this._isOptionGroupElement(aNode.parentNode),
|
|
|
|
disabled: aNode.disabled,
|
|
|
|
id: aIndex
|
|
|
|
}
|
|
|
|
result.selected[aIndex] = aNode.selected;
|
|
|
|
});
|
|
|
|
return result;
|
|
|
|
},
|
|
|
|
|
|
|
|
forOptions: function(aElement, aFunction) {
|
|
|
|
let optionIndex = 0;
|
|
|
|
let children = aElement.children;
|
2011-11-03 15:19:58 -07:00
|
|
|
// if there are no children in this select, we add a dummy row so that at least something appears
|
|
|
|
if (children.length == 0)
|
|
|
|
aFunction.call(this, {label:""}, optionIndex);
|
2011-10-28 11:49:19 -07:00
|
|
|
for (let i = 0; i < children.length; i++) {
|
|
|
|
let child = children[i];
|
|
|
|
if (this._isOptionGroupElement(child)) {
|
|
|
|
aFunction.call(this, child, optionIndex);
|
|
|
|
optionIndex++;
|
|
|
|
|
|
|
|
let subchildren = child.children;
|
|
|
|
for (let j = 0; j < subchildren.length; j++) {
|
|
|
|
let subchild = subchildren[j];
|
|
|
|
aFunction.call(this, subchild, optionIndex);
|
|
|
|
optionIndex++;
|
|
|
|
}
|
|
|
|
|
|
|
|
} else if (this._isOptionElement(child)) {
|
|
|
|
// This is a regular choice under no group.
|
|
|
|
aFunction.call(this, child, optionIndex);
|
|
|
|
optionIndex++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-10-26 13:21:51 -07:00
|
|
|
var XPInstallObserver = {
|
|
|
|
observe: function xpi_observer(aSubject, aTopic, aData) {
|
|
|
|
switch (aTopic) {
|
|
|
|
case "addon-install-started":
|
|
|
|
NativeWindow.toast.show(Strings.browser.GetStringFromName("alertAddonsDownloading"), "short");
|
|
|
|
break;
|
|
|
|
case "addon-install-blocked":
|
|
|
|
dump("XPInstallObserver addon-install-blocked");
|
|
|
|
let installInfo = aSubject.QueryInterface(Ci.amIWebInstallInfo);
|
|
|
|
let host = installInfo.originatingURI.host;
|
|
|
|
|
|
|
|
let brandShortName = Strings.brand.GetStringFromName("brandShortName");
|
|
|
|
let notificationName, buttons, messageString;
|
|
|
|
let strings = Strings.browser;
|
|
|
|
let enabled = true;
|
|
|
|
try {
|
|
|
|
enabled = Services.prefs.getBoolPref("xpinstall.enabled");
|
|
|
|
}
|
|
|
|
catch (e) {}
|
|
|
|
|
|
|
|
if (!enabled) {
|
|
|
|
notificationName = "xpinstall-disabled";
|
|
|
|
if (Services.prefs.prefIsLocked("xpinstall.enabled")) {
|
|
|
|
messageString = strings.GetStringFromName("xpinstallDisabledMessageLocked");
|
|
|
|
buttons = [];
|
|
|
|
} else {
|
|
|
|
messageString = strings.formatStringFromName("xpinstallDisabledMessage2", [brandShortName, host], 2);
|
|
|
|
buttons = [{
|
|
|
|
label: strings.GetStringFromName("xpinstallDisabledButton"),
|
|
|
|
callback: function editPrefs() {
|
|
|
|
Services.prefs.setBoolPref("xpinstall.enabled", true);
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
}];
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
notificationName = "xpinstall";
|
|
|
|
messageString = strings.formatStringFromName("xpinstallPromptWarning2", [brandShortName, host], 2);
|
|
|
|
|
|
|
|
buttons = [{
|
|
|
|
label: strings.GetStringFromName("xpinstallPromptAllowButton"),
|
|
|
|
callback: function() {
|
|
|
|
// Kick off the install
|
|
|
|
installInfo.install();
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
}];
|
|
|
|
}
|
2011-11-01 13:26:11 -07:00
|
|
|
NativeWindow.doorhanger.show(messageString, aTopic, buttons);
|
2011-10-26 13:21:51 -07:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
};
|
2011-11-03 23:54:47 -07:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Handler for blocked popups, triggered by DOMUpdatePageReport events in browser.xml
|
|
|
|
*/
|
|
|
|
var PopupBlockerObserver = {
|
|
|
|
onUpdatePageReport: function onUpdatePageReport(aEvent) {
|
|
|
|
let browser = BrowserApp.selectedBrowser;
|
|
|
|
if (aEvent.originalTarget != browser)
|
|
|
|
return;
|
|
|
|
|
|
|
|
if (!browser.pageReport)
|
|
|
|
return;
|
|
|
|
|
|
|
|
let result = Services.perms.testExactPermission(BrowserApp.selectedBrowser.currentURI, "popup");
|
|
|
|
if (result == Ci.nsIPermissionManager.DENY_ACTION)
|
|
|
|
return;
|
|
|
|
|
|
|
|
// Only show the notification again if we've not already shown it. Since
|
|
|
|
// notifications are per-browser, we don't need to worry about re-adding
|
|
|
|
// it.
|
|
|
|
if (!browser.pageReport.reported) {
|
|
|
|
if (Services.prefs.getBoolPref("privacy.popups.showBrowserMessage")) {
|
|
|
|
let brandShortName = Strings.brand.GetStringFromName("brandShortName");
|
|
|
|
let message;
|
|
|
|
let popupCount = browser.pageReport.length;
|
|
|
|
|
|
|
|
let strings = Strings.browser;
|
|
|
|
if (popupCount > 1)
|
|
|
|
message = strings.formatStringFromName("popupWarningMultiple", [brandShortName, popupCount], 2);
|
|
|
|
else
|
|
|
|
message = strings.formatStringFromName("popupWarning", [brandShortName], 1);
|
|
|
|
|
|
|
|
let buttons = [
|
|
|
|
{
|
|
|
|
label: strings.GetStringFromName("popupButtonAllowOnce"),
|
|
|
|
callback: function() { PopupBlockerObserver.showPopupsForSite(); }
|
|
|
|
},
|
|
|
|
{
|
|
|
|
label: strings.GetStringFromName("popupButtonAlwaysAllow2"),
|
|
|
|
callback: function() { PopupBlockerObserver.allowPopupsForSite(true); }
|
|
|
|
},
|
|
|
|
{
|
|
|
|
label: strings.GetStringFromName("popupButtonNeverWarn2"),
|
|
|
|
callback: function() { PopupBlockerObserver.allowPopupsForSite(false); }
|
|
|
|
}
|
|
|
|
];
|
|
|
|
|
|
|
|
NativeWindow.doorhanger.show(message, "popup-blocked", buttons);
|
|
|
|
}
|
|
|
|
// Record the fact that we've reported this blocked popup, so we don't
|
|
|
|
// show it again.
|
|
|
|
browser.pageReport.reported = true;
|
|
|
|
}
|
|
|
|
},
|
|
|
|
|
|
|
|
allowPopupsForSite: function allowPopupsForSite(aAllow) {
|
|
|
|
let currentURI = BrowserApp.selectedBrowser.currentURI;
|
|
|
|
Services.perms.add(currentURI, "popup", aAllow
|
|
|
|
? Ci.nsIPermissionManager.ALLOW_ACTION
|
|
|
|
: Ci.nsIPermissionManager.DENY_ACTION);
|
|
|
|
dump("Allowing popups for: " + currentURI);
|
|
|
|
},
|
|
|
|
|
|
|
|
showPopupsForSite: function showPopupsForSite() {
|
|
|
|
let uri = BrowserApp.selectedBrowser.currentURI;
|
|
|
|
let pageReport = BrowserApp.selectedBrowser.pageReport;
|
|
|
|
if (pageReport) {
|
|
|
|
for (let i = 0; i < pageReport.length; ++i) {
|
|
|
|
var popupURIspec = pageReport[i].popupWindowURI.spec;
|
|
|
|
|
|
|
|
// Sometimes the popup URI that we get back from the pageReport
|
|
|
|
// isn't useful (for instance, netscape.com's popup URI ends up
|
|
|
|
// being "http://www.netscape.com", which isn't really the URI of
|
|
|
|
// the popup they're trying to show). This isn't going to be
|
|
|
|
// useful to the user, so we won't create a menu item for it.
|
|
|
|
if (popupURIspec == "" || popupURIspec == "about:blank" || popupURIspec == uri.spec)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
let popupFeatures = pageReport[i].popupWindowFeatures;
|
|
|
|
let popupName = pageReport[i].popupWindowName;
|
|
|
|
|
|
|
|
BrowserApp.addTab(popupURIspec);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
};
|
2011-11-11 08:02:10 -08:00
|
|
|
|
|
|
|
|
|
|
|
var OfflineApps = {
|
|
|
|
init: function() {
|
|
|
|
BrowserApp.deck.addEventListener("MozApplicationManifest", this, false);
|
|
|
|
},
|
|
|
|
|
|
|
|
uninit: function() {
|
|
|
|
BrowserApp.deck.removeEventListener("MozApplicationManifest", this, false);
|
|
|
|
},
|
|
|
|
|
|
|
|
handleEvent: function(aEvent) {
|
|
|
|
if (aEvent.type == "MozApplicationManifest")
|
|
|
|
this.offlineAppRequested(aEvent.originalTarget.defaultView);
|
|
|
|
},
|
|
|
|
|
|
|
|
offlineAppRequested: function(aContentWindow) {
|
|
|
|
if (!Services.prefs.getBoolPref("browser.offline-apps.notify"))
|
|
|
|
return;
|
|
|
|
|
|
|
|
let browser = BrowserApp.getBrowserForWindow(aContentWindow);
|
|
|
|
let tab = BrowserApp.getTabForBrowser(browser);
|
|
|
|
let currentURI = aContentWindow.document.documentURIObject;
|
|
|
|
|
|
|
|
// Don't bother showing UI if the user has already made a decision
|
|
|
|
if (Services.perms.testExactPermission(currentURI, "offline-app") != Services.perms.UNKNOWN_ACTION)
|
|
|
|
return;
|
|
|
|
|
|
|
|
try {
|
|
|
|
if (Services.prefs.getBoolPref("offline-apps.allow_by_default")) {
|
|
|
|
// All pages can use offline capabilities, no need to ask the user
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
} catch(e) {
|
|
|
|
// This pref isn't set by default, ignore failures
|
|
|
|
}
|
|
|
|
|
|
|
|
let host = currentURI.asciiHost;
|
|
|
|
let notificationID = "offline-app-requested-" + host;
|
|
|
|
|
|
|
|
let strings = Strings.browser;
|
|
|
|
let buttons = [{
|
|
|
|
label: strings.GetStringFromName("offlineApps.allow"),
|
|
|
|
callback: function() {
|
|
|
|
OfflineApps.allowSite(aContentWindow.document);
|
|
|
|
}
|
|
|
|
},
|
|
|
|
{
|
|
|
|
label: strings.GetStringFromName("offlineApps.never"),
|
|
|
|
callback: function() {
|
|
|
|
OfflineApps.disallowSite(aContentWindow.document);
|
|
|
|
}
|
|
|
|
},
|
|
|
|
{
|
|
|
|
label: strings.GetStringFromName("offlineApps.notNow"),
|
|
|
|
callback: function() { /* noop */ }
|
|
|
|
}];
|
|
|
|
|
|
|
|
let message = strings.formatStringFromName("offlineApps.available2", [host], 1);
|
|
|
|
NativeWindow.doorhanger.show(message, notificationID, buttons, tab.id);
|
|
|
|
},
|
|
|
|
|
|
|
|
allowSite: function(aDocument) {
|
|
|
|
Services.perms.add(aDocument.documentURIObject, "offline-app", Services.perms.ALLOW_ACTION);
|
|
|
|
|
|
|
|
// When a site is enabled while loading, manifest resources will
|
|
|
|
// start fetching immediately. This one time we need to do it
|
|
|
|
// ourselves.
|
|
|
|
this._startFetching(aDocument);
|
|
|
|
},
|
|
|
|
|
|
|
|
disallowSite: function(aDocument) {
|
|
|
|
Services.perms.add(aDocument.documentURIObject, "offline-app", Services.perms.DENY_ACTION);
|
|
|
|
},
|
|
|
|
|
|
|
|
_startFetching: function(aDocument) {
|
|
|
|
if (!aDocument.documentElement)
|
|
|
|
return;
|
|
|
|
|
|
|
|
let manifest = aDocument.documentElement.getAttribute("manifest");
|
|
|
|
if (!manifest)
|
|
|
|
return;
|
|
|
|
|
|
|
|
let manifestURI = Services.io.newURI(manifest, aDocument.characterSet, aDocument.documentURIObject);
|
|
|
|
let updateService = Cc["@mozilla.org/offlinecacheupdate-service;1"].getService(Ci.nsIOfflineCacheUpdateService);
|
|
|
|
updateService.scheduleUpdate(manifestURI, aDocument.documentURIObject, window);
|
|
|
|
}
|
|
|
|
};
|
2011-11-15 14:45:10 -08:00
|
|
|
|
|
|
|
var IndexedDB = {
|
|
|
|
_permissionsPrompt: "indexedDB-permissions-prompt",
|
|
|
|
_permissionsResponse: "indexedDB-permissions-response",
|
|
|
|
|
|
|
|
_quotaPrompt: "indexedDB-quota-prompt",
|
|
|
|
_quotaResponse: "indexedDB-quota-response",
|
|
|
|
_quotaCancel: "indexedDB-quota-cancel",
|
|
|
|
|
|
|
|
init: function IndexedDB_init() {
|
|
|
|
Services.obs.addObserver(this, this._permissionsPrompt, false);
|
|
|
|
Services.obs.addObserver(this, this._quotaPrompt, false);
|
|
|
|
Services.obs.addObserver(this, this._quotaCancel, false);
|
|
|
|
},
|
|
|
|
|
|
|
|
uninit: function IndexedDB_uninit() {
|
|
|
|
Services.obs.removeObserver(this, this._permissionsPrompt, false);
|
|
|
|
Services.obs.removeObserver(this, this._quotaPrompt, false);
|
|
|
|
Services.obs.removeObserver(this, this._quotaCancel, false);
|
|
|
|
},
|
|
|
|
|
|
|
|
observe: function IndexedDB_observe(subject, topic, data) {
|
|
|
|
if (topic != this._permissionsPrompt &&
|
|
|
|
topic != this._quotaPrompt &&
|
|
|
|
topic != this._quotaCancel) {
|
|
|
|
throw new Error("Unexpected topic!");
|
|
|
|
}
|
|
|
|
|
|
|
|
let requestor = subject.QueryInterface(Ci.nsIInterfaceRequestor);
|
|
|
|
|
|
|
|
let contentWindow = requestor.getInterface(Ci.nsIDOMWindow);
|
|
|
|
let contentDocument = contentWindow.document;
|
|
|
|
let browser = BrowserApp.getBrowserForWindow(contentWindow);
|
|
|
|
if (!browser)
|
|
|
|
return;
|
|
|
|
|
|
|
|
let host = contentDocument.documentURIObject.asciiHost;
|
|
|
|
|
|
|
|
let strings = Strings.browser;
|
|
|
|
|
|
|
|
let message, responseTopic;
|
|
|
|
if (topic == this._permissionsPrompt) {
|
|
|
|
message = strings.formatStringFromName("offlineApps.available2", [host], 1);
|
|
|
|
responseTopic = this._permissionsResponse;
|
|
|
|
} else if (topic == this._quotaPrompt) {
|
|
|
|
message = strings.formatStringFromName("indexedDBQuota.wantsTo", [ host, data ], 2);
|
|
|
|
responseTopic = this._quotaResponse;
|
|
|
|
} else if (topic == this._quotaCancel) {
|
|
|
|
responseTopic = this._quotaResponse;
|
|
|
|
}
|
|
|
|
|
|
|
|
let notificationID = responseTopic + host;
|
2011-11-15 14:45:54 -08:00
|
|
|
let tab = BrowserApp.getTabForBrowser(browser);
|
2011-11-15 14:45:10 -08:00
|
|
|
let observer = requestor.getInterface(Ci.nsIObserver);
|
2011-11-15 14:45:54 -08:00
|
|
|
|
|
|
|
if (topic == this._quotaCancel) {
|
|
|
|
NativeWindow.doorhanger.hide(notificationID, tab.id);
|
|
|
|
observer.observe(null, responseTopic, Ci.nsIPermissionManager.UNKNOWN_ACTION);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2011-11-15 14:45:10 -08:00
|
|
|
let buttons = [{
|
|
|
|
label: strings.GetStringFromName("offlineApps.allow"),
|
|
|
|
callback: function() {
|
|
|
|
observer.observe(null, responseTopic, Ci.nsIPermissionManager.ALLOW_ACTION);
|
|
|
|
}
|
|
|
|
},
|
|
|
|
{
|
|
|
|
label: strings.GetStringFromName("offlineApps.never"),
|
|
|
|
callback: function() {
|
|
|
|
observer.observe(null, responseTopic, Ci.nsIPermissionManager.DENY_ACTION);
|
|
|
|
}
|
|
|
|
},
|
|
|
|
{
|
|
|
|
label: strings.GetStringFromName("offlineApps.notNow"),
|
|
|
|
callback: function() {
|
|
|
|
observer.observe(null, responseTopic, Ci.nsIPermissionManager.UNKNOWN_ACTION);
|
|
|
|
}
|
|
|
|
}];
|
|
|
|
|
|
|
|
NativeWindow.doorhanger.show(message, notificationID, buttons, tab.id);
|
|
|
|
}
|
|
|
|
};
|