agriget/lib/dojo/_base/configFirefoxExtension.js
2019-03-22 10:17:29 -04:00

337 lines
11 KiB
JavaScript

// TODO: this file needs to be converted to the v1.7 loader
// a host environment specifically built for Mozilla extensions, but derived
// from the browser host environment
if(typeof window != 'undefined'){
dojo.isBrowser = true;
dojo._name = "browser";
// FIXME: PORTME
// http://developer.mozilla.org/en/mozIJSSubScriptLoader
// attempt to figure out the path to dojo if it isn't set in the config
(function(){
// this is a scope protection closure. We set browser versions and grab
// the URL we were loaded from here.
// FIXME: need to probably use a different reference to "document" to get the hosting XUL environment
dojo.baseUrl = dojo.config.baseUrl;
// fill in the rendering support information in dojo.render.*
var n = navigator;
var dua = n.userAgent;
var dav = n.appVersion;
var tv = parseFloat(dav);
dojo.isMozilla = dojo.isMoz = tv;
if(dojo.isMoz){
dojo.isFF = parseFloat(dua.split("Firefox/")[1]) || undefined;
}
// FIXME
dojo.isQuirks = document.compatMode == "BackCompat";
// FIXME
// TODO: is the HTML LANG attribute relevant?
dojo.locale = dojo.config.locale || n.language.toLowerCase();
dojo._xhrObj = function(){
return new XMLHttpRequest();
};
// monkey-patch _loadUri to handle file://, chrome://, and resource:// url's
var oldLoadUri = dojo._loadUri;
dojo._loadUri = function(uri, cb){
var handleLocal = ["file:", "chrome:", "resource:"].some(function(prefix){
return String(uri).indexOf(prefix) == 0;
});
if(handleLocal){
// see:
// http://developer.mozilla.org/en/mozIJSSubScriptLoader
var l = Components.classes["@mozilla.org/moz/jssubscript-loader;1"]
.getService(Components.interfaces.mozIJSSubScriptLoader);
var value = l.loadSubScript(uri, dojo.global);
if(cb){ cb(value); }
return true;
}else{
// otherwise, call the pre-existing version
return oldLoadUri.apply(dojo, arguments);
}
};
// FIXME: PORTME
dojo._isDocumentOk = function(http){
var stat = http.status || 0;
return (stat >= 200 && stat < 300) || // Boolean
stat == 304 || // allow any 2XX response code
stat == 1223 || // get it out of the cache
(!stat && (location.protocol == "file:" || location.protocol == "chrome:") );
};
// FIXME: PORTME
// var owloc = window.location+"";
// var base = document.getElementsByTagName("base");
// var hasBase = (base && base.length > 0);
var hasBase = false;
dojo._getText = function(/*URI*/ uri, /*Boolean*/ fail_ok){
// summary:
// Read the contents of the specified uri and return those contents.
// uri:
// A relative or absolute uri. If absolute, it still must be in
// the same "domain" as we are.
// fail_ok:
// Default false. If fail_ok and loading fails, return null
// instead of throwing.
// returns:
// The response text. null is returned when there is a
// failure and failure is okay (an exception otherwise)
// alert("_getText: " + uri);
// NOTE: must be declared before scope switches ie. this._xhrObj()
var http = dojo._xhrObj();
if(!hasBase && dojo._Url){
uri = (new dojo._Url(uri)).toString();
}
if(dojo.config.cacheBust){
//Make sure we have a string before string methods are used on uri
uri += "";
uri += (uri.indexOf("?") == -1 ? "?" : "&") + String(dojo.config.cacheBust).replace(/\W+/g, "");
}
var handleLocal = ["file:", "chrome:", "resource:"].some(function(prefix){
return String(uri).indexOf(prefix) == 0;
});
if(handleLocal){
// see:
// http://forums.mozillazine.org/viewtopic.php?p=921150#921150
var ioService = Components.classes["@mozilla.org/network/io-service;1"]
.getService(Components.interfaces.nsIIOService);
var scriptableStream = Components
.classes["@mozilla.org/scriptableinputstream;1"]
.getService(Components.interfaces.nsIScriptableInputStream);
var channel = ioService.newChannel(uri, null, null);
var input = channel.open();
scriptableStream.init(input);
var str = scriptableStream.read(input.available());
scriptableStream.close();
input.close();
return str;
}else{
http.open('GET', uri, false);
try{
http.send(null);
// alert(http);
if(!dojo._isDocumentOk(http)){
var err = Error("Unable to load " + uri + " status:" + http.status);
err.status = http.status;
err.responseText = http.responseText;
throw err;
}
}catch(e){
if(fail_ok){
return null;
} // null
// rethrow the exception
throw e;
}
return http.responseText; // String
}
};
dojo._windowUnloaders = [];
// FIXME: PORTME
dojo.windowUnloaded = function(){
// summary:
// signal fired by impending window destruction. You may use
// dojo.addOnWIndowUnload() or dojo.connect() to this method to perform
// page/application cleanup methods. See dojo.addOnWindowUnload for more info.
var mll = dojo._windowUnloaders;
while(mll.length){
(mll.pop())();
}
};
// FIXME: PORTME
dojo.addOnWindowUnload = function(/*Object?*/obj, /*String|Function?*/functionName){
// summary:
// registers a function to be triggered when window.onunload fires.
// Be careful trying to modify the DOM or access JavaScript properties
// during this phase of page unloading: they may not always be available.
// Consider dojo.addOnUnload() if you need to modify the DOM or do heavy
// JavaScript work.
// example:
// | dojo.addOnWindowUnload(functionPointer)
// | dojo.addOnWindowUnload(object, "functionName")
// | dojo.addOnWindowUnload(object, function(){ /* ... */});
dojo._onto(dojo._windowUnloaders, obj, functionName);
};
// XUL specific APIs
var contexts = [];
var current = null;
dojo._defaultContext = [ window, document ];
dojo.pushContext = function(/*Object|String?*/g, /*MDocumentElement?*/d){
// summary:
// causes subsequent calls to Dojo methods to assume the
// passed object and, optionally, document as the default
// scopes to use. A 2-element array of the previous global and
// document are returned.
// description:
// dojo.pushContext treats contexts as a stack. The
// auto-detected contexts which are initially provided using
// dojo.setContext() require authors to keep state in order to
// "return" to a previous context, whereas the
// dojo.pushContext and dojo.popContext methods provide a more
// natural way to augment blocks of code to ensure that they
// execute in a different window or frame without issue. If
// called without any arguments, the default context (the
// context when Dojo is first loaded) is instead pushed into
// the stack. If only a single string is passed, a node in the
// intitial context's document is looked up and its
// contextWindow and contextDocument properties are used as
// the context to push. This means that iframes can be given
// an ID and code can be executed in the scope of the iframe's
// document in subsequent calls easily.
// g:
// The global context. If a string, the id of the frame to
// search for a context and document.
// d:
// The document element to execute subsequent code with.
var old = [dojo.global, dojo.doc];
contexts.push(old);
var n;
if(!g && !d){
n = dojo._defaultContext;
}else{
n = [ g, d ];
if(!d && dojo.isString(g)){
var t = document.getElementById(g);
if(t.contentDocument){
n = [t.contentWindow, t.contentDocument];
}
}
}
current = n;
dojo.setContext.apply(dojo, n);
return old; // Array
};
dojo.popContext = function(){
// summary:
// If the context stack contains elements, ensure that
// subsequent code executes in the *previous* context to the
// current context. The current context set ([global,
// document]) is returned.
var oc = current;
if(!contexts.length){
return oc;
}
dojo.setContext.apply(dojo, contexts.pop());
return oc;
};
// FIXME:
// don't really like the current arguments and order to
// _inContext, so don't make it public until it's right!
dojo._inContext = function(g, d, f){
var a = dojo._toArray(arguments);
f = a.pop();
if(a.length == 1){
d = null;
}
dojo.pushContext(g, d);
var r = f();
dojo.popContext();
return r;
};
})();
dojo._initFired = false;
// BEGIN DOMContentLoaded, from Dean Edwards (http://dean.edwards.name/weblog/2006/06/again/)
dojo._loadInit = function(e){
dojo._initFired = true;
// allow multiple calls, only first one will take effect
// A bug in khtml calls events callbacks for document for event which isnt supported
// for example a created contextmenu event calls DOMContentLoaded, workaround
var type = (e && e.type) ? e.type.toLowerCase() : "load";
if(arguments.callee.initialized || (type != "domcontentloaded" && type != "load")){ return; }
arguments.callee.initialized = true;
if(dojo._inFlightCount == 0){
dojo._modulesLoaded();
}
};
/*
(function(){
var _w = window;
var _handleNodeEvent = function(evtName, fp){
// summary:
// non-destructively adds the specified function to the node's
// evtName handler.
// evtName: should be in the form "onclick" for "onclick" handlers.
// Make sure you pass in the "on" part.
var oldHandler = _w[evtName] || function(){};
_w[evtName] = function(){
fp.apply(_w, arguments);
oldHandler.apply(_w, arguments);
};
};
// FIXME: PORT
// FIXME: dojo.unloaded requires dojo scope, so using anon function wrapper.
_handleNodeEvent("onbeforeunload", function(){ dojo.unloaded(); });
_handleNodeEvent("onunload", function(){ dojo.windowUnloaded(); });
})();
*/
// FIXME: PORTME
// this event fires a lot, namely for all plugin XUL overlays and for
// all iframes (in addition to window navigations). We only want
// Dojo's to fire once..but we might care if pages navigate. We'll
// probably need an extension-specific API
if(!dojo.config.afterOnLoad){
window.addEventListener("DOMContentLoaded", function(e){
dojo._loadInit(e);
// console.log("DOM content loaded", e);
}, false);
}
} //if (typeof window != 'undefined')
//Register any module paths set up in djConfig. Need to do this
//in the hostenvs since hostenv_browser can read djConfig from a
//script tag's attribute.
(function(){
var mp = dojo.config["modulePaths"];
if(mp){
for(var param in mp){
dojo.registerModulePath(param, mp[param]);
}
}
})();
//Load debug code if necessary.
if(dojo.config.isDebug){
// logging stub for extension logging
console.log = function(m){
var s = Components.classes["@mozilla.org/consoleservice;1"].getService(
Components.interfaces.nsIConsoleService
);
s.logStringMessage(m);
};
console.debug = function(){
console.log(dojo._toArray(arguments).join(" "));
};
// FIXME: what about the rest of the console.* methods? And is there any way to reach into firebug and log into it directly?
}