var Spry; if (!Spry) Spry = {}; if (!Spry.Utils) Spry.Utils = {};
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;
};
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);
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.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;
};
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.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.$$.uniqueID = 0;
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.$$.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;
};