Subversion Repositories Applications.papyrus

/*
        Copyright (c) 2004-2006, The Dojo Foundation
        All Rights Reserved.

        Licensed under the Academic Free License version 2.1 or above OR the
        modified BSD license. For more information on Dojo licensing, see:

                http://dojotoolkit.org/community/licensing.shtml
*/



dojo.provide("dojo.widget.html.loader");
dojo.require("dojo.widget.HtmlWidget");
dojo.require("dojo.io.*");
dojo.require("dojo.lang.common");
dojo.require("dojo.lang.extras");
dojo.require("dojo.experimental");
dojo.experimental("dojo.widget.html.loader");
dojo.widget.html.loader = new (function () {
        this.toString = function () {
                return "dojo.widget.html.loader";
        };
        var _loader = this;
        dojo.addOnLoad(function () {
                dojo.experimental(_loader.toString());
                var undo = dojo.evalObjPath("dojo.undo.browser");
                if (djConfig["preventBackButtonFix"] && undo && !undo.initialState) {
                        undo.setInitialState(new trackerObj);
                }
        });
        var logger = {};
        var trackerObj = function (id, data) {
                this.id = id;
                this.data = data;
        };
        trackerObj.prototype.handle = function (type) {
                if (typeof dojo == "undefined") {
                        return;
                }
                var wg = dojo.widget.byId(this.id);
                if (wg) {
                        wg.setContent(this.data, true);
                }
        };
        this._log = function (widget, data) {
                if (widget.trackHistory) {
                        if (!logger[widget.widgetId]) {
                                logger[widget.widgetId] = {childrenIds:[], stack:[data]};
                        }
                        var children = logger[widget.widgetId].childrenIds;
                        while (children && children.length) {
                                delete logger[children.pop()];
                        }
                        for (var child in widget.children) {
                                logger[widget.widgetId].childrenIds = child.widgetId;
                        }
                        dojo.undo.browser.addToHistory(new trackerObj(widget.widgetId, dojo.lang.shallowCopy(data, true)));
                }
        };
        var undef = dojo.lang.isUndefined;
        var isFunc = dojo.lang.isFunction;
        function handleDefaults(e, handler, useAlert) {
                if (!handler) {
                        handler = "onContentError";
                }
                if (dojo.lang.isString(e)) {
                        e = {_text:e};
                }
                if (!e._text) {
                        e._text = e.toString();
                }
                e.toString = function () {
                        return this._text;
                };
                if (typeof e.returnValue != "boolean") {
                        e.returnValue = true;
                }
                if (typeof e.preventDefault != "function") {
                        e.preventDefault = function () {
                                this.returnValue = false;
                        };
                }
                this[handler](e);
                if (e.returnValue) {
                        if (useAlert) {
                                alert(e.toString());
                        } else {
                                this.loader.callOnUnLoad.call(this, false);
                                this.onSetContent(e.toString());
                        }
                }
        }
        function downloader(bindArgs) {
                for (var x in this.bindArgs) {
                        bindArgs[x] = (undef(bindArgs[x]) ? this.bindArgs[x] : undefined);
                }
                var cache = this.cacheContent;
                if (undef(bindArgs.useCache)) {
                        bindArgs.useCache = cache;
                }
                if (undef(bindArgs.preventCache)) {
                        bindArgs.preventCache = !cache;
                }
                if (undef(bindArgs.mimetype)) {
                        bindArgs.mimetype = "text/html";
                }
                this.loader.bindObj = dojo.io.bind(bindArgs);
        }
        function stackRunner(st) {
                var err = "", func = null;
                var scope = this.scriptScope || dojo.global();
                while (st.length) {
                        func = st.shift();
                        try {
                                func.call(scope);
                        }
                        catch (e) {
                                err += "\n" + func + " failed: " + e;
                        }
                }
                if (err.length) {
                        var name = (st == this.loader.addOnLoads) ? "addOnLoad" : "addOnUnLoad";
                        handleDefaults.call(this, name + " failure\n " + err, "onExecError", true);
                }
        }
        function stackPusher(st, obj, func) {
                if (typeof func == "undefined") {
                        st.push(obj);
                } else {
                        st.push(function () {
                                obj[func]();
                        });
                }
        }
        function refreshed() {
                this.onResized();
                this.onLoad();
                this.isLoaded = true;
        }
        function asyncParse(data) {
                if (this.executeScripts) {
                        this.onExecScript.call(this, data.scripts);
                }
                if (this.parseContent) {
                        this.onContentParse.call(this);
                }
                refreshed.call(this);
        }
        function runHandler() {
                if (dojo.lang.isFunction(this.handler)) {
                        this.handler(this, this.containerNode || this.domNode);
                        refreshed.call(this);
                        return false;
                }
                return true;
        }
        this.htmlContentBasicFix = function (s, url) {
                var titles = [], styles = [];
                var regex = /<title[^>]*>([\s\S]*?)<\/title>/i;
                var match, attr;
                while (match = regex.exec(s)) {
                        titles.push(match[1]);
                        s = s.substring(0, match.index) + s.substr(match.index + match[0].length);
                }
                regex = /(?:<(style)[^>]*>([\s\S]*?)<\/style>|<link ([^>]*rel=['"]?stylesheet['"]?[^>]*)>)/i;
                while (match = regex.exec(s)) {
                        if (match[1] && match[1].toLowerCase() == "style") {
                                styles.push(dojo.html.fixPathsInCssText(match[2], url));
                        } else {
                                if (attr = match[3].match(/href=(['"]?)([^'">]*)\1/i)) {
                                        styles.push({path:attr[2]});
                                }
                        }
                        s = s.substring(0, match.index) + s.substr(match.index + match[0].length);
                }
                return {"s":s, "titles":titles, "styles":styles};
        };
        this.htmlContentAdjustPaths = function (s, url) {
                var tag = "", str = "", tagFix = "", path = "";
                var attr = [], origPath = "", fix = "";
                var regexFindTag = /<[a-z][a-z0-9]*[^>]*\s(?:(?:src|href|style)=[^>])+[^>]*>/i;
                var regexFindAttr = /\s(src|href|style)=(['"]?)([\w()\[\]\/.,\\'"-:;#=&?\s@]+?)\2/i;
                var regexProtocols = /^(?:[#]|(?:(?:https?|ftps?|file|javascript|mailto|news):))/;
                while (tag = regexFindTag.exec(s)) {
                        str += s.substring(0, tag.index);
                        s = s.substring((tag.index + tag[0].length), s.length);
                        tag = tag[0];
                        tagFix = "";
                        while (attr = regexFindAttr.exec(tag)) {
                                path = "";
                                origPath = attr[3];
                                switch (attr[1].toLowerCase()) {
                                  case "src":
                                  case "href":
                                        if (regexProtocols.exec(origPath)) {
                                                path = origPath;
                                        } else {
                                                path = (new dojo.uri.Uri(url, origPath).toString());
                                        }
                                        break;
                                  case "style":
                                        path = dojo.html.fixPathsInCssText(origPath, url);
                                        break;
                                  default:
                                        path = origPath;
                                }
                                fix = " " + attr[1] + "=" + attr[2] + path + attr[2];
                                tagFix += tag.substring(0, attr.index) + fix;
                                tag = tag.substring((attr.index + attr[0].length), tag.length);
                        }
                        str += tagFix + tag;
                }
                return str + s;
        };
        this.htmlContentScripts = function (s, collectScripts) {
                var scripts = [], requires = [], match = [];
                var attr = "", tmp = null, tag = "", sc = "", str = "";
                var regex = /<script([^>]*)>([\s\S]*?)<\/script>/i;
                var regexSrc = /src=(['"]?)([^"']*)\1/i;
                var regexDojoJs = /.*(\bdojo\b\.js(?:\.uncompressed\.js)?)$/;
                var regexInvalid = /(?:var )?\bdjConfig\b(?:[\s]*=[\s]*\{[^}]+\}|\.[\w]*[\s]*=[\s]*[^;\n]*)?;?|dojo\.hostenv\.writeIncludes\(\s*\);?/g;
                var regexRequires = /dojo\.(?:(?:require(?:After)?(?:If)?)|(?:widget\.(?:manager\.)?registerWidgetPackage)|(?:(?:hostenv\.)?setModulePrefix)|defineNamespace)\((['"]).*?\1\)\s*;?/;
                while (match = regex.exec(s)) {
                        if (this.executeScripts && match[1]) {
                                if (attr = regexSrc.exec(match[1])) {
                                        if (regexDojoJs.exec(attr[2])) {
                                                dojo.debug("Security note! inhibit:" + attr[2] + " from  beeing loaded again.");
                                        } else {
                                                scripts.push({path:attr[2]});
                                        }
                                }
                        }
                        if (match[2]) {
                                sc = match[2].replace(regexInvalid, "");
                                if (!sc) {
                                        continue;
                                }
                                while (tmp = regexRequires.exec(sc)) {
                                        requires.push(tmp[0]);
                                        sc = sc.substring(0, tmp.index) + sc.substr(tmp.index + tmp[0].length);
                                }
                                if (collectScripts) {
                                        scripts.push(sc);
                                }
                        }
                        s = s.substr(0, match.index) + s.substr(match.index + match[0].length);
                }
                if (collectScripts) {
                        var regex = /(<[a-zA-Z][a-zA-Z0-9]*\s[^>]*\S=(['"])[^>]*[^\.\]])scriptScope([^>]*>)/;
                        str = "";
                        while (tag = regex.exec(s)) {
                                tmp = ((tag[2] == "'") ? "\"" : "'");
                                str += s.substring(0, tag.index);
                                s = s.substr(tag.index).replace(regex, "$1dojo.widget.byId(" + tmp + this.widgetId + tmp + ").scriptScope$3");
                        }
                        s = str + s;
                }
                return {"s":s, "requires":requires, "scripts":scripts};
        };
        this.splitAndFixPaths = function (args) {
                if (!args.url) {
                        args.url = "./";
                }
                url = new dojo.uri.Uri(location, args.url).toString();
                var ret = {"xml":"", "styles":[], "titles":[], "requires":[], "scripts":[], "url":url};
                if (args.content) {
                        var tmp = null, content = args.content;
                        if (args.adjustPaths) {
                                content = _loader.htmlContentAdjustPaths.call(this, content, url);
                        }
                        tmp = _loader.htmlContentBasicFix.call(this, content, url);
                        content = tmp.s;
                        ret.styles = tmp.styles;
                        ret.titles = tmp.titles;
                        if (args.collectRequires || args.collectScripts) {
                                tmp = _loader.htmlContentScripts.call(this, content, args.collectScripts);
                                content = tmp.s;
                                ret.requires = tmp.requires;
                                ret.scripts = tmp.scripts;
                        }
                        var match = [];
                        if (args.bodyExtract) {
                                match = content.match(/<body[^>]*>\s*([\s\S]+)\s*<\/body>/im);
                                if (match) {
                                        content = match[1];
                                }
                        }
                        ret.xml = content;
                }
                return ret;
        };
        this.hookUp = function (args) {
                var widget = args.widget;
                if (dojo.lang.isString(widget)) {
                        if (args.mixin) {
                                dojo.raise(this.toString() + ", cant use mixin when widget is a string");
                        }
                        widget = dojo.evalObjPath(widget);
                }
                if (!widget || !(widget instanceof dojo.widget.HtmlWidget)) {
                        dojo.raise(this.toString() + " Widget isn't defined or isn't a HtmlWidget instance");
                }
                if (widget.loader && widget.setUrl) {
                        return;
                }
                var widgetProto = (args.mixin) ? widget : widget.constructor.prototype;
                widget.loader = {isLoaded:false, styleNodes:[], addOnLoads:[], addOnUnLoads:[], callOnUnLoad:(function (canCall) {
                        return function (after) {
                                this.abort();
                                if (canCall) {
                                        this.onUnLoad();
                                }
                                canCall = after;
                        };
                })(false), bindObj:null, unHook:(function (w, wg) {
                        var oldProps = {isContainer:w.isContainer, adjustPats:w.adjustPaths, href:w.href, extractContent:w.extractContent, parseContent:w.parseContent, cacheContent:w.cacheContent, bindArgs:w.bindArgs, preload:w.preload, refreshOnShow:w.refreshOnShow, handler:w.handler, trackHistory:w.trackHistory, executeScripts:w.executeScripts, scriptScope:w.scriptScope, postCreate:w.postCreate, show:w.show, refresh:w.refresh, loadContents:w.loadContents, abort:w.abort, destroy:w.destroy, onLoad:w.onLoad, onUnLoad:w.onUnLoad, addOnLoad:w.addOnLoad, addOnUnLoad:w.addOnUnLoad, onDownloadStart:w.onDownloadStart, onDownloadEnd:w.onDownloadEnd, onDownloadError:w.onDownloadError, onContentError:w.onContentError, onExecError:w.onExecError, onSetContent:w.onSetContent, setUrl:w.setUrl, setContent:w.setContent, onContentParse:w.onContentParse, onExecScript:w.onExecScript, setHandler:w.setHandler};
                        return function () {
                                if (wg.abort) {
                                        wg.abort();
                                }
                                if ((w != wg) && (dojo.widget.byType(wg.widgetType).length > 1)) {
                                        return;
                                }
                                for (var x in oldProps) {
                                        if (oldProps[x] === undefined) {
                                                delete w[x];
                                                continue;
                                        }
                                        w[x] = oldProps[x];
                                }
                                delete wg._loader_defined;
                                delete wg.loader;
                        };
                })(widgetProto, widget)};
                if (widgetProto._loader_defined || widget._loader_defined) {
                        return;
                }
                dojo.mixin(widgetProto, {isContainer:true, adjustPaths:undef(widgetProto.adjustPaths) ? true : widgetProto.adjustPaths, href:undef(widgetProto.href) ? "" : widgetProto.href, extractContent:undef(widgetProto.extractContent) ? true : widgetProto.extractContent, parseContent:undef(widgetProto.parseContent) ? true : widgetProto.parseContent, cacheContent:undef(widgetProto.cacheContent) ? true : widgetProto.cacheContent, bindArgs:undef(widgetProto.bindArgs) ? {} : widgetProto.bindArgs, preload:undef(widgetProto.preload) ? false : widgetProto.preload, refreshOnShow:undef(widgetProto.refreshOnShow) ? false : widgetProto.refreshOnShow, handler:undef(widgetProto.handler) ? "" : widgetProto.handler, executeScripts:undef(widgetProto.executeScripts) ? false : widgetProto.executeScripts, trackHistory:undef(widgetProto.tracHistory) ? false : widgetProto.trackHistory, scriptScope:null});
                widgetProto.postCreate = (function (postCreate) {
                        return function () {
                                if (widgetProto.constructor.superclass.postCreate != postCreate) {
                                        postCreate.apply(this, arguments);
                                } else {
                                        widgetProto.constructor.superclass.postCreate.apply(this, arguments);
                                }
                                if (this.handler !== "") {
                                        this.setHandler(this.handler);
                                }
                                if (this.isShowing() || this.preload) {
                                        this.loadContents();
                                        if (!this.href) {
                                                _loader._log(this, (this.domNode || this.containerNode).innerHTML);
                                        }
                                }
                        };
                })(widgetProto.postCreate);
                widgetProto.show = (function (show) {
                        return function () {
                                if (this.refreshOnShow) {
                                        this.refresh();
                                } else {
                                        this.loadContents();
                                }
                                if ((widgetProto.constructor.superclass.show == show) || !isFunc(show)) {
                                        widgetProto.constructor.superclass.show.apply(this, arguments);
                                } else {
                                        show.apply(this, arguments);
                                }
                        };
                })(widgetProto.show);
                widgetProto.destroy = (function (destroy) {
                        return function (destroy) {
                                this.onUnLoad();
                                this.abort();
                                this.loader.unHook();
                                if ((widgetProto.constructor.superclass.destroy != destroy) && isFunc(destroy)) {
                                        destroy.apply(this, arguments);
                                } else {
                                        widgetProto.constructor.superclass.destroy.apply(this, arguments);
                                }
                        };
                })(widgetProto.destroy);
                if (!widgetProto.refresh) {
                        widgetProto.refresh = function () {
                                this.loader.isLoaded = false;
                                this.loadContents();
                        };
                }
                if (!widgetProto.loadContents) {
                        widgetProto.loadContents = function () {
                                if (this.loader.isLoaded) {
                                        return;
                                }
                                if (isFunc(this.handler)) {
                                        runHandler.call(this);
                                } else {
                                        if (this.href !== "") {
                                                handleDefaults.call(this, "Loading...", "onDownloadStart");
                                                var self = this, url = this.href;
                                                downloader.call(this, {url:url, load:function (type, data, xhr) {
                                                        self.onDownloadEnd.call(self, url, data);
                                                }, error:function (type, err, xhr) {
                                                        var e = {responseText:xhr.responseText, status:xhr.status, statusText:xhr.statusText, responseHeaders:(xhr.getAllResponseHeaders) ? xhr.getAllResponseHeaders() : [], _text:"Error loading '" + url + "' (" + xhr.status + " " + xhr.statusText + ")"};
                                                        handleDefaults.call(self, e, "onDownloadError");
                                                        self.onLoad();
                                                }});
                                        }
                                }
                        };
                }
                if (!widgetProto.abort) {
                        widgetProto.abort = function () {
                                if (!this.loader || !this.loader.bindObj || !this.loader.bindObj.abort) {
                                        return;
                                }
                                this.loader.bindObj.abort();
                                this.loader.bindObj = null;
                        };
                }
                if (!widgetProto.onLoad) {
                        widgetProto.onLoad = function () {
                                stackRunner.call(this, this.loader.addOnLoads);
                                this.loader.isLoaded = true;
                        };
                }
                if (!widgetProto.onUnLoad) {
                        widgetProto.onUnLoad = function () {
                                stackRunner.call(this, this.loader.addOnUnLoads);
                                delete this.scriptScope;
                        };
                }
                if (!widgetProto.addOnLoad) {
                        widgetProto.addOnLoad = function (obj, func) {
                                stackPusher.call(this, this.loader.addOnLoads, obj, func);
                        };
                }
                if (!widgetProto.addOnUnLoad) {
                        widgetProto.addOnUnLoad = function (obj, func) {
                                stackPusher.call(this, this.loader.addOnUnLoads, obj, func);
                        };
                }
                if (!widgetProto.onExecError) {
                        widgetProto.onExecError = function () {
                        };
                }
                if (!widgetProto.onContentError) {
                        widgetProto.onContentError = function () {
                        };
                }
                if (!widgetProto.onDownloadError) {
                        widgetProto.onDownloadError = function () {
                        };
                }
                if (!widgetProto.onDownloadStart) {
                        widgetProto.onDownloadStart = function (onDownloadStart) {
                        };
                }
                if (!widgetProto.onDownloadEnd) {
                        widgetProto.onDownloadEnd = function (url, data) {
                                var args = {content:data, url:url, adjustPaths:this.adjustPaths, collectScripts:this.executeScripts, collectRequires:this.parseContent, bodyExtract:this.extractContent};
                                data = _loader.splitAndFixPaths.call(this, args);
                                this.setContent(data);
                        };
                }
                if (!widgetProto.onSetContent) {
                        widgetProto.onSetContent = function (cont) {
                                this.destroyChildren();
                                var styleNodes = this.loader.styleNodes;
                                while (styleNodes.length) {
                                        var st = styleNodes.pop();
                                        if (st && st.parentNode) {
                                                st.parentNode.removeChild(st);
                                        }
                                }
                                var node = this.containerNode || this.domNode;
                                while (node.firstChild) {
                                        try {
                                                dojo.event.browser.clean(node.firstChild);
                                        }
                                        catch (e) {
                                        }
                                        node.removeChild(node.firstChild);
                                }
                                try {
                                        if (typeof cont != "string") {
                                                node.appendChild(cont);
                                        } else {
                                                try {
                                                        node.innerHTML = cont;
                                                }
                                                catch (e) {
                                                        var tmp;
                                                        (tmp = dojo.doc().createElement("div")).innerHTML = cont;
                                                        while (tmp.firstChild) {
                                                                node.appendChild(tmp.removeChild(tmp.firstChild));
                                                        }
                                                }
                                        }
                                }
                                catch (e) {
                                        e._text = "Could'nt load content: " + e;
                                        var useAlert = (this.loader._onSetContent_err == e._text);
                                        this.loader._onSetContent_err = e._text;
                                        handleDefaults.call(this, e, "onContentError", useAlert);
                                }
                        };
                }
                if (!widgetProto.setUrl) {
                        widgetProto.setUrl = function (url) {
                                this.href = url;
                                this.loader.isLoaded = false;
                                if (this.preload || this.isShowing()) {
                                        this.loadContents();
                                }
                        };
                }
                if (!widgetProto.setContent) {
                        widgetProto.setContent = function (data, dontLog) {
                                this.loader.callOnUnLoad.call(this, true);
                                if (!data || dojo.html.isNode(data)) {
                                        this.onSetContent(data);
                                        refreshed.call(this);
                                } else {
                                        if (typeof data.xml != "string") {
                                                this.href = "";
                                                var args = {content:data, url:this.href, adjustPaths:this.adjustPaths, collectScripts:this.executeScripts, collectRequires:this.parseContent, bodyExtract:this.extractContent};
                                                data = _loader.splitAndFixPaths.call(this, args);
                                        } else {
                                                if (data.url != "./") {
                                                        this.url = data.url;
                                                }
                                        }
                                        this.onSetContent(data.xml);
                                        for (var i = 0, styles = data.styles; i < styles.length; i++) {
                                                if (styles[i].path) {
                                                        this.loader.styleNodes.push(dojo.html.insertCssFile(styles[i].path));
                                                } else {
                                                        this.loader.styleNodes.push(dojo.html.insertCssText(styles[i]));
                                                }
                                        }
                                        if (this.parseContent) {
                                                for (var i = 0, requires = data.requires; i < requires.length; i++) {
                                                        try {
                                                                eval(requires[i]);
                                                        }
                                                        catch (e) {
                                                                e._text = "dojo.widget.html.loader.hookUp: error in package loading calls, " + (e.description || e);
                                                                handleDefaults.call(this, e, "onContentError", true);
                                                        }
                                                }
                                        }
                                        if (dojo.hostenv.isXDomain && data.requires.length) {
                                                dojo.addOnLoad(function () {
                                                        asyncParse.call(this, data);
                                                        if (!dontLog) {
                                                                _loader._log(this, data);
                                                        }
                                                });
                                                dontLog = true;
                                        } else {
                                                asyncParse.call(this, data);
                                        }
                                }
                                if (!dontLog) {
                                }
                        };
                }
                if (!widgetProto.onContentParse) {
                        widgetProto.onContentParse = function () {
                                var node = this.containerNode || this.domNode;
                                var parser = new dojo.xml.Parse();
                                var frag = parser.parseElement(node, null, true);
                                dojo.widget.getParser().createSubComponents(frag, this);
                        };
                }
                if (!widgetProto.onExecScript) {
                        widgetProto.onExecScript = function (scripts) {
                                var self = this, tmp = "", code = "";
                                for (var i = 0; i < scripts.length; i++) {
                                        if (scripts[i].path) {
                                                var url = scripts[i].path;
                                                downloader.call(this, {"url":url, "load":function (type, scriptStr) {
                                                        (function () {
                                                                tmp = scriptStr;
                                                                scripts[i] = scriptStr;
                                                        }).call(self);
                                                }, "error":function (type, error) {
                                                        error._text = type + " downloading remote script";
                                                        handleDefaults.call(self, error, "onExecError", true);
                                                }, "mimetype":"text/plain", "sync":true});
                                                code += tmp;
                                        } else {
                                                code += scripts[i];
                                        }
                                }
                                try {
                                        delete this.scriptScope;
                                        this.scriptScope = new (new Function("_container_", code + "; return this;"))(self);
                                }
                                catch (e) {
                                        e._text = "Error running scripts from content:\n" + (e.description || e.toString());
                                        handleDefaults.call(this, e, "onExecError", true);
                                }
                        };
                }
                if (!widgetProto.setHandler) {
                        widgetProto.setHandler = function (handler) {
                                var fcn = dojo.lang.isFunction(handler) ? handler : window[handler];
                                if (!isFunc(fcn)) {
                                        handleDefaults.call(this, "Unable to set handler, '" + handler + "' not a function.", "onExecError", true);
                                        return;
                                }
                                this.handler = function () {
                                        return fcn.apply(this, arguments);
                                };
                        };
                }
                widgetProto._loader_defined = true;
        };
})();