").append( jQuery.parseHTML( responseText ) ).find( selector ) :
+
+ // Otherwise use the full result
+ responseText );
+
+ }).complete( callback && function( jqXHR, status ) {
+ self.each( callback, response || [ jqXHR.responseText, status, jqXHR ] );
+ });
+ }
+
+ return this;
+};
+
+// Attach a bunch of functions for handling common AJAX events
+jQuery.each( [ "ajaxStart", "ajaxStop", "ajaxComplete", "ajaxError", "ajaxSuccess", "ajaxSend" ], function( i, type ){
+ jQuery.fn[ type ] = function( fn ){
+ return this.on( type, fn );
+ };
+});
+
+jQuery.each( [ "get", "post" ], function( i, method ) {
+ jQuery[ method ] = function( url, data, callback, type ) {
+ // shift arguments if data argument was omitted
+ if ( jQuery.isFunction( data ) ) {
+ type = type || callback;
+ callback = data;
+ data = undefined;
+ }
+
+ return jQuery.ajax({
+ url: url,
+ type: method,
+ dataType: type,
+ data: data,
+ success: callback
+ });
+ };
+});
+
+jQuery.extend({
+
+ // Counter for holding the number of active queries
+ active: 0,
+
+ // Last-Modified header cache for next request
+ lastModified: {},
+ etag: {},
+
+ ajaxSettings: {
+ url: ajaxLocation,
+ type: "GET",
+ isLocal: rlocalProtocol.test( ajaxLocParts[ 1 ] ),
+ global: true,
+ processData: true,
+ async: true,
+ contentType: "application/x-www-form-urlencoded; charset=UTF-8",
+ /*
+ timeout: 0,
+ data: null,
+ dataType: null,
+ username: null,
+ password: null,
+ cache: null,
+ throws: false,
+ traditional: false,
+ headers: {},
+ */
+
+ accepts: {
+ "*": allTypes,
+ text: "text/plain",
+ html: "text/html",
+ xml: "application/xml, text/xml",
+ json: "application/json, text/javascript"
+ },
+
+ contents: {
+ xml: /xml/,
+ html: /html/,
+ json: /json/
+ },
+
+ responseFields: {
+ xml: "responseXML",
+ text: "responseText"
+ },
+
+ // Data converters
+ // Keys separate source (or catchall "*") and destination types with a single space
+ converters: {
+
+ // Convert anything to text
+ "* text": window.String,
+
+ // Text to html (true = no transformation)
+ "text html": true,
+
+ // Evaluate text as a json expression
+ "text json": jQuery.parseJSON,
+
+ // Parse text as xml
+ "text xml": jQuery.parseXML
+ },
+
+ // For options that shouldn't be deep extended:
+ // you can add your own custom options here if
+ // and when you create one that shouldn't be
+ // deep extended (see ajaxExtend)
+ flatOptions: {
+ url: true,
+ context: true
+ }
+ },
+
+ // Creates a full fledged settings object into target
+ // with both ajaxSettings and settings fields.
+ // If target is omitted, writes into ajaxSettings.
+ ajaxSetup: function( target, settings ) {
+ return settings ?
+
+ // Building a settings object
+ ajaxExtend( ajaxExtend( target, jQuery.ajaxSettings ), settings ) :
+
+ // Extending ajaxSettings
+ ajaxExtend( jQuery.ajaxSettings, target );
+ },
+
+ ajaxPrefilter: addToPrefiltersOrTransports( prefilters ),
+ ajaxTransport: addToPrefiltersOrTransports( transports ),
+
+ // Main method
+ ajax: function( url, options ) {
+
+ // If url is an object, simulate pre-1.5 signature
+ if ( typeof url === "object" ) {
+ options = url;
+ url = undefined;
+ }
+
+ // Force options to be an object
+ options = options || {};
+
+ var transport,
+ // URL without anti-cache param
+ cacheURL,
+ // Response headers
+ responseHeadersString,
+ responseHeaders,
+ // timeout handle
+ timeoutTimer,
+ // Cross-domain detection vars
+ parts,
+ // To know if global events are to be dispatched
+ fireGlobals,
+ // Loop variable
+ i,
+ // Create the final options object
+ s = jQuery.ajaxSetup( {}, options ),
+ // Callbacks context
+ callbackContext = s.context || s,
+ // Context for global events is callbackContext if it is a DOM node or jQuery collection
+ globalEventContext = s.context && ( callbackContext.nodeType || callbackContext.jquery ) ?
+ jQuery( callbackContext ) :
+ jQuery.event,
+ // Deferreds
+ deferred = jQuery.Deferred(),
+ completeDeferred = jQuery.Callbacks("once memory"),
+ // Status-dependent callbacks
+ statusCode = s.statusCode || {},
+ // Headers (they are sent all at once)
+ requestHeaders = {},
+ requestHeadersNames = {},
+ // The jqXHR state
+ state = 0,
+ // Default abort message
+ strAbort = "canceled",
+ // Fake xhr
+ jqXHR = {
+ readyState: 0,
+
+ // Builds headers hashtable if needed
+ getResponseHeader: function( key ) {
+ var match;
+ if ( state === 2 ) {
+ if ( !responseHeaders ) {
+ responseHeaders = {};
+ while ( (match = rheaders.exec( responseHeadersString )) ) {
+ responseHeaders[ match[1].toLowerCase() ] = match[ 2 ];
+ }
+ }
+ match = responseHeaders[ key.toLowerCase() ];
+ }
+ return match == null ? null : match;
+ },
+
+ // Raw string
+ getAllResponseHeaders: function() {
+ return state === 2 ? responseHeadersString : null;
+ },
+
+ // Caches the header
+ setRequestHeader: function( name, value ) {
+ var lname = name.toLowerCase();
+ if ( !state ) {
+ name = requestHeadersNames[ lname ] = requestHeadersNames[ lname ] || name;
+ requestHeaders[ name ] = value;
+ }
+ return this;
+ },
+
+ // Overrides response content-type header
+ overrideMimeType: function( type ) {
+ if ( !state ) {
+ s.mimeType = type;
+ }
+ return this;
+ },
+
+ // Status-dependent callbacks
+ statusCode: function( map ) {
+ var code;
+ if ( map ) {
+ if ( state < 2 ) {
+ for ( code in map ) {
+ // Lazy-add the new callback in a way that preserves old ones
+ statusCode[ code ] = [ statusCode[ code ], map[ code ] ];
+ }
+ } else {
+ // Execute the appropriate callbacks
+ jqXHR.always( map[ jqXHR.status ] );
+ }
+ }
+ return this;
+ },
+
+ // Cancel the request
+ abort: function( statusText ) {
+ var finalText = statusText || strAbort;
+ if ( transport ) {
+ transport.abort( finalText );
+ }
+ done( 0, finalText );
+ return this;
+ }
+ };
+
+ // Attach deferreds
+ deferred.promise( jqXHR ).complete = completeDeferred.add;
+ jqXHR.success = jqXHR.done;
+ jqXHR.error = jqXHR.fail;
+
+ // Remove hash character (#7531: and string promotion)
+ // Add protocol if not provided (#5866: IE7 issue with protocol-less urls)
+ // Handle falsy url in the settings object (#10093: consistency with old signature)
+ // We also use the url parameter if available
+ s.url = ( ( url || s.url || ajaxLocation ) + "" ).replace( rhash, "" ).replace( rprotocol, ajaxLocParts[ 1 ] + "//" );
+
+ // Alias method option to type as per ticket #12004
+ s.type = options.method || options.type || s.method || s.type;
+
+ // Extract dataTypes list
+ s.dataTypes = jQuery.trim( s.dataType || "*" ).toLowerCase().match( core_rnotwhite ) || [""];
+
+ // A cross-domain request is in order when we have a protocol:host:port mismatch
+ if ( s.crossDomain == null ) {
+ parts = rurl.exec( s.url.toLowerCase() );
+ s.crossDomain = !!( parts &&
+ ( parts[ 1 ] !== ajaxLocParts[ 1 ] || parts[ 2 ] !== ajaxLocParts[ 2 ] ||
+ ( parts[ 3 ] || ( parts[ 1 ] === "http:" ? 80 : 443 ) ) !=
+ ( ajaxLocParts[ 3 ] || ( ajaxLocParts[ 1 ] === "http:" ? 80 : 443 ) ) )
+ );
+ }
+
+ // Convert data if not already a string
+ if ( s.data && s.processData && typeof s.data !== "string" ) {
+ s.data = jQuery.param( s.data, s.traditional );
+ }
+
+ // Apply prefilters
+ inspectPrefiltersOrTransports( prefilters, s, options, jqXHR );
+
+ // If request was aborted inside a prefilter, stop there
+ if ( state === 2 ) {
+ return jqXHR;
+ }
+
+ // We can fire global events as of now if asked to
+ fireGlobals = s.global;
+
+ // Watch for a new set of requests
+ if ( fireGlobals && jQuery.active++ === 0 ) {
+ jQuery.event.trigger("ajaxStart");
+ }
+
+ // Uppercase the type
+ s.type = s.type.toUpperCase();
+
+ // Determine if request has content
+ s.hasContent = !rnoContent.test( s.type );
+
+ // Save the URL in case we're toying with the If-Modified-Since
+ // and/or If-None-Match header later on
+ cacheURL = s.url;
+
+ // More options handling for requests with no content
+ if ( !s.hasContent ) {
+
+ // If data is available, append data to url
+ if ( s.data ) {
+ cacheURL = ( s.url += ( ajax_rquery.test( cacheURL ) ? "&" : "?" ) + s.data );
+ // #9682: remove data so that it's not used in an eventual retry
+ delete s.data;
+ }
+
+ // Add anti-cache in url if needed
+ if ( s.cache === false ) {
+ s.url = rts.test( cacheURL ) ?
+
+ // If there is already a '_' parameter, set its value
+ cacheURL.replace( rts, "$1_=" + ajax_nonce++ ) :
+
+ // Otherwise add one to the end
+ cacheURL + ( ajax_rquery.test( cacheURL ) ? "&" : "?" ) + "_=" + ajax_nonce++;
+ }
+ }
+
+ // Set the If-Modified-Since and/or If-None-Match header, if in ifModified mode.
+ if ( s.ifModified ) {
+ if ( jQuery.lastModified[ cacheURL ] ) {
+ jqXHR.setRequestHeader( "If-Modified-Since", jQuery.lastModified[ cacheURL ] );
+ }
+ if ( jQuery.etag[ cacheURL ] ) {
+ jqXHR.setRequestHeader( "If-None-Match", jQuery.etag[ cacheURL ] );
+ }
+ }
+
+ // Set the correct header, if data is being sent
+ if ( s.data && s.hasContent && s.contentType !== false || options.contentType ) {
+ jqXHR.setRequestHeader( "Content-Type", s.contentType );
+ }
+
+ // Set the Accepts header for the server, depending on the dataType
+ jqXHR.setRequestHeader(
+ "Accept",
+ s.dataTypes[ 0 ] && s.accepts[ s.dataTypes[0] ] ?
+ s.accepts[ s.dataTypes[0] ] + ( s.dataTypes[ 0 ] !== "*" ? ", " + allTypes + "; q=0.01" : "" ) :
+ s.accepts[ "*" ]
+ );
+
+ // Check for headers option
+ for ( i in s.headers ) {
+ jqXHR.setRequestHeader( i, s.headers[ i ] );
+ }
+
+ // Allow custom headers/mimetypes and early abort
+ if ( s.beforeSend && ( s.beforeSend.call( callbackContext, jqXHR, s ) === false || state === 2 ) ) {
+ // Abort if not done already and return
+ return jqXHR.abort();
+ }
+
+ // aborting is no longer a cancellation
+ strAbort = "abort";
+
+ // Install callbacks on deferreds
+ for ( i in { success: 1, error: 1, complete: 1 } ) {
+ jqXHR[ i ]( s[ i ] );
+ }
+
+ // Get transport
+ transport = inspectPrefiltersOrTransports( transports, s, options, jqXHR );
+
+ // If no transport, we auto-abort
+ if ( !transport ) {
+ done( -1, "No Transport" );
+ } else {
+ jqXHR.readyState = 1;
+
+ // Send global event
+ if ( fireGlobals ) {
+ globalEventContext.trigger( "ajaxSend", [ jqXHR, s ] );
+ }
+ // Timeout
+ if ( s.async && s.timeout > 0 ) {
+ timeoutTimer = setTimeout(function() {
+ jqXHR.abort("timeout");
+ }, s.timeout );
+ }
+
+ try {
+ state = 1;
+ transport.send( requestHeaders, done );
+ } catch ( e ) {
+ // Propagate exception as error if not done
+ if ( state < 2 ) {
+ done( -1, e );
+ // Simply rethrow otherwise
+ } else {
+ throw e;
+ }
+ }
+ }
+
+ // Callback for when everything is done
+ function done( status, nativeStatusText, responses, headers ) {
+ var isSuccess, success, error, response, modified,
+ statusText = nativeStatusText;
+
+ // Called once
+ if ( state === 2 ) {
+ return;
+ }
+
+ // State is "done" now
+ state = 2;
+
+ // Clear timeout if it exists
+ if ( timeoutTimer ) {
+ clearTimeout( timeoutTimer );
+ }
+
+ // Dereference transport for early garbage collection
+ // (no matter how long the jqXHR object will be used)
+ transport = undefined;
+
+ // Cache response headers
+ responseHeadersString = headers || "";
+
+ // Set readyState
+ jqXHR.readyState = status > 0 ? 4 : 0;
+
+ // Get response data
+ if ( responses ) {
+ response = ajaxHandleResponses( s, jqXHR, responses );
+ }
+
+ // If successful, handle type chaining
+ if ( status >= 200 && status < 300 || status === 304 ) {
+
+ // Set the If-Modified-Since and/or If-None-Match header, if in ifModified mode.
+ if ( s.ifModified ) {
+ modified = jqXHR.getResponseHeader("Last-Modified");
+ if ( modified ) {
+ jQuery.lastModified[ cacheURL ] = modified;
+ }
+ modified = jqXHR.getResponseHeader("etag");
+ if ( modified ) {
+ jQuery.etag[ cacheURL ] = modified;
+ }
+ }
+
+ // If not modified
+ if ( status === 304 ) {
+ isSuccess = true;
+ statusText = "notmodified";
+
+ // If we have data
+ } else {
+ isSuccess = ajaxConvert( s, response );
+ statusText = isSuccess.state;
+ success = isSuccess.data;
+ error = isSuccess.error;
+ isSuccess = !error;
+ }
+ } else {
+ // We extract error from statusText
+ // then normalize statusText and status for non-aborts
+ error = statusText;
+ if ( status || !statusText ) {
+ statusText = "error";
+ if ( status < 0 ) {
+ status = 0;
+ }
+ }
+ }
+
+ // Set data for the fake xhr object
+ jqXHR.status = status;
+ jqXHR.statusText = ( nativeStatusText || statusText ) + "";
+
+ // Success/Error
+ if ( isSuccess ) {
+ deferred.resolveWith( callbackContext, [ success, statusText, jqXHR ] );
+ } else {
+ deferred.rejectWith( callbackContext, [ jqXHR, statusText, error ] );
+ }
+
+ // Status-dependent callbacks
+ jqXHR.statusCode( statusCode );
+ statusCode = undefined;
+
+ if ( fireGlobals ) {
+ globalEventContext.trigger( isSuccess ? "ajaxSuccess" : "ajaxError",
+ [ jqXHR, s, isSuccess ? success : error ] );
+ }
+
+ // Complete
+ completeDeferred.fireWith( callbackContext, [ jqXHR, statusText ] );
+
+ if ( fireGlobals ) {
+ globalEventContext.trigger( "ajaxComplete", [ jqXHR, s ] );
+ // Handle the global AJAX counter
+ if ( !( --jQuery.active ) ) {
+ jQuery.event.trigger("ajaxStop");
+ }
+ }
+ }
+
+ return jqXHR;
+ },
+
+ getScript: function( url, callback ) {
+ return jQuery.get( url, undefined, callback, "script" );
+ },
+
+ getJSON: function( url, data, callback ) {
+ return jQuery.get( url, data, callback, "json" );
+ }
+});
+
+/* Handles responses to an ajax request:
+ * - sets all responseXXX fields accordingly
+ * - finds the right dataType (mediates between content-type and expected dataType)
+ * - returns the corresponding response
+ */
+function ajaxHandleResponses( s, jqXHR, responses ) {
+
+ var ct, type, finalDataType, firstDataType,
+ contents = s.contents,
+ dataTypes = s.dataTypes,
+ responseFields = s.responseFields;
+
+ // Fill responseXXX fields
+ for ( type in responseFields ) {
+ if ( type in responses ) {
+ jqXHR[ responseFields[type] ] = responses[ type ];
+ }
+ }
+
+ // Remove auto dataType and get content-type in the process
+ while( dataTypes[ 0 ] === "*" ) {
+ dataTypes.shift();
+ if ( ct === undefined ) {
+ ct = s.mimeType || jqXHR.getResponseHeader("Content-Type");
+ }
+ }
+
+ // Check if we're dealing with a known content-type
+ if ( ct ) {
+ for ( type in contents ) {
+ if ( contents[ type ] && contents[ type ].test( ct ) ) {
+ dataTypes.unshift( type );
+ break;
+ }
+ }
+ }
+
+ // Check to see if we have a response for the expected dataType
+ if ( dataTypes[ 0 ] in responses ) {
+ finalDataType = dataTypes[ 0 ];
+ } else {
+ // Try convertible dataTypes
+ for ( type in responses ) {
+ if ( !dataTypes[ 0 ] || s.converters[ type + " " + dataTypes[0] ] ) {
+ finalDataType = type;
+ break;
+ }
+ if ( !firstDataType ) {
+ firstDataType = type;
+ }
+ }
+ // Or just use first one
+ finalDataType = finalDataType || firstDataType;
+ }
+
+ // If we found a dataType
+ // We add the dataType to the list if needed
+ // and return the corresponding response
+ if ( finalDataType ) {
+ if ( finalDataType !== dataTypes[ 0 ] ) {
+ dataTypes.unshift( finalDataType );
+ }
+ return responses[ finalDataType ];
+ }
+}
+
+// Chain conversions given the request and the original response
+function ajaxConvert( s, response ) {
+
+ var conv, conv2, current, tmp,
+ converters = {},
+ i = 0,
+ // Work with a copy of dataTypes in case we need to modify it for conversion
+ dataTypes = s.dataTypes.slice(),
+ prev = dataTypes[ 0 ];
+
+ // Apply the dataFilter if provided
+ if ( s.dataFilter ) {
+ response = s.dataFilter( response, s.dataType );
+ }
+
+ // Create converters map with lowercased keys
+ if ( dataTypes[ 1 ] ) {
+ for ( conv in s.converters ) {
+ converters[ conv.toLowerCase() ] = s.converters[ conv ];
+ }
+ }
+
+ // Convert to each sequential dataType, tolerating list modification
+ for ( ; (current = dataTypes[++i]); ) {
+
+ // There's only work to do if current dataType is non-auto
+ if ( current !== "*" ) {
+
+ // Convert response if prev dataType is non-auto and differs from current
+ if ( prev !== "*" && prev !== current ) {
+
+ // Seek a direct converter
+ conv = converters[ prev + " " + current ] || converters[ "* " + current ];
+
+ // If none found, seek a pair
+ if ( !conv ) {
+ for ( conv2 in converters ) {
+
+ // If conv2 outputs current
+ tmp = conv2.split(" ");
+ if ( tmp[ 1 ] === current ) {
+
+ // If prev can be converted to accepted input
+ conv = converters[ prev + " " + tmp[ 0 ] ] ||
+ converters[ "* " + tmp[ 0 ] ];
+ if ( conv ) {
+ // Condense equivalence converters
+ if ( conv === true ) {
+ conv = converters[ conv2 ];
+
+ // Otherwise, insert the intermediate dataType
+ } else if ( converters[ conv2 ] !== true ) {
+ current = tmp[ 0 ];
+ dataTypes.splice( i--, 0, current );
+ }
+
+ break;
+ }
+ }
+ }
+ }
+
+ // Apply converter (if not an equivalence)
+ if ( conv !== true ) {
+
+ // Unless errors are allowed to bubble, catch and return them
+ if ( conv && s["throws"] ) {
+ response = conv( response );
+ } else {
+ try {
+ response = conv( response );
+ } catch ( e ) {
+ return { state: "parsererror", error: conv ? e : "No conversion from " + prev + " to " + current };
+ }
+ }
+ }
+ }
+
+ // Update prev for next iteration
+ prev = current;
+ }
+ }
+
+ return { state: "success", data: response };
+}
+// Install script dataType
+jQuery.ajaxSetup({
+ accepts: {
+ script: "text/javascript, application/javascript, application/ecmascript, application/x-ecmascript"
+ },
+ contents: {
+ script: /(?:java|ecma)script/
+ },
+ converters: {
+ "text script": function( text ) {
+ jQuery.globalEval( text );
+ return text;
+ }
+ }
+});
+
+// Handle cache's special case and global
+jQuery.ajaxPrefilter( "script", function( s ) {
+ if ( s.cache === undefined ) {
+ s.cache = false;
+ }
+ if ( s.crossDomain ) {
+ s.type = "GET";
+ s.global = false;
+ }
+});
+
+// Bind script tag hack transport
+jQuery.ajaxTransport( "script", function(s) {
+
+ // This transport only deals with cross domain requests
+ if ( s.crossDomain ) {
+
+ var script,
+ head = document.head || jQuery("head")[0] || document.documentElement;
+
+ return {
+
+ send: function( _, callback ) {
+
+ script = document.createElement("script");
+
+ script.async = true;
+
+ if ( s.scriptCharset ) {
+ script.charset = s.scriptCharset;
+ }
+
+ script.src = s.url;
+
+ // Attach handlers for all browsers
+ script.onload = script.onreadystatechange = function( _, isAbort ) {
+
+ if ( isAbort || !script.readyState || /loaded|complete/.test( script.readyState ) ) {
+
+ // Handle memory leak in IE
+ script.onload = script.onreadystatechange = null;
+
+ // Remove the script
+ if ( script.parentNode ) {
+ script.parentNode.removeChild( script );
+ }
+
+ // Dereference the script
+ script = null;
+
+ // Callback if not abort
+ if ( !isAbort ) {
+ callback( 200, "success" );
+ }
+ }
+ };
+
+ // Circumvent IE6 bugs with base elements (#2709 and #4378) by prepending
+ // Use native DOM manipulation to avoid our domManip AJAX trickery
+ head.insertBefore( script, head.firstChild );
+ },
+
+ abort: function() {
+ if ( script ) {
+ script.onload( undefined, true );
+ }
+ }
+ };
+ }
+});
+var oldCallbacks = [],
+ rjsonp = /(=)\?(?=&|$)|\?\?/;
+
+// Default jsonp settings
+jQuery.ajaxSetup({
+ jsonp: "callback",
+ jsonpCallback: function() {
+ var callback = oldCallbacks.pop() || ( jQuery.expando + "_" + ( ajax_nonce++ ) );
+ this[ callback ] = true;
+ return callback;
+ }
+});
+
+// Detect, normalize options and install callbacks for jsonp requests
+jQuery.ajaxPrefilter( "json jsonp", function( s, originalSettings, jqXHR ) {
+
+ var callbackName, overwritten, responseContainer,
+ jsonProp = s.jsonp !== false && ( rjsonp.test( s.url ) ?
+ "url" :
+ typeof s.data === "string" && !( s.contentType || "" ).indexOf("application/x-www-form-urlencoded") && rjsonp.test( s.data ) && "data"
+ );
+
+ // Handle iff the expected data type is "jsonp" or we have a parameter to set
+ if ( jsonProp || s.dataTypes[ 0 ] === "jsonp" ) {
+
+ // Get callback name, remembering preexisting value associated with it
+ callbackName = s.jsonpCallback = jQuery.isFunction( s.jsonpCallback ) ?
+ s.jsonpCallback() :
+ s.jsonpCallback;
+
+ // Insert callback into url or form data
+ if ( jsonProp ) {
+ s[ jsonProp ] = s[ jsonProp ].replace( rjsonp, "$1" + callbackName );
+ } else if ( s.jsonp !== false ) {
+ s.url += ( ajax_rquery.test( s.url ) ? "&" : "?" ) + s.jsonp + "=" + callbackName;
+ }
+
+ // Use data converter to retrieve json after script execution
+ s.converters["script json"] = function() {
+ if ( !responseContainer ) {
+ jQuery.error( callbackName + " was not called" );
+ }
+ return responseContainer[ 0 ];
+ };
+
+ // force json dataType
+ s.dataTypes[ 0 ] = "json";
+
+ // Install callback
+ overwritten = window[ callbackName ];
+ window[ callbackName ] = function() {
+ responseContainer = arguments;
+ };
+
+ // Clean-up function (fires after converters)
+ jqXHR.always(function() {
+ // Restore preexisting value
+ window[ callbackName ] = overwritten;
+
+ // Save back as free
+ if ( s[ callbackName ] ) {
+ // make sure that re-using the options doesn't screw things around
+ s.jsonpCallback = originalSettings.jsonpCallback;
+
+ // save the callback name for future use
+ oldCallbacks.push( callbackName );
+ }
+
+ // Call if it was a function and we have a response
+ if ( responseContainer && jQuery.isFunction( overwritten ) ) {
+ overwritten( responseContainer[ 0 ] );
+ }
+
+ responseContainer = overwritten = undefined;
+ });
+
+ // Delegate to script
+ return "script";
+ }
+});
+var xhrCallbacks, xhrSupported,
+ xhrId = 0,
+ // #5280: Internet Explorer will keep connections alive if we don't abort on unload
+ xhrOnUnloadAbort = window.ActiveXObject && function() {
+ // Abort all pending requests
+ var key;
+ for ( key in xhrCallbacks ) {
+ xhrCallbacks[ key ]( undefined, true );
+ }
+ };
+
+// Functions to create xhrs
+function createStandardXHR() {
+ try {
+ return new window.XMLHttpRequest();
+ } catch( e ) {}
+}
+
+function createActiveXHR() {
+ try {
+ return new window.ActiveXObject("Microsoft.XMLHTTP");
+ } catch( e ) {}
+}
+
+// Create the request object
+// (This is still attached to ajaxSettings for backward compatibility)
+jQuery.ajaxSettings.xhr = window.ActiveXObject ?
+ /* Microsoft failed to properly
+ * implement the XMLHttpRequest in IE7 (can't request local files),
+ * so we use the ActiveXObject when it is available
+ * Additionally XMLHttpRequest can be disabled in IE7/IE8 so
+ * we need a fallback.
+ */
+ function() {
+ return !this.isLocal && createStandardXHR() || createActiveXHR();
+ } :
+ // For all other browsers, use the standard XMLHttpRequest object
+ createStandardXHR;
+
+// Determine support properties
+xhrSupported = jQuery.ajaxSettings.xhr();
+jQuery.support.cors = !!xhrSupported && ( "withCredentials" in xhrSupported );
+xhrSupported = jQuery.support.ajax = !!xhrSupported;
+
+// Create transport if the browser can provide an xhr
+if ( xhrSupported ) {
+
+ jQuery.ajaxTransport(function( s ) {
+ // Cross domain only allowed if supported through XMLHttpRequest
+ if ( !s.crossDomain || jQuery.support.cors ) {
+
+ var callback;
+
+ return {
+ send: function( headers, complete ) {
+
+ // Get a new xhr
+ var handle, i,
+ xhr = s.xhr();
+
+ // Open the socket
+ // Passing null username, generates a login popup on Opera (#2865)
+ if ( s.username ) {
+ xhr.open( s.type, s.url, s.async, s.username, s.password );
+ } else {
+ xhr.open( s.type, s.url, s.async );
+ }
+
+ // Apply custom fields if provided
+ if ( s.xhrFields ) {
+ for ( i in s.xhrFields ) {
+ xhr[ i ] = s.xhrFields[ i ];
+ }
+ }
+
+ // Override mime type if needed
+ if ( s.mimeType && xhr.overrideMimeType ) {
+ xhr.overrideMimeType( s.mimeType );
+ }
+
+ // X-Requested-With header
+ // For cross-domain requests, seeing as conditions for a preflight are
+ // akin to a jigsaw puzzle, we simply never set it to be sure.
+ // (it can always be set on a per-request basis or even using ajaxSetup)
+ // For same-domain requests, won't change header if already provided.
+ if ( !s.crossDomain && !headers["X-Requested-With"] ) {
+ headers["X-Requested-With"] = "XMLHttpRequest";
+ }
+
+ // Need an extra try/catch for cross domain requests in Firefox 3
+ try {
+ for ( i in headers ) {
+ xhr.setRequestHeader( i, headers[ i ] );
+ }
+ } catch( err ) {}
+
+ // Do send the request
+ // This may raise an exception which is actually
+ // handled in jQuery.ajax (so no try/catch here)
+ xhr.send( ( s.hasContent && s.data ) || null );
+
+ // Listener
+ callback = function( _, isAbort ) {
+
+ var status,
+ statusText,
+ responseHeaders,
+ responses,
+ xml;
+
+ // Firefox throws exceptions when accessing properties
+ // of an xhr when a network error occurred
+ // http://helpful.knobs-dials.com/index.php/Component_returned_failure_code:_0x80040111_(NS_ERROR_NOT_AVAILABLE)
+ try {
+
+ // Was never called and is aborted or complete
+ if ( callback && ( isAbort || xhr.readyState === 4 ) ) {
+
+ // Only called once
+ callback = undefined;
+
+ // Do not keep as active anymore
+ if ( handle ) {
+ xhr.onreadystatechange = jQuery.noop;
+ if ( xhrOnUnloadAbort ) {
+ delete xhrCallbacks[ handle ];
+ }
+ }
+
+ // If it's an abort
+ if ( isAbort ) {
+ // Abort it manually if needed
+ if ( xhr.readyState !== 4 ) {
+ xhr.abort();
+ }
+ } else {
+ responses = {};
+ status = xhr.status;
+ xml = xhr.responseXML;
+ responseHeaders = xhr.getAllResponseHeaders();
+
+ // Construct response list
+ if ( xml && xml.documentElement /* #4958 */ ) {
+ responses.xml = xml;
+ }
+
+ // When requesting binary data, IE6-9 will throw an exception
+ // on any attempt to access responseText (#11426)
+ if ( typeof xhr.responseText === "string" ) {
+ responses.text = xhr.responseText;
+ }
+
+ // Firefox throws an exception when accessing
+ // statusText for faulty cross-domain requests
+ try {
+ statusText = xhr.statusText;
+ } catch( e ) {
+ // We normalize with Webkit giving an empty statusText
+ statusText = "";
+ }
+
+ // Filter status for non standard behaviors
+
+ // If the request is local and we have data: assume a success
+ // (success with no data won't get notified, that's the best we
+ // can do given current implementations)
+ if ( !status && s.isLocal && !s.crossDomain ) {
+ status = responses.text ? 200 : 404;
+ // IE - #1450: sometimes returns 1223 when it should be 204
+ } else if ( status === 1223 ) {
+ status = 204;
+ }
+ }
+ }
+ } catch( firefoxAccessException ) {
+ if ( !isAbort ) {
+ complete( -1, firefoxAccessException );
+ }
+ }
+
+ // Call complete if needed
+ if ( responses ) {
+ complete( status, statusText, responses, responseHeaders );
+ }
+ };
+
+ if ( !s.async ) {
+ // if we're in sync mode we fire the callback
+ callback();
+ } else if ( xhr.readyState === 4 ) {
+ // (IE6 & IE7) if it's in cache and has been
+ // retrieved directly we need to fire the callback
+ setTimeout( callback );
+ } else {
+ handle = ++xhrId;
+ if ( xhrOnUnloadAbort ) {
+ // Create the active xhrs callbacks list if needed
+ // and attach the unload handler
+ if ( !xhrCallbacks ) {
+ xhrCallbacks = {};
+ jQuery( window ).unload( xhrOnUnloadAbort );
+ }
+ // Add to list of active xhrs callbacks
+ xhrCallbacks[ handle ] = callback;
+ }
+ xhr.onreadystatechange = callback;
+ }
+ },
+
+ abort: function() {
+ if ( callback ) {
+ callback( undefined, true );
+ }
+ }
+ };
+ }
+ });
+}
+var fxNow, timerId,
+ rfxtypes = /^(?:toggle|show|hide)$/,
+ rfxnum = new RegExp( "^(?:([+-])=|)(" + core_pnum + ")([a-z%]*)$", "i" ),
+ rrun = /queueHooks$/,
+ animationPrefilters = [ defaultPrefilter ],
+ tweeners = {
+ "*": [function( prop, value ) {
+ var end, unit,
+ tween = this.createTween( prop, value ),
+ parts = rfxnum.exec( value ),
+ target = tween.cur(),
+ start = +target || 0,
+ scale = 1,
+ maxIterations = 20;
+
+ if ( parts ) {
+ end = +parts[2];
+ unit = parts[3] || ( jQuery.cssNumber[ prop ] ? "" : "px" );
+
+ // We need to compute starting value
+ if ( unit !== "px" && start ) {
+ // Iteratively approximate from a nonzero starting point
+ // Prefer the current property, because this process will be trivial if it uses the same units
+ // Fallback to end or a simple constant
+ start = jQuery.css( tween.elem, prop, true ) || end || 1;
+
+ do {
+ // If previous iteration zeroed out, double until we get *something*
+ // Use a string for doubling factor so we don't accidentally see scale as unchanged below
+ scale = scale || ".5";
+
+ // Adjust and apply
+ start = start / scale;
+ jQuery.style( tween.elem, prop, start + unit );
+
+ // Update scale, tolerating zero or NaN from tween.cur()
+ // And breaking the loop if scale is unchanged or perfect, or if we've just had enough
+ } while ( scale !== (scale = tween.cur() / target) && scale !== 1 && --maxIterations );
+ }
+
+ tween.unit = unit;
+ tween.start = start;
+ // If a +=/-= token was provided, we're doing a relative animation
+ tween.end = parts[1] ? start + ( parts[1] + 1 ) * end : end;
+ }
+ return tween;
+ }]
+ };
+
+// Animations created synchronously will run synchronously
+function createFxNow() {
+ setTimeout(function() {
+ fxNow = undefined;
+ });
+ return ( fxNow = jQuery.now() );
+}
+
+function createTweens( animation, props ) {
+ jQuery.each( props, function( prop, value ) {
+ var collection = ( tweeners[ prop ] || [] ).concat( tweeners[ "*" ] ),
+ index = 0,
+ length = collection.length;
+ for ( ; index < length; index++ ) {
+ if ( collection[ index ].call( animation, prop, value ) ) {
+
+ // we're done with this property
+ return;
+ }
+ }
+ });
+}
+
+function Animation( elem, properties, options ) {
+ var result,
+ stopped,
+ index = 0,
+ length = animationPrefilters.length,
+ deferred = jQuery.Deferred().always( function() {
+ // don't match elem in the :animated selector
+ delete tick.elem;
+ }),
+ tick = function() {
+ if ( stopped ) {
+ return false;
+ }
+ var currentTime = fxNow || createFxNow(),
+ remaining = Math.max( 0, animation.startTime + animation.duration - currentTime ),
+ // archaic crash bug won't allow us to use 1 - ( 0.5 || 0 ) (#12497)
+ temp = remaining / animation.duration || 0,
+ percent = 1 - temp,
+ index = 0,
+ length = animation.tweens.length;
+
+ for ( ; index < length ; index++ ) {
+ animation.tweens[ index ].run( percent );
+ }
+
+ deferred.notifyWith( elem, [ animation, percent, remaining ]);
+
+ if ( percent < 1 && length ) {
+ return remaining;
+ } else {
+ deferred.resolveWith( elem, [ animation ] );
+ return false;
+ }
+ },
+ animation = deferred.promise({
+ elem: elem,
+ props: jQuery.extend( {}, properties ),
+ opts: jQuery.extend( true, { specialEasing: {} }, options ),
+ originalProperties: properties,
+ originalOptions: options,
+ startTime: fxNow || createFxNow(),
+ duration: options.duration,
+ tweens: [],
+ createTween: function( prop, end ) {
+ var tween = jQuery.Tween( elem, animation.opts, prop, end,
+ animation.opts.specialEasing[ prop ] || animation.opts.easing );
+ animation.tweens.push( tween );
+ return tween;
+ },
+ stop: function( gotoEnd ) {
+ var index = 0,
+ // if we are going to the end, we want to run all the tweens
+ // otherwise we skip this part
+ length = gotoEnd ? animation.tweens.length : 0;
+ if ( stopped ) {
+ return this;
+ }
+ stopped = true;
+ for ( ; index < length ; index++ ) {
+ animation.tweens[ index ].run( 1 );
+ }
+
+ // resolve when we played the last frame
+ // otherwise, reject
+ if ( gotoEnd ) {
+ deferred.resolveWith( elem, [ animation, gotoEnd ] );
+ } else {
+ deferred.rejectWith( elem, [ animation, gotoEnd ] );
+ }
+ return this;
+ }
+ }),
+ props = animation.props;
+
+ propFilter( props, animation.opts.specialEasing );
+
+ for ( ; index < length ; index++ ) {
+ result = animationPrefilters[ index ].call( animation, elem, props, animation.opts );
+ if ( result ) {
+ return result;
+ }
+ }
+
+ createTweens( animation, props );
+
+ if ( jQuery.isFunction( animation.opts.start ) ) {
+ animation.opts.start.call( elem, animation );
+ }
+
+ jQuery.fx.timer(
+ jQuery.extend( tick, {
+ elem: elem,
+ anim: animation,
+ queue: animation.opts.queue
+ })
+ );
+
+ // attach callbacks from options
+ return animation.progress( animation.opts.progress )
+ .done( animation.opts.done, animation.opts.complete )
+ .fail( animation.opts.fail )
+ .always( animation.opts.always );
+}
+
+function propFilter( props, specialEasing ) {
+ var index, name, easing, value, hooks;
+
+ // camelCase, specialEasing and expand cssHook pass
+ for ( index in props ) {
+ name = jQuery.camelCase( index );
+ easing = specialEasing[ name ];
+ value = props[ index ];
+ if ( jQuery.isArray( value ) ) {
+ easing = value[ 1 ];
+ value = props[ index ] = value[ 0 ];
+ }
+
+ if ( index !== name ) {
+ props[ name ] = value;
+ delete props[ index ];
+ }
+
+ hooks = jQuery.cssHooks[ name ];
+ if ( hooks && "expand" in hooks ) {
+ value = hooks.expand( value );
+ delete props[ name ];
+
+ // not quite $.extend, this wont overwrite keys already present.
+ // also - reusing 'index' from above because we have the correct "name"
+ for ( index in value ) {
+ if ( !( index in props ) ) {
+ props[ index ] = value[ index ];
+ specialEasing[ index ] = easing;
+ }
+ }
+ } else {
+ specialEasing[ name ] = easing;
+ }
+ }
+}
+
+jQuery.Animation = jQuery.extend( Animation, {
+
+ tweener: function( props, callback ) {
+ if ( jQuery.isFunction( props ) ) {
+ callback = props;
+ props = [ "*" ];
+ } else {
+ props = props.split(" ");
+ }
+
+ var prop,
+ index = 0,
+ length = props.length;
+
+ for ( ; index < length ; index++ ) {
+ prop = props[ index ];
+ tweeners[ prop ] = tweeners[ prop ] || [];
+ tweeners[ prop ].unshift( callback );
+ }
+ },
+
+ prefilter: function( callback, prepend ) {
+ if ( prepend ) {
+ animationPrefilters.unshift( callback );
+ } else {
+ animationPrefilters.push( callback );
+ }
+ }
+});
+
+function defaultPrefilter( elem, props, opts ) {
+ /*jshint validthis:true */
+ var index, prop, value, length, dataShow, toggle, tween, hooks, oldfire,
+ anim = this,
+ style = elem.style,
+ orig = {},
+ handled = [],
+ hidden = elem.nodeType && isHidden( elem );
+
+ // handle queue: false promises
+ if ( !opts.queue ) {
+ hooks = jQuery._queueHooks( elem, "fx" );
+ if ( hooks.unqueued == null ) {
+ hooks.unqueued = 0;
+ oldfire = hooks.empty.fire;
+ hooks.empty.fire = function() {
+ if ( !hooks.unqueued ) {
+ oldfire();
+ }
+ };
+ }
+ hooks.unqueued++;
+
+ anim.always(function() {
+ // doing this makes sure that the complete handler will be called
+ // before this completes
+ anim.always(function() {
+ hooks.unqueued--;
+ if ( !jQuery.queue( elem, "fx" ).length ) {
+ hooks.empty.fire();
+ }
+ });
+ });
+ }
+
+ // height/width overflow pass
+ if ( elem.nodeType === 1 && ( "height" in props || "width" in props ) ) {
+ // Make sure that nothing sneaks out
+ // Record all 3 overflow attributes because IE does not
+ // change the overflow attribute when overflowX and
+ // overflowY are set to the same value
+ opts.overflow = [ style.overflow, style.overflowX, style.overflowY ];
+
+ // Set display property to inline-block for height/width
+ // animations on inline elements that are having width/height animated
+ if ( jQuery.css( elem, "display" ) === "inline" &&
+ jQuery.css( elem, "float" ) === "none" ) {
+
+ // inline-level elements accept inline-block;
+ // block-level elements need to be inline with layout
+ if ( !jQuery.support.inlineBlockNeedsLayout || css_defaultDisplay( elem.nodeName ) === "inline" ) {
+ style.display = "inline-block";
+
+ } else {
+ style.zoom = 1;
+ }
+ }
+ }
+
+ if ( opts.overflow ) {
+ style.overflow = "hidden";
+ if ( !jQuery.support.shrinkWrapBlocks ) {
+ anim.done(function() {
+ style.overflow = opts.overflow[ 0 ];
+ style.overflowX = opts.overflow[ 1 ];
+ style.overflowY = opts.overflow[ 2 ];
+ });
+ }
+ }
+
+
+ // show/hide pass
+ for ( index in props ) {
+ value = props[ index ];
+ if ( rfxtypes.exec( value ) ) {
+ delete props[ index ];
+ toggle = toggle || value === "toggle";
+ if ( value === ( hidden ? "hide" : "show" ) ) {
+ continue;
+ }
+ handled.push( index );
+ }
+ }
+
+ length = handled.length;
+ if ( length ) {
+ dataShow = jQuery._data( elem, "fxshow" ) || jQuery._data( elem, "fxshow", {} );
+ if ( "hidden" in dataShow ) {
+ hidden = dataShow.hidden;
+ }
+
+ // store state if its toggle - enables .stop().toggle() to "reverse"
+ if ( toggle ) {
+ dataShow.hidden = !hidden;
+ }
+ if ( hidden ) {
+ jQuery( elem ).show();
+ } else {
+ anim.done(function() {
+ jQuery( elem ).hide();
+ });
+ }
+ anim.done(function() {
+ var prop;
+ jQuery._removeData( elem, "fxshow" );
+ for ( prop in orig ) {
+ jQuery.style( elem, prop, orig[ prop ] );
+ }
+ });
+ for ( index = 0 ; index < length ; index++ ) {
+ prop = handled[ index ];
+ tween = anim.createTween( prop, hidden ? dataShow[ prop ] : 0 );
+ orig[ prop ] = dataShow[ prop ] || jQuery.style( elem, prop );
+
+ if ( !( prop in dataShow ) ) {
+ dataShow[ prop ] = tween.start;
+ if ( hidden ) {
+ tween.end = tween.start;
+ tween.start = prop === "width" || prop === "height" ? 1 : 0;
+ }
+ }
+ }
+ }
+}
+
+function Tween( elem, options, prop, end, easing ) {
+ return new Tween.prototype.init( elem, options, prop, end, easing );
+}
+jQuery.Tween = Tween;
+
+Tween.prototype = {
+ constructor: Tween,
+ init: function( elem, options, prop, end, easing, unit ) {
+ this.elem = elem;
+ this.prop = prop;
+ this.easing = easing || "swing";
+ this.options = options;
+ this.start = this.now = this.cur();
+ this.end = end;
+ this.unit = unit || ( jQuery.cssNumber[ prop ] ? "" : "px" );
+ },
+ cur: function() {
+ var hooks = Tween.propHooks[ this.prop ];
+
+ return hooks && hooks.get ?
+ hooks.get( this ) :
+ Tween.propHooks._default.get( this );
+ },
+ run: function( percent ) {
+ var eased,
+ hooks = Tween.propHooks[ this.prop ];
+
+ if ( this.options.duration ) {
+ this.pos = eased = jQuery.easing[ this.easing ](
+ percent, this.options.duration * percent, 0, 1, this.options.duration
+ );
+ } else {
+ this.pos = eased = percent;
+ }
+ this.now = ( this.end - this.start ) * eased + this.start;
+
+ if ( this.options.step ) {
+ this.options.step.call( this.elem, this.now, this );
+ }
+
+ if ( hooks && hooks.set ) {
+ hooks.set( this );
+ } else {
+ Tween.propHooks._default.set( this );
+ }
+ return this;
+ }
+};
+
+Tween.prototype.init.prototype = Tween.prototype;
+
+Tween.propHooks = {
+ _default: {
+ get: function( tween ) {
+ var result;
+
+ if ( tween.elem[ tween.prop ] != null &&
+ (!tween.elem.style || tween.elem.style[ tween.prop ] == null) ) {
+ return tween.elem[ tween.prop ];
+ }
+
+ // passing a non empty string as a 3rd parameter to .css will automatically
+ // attempt a parseFloat and fallback to a string if the parse fails
+ // so, simple values such as "10px" are parsed to Float.
+ // complex values such as "rotate(1rad)" are returned as is.
+ result = jQuery.css( tween.elem, tween.prop, "auto" );
+ // Empty strings, null, undefined and "auto" are converted to 0.
+ return !result || result === "auto" ? 0 : result;
+ },
+ set: function( tween ) {
+ // use step hook for back compat - use cssHook if its there - use .style if its
+ // available and use plain properties where available
+ if ( jQuery.fx.step[ tween.prop ] ) {
+ jQuery.fx.step[ tween.prop ]( tween );
+ } else if ( tween.elem.style && ( tween.elem.style[ jQuery.cssProps[ tween.prop ] ] != null || jQuery.cssHooks[ tween.prop ] ) ) {
+ jQuery.style( tween.elem, tween.prop, tween.now + tween.unit );
+ } else {
+ tween.elem[ tween.prop ] = tween.now;
+ }
+ }
+ }
+};
+
+// Remove in 2.0 - this supports IE8's panic based approach
+// to setting things on disconnected nodes
+
+Tween.propHooks.scrollTop = Tween.propHooks.scrollLeft = {
+ set: function( tween ) {
+ if ( tween.elem.nodeType && tween.elem.parentNode ) {
+ tween.elem[ tween.prop ] = tween.now;
+ }
+ }
+};
+
+jQuery.each([ "toggle", "show", "hide" ], function( i, name ) {
+ var cssFn = jQuery.fn[ name ];
+ jQuery.fn[ name ] = function( speed, easing, callback ) {
+ return speed == null || typeof speed === "boolean" ?
+ cssFn.apply( this, arguments ) :
+ this.animate( genFx( name, true ), speed, easing, callback );
+ };
+});
+
+jQuery.fn.extend({
+ fadeTo: function( speed, to, easing, callback ) {
+
+ // show any hidden elements after setting opacity to 0
+ return this.filter( isHidden ).css( "opacity", 0 ).show()
+
+ // animate to the value specified
+ .end().animate({ opacity: to }, speed, easing, callback );
+ },
+ animate: function( prop, speed, easing, callback ) {
+ var empty = jQuery.isEmptyObject( prop ),
+ optall = jQuery.speed( speed, easing, callback ),
+ doAnimation = function() {
+ // Operate on a copy of prop so per-property easing won't be lost
+ var anim = Animation( this, jQuery.extend( {}, prop ), optall );
+ doAnimation.finish = function() {
+ anim.stop( true );
+ };
+ // Empty animations, or finishing resolves immediately
+ if ( empty || jQuery._data( this, "finish" ) ) {
+ anim.stop( true );
+ }
+ };
+ doAnimation.finish = doAnimation;
+
+ return empty || optall.queue === false ?
+ this.each( doAnimation ) :
+ this.queue( optall.queue, doAnimation );
+ },
+ stop: function( type, clearQueue, gotoEnd ) {
+ var stopQueue = function( hooks ) {
+ var stop = hooks.stop;
+ delete hooks.stop;
+ stop( gotoEnd );
+ };
+
+ if ( typeof type !== "string" ) {
+ gotoEnd = clearQueue;
+ clearQueue = type;
+ type = undefined;
+ }
+ if ( clearQueue && type !== false ) {
+ this.queue( type || "fx", [] );
+ }
+
+ return this.each(function() {
+ var dequeue = true,
+ index = type != null && type + "queueHooks",
+ timers = jQuery.timers,
+ data = jQuery._data( this );
+
+ if ( index ) {
+ if ( data[ index ] && data[ index ].stop ) {
+ stopQueue( data[ index ] );
+ }
+ } else {
+ for ( index in data ) {
+ if ( data[ index ] && data[ index ].stop && rrun.test( index ) ) {
+ stopQueue( data[ index ] );
+ }
+ }
+ }
+
+ for ( index = timers.length; index--; ) {
+ if ( timers[ index ].elem === this && (type == null || timers[ index ].queue === type) ) {
+ timers[ index ].anim.stop( gotoEnd );
+ dequeue = false;
+ timers.splice( index, 1 );
+ }
+ }
+
+ // start the next in the queue if the last step wasn't forced
+ // timers currently will call their complete callbacks, which will dequeue
+ // but only if they were gotoEnd
+ if ( dequeue || !gotoEnd ) {
+ jQuery.dequeue( this, type );
+ }
+ });
+ },
+ finish: function( type ) {
+ if ( type !== false ) {
+ type = type || "fx";
+ }
+ return this.each(function() {
+ var index,
+ data = jQuery._data( this ),
+ queue = data[ type + "queue" ],
+ hooks = data[ type + "queueHooks" ],
+ timers = jQuery.timers,
+ length = queue ? queue.length : 0;
+
+ // enable finishing flag on private data
+ data.finish = true;
+
+ // empty the queue first
+ jQuery.queue( this, type, [] );
+
+ if ( hooks && hooks.cur && hooks.cur.finish ) {
+ hooks.cur.finish.call( this );
+ }
+
+ // look for any active animations, and finish them
+ for ( index = timers.length; index--; ) {
+ if ( timers[ index ].elem === this && timers[ index ].queue === type ) {
+ timers[ index ].anim.stop( true );
+ timers.splice( index, 1 );
+ }
+ }
+
+ // look for any animations in the old queue and finish them
+ for ( index = 0; index < length; index++ ) {
+ if ( queue[ index ] && queue[ index ].finish ) {
+ queue[ index ].finish.call( this );
+ }
+ }
+
+ // turn off finishing flag
+ delete data.finish;
+ });
+ }
+});
+
+// Generate parameters to create a standard animation
+function genFx( type, includeWidth ) {
+ var which,
+ attrs = { height: type },
+ i = 0;
+
+ // if we include width, step value is 1 to do all cssExpand values,
+ // if we don't include width, step value is 2 to skip over Left and Right
+ includeWidth = includeWidth? 1 : 0;
+ for( ; i < 4 ; i += 2 - includeWidth ) {
+ which = cssExpand[ i ];
+ attrs[ "margin" + which ] = attrs[ "padding" + which ] = type;
+ }
+
+ if ( includeWidth ) {
+ attrs.opacity = attrs.width = type;
+ }
+
+ return attrs;
+}
+
+// Generate shortcuts for custom animations
+jQuery.each({
+ slideDown: genFx("show"),
+ slideUp: genFx("hide"),
+ slideToggle: genFx("toggle"),
+ fadeIn: { opacity: "show" },
+ fadeOut: { opacity: "hide" },
+ fadeToggle: { opacity: "toggle" }
+}, function( name, props ) {
+ jQuery.fn[ name ] = function( speed, easing, callback ) {
+ return this.animate( props, speed, easing, callback );
+ };
+});
+
+jQuery.speed = function( speed, easing, fn ) {
+ var opt = speed && typeof speed === "object" ? jQuery.extend( {}, speed ) : {
+ complete: fn || !fn && easing ||
+ jQuery.isFunction( speed ) && speed,
+ duration: speed,
+ easing: fn && easing || easing && !jQuery.isFunction( easing ) && easing
+ };
+
+ opt.duration = jQuery.fx.off ? 0 : typeof opt.duration === "number" ? opt.duration :
+ opt.duration in jQuery.fx.speeds ? jQuery.fx.speeds[ opt.duration ] : jQuery.fx.speeds._default;
+
+ // normalize opt.queue - true/undefined/null -> "fx"
+ if ( opt.queue == null || opt.queue === true ) {
+ opt.queue = "fx";
+ }
+
+ // Queueing
+ opt.old = opt.complete;
+
+ opt.complete = function() {
+ if ( jQuery.isFunction( opt.old ) ) {
+ opt.old.call( this );
+ }
+
+ if ( opt.queue ) {
+ jQuery.dequeue( this, opt.queue );
+ }
+ };
+
+ return opt;
+};
+
+jQuery.easing = {
+ linear: function( p ) {
+ return p;
+ },
+ swing: function( p ) {
+ return 0.5 - Math.cos( p*Math.PI ) / 2;
+ }
+};
+
+jQuery.timers = [];
+jQuery.fx = Tween.prototype.init;
+jQuery.fx.tick = function() {
+ var timer,
+ timers = jQuery.timers,
+ i = 0;
+
+ fxNow = jQuery.now();
+
+ for ( ; i < timers.length; i++ ) {
+ timer = timers[ i ];
+ // Checks the timer has not already been removed
+ if ( !timer() && timers[ i ] === timer ) {
+ timers.splice( i--, 1 );
+ }
+ }
+
+ if ( !timers.length ) {
+ jQuery.fx.stop();
+ }
+ fxNow = undefined;
+};
+
+jQuery.fx.timer = function( timer ) {
+ if ( timer() && jQuery.timers.push( timer ) ) {
+ jQuery.fx.start();
+ }
+};
+
+jQuery.fx.interval = 13;
+
+jQuery.fx.start = function() {
+ if ( !timerId ) {
+ timerId = setInterval( jQuery.fx.tick, jQuery.fx.interval );
+ }
+};
+
+jQuery.fx.stop = function() {
+ clearInterval( timerId );
+ timerId = null;
+};
+
+jQuery.fx.speeds = {
+ slow: 600,
+ fast: 200,
+ // Default speed
+ _default: 400
+};
+
+// Back Compat <1.8 extension point
+jQuery.fx.step = {};
+
+if ( jQuery.expr && jQuery.expr.filters ) {
+ jQuery.expr.filters.animated = function( elem ) {
+ return jQuery.grep(jQuery.timers, function( fn ) {
+ return elem === fn.elem;
+ }).length;
+ };
+}
+jQuery.fn.offset = function( options ) {
+ if ( arguments.length ) {
+ return options === undefined ?
+ this :
+ this.each(function( i ) {
+ jQuery.offset.setOffset( this, options, i );
+ });
+ }
+
+ var docElem, win,
+ box = { top: 0, left: 0 },
+ elem = this[ 0 ],
+ doc = elem && elem.ownerDocument;
+
+ if ( !doc ) {
+ return;
+ }
+
+ docElem = doc.documentElement;
+
+ // Make sure it's not a disconnected DOM node
+ if ( !jQuery.contains( docElem, elem ) ) {
+ return box;
+ }
+
+ // If we don't have gBCR, just use 0,0 rather than error
+ // BlackBerry 5, iOS 3 (original iPhone)
+ if ( typeof elem.getBoundingClientRect !== "undefined" ) {
+ box = elem.getBoundingClientRect();
+ }
+ win = getWindow( doc );
+ return {
+ top: box.top + ( win.pageYOffset || docElem.scrollTop ) - ( docElem.clientTop || 0 ),
+ left: box.left + ( win.pageXOffset || docElem.scrollLeft ) - ( docElem.clientLeft || 0 )
+ };
+};
+
+jQuery.offset = {
+
+ setOffset: function( elem, options, i ) {
+ var position = jQuery.css( elem, "position" );
+
+ // set position first, in-case top/left are set even on static elem
+ if ( position === "static" ) {
+ elem.style.position = "relative";
+ }
+
+ var curElem = jQuery( elem ),
+ curOffset = curElem.offset(),
+ curCSSTop = jQuery.css( elem, "top" ),
+ curCSSLeft = jQuery.css( elem, "left" ),
+ calculatePosition = ( position === "absolute" || position === "fixed" ) && jQuery.inArray("auto", [curCSSTop, curCSSLeft]) > -1,
+ props = {}, curPosition = {}, curTop, curLeft;
+
+ // need to be able to calculate position if either top or left is auto and position is either absolute or fixed
+ if ( calculatePosition ) {
+ curPosition = curElem.position();
+ curTop = curPosition.top;
+ curLeft = curPosition.left;
+ } else {
+ curTop = parseFloat( curCSSTop ) || 0;
+ curLeft = parseFloat( curCSSLeft ) || 0;
+ }
+
+ if ( jQuery.isFunction( options ) ) {
+ options = options.call( elem, i, curOffset );
+ }
+
+ if ( options.top != null ) {
+ props.top = ( options.top - curOffset.top ) + curTop;
+ }
+ if ( options.left != null ) {
+ props.left = ( options.left - curOffset.left ) + curLeft;
+ }
+
+ if ( "using" in options ) {
+ options.using.call( elem, props );
+ } else {
+ curElem.css( props );
+ }
+ }
+};
+
+
+jQuery.fn.extend({
+
+ position: function() {
+ if ( !this[ 0 ] ) {
+ return;
+ }
+
+ var offsetParent, offset,
+ parentOffset = { top: 0, left: 0 },
+ elem = this[ 0 ];
+
+ // fixed elements are offset from window (parentOffset = {top:0, left: 0}, because it is it's only offset parent
+ if ( jQuery.css( elem, "position" ) === "fixed" ) {
+ // we assume that getBoundingClientRect is available when computed position is fixed
+ offset = elem.getBoundingClientRect();
+ } else {
+ // Get *real* offsetParent
+ offsetParent = this.offsetParent();
+
+ // Get correct offsets
+ offset = this.offset();
+ if ( !jQuery.nodeName( offsetParent[ 0 ], "html" ) ) {
+ parentOffset = offsetParent.offset();
+ }
+
+ // Add offsetParent borders
+ parentOffset.top += jQuery.css( offsetParent[ 0 ], "borderTopWidth", true );
+ parentOffset.left += jQuery.css( offsetParent[ 0 ], "borderLeftWidth", true );
+ }
+
+ // Subtract parent offsets and element margins
+ // note: when an element has margin: auto the offsetLeft and marginLeft
+ // are the same in Safari causing offset.left to incorrectly be 0
+ return {
+ top: offset.top - parentOffset.top - jQuery.css( elem, "marginTop", true ),
+ left: offset.left - parentOffset.left - jQuery.css( elem, "marginLeft", true)
+ };
+ },
+
+ offsetParent: function() {
+ return this.map(function() {
+ var offsetParent = this.offsetParent || document.documentElement;
+ while ( offsetParent && ( !jQuery.nodeName( offsetParent, "html" ) && jQuery.css( offsetParent, "position") === "static" ) ) {
+ offsetParent = offsetParent.offsetParent;
+ }
+ return offsetParent || document.documentElement;
+ });
+ }
+});
+
+
+// Create scrollLeft and scrollTop methods
+jQuery.each( {scrollLeft: "pageXOffset", scrollTop: "pageYOffset"}, function( method, prop ) {
+ var top = /Y/.test( prop );
+
+ jQuery.fn[ method ] = function( val ) {
+ return jQuery.access( this, function( elem, method, val ) {
+ var win = getWindow( elem );
+
+ if ( val === undefined ) {
+ return win ? (prop in win) ? win[ prop ] :
+ win.document.documentElement[ method ] :
+ elem[ method ];
+ }
+
+ if ( win ) {
+ win.scrollTo(
+ !top ? val : jQuery( win ).scrollLeft(),
+ top ? val : jQuery( win ).scrollTop()
+ );
+
+ } else {
+ elem[ method ] = val;
+ }
+ }, method, val, arguments.length, null );
+ };
+});
+
+function getWindow( elem ) {
+ return jQuery.isWindow( elem ) ?
+ elem :
+ elem.nodeType === 9 ?
+ elem.defaultView || elem.parentWindow :
+ false;
+}
+// Create innerHeight, innerWidth, height, width, outerHeight and outerWidth methods
+jQuery.each( { Height: "height", Width: "width" }, function( name, type ) {
+ jQuery.each( { padding: "inner" + name, content: type, "": "outer" + name }, function( defaultExtra, funcName ) {
+ // margin is only for outerHeight, outerWidth
+ jQuery.fn[ funcName ] = function( margin, value ) {
+ var chainable = arguments.length && ( defaultExtra || typeof margin !== "boolean" ),
+ extra = defaultExtra || ( margin === true || value === true ? "margin" : "border" );
+
+ return jQuery.access( this, function( elem, type, value ) {
+ var doc;
+
+ if ( jQuery.isWindow( elem ) ) {
+ // As of 5/8/2012 this will yield incorrect results for Mobile Safari, but there
+ // isn't a whole lot we can do. See pull request at this URL for discussion:
+ // https://github.com/jquery/jquery/pull/764
+ return elem.document.documentElement[ "client" + name ];
+ }
+
+ // Get document width or height
+ if ( elem.nodeType === 9 ) {
+ doc = elem.documentElement;
+
+ // Either scroll[Width/Height] or offset[Width/Height] or client[Width/Height], whichever is greatest
+ // unfortunately, this causes bug #3838 in IE6/8 only, but there is currently no good, small way to fix it.
+ return Math.max(
+ elem.body[ "scroll" + name ], doc[ "scroll" + name ],
+ elem.body[ "offset" + name ], doc[ "offset" + name ],
+ doc[ "client" + name ]
+ );
+ }
+
+ return value === undefined ?
+ // Get width or height on the element, requesting but not forcing parseFloat
+ jQuery.css( elem, type, extra ) :
+
+ // Set width or height on the element
+ jQuery.style( elem, type, value, extra );
+ }, type, chainable ? margin : undefined, chainable, null );
+ };
+ });
+});
+// Limit scope pollution from any deprecated API
+// (function() {
+
+// })();
+// Expose jQuery to the global object
+window.jQuery = window.$ = jQuery;
+
+// Expose jQuery as an AMD module, but only for AMD loaders that
+// understand the issues with loading multiple versions of jQuery
+// in a page that all might call define(). The loader will indicate
+// they have special allowances for multiple jQuery versions by
+// specifying define.amd.jQuery = true. Register as a named module,
+// since jQuery can be concatenated with other files that may use define,
+// but not use a proper concatenation script that understands anonymous
+// AMD modules. A named AMD is safest and most robust way to register.
+// Lowercase jquery is used because AMD module names are derived from
+// file names, and jQuery is normally delivered in a lowercase file name.
+// Do this after creating the global so that if an AMD module wants to call
+// noConflict to hide this version of jQuery, it will work.
+if ( typeof define === "function" && define.amd && define.amd.jQuery ) {
+ define( "jquery", [], function () { return jQuery; } );
+}
+
+})( window );
diff --git a/2.3/async/scalatra-atmosphere-embedded/src/main/webapp/js/jquery-atmosphere.js b/2.3/async/scalatra-atmosphere-embedded/src/main/webapp/js/jquery-atmosphere.js
new file mode 100644
index 00000000..534bd3aa
--- /dev/null
+++ b/2.3/async/scalatra-atmosphere-embedded/src/main/webapp/js/jquery-atmosphere.js
@@ -0,0 +1,2776 @@
+/**
+ * Copyright 2012 Jeanfrancois Arcand
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/*
+ * IE streaming/XDR supports is copied/highly inspired by http://code.google.com/p/jquery-stream/
+ *
+ * Copyright 2011, Donghwan Kim
+ * Licensed under the Apache License, Version 2.0
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * LocalStorage supports is copied/highly inspired by https://github.com/flowersinthesand/jquery-socket
+ * Copyright 2011, Donghwan Kim
+ * Licensed under the Apache License, Version 2.0
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * */
+/**
+ * Official documentation of this library: https://github.com/Atmosphere/atmosphere/wiki/jQuery.atmosphere.js-API
+ */
+jQuery.atmosphere = function() {
+ jQuery(window).bind("unload.atmosphere", function() {
+ jQuery.atmosphere.unsubscribe();
+ });
+
+ // Prevent ESC to kill the connection from Firefox.
+ jQuery(window).keypress(function(e){
+ if(e.keyCode == 27){
+ e.preventDefault();
+ }
+ });
+
+ var parseHeaders = function(headerString) {
+ var match, rheaders = /^(.*?):[ \t]*([^\r\n]*)\r?$/mg, headers = {};
+ while (match = rheaders.exec(headerString)) {
+ headers[match[1]] = match[2];
+ }
+ return headers;
+ };
+
+ return {
+ version : "1.1.0",
+ requests : [],
+ callbacks : [],
+
+ onError : function(response) {
+ },
+ onClose : function(response) {
+ },
+ onOpen : function(response) {
+ },
+ onMessage : function(response) {
+ },
+ onReconnect : function(request, response) {
+ },
+ onMessagePublished : function(response) {
+ },
+ onTransportFailure : function(errorMessage, _request) {
+ },
+ onLocalMessage : function (response) {
+ },
+
+ AtmosphereRequest : function(options) {
+
+ /**
+ * {Object} Request parameters.
+ * @private
+ */
+ var _request = {
+ timeout: 300000,
+ method: 'GET',
+ headers: {},
+ contentType : '',
+ callback: null,
+ url : '',
+ data : '',
+ suspend : true,
+ maxRequest : -1,
+ reconnect : true,
+ maxStreamingLength : 10000000,
+ lastIndex : 0,
+ logLevel : 'info',
+ requestCount : 0,
+ fallbackMethod: 'GET',
+ fallbackTransport : 'streaming',
+ transport : 'long-polling',
+ webSocketImpl: null,
+ webSocketBinaryType: null,
+ dispatchUrl: null,
+ webSocketPathDelimiter: "@@",
+ enableXDR : false,
+ rewriteURL : false,
+ attachHeadersAsQueryString : true,
+ executeCallbackBeforeReconnect : false,
+ readyState : 0,
+ lastTimestamp : 0,
+ withCredentials : false,
+ trackMessageLength : false ,
+ messageDelimiter : '|',
+ connectTimeout : -1,
+ reconnectInterval : 0,
+ dropAtmosphereHeaders : true,
+ uuid : 0,
+ shared : false,
+ readResponsesHeaders : false,
+ maxReconnectOnClose: 5,
+ enableProtocol: true,
+ onError : function(response) {
+ },
+ onClose : function(response) {
+ },
+ onOpen : function(response) {
+ },
+ onMessage : function(response) {
+ },
+ onReopen : function(request, response) {
+ },
+ onReconnect : function(request, response) {
+ },
+ onMessagePublished : function(response) {
+ },
+ onTransportFailure : function (reason, request) {
+ },
+ onLocalMessage : function (request) {
+ }
+ };
+
+ /**
+ * {Object} Request's last response.
+ * @private
+ */
+ var _response = {
+ status: 200,
+ reasonPhrase : "OK",
+ responseBody : '',
+ headers : [],
+ state : "messageReceived",
+ transport : "polling",
+ error: null,
+ request : null,
+ partialMessage : "",
+ errorHandled: false,
+ id : 0
+ };
+
+ /**
+ * {websocket} Opened web socket.
+ *
+ * @private
+ */
+ var _websocket = null;
+
+ /**
+ * {SSE} Opened SSE.
+ *
+ * @private
+ */
+ var _sse = null;
+
+ /**
+ * {XMLHttpRequest, ActiveXObject} Opened ajax request (in case of
+ * http-streaming or long-polling)
+ *
+ * @private
+ */
+ var _activeRequest = null;
+
+ /**
+ * {Object} Object use for streaming with IE.
+ *
+ * @private
+ */
+ var _ieStream = null;
+
+ /**
+ * {Object} Object use for jsonp transport.
+ *
+ * @private
+ */
+ var _jqxhr = null;
+
+ /**
+ * {boolean} If request has been subscribed or not.
+ *
+ * @private
+ */
+ var _subscribed = true;
+
+ /**
+ * {number} Number of test reconnection.
+ *
+ * @private
+ */
+ var _requestCount = 0;
+
+ /**
+ * {boolean} If request is currently aborded.
+ *
+ * @private
+ */
+ var _abordingConnection = false;
+
+ /**
+ * A local "channel' of communication.
+ * @private
+ */
+ var _localSocketF = null;
+
+ /**
+ * The storage used.
+ * @private
+ */
+ var _storageService;
+
+ /**
+ * Local communication
+ * @private
+ */
+ var _localStorageService = null;
+
+ /**
+ * A Unique ID
+ * @private
+ */
+ var guid = jQuery.now();
+
+ /** Trace time */
+ var _traceTimer;
+
+ // Automatic call to subscribe
+ _subscribe(options);
+
+ /**
+ * Initialize atmosphere request object.
+ *
+ * @private
+ */
+ function _init() {
+ _subscribed = true;
+ _abordingConnection = false;
+ _requestCount = 0;
+
+ _websocket = null;
+ _sse = null;
+ _activeRequest = null;
+ _ieStream = null;
+ }
+
+ /**
+ * Re-initialize atmosphere object.
+ * @private
+ */
+ function _reinit() {
+ _clearState();
+ _init();
+ }
+
+ /**
+ * Subscribe request using request transport.
+ * If request is currently opened, this one will be closed.
+ *
+ * @param {Object}
+ * Request parameters.
+ * @private
+ */
+ function _subscribe(options) {
+ _reinit();
+
+ _request = jQuery.extend(_request, options);
+ // Allow at least 1 request
+ _request.mrequest = _request.reconnect;
+ if (!_request.reconnect) {
+ _request.reconnect = true;
+ }
+ }
+
+ /**
+ * Check if web socket is supported (check for custom implementation
+ * provided by request object or browser implementation).
+ *
+ * @returns {boolean} True if web socket is supported, false
+ * otherwise.
+ * @private
+ */
+ function _supportWebsocket() {
+ return _request.webSocketImpl != null || window.WebSocket || window.MozWebSocket;
+ }
+
+ /**
+ * Check if server side events (SSE) is supported (check for custom implementation
+ * provided by request object or browser implementation).
+ *
+ * @returns {boolean} True if web socket is supported, false
+ * otherwise.
+ * @private
+ */
+ function _supportSSE() {
+ return window.EventSource;
+ }
+
+ /**
+ * Open request using request transport.
+ * If request transport is 'websocket' but websocket can't be
+ * opened, request will automatically reconnect using fallback
+ * transport.
+ *
+ * @private
+ */
+ function _execute() {
+ // Shared across multiple tabs/windows.
+ if (_request.shared) {
+ _localStorageService = _local(_request);
+ if (_localStorageService != null) {
+ if (_request.logLevel == 'debug') {
+ jQuery.atmosphere.debug("Storage service available. All communication will be local");
+ }
+
+ if (_localStorageService.open(_request)) {
+ // Local connection.
+ return;
+ }
+ }
+
+ if (_request.logLevel == 'debug') {
+ jQuery.atmosphere.debug("No Storage service available.");
+ }
+ // Wasn't local or an error occurred
+ _localStorageService = null;
+ }
+
+ // Protocol
+ _request.firstMessage = true;
+ _request.isOpen = false;
+ _request.ctime = jQuery.now();
+ _request.isReopen = false;
+
+ if (_request.transport != 'websocket' && _request.transport != 'sse') {
+ _executeRequest(_request);
+
+ } else if (_request.transport == 'websocket') {
+ if (!_supportWebsocket()) {
+ _reconnectWithFallbackTransport("Websocket is not supported, using request.fallbackTransport (" + _request.fallbackTransport + ")");
+ } else {
+ _executeWebSocket(false);
+ }
+ } else if (_request.transport == 'sse') {
+ if (!_supportSSE()) {
+ _reconnectWithFallbackTransport("Server Side Events(SSE) is not supported, using request.fallbackTransport (" + _request.fallbackTransport + ")");
+ } else {
+ _executeSSE(false);
+ }
+ }
+ }
+
+ function _local(request) {
+ var trace, connector, orphan, name = "atmosphere-" + request.url, connectors = {
+ storage: function() {
+ if (!jQuery.atmosphere.supportStorage()) {
+ return;
+ }
+
+ var storage = window.localStorage,
+ get = function(key) {
+ return jQuery.parseJSON(storage.getItem(name + "-" + key));
+ },
+ set = function(key, value) {
+ storage.setItem(name + "-" + key, jQuery.stringifyJSON(value));
+ };
+
+ return {
+ init: function() {
+ set("children", get("children").concat([guid]));
+ jQuery(window).on("storage.socket", function(event) {
+ event = event.originalEvent;
+ if (event.key === name && event.newValue) {
+ listener(event.newValue);
+ }
+ });
+ return get("opened");
+ },
+ signal: function(type, data) {
+ storage.setItem(name, jQuery.stringifyJSON({target: "p", type: type, data: data}));
+ },
+ close: function() {
+ var index, children = get("children");
+
+ jQuery(window).off("storage.socket");
+ if (children) {
+ index = jQuery.inArray(request.id, children);
+ if (index > -1) {
+ children.splice(index, 1);
+ set("children", children);
+ }
+ }
+ }
+ };
+ },
+ windowref: function() {
+ var win = window.open("", name.replace(/\W/g, ""));
+
+ if (!win || win.closed || !win.callbacks) {
+ return;
+ }
+
+ return {
+ init: function() {
+ win.callbacks.push(listener);
+ win.children.push(guid);
+ return win.opened;
+ },
+ signal: function(type, data) {
+ if (!win.closed && win.fire) {
+ win.fire(jQuery.stringifyJSON({target: "p", type: type, data: data}));
+ }
+ },
+ close : function() {
+ function remove(array, e) {
+ var index = jQuery.inArray(e, array);
+ if (index > -1) {
+ array.splice(index, 1);
+ }
+ }
+
+ // Removes traces only if the parent is alive
+ if (!orphan) {
+ remove(win.callbacks, listener);
+ remove(win.children, guid);
+ }
+ }
+
+ };
+ }
+ };
+
+ // Receives open, close and message command from the parent
+ function listener(string) {
+ var command = jQuery.parseJSON(string), data = command.data;
+
+ if (command.target === "c") {
+ switch (command.type) {
+ case "open":
+ _open("opening", 'local', _request)
+ break;
+ case "close":
+ if (!orphan) {
+ orphan = true;
+ if (data.reason === "aborted") {
+ _close();
+ } else {
+ // Gives the heir some time to reconnect
+ if (data.heir === guid) {
+ _execute();
+ } else {
+ setTimeout(function() {
+ _execute();
+ }, 100);
+ }
+ }
+ }
+ break;
+ case "message":
+ _prepareCallback(data, "messageReceived", 200, request.transport);
+ break;
+ case "localMessage":
+ _localMessage(data);
+ break;
+ }
+ }
+ }
+
+ function findTrace() {
+ var matcher = new RegExp("(?:^|; )(" + encodeURIComponent(name) + ")=([^;]*)").exec(document.cookie);
+ if (matcher) {
+ return jQuery.parseJSON(decodeURIComponent(matcher[2]));
+ }
+ }
+
+ // Finds and validates the parent socket's trace from the cookie
+ trace = findTrace();
+ if (!trace || jQuery.now() - trace.ts > 1000) {
+ return;
+ }
+
+ // Chooses a connector
+ connector = connectors.storage() || connectors.windowref();
+ if (!connector) {
+ return;
+ }
+
+ return {
+ open: function() {
+ var parentOpened;
+
+ // Checks the shared one is alive
+ _traceTimer = setInterval(function() {
+ var oldTrace = trace;
+ trace = findTrace();
+ if (!trace || oldTrace.ts === trace.ts) {
+ // Simulates a close signal
+ listener(jQuery.stringifyJSON({target: "c", type: "close", data: {reason: "error", heir: oldTrace.heir}}));
+ }
+ }, 1000);
+
+ parentOpened = connector.init();
+ if (parentOpened) {
+ // Firing the open event without delay robs the user of the opportunity to bind connecting event handlers
+ setTimeout(function() {
+ _open("opening", 'local', request)
+ }, 50);
+ }
+ return parentOpened;
+ },
+ send: function(event) {
+ connector.signal("send", event);
+ },
+ localSend: function(event) {
+ connector.signal("localSend", jQuery.stringifyJSON({id: guid , event: event}));
+ },
+ close: function() {
+ // Do not signal the parent if this method is executed by the unload event handler
+ if (!_abordingConnection) {
+ clearInterval(_traceTimer);
+ connector.signal("close");
+ connector.close();
+ }
+ }
+ };
+ };
+
+ function share() {
+ var storageService, name = "atmosphere-" + _request.url, servers = {
+ // Powered by the storage event and the localStorage
+ // http://www.w3.org/TR/webstorage/#event-storage
+ storage: function() {
+ if (!jQuery.atmosphere.supportStorage()) {
+ return;
+ }
+
+ var storage = window.localStorage;
+
+ return {
+ init: function() {
+ // Handles the storage event
+ jQuery(window).on("storage.socket", function(event) {
+ event = event.originalEvent;
+ // When a deletion, newValue initialized to null
+ if (event.key === name && event.newValue) {
+ listener(event.newValue);
+ }
+ });
+ },
+ signal: function(type, data) {
+ storage.setItem(name, jQuery.stringifyJSON({target: "c", type: type, data: data}));
+ },
+ get: function(key) {
+ return jQuery.parseJSON(storage.getItem(name + "-" + key));
+ },
+ set: function(key, value) {
+ storage.setItem(name + "-" + key, jQuery.stringifyJSON(value));
+ },
+ close : function() {
+ jQuery(window).off("storage.socket");
+ storage.removeItem(name);
+ storage.removeItem(name + "-opened");
+ storage.removeItem(name + "-children");
+ }
+
+ };
+ },
+ // Powered by the window.open method
+ // https://developer.mozilla.org/en/DOM/window.open
+ windowref: function() {
+ // Internet Explorer raises an invalid argument error
+ // when calling the window.open method with the name containing non-word characters
+ var neim = name.replace(/\W/g, ""), win = (jQuery('iframe[name="' + neim + '"]')[0]
+ || jQuery('
').hide().appendTo("body")[0]).contentWindow;
+
+ return {
+ init: function() {
+ // Callbacks from different windows
+ win.callbacks = [listener];
+ // In IE 8 and less, only string argument can be safely passed to the function in other window
+ win.fire = function(string) {
+ var i;
+
+ for (i = 0; i < win.callbacks.length; i++) {
+ win.callbacks[i](string);
+ }
+ };
+ },
+ signal: function(type, data) {
+ if (!win.closed && win.fire) {
+ win.fire(jQuery.stringifyJSON({target: "c", type: type, data: data}));
+ }
+ },
+ get: function(key) {
+ return !win.closed ? win[key] : null;
+ },
+ set: function(key, value) {
+ if (!win.closed) {
+ win[key] = value;
+ }
+ },
+ close : function() {}
+ };
+ }
+ };
+
+
+ // Receives send and close command from the children
+ function listener(string) {
+ var command = jQuery.parseJSON(string), data = command.data;
+
+ if (command.target === "p") {
+ switch (command.type) {
+ case "send":
+ _push(data);
+ break;
+ case "localSend":
+ _localMessage(data);
+ break;
+ case "close":
+ _close();
+ break;
+ }
+ }
+ }
+
+ _localSocketF = function propagateMessageEvent(context) {
+ storageService.signal("message", context);
+ }
+
+ function leaveTrace() {
+ document.cookie = encodeURIComponent(name) + "=" +
+ // Opera's JSON implementation ignores a number whose a last digit of 0 strangely
+ // but has no problem with a number whose a last digit of 9 + 1
+ encodeURIComponent(jQuery.stringifyJSON({ts: jQuery.now() + 1, heir: (storageService.get("children") || [])[0]}));
+ }
+
+ // Chooses a storageService
+ storageService = servers.storage() || servers.windowref();
+ storageService.init();
+
+ if (_request.logLevel == 'debug') {
+ jQuery.atmosphere.debug("Installed StorageService " + storageService);
+ }
+
+ // List of children sockets
+ storageService.set("children", []);
+
+ if (storageService.get("opened") != null && !storageService.get("opened")) {
+ // Flag indicating the parent socket is opened
+ storageService.set("opened", false);
+ }
+ // Leaves traces
+ leaveTrace();
+ _traceTimer = setInterval(leaveTrace, 1000);
+
+ _storageService = storageService;
+ }
+
+ /**
+ * @private
+ */
+ function _open(state, transport, request) {
+ if (_request.shared && transport != 'local') {
+ share();
+ }
+
+ if (_storageService != null) {
+ _storageService.set("opened", true);
+ }
+
+ request.close = function() {
+ _close();
+ };
+
+ if (_response.error == null) {
+ _response.request = request;
+ var prevState = _response.state;
+ _response.state = state;
+ var prevTransport = _response.transport;
+ _response.transport = transport;
+
+ var _body = _response.responseBody;
+ _invokeCallback();
+ _response.responseBody = _body;
+
+ _response.state = prevState;
+ _response.transport = prevTransport;
+ }
+ }
+
+ /**
+ * Execute request using jsonp transport.
+ *
+ * @param request
+ * {Object} request Request parameters, if
+ * undefined _request object will be used.
+ * @private
+ */
+ function _jsonp(request) {
+ // When CORS is enabled, make sure we force the proper transport.
+ request.transport="jsonp";
+
+ var rq = _request;
+ if ((request != null) && (typeof(request) != 'undefined')) {
+ rq = request;
+ }
+
+ var url = rq.url;
+ if (rq.dispatchUrl != null) {
+ url += rq.dispatchUrl;
+ }
+
+ var data = rq.data;
+ if (rq.attachHeadersAsQueryString) {
+ url = _attachHeaders(rq);
+ if (data != '') {
+ url += "&X-Atmosphere-Post-Body=" + encodeURIComponent(data);
+ }
+ data = '';
+ }
+
+ _jqxhr = jQuery.ajax({
+ url : url,
+ type : rq.method,
+ dataType: "jsonp",
+ error : function(jqXHR, textStatus, errorThrown) {
+ _response.error = true;
+ if (jqXHR.status < 300) {
+ _reconnect(_jqxhr, rq);
+ } else {
+ _onError(jqXHR.status, errorThrown);
+ }
+ },
+ jsonp : "jsonpTransport",
+ success: function(json) {
+ if (rq.reconnect) {
+ if (rq.maxRequest == -1 || rq.requestCount++ < rq.maxRequest) {
+ _readHeaders(_jqxhr, rq);
+
+ if (!rq.executeCallbackBeforeReconnect) {
+ _reconnect(_jqxhr, rq);
+ }
+
+ var msg = json.message;
+ if (msg != null && typeof msg != 'string') {
+ try {
+ msg = jQuery.stringifyJSON(msg);
+ } catch (err) {
+ // The message was partial
+ }
+ }
+
+ var skipCallbackInvocation = _trackMessageSize(msg, rq, _response);
+ if (!skipCallbackInvocation) {
+ _prepareCallback(_response.responseBody, "messageReceived", 200, rq.transport);
+ }
+
+ if (rq.executeCallbackBeforeReconnect) {
+ _reconnect(_jqxhr, rq);
+ }
+ } else {
+ jQuery.atmosphere.log(_request.logLevel, ["JSONP reconnect maximum try reached " + _request.requestCount]);
+ _onError(0, "maxRequest reached");
+ }
+ }
+ },
+ data : rq.data,
+ beforeSend : function(jqXHR) {
+ _doRequest(jqXHR, rq, false);
+ }
+ });
+ }
+
+ /**
+ * Execute request using ajax transport.
+ *
+ * @param request
+ * {Object} request Request parameters, if
+ * undefined _request object will be used.
+ * @private
+ */
+ function _ajax(request) {
+ var rq = _request;
+ if ((request != null) && (typeof(request) != 'undefined')) {
+ rq = request;
+ }
+
+ var url = rq.url;
+ if (rq.dispatchUrl != null) {
+ url += rq.dispatchUrl;
+ }
+
+ var data = rq.data;
+ if (rq.attachHeadersAsQueryString) {
+ url = _attachHeaders(rq);
+ if (data != '') {
+ url += "&X-Atmosphere-Post-Body=" + encodeURIComponent(data);
+ }
+ data = '';
+ }
+
+ var async = typeof(rq.async) != 'undefined' ? rq.async : true;
+ _jqxhr = jQuery.ajax({
+ url : url,
+ type : rq.method,
+ error : function(jqXHR, textStatus, errorThrown) {
+ _response.error = true;
+ if (jqXHR.status < 300) {
+ _reconnect(_jqxhr, rq);
+ } else {
+ _onError(jqXHR.status, errorThrown);
+ }
+ },
+ success: function(data, textStatus, jqXHR) {
+
+ if (rq.reconnect) {
+ if (rq.maxRequest == -1 || rq.requestCount++ < rq.maxRequest) {
+ if (!rq.executeCallbackBeforeReconnect) {
+ _reconnect(_jqxhr, rq);
+ }
+ var skipCallbackInvocation = _trackMessageSize(data, rq, _response);
+ if (!skipCallbackInvocation) {
+ _prepareCallback(_response.responseBody, "messageReceived", 200, rq.transport);
+ }
+
+ if (rq.executeCallbackBeforeReconnect) {
+ _reconnect(_jqxhr, rq);
+ }
+ } else {
+ jQuery.atmosphere.log(_request.logLevel, ["AJAX reconnect maximum try reached " + _request.requestCount]);
+ _onError(0, "maxRequest reached");
+ }
+ }
+ },
+ beforeSend : function(jqXHR) {
+ _doRequest(jqXHR, rq, false);
+ },
+ crossDomain : rq.enableXDR,
+ async: async
+ });
+ }
+
+ /**
+ * Build websocket object.
+ *
+ * @param location
+ * {string} Web socket url.
+ * @returns {websocket} Web socket object.
+ * @private
+ */
+ function _getWebSocket(location) {
+ if (_request.webSocketImpl != null) {
+ return _request.webSocketImpl;
+ } else {
+ if (window.WebSocket) {
+ return new WebSocket(location);
+ } else {
+ return new MozWebSocket(location);
+ }
+ }
+ }
+
+ /**
+ * Build web socket url from request url.
+ *
+ * @return {string} Web socket url (start with "ws" or "wss" for
+ * secure web socket).
+ * @private
+ */
+ function _buildWebSocketUrl() {
+ var url = _attachHeaders(_request);
+
+ return decodeURI(jQuery('
')[0].href.replace(/^http/, "ws"));
+ }
+
+ /**
+ * Build SSE url from request url.
+ *
+ * @return a url with Atmosphere's headers
+ * @private
+ */
+ function _buildSSEUrl() {
+ var url = _attachHeaders(_request);
+ return url;
+ }
+
+ /**
+ * Open SSE.
+ * Automatically use fallback transport if SSE can't be
+ * opened.
+ *
+ * @private
+ */
+ function _executeSSE(sseOpened) {
+
+ _response.transport = "sse";
+
+ var location = _buildSSEUrl(_request.url);
+
+ if (_request.logLevel == 'debug') {
+ jQuery.atmosphere.debug("Invoking executeSSE");
+ jQuery.atmosphere.debug("Using URL: " + location);
+ }
+
+ if (_request.enableProtocol && sseOpened) {
+ var time = jQuery.now() - _request.ctime;
+ _request.lastTimestamp = Number(_request.stime) + Number(time);
+ }
+
+ if (sseOpened && !_request.reconnect) {
+ if (_sse != null) {
+ _clearState();
+ }
+ return;
+ }
+
+ try {
+ _sse = new EventSource(location, {withCredentials: _request.withCredentials});
+ } catch (e) {
+ _onError(0, e);
+ _reconnectWithFallbackTransport("SSE failed. Downgrading to fallback transport and resending");
+ return;
+ }
+
+ if (_request.connectTimeout > 0) {
+ _request.id = setTimeout(function() {
+ if (!sseOpened) {
+ _clearState();
+ }
+ }, _request.connectTimeout);
+ }
+
+ _sse.onopen = function(event) {
+ if (_request.logLevel == 'debug') {
+ jQuery.atmosphere.debug("SSE successfully opened");
+ }
+
+ if (!sseOpened) {
+ _open('opening', "sse", _request);
+ } else {
+ _open('re-opening', "sse", _request);
+ }
+ sseOpened = true;
+
+ if (_request.method == 'POST') {
+ _response.state = "messageReceived";
+ _sse.send(_request.data);
+ }
+ };
+
+ _sse.onmessage = function(message) {
+ if (message.origin != window.location.protocol + "//" + window.location.host) {
+ jQuery.atmosphere.log(_request.logLevel, ["Origin was not " + window.location.protocol + "//" + window.location.host]);
+ return;
+ }
+
+ _response.state = 'messageReceived';
+ _response.status = 200;
+
+ message = message.data;
+ var skipCallbackInvocation = _trackMessageSize(message, _request, _response);
+
+ if (jQuery.trim(message).length == 0) {
+ skipCallbackInvocation = true;
+ }
+
+ if (!skipCallbackInvocation) {
+ _invokeCallback();
+ _response.responseBody = '';
+ }
+ };
+
+ _sse.onerror = function(message) {
+
+ clearTimeout(_request.id);
+ _response.state = 'closed';
+ _response.responseBody = "";
+ _response.status = !sseOpened ? 501 : 200;
+ _invokeCallback();
+ _clearState();
+
+ if (_abordingConnection) {
+ jQuery.atmosphere.log(_request.logLevel, ["SSE closed normally"]);
+ } else if (!sseOpened) {
+ _reconnectWithFallbackTransport("SSE failed. Downgrading to fallback transport and resending");
+ } else if (_request.reconnect && (_response.transport == 'sse')) {
+ if (_requestCount++ < _request.maxReconnectOnClose) {
+ _open('re-connecting', _request.transport, _request);
+ _request.id = setTimeout(function() {
+ _executeSSE(true);
+ }, _request.reconnectInterval);
+ _response.responseBody = "";
+ } else {
+ jQuery.atmosphere.log(_request.logLevel, ["SSE reconnect maximum try reached " + _requestCount]);
+ _onError(0, "maxReconnectOnClose reached");
+ }
+ }
+ };
+ }
+
+ /**
+ * Open web socket.
+ * Automatically use fallback transport if web socket can't be
+ * opened.
+ *
+ * @private
+ */
+ function _executeWebSocket(webSocketOpened) {
+
+ _response.transport = "websocket";
+
+ if (_request.enableProtocol && webSocketOpened) {
+ var time = jQuery.now() - _request.ctime;
+ _request.lastTimestamp = Number(_request.stime) + Number(time);
+ }
+
+ var location = _buildWebSocketUrl(_request.url);
+ var closed = false;
+
+ if (_request.logLevel == 'debug') {
+ jQuery.atmosphere.debug("Invoking executeWebSocket");
+ jQuery.atmosphere.debug("Using URL: " + location);
+ }
+
+ if (webSocketOpened && !_request.reconnect) {
+ if (_websocket != null) {
+ _clearState();
+ }
+ return;
+ }
+
+ _websocket = _getWebSocket(location);
+ if(_request.webSocketBinaryType != null){
+ _websocket.binaryType = _request.webSocketBinaryType;
+ }
+
+ if (_request.connectTimeout > 0) {
+ _request.id = setTimeout(function() {
+ if (!webSocketOpened) {
+ var _message = {
+ code : 1002,
+ reason : "",
+ wasClean : false
+ };
+ _websocket.onclose(_message);
+ // Close it anyway
+ try {
+ _clearState();
+ } catch (e) {
+ }
+ return;
+ }
+
+ }, _request.connectTimeout);
+ }
+
+ _request.id = setTimeout(function() {
+ setTimeout(function () {
+ _clearState();
+ }, _request.reconnectInterval)
+ }, _request.timeout);
+
+ _websocket.onopen = function(message) {
+ if (_request.logLevel == 'debug') {
+ jQuery.atmosphere.debug("Websocket successfully opened");
+ }
+
+ if (!webSocketOpened) {
+ _open('opening', "websocket", _request);
+ } else {
+ _open('re-opening', "websocket", _request);
+ }
+
+ webSocketOpened = true;
+ _websocket.webSocketOpened = webSocketOpened;
+
+ if (_request.method == 'POST') {
+ _response.state = "messageReceived";
+ _websocket.send(_request.data);
+ }
+ };
+
+ _websocket.onmessage = function(message) {
+
+ clearTimeout(_request.id);
+ _request.id = setTimeout(function() {
+ setTimeout(function () {
+ _clearState();
+ }, _request.reconnectInterval)
+ }, _request.timeout);
+
+ _response.state = 'messageReceived';
+ _response.status = 200;
+
+ var message = message.data;
+ var isString = typeof(message) == 'string';
+ if(isString){
+ var skipCallbackInvocation = _trackMessageSize(message, _request, _response);
+ if (!skipCallbackInvocation) {
+ _invokeCallback();
+ _response.responseBody = '';
+ }
+ } else{
+ if (!_handleProtocol(_request, message)) return;
+
+ _response.responseBody = message;
+ _invokeCallback();
+ _response.responseBody = null;
+ }
+ };
+
+ _websocket.onerror = function(message) {
+ clearTimeout(_request.id)
+ };
+
+ _websocket.onclose = function(message) {
+ if (closed) return
+ clearTimeout(_request.id)
+
+ var reason = message.reason;
+ if (reason === "") {
+ switch (message.code) {
+ case 1000:
+ reason = "Normal closure; the connection successfully completed whatever purpose for which " +
+ "it was created.";
+ break;
+ case 1001:
+ reason = "The endpoint is going away, either because of a server failure or because the " +
+ "browser is navigating away from the page that opened the connection.";
+ break;
+ case 1002:
+ reason = "The endpoint is terminating the connection due to a protocol error.";
+ break;
+ case 1003:
+ reason = "The connection is being terminated because the endpoint received data of a type it " +
+ "cannot accept (for example, a text-only endpoint received binary data).";
+ break;
+ case 1004:
+ reason = "The endpoint is terminating the connection because a data frame was received that " +
+ "is too large.";
+ break;
+ case 1005:
+ reason = "Unknown: no status code was provided even though one was expected.";
+ break;
+ case 1006:
+ reason = "Connection was closed abnormally (that is, with no close frame being sent).";
+ break;
+ }
+ }
+
+ jQuery.atmosphere.warn("Websocket closed, reason: " + reason);
+ jQuery.atmosphere.warn("Websocket closed, wasClean: " + message.wasClean);
+
+ _response.state = 'closed';
+ _response.responseBody = "";
+ _response.status = !webSocketOpened ? 501 : 200;
+ _invokeCallback();
+
+ closed = true;
+
+ if (_abordingConnection) {
+ jQuery.atmosphere.log(_request.logLevel, ["Websocket closed normally"]);
+ } else if (!webSocketOpened) {
+ _reconnectWithFallbackTransport("Websocket failed. Downgrading to Comet and resending");
+
+ } else if (_request.reconnect && _response.transport == 'websocket') {
+ _clearState();
+ if (_requestCount++ < _request.maxReconnectOnClose) {
+ _open('re-connecting', _request.transport, _request);
+ _request.id = setTimeout(function() {
+ _response.responseBody = "";
+ _executeWebSocket(true);
+ }, _request.reconnectInterval);
+ } else {
+ jQuery.atmosphere.log(_request.logLevel, ["Websocket reconnect maximum try reached " + _request.requestCount]);
+ jQuery.atmosphere.warn("Websocket error, reason: " + message.reason);
+ _onError(0, "maxReconnectOnClose reached");
+ }
+ }
+ };
+ }
+
+ function _handleProtocol(request, message) {
+ // The first messages is always the uuid.
+ if (request.enableProtocol && request.firstMessage) {
+ request.firstMessage = false;
+ var messages = message.split(request.messageDelimiter);
+ request.uuid = messages[0];
+ request.stime = messages[1];
+ return false;
+ }
+ return true;
+ }
+
+ function _onError(code, reason) {
+ _clearState();
+
+ _response.state = 'error';
+ _response.reasonPhrase = reason
+ _response.responseBody = "";
+ _response.status = code;
+ _invokeCallback();
+ }
+
+ /**
+ * Track received message and make sure callbacks/functions are only invoked when the complete message
+ * has been received.
+ *
+ * @param message
+ * @param request
+ * @param response
+ */
+ function _trackMessageSize(message, request, response) {
+ if (!_handleProtocol( _request, message)) return true;
+
+ if (request.trackMessageLength) {
+ // If we have found partial message, prepend them.
+ if (response.partialMessage.length != 0) {
+ message = response.partialMessage + message;
+ }
+
+ var messages = [];
+ var messageLength = 0;
+ var messageStart = message.indexOf(request.messageDelimiter);
+ while (messageStart != -1) {
+ messageLength = message.substring(messageLength, messageStart);
+ message = message.substring(messageStart + request.messageDelimiter.length, message.length);
+
+ if (message.length == 0 || message.length < messageLength) break;
+
+ messageStart = message.indexOf(request.messageDelimiter);
+ messages.push(message.substring(0, messageLength));
+ }
+
+ if (messages.length == 0 || (messageStart != -1 && message.length != 0 && messageLength != message.length)){
+ response.partialMessage = messageLength + request.messageDelimiter + message ;
+ } else {
+ response.partialMessage = "";
+ }
+
+ if (messages.length != 0) {
+ response.responseBody = messages.join(request.messageDelimiter);
+ return false;
+ } else {
+ response.responseBody = "";
+ return true;
+ }
+ } else {
+ response.responseBody = message;
+ }
+ return false;
+ }
+
+ /**
+ * Reconnect request with fallback transport.
+ * Used in case websocket can't be opened.
+ *
+ * @private
+ */
+ function _reconnectWithFallbackTransport(errorMessage) {
+ jQuery.atmosphere.log(_request.logLevel, [errorMessage]);
+
+ if (typeof(_request.onTransportFailure) != 'undefined') {
+ _request.onTransportFailure(errorMessage, _request);
+ } else if (typeof(jQuery.atmosphere.onTransportFailure) != 'undefined') {
+ jQuery.atmosphere.onTransportFailure(errorMessage, _request);
+ }
+
+ _request.transport = _request.fallbackTransport;
+ if (_request.reconnect && _request.transport != 'none' || _request.transport == null) {
+ _request.method = _request.fallbackMethod;
+ _response.transport = _request.fallbackTransport;
+ _request.fallbackTransport = 'none';
+ _request.id = setTimeout(function() {
+ _execute();
+ }, _request.reconnectInterval);
+ } else {
+ _onError(500, "Unable to reconnect with fallback transport");
+ }
+ }
+
+ /**
+ * Get url from request and attach headers to it.
+ *
+ * @param request
+ * {Object} request Request parameters, if
+ * undefined _request object will be used.
+ *
+ * @returns {Object} Request object, if undefined,
+ * _request object will be used.
+ * @private
+ */
+ function _attachHeaders(request, url) {
+ var rq = _request;
+ if ((request != null) && (typeof(request) != 'undefined')) {
+ rq = request;
+ }
+
+ if (url == null) {
+ url = rq.url;
+ }
+
+ // If not enabled
+ if (!rq.attachHeadersAsQueryString) return url;
+
+ // If already added
+ if (url.indexOf("X-Atmosphere-Framework") != -1) {
+ return url;
+ }
+
+ url += (url.indexOf('?') != -1) ? '&' : '?';
+ url += "X-Atmosphere-tracking-id=" + rq.uuid;
+ url += "&X-Atmosphere-Framework=" + jQuery.atmosphere.version;
+ url += "&X-Atmosphere-Transport=" + rq.transport;
+
+ if (rq.trackMessageLength) {
+ url += "&X-Atmosphere-TrackMessageSize=" + "true";
+ }
+
+ if (rq.lastTimestamp != undefined) {
+ url += "&X-Cache-Date=" + rq.lastTimestamp;
+ } else {
+ url += "&X-Cache-Date=" + 0;
+ }
+
+ if (rq.contentType != '') {
+ url += "&Content-Type=" + rq.contentType;
+ }
+
+ if (rq.enableProtocol) {
+ url += "&X-atmo-protocol=true";
+ }
+
+ jQuery.each(rq.headers, function(name, value) {
+ var h = jQuery.isFunction(value) ? value.call(this, rq, request, _response) : value;
+ if (h != null) {
+ url += "&" + encodeURIComponent(name) + "=" + encodeURIComponent(h);
+ }
+ });
+
+ return url;
+ }
+
+ /**
+ * Build ajax request.
+ * Ajax Request is an XMLHttpRequest object, except for IE6 where
+ * ajax request is an ActiveXObject.
+ *
+ * @return {XMLHttpRequest, ActiveXObject} Ajax request.
+ * @private
+ */
+ function _buildAjaxRequest() {
+ if (jQuery.browser.msie) {
+ if (typeof XMLHttpRequest == "undefined")
+ XMLHttpRequest = function () {
+ try { return new ActiveXObject("Msxml2.XMLHTTP.6.0"); }
+ catch (e) {}
+ try { return new ActiveXObject("Msxml2.XMLHTTP.3.0"); }
+ catch (e) {}
+ try { return new ActiveXObject("Microsoft.XMLHTTP"); }
+ catch (e) {}
+ //Microsoft.XMLHTTP points to Msxml2.XMLHTTP and is redundant
+ throw new Error("This browser does not support XMLHttpRequest.");
+ };
+ }
+ return new XMLHttpRequest();
+ }
+
+ function _triggerOpen(rq) {
+ if (!rq.isOpen) {
+ rq.isOpen = true;
+ _open('opening', rq.transport, rq);
+ } else if (rq.isReopen) {
+ rq.isReopen = false;
+ _open('re-opening', rq.transport, rq);
+ }
+ }
+
+ /**
+ * Execute ajax request.
+ *
+ * @param request
+ * {Object} request Request parameters, if
+ * undefined _request object will be used.
+ * @private
+ */
+ function _executeRequest(request) {
+ var rq = _request;
+ if ((request != null) || (typeof(request) != 'undefined')) {
+ rq = request;
+ }
+
+ // CORS fake using JSONP
+ if ((rq.transport == 'jsonp') || ((rq.enableXDR) && (jQuery.atmosphere.checkCORSSupport()))) {
+ _jsonp(rq);
+ return;
+ }
+
+ if (rq.transport == 'ajax') {
+ _ajax(request);
+ return;
+ }
+
+ if (jQuery.browser.msie && jQuery.browser.version < 10) {
+ if ((rq.transport == 'streaming')) {
+ rq.enableXDR && window.XDomainRequest ? _ieXDR(rq) : _ieStreaming(rq);
+ return;
+ }
+
+ if ((rq.enableXDR) && (window.XDomainRequest)) {
+ _ieXDR(rq);
+ return;
+ }
+ }
+
+ if (rq.reconnect && ( rq.maxRequest == -1 || rq.requestCount++ < rq.maxRequest)) {
+ var ajaxRequest = _buildAjaxRequest();
+ _doRequest(ajaxRequest, rq, true);
+
+ if (rq.suspend) {
+ _activeRequest = ajaxRequest;
+ }
+
+ if (rq.transport != 'polling') {
+ _response.transport = rq.transport;
+ }
+
+ ajaxRequest.onerror = function() {
+ _response.error = true;
+ try {
+ _response.status = XMLHttpRequest.status;
+ } catch(e) {
+ _response.status = 500;
+ }
+
+ if (!_response.status) {
+ _response.status = 500;
+ }
+ _clearState();
+
+ if (!_response.errorHandled) {
+ if (rq.reconnect && _requestCount++ < rq.maxReconnectOnClose) {
+ _reconnect(ajaxRequest, rq, true);
+ } else {
+ _onError(0, "maxReconnectOnClose reached");
+ }
+ }
+ _response.errorHandled = true;
+ };
+
+ ajaxRequest.onreadystatechange = function() {
+ if (_abordingConnection) {
+ return;
+ }
+ _response.error = null;
+ var skipCallbackInvocation = false;
+ var update = false;
+
+ // Remote server disconnected us, reconnect.
+ if (rq.transport == 'streaming'
+ && rq.readyState > 2
+ && ajaxRequest.readyState == 4) {
+
+ rq.readyState = 0;
+ rq.lastIndex = 0;
+
+ _reconnect(ajaxRequest, rq, true);
+ return;
+ }
+
+ rq.readyState = ajaxRequest.readyState;
+
+ if (ajaxRequest.readyState == 4) {
+ if (jQuery.browser.msie) {
+ update = true;
+ } else if (rq.transport == 'streaming') {
+ update = true;
+ } else if (rq.transport == 'long-polling') {
+ update = true;
+ clearTimeout(rq.id);
+ }
+ } else if (rq.transport == 'streaming' && jQuery.browser.msie && ajaxRequest.readyState >= 3) {
+ update = true;
+ } else if (!jQuery.browser.msie && ajaxRequest.readyState == 3 && ajaxRequest.status == 200 && rq.transport != 'long-polling') {
+ update = true;
+ } else {
+ clearTimeout(rq.id);
+ }
+
+ if (update) {
+ var responseText = jQuery.trim(ajaxRequest.responseText);
+
+ if (responseText.length == 0) return;
+
+ // MSIE 9 and lower status can be higher than 1000, Chrome can be 0
+ if (ajaxRequest.status >= 300 || ajaxRequest.status == 0) {
+
+ var status = ajaxRequest.status > 1000 ? ajaxRequest.status = 0 : ajaxRequest.status;
+ // Allow recovering from cached content.
+ clearTimeout(rq.id);
+
+ // Prevent onerror callback to be called
+ _response.errorHandled = true;
+ if (status < 400 && _requestCount++ < _request.maxReconnectOnClose) {
+ _reconnect(ajaxRequest, rq, true);
+ } else {
+ _onError(status, "maxReconnectOnClose reached");
+ }
+ return;
+ }
+
+ _triggerOpen(rq);
+
+ _readHeaders(ajaxRequest, _request);
+
+ if (rq.transport == 'streaming') {
+ var message = responseText.substring(rq.lastIndex, responseText.length);
+ skipCallbackInvocation = _trackMessageSize(message, rq, _response);
+
+ if (!skipCallbackInvocation) {
+ rq.lastIndex = responseText.length;
+ return;
+ }
+
+ rq.lastIndex = responseText.length;
+
+ if (jQuery.browser.opera) {
+ jQuery.atmosphere.iterate(function () {
+ if (ajaxRequest.responseText.length > rq.lastIndex) {
+ try {
+ _response.status = ajaxRequest.status;
+ _response.headers = parseHeaders(ajaxRequest.getAllResponseHeaders());
+
+ _readHeaders(ajaxRequest, _request);
+
+ }
+ catch (e) {
+ _response.status = 404;
+ }
+
+ //any message from the server will reset the last ping time
+ rq.lastPingTime = (new Date()).getTime();
+ _response.state = "messageReceived";
+ _response.responseBody = ajaxRequest.responseText.substring(rq.lastIndex);
+ rq.lastIndex = ajaxRequest.responseText.length;
+
+ if (!skipCallbackInvocation) {
+ _invokeCallback();
+ }
+ if ((rq.transport == 'streaming') && (ajaxRequest.responseText.length > rq.maxStreamingLength)) {
+ rq.isReopen = true;
+ _response.partialMessage = "";
+ if (rq.enableProtocol) {
+ var query = "X-Atmosphere-Transport=close&X-Atmosphere-tracking-id=" + rq.uuid;
+ var url = rq.url.replace(/([?&])_=[^&]*/, query);
+ url = url + (url === rq.url ? (/\?/.test(rq.url) ? "&" : "?") + query : "");
+ jQuery.ajax({url: url, async:false});
+ }
+ _clearState();
+ }
+ }
+ }, 0);
+ }
+
+ if (skipCallbackInvocation) {
+ return;
+ }
+ } else {
+ skipCallbackInvocation = _trackMessageSize(responseText, rq, _response);
+ if (!skipCallbackInvocation) {
+ _reconnect(ajaxRequest, rq, false);
+ return;
+ }
+
+ rq.lastIndex = responseText.length;
+ }
+
+ try {
+ _response.status = ajaxRequest.status;
+ _response.headers = parseHeaders(ajaxRequest.getAllResponseHeaders());
+
+ _readHeaders(ajaxRequest, rq);
+ } catch(e) {
+ _response.status = 404;
+ }
+
+ if (rq.suspend) {
+ _response.state = _response.status == 0 ? "closed" : "messageReceived";
+ } else {
+ _response.state = "messagePublished";
+ }
+
+
+ if (!rq.executeCallbackBeforeReconnect) {
+ _reconnect(ajaxRequest, rq, false);
+ }
+
+ if (_response.responseBody.length != 0 && !skipCallbackInvocation) _invokeCallback();
+
+ if (rq.executeCallbackBeforeReconnect) {
+ _reconnect(ajaxRequest, rq, false);
+ }
+
+ if ((rq.transport == 'streaming') && (responseText.length > rq.maxStreamingLength)) {
+ // Close and reopen connection on large data received
+ rq.isReopen = true;
+ setTimeout(function () {
+ _response.partialMessage = "";
+ if (rq.enableProtocol) {
+ var query = "X-Atmosphere-Transport=close&X-Atmosphere-tracking-id=" + rq.uuid;
+ var url = rq.url.replace(/([?&])_=[^&]*/, query);
+ url = url + (url === rq.url ? (/\?/.test(rq.url) ? "&" : "?") + query : "");
+ jQuery.ajax({url: url, async:false});
+ }
+ _clearState();
+ }, rq.reconnectInterval)
+ }
+ }
+ };
+ ajaxRequest.send(rq.data);
+
+ if (rq.suspend) {
+ rq.id = setTimeout(function() {
+ if (_subscribed) {
+ setTimeout(function () {
+ _clearState();
+ rq.isReopen = true;
+ _executeRequest(rq);
+ }, rq.reconnectInterval)
+ }
+ }, rq.timeout);
+ }
+ _subscribed = true;
+
+ } else {
+ if (rq.logLevel == 'debug') {
+ jQuery.atmosphere.log(rq.logLevel, ["Max re-connection reached."]);
+ }
+ _onError(0, "maxRequest reached");
+ }
+ }
+
+ /**
+ * Do ajax request.
+ * @param ajaxRequest Ajax request.
+ * @param request Request parameters.
+ * @param create If ajax request has to be open.
+ */
+ function _doRequest(ajaxRequest, request, create) {
+ // Prevent Android to cache request
+ var url = request.url;
+ if (request.dispatchUrl != null && request.method == 'POST') {
+ url += request.dispatchUrl;
+ }
+ url = _attachHeaders(request, url);
+ url = jQuery.atmosphere.prepareURL(url);
+
+ if (create) {
+ ajaxRequest.open(request.method, url, true);
+ if (request.connectTimeout > -1) {
+ request.id = setTimeout(function() {
+ if (request.requestCount == 0) {
+ _clearState();
+ _prepareCallback("Connect timeout", "closed", 200, request.transport);
+ }
+ }, request.connectTimeout);
+ }
+ }
+
+ if (_request.withCredentials) {
+ if ("withCredentials" in ajaxRequest) {
+ ajaxRequest.withCredentials = true;
+ }
+ }
+
+ if (!_request.dropAtmosphereHeaders) {
+ ajaxRequest.setRequestHeader("X-Atmosphere-Framework", jQuery.atmosphere.version);
+ ajaxRequest.setRequestHeader("X-Atmosphere-Transport", request.transport);
+ if (request.lastTimestamp != undefined) {
+ ajaxRequest.setRequestHeader("X-Cache-Date", request.lastTimestamp);
+ } else {
+ ajaxRequest.setRequestHeader("X-Cache-Date", 0);
+ }
+
+ if (request.trackMessageLength) {
+ ajaxRequest.setRequestHeader("X-Atmosphere-TrackMessageSize", "true")
+ }
+ ajaxRequest.setRequestHeader("X-Atmosphere-tracking-id", request.uuid);
+ }
+
+ if (request.contentType != '') {
+ ajaxRequest.setRequestHeader("Content-Type", request.contentType);
+ }
+
+ jQuery.each(request.headers, function(name, value) {
+ var h = jQuery.isFunction(value) ? value.call(this, ajaxRequest, request, create, _response) : value;
+ if (h != null) {
+ ajaxRequest.setRequestHeader(name, h);
+ }
+ });
+ }
+
+ function _reconnect(ajaxRequest, request, force) {
+ if (force || request.transport != 'streaming') {
+ if ( request.reconnect || (request.suspend && _subscribed)) {
+ var status = ajaxRequest.status > 1000 ? ajaxRequest.status = 0 : ajaxRequest.status;
+ _response.status = status == 0 ? 204 : status;
+ _response.reason = status == 0 ? "Server resumed the connection or down." : "OK";
+ _open('re-connecting', request.transport, request);
+ request.id = setTimeout(function() {
+ request.isReopen = true;
+ _executeRequest(request);
+ }, request.reconnectInterval);
+ }
+ }
+ }
+
+ // From jquery-stream, which is APL2 licensed as well.
+ function _ieXDR(request) {
+ if (request.transport != "polling") {
+ _ieStream = _configureXDR(request);
+ _ieStream.open();
+ } else {
+ _configureXDR(request).open();
+ }
+ }
+
+ // From jquery-stream
+ function _configureXDR(request) {
+ var rq = _request;
+ if ((request != null) && (typeof(request) != 'undefined')) {
+ rq = request;
+ }
+
+ var transport = rq.transport;
+ var xdr = new window.XDomainRequest();
+ var rewriteURL = rq.rewriteURL || function(url) {
+ // Maintaining session by rewriting URL
+ // http://stackoverflow.com/questions/6453779/maintaining-session-by-rewriting-url
+ var match = /(?:^|;\s*)(JSESSIONID|PHPSESSID)=([^;]*)/.exec(document.cookie);
+
+ switch (match && match[1]) {
+ case "JSESSIONID":
+ return url.replace(/;jsessionid=[^\?]*|(\?)|$/, ";jsessionid=" + match[2] + "$1");
+ case "PHPSESSID":
+ return url.replace(/\?PHPSESSID=[^&]*&?|\?|$/, "?PHPSESSID=" + match[2] + "&").replace(/&$/, "");
+ }
+ return url;
+ };
+
+ // Handles open and message event
+ xdr.onprogress = function() {
+ handle(xdr);
+ };
+ // Handles error event
+ xdr.onerror = function() {
+ // If the server doesn't send anything back to XDR will fail with polling
+ if (rq.transport != 'polling') {
+ _onError("XDR error");
+ }
+ };
+ // Handles close event
+ xdr.onload = function () {
+ handle(xdr);
+ };
+
+ var handle = function (xdr) {
+ // XDomain loop forever on itself without this.
+ // TODO: Clearly I need to come with something better than that solution
+ var message = jQuery.trim(xdr.responseText);
+ if (message.length == 0 || rq.lastMessage == message) return;
+
+ var reconnect = function() {
+ if (rq.transport == "long-polling" && (rq.reconnect && (rq.maxRequest == -1 || rq.requestCount++ < rq.maxRequest))) {
+ xdr.status = 200;
+ if (message.length != 0) {
+ _reconnect(xdr, rq, false);
+ }
+ }
+ }
+
+ var skipCallbackInvocation = _trackMessageSize(message, rq, _response);
+ _triggerOpen(rq);
+
+ if (rq.executeCallbackBeforeReconnect) {
+ reconnect();
+ }
+
+ if (!skipCallbackInvocation) {
+ _prepareCallback(_response.responseBody, "messageReceived", 200, transport);
+ }
+
+ if (!rq.executeCallbackBeforeReconnect) {
+ reconnect();
+ }
+ rq.lastMessage = message;
+ };
+
+ return {
+ open: function() {
+ var url = rq.url;
+ if (rq.dispatchUrl != null) {
+ url += rq.dispatchUrl;
+ }
+ url = _attachHeaders(rq, url);
+ xdr.open(rq.method, rewriteURL(url));
+ if (rq.method == 'GET') {
+ xdr.send();
+ } else {
+ xdr.send(rq.data);
+ }
+
+ if (rq.connectTimeout > -1) {
+ rq.id = setTimeout(function() {
+ if (rq.requestCount == 0) {
+ _clearState();
+ _prepareCallback("Connect timeout", "closed", 200, rq.transport);
+ }
+ }, rq.connectTimeout);
+ }
+ },
+ close: function() {
+ xdr.abort();
+ _prepareCallback(xdr.responseText, "closed", 200, transport);
+ }
+ };
+ }
+
+ // From jquery-stream, which is APL2 licensed as well.
+ function _ieStreaming(request) {
+ _ieStream = _configureIE(request);
+ _ieStream.open();
+ }
+
+ function _configureIE(request) {
+ var rq = _request;
+ if ((request != null) && (typeof(request) != 'undefined')) {
+ rq = request;
+ }
+
+ var stop;
+ var doc = new window.ActiveXObject("htmlfile");
+
+ doc.open();
+ doc.close();
+
+ var url = rq.url;
+ if (rq.dispatchUrl != null) {
+ url += rq.dispatchUrl;
+ }
+
+ if (rq.transport != 'polling') {
+ _response.transport = rq.transport;
+ }
+
+ return {
+ open: function() {
+ var iframe = doc.createElement("iframe");
+
+ url = _attachHeaders(rq);
+ if (rq.data != '') {
+ url += "&X-Atmosphere-Post-Body=" + encodeURIComponent(rq.data);
+ }
+
+ // Finally attach a timestamp to prevent Android and IE caching.
+ url = jQuery.atmosphere.prepareURL(url);
+
+ iframe.src = url;
+ doc.body.appendChild(iframe);
+
+ // For the server to respond in a consistent format regardless of user agent, we polls response text
+ var cdoc = iframe.contentDocument || iframe.contentWindow.document;
+
+ stop = jQuery.atmosphere.iterate(function() {
+ try {
+ if (!cdoc.firstChild) {
+ return;
+ }
+
+ // Detects connection failure
+ if (cdoc.readyState === "complete") {
+ try {
+ jQuery.noop(cdoc.fileSize);
+ } catch(e) {
+ _prepareCallback("Connection Failure", "error", 500, rq.transport);
+ return false;
+ }
+ }
+
+ var res = cdoc.body ? cdoc.body.lastChild : cdoc;
+ var readResponse = function() {
+ // Clones the element not to disturb the original one
+ var clone = res.cloneNode(true);
+
+ // If the last character is a carriage return or a line feed, IE ignores it in the innerText property
+ // therefore, we add another non-newline character to preserve it
+ clone.appendChild(cdoc.createTextNode("."));
+
+ var text = clone.innerText;
+
+ text = jQuery.trim(text.substring(0, text.length - 1));
+ return text;
+
+ };
+
+ //To support text/html content type
+ if (!jQuery.nodeName(res, "pre")) {
+ // Injects a plaintext element which renders text without interpreting the HTML and cannot be stopped
+ // it is deprecated in HTML5, but still works
+ var head = cdoc.head || cdoc.getElementsByTagName("head")[0] || cdoc.documentElement || cdoc;
+ var script = cdoc.createElement("script");
+
+ script.text = "document.write('