| blob | 88e661eec806dc61eb5dfbd08fd0bae8343f96be |
2 /*
3 * jQuery 1.2.6 - New Wave Javascript
4 *
5 * Copyright (c) 2008 John Resig (jquery.com)
6 * Dual licensed under the MIT (MIT-LICENSE.txt)
7 * and GPL (GPL-LICENSE.txt) licenses.
8 *
9 * $Date: 2008-05-24 14:22:17 -0400 (Sat, 24 May 2008) $
10 * $Rev: 5685 $
11 */
13 // Map over jQuery in case of overwrite
15 // Map over the $ in case of overwrite
19 // The jQuery object is actually just the init constructor 'enhanced'
21 };
23 // A simple way to check for HTML strings or ID strings
24 // (both of which we optimize for)
27 // Is it a simple selector
30 // Will speed up references to undefined, and allows munging its name.
35 // Make sure that a selection was provided
38 // Handle $(DOMElement)
43 }
44 // Handle HTML strings
46 // Are we dealing with HTML string or an ID?
49 // Verify a match, and that no context was specified for #id
52 // HANDLE: $(html) -> $(array)
56 // HANDLE: $("#id")
60 // Make sure an element was located
62 // Handle the case where IE and Opera return items
63 // by name instead of ID
67 // Otherwise, we inject the element directly into the jQuery object
69 }
70 selector = [];
71 }
73 // HANDLE: $(expr, [context])
74 // (which is just equivalent to: $(content).find(expr)
78 // HANDLE: $(function)
79 // Shortcut for document ready
84 },
86 // The current version of jQuery being used
89 // The number of elements contained in the matched element set
92 },
94 // The number of elements contained in the matched element set
97 // Get the Nth element in the matched element set OR
98 // Get the whole matched element set as a clean array
102 // Return a 'clean' array
105 // Return just the object
107 },
109 // Take an array of elements and push it onto the stack
110 // (returning the new matched element set)
112 // Build a new jQuery matched element set
115 // Add the old object onto the stack (as a reference)
118 // Return the newly-formed element set
120 },
122 // Force the current matched set of elements to become
123 // the specified array of elements (destroying the stack in the process)
124 // You should use pushStack() in order to do this, but maintain the stack
126 // Resetting the length to 0, then using the native Array push
127 // is a super-fast way to populate an object with array-like properties
132 },
134 // Execute a callback for every element in the matched set.
135 // (You can seed the arguments with an array of args, but this is
136 // only used internally.)
139 },
141 // Determine the position of an element within
142 // the matched set of elements
146 // Locate the position of the desired element
148 // If it receives a jQuery object, the first element is used
151 },
156 // Look for the case where we're accessing a style value
162 options = {};
164 }
166 // Check to see if we're setting style values
168 // Set all the styles
171 type ?
175 );
176 });
177 },
180 // ignore negative width and height values
184 },
188 return this.empty().append( (this[0] && this[0].ownerDocument || document).createTextNode( text ) );
198 });
199 });
202 },
206 // The elements to wrap the target around
217 })
221 },
226 });
227 },
232 });
233 },
239 });
240 },
246 });
247 },
252 });
253 },
258 });
259 },
263 },
268 });
272 elems );
273 },
276 // Do the clone
279 // IE copies events bound via attachEvent when
280 // using cloneNode. Calling detachEvent on the
281 // clone will also remove the events from the orignal
282 // In order to get around this, we use innerHTML.
283 // Unfortunately, this means some modifications to
284 // attributes in IE that are actually only stored
285 // as properties will not be copied (such as the
286 // the name attribute on an input).
293 });
295 // Need to set the expando to null on the cloned set if it exists
296 // removeData doesn't work here, IE removes it from the original as well
297 // this is primarily for IE but the data expando shouldn't be copied over in any browser
301 });
303 // Copy the events from the original to the clone
312 jQuery.event.add( clone[ i ], type, events[ type ][ handler ], events[ type ][ handler ].data );
313 });
315 // Return the cloned set
317 },
324 }) ||
327 },
331 // test special case where just one selector is passed in
334 else
337 var isArrayLike = selector.length && selector[selector.length - 1] !== undefined && !selector.nodeType;
340 });
341 },
349 )));
350 },
354 },
358 },
366 // We need to handle select boxes special
369 values = [],
373 // Nothing was selected
377 // Loop through all the selected options
382 // Get the specifc value for the option
385 // We don't need an array for one selects
389 // Multi-Selects return an array
391 }
392 }
396 // Everything else, we just grab the value
400 }
403 }
422 });
429 });
430 },
438 },
442 },
446 },
450 },
455 }));
456 },
460 },
474 data;
478 });
479 },
484 });
485 },
496 }
501 obj = this.getElementsByTagName("tbody")[0] || this.appendChild( this.ownerDocument.createElement("tbody") );
510 // execute all scripts after the elements have been injected
514 // Remove any inner scripts for later evaluation
518 // Inject the elements into the document
520 }
521 });
524 });
525 }
526 };
528 // Give the init function the jQuery prototype for later instantiation
537 });
539 else
544 }
548 }
551 // copy reference to target object
554 // Handle a deep copy situation
558 // skip the boolean and the target
560 }
562 // Handle case when target is a string or something (possible in deep copy)
564 target = {};
566 // extend jQuery itself if only one argument is passed
570 }
573 // Only deal with non-null/undefined values
575 // Extend the base object
579 // Prevent never-ending loop
583 // Recurse if we're merging object values
586 // Never move original objects, clone them
590 // Don't bring in undefined values
594 }
596 // Return the modified object
598 };
601 // exclude the following css properties to add px
603 // cache defaultView
614 },
616 // See test/unit/core.js for details concerning this function.
620 },
622 // check if an element is in a (or is an) XML document
626 },
628 // Evalulates a script in a global context
633 // Inspired by code by Andrea Giammarchi
634 // http://webreflection.blogspot.com/2007/08/global-scope-evaluation-and-dom.html
641 else
644 // Use insertBefore instead of appendChild to circumvent an IE6 bug.
645 // This arises when a base node is used (#2709).
648 }
649 },
653 },
655 cache: {},
659 windowData :
660 elem;
664 // Compute a unique ID for the element
668 // Only generate the data cache if we're
669 // trying to access or manipulate it
673 // Prevent overriding the named cache with undefined values
677 // Return the named cache data, or the ID for the element
680 id;
681 },
685 windowData :
686 elem;
690 // If we want to remove a specific section of the element's data
693 // Remove the section of cache data
696 // If we've removed all the data, remove the element's cache
704 }
706 // Otherwise, we want to remove all of the element's data
708 // Clean up the element expando
712 // IE has trouble directly removing the expando
713 // but it's ok with using removeAttribute
716 }
718 // Completely remove the data cache
720 }
721 },
723 // args is for internal usage only
737 // A special, fast, case for the most common use of each
746 }
749 },
752 // Handle executable functions
756 // Handle passing in a number to a CSS property
759 value;
760 },
762 className: {
763 // internal only, use addClass("class")
768 });
769 },
771 // internal only, use removeClass("class")
779 },
781 // internal only, use hasClass("class")
784 }
785 },
787 // A method for quickly swapping in/out CSS properties to get correct calculations
790 // Remember the old values, and insert the new ones
794 }
798 // Revert the old values
801 },
805 var val, props = { position: "absolute", visibility: "hidden", display:"block" }, which = name == "width" ? [ "Left", "Right" ] : [ "Top", "Bottom" ];
813 });
815 }
819 else
823 }
826 },
831 // A helper method for determining if an element's values are broken
836 // defaultView is cached
839 }
841 // We need to handle opacity special in IE
847 ret;
848 }
849 // Opera sometimes will give the wrong display answer, this fixes it, see #2037
854 }
856 // Make sure we're using the right name for getting the float value
865 // Only "float" is needed here
876 // If the element isn't reporting its values properly in Safari
877 // then some display: none elements are involved
881 // Locate all of the parent display: none elements
885 // Go through and make them visible, but in reverse
886 // (It would be better if we knew the exact display type that they had)
891 }
893 // Since we flip the display style, we have to handle that
894 // one special, otherwise get the value
899 // Finally, revert the display styles back
903 }
905 // We should always get a number back from opacity
912 });
916 // From the awesome hack by Dean Edwards
917 // http://erik.eae.net/archives/2007/07/27/18.54.15/#comment-102291
919 // If we're not dealing with a regular pixel number
920 // but a number that has a weird ending, we need to convert it to pixels
922 // Remember the original values
925 // Put in the new values to get a computed value out
930 // Revert the changed values
933 }
934 }
937 },
942 // !context.createElement fails in IE with an error but returns typeof 'object'
953 // Convert html string into DOM nodes
955 // Fix "XHTML"-style tags in all browsers
958 all :
960 });
962 // Trim whitespace, otherwise indexOf won't work as expected
966 // option or optgroup
979 // <thead> matched above
986 // IE can't serialize <link> and <script> tags normally
992 // Go to html and back, then peel off extra wrappers
995 // Move to the right depth
999 // Remove IE's autoinserted <tbody> from table fragments
1002 // String was a <table>, *may* have spurious <tbody>
1006 // String was a bare <thead> or <tfoot>
1009 [];
1015 // IE completely kills leading whitespace when innerHTML is used
1019 }
1022 }
1024 if ( elem.length === 0 && (!jQuery.nodeName( elem, "form" ) && !jQuery.nodeName( elem, "select" )) )
1030 else
1033 });
1036 },
1039 // don't set attributes on text and comment nodes
1044 // Whether we are setting (or getting)
1048 // Try to normalize/fix the name
1051 // Only do all the following if this is a node (faster for style)
1052 // IE elem.getAttribute passes even for style
1055 // These attributes require special treatment
1058 // Safari mis-reports the default selected property of a hidden option
1059 // Accessing the parent's selectedIndex property fixes it
1063 // If applicable, access the attribute via the DOM 0 way
1066 // We can't allow the type property to be changed (since it causes problems in IE)
1071 }
1073 // browsers index elements by id/name on forms, give priority to attributes.
1078 }
1084 // convert the value to a string (all browsers do this but IE) see #1070
1088 // Some attributes require a special call on IE
1092 // Non-existent attributes return null, we normalize to undefined
1094 }
1096 // elem is actually elem.style ... set the style
1098 // IE uses filters for opacity
1101 // IE has trouble with opacity if it does not have layout
1102 // Force it by setting the zoom level
1105 // Set the alpha filter to set the opacity
1108 }
1113 }
1117 });
1123 },
1127 },
1134 //the window, strings and functions also have 'length'
1137 else
1140 }
1143 },
1147 // Use === because on IE, window == document
1152 },
1155 // We have to loop this way because IE & Opera overwrite the length
1156 // expando of getElementsByTagName
1158 // Also, we need to make sure that the correct elements are being returned
1159 // (IE returns comment nodes in a '*' query)
1170 },
1183 }
1184 }
1188 }
1191 },
1196 // Go through the array, only saving the items
1197 // that pass the validator function
1203 },
1208 // Go through the array, translating each of the items to their
1209 // new value (or values).
1215 }
1218 }
1219 });
1223 // Figure out what browser is being used
1230 };
1237 // Check to see if the W3C box model is being used
1240 props: {
1249 }
1250 });
1261 contents: function(elem){return jQuery.nodeName(elem,"iframe")?elem.contentDocument||elem.contentWindow.document:jQuery.makeArray(elem.childNodes);}
1270 };
1271 });
1286 });
1287 };
1288 });
1295 },
1299 },
1303 },
1306 jQuery.className[ jQuery.className.has( this, classNames ) ? "remove" : "add" ]( this, classNames );
1307 },
1311 // Prevent memory leaks
1315 });
1318 }
1319 },
1322 // Remove element nodes and prevent memory leaks
1325 // Remove any remaining nodes
1328 }
1332 };
1333 });
1339 // Get window width or height
1341 // Opera reports document.body.client[Width/Height] properly in both quirks and standards
1344 // Safari reports inner[Width/Height] just fine (Mozilla and Opera include scroll bar widths)
1347 // Everyone else use document.documentElement or document.body depending on Quirks vs Standards mode
1348 document.compatMode == "CSS1Compat" && document.documentElement[ "client" + name ] || document.body[ "client" + name ] :
1350 // Get document width or height
1352 // Either scroll[Width/Height] or offset[Width/Height], whichever is greater
1356 ) :
1358 // Get or set width or height on the element
1360 // Get width or height on the element
1363 // Set the width or height on the element (default to pixels if value is unitless)
1365 };
1366 });
1368 // Helper function used by the dimensions and offset modules
1379 expr: {
1383 // Position Checks
1393 // Child Checks
1398 // Parent Checks
1402 // Text Check
1403 contains: function(a,i,m){return (a.textContent||a.innerText||jQuery(a).text()||"").indexOf(m[3])>=0;},
1405 // Visibility
1406 visible: function(a){return "hidden"!=a.type&&jQuery.css(a,"display")!="none"&&jQuery.css(a,"visibility")!="hidden";},
1407 hidden: function(a){return "hidden"==a.type||jQuery.css(a,"display")=="none"||jQuery.css(a,"visibility")=="hidden";},
1409 // Form attributes
1415 // Form elements
1427 // :has()
1430 // :header
1433 // :animated
1434 animated: function(a){return jQuery.grep(jQuery.timers,function(fn){return a==fn.elem;}).length;}
1435 }
1436 },
1438 // The regular expressions that power the parsing engine
1439 parse: [
1440 // Match: [@value='test'], [@foo]
1443 // Match: :contains('foo')
1446 // Match: :even, :last-child, #id, .class
1448 ],
1458 }
1461 },
1464 // Quickly handle non-string expressions
1468 // check to make sure context is a DOM element or a document
1472 // Set the correct context (if none is provided)
1475 // Initialize the search
1478 // Continue while a selector expression exists, and while
1479 // we're no longer looping upon ourselves
1488 // An attempt at speeding up child selectors that
1489 // point to a specific element tag
1497 // Perform our own iteration and filter
1511 r = [];
1528 }
1531 }
1532 }
1536 // And remove the token
1539 }
1540 }
1542 // See if there's still an expression, and that we haven't already
1543 // matched a token
1545 // Handle multiple expressions
1547 // Clean the result set
1550 // Merge the result sets
1553 // Reset the context
1556 // Touch up the selector string
1560 // Optimize for the case nodeName#idName
1564 // Re-organize the results, so that they're consistent
1569 // Otherwise, do a traditional filter check for
1570 // ID, class, and element selectors
1573 }
1579 // Try to do a global search by ID, where we can
1581 // Optimization for HTML document case
1584 // Do a quick check for the existence of the actual ID attribute
1585 // to avoid selecting by the name attribute in IE
1586 // also check to insure id is a string to avoid selecting an element with the name of 'id' inside a form
1587 if ( (jQuery.browser.msie||jQuery.browser.opera) && oid && typeof oid.id == "string" && oid.id != m[2] )
1590 // Do a quick check for node name (where applicable) so
1591 // that div#foo searches will be really fast
1594 // We need to find all descendant elements
1596 // Grab the tag name being searched for
1599 // Handle IE7 being really dumb about <object>s
1604 }
1606 // It's faster to filter by class and be done with it
1610 // Same with ID filtering
1614 // Try to find the element with the ID
1619 }
1622 }
1625 }
1628 }
1630 }
1632 // If a selector string still exists
1634 // Attempt to filter it
1638 }
1639 }
1641 // An error occurred with the selector;
1642 // just return an empty set instead
1644 ret = [];
1646 // Remove the root context
1650 // And combine the results
1654 },
1663 }
1665 },
1670 // Look for common filter expressions
1680 // Remove what we just matched
1685 }
1686 }
1691 // :not() is a special case that can be optimized by
1692 // keeping it out of the expression list
1694 // optimize if only one selector found (most common case)
1699 // We can get a big speed boost by filtering by class here
1719 }
1723 // We can get a speed boost by handling nth-child here
1726 // parse equations like 'even', 'odd', '5', '2n', '3n+2', '4n-1', '-n+6'
1730 // calculate the numbers (first)n+(last) including if they are negative
1733 // loop through all the elements left in the jQuery object
1745 }
1757 }
1761 // Otherwise, find the expression to execute
1770 // Execute it against the current filter
1774 }
1775 }
1777 // Return an array of filtered elements (r)
1778 // and the modified expression string (t)
1780 },
1789 }
1791 },
1802 },
1810 }
1813 }
1814 });
1815 /*
1816 * A number of helper functions used for managing events.
1817 * Many of the ideas behind this code orignated from
1818 * Dean Edwards' addEvent library.
1819 */
1822 // Bind an event to an element
1823 // Original by Dean Edwards
1828 // For whatever reason, IE has trouble passing the window object
1829 // around, causing it to be cloned in the process
1833 // Make sure that the function being executed has a unique ID
1837 // if data is passed, bind to handler
1839 // Create temporary function pointer to original handler
1842 // Create unique handler function, wrapped around original handler
1844 // Pass arguments and context to original handler
1846 });
1848 // Store data in unique handler
1850 }
1852 // Init the element's event structure
1855 // Handle the second event of a trigger and when
1856 // an event is called after a page has unloaded
1859 });
1860 // Add elem as a property of the handle function
1861 // This is to prevent a memory leak with non-native
1862 // event in IE.
1865 // Handle multiple events separated by a space
1866 // jQuery(...).bind("mouseover mouseout", fn);
1868 // Namespaced event handlers
1873 // Get the current list of functions bound to this event
1876 // Init the event handler queue
1880 // Check for a special event handler
1881 // Only use addEventListener/attachEvent if the special
1882 // events handler returns false
1884 // Bind the global event handler to the element
1889 }
1890 }
1892 // Add the function to the element's handler list
1895 // Keep track of which events have been used, for global triggering
1897 });
1899 // Nullify elem to prevent memory leaks in IE
1901 },
1904 global: {},
1906 // Detach an event or set of events from an element
1908 // don't do events on text and comment nodes
1915 // Unbind all events for the element
1920 // types is actually an event object here
1924 }
1926 // Handle multiple events seperated by a space
1927 // jQuery(...).unbind("mouseover mouseout", fn);
1929 // Namespaced event handlers
1934 // remove the given handler for the given type
1938 // remove all handlers for the given type
1939 else
1941 // Handle the removal of namespaced events
1945 // remove generic event handler if no more handlers exist
1948 if ( !jQuery.event.special[type] || jQuery.event.special[type].teardown.call(elem) === false ) {
1953 }
1956 }
1957 }
1958 });
1959 }
1961 // Remove the expando if it's no longer used
1968 }
1969 }
1970 },
1973 // Clone the incoming data, if any
1979 }
1981 // Handle a global trigger
1983 // Only trigger if we've ever bound an event for it
1987 // Handle triggering a single element
1989 // don't do events on text and comment nodes
1994 // Check to see if we need to provide a fake event, or not
1997 // Pass along a fake event
2005 });
2007 }
2009 // Enforce the right trigger type
2014 // Trigger the event, it is assumed that "handle" is a function
2019 // Handle triggering native .onfoo handlers (and on links since we don't call .click() for links)
2020 if ( (!fn || (jQuery.nodeName(elem, 'a') && type == "click")) && elem["on"+type] && elem["on"+type].apply( elem, data ) === false )
2023 // Extra functions don't get the custom event object
2027 // Handle triggering of extra function
2029 // call the extra function and tack the current return value on the end for possible inspection
2031 // if anything is returned, give it precedence and have it overwrite the previous value
2034 }
2036 // Trigger the native events (except for clicks on links)
2037 if ( fn && donative !== false && val !== false && !(jQuery.nodeName(elem, 'a') && type == "click") ) {
2041 // prevent IE from throwing an error for some hidden elements
2043 }
2046 }
2049 },
2052 // returned undefined or false
2057 // Namespaced event handlers
2061 // Cache this now, all = true means, any handler
2069 // Filter the functions by class
2071 // Pass in a reference to the handler function itself
2072 // So that we can later remove it
2084 }
2085 }
2086 }
2089 },
2095 // store a copy of the original event object
2096 // and "clone" to set read-only properties
2099 var props = "altKey attrChange attrName bubbles button cancelable charCode clientX clientY ctrlKey currentTarget data detail eventPhase fromElement handler keyCode metaKey newValue originalTarget pageX pageY prevValue relatedNode relatedTarget screenX screenY shiftKey srcElement target timeStamp toElement type view wheelDelta which".split(" ");
2103 // Mark it as fixed
2106 // add preventDefault and stopPropagation since
2107 // they will not work on the clone
2109 // if preventDefault exists run it on the original event
2112 // otherwise set the returnValue property of the original event to false (IE)
2114 };
2116 // if stopPropagation exists run it on the original event
2119 // otherwise set the cancelBubble property of the original event to true (IE)
2121 };
2123 // Fix timeStamp
2126 // Fix target property, if necessary
2128 event.target = event.srcElement || document; // Fixes #1925 where srcElement might not be defined either
2130 // check if target is a textnode (safari)
2134 // Add relatedTarget, if necessary
2138 // Calculate pageX/Y if missing and clientX/Y available
2141 event.pageX = event.clientX + (doc && doc.scrollLeft || body && body.scrollLeft || 0) - (doc.clientLeft || 0);
2142 event.pageY = event.clientY + (doc && doc.scrollTop || body && body.scrollTop || 0) - (doc.clientTop || 0);
2143 }
2145 // Add which for key events
2146 if ( !event.which && ((event.charCode || event.charCode === 0) ? event.charCode : event.keyCode) )
2149 // Add metaKey to non-Mac browsers (use ctrl for PC's and Meta for Macs)
2153 // Add which for click: 1 == left; 2 == middle; 3 == right
2154 // Note: button is not normalized, so don't use it
2156 event.which = (event.button & 1 ? 1 : ( event.button & 2 ? 3 : ( event.button & 4 ? 2 : 0 ) ));
2159 },
2162 // Set the guid of unique handler to the same of original handler, so it can be removed
2164 // So proxy can be declared as an argument
2166 },
2168 special: {
2169 ready: {
2171 // Make sure the ready event is setup
2174 },
2177 },
2179 mouseenter: {
2184 },
2190 },
2193 // If we actually just moused on to a sub-element, ignore it
2195 // Execute the right handlers by setting the event type to mouseenter
2198 }
2199 },
2201 mouseleave: {
2206 },
2212 },
2215 // If we actually just moused on to a sub-element, ignore it
2217 // Execute the right handlers by setting the event type to mouseleave
2220 }
2221 }
2222 }
2223 };
2229 });
2230 },
2236 });
2239 });
2240 },
2245 });
2246 },
2251 });
2252 },
2256 },
2259 // Save reference to arguments for access in closure
2262 // link all the functions, so any of them can unbind this click handler
2267 // Figure out which function to execute
2270 // Make sure that clicks stop
2273 // and execute the function
2275 }));
2276 },
2280 },
2283 // Attach the listeners
2286 // If the DOM is already ready
2288 // Execute the function immediately
2291 // Otherwise, remember the function for later
2292 else
2293 // Add the function to the wait list
2297 }
2298 });
2302 readyList: [],
2303 // Handle when the DOM is ready
2305 // Make sure that the DOM is not already loaded
2307 // Remember that the DOM is ready
2310 // If there are functions bound, to execute
2312 // Execute all of them
2315 });
2317 // Reset the list of functions
2319 }
2321 // Trigger any bound ready events
2323 }
2324 }
2325 });
2333 // Mozilla, Opera (see further below for it) and webkit nightlies currently support this event
2335 // Use the handy event callback
2338 // If IE is used and is not in a frame
2339 // Continually check to see if the document is ready
2343 // If IE is used, use the trick by Diego Perini
2344 // http://javascript.nwbox.com/IEContentLoaded/
2349 }
2350 // and execute any waiting functions
2352 })();
2361 }
2362 // and execute any waiting functions
2373 }
2379 }
2380 // and execute any waiting functions
2382 })();
2383 }
2385 // A fallback to window.onload, that will always work
2387 }
2393 // Handle event binding
2396 };
2397 });
2399 // Checks if an event happened on an element within another element
2400 // Used in jQuery.event.special.mouseenter and mouseleave handlers
2402 // Check if mouse(over|out) are still within the same parent element
2404 // Traverse up the tree
2405 while ( parent && parent != elem ) try { parent = parent.parentNode; } catch(error) { parent = elem; }
2406 // Return true if we actually just moused on to a sub-element
2408 };
2410 // Prevent memory leaks in IE
2411 // And prevent errors on refresh with events like mouseover in other browsers
2412 // Window isn't included so as not to unbind existing unload events
2415 });
2417 // Keep a copy of the old load
2428 }
2432 // Default to a GET request
2435 // If the second parameter was provided
2437 // If it's a function
2439 // We assume that it's the callback
2443 // Otherwise, build a param string
2447 }
2451 // Request the remote document
2458 // If successful, inject the HTML into all the matched elements
2460 // See if a selector was specified
2462 // Create a dummy div to hold the results
2464 // inject the contents of the document in, removing the scripts
2465 // to avoid any 'Permission Denied' errors in IE
2468 // Locate the specified elements
2471 // If not, just inject the full result
2475 }
2476 });
2478 },
2482 },
2487 })
2492 })
2499 }) :
2502 }
2503 });
2505 // Attach a bunch of functions for handling common AJAX events
2506 jQuery.each( "ajaxStart,ajaxStop,ajaxComplete,ajaxError,ajaxSuccess,ajaxSend".split(","), function(i,o){
2509 };
2510 });
2516 // shift arguments if data argument was ommited
2520 }
2527 dataType: type
2528 });
2529 },
2533 },
2537 },
2542 data = {};
2543 }
2550 dataType: type
2551 });
2552 },
2556 },
2558 ajaxSettings: {
2569 accepts: {
2576 }
2577 },
2579 // Last-Modified header cache for next request
2580 lastModified: {},
2583 // Extend the settings, but re-extend 's' so that it can be
2584 // checked again later (in the test suite, specifically)
2590 // convert data if not already a string
2594 // Handle JSONP Parameter Callbacks
2602 }
2604 // Build temporary JSONP function
2608 // Replace the =? sequence both in the query string and the data
2613 // We need to make sure
2614 // that a JSONP style response is executed properly
2617 // Handle JSONP-style loading
2622 // Garbage collect
2627 };
2628 }
2635 // try replacing _= if it is there
2637 // if nothing was replaced, add timestamp to the end
2639 }
2641 // If data is available, append data to url for get requests
2645 // IE likes to send both get and post data, prevent this
2647 }
2649 // Watch for a new set of requests
2653 // Matches an absolute URL, and saves the domain
2656 // If we're requesting a remote document
2657 // and trying to load JSON or Script with a GET
2666 // Handle Script loading
2670 // Attach handlers for all browsers
2678 }
2679 };
2680 }
2684 // We handle everything using the script element injection
2686 }
2690 // Create the request object; Microsoft failed to properly
2691 // implement the XMLHttpRequest in IE7, so we use the ActiveXObject when it is available
2692 var xhr = window.ActiveXObject ? new ActiveXObject("Microsoft.XMLHTTP") : new XMLHttpRequest();
2694 // Open the socket
2695 // Passing null username, generates a login popup on Opera (#2865)
2698 else
2701 // Need an extra try/catch for cross domain requests in Firefox 3
2703 // Set the correct header, if data is being sent
2707 // Set the If-Modified-Since header, if ifModified mode.
2712 // Set header so the called script knows that it's an XMLHttpRequest
2715 // Set the Accepts header for the server, depending on the dataType
2721 // Allow custom headers/mimetypes
2723 // cleanup active request counter
2725 // close opended socket
2728 }
2733 // Wait for a response to come back
2735 // The transfer is complete and the data is available, or the request timed out
2739 // clear poll interval
2743 }
2751 // Watch for, and catch, XML document parse errors
2753 // process the data (runs the xml through httpData regardless of callback)
2757 }
2758 }
2760 // Make sure that the request was successful or notmodified
2762 // Cache Last-Modified header, if ifModified mode.
2771 // JSONP handles its own success callback
2777 // Fire the complete handlers
2780 // Stop memory leaks
2783 }
2784 };
2787 // don't attach the handler to the request, just poll it instead
2790 // Timeout checker
2793 // Check to see if the request is still happening
2795 // Cancel the request
2800 }
2802 }
2804 // Send the data
2809 }
2811 // firefox 1.5 doesn't fire statechange for sync requests
2816 // If a local callback was specified, fire it and pass it the data
2820 // Fire the global callback
2823 }
2826 // Process result
2830 // The request was completed
2834 // Handle the global AJAX counter
2837 }
2839 // return XMLHttpRequest to allow aborting the request etc.
2841 },
2844 // If a local callback was specified, fire it
2847 // Fire the global callback
2850 },
2852 // Counter for holding the number of active queries
2855 // Determines if an XMLHttpRequest was successful or not
2858 // IE error sometimes returns 1223 when it should be 204 so treat it as success, see #1450
2864 },
2866 // Determines if an XMLHttpRequest returns NotModified
2871 // Firefox always returns 200. check Last-Modified date
2876 },
2886 // Allow a pre-filtering function to sanitize the response
2890 // If the type is "script", eval it in global context
2894 // Get the JavaScript object, if JSON is used.
2899 },
2901 // Serialize an array of form elements or a set of
2902 // key/values into a query string
2906 // If an array was passed in, assume that it is an array
2907 // of form elements
2909 // Serialize the form elements
2912 });
2914 // Otherwise, assume that it's an object of key/value pairs
2915 else
2916 // Serialize the key/values
2918 // If the value is an array then the key names need to be repeated
2922 });
2923 else
2924 s.push( encodeURIComponent(j) + "=" + encodeURIComponent( jQuery.isFunction(a[j]) ? a[j]() : a[j] ) );
2926 // Return the resulting serialization
2928 }
2930 });
2943 // handle an edge condition where css is - div { display:none; } or similar
2947 }
2949 },
2961 },
2963 // Save the old toggle function
2969 fn ?
2975 });
2976 },
2980 },
2984 },
2988 },
2992 },
2996 },
3000 },
3017 // Store display property
3020 // Make sure that nothing sneaks out
3022 }
3023 }
3043 // We need to compute starting value
3048 }
3050 // If a +=/-= token was provided, we're doing a relative animation
3057 }
3058 });
3060 // For JS strict compliance
3062 });
3063 },
3069 }
3082 }
3083 });
3084 },
3093 // go in reverse order so anything added to the queue during the loop is ignored
3097 // force the next step to be the last
3100 }
3101 });
3103 // start the next in the queue if the last step wasn't forced
3108 }
3110 });
3122 }
3124 };
3136 });
3137 };
3147 };
3153 // Queueing
3160 };
3163 },
3165 easing: {
3168 },
3171 }
3172 },
3174 timers: [],
3184 }
3186 });
3190 // Simple function for setting a style value
3197 // Set display property to block for height/width animations
3200 },
3202 // Get the current size
3209 },
3211 // Start an animation from one number to another
3224 }
3241 }
3243 }
3244 },
3246 // Simple 'show' function
3248 // Remember where we started, so that we can go back to it later
3252 // Begin the animation
3255 // Make sure that we start at a small width/height to avoid any
3256 // flash of content
3260 // Start by showing the element
3262 },
3264 // Simple 'hide' function
3266 // Remember where we started, so that we can go back to it later
3270 // Begin the animation
3272 },
3274 // Each step of an animation
3292 // Reset the overflow
3295 // Reset the display
3299 }
3301 // Hide the element if the "hide" operation was done
3305 // Reset the properties, if the item has been hidden or shown
3309 }
3312 // Execute the complete function
3320 // Perform the easing function, defaults to swing
3321 this.pos = jQuery.easing[this.options.easing || (jQuery.easing.swing ? "swing" : "linear")](this.state, n, 0, 1, this.options.duration);
3324 // Perform the next step of the animation
3326 }
3329 }
3331 };
3334 speeds:{
3337 // Default speed
3339 },
3340 step: {
3343 },
3347 },
3351 },
3355 }
3356 }
3357 });
3358 // The Offset Method
3359 // Originally By Brandon Aaron, part of the Dimension Plugin
3360 // http://jquery.com/plugins/project/dimensions
3373 // Use getBoundingClientRect if available
3377 // Add the document scroll offsets
3381 // IE adds the HTML element's border, by default it is medium which is 2px
3382 // IE 6 and 7 quirks mode the border width is overwritable by the following css html { border: 0; }
3383 // IE 7 standards mode, the border is always 2px
3384 // This border/offset is typically represented by the clientLeft and clientTop properties
3385 // However, in IE6 and 7 quirks mode the clientLeft and clientTop properties are not updated when overwriting it via CSS
3386 // Therefore this method will be off by 2px in IE while in quirksmode
3389 // Otherwise loop through the offsetParents and parentNodes
3392 // Initial element offsets
3395 // Get parent offsets
3397 // Add offsetParent offsets
3400 // Mozilla and Safari > 2 does not include the border on offset parents
3401 // However Mozilla adds the border for table or table cells
3405 // Add the document scroll offsets if position is fixed on any offsetParent
3409 // Set offsetChild to previous offsetParent unless it is the body element
3411 // Get next offsetParent
3413 }
3415 // Get parent scroll offsets
3417 // Remove parent scroll UNLESS that parent is inline or a table to work around Opera inline/table scrollLeft/Top bug
3419 // Subtract parent scroll offsets
3422 // Mozilla does not add the border for a parent that has overflow != visible
3426 // Get next parent
3428 }
3430 // Safari <= 2 doubles body offsets with a fixed position element/offsetParent or absolutely positioned offsetChild
3431 // Mozilla doubles body offsets with a non-absolutely positioned offsetChild
3436 // Add the document scroll offsets if position is fixed
3440 }
3442 // Return an object with top and left properties
3444 }
3447 add( jQuery.curCSS(elem, "borderLeftWidth", true), jQuery.curCSS(elem, "borderTopWidth", true) );
3448 }
3453 }
3456 };
3464 // Get *real* offsetParent
3467 // Get correct offsets
3469 parentOffset = /^body|html$/i.test(offsetParent[0].tagName) ? { top: 0, left: 0 } : offsetParent.offset();
3471 // Subtract element margins
3472 // note: when an element has margin: auto the offsetLeft and marginLeft
3473 // are the same in Safari causing offset.left to incorrectly be 0
3477 // Add offsetParent borders
3481 // Subtract the two offsets
3482 results = {
3485 };
3486 }
3489 },
3493 while ( offsetParent && (!/^body|html$/i.test(offsetParent.tagName) && jQuery.css(offsetParent, 'position') == 'static') )
3496 }
3497 });
3500 // Create scrollLeft and scrollTop methods
3509 // Set the scroll offset
3515 ) :
3517 }) :
3519 // Return the scroll offset
3525 };
3526 });
3527 // Create innerHeight, innerWidth, outerHeight and outerWidth methods
3533 // innerHeight and innerWidth
3538 };
3540 // outerHeight and outerWidth
3547 };
3549 });})();