// SpryDOMUtils.js - version 0.6 - Spry Pre-Release 1.6.1
//
// 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.
var Spry; if (!Spry) 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.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
ele.setAttribute(name, value);
};
Spry.Utils.removeAttribute = function(ele, name)
{
ele = Spry.$(ele);
if (!ele || !name)
return;
try
{
ele.removeAttribute(name);
// 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.
//
// XXX: We should add a check for IE here instead of doing
// it for every browser.
if (name == "class")
ele.removeAttribute("className");
} catch(e) {}
};
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)
{
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.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.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)
{
if (!rootNode)
rootNode = document;
else
rootNode = Spry.$(rootNode);
var sequences = Spry.$$.tokenizeSequence(selectorSequence);
var matches = [];
Spry.$$.addExtensions(matches);
++Spry.$$.queryID;
var nid = 0;
var ns = sequences.length;
for (var i = 0; i < ns; i++)
{
var m = Spry.$$.processTokens(sequences[i], rootNode);
var nm = m.length;
for (var j = 0; j < nm; j++)
{
var n = m[j];
if (!n.spry$$ID)
{
n.spry$$ID = ++nid;
matches.push(n);
}
}
}
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 (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 (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;
};