279 lines
8.6 KiB
JavaScript
279 lines
8.6 KiB
JavaScript
/*------------------------------- DEPRECATED -------------------------------*/
|
|
|
|
Hash.toQueryString = Object.toQueryString;
|
|
|
|
var Toggle = { display: Element.toggle };
|
|
|
|
Element.Methods.childOf = Element.Methods.descendantOf;
|
|
|
|
var Insertion = {
|
|
Before: function(element, content) {
|
|
return Element.insert(element, {before:content});
|
|
},
|
|
|
|
Top: function(element, content) {
|
|
return Element.insert(element, {top:content});
|
|
},
|
|
|
|
Bottom: function(element, content) {
|
|
return Element.insert(element, {bottom:content});
|
|
},
|
|
|
|
After: function(element, content) {
|
|
return Element.insert(element, {after:content});
|
|
}
|
|
};
|
|
|
|
var $continue = new Error('"throw $continue" is deprecated, use "return" instead');
|
|
|
|
// This should be moved to script.aculo.us; notice the deprecated methods
|
|
// further below, that map to the newer Element methods.
|
|
var Position = {
|
|
// set to true if needed, warning: firefox performance problems
|
|
// NOT neeeded for page scrolling, only if draggable contained in
|
|
// scrollable elements
|
|
includeScrollOffsets: false,
|
|
|
|
// must be called before calling withinIncludingScrolloffset, every time the
|
|
// page is scrolled
|
|
prepare: function() {
|
|
this.deltaX = window.pageXOffset
|
|
|| document.documentElement.scrollLeft
|
|
|| document.body.scrollLeft
|
|
|| 0;
|
|
this.deltaY = window.pageYOffset
|
|
|| document.documentElement.scrollTop
|
|
|| document.body.scrollTop
|
|
|| 0;
|
|
},
|
|
|
|
// caches x/y coordinate pair to use with overlap
|
|
within: function(element, x, y) {
|
|
if (this.includeScrollOffsets)
|
|
return this.withinIncludingScrolloffsets(element, x, y);
|
|
this.xcomp = x;
|
|
this.ycomp = y;
|
|
this.offset = Element.cumulativeOffset(element);
|
|
|
|
return (y >= this.offset[1] &&
|
|
y < this.offset[1] + element.offsetHeight &&
|
|
x >= this.offset[0] &&
|
|
x < this.offset[0] + element.offsetWidth);
|
|
},
|
|
|
|
withinIncludingScrolloffsets: function(element, x, y) {
|
|
var offsetcache = Element.cumulativeScrollOffset(element);
|
|
|
|
this.xcomp = x + offsetcache[0] - this.deltaX;
|
|
this.ycomp = y + offsetcache[1] - this.deltaY;
|
|
this.offset = Element.cumulativeOffset(element);
|
|
|
|
return (this.ycomp >= this.offset[1] &&
|
|
this.ycomp < this.offset[1] + element.offsetHeight &&
|
|
this.xcomp >= this.offset[0] &&
|
|
this.xcomp < this.offset[0] + element.offsetWidth);
|
|
},
|
|
|
|
// within must be called directly before
|
|
overlap: function(mode, element) {
|
|
if (!mode) return 0;
|
|
if (mode == 'vertical')
|
|
return ((this.offset[1] + element.offsetHeight) - this.ycomp) /
|
|
element.offsetHeight;
|
|
if (mode == 'horizontal')
|
|
return ((this.offset[0] + element.offsetWidth) - this.xcomp) /
|
|
element.offsetWidth;
|
|
},
|
|
|
|
// Deprecation layer -- use newer Element methods now (1.5.2).
|
|
|
|
cumulativeOffset: Element.Methods.cumulativeOffset,
|
|
|
|
positionedOffset: Element.Methods.positionedOffset,
|
|
|
|
absolutize: function(element) {
|
|
Position.prepare();
|
|
return Element.absolutize(element);
|
|
},
|
|
|
|
relativize: function(element) {
|
|
Position.prepare();
|
|
return Element.relativize(element);
|
|
},
|
|
|
|
realOffset: Element.Methods.cumulativeScrollOffset,
|
|
|
|
offsetParent: Element.Methods.getOffsetParent,
|
|
|
|
page: Element.Methods.viewportOffset,
|
|
|
|
clone: function(source, target, options) {
|
|
options = options || { };
|
|
return Element.clonePosition(target, source, options);
|
|
}
|
|
};
|
|
|
|
/*--------------------------------------------------------------------------*/
|
|
|
|
if (!document.getElementsByClassName) document.getElementsByClassName = function(instanceMethods){
|
|
function iter(name) {
|
|
return name.blank() ? null : "[contains(concat(' ', @class, ' '), ' " + name + " ')]";
|
|
}
|
|
|
|
instanceMethods.getElementsByClassName = Prototype.BrowserFeatures.XPath ?
|
|
function(element, className) {
|
|
className = className.toString().strip();
|
|
var cond = /\s/.test(className) ? $w(className).map(iter).join('') : iter(className);
|
|
return cond ? document._getElementsByXPath('.//*' + cond, element) : [];
|
|
} : function(element, className) {
|
|
className = className.toString().strip();
|
|
var elements = [], classNames = (/\s/.test(className) ? $w(className) : null);
|
|
if (!classNames && !className) return elements;
|
|
|
|
var nodes = $(element).getElementsByTagName('*');
|
|
className = ' ' + className + ' ';
|
|
|
|
for (var i = 0, child, cn; child = nodes[i]; i++) {
|
|
if (child.className && (cn = ' ' + child.className + ' ') && (cn.include(className) ||
|
|
(classNames && classNames.all(function(name) {
|
|
return !name.toString().blank() && cn.include(' ' + name + ' ');
|
|
}))))
|
|
elements.push(Element.extend(child));
|
|
}
|
|
return elements;
|
|
};
|
|
|
|
return function(className, parentElement) {
|
|
return $(parentElement || document.body).getElementsByClassName(className);
|
|
};
|
|
}(Element.Methods);
|
|
|
|
/*--------------------------------------------------------------------------*/
|
|
|
|
Element.ClassNames = Class.create();
|
|
Element.ClassNames.prototype = {
|
|
initialize: function(element) {
|
|
this.element = $(element);
|
|
},
|
|
|
|
_each: function(iterator) {
|
|
this.element.className.split(/\s+/).select(function(name) {
|
|
return name.length > 0;
|
|
})._each(iterator);
|
|
},
|
|
|
|
set: function(className) {
|
|
this.element.className = className;
|
|
},
|
|
|
|
add: function(classNameToAdd) {
|
|
if (this.include(classNameToAdd)) return;
|
|
this.set($A(this).concat(classNameToAdd).join(' '));
|
|
},
|
|
|
|
remove: function(classNameToRemove) {
|
|
if (!this.include(classNameToRemove)) return;
|
|
this.set($A(this).without(classNameToRemove).join(' '));
|
|
},
|
|
|
|
toString: function() {
|
|
return $A(this).join(' ');
|
|
}
|
|
};
|
|
|
|
Object.extend(Element.ClassNames.prototype, Enumerable);
|
|
|
|
/*--------------------------------------------------------------------------*/
|
|
|
|
/** deprecated, section: DOM
|
|
* class Selector
|
|
*
|
|
* A class that queries the document for elements that match a given CSS
|
|
* selector.
|
|
**/
|
|
(function() {
|
|
window.Selector = Class.create({
|
|
/** deprecated
|
|
* new Selector(expression)
|
|
* - expression (String): A CSS selector.
|
|
*
|
|
* Creates a `Selector` with the given CSS selector.
|
|
**/
|
|
initialize: function(expression) {
|
|
this.expression = expression.strip();
|
|
},
|
|
|
|
/** deprecated
|
|
* Selector#findElements(root) -> [Element...]
|
|
* - root (Element | document): A "scope" to search within. All results will
|
|
* be descendants of this node.
|
|
*
|
|
* Searches the document for elements that match the instance's CSS
|
|
* selector.
|
|
**/
|
|
findElements: function(rootElement) {
|
|
return Prototype.Selector.select(this.expression, rootElement);
|
|
},
|
|
|
|
/** deprecated
|
|
* Selector#match(element) -> Boolean
|
|
*
|
|
* Tests whether a `element` matches the instance's CSS selector.
|
|
**/
|
|
match: function(element) {
|
|
return Prototype.Selector.match(element, this.expression);
|
|
},
|
|
|
|
toString: function() {
|
|
return this.expression;
|
|
},
|
|
|
|
inspect: function() {
|
|
return "#<Selector: " + this.expression + ">";
|
|
}
|
|
});
|
|
|
|
Object.extend(Selector, {
|
|
/** deprecated
|
|
* Selector.matchElements(elements, expression) -> [Element...]
|
|
*
|
|
* Filters the given collection of elements with `expression`.
|
|
*
|
|
* The only nodes returned will be those that match the given CSS selector.
|
|
**/
|
|
matchElements: Prototype.Selector.filter,
|
|
|
|
/** deprecated
|
|
* Selector.findElement(elements, expression[, index = 0]) -> Element
|
|
* Selector.findElement(elements[, index = 0]) -> Element
|
|
*
|
|
* Returns the `index`th element in the collection that matches
|
|
* `expression`.
|
|
*
|
|
* Returns the `index`th element overall if `expression` is not given.
|
|
**/
|
|
findElement: function(elements, expression, index) {
|
|
index = index || 0;
|
|
var matchIndex = 0, element;
|
|
// Match each element individually, since Sizzle.matches does not preserve order
|
|
for (var i = 0, length = elements.length; i < length; i++) {
|
|
element = elements[i];
|
|
if (Prototype.Selector.match(element, expression) && index === matchIndex++) {
|
|
return Element.extend(element);
|
|
}
|
|
}
|
|
},
|
|
|
|
/** deprecated
|
|
* Selector.findChildElements(element, expressions) -> [Element...]
|
|
*
|
|
* Searches beneath `element` for any elements that match the selector
|
|
* (or selectors) specified in `expressions`.
|
|
**/
|
|
findChildElements: function(element, expressions) {
|
|
var selector = expressions.toArray().join(', ');
|
|
return Prototype.Selector.select(selector, element || document);
|
|
}
|
|
});
|
|
})();
|