Lines Matching refs:element
68 // Otherwise, we inject the element directly into the jQuery object
102 // The number of elements contained in the matched element set
107 // Get the Nth element in the matched element set OR
108 // Get the whole matched element set as a clean array
120 // (returning the new matched element set)
122 // Build a new jQuery matched element set
135 // Return the newly-formed element set
151 // Execute a callback for every element in the matched set.
158 // Determine the position of an element within
161 // Locate the position of the desired element
163 // If it receives a jQuery object, the first element is used
639 // check if an element is in a (or is an) XML document
1252 // Remove element nodes and prevent memory leaks
1281 // Compute a unique ID for the element
1294 // Return the named cache data, or the ID for the element
1307 // If we want to remove a specific section of the element's data
1313 // If we've removed all the data, remove the element's cache
1323 // Otherwise, we want to remove all of the element's data
1325 // Clean up the element expando
2133 // We're going to inject a fake input element with a specified name
2138 // Inject it into the root element, check its status, and remove it quickly
2165 // Create a fake element
2435 // Bind an event to an element
2462 // Init the element's event structure
2498 // Bind the global event handler to the element
2506 // Add the function to the element's handler list
2520 // Detach an event or set of events from an element
2529 // Unbind all events for the element
2621 // Handle triggering a single element
2862 // Checks if an event happened on an element within another element
2865 // Check if mouse(over|out) are still within the same parent element
2875 // handle event if we actually just moused on to a non sub-element
3140 // Make sure that you can get all elements in an <object> element
3146 // This requires a wrapper element in IE
3157 // Make sure that element opacity exists
3503 // We handle everything using the script element injection
4079 // Start by showing the element
4120 // Hide the element if the "hide" operation was done
4271 // Subtract element margins
4272 // note: when an element has margin: auto the offsetLeft and marginLeft
4366 // Get or set width or height on the element
4368 // Get width or height on the element
4371 // Set the width or height on the element (default to pixels if value is unitless)
4635 case 1: return 'element';
4773 if (!win.Element){
4774 win.Element = $empty;
4776 win.Element.prototype = (Browser.Engine.webkit) ? window["[[DOMElement.prototype]]"] : {};
5670 Script: Element.js
5678 var Element = new Native({
5680 name: 'Element',
5682 legacy: window.Element,
5685 var konstructor = Element.Constructors.get(tag);
5692 Element.Prototype[key] = value;
5699 if (elements) elements = ($type(returns) == 'element');
5707 Element.Prototype = {$family: {name: 'element'}};
5709 Element.Constructors = new Hash;
5724 iframe = new Element(iframe || 'iframe', props);
5732 $extend(win.Element.prototype, Element.Prototype);
5750 var el = $.element(elements[i], !options.cash);
5786 return $.element(this.createElement(tag)).set(props);
5818 case 'element': elements.push(item); break;
5837 return (id) ? $.element(id, nocash) : null;
5840 $.element = function(el, nocash){
5843 var proto = Element.Prototype;
5850 if (obj.toElement) return $.element(obj.toElement(doc), nocash);
5856 Native.implement([Element, Document], {
5899 Element.dispose(item);
5913 var walk = function(element, walk, start, match, all, nocash){
5914 var el = element[start || walk];
5917 if (el.nodeType == 1 && (!match || Element.match(el, match))){
5942 before: function(context, element){
5943 if (element.parentNode) element.parentNode.insertBefore(context, element);
5946 after: function(context, element){
5947 if (!element.parentNode) return;
5948 var next = element.nextSibling;
5949 (next) ? element.parentNode.insertBefore(context, next) : element.parentNode.appendChild(context);
5952 bottom: function(context, element){
5953 element.appendChild(context);
5956 top: function(context, element){
5957 var first = element.firstChild;
5958 (first) ? element.insertBefore(context, first) : element.appendChild(context);
5969 Element.implement('inject' + where, function(el){
5974 Element.implement('grab' + where, function(el){
5981 Element.implement({
5989 var property = Element.Properties.get(prop);
5996 var property = Element.Properties.get(prop);
6001 var property = Element.Properties.get(prop);
6060 Array.flatten(arguments).each(function(element){
6061 element = $(element, true);
6062 if (element) this.appendChild(element);
6146 return $.element(el, nocash);
6165 var value = (el.tagName.toLowerCase() == 'select') ? Element.getSelected(el).map(function(opt){
6178 var clean = function(node, element){
6182 node.mergeAttributes(element);
6185 var no = node.options, eo = element.options;
6189 var prop = props[element.tagName.toLowerCase()];
6190 if (prop && element[prop]) node[prop] = element[prop];
6203 Element.empty(this);
6204 Element.dispose(this);
6211 Element.destroy(node);
6228 return (!tag || (tag == this) || (Element.get(this, 'tag') == tag));
6233 Native.implement([Element, Window, Document], {
6280 Element.Properties = new Hash;
6282 Element.Properties.style = {
6298 Element.Properties.tag = {
6306 Element.Properties.html = (function(){
6337 if (Browser.Engine.webkit && Browser.Engine.version < 420) Element.Properties.text = {
6349 Script: Element.Event.js
6350 Contains Element methods for dealing with events, and custom Events.
6356 Element.Properties.events = {set: function(events){
6360 Native.implement([Element, Window, Document], {
6367 var realType = type, custom = Element.Events.get(type), condition = fn, self = this;
6381 var nativeEvent = Element.NativeEvents[realType];
6402 var custom = Element.Events.get(type);
6407 return (Element.NativeEvents[type]) ? this.removeListener(type, value) : this;
6458 Element.NativeEvents = {
6477 Element.Events = new Hash({
6499 Script: Element.Style.js
6506 Element.Properties.styles = {set: function(styles){
6510 Element.Properties.opacity = {
6532 Element.implement({
6549 var map = (Element.Styles.get(property) || '@').split(' ');
6570 for (var style in Element.ShortStyles){
6572 for (var s in Element.ShortStyles[style]) result.push(this.getStyle(s));
6611 Element.Styles = new Hash({
6621 Element.ShortStyles = {margin: {}, padding: {}, border: {}, borderWidth: {}, borderStyle: {}, borderColor: {}};
6624 var Short = Element.ShortStyles;
6625 var All = Element.Styles;
6641 Script: Element.Dimensions.js
6648 - Element positioning based on the [qooxdoo](http://qooxdoo.org/) code and smart browser fixes, [LGPL License](http://www.gnu.org/licenses/lgpl.html).
6654 Element.implement({
6682 var element = this, position = {x: 0, y: 0};
6683 while (element && !isBody(element)){
6684 position.x += element.scrollLeft;
6685 position.y += element.scrollTop;
6686 element = element.parentNode;
6692 var element = this;
6693 if (isBody(element)) return null;
6694 if (!Browser.Engine.trident) return element.offsetParent;
6695 while ((element = element.parentNode) && !isBody(element)){
6696 if (styleString(element, 'position') != 'static') return element;
6711 var element = this, position = {x: 0, y: 0};
6714 while (element && !isBody(element)){
6715 position.x += element.offsetLeft;
6716 position.y += element.offsetTop;
6719 if (!borderBox(element)){
6720 position.x += leftBorder(element);
6721 position.y += topBorder(element);
6723 var parent = element.parentNode;
6728 } else if (element != this && Browser.Engine.webkit){
6729 position.x += leftBorder(element);
6730 position.y += topBorder(element);
6733 element = element.offsetParent;
6750 getCoordinates: function(element){
6752 var position = this.getPosition(element), size = this.getSize();
6803 var styleString = Element.getComputedStyle;
6805 function styleNumber(element, style){
6806 return styleString(element, style).toInt() || 0;
6809 function borderBox(element){
6810 return styleString(element, '-moz-box-sizing') == 'border-box';
6813 function topBorder(element){
6814 return styleNumber(element, 'border-top-width');
6817 function leftBorder(element){
6818 return styleNumber(element, 'border-left-width');
6821 function isBody(element){
6822 return (/^(?:body|html)$/i).test(element.tagName);
6825 function getCompatElement(element){
6826 var doc = element.getDocument();
6834 Native.implement([Window, Document, Element], {
6879 Native.implement([Document, Element], {
6894 Element.implement({
7008 var item = (ctx.getElementById) ? ctx.getElementById(id, true) : Element.getElementById(ctx, id, true);
7127 var result = Element.prototype.getProperty.call(self, name);
7157 return !Element.match(this, selector);
7169 var element = this;
7170 while ((element = element.nextSibling)){
7171 if (element.nodeType == 1) return false;
7214 var element = this, count = 0;
7215 while ((element = element.previousSibling)){
7216 if (element.nodeType == 1 && ++count > index) return false;
7244 Element.Events.domready = {
7477 this.object = ((container) ? container.empty() : new Element('div')).set('html', build).firstChild;
7480 replaces: function(element){
7481 element = $(element, true);
7482 element.parentNode.replaceChild(this.toElement(), element);
7486 inject: function(element){
7487 $(element, true).appendChild(this.toElement());
7652 prepare: function(element, property, values){
7657 values[0] = element.getStyle(property);
7703 //renders the change to an element
7705 render: function(element, property, value, unit){
7706 element.setStyle(property, this.serve(value, unit));
7724 Element.Styles.each(function(value, style){
7725 if (!rule.style[style] || Element.ShortStyles[style]) return;
7774 Formerly Fx.Style, effect to transition any CSS property for an element.
7784 initialize: function(element, options){
7785 this.element = this.subject = $(element);
7794 this.render(this.element, property, now, this.options.unit);
7802 var parsed = this.prepare(this.element, this.property, args);
7808 Element.Properties.tween = {
7826 Element.implement({
7871 Formerly Fx.Styles, effect to transition any number of CSS properties for an element using an object of rules, or CSS based selector rules.
7881 initialize: function(element, options){
7882 this.element = this.subject = $(element);
7888 for (var p in now) this.render(this.element, p, now[p], this.options.unit);
7903 var parsed = this.prepare(this.element, p, properties[p]);
7912 Element.Properties.morph = {
7930 Element.implement({
8150 if (type == 'string' || type == 'element') options = {data: options};
8157 case 'element': data = $(data).toQueryString(); break;
8256 var container = new Element('div');
8270 var child = Element.clone(root.childNodes[i], true, true);
8299 Element.Properties.send = {
8319 Element.Properties.load = {
8337 Element.implement({
8791 var div = new Element('div');
9892 function $(element) {
9898 if (Object.isString(element))
9899 element = document.getElementById(element);
9900 return Element.extend(element);
9909 results.push(Element.extend(query.snapshotItem(i)));
9937 var element = this.Element;
9938 this.Element = function(tagName, attributes) {
9941 var cache = Element.cache;
9945 return Element.writeAttribute(document.createElement(tagName), attributes);
9947 Element.extend(document.createElement(tagName));
9948 return Element.writeAttribute(cache[tagName].cloneNode(false), attributes);
9950 Object.extend(this.Element, element || { });
9951 if (element) this.Element.prototype = element.prototype;
9954 Element.cache = { };
9956 Element.Methods = {
9957 visible: function(element) {
9958 return $(element).style.display != 'none';
9961 toggle: function(element) {
9962 element = $(element);
9963 Element[Element.visible(element) ? 'hide' : 'show'](element);
9964 return element;
9967 hide: function(element) {
9968 element = $(element);
9969 element.style.display = 'none';
9970 return element;
9973 show: function(element) {
9974 element = $(element);
9975 element.style.display = '';
9976 return element;
9979 remove: function(element) {
9980 element = $(element);
9981 element.parentNode.removeChild(element);
9982 return element;
9985 update: function(element, content) {
9986 element = $(element);
9988 if (Object.isElement(content)) return element.update().insert(content);
9990 element.innerHTML = content.stripScripts();
9992 return element;
9995 replace: function(element, content) {
9996 element = $(element);
10000 var range = element.ownerDocument.createRange();
10001 range.selectNode(element);
10005 element.parentNode.replaceChild(content, element);
10006 return element;
10009 insert: function(element, insertions) {
10010 element = $(element);
10021 insert = Element._insertionTranslations[position];
10025 insert(element, content);
10032 ? element.parentNode : element).tagName.toUpperCase();
10034 childNodes = Element._getContentFromAnonymousElement(tagName, content.stripScripts());
10037 childNodes.each(insert.curry(element));
10042 return element;
10045 wrap: function(element, wrapper, attributes) {
10046 element = $(element);
10049 else if (Object.isString(wrapper)) wrapper = new Element(wrapper, attributes);
10050 else wrapper = new Element('div', wrapper);
10051 if (element.parentNode)
10052 element.parentNode.replaceChild(wrapper, element);
10053 wrapper.appendChild(element);
10057 inspect: function(element) {
10058 element = $(element);
10059 var result = '<' + element.tagName.toLowerCase();
10062 var value = (element[property] || '').toString();
10068 recursivelyCollect: function(element, property) {
10069 element = $(element);
10071 while (element = element[property])
10072 if (element.nodeType == 1)
10073 elements.push(Element.extend(element));
10077 ancestors: function(element) {
10078 return $(element).recursivelyCollect('parentNode');
10081 descendants: function(element) {
10082 return $(element).select("*");
10085 firstDescendant: function(element) {
10086 element = $(element).firstChild;
10087 while (element && element.nodeType != 1) element = element.nextSibling;
10088 return $(element);
10091 immediateDescendants: function(element) {
10092 if (!(element = $(element).firstChild)) return [];
10093 while (element && element.nodeType != 1) element = element.nextSibling;
10094 if (element) return [element].concat($(element).nextSiblings());
10098 previousSiblings: function(element) {
10099 return $(element).recursivelyCollect('previousSibling');
10102 nextSiblings: function(element) {
10103 return $(element).recursivelyCollect('nextSibling');
10106 siblings: function(element) {
10107 element = $(element);
10108 return element.previousSiblings().reverse().concat(element.nextSiblings());
10111 match: function(element, selector) {
10114 return selector.match($(element));
10117 up: function(element, expression, index) {
10118 element = $(element);
10119 if (arguments.length == 1) return $(element.parentNode);
10120 var ancestors = element.ancestors();
10125 down: function(element, expression, index) {
10126 element = $(element);
10127 if (arguments.length == 1) return element.firstDescendant();
10128 return Object.isNumber(expression) ? element.descendants()[expression] :
10129 Element.select(element, expression)[index || 0];
10132 previous: function(element, expression, index) {
10133 element = $(element);
10134 if (arguments.length == 1) return $(Selector.handlers.previousElementSibling(element));
10135 var previousSiblings = element.previousSiblings();
10140 next: function(element, expression, index) {
10141 element = $(element);
10142 if (arguments.length == 1) return $(Selector.handlers.nextElementSibling(element));
10143 var nextSiblings = element.nextSiblings();
10149 var args = $A(arguments), element = $(args.shift());
10150 return Selector.findChildElements(element, args);
10154 var args = $A(arguments), element = $(args.shift());
10155 return Selector.findChildElements(element.parentNode, args).without(element);
10158 identify: function(element) {
10159 element = $(element);
10160 var id = element.readAttribute('id'), self = arguments.callee;
10163 element.writeAttribute('id', id);
10167 readAttribute: function(element, name) {
10168 element = $(element);
10170 var t = Element._attributeTranslations.read;
10171 if (t.values[name]) return t.values[name](element, name);
10174 return (!element.attributes || !element.attributes[name]) ? null :
10175 element.attributes[name].value;
10178 return element.getAttribute(name);
10181 writeAttribute: function(element, name, value) {
10182 element = $(element);
10183 var attributes = { }, t = Element._attributeTranslations.write;
10191 if (t.values[attr]) name = t.values[attr](element, value);
10193 element.removeAttribute(name);
10195 element.setAttribute(name, name);
10196 else element.setAttribute(name, value);
10198 return element;
10201 getHeight: function(element) {
10202 return $(element).getDimensions().height;
10205 getWidth: function(element) {
10206 return $(element).getDimensions().width;
10209 classNames: function(element) {
10210 return new Element.ClassNames(element);
10213 hasClassName: function(element, className) {
10214 if (!(element = $(element))) return;
10215 var elementClassName = element.className;
10220 addClassName: function(element, className) {
10221 if (!(element = $(element))) return;
10222 if (!element.hasClassName(className))
10223 element.className += (element.className ? ' ' : '') + className;
10224 return element;
10227 removeClassName: function(element, className) {
10228 if (!(element = $(element))) return;
10229 element.className = element.className.replace(
10231 return element;
10234 toggleClassName: function(element, className) {
10235 if (!(element = $(element))) return;
10236 return element[element.hasClassName(className) ?
10241 cleanWhitespace: function(element) {
10242 element = $(element);
10243 var node = element.firstChild;
10247 element.removeChild(node);
10250 return element;
10253 empty: function(element) {
10254 return $(element).innerHTML.blank();
10257 descendantOf: function(element, ancestor) {
10258 element = $(element), ancestor = $(ancestor);
10260 if (element.compareDocumentPosition)
10261 return (element.compareDocumentPosition(ancestor) & 8) === 8;
10264 return ancestor.contains(element) && ancestor !== element;
10266 while (element = element.parentNode)
10267 if (element == ancestor) return true;
10272 scrollTo: function(element) {
10273 element = $(element);
10274 var pos = element.cumulativeOffset();
10276 return element;
10279 getStyle: function(element, style) {
10280 element = $(element);
10282 var value = element.style[style];
10284 var css = document.defaultView.getComputedStyle(element, null);
10291 getOpacity: function(element) {
10292 return $(element).getStyle('opacity');
10295 setStyle: function(element, styles) {
10296 element = $(element);
10297 var elementStyle = element.style, match;
10299 element.style.cssText += ';' + styles;
10301 element.setOpacity(styles.match(/opacity:\s*(\d?\.?\d*)/)[1]) : element;
10304 if (property == 'opacity') element.setOpacity(styles[property]);
10310 return element;
10313 setOpacity: function(element, value) {
10314 element = $(element);
10315 element.style.opacity = (value == 1 || value === '') ? '' :
10317 return element;
10320 getDimensions: function(element) {
10321 element = $(element);
10322 var display = element.getStyle('display');
10324 return {width: element.offsetWidth, height: element.offsetHeight};
10327 // so enable the element temporarily
10328 var els = element.style;
10335 var originalWidth = element.clientWidth;
10336 var originalHeight = element.clientHeight;
10343 makePositioned: function(element) {
10344 element = $(element);
10345 var pos = Element.getStyle(element, 'position');
10347 element._madePositioned = true;
10348 element.style.position = 'relative';
10350 // element is position relative but top and left have not been defined
10352 element.style.top = 0;
10353 element.style.left = 0;
10356 return element;
10359 undoPositioned: function(element) {
10360 element = $(element);
10361 if (element._madePositioned) {
10362 element._madePositioned = undefined;
10363 element.style.position =
10364 element.style.top =
10365 element.style.left =
10366 element.style.bottom =
10367 element.style.right = '';
10369 return element;
10372 makeClipping: function(element) {
10373 element = $(element);
10374 if (element._overflow) return element;
10375 element._overflow = Element.getStyle(element, 'overflow') || 'auto';
10376 if (element._overflow !== 'hidden')
10377 element.style.overflow = 'hidden';
10378 return element;
10381 undoClipping: function(element) {
10382 element = $(element);
10383 if (!element._overflow) return element;
10384 element.style.overflow = element._overflow == 'auto' ? '' : element._overflow;
10385 element._overflow = null;
10386 return element;
10389 cumulativeOffset: function(element) {
10392 valueT += element.offsetTop || 0;
10393 valueL += element.offsetLeft || 0;
10394 element = element.offsetParent;
10395 } while (element);
10396 return Element._returnOffset(valueL, valueT);
10399 positionedOffset: function(element) {
10402 valueT += element.offsetTop || 0;
10403 valueL += element.offsetLeft || 0;
10404 element = element.offsetParent;
10405 if (element) {
10406 if (element.tagName.toUpperCase() == 'BODY') break;
10407 var p = Element.getStyle(element, 'position');
10410 } while (element);
10411 return Element._returnOffset(valueL, valueT);
10414 absolutize: function(element) {
10415 element = $(element);
10416 if (element.getStyle('position') == 'absolute') return element;
10419 var offsets = element.positionedOffset();
10422 var width = element.clientWidth;
10423 var height = element.clientHeight;
10425 element._originalLeft = left - parseFloat(element.style.left || 0);
10426 element._originalTop = top - parseFloat(element.style.top || 0);
10427 element._originalWidth = element.style.width;
10428 element._originalHeight = element.style.height;
10430 element.style.position = 'absolute';
10431 element.style.top = top + 'px';
10432 element.style.left = left + 'px';
10433 element.style.width = width + 'px';
10434 element.style.height = height + 'px';
10435 return element;
10438 relativize: function(element) {
10439 element = $(element);
10440 if (element.getStyle('position') == 'relative') return element;
10443 element.style.position = 'relative';
10444 var top = parseFloat(element.style.top || 0) - (element._originalTop || 0);
10445 var left = parseFloat(element.style.left || 0) - (element._originalLeft || 0);
10447 element.style.top = top + 'px';
10448 element.style.left = left + 'px';
10449 element.style.height = element._originalHeight;
10450 element.style.width = element._originalWidth;
10451 return element;
10454 cumulativeScrollOffset: function(element) {
10457 valueT += element.scrollTop || 0;
10458 element.scrollLeft || 0;
10459 element = element.parentNode;
10460 } while (element);
10461 return Element._returnOffset(valueL, valueT);
10464 getOffsetParent: function(element) {
10465 if (element.offsetParent) return $(element.offsetParent);
10466 if (element == document.body) return $(element);
10468 while ((element = element.parentNode) && element != document.body)
10469 if (Element.getStyle(element, 'position') != 'static')
10470 return $(element);
10478 var element = forElement;
10480 valueT += element.offsetTop || 0;
10481 valueL += element.offsetLeft || 0;
10484 if (element.offsetParent == document.body &&
10485 Element.getStyle(element, 'position') == 'absolute') break;
10487 } while (element = element.offsetParent);
10489 element = forElement;
10491 if (!Prototype.Browser.Opera || (element.tagName && (element.tagName.toUpperCase() == 'BODY'))) {
10492 valueT -= element.scrollTop || 0;
10493 valueL -= element.scrollLeft || 0;
10495 } while (element = element.parentNode);
10497 return Element._returnOffset(valueL, valueT);
10500 clonePosition: function(element, source) {
10515 element = $(element);
10520 if (Element.getStyle(element, 'position') == 'absolute') {
10521 parent = element.getOffsetParent();
10532 if (options.setLeft) element.style.left = (p[0] - delta[0] + options.offsetLeft) + 'px';
10533 if (options.setTop) element.style.top = (p[1] - delta[1] + options.offsetTop) + 'px';
10534 if (options.setWidth) element.style.width = source.offsetWidth + 'px';
10535 if (options.setHeight) element.style.height = source.offsetHeight + 'px';
10536 return element;
10540 Element.Methods.identify.counter = 1;
10542 Object.extend(Element.Methods, {
10543 getElementsBySelector: Element.Methods.select,
10544 childElements: Element.Methods.immediateDescendants
10547 Element._attributeTranslations = {
10558 Element.Methods.getStyle = Element.Methods.getStyle.wrap(
10559 function(proceed, element, style) {
10562 if (proceed(element, 'position') === 'static') return null;
10565 if (!Element.visible(element)) return null;
10569 var dim = parseInt(proceed(element, style), 10);
10571 if (dim !== element['offset' + style.capitalize()])
10584 var val = proceed(element, property);
10587 default: return proceed(element, style);
10592 Element.Methods.readAttribute = Element.Methods.readAttribute.wrap(
10593 function(proceed, element, attribute) {
10594 if (attribute === 'title') return element.title;
10595 return proceed(element, attribute);
10603 Element.Methods.getOffsetParent = Element.Methods.getOffsetParent.wrap(
10604 function(proceed, element) {
10605 element = $(element);
10606 // IE throws an error if element is not in document
10607 try { element.offsetParent }
10609 var position = element.getStyle('position');
10610 if (position !== 'static') return proceed(element);
10611 element.setStyle({ position: 'relative' });
10612 var value = proceed(element);
10613 element.setStyle({ position: position });
10619 Element.Methods[method] = Element.Methods[method].wrap(
10620 function(proceed, element) {
10621 element = $(element);
10622 try { element.offsetParent }
10623 catch(e) { return Element._returnOffset(0,0) }
10624 var position = element.getStyle('position');
10625 if (position !== 'static') return proceed(element);
10628 var offsetParent = element.getOffsetParent();
10631 element.setStyle({ position: 'relative' });
10632 var value = proceed(element);
10633 element.setStyle({ position: position });
10639 Element.Methods.cumulativeOffset = Element.Methods.cumulativeOffset.wrap(
10640 function(proceed, element) {
10641 try { element.offsetParent }
10642 catch(e) { return Element._returnOffset(0,0) }
10643 return proceed(element);
10647 Element.Methods.getStyle = function(element, style) {
10648 element = $(element);
10650 var value = element.style[style];
10651 if (!value && element.currentStyle) value = element.currentStyle[style];
10654 if (value = (element.getStyle('filter') || '').match(/alpha\(opacity=(.*)\)/))
10660 if ((style == 'width' || style == 'height') && (element.getStyle('display') != 'none'))
10661 return element['offset' + style.capitalize()] + 'px';
10667 Element.Methods.setOpacity = function(element, value) {
10671 element = $(element);
10672 var currentStyle = element.currentStyle;
10674 (!currentStyle && element.style.zoom == 'normal'))
10675 element.style.zoom = 1;
10677 var filter = element.getStyle('filter'), style = element.style;
10681 return element;
10685 return element;
10688 Element._attributeTranslations = {
10695 _getAttr: function(element, attribute) {
10696 return element.getAttribute(attribute, 2);
10698 _getAttrNode: function(element, attribute) {
10699 var node = element.getAttributeNode(attribute);
10702 _getEv: function(element, attribute) {
10703 attribute = element.getAttribute(attribute);
10706 _flag: function(element, attribute) {
10707 return $(element).hasAttribute(attribute) ? attribute : null;
10709 style: function(element) {
10710 return element.style.cssText.toLowerCase();
10712 title: function(element) {
10713 return element.title;
10719 Element._attributeTranslations.write = {
10723 }, Element._attributeTranslations.read.names),
10725 checked: function(element, value) {
10726 element.checked = !!value;
10729 style: function(element, value) {
10730 element.style.cssText = value ? value : '';
10735 Element._attributeTranslations.has = {};
10739 Element._attributeTranslations.write.names[attr.toLowerCase()] = attr;
10740 Element._attributeTranslations.has[attr.toLowerCase()] = attr;
10772 })(Element._attributeTranslations.read.values);
10776 Element.Methods.setOpacity = function(element, value) {
10777 element = $(element);
10778 element.style.opacity = (value == 1) ? 0.999999 :
10780 return element;
10785 Element.Methods.setOpacity = function(element, value) {
10786 element = $(element);
10787 element.style.opacity = (value == 1 || value === '') ? '' :
10791 if(element.tagName.toUpperCase() == 'IMG' && element.width) {
10792 element.width++; element.width--;
10795 element.appendChild(n);
10796 element.removeChild(n);
10799 return element;
10803 // positioned. For performance reasons, redefine Element#cumulativeOffset for
10805 Element.Methods.cumulativeOffset = function(element) {
10808 valueT += element.offsetTop || 0;
10809 valueL += element.offsetLeft || 0;
10810 if (element.offsetParent == document.body)
10811 if (Element.getStyle(element, 'position') == 'absolute') break;
10813 element = element.offsetParent;
10814 } while (element);
10816 return Element._returnOffset(valueL, valueT);
10822 Element.Methods.update = function(element, content) {
10823 element = $(element);
10826 if (Object.isElement(content)) return element.update().insert(content);
10829 var tagName = element.tagName.toUpperCase();
10831 if (tagName in Element._insertionTranslations.tags) {
10832 $A(element.childNodes).each(function(node) { element.removeChild(node) });
10833 Element._getContentFromAnonymousElement(tagName, content.stripScripts())
10834 .each(function(node) { element.appendChild(node) });
10836 else element.innerHTML = content.stripScripts();
10839 return element;
10844 Element.Methods.replace = function(element, content) {
10845 element = $(element);
10849 element.parentNode.replaceChild(content, element);
10850 return element;
10854 var parent = element.parentNode, tagName = parent.tagName.toUpperCase();
10856 if (Element._insertionTranslations.tags[tagName]) {
10857 var nextSibling = element.next();
10858 var fragments = Element._getContentFromAnonymousElement(tagName, content.stripScripts());
10859 parent.removeChild(element);
10865 else element.outerHTML = content.stripScripts();
10868 return element;
10872 Element._returnOffset = function(l, t) {
10879 Element._getContentFromAnonymousElement = function(tagName, html) {
10880 var div = new Element('div'), t = Element._insertionTranslations.tags[tagName];
10888 Element._insertionTranslations = {
10889 before: function(element, node) {
10890 element.parentNode.insertBefore(node, element);
10892 top: function(element, node) {
10893 element.insertBefore(node, element.firstChild);
10895 bottom: function(element, node) {
10896 element.appendChild(node);
10898 after: function(element, node) {
10899 element.parentNode.insertBefore(node, element.nextSibling);
10916 }).call(Element._insertionTranslations);
10918 Element.Methods.Simulated = {
10919 hasAttribute: function(element, attribute) {
10920 attribute = Element._attributeTranslations.has[attribute] || attribute;
10921 var node = $(element).getAttributeNode(attribute);
10926 Element.Methods.ByTag = { };
10928 Object.extend(Element, Element.Methods);
10937 Element.extend = (function() {
10941 var Methods = { }, ByTag = Element.Methods.ByTag;
10943 var extend = Object.extend(function(element) {
10944 if (!element || element._extendedByPrototype ||
10945 element.nodeType != 1 || element == window) return element;
10948 tagName = element.tagName.toUpperCase(), property, value;
10955 if (Object.isFunction(value) && !(property in element))
10956 element[property] = value.methodize();
10959 element._extendedByPrototype = Prototype.emptyFunction;
10960 return element;
10966 Object.extend(Methods, Element.Methods);
10967 Object.extend(Methods, Element.Methods.Simulated);
10976 Element.hasAttribute = function(element, attribute) {
10977 if (element.hasAttribute) return element.hasAttribute(attribute);
10978 return Element.Methods.Simulated.hasAttribute(element, attribute);
10981 Element.addMethods = function(methods) {
10982 var F = Prototype.BrowserFeatures, T = Element.Methods.ByTag;
10986 Object.extend(Form.Element, Form.Element.Methods);
10987 Object.extend(Element.Methods.ByTag, {
10989 "INPUT": Object.clone(Form.Element.Methods),
10990 "SELECT": Object.clone(Form.Element.Methods),
10991 "TEXTAREA": Object.clone(Form.Element.Methods)
11000 if (!tagName) Object.extend(Element.Methods, methods || { });
11008 if (!Element.Methods.ByTag[tagName])
11009 Element.Methods.ByTag[tagName] = { };
11010 Object.extend(Element.Methods.ByTag[tagName], methods);
11036 if (trans[tagName]) klass = 'HTML' + trans[tagName] + 'Element';
11038 klass = 'HTML' + tagName + 'Element';
11040 klass = 'HTML' + tagName.capitalize() + 'Element';
11049 copy(Element.Methods, HTMLElement.prototype);
11050 copy(Element.Methods.Simulated, HTMLElement.prototype, true);
11054 for (var tag in Element.Methods.ByTag) {
11061 Object.extend(Element, Element.Methods);
11062 delete Element.ByTag;
11064 if (Element.extend.refresh) Element.extend.refresh();
11065 Element.cache = { };
11095 return Element._returnOffset(
11141 if (!Selector._div) Selector._div = new Element('div');
11144 // isolated element to minimize cost of this check.
11216 // of the context element. That's not what we want.
11223 results = $A(root.querySelectorAll(e)).map(Element.extend);
11234 match: function(element) {
11253 return this.findElements(document).include(element);
11262 if (!Selector.assertions[name](element, matches)) {
11421 // for Selector.match and Element#match
11423 tagName: function(element, matches) {
11424 return matches[1].toUpperCase() == element.tagName.toUpperCase();
11427 className: function(element, matches) {
11428 return Element.hasClassName(element, matches[1]);
11431 id: function(element, matches) {
11432 return element.id === matches[1];
11435 attrPresence: function(element, matches) {
11436 return Element.hasAttribute(element, matches[1]);
11439 attr: function(element, matches) {
11440 var nodeValue = Element.readAttribute(element, matches[1]);
11491 results.push(Element.extend(n));
11524 h.concat(results, Element.nextSiblings(node));
11571 if (Element.descendantOf(targetNode, node)) return [targetNode];
11582 return (targetNode && Element.descendantOf(targetNode, root)) ? [targetNode] : [];
11607 if (Element.hasAttribute(node, attr)) results.push(node);
11616 var nodeValue = Element.readAttribute(node, attr);
11718 // IE treats comments as element nodes
11779 for (var i = 0, results = [], element; element = elements[i]; i++)
11780 if (element._countedByPrototype) results.push(element);
11792 findChildElements: function(element, expressions) {
11797 h.concat(results, selector.findElements(element));
11836 var data = elements.inject({ }, function(result, element) {
11837 if (!element.disabled && element.name) {
11838 key = element.name; value = $(element).getValue();
11839 if (value != null && element.type != 'file' && (element.type != 'submit' || (!submitted &&
11864 if (Form.Element.Serializers[child.tagName.toLowerCase()])
11865 elements.push(Element.extend(child));
11875 if (!typeName && !name) return $A(inputs).map(Element.extend);
11881 matchingInputs.push(Element.extend(input));
11900 var elements = $(form).getElements().findAll(function(element) {
11901 return 'hidden' != element.type && !element.disabled;
11903 var firstByIndex = elements.findAll(function(element) {
11904 return element.hasAttribute('tabIndex') && element.tabIndex >= 0;
11905 }).sortBy(function(element) { return element.tabIndex }).first();
11907 return firstByIndex ? firstByIndex : elements.find(function(element) {
11908 return ['input', 'select', 'textarea'].include(element.tagName.toLowerCase());
11939 Form.Element = {
11940 focus: function(element) {
11941 element).focus();
11942 return element;
11945 select: function(element) {
11946 $(element).select();
11947 return element;
11951 Form.Element.Methods = {
11952 serialize: function(element) {
11953 element = $(element);
11954 if (!element.disabled && element.name) {
11955 var value = element.getValue();
11958 pair[element.name] = value;
11965 getValue: function(element) {
11966 element = $(element);
11967 var method = element.tagName.toLowerCase();
11968 return Form.Element.Serializers[method](element);
11971 setValue: function(element, value) {
11972 element = $(element);
11973 var method = element.tagName.toLowerCase();
11974 Form.Element.Serializers[method](element, value);
11975 return element;
11978 clear: function(element) {
11979 $(element).value = '';
11980 return element;
11983 present: function(element) {
11984 return $(element).value != '';
11987 activate: function(element) {
11988 element = $(element);
11990 element.focus();
11991 if (element.select && (element.tagName.toLowerCase() != 'input' ||
11992 !['button', 'reset', 'submit'].include(element.type)))
11993 element.select();
11995 return element;
11998 disable: function(element) {
11999 element = $(element);
12000 element.disabled = true;
12001 return element;
12004 enable: function(element) {
12005 element = $(element);
12006 element.disabled = false;
12007 return element;
12013 var Field = Form.Element;
12014 var $F = Form.Element.Methods.getValue;
12018 Form.Element.Serializers = {
12019 input: function(element, value) {
12020 switch (element.type.toLowerCase()) {
12023 return Form.Element.Serializers.inputSelector(element, value);
12025 return Form.Element.Serializers.textarea(element, value);
12029 inputSelector: function(element, value) {
12030 if (Object.isUndefined(value)) return element.checked ? element.value : null;
12031 else element.checked = !!value;
12034 textarea: function(element, value) {
12035 if (Object.isUndefined(value)) return element.value;
12036 else element.value = value;
12039 select: function(element, value) {
12041 return this[element.type == 'select-one' ?
12042 'selectOne' : 'selectMany'](element);
12045 for (var i = 0, length = element.length; i < length; i++) {
12046 opt = element.options[i];
12059 selectOne: function(element) {
12060 var index = element.selectedIndex;
12061 return index >= 0 ? this.optionValue(element.options[index]) : null;
12064 selectMany: function(element) {
12065 var values, length = element.length;
12069 var opt = element.options[i];
12076 // extend element because hasAttribute may not be native
12077 return Element.extend(opt).hasAttribute('value') ? opt.value : opt.text;
12084 initialize: function($super, element, frequency, callback) {
12086 this.element = $(element);
12094 this.callback(this.element, value);
12100 Form.Element.Observer = Class.create(Abstract.TimedObserver, {
12102 return Form.Element.getValue(this.element);
12108 return Form.serialize(this.element);
12115 initialize: function(element, callback) {
12116 this.element = $(element);
12120 if (this.element.tagName.toLowerCase() == 'form')
12123 this.registerCallback(this.element);
12129 this.callback(this.element, value);
12135 Form.getElements(this.element).each(this.registerCallback, this);
12138 registerCallback: function(element) {
12139 if (element.type) {
12140 switch (element.type.toLowerCase()) {
12143 Event.observe(element, 'click', this.onElementEvent.bind(this));
12146 Event.observe(element, 'change', this.onElementEvent.bind(this));
12153 Form.Element.EventObserver = Class.create(Abstract.EventObserver, {
12155 return Form.Element.getValue(this.element);
12161 return Form.serialize(this.element);
12185 var element;
12187 case 'mouseover': element = event.fromElement; break;
12188 case 'mouseout': element = event.toElement; break;
12191 return Element.extend(element);
12224 element: function(event) {
12241 return Element.extend(node);
12245 var element = Event.element(event);
12246 if (!expression) return element;
12247 var elements = [element].concat(element.ancestors());
12314 function getEventID(element) {
12315 if (element._prototypeEventID) return element._prototypeEventID[0];
12317 return element._prototypeEventID = [++arguments.callee.id];
12334 function createWrapper(element, eventName, handler) {
12335 var id = getEventID(element);
12345 handler.call(element, event);
12385 observe: function(element, eventName, handler) {
12386 element = $(element);
12389 var wrapper = createWrapper(element, eventName, handler);
12390 if (!wrapper) return element;
12392 if (element.addEventListener) {
12393 element.addEventListener(name, wrapper, false);
12395 element.attachEvent("on" + name, wrapper);
12398 return element;
12401 stopObserving: function(element, eventName, handler) {
12402 element = $(element);
12403 var id = getEventID(element), name = getDOMEventName(eventName);
12407 element.stopObserving(eventName, wrapper.handler);
12409 return element;
12413 element.stopObserving(eventName);
12415 return element;
12419 if (!wrapper) return element;
12421 if (element.removeEventListener) {
12422 element.removeEventListener(name, wrapper, false);
12424 element.detachEvent("on" + name, wrapper);
12429 return element;
12432 fire: function(element, eventName, memo) {
12433 element = $(element);
12434 if (element == document && document.createEvent && !element.dispatchEvent)
12435 element = document.documentElement;
12450 element.dispatchEvent(event);
12452 element.fireEvent(event.eventType, event);
12462 Element.addMethods({
12469 fire: Element.Methods.fire.methodize(),
12470 observe: Element.Methods.observe.methodize(),
12471 stopObserving: Element.Methods.stopObserving.methodize(),
12516 var Toggle = { display: Element.toggle };
12518 Element.Methods.childOf = Element.Methods.descendantOf;
12521 Before: function(element, content) {
12522 return Element.insert(element, {before:content});
12525 Top: function(element, content) {
12526 return Element.insert(element, {top:content});
12529 Bottom: function(element, content) {
12530 return Element.insert(element, {bottom:content});
12533 After: function(element
12534 return Element.insert(element, {after:content});
12541 // further below, that map to the newer Element methods.
12562 within: function(element, x, y) {
12564 return this.withinIncludingScrolloffsets(element, x, y);
12567 this.offset = Element.cumulativeOffset(element);
12570 y < this.offset[1] + element.offsetHeight &&
12572 x < this.offset[0] + element.offsetWidth);
12575 withinIncludingScrolloffsets: function(element, x, y) {
12576 var offsetcache = Element.cumulativeScrollOffset(element);
12580 this.offset = Element.cumulativeOffset(element);
12583 this.ycomp < this.offset[1] + element.offsetHeight &&
12585 this.xcomp < this.offset[0] + element.offsetWidth);
12589 overlap: function(mode, element) {
12592 return ((this.offset[1] + element.offsetHeight) - this.ycomp) /
12593 element.offsetHeight;
12595 return ((this.offset[0] + element.offsetWidth) - this.xcomp) /
12596 element.offsetWidth;
12599 // Deprecation layer -- use newer Element methods now (1.5.2).
12601 cumulativeOffset: Element.Methods.cumulativeOffset,
12603 positionedOffset: Element.Methods.positionedOffset,
12605 absolutize: function(element) {
12607 return Element.absolutize(element);
12610 relativize: function(element) {
12612 return Element.relativize(element);
12615 realOffset: Element.Methods.cumulativeScrollOffset,
12617 offsetParent: Element.Methods.getOffsetParent,
12619 page: Element.Methods.viewportOffset,
12623 return Element.clonePosition(target, source, options);
12635 function(element, className) {
12638 return cond ? document._getElementsByXPath('.//*' + cond, element) : [];
12639 } : function(element, className) {
12644 var nodes = $(element).getElementsByTagName('*');
12652 elements.push(Element.extend(child));
12660 }(Element.Methods);
12664 Element.ClassNames = Class.create();
12665 Element.ClassNames.prototype = {
12666 initialize: function(element) {
12667 this.element = $(element);
12671 this.element.className.split(/\s+/).select(function(name) {
12677 this.element.className = className;
12695 Object.extend(Element.ClassNames.prototype, Enumerable);
12699 Element.addMethods();
