| /* |
| 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.DomWidget"); |
| dojo.require("dojo.event.*"); |
| dojo.require("dojo.widget.Widget"); |
| dojo.require("dojo.dom"); |
| dojo.require("dojo.html.style"); |
| dojo.require("dojo.xml.Parse"); |
| dojo.require("dojo.uri.*"); |
| dojo.require("dojo.lang.func"); |
| dojo.require("dojo.lang.extras"); |
| dojo.widget._cssFiles = {}; |
| dojo.widget._cssStrings = {}; |
| dojo.widget._templateCache = {}; |
| dojo.widget.defaultStrings = {dojoRoot:dojo.hostenv.getBaseScriptUri(), dojoWidgetModuleUri:dojo.uri.moduleUri("dojo.widget"), baseScriptUri:dojo.hostenv.getBaseScriptUri()}; |
| dojo.widget.fillFromTemplateCache = function (obj, templatePath, templateString, avoidCache) { |
| var tpath = templatePath || obj.templatePath; |
| var tmplts = dojo.widget._templateCache; |
| if (!tpath && !obj["widgetType"]) { |
| do { |
| var dummyName = "__dummyTemplate__" + dojo.widget._templateCache.dummyCount++; |
| } while (tmplts[dummyName]); |
| obj.widgetType = dummyName; |
| } |
| var wt = tpath ? tpath.toString() : obj.widgetType; |
| var ts = tmplts[wt]; |
| if (!ts) { |
| tmplts[wt] = {"string":null, "node":null}; |
| if (avoidCache) { |
| ts = {}; |
| } else { |
| ts = tmplts[wt]; |
| } |
| } |
| if ((!obj.templateString) && (!avoidCache)) { |
| obj.templateString = templateString || ts["string"]; |
| } |
| if (obj.templateString) { |
| obj.templateString = this._sanitizeTemplateString(obj.templateString); |
| } |
| if ((!obj.templateNode) && (!avoidCache)) { |
| obj.templateNode = ts["node"]; |
| } |
| if ((!obj.templateNode) && (!obj.templateString) && (tpath)) { |
| var tstring = this._sanitizeTemplateString(dojo.hostenv.getText(tpath)); |
| obj.templateString = tstring; |
| if (!avoidCache) { |
| tmplts[wt]["string"] = tstring; |
| } |
| } |
| if ((!ts["string"]) && (!avoidCache)) { |
| ts.string = obj.templateString; |
| } |
| }; |
| dojo.widget._sanitizeTemplateString = function (tString) { |
| if (tString) { |
| tString = tString.replace(/^\s*<\?xml(\s)+version=[\'\"](\d)*.(\d)*[\'\"](\s)*\?>/im, ""); |
| var matches = tString.match(/<body[^>]*>\s*([\s\S]+)\s*<\/body>/im); |
| if (matches) { |
| tString = matches[1]; |
| } |
| } else { |
| tString = ""; |
| } |
| return tString; |
| }; |
| dojo.widget._templateCache.dummyCount = 0; |
| dojo.widget.attachProperties = ["dojoAttachPoint", "id"]; |
| dojo.widget.eventAttachProperty = "dojoAttachEvent"; |
| dojo.widget.onBuildProperty = "dojoOnBuild"; |
| dojo.widget.waiNames = ["waiRole", "waiState"]; |
| dojo.widget.wai = {waiRole:{name:"waiRole", "namespace":"http://www.w3.org/TR/xhtml2", alias:"x2", prefix:"wairole:"}, waiState:{name:"waiState", "namespace":"http://www.w3.org/2005/07/aaa", alias:"aaa", prefix:""}, setAttr:function (node, ns, attr, value) { |
| if (dojo.render.html.ie) { |
| node.setAttribute(this[ns].alias + ":" + attr, this[ns].prefix + value); |
| } else { |
| node.setAttributeNS(this[ns]["namespace"], attr, this[ns].prefix + value); |
| } |
| }, getAttr:function (node, ns, attr) { |
| if (dojo.render.html.ie) { |
| return node.getAttribute(this[ns].alias + ":" + attr); |
| } else { |
| return node.getAttributeNS(this[ns]["namespace"], attr); |
| } |
| }, removeAttr:function (node, ns, attr) { |
| var success = true; |
| if (dojo.render.html.ie) { |
| success = node.removeAttribute(this[ns].alias + ":" + attr); |
| } else { |
| node.removeAttributeNS(this[ns]["namespace"], attr); |
| } |
| return success; |
| }}; |
| dojo.widget.attachTemplateNodes = function (rootNode, targetObj, events) { |
| var elementNodeType = dojo.dom.ELEMENT_NODE; |
| function trim(str) { |
| return str.replace(/^\s+|\s+$/g, ""); |
| } |
| if (!rootNode) { |
| rootNode = targetObj.domNode; |
| } |
| if (rootNode.nodeType != elementNodeType) { |
| return; |
| } |
| var nodes = rootNode.all || rootNode.getElementsByTagName("*"); |
| var _this = targetObj; |
| for (var x = -1; x < nodes.length; x++) { |
| var baseNode = (x == -1) ? rootNode : nodes[x]; |
| var attachPoint = []; |
| if (!targetObj.widgetsInTemplate || !baseNode.getAttribute("dojoType")) { |
| for (var y = 0; y < this.attachProperties.length; y++) { |
| var tmpAttachPoint = baseNode.getAttribute(this.attachProperties[y]); |
| if (tmpAttachPoint) { |
| attachPoint = tmpAttachPoint.split(";"); |
| for (var z = 0; z < attachPoint.length; z++) { |
| if (dojo.lang.isArray(targetObj[attachPoint[z]])) { |
| targetObj[attachPoint[z]].push(baseNode); |
| } else { |
| targetObj[attachPoint[z]] = baseNode; |
| } |
| } |
| break; |
| } |
| } |
| var attachEvent = baseNode.getAttribute(this.eventAttachProperty); |
| if (attachEvent) { |
| var evts = attachEvent.split(";"); |
| for (var y = 0; y < evts.length; y++) { |
| if ((!evts[y]) || (!evts[y].length)) { |
| continue; |
| } |
| var thisFunc = null; |
| var tevt = trim(evts[y]); |
| if (evts[y].indexOf(":") >= 0) { |
| var funcNameArr = tevt.split(":"); |
| tevt = trim(funcNameArr[0]); |
| thisFunc = trim(funcNameArr[1]); |
| } |
| if (!thisFunc) { |
| thisFunc = tevt; |
| } |
| var tf = function () { |
| var ntf = new String(thisFunc); |
| return function (evt) { |
| if (_this[ntf]) { |
| _this[ntf](dojo.event.browser.fixEvent(evt, this)); |
| } |
| }; |
| }(); |
| dojo.event.browser.addListener(baseNode, tevt, tf, false, true); |
| } |
| } |
| for (var y = 0; y < events.length; y++) { |
| var evtVal = baseNode.getAttribute(events[y]); |
| if ((evtVal) && (evtVal.length)) { |
| var thisFunc = null; |
| var domEvt = events[y].substr(4); |
| thisFunc = trim(evtVal); |
| var funcs = [thisFunc]; |
| if (thisFunc.indexOf(";") >= 0) { |
| funcs = dojo.lang.map(thisFunc.split(";"), trim); |
| } |
| for (var z = 0; z < funcs.length; z++) { |
| if (!funcs[z].length) { |
| continue; |
| } |
| var tf = function () { |
| var ntf = new String(funcs[z]); |
| return function (evt) { |
| if (_this[ntf]) { |
| _this[ntf](dojo.event.browser.fixEvent(evt, this)); |
| } |
| }; |
| }(); |
| dojo.event.browser.addListener(baseNode, domEvt, tf, false, true); |
| } |
| } |
| } |
| } |
| var tmpltPoint = baseNode.getAttribute(this.templateProperty); |
| if (tmpltPoint) { |
| targetObj[tmpltPoint] = baseNode; |
| } |
| dojo.lang.forEach(dojo.widget.waiNames, function (name) { |
| var wai = dojo.widget.wai[name]; |
| var val = baseNode.getAttribute(wai.name); |
| if (val) { |
| if (val.indexOf("-") == -1) { |
| dojo.widget.wai.setAttr(baseNode, wai.name, "role", val); |
| } else { |
| var statePair = val.split("-"); |
| dojo.widget.wai.setAttr(baseNode, wai.name, statePair[0], statePair[1]); |
| } |
| } |
| }, this); |
| var onBuild = baseNode.getAttribute(this.onBuildProperty); |
| if (onBuild) { |
| eval("var node = baseNode; var widget = targetObj; " + onBuild); |
| } |
| } |
| }; |
| dojo.widget.getDojoEventsFromStr = function (str) { |
| var re = /(dojoOn([a-z]+)(\s?))=/gi; |
| var evts = str ? str.match(re) || [] : []; |
| var ret = []; |
| var lem = {}; |
| for (var x = 0; x < evts.length; x++) { |
| if (evts[x].length < 1) { |
| continue; |
| } |
| var cm = evts[x].replace(/\s/, ""); |
| cm = (cm.slice(0, cm.length - 1)); |
| if (!lem[cm]) { |
| lem[cm] = true; |
| ret.push(cm); |
| } |
| } |
| return ret; |
| }; |
| dojo.declare("dojo.widget.DomWidget", dojo.widget.Widget, function () { |
| if ((arguments.length > 0) && (typeof arguments[0] == "object")) { |
| this.create(arguments[0]); |
| } |
| }, {templateNode:null, templateString:null, templateCssString:null, preventClobber:false, domNode:null, containerNode:null, widgetsInTemplate:false, addChild:function (widget, overrideContainerNode, pos, ref, insertIndex) { |
| if (!this.isContainer) { |
| dojo.debug("dojo.widget.DomWidget.addChild() attempted on non-container widget"); |
| return null; |
| } else { |
| if (insertIndex == undefined) { |
| insertIndex = this.children.length; |
| } |
| this.addWidgetAsDirectChild(widget, overrideContainerNode, pos, ref, insertIndex); |
| this.registerChild(widget, insertIndex); |
| } |
| return widget; |
| }, addWidgetAsDirectChild:function (widget, overrideContainerNode, pos, ref, insertIndex) { |
| if ((!this.containerNode) && (!overrideContainerNode)) { |
| this.containerNode = this.domNode; |
| } |
| var cn = (overrideContainerNode) ? overrideContainerNode : this.containerNode; |
| if (!pos) { |
| pos = "after"; |
| } |
| if (!ref) { |
| if (!cn) { |
| cn = dojo.body(); |
| } |
| ref = cn.lastChild; |
| } |
| if (!insertIndex) { |
| insertIndex = 0; |
| } |
| widget.domNode.setAttribute("dojoinsertionindex", insertIndex); |
| if (!ref) { |
| cn.appendChild(widget.domNode); |
| } else { |
| if (pos == "insertAtIndex") { |
| dojo.dom.insertAtIndex(widget.domNode, ref.parentNode, insertIndex); |
| } else { |
| if ((pos == "after") && (ref === cn.lastChild)) { |
| cn.appendChild(widget.domNode); |
| } else { |
| dojo.dom.insertAtPosition(widget.domNode, cn, pos); |
| } |
| } |
| } |
| }, registerChild:function (widget, insertionIndex) { |
| widget.dojoInsertionIndex = insertionIndex; |
| var idx = -1; |
| for (var i = 0; i < this.children.length; i++) { |
| if (this.children[i].dojoInsertionIndex <= insertionIndex) { |
| idx = i; |
| } |
| } |
| this.children.splice(idx + 1, 0, widget); |
| widget.parent = this; |
| widget.addedTo(this, idx + 1); |
| delete dojo.widget.manager.topWidgets[widget.widgetId]; |
| }, removeChild:function (widget) { |
| dojo.dom.removeNode(widget.domNode); |
| return dojo.widget.DomWidget.superclass.removeChild.call(this, widget); |
| }, getFragNodeRef:function (frag) { |
| if (!frag) { |
| return null; |
| } |
| if (!frag[this.getNamespacedType()]) { |
| dojo.raise("Error: no frag for widget type " + this.getNamespacedType() + ", id " + this.widgetId + " (maybe a widget has set it's type incorrectly)"); |
| } |
| return frag[this.getNamespacedType()]["nodeRef"]; |
| }, postInitialize:function (args, frag, parentComp) { |
| var sourceNodeRef = this.getFragNodeRef(frag); |
| if (parentComp && (parentComp.snarfChildDomOutput || !sourceNodeRef)) { |
| parentComp.addWidgetAsDirectChild(this, "", "insertAtIndex", "", args["dojoinsertionindex"], sourceNodeRef); |
| } else { |
| if (sourceNodeRef) { |
| if (this.domNode && (this.domNode !== sourceNodeRef)) { |
| this._sourceNodeRef = dojo.dom.replaceNode(sourceNodeRef, this.domNode); |
| } |
| } |
| } |
| if (parentComp) { |
| parentComp.registerChild(this, args.dojoinsertionindex); |
| } else { |
| dojo.widget.manager.topWidgets[this.widgetId] = this; |
| } |
| if (this.widgetsInTemplate) { |
| var parser = new dojo.xml.Parse(); |
| var subContainerNode; |
| var subnodes = this.domNode.getElementsByTagName("*"); |
| for (var i = 0; i < subnodes.length; i++) { |
| if (subnodes[i].getAttribute("dojoAttachPoint") == "subContainerWidget") { |
| subContainerNode = subnodes[i]; |
| } |
| if (subnodes[i].getAttribute("dojoType")) { |
| subnodes[i].setAttribute("isSubWidget", true); |
| } |
| } |
| if (this.isContainer && !this.containerNode) { |
| if (subContainerNode) { |
| var src = this.getFragNodeRef(frag); |
| if (src) { |
| dojo.dom.moveChildren(src, subContainerNode); |
| frag["dojoDontFollow"] = true; |
| } |
| } else { |
| dojo.debug("No subContainerWidget node can be found in template file for widget " + this); |
| } |
| } |
| var templatefrag = parser.parseElement(this.domNode, null, true); |
| dojo.widget.getParser().createSubComponents(templatefrag, this); |
| var subwidgets = []; |
| var stack = [this]; |
| var w; |
| while ((w = stack.pop())) { |
| for (var i = 0; i < w.children.length; i++) { |
| var cwidget = w.children[i]; |
| if (cwidget._processedSubWidgets || !cwidget.extraArgs["issubwidget"]) { |
| continue; |
| } |
| subwidgets.push(cwidget); |
| if (cwidget.isContainer) { |
| stack.push(cwidget); |
| } |
| } |
| } |
| for (var i = 0; i < subwidgets.length; i++) { |
| var widget = subwidgets[i]; |
| if (widget._processedSubWidgets) { |
| dojo.debug("This should not happen: widget._processedSubWidgets is already true!"); |
| return; |
| } |
| widget._processedSubWidgets = true; |
| if (widget.extraArgs["dojoattachevent"]) { |
| var evts = widget.extraArgs["dojoattachevent"].split(";"); |
| for (var j = 0; j < evts.length; j++) { |
| var thisFunc = null; |
| var tevt = dojo.string.trim(evts[j]); |
| if (tevt.indexOf(":") >= 0) { |
| var funcNameArr = tevt.split(":"); |
| tevt = dojo.string.trim(funcNameArr[0]); |
| thisFunc = dojo.string.trim(funcNameArr[1]); |
| } |
| if (!thisFunc) { |
| thisFunc = tevt; |
| } |
| if (dojo.lang.isFunction(widget[tevt])) { |
| dojo.event.kwConnect({srcObj:widget, srcFunc:tevt, targetObj:this, targetFunc:thisFunc}); |
| } else { |
| alert(tevt + " is not a function in widget " + widget); |
| } |
| } |
| } |
| if (widget.extraArgs["dojoattachpoint"]) { |
| this[widget.extraArgs["dojoattachpoint"]] = widget; |
| } |
| } |
| } |
| if (this.isContainer && !frag["dojoDontFollow"]) { |
| dojo.widget.getParser().createSubComponents(frag, this); |
| } |
| }, buildRendering:function (args, frag) { |
| var ts = dojo.widget._templateCache[this.widgetType]; |
| if (args["templatecsspath"]) { |
| args["templateCssPath"] = args["templatecsspath"]; |
| } |
| var cpath = args["templateCssPath"] || this.templateCssPath; |
| if (cpath && !dojo.widget._cssFiles[cpath.toString()]) { |
| if ((!this.templateCssString) && (cpath)) { |
| this.templateCssString = dojo.hostenv.getText(cpath); |
| this.templateCssPath = null; |
| } |
| dojo.widget._cssFiles[cpath.toString()] = true; |
| } |
| if ((this["templateCssString"]) && (!dojo.widget._cssStrings[this.templateCssString])) { |
| dojo.html.insertCssText(this.templateCssString, null, cpath); |
| dojo.widget._cssStrings[this.templateCssString] = true; |
| } |
| if ((!this.preventClobber) && ((this.templatePath) || (this.templateNode) || ((this["templateString"]) && (this.templateString.length)) || ((typeof ts != "undefined") && ((ts["string"]) || (ts["node"]))))) { |
| this.buildFromTemplate(args, frag); |
| } else { |
| this.domNode = this.getFragNodeRef(frag); |
| } |
| this.fillInTemplate(args, frag); |
| }, buildFromTemplate:function (args, frag) { |
| var avoidCache = false; |
| if (args["templatepath"]) { |
| args["templatePath"] = args["templatepath"]; |
| } |
| dojo.widget.fillFromTemplateCache(this, args["templatePath"], null, avoidCache); |
| var ts = dojo.widget._templateCache[this.templatePath ? this.templatePath.toString() : this.widgetType]; |
| if ((ts) && (!avoidCache)) { |
| if (!this.templateString.length) { |
| this.templateString = ts["string"]; |
| } |
| if (!this.templateNode) { |
| this.templateNode = ts["node"]; |
| } |
| } |
| var matches = false; |
| var node = null; |
| var tstr = this.templateString; |
| if ((!this.templateNode) && (this.templateString)) { |
| matches = this.templateString.match(/\$\{([^\}]+)\}/g); |
| if (matches) { |
| var hash = this.strings || {}; |
| for (var key in dojo.widget.defaultStrings) { |
| if (dojo.lang.isUndefined(hash[key])) { |
| hash[key] = dojo.widget.defaultStrings[key]; |
| } |
| } |
| for (var i = 0; i < matches.length; i++) { |
| var key = matches[i]; |
| key = key.substring(2, key.length - 1); |
| var kval = (key.substring(0, 5) == "this.") ? dojo.lang.getObjPathValue(key.substring(5), this) : hash[key]; |
| var value; |
| if ((kval) || (dojo.lang.isString(kval))) { |
| value = new String((dojo.lang.isFunction(kval)) ? kval.call(this, key, this.templateString) : kval); |
| while (value.indexOf("\"") > -1) { |
| value = value.replace("\"", """); |
| } |
| tstr = tstr.replace(matches[i], value); |
| } |
| } |
| } else { |
| this.templateNode = this.createNodesFromText(this.templateString, true)[0]; |
| if (!avoidCache) { |
| ts.node = this.templateNode; |
| } |
| } |
| } |
| if ((!this.templateNode) && (!matches)) { |
| dojo.debug("DomWidget.buildFromTemplate: could not create template"); |
| return false; |
| } else { |
| if (!matches) { |
| node = this.templateNode.cloneNode(true); |
| if (!node) { |
| return false; |
| } |
| } else { |
| node = this.createNodesFromText(tstr, true)[0]; |
| } |
| } |
| this.domNode = node; |
| this.attachTemplateNodes(); |
| if (this.isContainer && this.containerNode) { |
| var src = this.getFragNodeRef(frag); |
| if (src) { |
| dojo.dom.moveChildren(src, this.containerNode); |
| } |
| } |
| }, attachTemplateNodes:function (baseNode, targetObj) { |
| if (!baseNode) { |
| baseNode = this.domNode; |
| } |
| if (!targetObj) { |
| targetObj = this; |
| } |
| return dojo.widget.attachTemplateNodes(baseNode, targetObj, dojo.widget.getDojoEventsFromStr(this.templateString)); |
| }, fillInTemplate:function () { |
| }, destroyRendering:function () { |
| try { |
| dojo.dom.destroyNode(this.domNode); |
| delete this.domNode; |
| } |
| catch (e) { |
| } |
| if (this._sourceNodeRef) { |
| try { |
| dojo.dom.destroyNode(this._sourceNodeRef); |
| } |
| catch (e) { |
| } |
| } |
| }, createNodesFromText:function () { |
| dojo.unimplemented("dojo.widget.DomWidget.createNodesFromText"); |
| }}); |
| |
