| blob | 2e43a823581d7efd076dea7d734cf02ad3b91e42 |
2 /*
3 * jQuery 1.2.3 - 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-02-06 00:21:25 -0500 (Wed, 06 Feb 2008) $
10 * $Rev: 4663 $
11 */
13 // Map over jQuery in case of overwrite
18 // The jQuery object is actually just the init constructor 'enhanced'
20 };
22 // Map over the $ in case of overwrite
26 // Map the jQuery namespace to the '$' one
29 // A simple way to check for HTML strings or ID strings
30 // (both of which we optimize for)
33 // Is it a simple selector
38 // Make sure that a selection was provided
41 // Handle $(DOMElement)
47 // Handle HTML strings
49 // Are we dealing with HTML string or an ID?
52 // Verify a match, and that no context was specified for #id
55 // HANDLE: $(html) -> $(array)
59 // HANDLE: $("#id")
63 // Make sure an element was located
65 // Handle the case where IE and Opera return items
66 // by name instead of ID
70 // Otherwise, we inject the element directly into the jQuery object
75 }
77 else
78 selector = [];
79 }
81 // HANDLE: $(expr, [context])
82 // (which is just equivalent to: $(content).find(expr)
86 // HANDLE: $(function)
87 // Shortcut for document ready
92 // HANDLE: $(array)
95 // HANDLE: $(arraylike)
96 // Watch for when an array-like object, contains DOM nodes, is passed in as the selector
97 (selector.jquery || selector.length && selector != window && !selector.nodeType && selector[0] != undefined && selector[0].nodeType) && jQuery.makeArray( selector ) ||
99 // HANDLE: $(*)
101 },
103 // The current version of jQuery being used
106 // The number of elements contained in the matched element set
109 },
111 // The number of elements contained in the matched element set
114 // Get the Nth element in the matched element set OR
115 // Get the whole matched element set as a clean array
119 // Return a 'clean' array
122 // Return just the object
124 },
126 // Take an array of elements and push it onto the stack
127 // (returning the new matched element set)
129 // Build a new jQuery matched element set
132 // Add the old object onto the stack (as a reference)
135 // Return the newly-formed element set
137 },
139 // Force the current matched set of elements to become
140 // the specified array of elements (destroying the stack in the process)
141 // You should use pushStack() in order to do this, but maintain the stack
143 // Resetting the length to 0, then using the native Array push
144 // is a super-fast way to populate an object with array-like properties
149 },
151 // Execute a callback for every element in the matched set.
152 // (You can seed the arguments with an array of args, but this is
153 // only used internally.)
156 },
158 // Determine the position of an element within
159 // the matched set of elements
163 // Locate the position of the desired element
167 });
170 },
175 // Look for the case where we're accessing a style value
181 options = {};
183 }
185 // Check to see if we're setting style values
187 // Set all the styles
190 type ?
194 );
195 });
196 },
199 // ignore negative width and height values
203 },
207 return this.empty().append( (this[0] && this[0].ownerDocument || document).createTextNode( text ) );
217 });
218 });
221 },
225 // The elements to wrap the target around
236 })
240 },
245 });
246 },
251 });
252 },
258 });
259 },
265 });
266 },
271 });
272 },
277 });
278 },
282 },
287 });
291 elems );
292 },
295 // Do the clone
298 // IE copies events bound via attachEvent when
299 // using cloneNode. Calling detachEvent on the
300 // clone will also remove the events from the orignal
301 // In order to get around this, we use innerHTML.
302 // Unfortunately, this means some modifications to
303 // attributes in IE that are actually only stored
304 // as properties will not be copied (such as the
305 // the name attribute on an input).
312 });
314 // Need to set the expando to null on the cloned set if it exists
315 // removeData doesn't work here, IE removes it from the original as well
316 // this is primarily for IE but the data expando shouldn't be copied over in any browser
320 });
322 // Copy the events from the original to the clone
331 jQuery.event.add( clone[ i ], type, events[ type ][ handler ], events[ type ][ handler ].data );
332 });
334 // Return the cloned set
336 },
343 }) ||
346 },
350 // test special case where just one selector is passed in
353 else
356 var isArrayLike = selector.length && selector[selector.length - 1] !== undefined && !selector.nodeType;
359 });
360 },
369 },
375 },
379 },
387 // We need to handle select boxes special
390 values = [],
394 // Nothing was selected
398 // Loop through all the selected options
403 // Get the specifc value for the option
406 // We don't need an array for one selects
410 // Multi-Selects return an array
412 }
413 }
417 // Everything else, we just grab the value
421 }
424 }
436 value :
442 });
449 });
450 },
458 },
462 },
466 },
470 },
475 }));
476 },
480 },
494 data;
498 });
499 },
504 });
505 },
516 }
521 obj = this.getElementsByTagName("tbody")[0] || this.appendChild( this.ownerDocument.createElement("tbody") );
530 // execute all scripts after the elements have been injected
534 // Remove any inner scripts for later evaluation
538 // Inject the elements into the document
540 }
541 });
544 });
545 }
546 };
548 // Give the init function the jQuery prototype for later instantiation
557 });
559 else
564 }
567 // copy reference to target object
570 // Handle a deep copy situation
574 // skip the boolean and the target
576 }
578 // Handle case when target is a string or something (possible in deep copy)
580 target = {};
582 // extend jQuery itself if only one argument is passed
586 }
589 // Only deal with non-null/undefined values
591 // Extend the base object
593 // Prevent never-ending loop
597 // Recurse if we're merging object values
598 if ( deep && options[ name ] && typeof options[ name ] == "object" && target[ name ] && !options[ name ].nodeType )
601 // Don't bring in undefined values
605 }
607 // Return the modified object
609 };
613 // exclude the following css properties to add px
624 },
626 // See test/unit/core.js for details concerning this function.
630 },
632 // check if an element is in a (or is an) XML document
636 },
638 // Evalulates a script in a global context
643 // Inspired by code by Andrea Giammarchi
644 // http://webreflection.blogspot.com/2007/08/global-scope-evaluation-and-dom.html
651 else
656 }
657 },
661 },
663 cache: {},
667 windowData :
668 elem;
672 // Compute a unique ID for the element
676 // Only generate the data cache if we're
677 // trying to access or manipulate it
681 // Prevent overriding the named cache with undefined values
685 // Return the named cache data, or the ID for the element
688 id;
689 },
693 windowData :
694 elem;
698 // If we want to remove a specific section of the element's data
701 // Remove the section of cache data
704 // If we've removed all the data, remove the element's cache
712 }
714 // Otherwise, we want to remove all of the element's data
716 // Clean up the element expando
720 // IE has trouble directly removing the expando
721 // but it's ok with using removeAttribute
724 }
726 // Completely remove the data cache
728 }
729 },
731 // args is for internal usage only
743 // A special, fast, case for the most common use of each
752 }
755 },
758 // Handle executable functions
762 // Handle passing in a number to a CSS property
765 value;
766 },
768 className: {
769 // internal only, use addClass("class")
774 });
775 },
777 // internal only, use removeClass("class")
785 },
787 // internal only, use is(".class")
790 }
791 },
793 // A method for quickly swapping in/out CSS properties to get correct calculations
796 // Remember the old values, and insert the new ones
800 }
804 // Revert the old values
807 },
811 var val, props = { position: "absolute", visibility: "hidden", display:"block" }, which = name == "width" ? [ "Left", "Right" ] : [ "Top", "Bottom" ];
819 });
821 }
825 else
829 }
832 },
837 // A helper method for determining if an element's values are broken
844 }
846 // We need to handle opacity special in IE
852 ret;
853 }
854 // Opera sometimes will give the wrong display answer, this fixes it, see #2037
859 }
861 // Make sure we're using the right name for getting the float value
870 // Only "float" is needed here
881 // If the element isn't reporting its values properly in Safari
882 // then some display: none elements are involved
886 // Locate all of the parent display: none elements
890 // Go through and make them visible, but in reverse
891 // (It would be better if we knew the exact display type that they had)
896 }
898 // Since we flip the display style, we have to handle that
899 // one special, otherwise get the value
904 // Finally, revert the display styles back
908 }
910 // We should always get a number back from opacity
917 });
921 // From the awesome hack by Dean Edwards
922 // http://erik.eae.net/archives/2007/07/27/18.54.15/#comment-102291
924 // If we're not dealing with a regular pixel number
925 // but a number that has a weird ending, we need to convert it to pixels
927 // Remember the original values
930 // Put in the new values to get a computed value out
935 // Revert the changed values
938 }
939 }
942 },
947 // !context.createElement fails in IE with an error but returns typeof 'object'
958 // Convert html string into DOM nodes
960 // Fix "XHTML"-style tags in all browsers
963 all :
965 });
967 // Trim whitespace, otherwise indexOf won't work as expected
971 // option or optgroup
984 // <thead> matched above
991 // IE can't serialize <link> and <script> tags normally
997 // Go to html and back, then peel off extra wrappers
1000 // Move to the right depth
1004 // Remove IE's autoinserted <tbody> from table fragments
1007 // String was a <table>, *may* have spurious <tbody>
1011 // String was a bare <thead> or <tfoot>
1014 [];
1020 // IE completely kills leading whitespace when innerHTML is used
1024 }
1027 }
1029 if ( elem.length === 0 && (!jQuery.nodeName( elem, "form" ) && !jQuery.nodeName( elem, "select" )) )
1035 else
1038 });
1041 },
1044 // don't set attributes on text and comment nodes
1049 {} :
1052 // Safari mis-reports the default selected property of a hidden option
1053 // Accessing the parent's selectedIndex property fixes it
1057 // Certain attributes only work when accessed via the old DOM 0 way
1067 else if ( value == undefined && jQuery.browser.msie && jQuery.nodeName( elem, "form" ) && (name == "action" || name == "method") )
1070 // IE elem.getAttribute passes even for style
1074 // We can't allow the type property to be changed (since it causes problems in IE)
1078 // convert the value to a string (all browsers do this but IE) see #1070
1080 }
1087 // elem is actually elem.style ... set the style
1089 // IE actually uses filters for opacity
1092 // IE has trouble with opacity if it does not have layout
1093 // Force it by setting the zoom level
1096 // Set the alpha filter to set the opacity
1099 }
1104 }
1108 });
1114 }
1115 },
1119 },
1124 // Need to use typeof to fight Safari childNodes crashes
1128 else
1132 },
1140 },
1143 // We have to loop this way because IE & Opera overwrite the length
1144 // expando of getElementsByTagName
1146 // Also, we need to make sure that the correct elements are being returned
1147 // (IE returns comment nodes in a '*' query)
1158 },
1171 }
1172 }
1176 }
1179 },
1184 // Go through the array, only saving the items
1185 // that pass the validator function
1191 },
1196 // Go through the array, translating each of the items to their
1197 // new value (or values).
1206 }
1207 }
1210 }
1211 });
1215 // Figure out what browser is being used
1222 };
1229 // Check to see if the W3C box model is being used
1232 props: {
1250 }
1251 });
1262 contents: function(elem){return jQuery.nodeName(elem,"iframe")?elem.contentDocument||elem.contentWindow.document:jQuery.makeArray(elem.childNodes);}
1271 };
1272 });
1287 });
1288 };
1289 });
1296 },
1300 },
1304 },
1307 jQuery.className[ jQuery.className.has( this, classNames ) ? "remove" : "add" ]( this, classNames );
1308 },
1312 // Prevent memory leaks
1316 });
1319 }
1320 },
1323 // Remove element nodes and prevent memory leaks
1326 // Remove any remaining nodes
1329 }
1333 };
1334 });
1340 // Get window width or height
1342 // Opera reports document.body.client[Width/Height] properly in both quirks and standards
1345 // Safari reports inner[Width/Height] just fine (Mozilla and Opera include scroll bar widths)
1348 // Everyone else use document.documentElement or document.body depending on Quirks vs Standards mode
1349 document.compatMode == "CSS1Compat" && document.documentElement[ "client" + name ] || document.body[ "client" + name ] :
1351 // Get document width or height
1353 // Either scroll[Width/Height] or offset[Width/Height], whichever is greater
1357 ) :
1359 // Get or set width or height on the element
1361 // Get width or height on the element
1364 // Set the width or height on the element (default to pixels if value is unitless)
1366 };
1367 });
1377 expr: {
1381 // Position Checks
1391 // Child Checks
1396 // Parent Checks
1400 // Text Check
1401 contains: function(a,i,m){return (a.textContent||a.innerText||jQuery(a).text()||"").indexOf(m[3])>=0;},
1403 // Visibility
1404 visible: function(a){return "hidden"!=a.type&&jQuery.css(a,"display")!="none"&&jQuery.css(a,"visibility")!="hidden";},
1405 hidden: function(a){return "hidden"==a.type||jQuery.css(a,"display")=="none"||jQuery.css(a,"visibility")=="hidden";},
1407 // Form attributes
1413 // Form elements
1425 // :has()
1428 // :header
1431 // :animated
1432 animated: function(a){return jQuery.grep(jQuery.timers,function(fn){return a==fn.elem;}).length;}
1433 }
1434 },
1436 // The regular expressions that power the parsing engine
1437 parse: [
1438 // Match: [@value='test'], [@foo]
1441 // Match: :contains('foo')
1444 // Match: :even, :last-chlid, #id, .class
1446 ],
1456 }
1459 },
1462 // Quickly handle non-string expressions
1466 // check to make sure context is a DOM element or a document
1470 // Set the correct context (if none is provided)
1473 // Initialize the search
1476 // Continue while a selector expression exists, and while
1477 // we're no longer looping upon ourselves
1486 // An attempt at speeding up child selectors that
1487 // point to a specific element tag
1494 // Perform our own iteration and filter
1508 r = [];
1525 }
1528 }
1529 }
1533 // And remove the token
1536 }
1537 }
1539 // See if there's still an expression, and that we haven't already
1540 // matched a token
1542 // Handle multiple expressions
1544 // Clean the result set
1547 // Merge the result sets
1550 // Reset the context
1553 // Touch up the selector string
1557 // Optimize for the case nodeName#idName
1561 // Re-organize the results, so that they're consistent
1566 // Otherwise, do a traditional filter check for
1567 // ID, class, and element selectors
1570 }
1576 // Try to do a global search by ID, where we can
1578 // Optimization for HTML document case
1581 // Do a quick check for the existence of the actual ID attribute
1582 // to avoid selecting by the name attribute in IE
1583 // also check to insure id is a string to avoid selecting an element with the name of 'id' inside a form
1584 if ( (jQuery.browser.msie||jQuery.browser.opera) && oid && typeof oid.id == "string" && oid.id != m[2] )
1587 // Do a quick check for node name (where applicable) so
1588 // that div#foo searches will be really fast
1591 // We need to find all descendant elements
1593 // Grab the tag name being searched for
1596 // Handle IE7 being really dumb about <object>s
1601 }
1603 // It's faster to filter by class and be done with it
1607 // Same with ID filtering
1611 // Try to find the element with the ID
1616 }
1619 }
1622 }
1625 }
1627 }
1629 // If a selector string still exists
1631 // Attempt to filter it
1635 }
1636 }
1638 // An error occurred with the selector;
1639 // just return an empty set instead
1641 ret = [];
1643 // Remove the root context
1647 // And combine the results
1651 },
1660 }
1662 },
1667 // Look for common filter expressions
1677 // Remove what we just matched
1682 }
1683 }
1688 // :not() is a special case that can be optimized by
1689 // keeping it out of the expression list
1691 // optimize if only one selector found (most common case)
1696 // We can get a big speed boost by filtering by class here
1716 }
1720 // We can get a speed boost by handling nth-child here
1723 // parse equations like 'even', 'odd', '5', '2n', '3n+2', '4n-1', '-n+6'
1727 // calculate the numbers (first)n+(last) including if they are negative
1730 // loop through all the elements left in the jQuery object
1742 }
1754 }
1758 // Otherwise, find the expression to execute
1767 // Execute it against the current filter
1771 }
1772 }
1774 // Return an array of filtered elements (r)
1775 // and the modified expression string (t)
1777 },
1786 }
1788 },
1799 },
1807 }
1810 }
1811 });
1813 /*
1814 * A number of helper functions used for managing events.
1815 * Many of the ideas behind this code orignated from
1816 * Dean Edwards' addEvent library.
1817 */
1820 // Bind an event to an element
1821 // Original by Dean Edwards
1826 // For whatever reason, IE has trouble passing the window object
1827 // around, causing it to be cloned in the process
1831 // Make sure that the function being executed has a unique ID
1835 // if data is passed, bind to handler
1837 // Create temporary function pointer to original handler
1840 // Create unique handler function, wrapped around original handler
1842 // Pass arguments and context to original handler
1844 };
1846 // Store data in unique handler
1849 // Set the guid of unique handler to the same of original handler, so it can be removed
1851 }
1853 // Init the element's event structure
1856 // returned undefined or false
1859 // Handle the second event of a trigger and when
1860 // an event is called after a page has unloaded
1867 });
1868 // Add elem as a property of the handle function
1869 // This is to prevent a memory leak with non-native
1870 // event in IE.
1873 // Handle multiple events seperated by a space
1874 // jQuery(...).bind("mouseover mouseout", fn);
1876 // Namespaced event handlers
1881 // Get the current list of functions bound to this event
1884 // Init the event handler queue
1888 // Check for a special event handler
1889 // Only use addEventListener/attachEvent if the special
1890 // events handler returns false
1892 // Bind the global event handler to the element
1897 }
1898 }
1900 // Add the function to the element's handler list
1903 // Keep track of which events have been used, for global triggering
1905 });
1907 // Nullify elem to prevent memory leaks in IE
1909 },
1912 global: {},
1914 // Detach an event or set of events from an element
1916 // don't do events on text and comment nodes
1923 // Unbind all events for the element
1928 // types is actually an event object here
1932 }
1934 // Handle multiple events seperated by a space
1935 // jQuery(...).unbind("mouseover mouseout", fn);
1937 // Namespaced event handlers
1942 // remove the given handler for the given type
1946 // remove all handlers for the given type
1947 else
1949 // Handle the removal of namespaced events
1953 // remove generic event handler if no more handlers exist
1956 if ( !jQuery.event.special[type] || jQuery.event.special[type].teardown.call(elem) === false ) {
1961 }
1964 }
1965 }
1966 });
1967 }
1969 // Remove the expando if it's no longer used
1976 }
1977 }
1978 },
1981 // Clone the incoming data, if any
1987 }
1989 // Handle a global trigger
1991 // Only trigger if we've ever bound an event for it
1995 // Handle triggering a single element
1997 // don't do events on text and comment nodes
2002 // Check to see if we need to provide a fake event, or not
2005 // Pass along a fake event
2009 // Enforce the right trigger type
2014 // Trigger the event
2018 // Handle triggering native .onfoo handlers
2022 // Extra functions don't get the custom event object
2026 // Handle triggering of extra function
2028 // call the extra function and tack the current return value on the end for possible inspection
2030 // if anything is returned, give it precedence and have it overwrite the previous value
2033 }
2035 // Trigger the native events (except for clicks on links)
2036 if ( fn && donative !== false && val !== false && !(jQuery.nodeName(elem, 'a') && type == "click") ) {
2040 // prevent IE from throwing an error for some hidden elements
2042 }
2045 }
2048 },
2051 // returned undefined or false
2054 // Empty object is for triggered events with no data
2057 // Namespaced event handlers
2061 var handlers = jQuery.data(this, "events") && jQuery.data(this, "events")[event.type], args = Array.prototype.slice.call( arguments, 1 );
2066 // Pass in a reference to the handler function itself
2067 // So that we can later remove it
2071 // Filter the functions by class
2081 }
2082 }
2083 }
2085 // Clean up added properties in IE to prevent memory leak
2091 },
2094 // store a copy of the original event object
2095 // and clone to set read-only properties
2099 // add preventDefault and stopPropagation since
2100 // they will not work on the clone
2102 // if preventDefault exists run it on the original event
2105 // otherwise set the returnValue property of the original event to false (IE)
2107 };
2109 // if stopPropagation exists run it on the original event
2112 // otherwise set the cancelBubble property of the original event to true (IE)
2114 };
2116 // Fix target property, if necessary
2118 event.target = event.srcElement || document; // Fixes #1925 where srcElement might not be defined either
2120 // check if target is a textnode (safari)
2124 // Add relatedTarget, if necessary
2128 // Calculate pageX/Y if missing and clientX/Y available
2131 event.pageX = event.clientX + (doc && doc.scrollLeft || body && body.scrollLeft || 0) - (doc.clientLeft || 0);
2132 event.pageY = event.clientY + (doc && doc.scrollTop || body && body.scrollTop || 0) - (doc.clientTop || 0);
2133 }
2135 // Add which for key events
2136 if ( !event.which && ((event.charCode || event.charCode === 0) ? event.charCode : event.keyCode) )
2139 // Add metaKey to non-Mac browsers (use ctrl for PC's and Meta for Macs)
2143 // Add which for click: 1 == left; 2 == middle; 3 == right
2144 // Note: button is not normalized, so don't use it
2146 event.which = (event.button & 1 ? 1 : ( event.button & 2 ? 3 : ( event.button & 4 ? 2 : 0 ) ));
2149 },
2151 special: {
2152 ready: {
2154 // Make sure the ready event is setup
2157 },
2160 },
2162 mouseenter: {
2167 },
2173 },
2176 // If we actually just moused on to a sub-element, ignore it
2178 // Execute the right handlers by setting the event type to mouseenter
2181 }
2182 },
2184 mouseleave: {
2189 },
2195 },
2198 // If we actually just moused on to a sub-element, ignore it
2200 // Execute the right handlers by setting the event type to mouseleave
2203 }
2204 }
2205 }
2206 };
2212 });
2213 },
2221 });
2222 },
2227 });
2228 },
2233 });
2234 },
2240 },
2243 // Save reference to arguments for access in closure
2247 // Figure out which function to execute
2250 // Make sure that clicks stop
2253 // and execute the function
2255 });
2256 },
2260 },
2263 // Attach the listeners
2266 // If the DOM is already ready
2268 // Execute the function immediately
2271 // Otherwise, remember the function for later
2272 else
2273 // Add the function to the wait list
2277 }
2278 });
2282 readyList: [],
2283 // Handle when the DOM is ready
2285 // Make sure that the DOM is not already loaded
2287 // Remember that the DOM is ready
2290 // If there are functions bound, to execute
2292 // Execute all of them
2295 });
2297 // Reset the list of functions
2299 }
2301 // Trigger any bound ready events
2303 }
2304 }
2305 });
2313 // Mozilla, Opera (see further below for it) and webkit nightlies currently support this event
2315 // Use the handy event callback
2318 // If IE is used and is not in a frame
2319 // Continually check to see if the document is ready
2323 // If IE is used, use the trick by Diego Perini
2324 // http://javascript.nwbox.com/IEContentLoaded/
2329 }
2330 // and execute any waiting functions
2332 })();
2341 }
2342 // and execute any waiting functions
2353 }
2359 }
2360 // and execute any waiting functions
2362 })();
2363 }
2365 // A fallback to window.onload, that will always work
2367 }
2373 // Handle event binding
2376 };
2377 });
2379 // Checks if an event happened on an element within another element
2380 // Used in jQuery.event.special.mouseenter and mouseleave handlers
2382 // Check if mouse(over|out) are still within the same parent element
2384 // Traverse up the tree
2385 while ( parent && parent != elem ) try { parent = parent.parentNode; } catch(error) { parent = elem; }
2386 // Return true if we actually just moused on to a sub-element
2388 };
2390 // Prevent memory leaks in IE
2391 // And prevent errors on refresh with events like mouseover in other browsers
2392 // Window isn't included so as not to unbind existing unload events
2395 });
2405 }
2409 // Default to a GET request
2412 // If the second parameter was provided
2414 // If it's a function
2416 // We assume that it's the callback
2420 // Otherwise, build a param string
2424 }
2428 // Request the remote document
2435 // If successful, inject the HTML into all the matched elements
2437 // See if a selector was specified
2439 // Create a dummy div to hold the results
2441 // inject the contents of the document in, removing the scripts
2442 // to avoid any 'Permission Denied' errors in IE
2445 // Locate the specified elements
2448 // If not, just inject the full result
2452 }
2453 });
2455 },
2459 },
2464 })
2469 })
2476 }) :
2479 }
2480 });
2482 // Attach a bunch of functions for handling common AJAX events
2483 jQuery.each( "ajaxStart,ajaxStop,ajaxComplete,ajaxError,ajaxSuccess,ajaxSend".split(","), function(i,o){
2486 };
2487 });
2493 // shift arguments if data argument was ommited
2497 }
2504 dataType: type
2505 });
2506 },
2510 },
2514 },
2519 data = {};
2520 }
2527 dataType: type
2528 });
2529 },
2533 },
2535 ajaxSettings: {
2545 accepts: {
2552 }
2553 },
2555 // Last-Modified header cache for next request
2556 lastModified: {},
2561 // Extend the settings, but re-extend 's' so that it can be
2562 // checked again later (in the test suite, specifically)
2565 // convert data if not already a string
2569 // Handle JSONP Parameter Callbacks
2577 }
2579 // Build temporary JSONP function
2583 // Replace the =? sequence both in the query string and the data
2588 // We need to make sure
2589 // that a JSONP style response is executed properly
2592 // Handle JSONP-style loading
2597 // Garbage collect
2602 };
2603 }
2610 // try replacing _= if it is there
2612 // if nothing was replaced, add timestamp to the end
2614 }
2616 // If data is available, append data to url for get requests
2620 // IE likes to send both get and post data, prevent this
2622 }
2624 // Watch for a new set of requests
2628 // If we're requesting a remote document
2629 // and trying to load JSON or Script with a GET
2630 if ( (!s.url.indexOf("http") || !s.url.indexOf("//")) && s.dataType == "script" && s.type.toLowerCase() == "get" ) {
2637 // Handle Script loading
2641 // Attach handlers for all browsers
2649 }
2650 };
2651 }
2655 // We handle everything using the script element injection
2657 }
2661 // Create the request object; Microsoft failed to properly
2662 // implement the XMLHttpRequest in IE7, so we use the ActiveXObject when it is available
2663 var xml = window.ActiveXObject ? new ActiveXObject("Microsoft.XMLHTTP") : new XMLHttpRequest();
2665 // Open the socket
2668 // Need an extra try/catch for cross domain requests in Firefox 3
2670 // Set the correct header, if data is being sent
2674 // Set the If-Modified-Since header, if ifModified mode.
2679 // Set header so the called script knows that it's an XMLHttpRequest
2682 // Set the Accepts header for the server, depending on the dataType
2688 // Allow custom headers/mimetypes
2695 // Wait for a response to come back
2697 // The transfer is complete and the data is available, or the request timed out
2701 // clear poll interval
2705 }
2713 // Watch for, and catch, XML document parse errors
2715 // process the data (runs the xml through httpData regardless of callback)
2719 }
2720 }
2722 // Make sure that the request was successful or notmodified
2724 // Cache Last-Modified header, if ifModified mode.
2733 // JSONP handles its own success callback
2739 // Fire the complete handlers
2742 // Stop memory leaks
2745 }
2746 };
2749 // don't attach the handler to the request, just poll it instead
2752 // Timeout checker
2755 // Check to see if the request is still happening
2757 // Cancel the request
2762 }
2764 }
2766 // Send the data
2771 }
2773 // firefox 1.5 doesn't fire statechange for sync requests
2778 // If a local callback was specified, fire it and pass it the data
2782 // Fire the global callback
2785 }
2788 // Process result
2792 // The request was completed
2796 // Handle the global AJAX counter
2799 }
2801 // return XMLHttpRequest to allow aborting the request etc.
2803 },
2806 // If a local callback was specified, fire it
2809 // Fire the global callback
2812 },
2814 // Counter for holding the number of active queries
2817 // Determines if an XMLHttpRequest was successful or not
2820 // IE error sometimes returns 1223 when it should be 204 so treat it as success, see #1450
2826 },
2828 // Determines if an XMLHttpRequest returns NotModified
2833 // Firefox always returns 200. check Last-Modified date
2838 },
2848 // If the type is "script", eval it in global context
2852 // Get the JavaScript object, if JSON is used.
2857 },
2859 // Serialize an array of form elements or a set of
2860 // key/values into a query string
2864 // If an array was passed in, assume that it is an array
2865 // of form elements
2867 // Serialize the form elements
2870 });
2872 // Otherwise, assume that it's an object of key/value pairs
2873 else
2874 // Serialize the key/values
2876 // If the value is an array then the key names need to be repeated
2880 });
2881 else
2884 // Return the resulting serialization
2886 }
2888 });
2901 // handle an edge condition where css is - div { display:none; } or similar
2905 }
2907 },
2919 },
2921 // Save the old toggle function
2927 fn ?
2933 });
2934 },
2938 },
2942 },
2946 },
2950 },
2954 },
2958 },
2975 // Store display property
2978 // Make sure that nothing sneaks out
2980 }
2981 }
3001 // We need to compute starting value
3006 }
3008 // If a +=/-= token was provided, we're doing a relative animation
3015 }
3016 });
3018 // For JS strict compliance
3020 });
3021 },
3027 }
3040 }
3041 });
3042 },
3051 // go in reverse order so anything added to the queue during the loop is ignored
3055 // force the next step to be the last
3058 }
3059 });
3061 // start the next in the queue if the last step wasn't forced
3066 }
3068 });
3083 };
3095 });
3096 };
3106 };
3112 // Queueing
3119 };
3122 },
3124 easing: {
3127 },
3130 }
3131 },
3133 timers: [],
3143 }
3145 });
3149 // Simple function for setting a style value
3156 // Set display property to block for height/width animations
3159 },
3161 // Get the current size
3168 },
3170 // Start an animation from one number to another
3183 }
3200 }
3202 }
3203 },
3205 // Simple 'show' function
3207 // Remember where we started, so that we can go back to it later
3211 // Begin the animation
3214 // Make sure that we start at a small width/height to avoid any
3215 // flash of content
3219 // Start by showing the element
3221 },
3223 // Simple 'hide' function
3225 // Remember where we started, so that we can go back to it later
3229 // Begin the animation
3231 },
3233 // Each step of an animation
3251 // Reset the overflow
3254 // Reset the display
3258 }
3260 // Hide the element if the "hide" operation was done
3264 // Reset the properties, if the item has been hidden or shown
3268 }
3270 // If a callback was provided, execute it
3272 // Execute the complete function
3280 // Perform the easing function, defaults to swing
3281 this.pos = jQuery.easing[this.options.easing || (jQuery.easing.swing ? "swing" : "linear")](this.state, n, 0, 1, this.options.duration);
3284 // Perform the next step of the animation
3286 }
3289 }
3291 };
3296 },
3300 },
3304 },
3308 }
3309 };
3310 // The Offset Method
3311 // Originally By Brandon Aaron, part of the Dimension Plugin
3312 // http://jquery.com/plugins/project/dimensions
3324 // Use getBoundingClientRect if available
3328 // Add the document scroll offsets
3332 // IE adds the HTML element's border, by default it is medium which is 2px
3333 // IE 6 and 7 quirks mode the border width is overwritable by the following css html { border: 0; }
3334 // IE 7 standards mode, the border is always 2px
3335 // This border/offset is typically represented by the clientLeft and clientTop properties
3336 // However, in IE6 and 7 quirks mode the clientLeft and clientTop properties are not updated when overwriting it via CSS
3337 // Therefore this method will be off by 2px in IE while in quirksmode
3340 // Otherwise loop through the offsetParents and parentNodes
3343 // Initial element offsets
3346 // Get parent offsets
3348 // Add offsetParent offsets
3351 // Mozilla and Safari > 2 does not include the border on offset parents
3352 // However Mozilla adds the border for table or table cells
3356 // Add the document scroll offsets if position is fixed on any offsetParent
3360 // Set offsetChild to previous offsetParent unless it is the body element
3362 // Get next offsetParent
3364 }
3366 // Get parent scroll offsets
3368 // Remove parent scroll UNLESS that parent is inline or a table to work around Opera inline/table scrollLeft/Top bug
3370 // Subtract parent scroll offsets
3373 // Mozilla does not add the border for a parent that has overflow != visible
3377 // Get next parent
3379 }
3381 // Safari <= 2 doubles body offsets with a fixed position element/offsetParent or absolutely positioned offsetChild
3382 // Mozilla doubles body offsets with a non-absolutely positioned offsetChild
3387 // Add the document scroll offsets if position is fixed
3391 }
3393 // Return an object with top and left properties
3395 }
3398 add( jQuery.curCSS(elem, "borderLeftWidth", true), jQuery.curCSS(elem, "borderTopWidth", true) );
3399 }
3404 }
3407 };
3408 })();