//////

/*
 * jQuery JSONP Core Plugin 2.1.0 (2010-06-16)
 *
 * http://code.google.com/p/jquery-jsonp/
 *
 * Copyright (c) 2010 Julian Aubourg
 *
 * This document is licensed as free software under the terms of the
 * MIT License: http://www.opensource.org/licenses/mit-license.php
 */
( function( $ , setTimeout ) {
       
        // ###################### UTILITIES ##
       
        // Noop
        function noop() {
        }
       
        // Generic callback for firefox & opera
        function genericCallback( data ) {
                lastValue = [ data ];
        }

        // Add script to document
        function appendScript( node ) {
                head.insertBefore( node , head.firstChild );
        }
       
        // Call if defined
        function callIfDefined( method , object , parameters ) {
	            var my_context = object.context?object.context:object;
                method && method.apply( my_context , parameters );
        }
       
        // Give joining character given url
        function qMarkOrAmp( url ) {
                return /\?/ .test( url ) ? "&" : "?";
        }
       
        var // String constants (for better minification)
                STR_ASYNC = "async",
                STR_EMPTY = "",
                STR_ERROR = "error",
                STR_JQUERY_JSONP = "_jqjsp",
                STR_ON = "on",
                STR_ONCLICK = STR_ON + "click",
                STR_ONERROR = STR_ON + STR_ERROR,
                STR_ONLOAD = STR_ON + "load",
                STR_ONREADYSTATECHANGE = STR_ON + "readystatechange",
                STR_REMOVE_CHILD = "removeChild",
                STR_SCRIPT_TAG = "<script/>",
                STR_SUCCESS = "success",
                STR_TIMEOUT = "timeout",
               
                // Shortcut to jQuery.browser
                browser = $.browser,
               
                // Head element (for faster use)
                head = $( "head" )[ 0 ] || document.documentElement,
                // Page cache
                pageCache = {},
                // Counter
                count = 0,
                // Last returned value
                lastValue,
               
                // ###################### DEFAULT OPTIONS ##
                xOptionsDefaults = {
                        //beforeSend: undefined,
                        //cache: false,
                        callback: STR_JQUERY_JSONP,
                        //callbackParameter: undefined,
                        //complete: undefined,
                        //data: ""
                        //dataFilter: undefined,
                        //error: undefined,
                        //pageCache: false,
                        //success: undefined,
                        //timeout: 0,
                        //traditional: false,          
                        url: location.href
                };
       
        // ###################### MAIN FUNCTION ##
        function jsonp( xOptions ) {
               
                // Build data with default
                xOptions = $.extend( {} , xOptionsDefaults , xOptions );
               
                // References to xOptions members (for better minification)
                var completeCallback = xOptions.complete,
                        dataFilter = xOptions.dataFilter,
                        callbackParameter = xOptions.callbackParameter,
                        successCallbackName = xOptions.callback,
                        cacheFlag = xOptions.cache,
                        pageCacheFlag = xOptions.pageCache,
                        url = xOptions.url,
                        data = xOptions.data,
                        timeout = xOptions.timeout,
                        pageCached,
                       
                        // References to beforeSend (for better minification)
                        beforeSendCallback = xOptions.beforeSend,
               
                        // Abort/done flag
                        done = 0,
                       
                        // Life-cycle functions
                        cleanUp = noop;
               
                // Create the abort method
                xOptions.abort = function() {
                        ! done++ &&     cleanUp();
                };

                // Call beforeSend if provided (early abort if false returned)
                if ( beforeSendCallback
                        && ( beforeSendCallback( xOptions , xOptions ) === false || done ) ) {
                        return xOptions;
                }
                       
                // Control entries
                url = url || STR_EMPTY;
                data = data ? ( (typeof data) == "string" ? data : $.param( data , xOptions.traditional ) ) : STR_EMPTY;
                       
                // Build final url
                url += data ? ( qMarkOrAmp( url ) + data ) : STR_EMPTY;
               
                // Add callback parameter if provided as option
                callbackParameter && ( url += qMarkOrAmp( url ) + escape(callbackParameter) + "=?" );
               
                // Add anticache parameter if needed
                ! cacheFlag && ! pageCacheFlag && ( url += qMarkOrAmp( url ) + "_" + ( new Date() ).getTime() + "=" );
               
                // Replace last ? by callback parameter
                url = url.replace( /=\?(&|$)/ , "=" + successCallbackName + "$1" );
               
                // Success notifier
                function notifySuccess( json ) {
                        ! done++ && setTimeout( function() {
                                cleanUp();
                                // Pagecache if needed
                                pageCacheFlag && ( pageCache [ url ] = { s: [ json ] } );
                                // Apply the data filter if provided
                                dataFilter && ( json = dataFilter.apply( xOptions , [ json ] ) );
                                // Call success then complete
                                callIfDefined( xOptions.success , xOptions , [ json , STR_SUCCESS ] );
                                callIfDefined( completeCallback , xOptions , [ xOptions , STR_SUCCESS ] );
                        } , 0 );
                }
               
                // Error notifier
            function notifyError( type ) {
                ! done++ && setTimeout( function() {
                        // Clean up
                        cleanUp();
                                // If pure error (not timeout), cache if needed
                                pageCacheFlag && type != STR_TIMEOUT && ( pageCache[ url ] = type );
                                // Call error then complete
                                callIfDefined( xOptions.error , xOptions , [ xOptions , type ] );
                                callIfDefined( completeCallback , xOptions , [ xOptions , type ] );
                } , 0 );
            }
           
                // Check page cache
                pageCacheFlag && ( pageCached = pageCache[ url ] )
                        ? ( pageCached.s ? notifySuccess( pageCached.s[ 0 ] ) : notifyError( pageCached ) )
                        :
                        // Initiate request
                        setTimeout( function( script , scriptAfter , timeoutTimer ) {
                               
                                if ( ! done ) {
                               
                                        // If a timeout is needed, install it
                                        timeoutTimer = timeout > 0 && setTimeout( function() {
                                                notifyError( STR_TIMEOUT );
                                        } , timeout );
                                       
                                        // Re-declare cleanUp function
                                        cleanUp = function() {
                                                timeoutTimer && clearTimeout( timeoutTimer );
                                                script[ STR_ONREADYSTATECHANGE ]
                                                        = script[ STR_ONCLICK ]
                                                        = script[ STR_ONLOAD ]
                                                        = script[ STR_ONERROR ]
                                                        = null;
                                                head[ STR_REMOVE_CHILD ]( script );
                                                scriptAfter && head[ STR_REMOVE_CHILD ]( scriptAfter );
                                        };
                                       
                                        // Install the generic callback
                                        // (BEWARE: global namespace pollution ahoy)
                                        window[ successCallbackName ] = genericCallback;

                                        // Create the script tag
                                        script = $( STR_SCRIPT_TAG )[ 0 ];
                                        script.id = STR_JQUERY_JSONP + count++;
                                       
                                        // Callback function
                                        function callback( result ) {
                                                ( script[ STR_ONCLICK ] || noop )();
                                                result = lastValue;
                                                lastValue = undefined;
                                                result ? notifySuccess( result[ 0 ] ) : notifyError( STR_ERROR );
                                        }
                                                                               
                                        // IE: event/htmlFor/onclick trick
                                        // One can't rely on proper order for onreadystatechange
                                        // We have to sniff since FF doesn't like event & htmlFor... at all
                                        if ( browser.msie ) {
                                               
                                                script.event = STR_ONCLICK;
                                                script.htmlFor = script.id;
                                                script[ STR_ONREADYSTATECHANGE ] = function() {
                                                        script.readyState == "loaded" && callback();
                                                };
                                               
                                        // All others: standard handlers
                                        } else {                                        
                                       
                                                script[ STR_ONERROR ] = script[ STR_ONLOAD ] = callback;
                                               
                                                browser.opera ?
                                                       
                                                        // Opera: onerror is not called, use synchronized script execution
                                                        ( ( scriptAfter = $( STR_SCRIPT_TAG )[ 0 ] ).text = "jQuery('#" + script.id + "')[0]." + STR_ONERROR + "()" )
                                                       
                                                        // Firefox: set script as async to avoid blocking scripts (3.6+ only)
                                                        : script[ STR_ASYNC ] = STR_ASYNC;
                                                       
                                                ;
                                        }
                                       
                                        // Set source
                                        script.src = url;
                                       
                                        // Append main script
                                        appendScript( script );
                                       
                                        // Opera: Append trailing script
                                        scriptAfter && appendScript( scriptAfter );
                                }
                               
                        } , 0 );
               
                return xOptions;
        }
       
        // ###################### SETUP FUNCTION ##
        jsonp.setup = function( xOptions ) {
                $.extend( xOptionsDefaults , xOptions );
        };


        // ###################### INSTALL in jQuery ##
        $.jsonp = jsonp;
       
} )( jQuery , setTimeout );