gecko/mobile/chrome/content/Util.js

242 lines
7.6 KiB
JavaScript

// -*- 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) 2009
* the Initial Developer. All Rights Reserved.
*
* Contributor(s):
* Roy Frostig <rfrostig@mozilla.com>
* Ben Combee <bcombee@mozilla.com>
* Matt Brubeck <mbrubeck@mozilla.com>
*
* Alternatively, the contents of this file may be used under the terms of
* either the GNU General Public License Version 2 or later (the "GPL"), or
* the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
* in which case the provisions of the GPL or the LGPL are applicable instead
* of those above. If you wish to allow use of your version of this file only
* under the terms of either the GPL or the LGPL, and not to allow others to
* use your version of this file under the terms of the 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 ***** */
// -----------------------------------------------------------
// General util/convenience tools
//
let Util = {
/** printf-like dump function */
dumpf: function dumpf(str) {
let args = arguments;
let i = 1;
dump(str.replace(/%s/g, function() {
if (i >= args.length) {
throw "dumps received too many placeholders and not enough arguments";
}
return args[i++].toString();
}));
},
/** Like dump, but each arg is handled and there's an automatic newline */
dumpLn: function dumpLn() {
for (let i = 0; i < arguments.length; i++)
dump(arguments[i] + " ");
dump("\n");
},
getWindowUtils: function getWindowUtils(aWindow) {
return aWindow.QueryInterface(Ci.nsIInterfaceRequestor).getInterface(Ci.nsIDOMWindowUtils);
},
/** Executes aFunc after other events have been processed. */
executeSoon: function executeSoon(aFunc) {
Services.tm.mainThread.dispatch({
run: function() {
aFunc();
}
}, Ci.nsIThread.DISPATCH_NORMAL);
},
getHrefForElement: function getHrefForElement(target) {
// XXX: This is kind of a hack to work around a Gecko bug (see bug 266932)
// We're going to walk up the DOM looking for a parent link node.
// This shouldn't be necessary, but we're matching the existing behaviour for left click
let link = null;
while (target) {
if (target instanceof Ci.nsIDOMHTMLAnchorElement ||
target instanceof Ci.nsIDOMHTMLAreaElement ||
target instanceof Ci.nsIDOMHTMLLinkElement) {
if (target.hasAttribute("href"))
link = target;
}
target = target.parentNode;
}
if (link && link.hasAttribute("href"))
return link.href;
else
return null;
},
makeURI: function makeURI(aURL, aOriginCharset, aBaseURI) {
return Services.io.newURI(aURL, aOriginCharset, aBaseURI);
},
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;
},
isLocalScheme: function isLocalScheme(aURL) {
return (aURL.indexOf("about:") == 0 && aURL != "about:blank" && aURL != "about:empty") || aURL.indexOf("chrome:") == 0;
},
isOpenableScheme: function isShareableScheme(aProtocol) {
let dontOpen = /^(mailto|javascript|news|snews)$/;
return (aProtocol && !dontOpen.test(aProtocol));
},
isShareableScheme: function isShareableScheme(aProtocol) {
let dontShare = /^(chrome|about|file|javascript|resource)$/;
return (aProtocol && !dontShare.test(aProtocol));
},
clamp: function(num, min, max) {
return Math.max(min, Math.min(max, num));
},
/** Don't display anything in the urlbar for these special URIs. */
isURLEmpty: function isURLEmpty(aURL) {
return (!aURL || aURL == "about:blank" || aURL == "about:empty" || aURL == "about:home");
},
/** Recursively find all documents, including root document. */
getAllDocuments: function getAllDocuments(doc, resultSoFar) {
resultSoFar = resultSoFar || [doc];
if (!doc.defaultView)
return resultSoFar;
let frames = doc.defaultView.frames;
if (!frames)
return resultSoFar;
let i;
let currentDoc;
for (i = 0; i < frames.length; i++) {
currentDoc = frames[i].document;
resultSoFar.push(currentDoc);
this.getAllDocuments(currentDoc, resultSoFar);
}
return resultSoFar;
},
// Put the Mozilla networking code into a state that will kick the auto-connection
// process.
forceOnline: function forceOnline() {
Services.io.offline = false;
},
isParentProcess: function isInParentProcess() {
let appInfo = Cc["@mozilla.org/xre/app-info;1"];
return (!appInfo || appInfo.getService(Ci.nsIXULRuntime).processType == Ci.nsIXULRuntime.PROCESS_TYPE_DEFAULT);
},
isPortrait: function isPortrait() {
#ifdef MOZ_PLATFORM_MAEMO
return (screen.width <= screen.height);
#elifdef ANDROID
return (screen.width <= screen.height);
#else
return (window.innerWidth <= window.innerHeight);
#endif
}
};
/**
* Helper class to nsITimer that adds a little more pizazz. Callback can be an
* object with a notify method or a function.
*/
Util.Timeout = function(aCallback) {
this._callback = aCallback;
this._timer = Cc["@mozilla.org/timer;1"].createInstance(Ci.nsITimer);
this._type = null;
};
Util.Timeout.prototype = {
/** Timer callback. Don't call this manually. */
notify: function notify() {
if (this._type == this._timer.TYPE_ONE_SHOT)
this._type = null;
if (this._callback.notify)
this._callback.notify();
else
this._callback.apply(null);
},
/** Helper function for once and interval. */
_start: function _start(aDelay, aType, aCallback) {
if (aCallback)
this._callback = aCallback;
this.clear();
this._timer.initWithCallback(this, aDelay, aType);
this._type = aType;
return this;
},
/** Do the callback once. Cancels other timeouts on this object. */
once: function once(aDelay, aCallback) {
return this._start(aDelay, this._timer.TYPE_ONE_SHOT, aCallback);
},
/** Do the callback every aDelay msecs. Cancels other timeouts on this object. */
interval: function interval(aDelay, aCallback) {
return this._start(aDelay, this._timer.TYPE_REPEATING_SLACK, aCallback);
},
/** Clear any pending timeouts. */
clear: function clear() {
if (this.isPending()) {
this._timer.cancel();
this._type = null;
}
return this;
},
/** If there is a pending timeout, call it and cancel the timeout. */
flush: function flush() {
if (this.isPending()) {
this.notify();
this.clear();
}
return this;
},
/** Return true iff we are waiting for a callback. */
isPending: function isPending() {
return this._type !== null;
}
};