Lines Matching refs:element
1709 function $(element) { argument
1715 if (Object.isString(element))
1716 element = document.getElementById(element);
1717 return Element.extend(element);
1770 var element = global.Element; variable
1783 Object.extend(global.Element, element || { });
1784 if (element) global.Element.prototype = element.prototype;
1791 visible: function(element) { argument
1792 return $(element).style.display != 'none';
1795 toggle: function(element) { argument
1796 element = $(element);
1797 Element[Element.visible(element) ? 'hide' : 'show'](element);
1798 return element;
1802 hide: function(element) { argument
1803 element = $(element);
1804 element.style.display = 'none';
1805 return element;
1808 show: function(element) { argument
1809 element = $(element);
1810 element.style.display = '';
1811 return element;
1814 remove: function(element) { argument
1815 element = $(element);
1816 element.parentNode.removeChild(element);
1817 return element;
1861 function update(element, content) { argument
1862 element = $(element);
1868 return element.update().insert(content);
1872 var tagName = element.tagName.toUpperCase();
1875 element.text = content;
1876 return element;
1881 while (element.firstChild) {
1882 element.removeChild(element.firstChild);
1886 element.appendChild(node)
1890 element.innerHTML = content.stripScripts();
1894 element.innerHTML = content.stripScripts();
1898 return element;
1904 replace: function(element, content) { argument
1905 element = $(element);
1909 var range = element.ownerDocument.createRange();
1910 range.selectNode(element);
1914 element.parentNode.replaceChild(content, element);
1915 return element;
1918 insert: function(element, insertions) { argument
1919 element = $(element);
1934 insert(element, content);
1941 ? element.parentNode : element).tagName.toUpperCase();
1946 childNodes.each(insert.curry(element));
1951 return element;
1954 wrap: function(element, wrapper, attributes) { argument
1955 element = $(element);
1960 if (element.parentNode)
1961 element.parentNode.replaceChild(wrapper, element);
1962 wrapper.appendChild(element);
1966 inspect: function(element) { argument
1967 element = $(element);
1968 var result = '<' + element.tagName.toLowerCase();
1971 var value = (element[property] || '').toString();
1977 recursivelyCollect: function(element, property) { argument
1978 element = $(element);
1980 while (element = element[property])
1981 if (element.nodeType == 1)
1982 elements.push(Element.extend(element));
1986 ancestors: function(element) { argument
1987 return Element.recursivelyCollect(element, 'parentNode');
1990 descendants: function(element) { argument
1991 return Element.select(element, "*");
1994 firstDescendant: function(element) { argument
1995 element = $(element).firstChild;
1996 while (element && element.nodeType != 1) element = element.nextSibling;
1997 return $(element);
2000 immediateDescendants: function(element) { argument
2001 if (!(element = $(element).firstChild)) return [];
2002 while (element && element.nodeType != 1) element = element.nextSibling;
2003 if (element) return [element].concat($(element).nextSiblings());
2007 previousSiblings: function(element) { argument
2008 return Element.recursivelyCollect(element, 'previousSibling');
2011 nextSiblings: function(element) { argument
2012 return Element.recursivelyCollect(element, 'nextSibling');
2015 siblings: function(element) { argument
2016 element = $(element);
2017 return Element.previousSiblings(element).reverse()
2018 .concat(Element.nextSiblings(element));
2021 match: function(element, selector) { argument
2024 return selector.match($(element));
2027 up: function(element, expression, index) { argument
2028 element = $(element);
2029 if (arguments.length == 1) return $(element.parentNode);
2030 var ancestors = Element.ancestors(element);
2035 down: function(element, expression, index) { argument
2036 element = $(element);
2037 if (arguments.length == 1) return Element.firstDescendant(element);
2038 return Object.isNumber(expression) ? Element.descendants(element)[expression] :
2039 Element.select(element, expression)[index || 0];
2042 previous: function(element, expression, index) { argument
2043 element = $(element);
2044 if (arguments.length == 1) return $(Selector.handlers.previousElementSibling(element));
2045 var previousSiblings = Element.previousSiblings(element);
2050 next: function(element, expression, index) { argument
2051 element = $(element);
2052 if (arguments.length == 1) return $(Selector.handlers.nextElementSibling(element));
2053 var nextSiblings = Element.nextSiblings(element);
2059 select: function(element) { argument
2061 return Selector.findChildElements(element, args);
2064 adjacent: function(element) { argument
2066 return Selector.findChildElements(element.parentNode, args).without(element);
2069 identify: function(element) { argument
2070 element = $(element);
2071 var id = Element.readAttribute(element, 'id');
2074 Element.writeAttribute(element, 'id', id);
2078 readAttribute: function(element, name) { argument
2079 element = $(element);
2082 if (t.values[name]) return t.values[name](element, name);
2085 return (!element.attributes || !element.attributes[name]) ? null :
2086 element.attributes[name].value;
2089 return element.getAttribute(name);
2092 writeAttribute: function(element, name, value) { argument
2093 element = $(element);
2102 if (t.values[attr]) name = t.values[attr](element, value);
2104 element.removeAttribute(name);
2106 element.setAttribute(name, name);
2107 else element.setAttribute(name, value);
2109 return element;
2112 getHeight: function(element) { argument
2113 return Element.getDimensions(element).height;
2116 getWidth: function(element) { argument
2117 return Element.getDimensions(element).width;
2120 classNames: function(element) { argument
2121 return new Element.ClassNames(element);
2124 hasClassName: function(element, className) { argument
2125 if (!(element = $(element))) return;
2126 var elementClassName = element.className;
2131 addClassName: function(element, className) { argument
2132 if (!(element = $(element))) return;
2133 if (!Element.hasClassName(element, className))
2134 element.className += (element.className ? ' ' : '') + className;
2135 return element;
2138 removeClassName: function(element, className) { argument
2139 if (!(element = $(element))) return;
2140 element.className = element.className.replace(
2142 return element;
2145 toggleClassName: function(element, className) { argument
2146 if (!(element = $(element))) return;
2147 return Element[Element.hasClassName(element, className) ?
2148 'removeClassName' : 'addClassName'](element, className);
2151 cleanWhitespace: function(element) { argument
2152 element = $(element);
2153 var node = element.firstChild;
2157 element.removeChild(node);
2160 return element;
2163 empty: function(element) { argument
2164 return $(element).innerHTML.blank();
2167 descendantOf: function(element, ancestor) { argument
2168 element = $(element), ancestor = $(ancestor);
2170 if (element.compareDocumentPosition)
2171 return (element.compareDocumentPosition(ancestor) & 8) === 8;
2174 return ancestor.contains(element) && ancestor !== element;
2176 while (element = element.parentNode)
2177 if (element == ancestor) return true;
2182 scrollTo: function(element) { argument
2183 element = $(element);
2184 var pos = Element.cumulativeOffset(element);
2186 return element;
2189 getStyle: function(element, style) { argument
2190 element = $(element);
2192 var value = element.style[style];
2194 var css = document.defaultView.getComputedStyle(element, null);
2201 getOpacity: function(element) { argument
2202 return $(element).getStyle('opacity');
2205 setStyle: function(element, styles) { argument
2206 element = $(element);
2207 var elementStyle = element.style, match;
2209 element.style.cssText += ';' + styles;
2211 element.setOpacity(styles.match(/opacity:\s*(\d?\.?\d*)/)[1]) : element;
2214 if (property == 'opacity') element.setOpacity(styles[property]);
2220 return element;
2223 setOpacity: function(element, value) {
2224 element = $(element);
2225 element.style.opacity = (value == 1 || value === '') ? '' :
2227 return element;
2230 getDimensions: function(element) {
2231 element = $(element);
2232 var display = Element.getStyle(element, 'display');
2234 return {width: element.offsetWidth, height: element.offsetHeight};
2236 var els = element.style;
2244 var originalWidth = element.clientWidth;
2245 var originalHeight = element.clientHeight;
2252 makePositioned: function(element) {
2253 element = $(element);
2254 var pos = Element.getStyle(element, 'position');
2256 element._madePositioned = true;
2257 element.style.position = 'relative';
2259 element.style.top = 0;
2260 element.style.left = 0;
2263 return element;
2266 undoPositioned: function(element) {
2267 element = $(element);
2268 if (element._madePositioned) {
2269 element._madePositioned = undefined;
2270 element.style.position =
2271 element.style.top =
2272 element.style.left =
2273 element.style.bottom =
2274 element.style.right = '';
2276 return element;
2279 makeClipping: function(element) {
2280 element = $(element);
2281 if (element._overflow) return element;
2282 element._overflow = Element.getStyle(element, 'overflow') || 'auto';
2283 if (element._overflow !== 'hidden')
2284 element.style.overflow = 'hidden';
2285 return element;
2288 undoClipping: function(element) {
2289 element = $(element);
2290 if (!element._overflow) return element;
2291 element.style.overflow = element._overflow == 'auto' ? '' : element._overflow;
2292 element._overflow = null;
2293 return element;
2296 cumulativeOffset: function(element) {
2299 valueT += element.offsetTop || 0;
2300 valueL += element.offsetLeft || 0;
2301 element = element.offsetParent;
2302 } while (element);
2306 positionedOffset: function(element) {
2309 valueT += element.offsetTop || 0;
2310 valueL += element.offsetLeft || 0;
2311 element = element.offsetParent;
2312 if (element) {
2313 if (element.tagName.toUpperCase() == 'BODY') break;
2314 var p = Element.getStyle(element, 'position');
2317 } while (element);
2321 absolutize: function(element) {
2322 element = $(element);
2323 if (Element.getStyle(element, 'position') == 'absolute') return element;
2325 var offsets = Element.positionedOffset(element);
2328 var width = element.clientWidth;
2329 var height = element.clientHeight;
2331 element._originalLeft = left - parseFloat(element.style.left || 0);
2332 element._originalTop = top - parseFloat(element.style.top || 0);
2333 element._originalWidth = element.style.width;
2334 element._originalHeight = element.style.height;
2336 element.style.position = 'absolute';
2337 element.style.top = top + 'px';
2338 element.style.left = left + 'px';
2339 element.style.width = width + 'px';
2340 element.style.height = height + 'px';
2341 return element;
2344 relativize: function(element) {
2345 element = $(element);
2346 if (Element.getStyle(element, 'position') == 'relative') return element;
2348 element.style.position = 'relative';
2349 var top = parseFloat(element.style.top || 0) - (element._originalTop || 0);
2350 var left = parseFloat(element.style.left || 0) - (element._originalLeft || 0);
2352 element.style.top = top + 'px';
2353 element.style.left = left + 'px';
2354 element.style.height = element._originalHeight;
2355 element.style.width = element._originalWidth;
2356 return element;
2359 cumulativeScrollOffset: function(element) {
2362 valueT += element.scrollTop || 0;
2363 valueL += element.scrollLeft || 0;
2364 element = element.parentNode;
2365 } while (element);
2369 getOffsetParent: function(element) {
2370 if (element.offsetParent) return $(element.offsetParent);
2371 if (element == document.body) return $(element);
2373 while ((element = element.parentNode) && element != document.body)
2374 if (Element.getStyle(element, 'position') != 'static')
2375 return $(element);
2383 var element = forElement; variable
2385 valueT += element.offsetTop || 0;
2386 valueL += element.offsetLeft || 0;
2388 if (element.offsetParent == document.body &&
2389 Element.getStyle(element, 'position') == 'absolute') break;
2391 } while (element = element.offsetParent);
2393 element = forElement;
2395 … if (!Prototype.Browser.Opera || (element.tagName && (element.tagName.toUpperCase() == 'BODY'))) {
2396 valueT -= element.scrollTop || 0;
2397 valueL -= element.scrollLeft || 0;
2399 } while (element = element.parentNode);
2404 clonePosition: function(element, source) {
2417 element = $(element);
2420 if (Element.getStyle(element, 'position') == 'absolute') {
2421 parent = Element.getOffsetParent(element);
2430 if (options.setLeft) element.style.left = (p[0] - delta[0] + options.offsetLeft) + 'px';
2431 if (options.setTop) element.style.top = (p[1] - delta[1] + options.offsetTop) + 'px';
2432 if (options.setWidth) element.style.width = source.offsetWidth + 'px';
2433 if (options.setHeight) element.style.height = source.offsetHeight + 'px';
2434 return element;
2456 function(proceed, element, style) { argument
2459 if (proceed(element, 'position') === 'static') return null;
2461 if (!Element.visible(element)) return null;
2463 var dim = parseInt(proceed(element, style), 10);
2465 if (dim !== element['offset' + style.capitalize()])
2478 var val = proceed(element, property);
2481 default: return proceed(element, style);
2487 function(proceed, element, attribute) { argument
2488 if (attribute === 'title') return element.title;
2489 return proceed(element, attribute);
2496 function(proceed, element) { argument
2497 element = $(element);
2498 try { element.offsetParent }
2500 var position = element.getStyle('position');
2501 if (position !== 'static') return proceed(element);
2502 element.setStyle({ position: 'relative' });
2503 var value = proceed(element);
2504 element.setStyle({ position: position });
2511 function(proceed, element) { argument
2512 element = $(element);
2513 try { element.offsetParent }
2515 var position = element.getStyle('position');
2516 if (position !== 'static') return proceed(element);
2517 var offsetParent = element.getOffsetParent();
2520 element.setStyle({ position: 'relative' });
2521 var value = proceed(element);
2522 element.setStyle({ position: position });
2529 function(proceed, element) { argument
2530 try { element.offsetParent }
2532 return proceed(element);
2536 Element.Methods.getStyle = function(element, style) { argument
2537 element = $(element);
2539 var value = element.style[style];
2540 if (!value && element.currentStyle) value = element.currentStyle[style];
2543 if (value = (element.getStyle('filter') || '').match(/alpha\(opacity=(.*)\)/))
2549 if ((style == 'width' || style == 'height') && (element.getStyle('display') != 'none'))
2550 return element['offset' + style.capitalize()] + 'px';
2556 Element.Methods.setOpacity = function(element, value) { argument
2560 element = $(element);
2561 var currentStyle = element.currentStyle;
2563 (!currentStyle && element.style.zoom == 'normal'))
2564 element.style.zoom = 1;
2566 var filter = element.getStyle('filter'), style = element.style;
2570 return element;
2574 return element;
2613 _getAttr: function(element, attribute) {
2614 return element.getAttribute(attribute);
2616 _getAttr2: function(element, attribute) {
2617 return element.getAttribute(attribute, 2);
2619 _getAttrNode: function(element, attribute) {
2620 var node = element.getAttributeNode(attribute);
2631 f = function(element, attribute) { argument
2632 attribute = element.getAttribute(attribute);
2641 f = function(element, attribute) {
2642 attribute = element.getAttribute(attribute);
2650 _flag: function(element, attribute) {
2651 return $(element).hasAttribute(attribute) ? attribute : null;
2653 style: function(element) {
2654 return element.style.cssText.toLowerCase();
2656 title: function(element) {
2657 return element.title;
2670 checked: function(element, value) { argument
2671 element.checked = !!value;
2674 style: function(element, value) { argument
2675 element.style.cssText = value ? value : '';
2721 function _descendants(element) { argument
2722 var nodes = element.getElementsByTagName('*'), results = [];
2729 Element.Methods.down = function(element, expression, index) { argument
2730 element = $(element);
2731 if (arguments.length == 1) return element.firstDescendant();
2732 return Object.isNumber(expression) ? _descendants(element)[expression] :
2733 Element.select(element, expression)[index || 0];
2741 Element.Methods.setOpacity = function(element, value) {
2742 element = $(element);
2743 element.style.opacity = (value == 1) ? 0.999999 :
2745 return element;
2750 Element.Methods.setOpacity = function(element, value) {
2751 element = $(element);
2752 element.style.opacity = (value == 1 || value === '') ? '' :
2756 if(element.tagName.toUpperCase() == 'IMG' && element.width) {
2757 element.width++; element.width--;
2760 element.appendChild(n);
2761 element.removeChild(n);
2764 return element;
2767 Element.Methods.cumulativeOffset = function(element) { argument
2770 valueT += element.offsetTop || 0;
2771 valueL += element.offsetLeft || 0;
2772 if (element.offsetParent == document.body)
2773 if (Element.getStyle(element, 'position') == 'absolute') break;
2775 element = element.offsetParent;
2776 } while (element);
2783 Element.Methods.replace = function(element, content) { argument
2784 element = $(element);
2788 element.parentNode.replaceChild(content, element);
2789 return element;
2793 var parent = element.parentNode, tagName = parent.tagName.toUpperCase();
2796 var nextSibling = element.next();
2798 parent.removeChild(element);
2804 else element.outerHTML = content.stripScripts();
2807 return element;
2828 before: function(element, node) { argument
2829 element.parentNode.insertBefore(node, element);
2831 top: function(element, node) { argument
2832 element.insertBefore(node, element.firstChild);
2834 bottom: function(element, node) { argument
2835 element.appendChild(node);
2837 after: function(element, node) { argument
2838 element.parentNode.insertBefore(node, element.nextSibling);
2859 hasAttribute: function(element, attribute) { argument
2861 var node = $(element).getAttributeNode(attribute);
2900 function extendElementWith(element, methods) { argument
2903 if (Object.isFunction(value) && !(property in element))
2904 element[property] = value.methodize();
2912 return function(element) { argument
2913 if (element && typeof element._extendedByPrototype == 'undefined') {
2914 var t = element.tagName;
2916 extendElementWith(element, Element.Methods);
2917 extendElementWith(element, Element.Methods.Simulated);
2918 extendElementWith(element, Element.Methods.ByTag[t.toUpperCase()]);
2921 return element;
2929 var extend = Object.extend(function(element) { argument
2930 if (!element || typeof element._extendedByPrototype != 'undefined' ||
2931 element.nodeType != 1 || element == window) return element;
2934 tagName = element.tagName.toUpperCase();
2938 extendElementWith(element, methods);
2940 element._extendedByPrototype = Prototype.emptyFunction;
2941 return element;
2956 Element.hasAttribute = function(element, attribute) { argument
2957 if (element.hasAttribute) return element.hasAttribute(attribute);
2958 return Element.Methods.Simulated.hasAttribute(element, attribute);
3023 var element = document.createElement(tagName);
3024 var proto = element['__proto__'] || element.constructor.prototype;
3025 element = null;
3067 var B = Prototype.Browser, doc = document, element, property = {}; variable
3080 if (!element) element = getRootElement();
3084 viewport['get' + D] = function() { return element[property[D]] };
3099 getStorage: function(element) { argument
3100 if (!(element = $(element))) return;
3103 if (element === window) {
3106 if (typeof element._prototypeUID === "undefined")
3107 element._prototypeUID = [Element.Storage.UID++];
3108 uid = element._prototypeUID[0];
3117 store: function(element, key, value) { argument
3118 if (!(element = $(element))) return;
3121 Element.getStorage(element).update(key);
3123 Element.getStorage(element).set(key, value);
3126 return element;
3129 retrieve: function(element, key, defaultValue) { argument
3130 if (!(element = $(element))) return;
3131 var hash = Element.getStorage(element), value = hash.get(key);
3141 clone: function(element, deep) { argument
3142 if (!(element = $(element))) return;
3143 var clone = element.cloneNode(deep);
3310 match: function(element) { argument
3326 return this.findElements(document).include(element);
3335 if (!Selector.assertions[name](element, matches)) {
3507 tagName: function(element, matches) { argument
3508 return matches[1].toUpperCase() == element.tagName.toUpperCase();
3511 className: function(element, matches) { argument
3512 return Element.hasClassName(element, matches[1]);
3515 id: function(element, matches) { argument
3516 return element.id === matches[1];
3519 attrPresence: function(element, matches) { argument
3520 return Element.hasAttribute(element, matches[1]);
3523 attr: function(element, matches) { argument
3524 var nodeValue = Element.readAttribute(element, matches[1]);
3879 for (var i = 0, results = [], element; element = elements[i]; i++)
3880 if (element._countedByPrototype) results.push(element);
3892 findChildElements: function(element, expressions) { argument
3897 h.concat(results, selector.findElements(element));
3929 var data = elements.inject({ }, function(result, element) { argument
3930 if (!element.disabled && element.name) {
3931 key = element.name; value = $(element).getValue();
3932 if (value != null && element.type != 'file' && (element.type != 'submit' || (!submitted &&
3955 element,
3958 for (var i = 0; element = elements[i]; i++) {
3959 arr.push(element);
3997 var elements = $(form).getElements().findAll(function(element) { argument
3998 return 'hidden' != element.type && !element.disabled;
4000 var firstByIndex = elements.findAll(function(element) { argument
4001 return element.hasAttribute('tabIndex') && element.tabIndex >= 0;
4002 }).sortBy(function(element) { return element.tabIndex }).first(); argument
4004 return firstByIndex ? firstByIndex : elements.find(function(element) { argument
4005 return /^(?:input|select|textarea)$/i.test(element.tagName);
4038 focus: function(element) { argument
4039 $(element).focus();
4040 return element;
4043 select: function(element) { argument
4044 $(element).select();
4045 return element;
4051 serialize: function(element) { argument
4052 element = $(element);
4053 if (!element.disabled && element.name) {
4054 var value = element.getValue();
4057 pair[element.name] = value;
4064 getValue: function(element) { argument
4065 element = $(element);
4066 var method = element.tagName.toLowerCase();
4067 return Form.Element.Serializers[method](element);
4070 setValue: function(element, value) { argument
4071 element = $(element);
4072 var method = element.tagName.toLowerCase();
4073 Form.Element.Serializers[method](element, value);
4074 return element;
4077 clear: function(element) { argument
4078 $(element).value = '';
4079 return element;
4082 present: function(element) { argument
4083 return $(element).value != '';
4086 activate: function(element) { argument
4087 element = $(element);
4089 element.focus();
4090 if (element.select && (element.tagName.toLowerCase() != 'input' ||
4091 !(/^(?:button|reset|submit)$/i.test(element.type))))
4092 element.select();
4094 return element;
4097 disable: function(element) { argument
4098 element = $(element);
4099 element.disabled = true;
4100 return element;
4103 enable: function(element) { argument
4104 element = $(element);
4105 element.disabled = false;
4106 return element;
4119 input: function(element, value) { argument
4120 switch (element.type.toLowerCase()) {
4123 return Form.Element.Serializers.inputSelector(element, value);
4125 return Form.Element.Serializers.textarea(element, value);
4129 inputSelector: function(element, value) { argument
4130 if (Object.isUndefined(value)) return element.checked ? element.value : null;
4131 else element.checked = !!value;
4134 textarea: function(element, value) { argument
4135 if (Object.isUndefined(value)) return element.value;
4136 else element.value = value;
4139 select: function(element, value) { argument
4141 return this[element.type == 'select-one' ?
4142 'selectOne' : 'selectMany'](element);
4145 for (var i = 0, length = element.length; i < length; i++) {
4146 opt = element.options[i];
4159 selectOne: function(element) { argument
4160 var index = element.selectedIndex;
4161 return index >= 0 ? this.optionValue(element.options[index]) : null;
4164 selectMany: function(element) { argument
4165 var values, length = element.length;
4169 var opt = element.options[i];
4184 initialize: function($super, element, frequency, callback) { argument
4186 this.element = $(element);
4194 this.callback(this.element, value);
4202 return Form.Element.getValue(this.element);
4208 return Form.serialize(this.element);
4215 initialize: function(element, callback) { argument
4216 this.element = $(element);
4220 if (this.element.tagName.toLowerCase() == 'form')
4223 this.registerCallback(this.element);
4229 this.callback(this.element, value);
4235 Form.getElements(this.element).each(this.registerCallback, this);
4238 registerCallback: function(element) { argument
4239 if (element.type) {
4240 switch (element.type.toLowerCase()) {
4243 Event.observe(element, 'click', this.onElementEvent.bind(this));
4246 Event.observe(element, 'change', this.onElementEvent.bind(this));
4255 return Form.Element.getValue(this.element);
4261 return Form.serialize(this.element);
4315 function element(event) { function
4335 var element = Event.element(event);
4336 if (!expression) return element;
4337 var elements = [element].concat(element.ancestors());
4377 element: element, property in Event.Methods
4395 var element;
4397 case 'mouseover': element = event.fromElement; break;
4398 case 'mouseout': element = event.toElement; break;
4401 return Element.extend(element);
4410 Event.extend = function(event, element) { argument
4418 target: event.srcElement || element,
4432 function _createResponder(element, eventName, handler) { argument
4433 var registry = Element.retrieve(element, 'prototype_event_registry');
4436 CACHE.push(element);
4437 registry = Element.retrieve(element, 'prototype_event_registry', $H());
4457 Event.extend(event, element);
4458 handler.call(element, event);
4465 Event.extend(event, element);
4468 while (parent && parent !== element) {
4470 catch(e) { parent = element; }
4473 if (parent === element) return;
4475 handler.call(element, event);
4480 Event.extend(event, element);
4481 handler.call(element, event);
4516 function observe(element, eventName, handler) { argument
4517 element = $(element);
4519 var responder = _createResponder(element, eventName, handler);
4521 if (!responder) return element;
4524 if (element.addEventListener)
4525 element.addEventListener("dataavailable", responder, false);
4527 element.attachEvent("ondataavailable", responder);
4528 element.attachEvent("onfilterchange", responder);
4533 if (element.addEventListener)
4534 element.addEventListener(actualEventName, responder, false);
4536 element.attachEvent("on" + actualEventName, responder);
4539 return element;
4542 function stopObserving(element, eventName, handler) { argument
4543 element = $(element);
4545 var registry = Element.retrieve(element, 'prototype_event_registry');
4547 if (Object.isUndefined(registry)) return element;
4552 if (Object.isUndefined(responders)) return element;
4555 Element.stopObserving(element, eventName, r.handler);
4557 return element;
4563 Element.stopObserving(element, eventName, r.handler);
4566 return element;
4574 if (!responder) return element;
4579 if (element.removeEventListener)
4580 element.removeEventListener("dataavailable", responder, false);
4582 element.detachEvent("ondataavailable", responder);
4583 element.detachEvent("onfilterchange", responder);
4586 if (element.removeEventListener)
4587 element.removeEventListener(actualEventName, responder, false);
4589 element.detachEvent('on' + actualEventName, responder);
4594 return element;
4597 function fire(element, eventName, memo, bubble) { argument
4598 element = $(element);
4603 if (element == document && document.createEvent && !element.dispatchEvent)
4604 element = document.documentElement;
4620 element.dispatchEvent(event);
4622 element.fireEvent(event.eventType, event);
4710 Before: function(element, content) { argument
4711 return Element.insert(element, {before:content});
4714 Top: function(element, content) { argument
4715 return Element.insert(element, {top:content});
4718 Bottom: function(element, content) { argument
4719 return Element.insert(element, {bottom:content});
4722 After: function(element, content) { argument
4723 return Element.insert(element, {after:content});
4743 within: function(element, x, y) { argument
4745 return this.withinIncludingScrolloffsets(element, x, y);
4748 this.offset = Element.cumulativeOffset(element);
4751 y < this.offset[1] + element.offsetHeight &&
4753 x < this.offset[0] + element.offsetWidth);
4756 withinIncludingScrolloffsets: function(element, x, y) { argument
4757 var offsetcache = Element.cumulativeScrollOffset(element);
4761 this.offset = Element.cumulativeOffset(element);
4764 this.ycomp < this.offset[1] + element.offsetHeight &&
4766 this.xcomp < this.offset[0] + element.offsetWidth);
4769 overlap: function(mode, element) { argument
4772 return ((this.offset[1] + element.offsetHeight) - this.ycomp) /
4773 element.offsetHeight;
4775 return ((this.offset[0] + element.offsetWidth) - this.xcomp) /
4776 element.offsetWidth;
4784 absolutize: function(element) { argument
4786 return Element.absolutize(element);
4789 relativize: function(element) { argument
4791 return Element.relativize(element);
4814 function(element, className) {
4817 return cond ? document._getElementsByXPath('.//*' + cond, element) : [];
4818 } : function(element, className) {
4823 var nodes = $(element).getElementsByTagName('*');
4845 initialize: function(element) { argument
4846 this.element = $(element);
4850 this.element.className.split(/\s+/).select(function(name) {
4856 this.element.className = className;