Team:SYSU-China/temp/SpryDOMUtils.js

From 2011.igem.org

// SpryDOMUtils.js - version 0.13 - Spry Pre-Release 1.7 // // Copyright (c) 2007. Adobe Systems Incorporated. // All rights reserved. // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: // // * Redistributions of source code must retain the above copyright notice, // this list of conditions and the following disclaimer. // * Redistributions in binary form must reproduce the above copyright notice, // this list of conditions and the following disclaimer in the documentation // and/or other materials provided with the distribution. // * Neither the name of Adobe Systems Incorporated nor the names of its // contributors may be used to endorse or promote products derived from this // software without specific prior written permission. // // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" // AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE // ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE // LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR // CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF // SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS // INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN // CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) // ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE // POSSIBILITY OF SUCH DAMAGE.

(function() { // BeginSpryComponent

if (typeof Spry == "undefined") window.Spry = {}; if (!Spry.Utils) Spry.Utils = {};

////////////////////////////////////////////////////////////////////// // // Define Prototype's $() convenience function, but make sure it is // namespaced under Spry so that we avoid collisions with other // toolkits. // //////////////////////////////////////////////////////////////////////

Spry.$ = function(element) { if (arguments.length > 1) { for (var i = 0, elements = [], length = arguments.length; i < length; i++) elements.push(Spry.$(arguments[i])); return elements; } if (typeof element == 'string') element = document.getElementById(element); return element; };

////////////////////////////////////////////////////////////////////// // // DOM Utils // //////////////////////////////////////////////////////////////////////

Spry.Utils.getAttribute = function(ele, name) { ele = Spry.$(ele); if (!ele || !name) return null;

// We need to wrap getAttribute with a try/catch because IE will throw // an exception if you call it with a namespace prefixed attribute name // that doesn't exist.

try { var value = ele.getAttribute(name); } catch (e) { value == undefined; }

// XXX: Workaround for Safari 2.x and earlier: // // If value is undefined, the attribute didn't exist. Check to see if this is // a namespace prefixed attribute name. If it is, remove the ':' from the name // and try again. This allows us to support spry attributes of the form // "spry:region" and "spryregion".

if (value == undefined && name.search(/:/) != -1) { try { var value = ele.getAttribute(name.replace(/:/, "")); } catch (e) { value == undefined; } }

return value; };

Spry.Utils.setAttribute = function(ele, name, value) { ele = Spry.$(ele); if (!ele || !name) return;

// IE doesn't allow you to set the "class" attribute. You // have to set the className property instead.

if (name == "class") ele.className = value; else { // I'm probably being a bit paranoid, but given the fact that // getAttribute() throws exceptions when dealing with namespace // prefixed attributes, I'm going to wrap this setAttribute() // call with try/catch just in case ...

try { ele.setAttribute(name, value); } catch(e) {}

// XXX: Workaround for Safari 2.x and earlier: // // If this is a namespace prefixed attribute, check to make // sure an attribute was created. This is necessary because some // older versions of Safari (2.x and earlier) drop the namespace // prefixes. If the attribute was munged, try removing the ':' // character from the attribute name and setting the attribute // using the resulting name. The idea here is that even if we // remove the ':' character, Spry.Utils.getAttribute() will still // find the attribute.

if (name.search(/:/) != -1 && ele.getAttribute(name) == undefined) ele.setAttribute(name.replace(/:/, ""), value); } };

Spry.Utils.removeAttribute = function(ele, name) { ele = Spry.$(ele); if (!ele || !name) return;

try { ele.removeAttribute(name); } catch(e) {}

// XXX: Workaround for Safari 2.x and earlier: // // If this is a namespace prefixed attribute, make sure we // also remove any attributes with the same name, but without // the ':' character.

if (name.search(/:/) != -1) ele.removeAttribute(name.replace(/:/, ""));

// XXX: Workaround for IE // // IE doesn't allow you to remove the "class" attribute. // It requires you to remove "className" instead, so go // ahead and try to remove that too.

if (name == "class") ele.removeAttribute("className"); };

Spry.Utils.addClassName = function(ele, className) { ele = Spry.$(ele); if (!ele || !className || (ele.className && ele.className.search(new RegExp("\\b" + className + "\\b")) != -1)) return; ele.className += (ele.className ? " " : "") + className; };

Spry.Utils.removeClassName = function(ele, className) { ele = Spry.$(ele); if (Spry.Utils.hasClassName(ele, className)) ele.className = ele.className.replace(new RegExp("\\s*\\b" + className + "\\b", "g"), ""); };

Spry.Utils.toggleClassName = function(ele, className) { if (Spry.Utils.hasClassName(ele, className)) Spry.Utils.removeClassName(ele, className); else Spry.Utils.addClassName(ele, className); };

Spry.Utils.hasClassName = function(ele, className) { ele = Spry.$(ele); if (!ele || !className || !ele.className || ele.className.search(new RegExp("\\b" + className + "\\b")) == -1) return false; return true; };

Spry.Utils.camelizeString = function(str) { var cStr = ""; var a = str.split("-"); for (var i = 0; i < a.length; i++) { var s = a[i]; if (s) cStr = cStr ? (cStr + s.charAt(0).toUpperCase() + s.substring(1)) : s; } return cStr; };

Spry.Utils.styleStringToObject = function(styleStr) { var o = {}; if (styleStr) { var pvA = styleStr.split(";"); for (var i = 0; i < pvA.length; i++) { var pv = pvA[i]; if (pv && pv.indexOf(":") != -1) { var nvA = pv.split(":"); var n = nvA[0].replace(/^\s*|\s*$/g, ""); var v = nvA[1].replace(/^\s*|\s*$/g, ""); if (n && v) o[Spry.Utils.camelizeString(n)] = v; } } } return o; };

Spry.Utils.addEventListener = function(element, eventType, handler, capture) { try { if (!Spry.Utils.eventListenerIsBoundToElement(element, eventType, handler, capture)) { element = Spry.$(element); handler = Spry.Utils.bindEventListenerToElement(element, eventType, handler, capture); if (element.addEventListener) element.addEventListener(eventType, handler, capture); else if (element.attachEvent) element.attachEvent("on" + eventType, handler); } } catch (e) {} };

Spry.Utils.removeEventListener = function(element, eventType, handler, capture) { try { element = Spry.$(element); handler = Spry.Utils.unbindEventListenerFromElement(element, eventType, handler, capture); if (element.removeEventListener) element.removeEventListener(eventType, handler, capture); else if (element.detachEvent) element.detachEvent("on" + eventType, handler); } catch (e) {} };

Spry.Utils.eventListenerHash = {}; Spry.Utils.nextEventListenerID = 1;

Spry.Utils.getHashForElementAndHandler = function(element, eventType, handler, capture) { var hash = null; element = Spry.$(element); if (element) { if (typeof element.spryEventListenerID == "undefined") element.spryEventListenerID = "e" + (Spry.Utils.nextEventListenerID++); if (typeof handler.spryEventHandlerID == "undefined") handler.spryEventHandlerID = "h" + (Spry.Utils.nextEventListenerID++); hash = element.spryEventListenerID + "-" + handler.spryEventHandlerID + "-" + eventType + (capture?"-capture":""); } return hash; };

Spry.Utils.eventListenerIsBoundToElement = function(element, eventType, handler, capture) { element = Spry.$(element); var hash = Spry.Utils.getHashForElementAndHandler(element, eventType, handler, capture); return Spry.Utils.eventListenerHash[hash] != undefined; };

Spry.Utils.bindEventListenerToElement = function(element, eventType, handler, capture) { element = Spry.$(element); var hash = Spry.Utils.getHashForElementAndHandler(element, eventType, handler, capture); if (Spry.Utils.eventListenerHash[hash]) return Spry.Utils.eventListenerHash[hash]; return Spry.Utils.eventListenerHash[hash] = function(e) { e = e || window.event;

if (!e.preventDefault) e.preventDefault = function() { this.returnValue = false; }; if (!e.stopPropagation) e.stopPropagation = function() { this.cancelBubble = true; };

var result = handler.call(element, e); if (result == false) { e.preventDefault(); e.stopPropagation(); } return result; }; };

Spry.Utils.unbindEventListenerFromElement = function(element, eventType, handler, capture) { element = Spry.$(element); var hash = Spry.Utils.getHashForElementAndHandler(element, eventType, handler, capture); if (Spry.Utils.eventListenerHash[hash]) { handler = Spry.Utils.eventListenerHash[hash]; Spry.Utils.eventListenerHash[hash] = undefined; } return handler; };

Spry.Utils.cancelEvent = function(e) { if (e.preventDefault) e.preventDefault(); else e.returnValue = false; if (e.stopPropagation) e.stopPropagation(); else e.cancelBubble = true;

return false; };

Spry.Utils.addLoadListener = function(handler) { if (typeof window.addEventListener != 'undefined') window.addEventListener('load', handler, false); else if (typeof document.addEventListener != 'undefined') document.addEventListener('load', handler, false); else if (typeof window.attachEvent != 'undefined') window.attachEvent('onload', handler); };

Spry.Utils.isDescendant = function(parent, child) { if (parent && child) { child = child.parentNode; while (child) { if (parent == child) return true; child = child.parentNode; } } return false; };

Spry.Utils.getAncestor = function(ele, selector) { ele = Spry.$(ele); if (ele) { var s = Spry.$$.tokenizeSequence(selector ? selector : "*")[0]; var t = s ? s[0] : null; if (t) { var p = ele.parentNode; while (p) { if (t.match(p)) return p; p = p.parentNode; } } } return null; };

////////////////////////////////////////////////////////////////////// // // CSS Selector Matching // //////////////////////////////////////////////////////////////////////

Spry.$$ = function(selectorSequence, rootNode) { var matches = []; Spry.$$.addExtensions(matches);

// If the first argument to $$() is an object, it // is assumed that all args are either a DOM element // or an array of DOM elements, in which case we // simply append all DOM elements to our special // matches array and return immediately.

if (typeof arguments[0] == "object") { for (var i = 0; i < arguments.length; i++) { if (arguments[i].constructor == Array) matches.push.apply(matches, arguments[i]); else matches.push(arguments[i]); } return matches; }

if (!rootNode) rootNode = document; else rootNode = Spry.$(rootNode);

var sequences = Spry.$$.tokenizeSequence(selectorSequence);

++Spry.$$.queryID;

var nm = matches.length; for (i = 0; i < nm; i++) matches[i].spry$$ID = undefined;

return matches; };

Spry.$$.cache = {}; Spry.$$.queryID = 0;

Spry.$$.Token = function() { this.type = Spry.$$.Token.SELECTOR; this.name = "*"; this.id = ""; this.classes = []; this.attrs = [];

this.pseudos = []; };

Spry.$$.Token.Attr = function(n, v) { this.name = n; this.value = v ? new RegExp(v) : undefined; };

Spry.$$.Token.PseudoClass = function(pstr) { this.name = pstr.replace(/$.*/, ""); this.arg = pstr.replace(/^[^\($]*$?\s*|$\s*$/g, ""); this.func = Spry.$$.pseudoFuncs[this.name]; };

Spry.$$.Token.SELECTOR = 0; Spry.$$.Token.COMBINATOR = 1;

Spry.$$.Token.prototype.match = function(ele, nameAlreadyMatches) { if (this.type == Spry.$$.Token.COMBINATOR) return false; if (!nameAlreadyMatches && this.name != '*' && this.name != ele.nodeName.toLowerCase()) return false; if (this.id && this.id != ele.id) return false; var classes = this.classes; var len = classes.length; for (var i = 0; i < len; i++) { if (!ele.className || !classes[i].value.test(ele.className)) return false; }

var attrs = this.attrs; len = attrs.length; for (var i = 0; i < len; i++) { var a = attrs[i]; var an = ele.attributes.getNamedItem(a.name); if (!an || (!a.value && an.nodeValue == undefined) || (a.value && !a.value.test(an.nodeValue))) return false; }

var ps = this.pseudos; var len = ps.length; for (var i = 0; i < len; i++) { var p = ps[i]; if (p && p.func && !p.func(p.arg, ele, this)) return false; }

return true; };

Spry.$$.Token.prototype.getNodeNameIfTypeMatches = function(ele) { var nodeName = ele.nodeName.toLowerCase(); if (this.name != '*') { if (this.name != nodeName) return null; return this.name; } return nodeName; };

Spry.$$.escapeRegExpCharsRE = /\/|\.|\*|\+|$|$|\[|\]|\{|\}|\\|\|/g;

Spry.$$.tokenizeSequence = function(s) { var cc = Spry.$$.cache[s]; if (cc) return cc;

// Attribute Selector: /(\\]=]+([~\^\$\*\|]?=\s*('[^']*'|"[^"]*"|[^"'\+))?\s*\])/g // Simple Selector: /((:[^\.#:\s,>~\+\[\]]+$([^\($]+|$[^\($]*\))*\))|[\.#:]?[^\.#:\s,>~\+\[\]]+)/g // Combinator: /(\s*[\s,>~\+]\s*)/g

var tokenExpr = /(\\]=]+([~\^\$\*\|]?=\s*('[^']*'|"[^"]*"|[^"'\+))?\s*\])|((:[^\.#:\s,>~\+\[\]]+$([^\($]+|$[^\($]*\))*\))|[\.#:]?[^\.#:\s,>~\+\[\]]+)|(\s*[\s,>~\+]\s*)/g;

var tkn = new Spry.$$.Token; var sequence = []; sequence.push(tkn); var tokenSequences = []; tokenSequences.push(sequence);

s = s.replace(/^\s*|\s*$/, "");

var expMatch = tokenExpr.exec(s); while (expMatch) { var tstr = expMatch[0]; var c = tstr.charAt(0); switch (c) { case '.': tkn.classes.push(new Spry.$$.Token.Attr("class", "\\b" + tstr.substr(1) + "\\b")); break; case '#': tkn.id = tstr.substr(1); break; case ':': tkn.pseudos.push(new Spry.$$.Token.PseudoClass(tstr)); break; case '[': var attrComps = tstr.match(/\[([^\"'~\^\$\*\|\]=]+)(([~\^\$\*\|]?=)\s*('[^']*'|"[^"]*"|[^"'\]]+))?\s*\]/); var name = attrComps[1]; var matchType = attrComps[3]; var val = attrComps[4]; if (val) { val = val.replace(/^['"]|['"]$/g, ""); val = val.replace(Spry.$$.escapeRegExpCharsRE, '\\$&'); }

var matchStr = undefined;

switch(matchType) { case "=": matchStr = "^" + val + "$"; break; case "^=": matchStr = "^" + val; break; case "$=": matchStr = val + "$"; break; case "~=": case "|=": matchStr = "\\b" + val + "\\b"; break; case "*=": matchStr = val; break; }

tkn.attrs.push(new Spry.$$.Token.Attr(name, matchStr)); break; default: var combiMatch = tstr.match(/^\s*([\s,~>\+])\s*$/); if (combiMatch) { if (combiMatch[1] == ',') { sequence = new Array; tokenSequences.push(sequence); tkn = new Spry.$$.Token; sequence.push(tkn); } else { tkn = new Spry.$$.Token; tkn.type = Spry.$$.Token.COMBINATOR; tkn.name = combiMatch[1]; sequence.push(tkn); tkn = new Spry.$$.Token(); sequence.push(tkn); } } else tkn.name = tstr.toLowerCase(); break; } expMatch = tokenExpr.exec(s); }

Spry.$$.cache[s] = tokenSequences;

return tokenSequences; };

Spry.$$.combinatorFuncs = { // Element Descendant

" ": function(nodes, token) { var uid = ++Spry.$$.uniqueID; var results = []; var nn = nodes.length; for (var i = 0; i < nn; i++) { var n = nodes[i]; if (uid != n.spry$$uid) { // n.spry$$uid = uid; var ea = nodes[i].getElementsByTagName(token.name); var ne = ea.length; for (var j = 0; j < ne; j++) { var e = ea[j];

// If the token matches, add it to our results. We have // to make sure e is an element because IE6 returns the DOCTYPE // tag as a comment when '*' is used in the call to getElementsByTagName().

if (e.nodeType == 1 /* Node.ELEMENT_NODE */ && token.match(e, true)) results.push(e); e.spry$$uid = uid; } } } return results; },

// Element Child

">": function(nodes, token) { var results = []; var nn = nodes.length; for (var i = 0; i < nn; i++) { var n = nodes[i].firstChild; while (n) { if (n.nodeType == 1 /* Node.ELEMENT_NODE */ && token.match(n)) results.push(n); n = n.nextSibling; } } return results; },

// Element Immediately Preceded By

"+": function(nodes, token) { var results = []; var nn = nodes.length; for (var i = 0; i < nn; i++) { var n = nodes[i].nextSibling; while (n && n.nodeType != 1 /* Node.ELEMENT_NODE */) n = n.nextSibling; if (n && token.match(n)) results.push(n); } return results; },

// Element Preceded By

"~": function(nodes, token) { var uid = ++Spry.$$.uniqueID; var results = []; var nn = nodes.length; for (var i = 0; i < nn; i++) { var n = nodes[i].nextSibling; while (n) { if (n.nodeType == 1 /* Node.ELEMENT_NODE */) { if (uid == n.spry$$uid) break;

if (token.match(n)) { results.push(n); n.spry$$uid = uid; } } n = n.nextSibling; } } return results; } };

Spry.$$.uniqueID = 0;

Spry.$$.pseudoFuncs = { ":first-child": function(arg, node, token) { var n = node.previousSibling; while (n) { if (n.nodeType == 1) return false; // Node.ELEMENT_NODE n = n.previousSibling; }

return true; },

":last-child": function(arg, node, token) { var n = node.nextSibling; while (n) { if (n.nodeType == 1) // Node.ELEMENT_NODE return false; n = n.nextSibling; } return true; },

":empty": function(arg, node, token) { var n = node.firstChild; while (n) { switch(n.nodeType) { case 1: // Node.ELEMENT_NODE case 3: // Node.TEXT_NODE case 4: // Node.CDATA_NODE case 5: // Node.ENTITY_REFERENCE_NODE return false; } n = n.nextSibling; } return true; },

":nth-child": function(arg, node, token) { return Spry.$$.nthChild(arg, node, token); },

":nth-last-child": function(arg, node, token) { return Spry.$$.nthChild(arg, node, token, true); },

":nth-of-type": function(arg, node, token) { return Spry.$$.nthChild(arg, node, token, false, true); },

":nth-last-of-type": function(arg, node, token) { return Spry.$$.nthChild(arg, node, token, true, true); },

":first-of-type": function(arg, node, token) { var nodeName = token.getNodeNameIfTypeMatches(node); if (!nodeName) return false;

var n = node.previousSibling; while (n) { if (n.nodeType == 1 && nodeName == n.nodeName.toLowerCase()) return false; // Node.ELEMENT_NODE n = n.previousSibling; }

return true; },

":last-of-type": function(arg, node, token) { var nodeName = token.getNodeNameIfTypeMatches(node); if (!nodeName) return false;

var n = node.nextSibling; while (n) { if (n.nodeType == 1 && nodeName == n.nodeName.toLowerCase()) // Node.ELEMENT_NODE return false; n = n.nextSibling; } return true; },

":only-child": function(arg, node, token) { var f = Spry.$$.pseudoFuncs; return f[":first-child"](arg, node, token) && f[":last-child"](arg, node, token); },

":only-of-type": function(arg, node, token) { var f = Spry.$$.pseudoFuncs; return f[":first-of-type"](arg, node, token) && f[":last-of-type"](arg, node, token); },

":not": function(arg, node, token) { var s = Spry.$$.tokenizeSequence(arg)[0]; var t = s ? s[0] : null; return !t || !t.match(node); },

":enabled": function(arg, node, token) { return !node.disabled; },

":disabled": function(arg, node, token) { return node.disabled; },

":checked": function(arg, node, token) { return node.checked; },

":root": function(arg, node, token) { return node.parentNode && node.ownerDocument && node.parentNode == node.ownerDocument; } };

Spry.$$.nthRegExp = /((-|[0-9]+)?n)?([+-]?[0-9]*)/;

Spry.$$.nthCache = { "even": { a: 2, b: 0, mode: 1, invalid: false } , "odd": { a: 2, b: 1, mode: 1, invalid: false } , "2n": { a: 2, b: 0, mode: 1, invalid: false } , "2n+1": { a: 2, b: 1, mode: 1, invalid: false } };

Spry.$$.parseNthChildString = function(str) { var o = Spry.$$.nthCache[str]; if (!o) { var m = str.match(Spry.$$.nthRegExp); var n = m[1]; var a = m[2]; var b = m[3];

if (!a) { // An 'a' value was not specified. Was there an 'n' present? // If so, we treat it as an increment of 1, otherwise we're // in no-repeat mode.

a = n ? 1 : 0; } else if (a == "-") { // The string is using the "-n" short-hand which is // short for -1.

a = -1; } else { // An integer repeat value for 'a' was specified. Convert // it into number.

a = parseInt(a, 10); }

// If a 'b' value was specified, turn it into a number. // If no 'b' value was specified, default to zero.

b = b ? parseInt(b, 10) : 0;

// Figure out the mode: // // -1 - repeat backwards // 0 - no repeat // 1 - repeat forwards

var mode = (a == 0) ? 0 : ((a > 0) ? 1 : -1); var invalid = false;

// Fix up 'a' and 'b' for proper repeating.

if (a > 0 && b < 0) { b = b % a; b = ((b=(b%a)) < 0) ? a + b : b; } else if (a < 0) { if (b < 0) invalid = true; else a = Math.abs(a); }

o = new Object; o.a = a; o.b = b; o.mode = mode; o.invalid = invalid;

Spry.$$.nthCache[str] = o; }

return o; };

Spry.$$.nthChild = function(arg, node, token, fromLastSib, matchNodeName) { if (matchNodeName) { var nodeName = token.getNodeNameIfTypeMatches(node); if (!nodeName) return false; }

var o = Spry.$$.parseNthChildString(arg);

if (o.invalid) return false;

var qidProp = "spry$$ncQueryID"; var posProp = "spry$$ncPos"; var countProp = "spry$$ncCount"; if (matchNodeName) { qidProp += nodeName; posProp += nodeName; countProp += nodeName; }

var parent = node.parentNode; if (parent[qidProp] != Spry.$$.queryID) { var pos = 0; parent[qidProp] = Spry.$$.queryID; var c = parent.firstChild; while (c) { if (c.nodeType == 1 && (!matchNodeName || nodeName == c.nodeName.toLowerCase())) c[posProp] = ++pos; c = c.nextSibling; } parent[countProp] = pos; }

pos = node[posProp]; if (fromLastSib) pos = parent[countProp] - pos + 1;

/* var sib = fromLastSib ? "nextSibling" : "previousSibling";

var pos = 1; var n = node[sib]; while (n) { if (n.nodeType == 1 && (!matchNodeName || nodeName == n.nodeName.toLowerCase())) { if (n == node) break; ++pos; } n = n[sib]; }

/

if (o.mode == 0) // Exact match return pos == o.b; if (o.mode > 0) // Forward Repeat return (pos < o.b) ? false : (!((pos - o.b) % o.a)); return (pos > o.b) ? false : (!((o.b - pos) % o.a)); // Backward Repeat };

Spry.$$.processTokens = function(tokens, root) { var numTokens = tokens.length; var nodeSet = [ root ]; var combiFunc = null;

for (var i = 0; i < numTokens && nodeSet.length > 0; i++) { var t = tokens[i]; if (t.type == Spry.$$.Token.SELECTOR) { if (combiFunc) { nodeSet = combiFunc(nodeSet, t); combiFunc = null; } else nodeSet = Spry.$$.getMatchingElements(nodeSet, t); } else // Spry.$$.Token.COMBINATOR combiFunc = Spry.$$.combinatorFuncs[t.name]; } return nodeSet; };

Spry.$$.getMatchingElements = function(nodes, token) { var results = []; if (token.id) { n = nodes[0]; if (n && n.ownerDocument) { var e = n.ownerDocument.getElementById(token.id); if (e) { // XXX: We need to make sure that the element // we found is actually underneath the root // we were given!

if (token.match(e)) results.push(e); } return results; } }

var nn = nodes.length; for (var i = 0; i < nn; i++) { var n = nodes[i]; // if (token.match(n)) results.push(n);

var ea = n.getElementsByTagName(token.name); var ne = ea.length; for (var j = 0; j < ne; j++) { var e = ea[j];

// If the token matches, add it to our results. We have // to make sure e is an element because IE6 returns the DOCTYPE // tag as a comment when '*' is used in the call to getElementsByTagName().

if (e.nodeType == 1 /* Node.ELEMENT_NODE */ && token.match(e, true)) results.push(e); } } return results; };

/* Spry.$$.dumpSequences = function(sequences) {

Spry.Debug.trace("

Number of Sequences: " + sequences.length);

for (var i = 0; i < sequences.length; i++) { var str = ""; var s = sequences[i];

Spry.Debug.trace("

Sequence " + i + " -- Tokens: " + s.length);

for (var j = 0; j < s.length; j++) { var t = s[j]; if (t.type == Spry.$$.Token.SELECTOR) { str += " SELECTOR:\n Name: " + t.name + "\n ID: " + t.id + "\n Attrs:\n"; for (var k = 0; k < t.classes.length; k++) str += " " + t.classes[k].name + ": " + t.classes[k].value + "\n"; for (var k = 0; k < t.attrs.length; k++) str += " " + t.attrs[k].name + ": " + t.attrs[k].value + "\n"; str += " Pseudos:\n"; for (var k = 0; k < t.pseudos.length; k++) str += " " + t.pseudos[k].name + (t.pseudos[k].arg ? "(" + t.pseudos[k].arg + ")" : "") + "\n"; } else { str += " COMBINATOR:\n Name: '" + t.name + "'\n"; } }

Spry.Debug.trace("

" + Spry.Utils.encodeEntities(str) + "

");

} };

/

Spry.$$.addExtensions = function(a) { for (var f in Spry.$$.Results) a[f] = Spry.$$.Results[f]; };

Spry.$$.Results = {};

Spry.$$.Results.forEach = function(func) { var n = this.length; for (var i = 0; i < n; i++) func(this[i]); return this; };

Spry.$$.Results.setAttribute = function(name, value) { return this.forEach(function(n) { Spry.Utils.setAttribute(n, name, value); }); };

Spry.$$.Results.removeAttribute = function(name) { return this.forEach(function(n) { Spry.Utils.removeAttribute(n, name); }); };

Spry.$$.Results.addClassName = function(className) { return this.forEach(function(n) { Spry.Utils.addClassName(n, className); }); };

Spry.$$.Results.removeClassName = function(className) { return this.forEach(function(n) { Spry.Utils.removeClassName(n, className); }); };

Spry.$$.Results.toggleClassName = function(className) { return this.forEach(function(n) { Spry.Utils.toggleClassName(n, className); }); };

Spry.$$.Results.addEventListener = function(eventType, handler, capture, bindHandler) { return this.forEach(function(n) { Spry.Utils.addEventListener(n, eventType, handler, capture, bindHandler); }); };

Spry.$$.Results.removeEventListener = function(eventType, handler, capture) { return this.forEach(function(n) { Spry.Utils.removeEventListener(n, eventType, handler, capture); }); };

Spry.$$.Results.setStyle = function(style) { if (style) { style = Spry.Utils.styleStringToObject(style); this.forEach(function(n) { for (var p in style) try { n.style[p] = style[p]; } catch (e) {} }); } return this; };

Spry.$$.Results.setProperty = function(prop, value) { if (prop) { if (typeof prop == "string") { var p = {}; p[prop] = value; prop = p; }

this.forEach(function(n) { for (var p in prop) try { n[p] = prop[p]; } catch (e) {} }); } return this; };

})(); // EndSpryComponent