Lines Matching refs:element

1818 function $(element) {  argument
1824 if (Object.isString(element))
1825 element = document.getElementById(element);
1826 return Element.extend(element);
1880 var element = global.Element; variable
1901 Object.extend(global.Element, element || { });
1902 if (element) global.Element.prototype = element.prototype;
1909 Element._purgeElement = function(element) { argument
1910 var uid = element._prototypeUID;
1912 Element.stopObserving(element);
1913 element._prototypeUID = void 0;
1919 visible: function(element) { argument
1920 return $(element).style.display != 'none';
1923 toggle: function(element) { argument
1924 element = $(element);
1925 Element[Element.visible(element) ? 'hide' : 'show'](element);
1926 return element;
1929 hide: function(element) { argument
1930 element = $(element);
1931 element.style.display = 'none';
1932 return element;
1935 show: function(element) { argument
1936 element = $(element);
1937 element.style.display = '';
1938 return element;
1941 remove: function(element) { argument
1942 element = $(element);
1943 element.parentNode.removeChild(element);
1944 return element;
2004 function update(element, content) { argument
2005 element = $(element);
2008 var descendants = element.getElementsByTagName('*'),
2016 return element.update().insert(content);
2020 var tagName = element.tagName.toUpperCase();
2023 element.text = content;
2024 return element;
2029 while (element.firstChild) {
2030 element.removeChild(element.firstChild);
2034 element.appendChild(node)
2037 while (element.firstChild) {
2038 element.removeChild(element.firstChild);
2041 nodes.each(function(node) { element.appendChild(node) });
2044 element.innerHTML = content.stripScripts();
2048 element.innerHTML = content.stripScripts();
2052 return element;
2058 replace: function(element, content) { argument
2059 element = $(element);
2063 var range = element.ownerDocument.createRange();
2064 range.selectNode(element);
2068 element.parentNode.replaceChild(content, element);
2069 return element;
2072 insert: function(element, insertions) { argument
2073 element = $(element);
2088 insert(element, content);
2095 ? element.parentNode : element).tagName.toUpperCase();
2100 childNodes.each(insert.curry(element));
2105 return element;
2108 wrap: function(element, wrapper, attributes) { argument
2109 element = $(element);
2114 if (element.parentNode)
2115 element.parentNode.replaceChild(wrapper, element);
2116 wrapper.appendChild(element);
2120 inspect: function(element) { argument
2121 element = $(element);
2122 var result = '<' + element.tagName.toLowerCase();
2126 value = (element[property] || '').toString();
2132 recursivelyCollect: function(element, property, maximumLength) { argument
2133 element = $(element);
2137 while (element = element[property]) {
2138 if (element.nodeType == 1)
2139 elements.push(Element.extend(element));
2147 ancestors: function(element) { argument
2148 return Element.recursivelyCollect(element, 'parentNode');
2151 descendants: function(element) { argument
2152 return Element.select(element, "*");
2155 firstDescendant: function(element) { argument
2156 element = $(element).firstChild;
2157 while (element && element.nodeType != 1) element = element.nextSibling;
2158 return $(element);
2161 immediateDescendants: function(element) { argument
2162 var results = [], child = $(element).firstChild;
2172 previousSiblings: function(element, maximumLength) { argument
2173 return Element.recursivelyCollect(element, 'previousSibling');
2176 nextSiblings: function(element) { argument
2177 return Element.recursivelyCollect(element, 'nextSibling');
2180 siblings: function(element) { argument
2181 element = $(element);
2182 return Element.previousSiblings(element).reverse()
2183 .concat(Element.nextSiblings(element));
2186 match: function(element, selector) { argument
2187 element = $(element);
2189 return Prototype.Selector.match(element, selector);
2190 return selector.match(element);
2193 up: function(element, expression, index) { argument
2194 element = $(element);
2195 if (arguments.length == 1) return $(element.parentNode);
2196 var ancestors = Element.ancestors(element);
2201 down: function(element, expression, index) { argument
2202 element = $(element);
2203 if (arguments.length == 1) return Element.firstDescendant(element);
2204 return Object.isNumber(expression) ? Element.descendants(element)[expression] :
2205 Element.select(element, expression)[index || 0];
2208 previous: function(element, expression, index) { argument
2209 element = $(element);
2214 return Prototype.Selector.find(element.previousSiblings(), expression, index);
2216 return element.recursivelyCollect("previousSibling", index + 1)[index];
2220 next: function(element, expression, index) { argument
2221 element = $(element);
2226 return Prototype.Selector.find(element.nextSiblings(), expression, index);
2229 return element.recursivelyCollect("nextSibling", index + 1)[index];
2234 select: function(element) { argument
2235 element = $(element);
2237 return Prototype.Selector.select(expressions, element);
2240 adjacent: function(element) { argument
2241 element = $(element);
2243 return Prototype.Selector.select(expressions, element.parentNode).without(element);
2246 identify: function(element) { argument
2247 element = $(element);
2248 var id = Element.readAttribute(element, 'id');
2251 Element.writeAttribute(element, 'id', id);
2255 readAttribute: function(element, name) { argument
2256 element = $(element);
2259 if (t.values[name]) return t.values[name](element, name);
2262 return (!element.attributes || !element.attributes[name]) ? null :
2263 element.attributes[name].value;
2266 return element.getAttribute(name);
2269 writeAttribute: function(element, name, value) { argument
2270 element = $(element);
2279 if (t.values[attr]) name = t.values[attr](element, value);
2281 element.removeAttribute(name);
2283 element.setAttribute(name, name);
2284 else element.setAttribute(name, value);
2286 return element;
2289 getHeight: function(element) { argument
2290 return Element.getDimensions(element).height;
2293 getWidth: function(element) { argument
2294 return Element.getDimensions(element).width;
2297 classNames: function(element) { argument
2298 return new Element.ClassNames(element);
2301 hasClassName: function(element, className) { argument
2302 if (!(element = $(element))) return;
2303 var elementClassName = element.className;
2308 addClassName: function(element, className) { argument
2309 if (!(element = $(element))) return;
2310 if (!Element.hasClassName(element, className))
2311 element.className += (element.className ? ' ' : '') + className;
2312 return element;
2315 removeClassName: function(element, className) { argument
2316 if (!(element = $(element))) return;
2317 element.className = element.className.replace(
2319 return element;
2322 toggleClassName: function(element, className) { argument
2323 if (!(element = $(element))) return;
2324 return Element[Element.hasClassName(element, className) ?
2325 'removeClassName' : 'addClassName'](element, className);
2328 cleanWhitespace: function(element) { argument
2329 element = $(element);
2330 var node = element.firstChild;
2334 element.removeChild(node);
2337 return element;
2340 empty: function(element) { argument
2341 return $(element).innerHTML.blank();
2344 descendantOf: function(element, ancestor) { argument
2345 element = $(element), ancestor = $(ancestor);
2347 if (element.compareDocumentPosition)
2348 return (element.compareDocumentPosition(ancestor) & 8) === 8;
2351 return ancestor.contains(element) && ancestor !== element;
2353 while (element = element.parentNode)
2354 if (element == ancestor) return true;
2359 scrollTo: function(element) { argument
2360 element = $(element);
2361 var pos = Element.cumulativeOffset(element);
2363 return element;
2366 getStyle: function(element, style) { argument
2367 element = $(element);
2369 var value = element.style[style];
2371 var css = document.defaultView.getComputedStyle(element, null);
2378 getOpacity: function(element) { argument
2379 return $(element).getStyle('opacity');
2382 setStyle: function(element, styles) { argument
2383 element = $(element);
2384 var elementStyle = element.style, match;
2386 element.style.cssText += ';' + styles;
2388 element.setOpacity(styles.match(/opacity:\s*(\d?\.?\d*)/)[1]) : element;
2391 if (property == 'opacity') element.setOpacity(styles[property]);
2397 return element;
2400 setOpacity: function(element, value) {
2401 element = $(element);
2402 element.style.opacity = (value == 1 || value === '') ? '' :
2404 return element;
2407 makePositioned: function(element) {
2408 element = $(element);
2409 var pos = Element.getStyle(element, 'position');
2411 element._madePositioned = true;
2412 element.style.position = 'relative';
2414 element.style.top = 0;
2415 element.style.left = 0;
2418 return element;
2421 undoPositioned: function(element) {
2422 element = $(element);
2423 if (element._madePositioned) {
2424 element._madePositioned = undefined;
2425 element.style.position =
2426 element.style.top =
2427 element.style.left =
2428 element.style.bottom =
2429 element.style.right = '';
2431 return element;
2434 makeClipping: function(element) {
2435 element = $(element);
2436 if (element._overflow) return element;
2437 element._overflow = Element.getStyle(element, 'overflow') || 'auto';
2438 if (element._overflow !== 'hidden')
2439 element.style.overflow = 'hidden';
2440 return element;
2443 undoClipping: function(element) {
2444 element = $(element);
2445 if (!element._overflow) return element;
2446 element.style.overflow = element._overflow == 'auto' ? '' : element._overflow;
2447 element._overflow = null;
2448 return element;
2451 clonePosition: function(element, source) {
2464 element = $(element);
2466 if (Element.getStyle(element, 'position') == 'absolute') {
2467 parent = Element.getOffsetParent(element);
2476 if (options.setLeft) element.style.left = (p[0] - delta[0] + options.offsetLeft) + 'px';
2477 if (options.setTop) element.style.top = (p[1] - delta[1] + options.offsetTop) + 'px';
2478 if (options.setWidth) element.style.width = source.offsetWidth + 'px';
2479 if (options.setHeight) element.style.height = source.offsetHeight + 'px';
2480 return element;
2502 function(proceed, element, style) { argument
2505 if (!Element.visible(element)) return null;
2507 var dim = parseInt(proceed(element, style), 10);
2509 if (dim !== element['offset' + style.capitalize()])
2522 var val = proceed(element, property);
2525 default: return proceed(element, style);
2531 function(proceed, element, attribute) { argument
2532 if (attribute === 'title') return element.title;
2533 return proceed(element, attribute);
2539 Element.Methods.getStyle = function(element, style) { argument
2540 element = $(element);
2542 var value = element.style[style];
2543 if (!value && element.currentStyle) value = element.currentStyle[style];
2546 if (value = (element.getStyle('filter') || '').match(/alpha\(opacity=(.*)\)/))
2552 if ((style == 'width' || style == 'height') && (element.getStyle('display') != 'none'))
2553 return element['offset' + style.capitalize()] + 'px';
2559 Element.Methods.setOpacity = function(element, value) { argument
2563 element = $(element);
2564 var currentStyle = element.currentStyle;
2566 (!currentStyle && element.style.zoom == 'normal'))
2567 element.style.zoom = 1;
2569 var filter = element.getStyle('filter'), style = element.style;
2573 return element;
2577 return element;
2615 _getAttr: function(element, attribute) {
2616 return element.getAttribute(attribute);
2618 _getAttr2: function(element, attribute) {
2619 return element.getAttribute(attribute, 2);
2621 _getAttrNode: function(element, attribute) {
2622 var node = element.getAttributeNode(attribute);
2632 f = function(element, attribute) { argument
2633 attribute = element.getAttribute(attribute);
2642 f = function(element, attribute) { argument
2643 attribute = element.getAttribute(attribute);
2651 _flag: function(element, attribute) {
2652 return $(element).hasAttribute(attribute) ? attribute : null;
2654 style: function(element) {
2655 return element.style.cssText.toLowerCase();
2657 title: function(element) {
2658 return element.title;
2671 checked: function(element, value) { argument
2672 element.checked = !!value;
2675 style: function(element, value) { argument
2676 element.style.cssText = value ? value : '';
2722 function _descendants(element) { argument
2723 var nodes = element.getElementsByTagName('*'), results = [];
2730 Element.Methods.down = function(element, expression, index) { argument
2731 element = $(element);
2732 if (arguments.length == 1) return element.firstDescendant();
2733 return Object.isNumber(expression) ? _descendants(element)[expression] :
2734 Element.select(element, expression)[index || 0];
2742 Element.Methods.setOpacity = function(element, value) {
2743 element = $(element);
2744 element.style.opacity = (value == 1) ? 0.999999 :
2746 return element;
2751 Element.Methods.setOpacity = function(element, value) {
2752 element = $(element);
2753 element.style.opacity = (value == 1 || value === '') ? '' :
2757 if (element.tagName.toUpperCase() == 'IMG' && element.width) {
2758 element.width++; element.width--;
2761 element.appendChild(n);
2762 element.removeChild(n);
2765 return element;
2770 Element.Methods.replace = function(element, content) { argument
2771 element = $(element);
2775 element.parentNode.replaceChild(content, element);
2776 return element;
2780 var parent = element.parentNode, tagName = parent.tagName.toUpperCase();
2783 var nextSibling = element.next(),
2785 parent.removeChild(element);
2791 else element.outerHTML = content.stripScripts();
2794 return element;
2830 before: function(element, node) { argument
2831 element.parentNode.insertBefore(node, element);
2833 top: function(element, node) { argument
2834 element.insertBefore(node, element.firstChild);
2836 bottom: function(element, node) { argument
2837 element.appendChild(node);
2839 after: function(element, node) { argument
2840 element.parentNode.insertBefore(node, element.nextSibling);
2861 hasAttribute: function(element, attribute) { argument
2863 var node = $(element).getAttributeNode(attribute);
2902 function extendElementWith(element, methods) { argument
2905 if (Object.isFunction(value) && !(property in element))
2906 element[property] = value.methodize();
2914 return function(element) { argument
2915 if (element && typeof element._extendedByPrototype == 'undefined') {
2916 var t = element.tagName;
2918 extendElementWith(element, Element.Methods);
2919 extendElementWith(element, Element.Methods.Simulated);
2920 extendElementWith(element, Element.Methods.ByTag[t.toUpperCase()]);
2923 return element;
2931 var extend = Object.extend(function(element) { argument
2932 if (!element || typeof element._extendedByPrototype != 'undefined' ||
2933 element.nodeType != 1 || element == window) return element;
2936 tagName = element.tagName.toUpperCase();
2940 extendElementWith(element, methods);
2942 element._extendedByPrototype = Prototype.emptyFunction;
2943 return element;
2959 Element.hasAttribute = function(element, attribute) { argument
2960 return element.hasAttribute(attribute);
3030 var element = document.createElement(tagName),
3031 proto = element['__proto__'] || element.constructor.prototype;
3033 element = null;
3075 var B = Prototype.Browser, doc = document, element, property = {}; variable
3088 if (!element) element = getRootElement();
3092 viewport['get' + D] = function() { return element[property[D]] };
3107 getStorage: function(element) { argument
3108 if (!(element = $(element))) return;
3111 if (element === window) {
3114 if (typeof element._prototypeUID === "undefined")
3115 element._prototypeUID = Element.Storage.UID++;
3116 uid = element._prototypeUID;
3125 store: function(element, key, value) { argument
3126 if (!(element = $(element))) return;
3129 Element.getStorage(element).update(key);
3131 Element.getStorage(element).set(key, value);
3134 return element;
3137 retrieve: function(element, key, defaultValue) { argument
3138 if (!(element = $(element))) return;
3139 var hash = Element.getStorage(element), value = hash.get(key);
3149 clone: function(element, deep) { argument
3150 if (!(element = $(element))) return;
3151 var clone = element.cloneNode(deep);
3163 purge: function(element) { argument
3164 if (!(element = $(element))) return;
3167 purgeElement(element);
3169 var descendants = element.getElementsByTagName('*'),
3187 var element = null;
3189 element = value;
3190 value = element.getStyle(property);
3203 if (/\d/.test(value) && element && element.runtimeStyle && !(isPercentage && isViewport)) {
3204 var style = element.style.left, rStyle = element.runtimeStyle.left;
3205 element.runtimeStyle.left = element.currentStyle.left;
3206 element.style.left = value || 0;
3207 value = element.style.pixelLeft;
3208 element.style.left = style;
3209 element.runtimeStyle.left = rStyle;
3214 if (element && isPercentage) {
3215 context = context || element.parentNode;
3218 var position = element.getStyle('position');
3253 function isDisplayed(element) { argument
3254 var originalElement = element;
3255 while (element && element.parentNode) {
3256 var display = element.getStyle('display');
3260 element = $(element.parentNode);
3267 hasLayout = function(element) { argument
3268 if (!element.currentStyle.hasLayout) {
3269 element.style.zoom = 1;
3271 return element;
3281 initialize: function($super, element, preCompute) { argument
3283 this.element = $(element);
3314 var element = this.element;
3315 if (isDisplayed(element)) {
3321 position: element.style.position || '',
3322 width: element.style.width || '',
3323 visibility: element.style.visibility || '',
3324 display: element.style.display || ''
3327 element.store('prototype_original_styles', originalStyles);
3329 var position = element.getStyle('position'),
3330 width = element.getStyle('width');
3333 element.style.display = 'block';
3334 width = element.getStyle('width');
3338 element.parentNode;
3340 element.setStyle({
3346 var positionedWidth = element.getStyle('width');
3350 newWidth = getPixelValue(element, 'width', context);
3352 newWidth = getPixelValue(element, 'width', context);
3354 var parent = element.parentNode, pLayout = $(parent).getLayout();
3365 element.setStyle({ width: newWidth + 'px' });
3371 var element = this.element;
3372 var originalStyles = element.retrieve('prototype_original_styles');
3373 element.store('prototype_original_styles', null);
3374 element.setStyle(originalStyles);
3384 return this._set(property, COMPUTATIONS[property].call(this, this.element));
3432 'height': function(element) { argument
3452 'width': function(element) { argument
3472 'padding-box-height': function(element) { argument
3480 'padding-box-width': function(element) { argument
3488 'border-box-height': function(element) { argument
3490 var height = element.offsetHeight;
3495 'border-box-width': function(element) { argument
3497 var width = element.offsetWidth;
3502 'margin-box-height': function(element) { argument
3512 'margin-box-width': function(element) { argument
3522 'top': function(element) { argument
3523 var offset = element.positionedOffset();
3527 'bottom': function(element) { argument
3528 var offset = element.positionedOffset(),
3529 parent = element.getOffsetParent(),
3537 'left': function(element) { argument
3538 var offset = element.positionedOffset();
3542 'right': function(element) { argument
3543 var offset = element.positionedOffset(),
3544 parent = element.getOffsetParent(),
3552 'padding-top': function(element) { argument
3553 return getPixelValue(element, 'paddingTop');
3556 'padding-bottom': function(element) { argument
3557 return getPixelValue(element, 'paddingBottom');
3560 'padding-left': function(element) { argument
3561 return getPixelValue(element, 'paddingLeft');
3564 'padding-right': function(element) { argument
3565 return getPixelValue(element, 'paddingRight');
3568 'border-top': function(element) { argument
3569 return getPixelValue(element, 'borderTopWidth');
3572 'border-bottom': function(element) { argument
3573 return getPixelValue(element, 'borderBottomWidth');
3576 'border-left': function(element) { argument
3577 return getPixelValue(element, 'borderLeftWidth');
3580 'border-right': function(element) { argument
3581 return getPixelValue(element, 'borderRightWidth');
3584 'margin-top': function(element) { argument
3585 return getPixelValue(element, 'marginTop');
3588 'margin-bottom': function(element) { argument
3589 return getPixelValue(element, 'marginBottom');
3592 'margin-left': function(element) { argument
3593 return getPixelValue(element, 'marginLeft');
3596 'margin-right': function(element) { argument
3597 return getPixelValue(element, 'marginRight');
3604 'right': function(element) { argument
3605 var parent = hasLayout(element.getOffsetParent());
3606 var rect = element.getBoundingClientRect(),
3612 'bottom': function(element) { argument
3613 var parent = hasLayout(element.getOffsetParent());
3614 var rect = element.getBoundingClientRect(),
3651 function getLayout(element, preCompute) { argument
3652 return new Element.Layout(element, preCompute);
3655 function measure(element, property) { argument
3656 return $(element).getLayout().get(property);
3659 function getDimensions(element) { argument
3660 element = $(element);
3661 var display = Element.getStyle(element, 'display');
3664 return { width: element.offsetWidth, height: element.offsetHeight };
3667 var style = element.style;
3682 Element.setStyle(element, newStyles);
3685 width: element.offsetWidth,
3686 height: element.offsetHeight
3689 Element.setStyle(element, originalStyles);
3694 function getOffsetParent(element) { argument
3695 element = $(element);
3697 if (isDocument(element) || isDetached(element) || isBody(element) || isHtml(element))
3700 var isInline = (Element.getStyle(element, 'display') === 'inline');
3701 if (!isInline && element.offsetParent) return $(element.offsetParent);
3703 while ((element = element.parentNode) && element !== document.body) {
3704 if (Element.getStyle(element, 'position') !== 'static') {
3705 return isHtml(element) ? $(document.body) : $(element);
3713 function cumulativeOffset(element) { argument
3714 element = $(element);
3716 if (element.parentNode) {
3718 valueT += element.offsetTop || 0;
3719 valueL += element.offsetLeft || 0;
3720 element = element.offsetParent;
3721 } while (element);
3726 function positionedOffset(element) { argument
3727 element = $(element);
3729 var layout = element.getLayout();
3733 valueT += element.offsetTop || 0;
3734 valueL += element.offsetLeft || 0;
3735 element = element.offsetParent;
3736 if (element) {
3737 if (isBody(element)) break;
3738 var p = Element.getStyle(element, 'position');
3741 } while (element);
3749 function cumulativeScrollOffset(element) { argument
3752 valueT += element.scrollTop || 0;
3753 valueL += element.scrollLeft || 0;
3754 element = element.parentNode;
3755 } while (element);
3760 element = $(element);
3763 var element = forElement;
3765 valueT += element.offsetTop || 0;
3766 valueL += element.offsetLeft || 0;
3767 if (element.offsetParent == docBody &&
3768 Element.getStyle(element, 'position') == 'absolute') break;
3769 } while (element = element.offsetParent);
3771 element = forElement;
3773 if (element != docBody) {
3774 valueT -= element.scrollTop || 0;
3775 valueL -= element.scrollLeft || 0;
3777 } while (element = element.parentNode);
3781 function absolutize(element) { argument
3782 element = $(element);
3784 if (Element.getStyle(element, 'position') === 'absolute') {
3785 return element;
3788 var offsetParent = getOffsetParent(element);
3789 var eOffset = element.viewportOffset(),
3793 var layout = element.getLayout();
3795 element.store('prototype_absolutize_original_styles', {
3796 left: element.getStyle('left'),
3797 top: element.getStyle('top'),
3798 width: element.getStyle('width'),
3799 height: element.getStyle('height')
3802 element.setStyle({
3810 return element;
3813 function relativize(element) { argument
3814 element = $(element);
3815 if (Element.getStyle(element, 'position') === 'relative') {
3816 return element;
3820 element.retrieve('prototype_absolutize_original_styles');
3822 if (originalStyles) element.setStyle(originalStyles);
3823 return element;
3828 function(proceed, element) { argument
3829 element = $(element);
3831 if (isDocument(element) || isDetached(element) || isBody(element) || isHtml(element))
3834 var position = element.getStyle('position');
3835 if (position !== 'static') return proceed(element);
3837 element.setStyle({ position: 'relative' });
3838 var value = proceed(element);
3839 element.setStyle({ position: position });
3844 positionedOffset = positionedOffset.wrap(function(proceed, element) { argument
3845 element = $(element);
3846 if (!element.parentNode) return new Element.Offset(0, 0);
3847 var position = element.getStyle('position');
3848 if (position !== 'static') return proceed(element);
3850 var offsetParent = element.getOffsetParent();
3854 element.setStyle({ position: 'relative' });
3855 var value = proceed(element);
3856 element.setStyle({ position: position });
3860 cumulativeOffset = function(element) {
3861 element = $(element);
3864 valueT += element.offsetTop || 0;
3865 valueL += element.offsetLeft || 0;
3866 if (element.offsetParent == document.body)
3867 if (Element.getStyle(element, 'position') == 'absolute') break;
3869 element = element.offsetParent;
3870 } while (element);
3890 function isBody(element) { argument
3891 return element.nodeName.toUpperCase() === 'BODY';
3894 function isHtml(element) { argument
3895 return element.nodeName.toUpperCase() === 'HTML';
3898 function isDocument(element) { argument
3899 return element.nodeType === Node.DOCUMENT_NODE;
3902 function isDetached(element) { argument
3903 return element !== document.body &&
3904 !Element.descendantOf(element, document.body);
3909 viewportOffset: function(element) { argument
3910 element = $(element);
3911 if (isDetached(element)) return new Element.Offset(0, 0);
3913 var rect = element.getBoundingClientRect(),
4951 function match(element, selector) { argument
4952 return engine.matches(selector, [element]).length == 1;
4991 return elements.inject(initial, function(result, element) { argument
4992 if (!element.disabled && element.name) {
4993 key = element.name; value = $(element).getValue();
4994 if (value != null && element.type != 'file' && (element.type != 'submit' || (!submitted &&
5011 element,
5014 for (var i = 0; element = elements[i]; i++) {
5015 arr.push(element);
5053 var elements = $(form).getElements().findAll(function(element) { argument
5054 return 'hidden' != element.type && !element.disabled;
5056 var firstByIndex = elements.findAll(function(element) { argument
5057 return element.hasAttribute('tabIndex') && element.tabIndex >= 0;
5058 }).sortBy(function(element) { return element.tabIndex }).first(); argument
5060 return firstByIndex ? firstByIndex : elements.find(function(element) { argument
5061 return /^(?:input|select|textarea)$/i.test(element.tagName);
5067 var element = form.findFirstElement();
5068 if (element) element.activate();
5095 focus: function(element) { argument
5096 $(element).focus();
5097 return element;
5100 select: function(element) { argument
5101 $(element).select();
5102 return element;
5108 serialize: function(element) { argument
5109 element = $(element);
5110 if (!element.disabled && element.name) {
5111 var value = element.getValue();
5114 pair[element.name] = value;
5121 getValue: function(element) { argument
5122 element = $(element);
5123 var method = element.tagName.toLowerCase();
5124 return Form.Element.Serializers[method](element);
5127 setValue: function(element, value) { argument
5128 element = $(element);
5129 var method = element.tagName.toLowerCase();
5130 Form.Element.Serializers[method](element, value);
5131 return element;
5134 clear: function(element) { argument
5135 $(element).value = '';
5136 return element;
5139 present: function(element) { argument
5140 return $(element).value != '';
5143 activate: function(element) { argument
5144 element = $(element);
5146 element.focus();
5147 if (element.select && (element.tagName.toLowerCase() != 'input' ||
5148 !(/^(?:button|reset|submit)$/i.test(element.type))))
5149 element.select();
5151 return element;
5154 disable: function(element) { argument
5155 element = $(element);
5156 element.disabled = true;
5157 return element;
5160 enable: function(element) { argument
5161 element = $(element);
5162 element.disabled = false;
5163 return element;
5176 function input(element, value) { argument
5177 switch (element.type.toLowerCase()) {
5180 return inputSelector(element, value);
5182 return valueSelector(element, value);
5186 function inputSelector(element, value) { argument
5188 return element.checked ? element.value : null;
5189 else element.checked = !!value;
5192 function valueSelector(element, value) { argument
5193 if (Object.isUndefined(value)) return element.value;
5194 else element.value = value;
5197 function select(element, value) { argument
5199 return (element.type === 'select-one' ? selectOne : selectMany)(element);
5202 for (var i = 0, length = element.length; i < length; i++) {
5203 opt = element.options[i];
5215 function selectOne(element) { argument
5216 var index = element.selectedIndex;
5217 return index >= 0 ? optionValue(element.options[index]) : null;
5220 function selectMany(element) { argument
5221 var values, length = element.length;
5225 var opt = element.options[i];
5251 initialize: function($super, element, frequency, callback) { argument
5253 this.element = $(element);
5261 this.callback(this.element, value);
5269 return Form.Element.getValue(this.element);
5275 return Form.serialize(this.element);
5282 initialize: function(element, callback) { argument
5283 this.element = $(element);
5287 if (this.element.tagName.toLowerCase() == 'form')
5290 this.registerCallback(this.element);
5296 this.callback(this.element, value);
5302 Form.getElements(this.element).each(this.registerCallback, this);
5305 registerCallback: function(element) { argument
5306 if (element.type) {
5307 switch (element.type.toLowerCase()) {
5310 Event.observe(element, 'click', this.onElementEvent.bind(this));
5313 Event.observe(element, 'change', this.onElementEvent.bind(this));
5322 return Form.Element.getValue(this.element);
5328 return Form.serialize(this.element);
5411 function element(event) { function
5431 var element = Event.element(event);
5433 if (!expression) return element;
5434 while (element) {
5435 if (Object.isElement(element) && Prototype.Selector.match(element, expression)) {
5436 return Element.extend(element);
5438 element = element.parentNode;
5479 element: element, property in Event.Methods
5496 var element;
5500 element = event.fromElement;
5504 element = event.toElement;
5509 return Element.extend(element);
5518 Event.extend = function(event, element) { argument
5529 target: event.srcElement || element,
5549 function _createResponder(element, eventName, handler) { argument
5550 var registry = Element.retrieve(element, 'prototype_event_registry');
5553 CACHE.push(element);
5554 registry = Element.retrieve(element, 'prototype_event_registry', $H());
5574 Event.extend(event, element);
5575 handler.call(element, event);
5582 Event.extend(event, element);
5585 while (parent && parent !== element) {
5587 catch(e) { parent = element; }
5590 if (parent === element) return;
5592 handler.call(element, event);
5597 Event.extend(event, element);
5598 handler.call(element, event);
5633 function observe(element, eventName, handler) { argument
5634 element = $(element);
5636 var responder = _createResponder(element, eventName, handler);
5638 if (!responder) return element;
5641 if (element.addEventListener)
5642 element.addEventListener("dataavailable", responder, false);
5644 element.attachEvent("ondataavailable", responder);
5645 element.attachEvent("onlosecapture", responder);
5650 if (element.addEventListener)
5651 element.addEventListener(actualEventName, responder, false);
5653 element.attachEvent("on" + actualEventName, responder);
5656 return element;
5659 function stopObserving(element, eventName, handler) { argument
5660 element = $(element);
5662 var registry = Element.retrieve(element, 'prototype_event_registry');
5663 if (!registry) return element;
5668 stopObserving(element, eventName);
5670 return element;
5674 if (!responders) return element;
5678 stopObserving(element, eventName, r.handler);
5680 return element;
5690 if (!responder) return element;
5693 if (element.removeEventListener)
5694 element.removeEventListener("dataavailable", responder, false);
5696 element.detachEvent("ondataavailable", responder);
5697 element.detachEvent("onlosecapture", responder);
5701 if (element.removeEventListener)
5702 element.removeEventListener(actualEventName, responder, false);
5704 element.detachEvent('on' + actualEventName, responder);
5709 return element;
5712 function fire(element, eventName, memo, bubble) { argument
5713 element = $(element);
5718 if (element == document && document.createEvent && !element.dispatchEvent)
5719 element = document.documentElement;
5734 element.dispatchEvent(event);
5736 element.fireEvent(event.eventType, event);
5742 initialize: function(element, eventName, selector, callback) { argument
5743 this.element = $(element);
5751 Event.observe(this.element, this.eventName, this.handler);
5756 Event.stopObserving(this.element, this.eventName, this.handler);
5761 var element = Event.findElement(event, this.selector);
5762 if (element) this.callback.call(this.element, event, element);
5766 function on(element, eventName, selector, callback) { argument
5767 element = $(element);
5772 return new Event.Handler(element, eventName, selector, callback).start();
5861 Before: function(element, content) { argument
5862 return Element.insert(element, {before:content});
5865 Top: function(element, content) { argument
5866 return Element.insert(element, {top:content});
5869 Bottom: function(element, content) { argument
5870 return Element.insert(element, {bottom:content});
5873 After: function(element, content) { argument
5874 return Element.insert(element, {after:content});
5894 within: function(element, x, y) { argument
5896 return this.withinIncludingScrolloffsets(element, x, y);
5899 this.offset = Element.cumulativeOffset(element);
5902 y < this.offset[1] + element.offsetHeight &&
5904 x < this.offset[0] + element.offsetWidth);
5907 withinIncludingScrolloffsets: function(element, x, y) { argument
5908 var offsetcache = Element.cumulativeScrollOffset(element);
5912 this.offset = Element.cumulativeOffset(element);
5915 this.ycomp < this.offset[1] + element.offsetHeight &&
5917 this.xcomp < this.offset[0] + element.offsetWidth);
5920 overlap: function(mode, element) { argument
5923 return ((this.offset[1] + element.offsetHeight) - this.ycomp) /
5924 element.offsetHeight;
5926 return ((this.offset[0] + element.offsetWidth) - this.xcomp) /
5927 element.offsetWidth;
5935 absolutize: function(element) { argument
5937 return Element.absolutize(element);
5940 relativize: function(element) { argument
5942 return Element.relativize(element);
5965 function(element, className) {
5968 return cond ? document._getElementsByXPath('.//*' + cond, element) : [];
5969 } : function(element, className) {
5974 var nodes = $(element).getElementsByTagName('*');
5996 initialize: function(element) { argument
5997 this.element = $(element);
6001 this.element.className.split(/\s+/).select(function(name) {
6007 this.element.className = className;
6039 match: function(element) { argument
6040 return Prototype.Selector.match(element, this.expression);
6058 var element = elements[i];
6059 if (match(element, expression)) {
6060 results.push(Element.extend(element));
6068 var matchIndex = 0, element;
6070 element = elements[i];
6071 if (Prototype.Selector.match(element, expression) && index === matchIndex++) {
6072 return Element.extend(element);
6077 findChildElements: function(element, expressions) { argument
6079 return Prototype.Selector.select(selector, element || document);