MyPersonalProducer.com - Hip Hop Beats | Beats | Instrumentals |
Free Beats | Buy Beats | Rap Beats "); // Use the defer script
hack var script = document.getElementById("__ie_init"); // script does
not exist if jQuery is loaded dynamically if ( script )
script.onreadystatechange = function() { if ( this.readyState !=
"complete" ) return; jQuery.ready(); }; // Clear from memory script =
null; // If Safari is used } else if ( jQuery.browser.safari ) //
Continually check to see if the document.readyState is valid
jQuery.safariTimer = setInterval(function(){ // loaded and complete
are both valid states if ( document.readyState == "loaded" ||
document.readyState == "complete" ) { // If either one are found,
remove the timer clearInterval( jQuery.safariTimer );
jQuery.safariTimer = null; // and execute any waiting functions
jQuery.ready(); } }, 10); // A fallback to window.onload, that will
always work jQuery.event.add( window, "load", jQuery.ready ); }; //
Clean up after IE to avoid memory leaks if (jQuery.browser.msie)
jQuery(window).one("unload", function() { var global =
jQuery.event.global; for ( var type in global ) { var els =
global[type], i = els.length; if ( i && type != 'unload' ) do els[i-1]
& while (--i); } }); jQuery.fn.extend({ loadIfModified: function( url,
params, callback ) { this.load( url, params, callback, 1 ); }, load:
function( url, params, callback, ifModified ) { if (
jQuery.isFunction( url ) ) return this.bind("load", url); callback =
callback || function(){}; // Default to a GET request var type =
"GET"; // If the second parameter was provided if ( params ) // If
it's a function if ( jQuery.isFunction( params ) ) { // We assume that
it's the callback callback = params; params = null; // Otherwise,
build a param string } else { params = jQuery.param( params ); type =
"POST"; } var self = this; // Request the remote document
jQuery.ajax({ url: url, type: type, data: params, ifModified:
ifModified, complete: function(res, status){ if ( status == "success"
|| !ifModified & else callback.apply( self, [res.responseText, status,
res] ); } }); return this; }, serialize: function() { return
jQuery.param( this ); }, evalScripts: function() { return
this.find("script").each(function(){ if ( this.src ) jQuery.getScript(
this.src ); else jQuery.globalEval( this.text || this.textContent ||
this.innerHTML || "" ); }).end(); } }); // Attach a bunch of functions
for handling common AJAX events jQuery.each(
"ajaxStart,ajaxStop,ajaxComplete,ajaxError,ajaxSuccess,ajaxSend".split(","),
function(i,o){ jQuery.fn[o] = function(f){ return this.bind(o, f); };
}); jQuery.extend({ get: function( url, data, callback, type,
ifModified ) { // shift arguments if data argument was ommited if (
jQuery.isFunction( data ) ) { callback = data; data = null; } return
jQuery.ajax({ type: "GET", url: url, data: data, success: callback,
dataType: type, ifModified: ifModified }); }, getIfModified: function(
url, data, callback, type ) { return jQuery.get(url, data, callback,
type, 1); }, getScript: function( url, callback ) { return
jQuery.get(url, null, callback, "script"); }, getJSON: function( url,
data, callback ) { return jQuery.get(url, data, callback, "json"); },
post: function( url, data, callback, type ) { if ( jQuery.isFunction(
data ) ) { callback = data; data = {}; } return jQuery.ajax({ type:
"POST", url: url, data: data, success: callback, dataType: type }); },
ajaxTimeout: function( timeout ) { jQuery.ajaxSettings.timeout =
timeout; }, ajaxSetup: function( settings ) { jQuery.extend(
jQuery.ajaxSettings, settings ); }, ajaxSettings: { global: true,
type: "GET", timeout: 0, contentType:
"application/x-www-form-urlencoded", processData: true, async: true,
data: null }, // Last-Modified header cache for next request
lastModified: {}, ajax: function( s ) { // TODO introduce global
settings, allowing the client to modify them for all requests, not
only timeout s = jQuery.extend({}, jQuery.ajaxSettings, s); // if data
available if ( s.data ) { // convert data if not already a string if
(s.processData & // append data to url for get requests if(
s.type.toLowerCase() == "get" ) { // "?" + data or "&" + data (in case
there are already params) s.url += ((s.url.indexOf("?") > -1) ? " //
IE likes to send both get and post data, prevent this s.data = null; }
} // Watch for a new set of requests if ( s.global & var requestDone =
false; // Create the request object; Microsoft failed to properly //
implement the XMLHttpRequest in IE7, so we use the ActiveXObject when
it is available var xml = window.ActiveXObject ? new
ActiveXObject("Microsoft.XMLHTTP") : new XMLHttpRequest(); // Open the
socket xml.open(s.type, s.url, s.async); // Set the correct header, if
data is being sent if ( s.data ) xml.setRequestHeader("Content-Type",
s.contentType); // Set the If-Modified-Since header, if ifModified
mode. if ( s.ifModified ) xml.setRequestHeader("If-Modified-Since",
jQuery.lastModified[s.url] || "Thu, 01 Jan 1970 00:00:00 GMT" ); //
Set header so the called script knows that it's an XMLHttpRequest
xml.setRequestHeader("X-Requested-With", "XMLHttpRequest"); // Allow
custom headers/mimetypes if( s.beforeSend ) s.beforeSend(xml); if (
s.global ) jQuery.event.trigger("ajaxSend", [xml, s]); // Wait for a
response to come back var onreadystatechange = function(isTimeout){ //
The transfer is complete and the data is available, or the request
timed out if ( xml & // clear poll interval if (ival) {
clearInterval(ival); ival = null; } var status; try { status =
jQuery.httpSuccess( xml ) && isTimeout != "timeout" ? s.ifModified &
// Make sure that the request was successful or notmodified if (
status != "error" ) { // Cache Last-Modified header, if ifModified
mode. var modRes; try { modRes =
xml.getResponseHeader("Last-Modified"); } catch(e) {} // swallow
exception thrown by FF if header is not available if ( s.ifModified &
// process the data (runs the xml through httpData regardless of
callback) var data = jQuery.httpData( xml, s.dataType ); // If a local
callback was specified, fire it and pass it the data if ( s.success )
s.success( data, status ); // Fire the global callback if( s.global )
jQuery.event.trigger( "ajaxSuccess", [xml, s] ); } else
jQuery.handleError(s, xml, status); } catch(e) { status = "error";
jQuery.handleError(s, xml, status, e); } // The request was completed
if( s.global ) jQuery.event.trigger( "ajaxComplete", [xml, s] ); //
Handle the global AJAX counter if ( s.global & // Process result if (
s.complete ) s.complete(xml, status); // Stop memory leaks if(s.async)
xml = null; } }; // don't attach the handler to the request, just poll
it instead var ival = setInterval(onreadystatechange, 13); // Timeout
checker if ( s.timeout > 0 ) setTimeout(function(){ // Check to see if
the request is still happening if ( xml ) { // Cancel the request
xml.abort(); if( !requestDone ) onreadystatechange( "timeout" ); } },
s.timeout); // Send the data try { xml.send(s.data); } catch(e) {
jQuery.handleError(s, xml, null, e); } // firefox 1.5 doesn't fire
statechange for sync requests if ( !s.async ) onreadystatechange(); //
return XMLHttpRequest to allow aborting the request etc. return xml;
}, handleError: function( s, xml, status, e ) { // If a local callback
was specified, fire it if ( s.error ) s.error( xml, status, e ); //
Fire the global callback if ( s.global ) jQuery.event.trigger(
"ajaxError", [xml, s, e] ); }, // Counter for holding the number of
active queries active: 0, // Determines if an XMLHttpRequest was
successful or not httpSuccess: function( r ) { try { return !r.status
&& location.protocol == "file:" || ( r.status >= 200 && r.status < 300
) || r.status == 304 || jQuery.browser.safari & } catch(e){} return
false; }, // Determines if an XMLHttpRequest returns NotModified
httpNotModified: function( xml, url ) { try { var xmlRes =
xml.getResponseHeader("Last-Modified"); // Firefox always returns 200.
check Last-Modified date return xml.status == 304 || xmlRes ==
jQuery.lastModified[url] || jQuery.browser.safari & } catch(e){}
return false; }, /* Get the data out of an XMLHttpRequest. * Return
parsed XML if content-type header is "xml" and type is "xml" or
omitted, * otherwise return plain text. * (String) data - The type of
data that you're expecting back, * (e.g. "xml", "html", "script") */
httpData: function( r, type ) { var ct =
r.getResponseHeader("content-type"); var data = !type && ct & data =
type == "xml" || data ? r.responseXML : r.responseText; // If the type
is "script", eval it in global context if ( type == "script" )
jQuery.globalEval( data ); // Get the JavaScript object, if JSON is
used. if ( type == "json" ) data = eval("(" + data + ")"); // evaluate
scripts within html if ( type == "html" )
jQuery("").html(data).evalScripts(); return data; }, // Serialize an
array of form elements or a set of // key/values into a query string
param: function( a ) { var s = []; // If an array was passed in,
assume that it is an array // of form elements if ( a.constructor ==
Array || a.jquery ) // Serialize the form elements jQuery.each( a,
function(){ s.push( encodeURIComponent(this.name) + "=" +
encodeURIComponent( this.value ) ); }); // Otherwise, assume that it's
an object of key/value pairs else // Serialize the key/values for (
var j in a ) // If the value is an array then the key names need to be
repeated if ( a[j] & }); else s.push( encodeURIComponent(j) + "=" +
encodeURIComponent( a[j] ) ); // Return the resulting serialization
return s.join(" }, // evalulates a script in global context // not
reliable for safari globalEval: function( data ) { if (
window.execScript ) window.execScript( data ); else if (
jQuery.browser.safari ) // safari doesn't provide a synchronous global
eval window.setTimeout( data, 0 ); else eval.call( window, data ); }
}); jQuery.fn.extend({ show: function(speed,callback){ return speed ?
this.animate({ height: "show", width: "show", opacity: "show" },
speed, callback) : this.filter(":hidden").each(function(){
this.style.display = this.oldblock ? this.oldblock : ""; if (
jQuery.css(this,"display") == "none" ) this.style.display = "block";
}).end(); }, hide: function(speed,callback){ return speed ?
this.animate({ height: "hide", width: "hide", opacity: "hide" },
speed, callback) : this.filter(":visible").each(function(){
this.oldblock = this.oldblock || jQuery.css(this,"display"); if (
this.oldblock == "none" ) this.oldblock = "block"; this.style.display
= "none"; }).end(); }, // Save the old toggle function _toggle:
jQuery.fn.toggle, toggle: function( fn, fn2 ){ return
jQuery.isFunction(fn) & }); }, slideDown: function(speed,callback){
return this.animate({height: "show"}, speed, callback); }, slideUp:
function(speed,callback){ return this.animate({height: "hide"}, speed,
callback); }, slideToggle: function(speed, callback){ return
this.animate({height: "toggle"}, speed, callback); }, fadeIn:
function(speed, callback){ return this.animate({opacity: "show"},
speed, callback); }, fadeOut: function(speed, callback){ return
this.animate({opacity: "hide"}, speed, callback); }, fadeTo:
function(speed,to,callback){ return this.animate({opacity: to}, speed,
callback); }, animate: function( prop, speed, easing, callback ) {
return this.queue(function(){ var hidden = jQuery(this).is(":hidden"),
opt = jQuery.speed(speed, easing, callback), self = this; for ( var p
in prop ) { if ( prop[p] == "hide" && hidden || prop[p] == "show" &&
!hidden ) return jQuery.isFunction(opt.complete) & if ( p == "height"
|| p == "width" ) { // Store display property opt.display =
jQuery.css(this, "display"); // Make sure that nothing sneaks out
opt.overflow = this.style.overflow; } } if ( opt.overflow != null )
this.style.overflow = "hidden"; this.curAnim = jQuery.extend({},
prop); jQuery.each( prop, function(name, val){ var e = new jQuery.fx(
self, opt, name ); if ( val.constructor == Number ) e.custom( e.cur(),
val ); else e[ val == "toggle" ? hidden ? "show" : "hide" : val ](
prop ); }); }); }, queue: function(type,fn){ if ( !fn ) { fn = type;
type = "fx"; } return this.each(function(){ if ( !this.queue )
this.queue = {}; if ( !this.queue[type] ) this.queue[type] = [];
this.queue[type].push( fn ); if ( this.queue[type].length == 1 )
fn.apply(this); }); } }); jQuery.extend({ speed: function(speed,
easing, fn) { var opt = speed && speed.constructor == Object ? speed :
{ complete: fn || !fn && easing || jQuery.isFunction( speed ) &&
speed, duration: speed, easing: fn && easing || easing &&
easing.constructor != Function & opt.duration = (opt.duration & //
Queueing opt.old = opt.complete; opt.complete = function(){
jQuery.dequeue(this, "fx"); if ( jQuery.isFunction( opt.old ) )
opt.old.apply( this ); }; return opt; }, easing: { linear: function(
p, n, firstNum, diff ) { return firstNum + diff * p; }, swing:
function( p, n, firstNum, diff ) { return ((-Math.cos(p*Math.PI)/2) +
0.5) * diff + firstNum; } }, queue: {}, dequeue: function(elem,type){
type = type || "fx"; if ( elem.queue & // Get next function var f =
elem.queue[type][0]; if ( f ) f.apply( elem ); } }, timers: [], /* * I
originally wrote fx() as a clone of moo.fx and in the process * of
making it small in size the code became illegible to sane * people.
You've been warned. */ fx: function( elem, options, prop ){ var z =
this; // The styles var y = elem.style; // Simple function for setting
a style value z.a = function(){ if ( options.step )
options.step.apply( elem, [ z.now ] ); if ( prop == "opacity" )
jQuery.attr(y, "opacity", z.now); // Let attr handle opacity else {
y[prop] = parseInt(z.now) + "px"; y.display = "block"; // Set display
property to block for animation } }; // Figure out the maximum number
to run to z.max = function(){ return parseFloat( jQuery.css(elem,prop)
); }; // Get the current size z.cur = function(){ var r = parseFloat(
jQuery.curCSS(elem, prop) ); return r & }; // Start an animation from
one number to another z.custom = function(from,to){ z.startTime = (new
Date()).getTime(); z.now = from; z.a(); jQuery.timers.push(function(){
return z.step(from, to); }); if ( jQuery.timers.length == 1 ) { var
timer = setInterval(function(){ var timers = jQuery.timers; for ( var
i = 0; i < timers.length; i++ ) if ( !timers[i]() ) timers.splice(i--,
1); if ( !timers.length ) clearInterval( timer ); }, 13); } }; //
Simple 'show' function z.show = function(){ if ( !elem.orig )
elem.orig = {}; // Remember where we started, so that we can go back
to it later elem.orig[prop] = jQuery.attr( elem.style, prop );
options.show = true; // Begin the animation z.custom(0, this.cur());
// Make sure that we start at a small width/height to avoid any //
flash of content if ( prop != "opacity" ) y[prop] = "1px"; // Start by
showing the element jQuery(elem).show(); }; // Simple 'hide' function
z.hide = function(){ if ( !elem.orig ) elem.orig = {}; // Remember
where we started, so that we can go back to it later elem.orig[prop] =
jQuery.attr( elem.style, prop ); options.hide = true; // Begin the
animation z.custom(this.cur(), 0); }; // Each step of an animation
z.step = function(firstNum, lastNum){ var t = (new Date()).getTime();
if (t > options.duration + z.startTime) { z.now = lastNum; z.a(); if
(elem.curAnim) elem.curAnim[ prop ] = true; var done = true; for ( var
i in elem.curAnim ) if ( elem.curAnim[i] !== true ) done = false; if (
done ) { if ( options.display != null ) { // Reset the overflow
y.overflow = options.overflow; // Reset the display y.display =
options.display; if ( jQuery.css(elem, "display") == "none" )
y.display = "block"; } // Hide the element if the "hide" operation was
done if ( options.hide ) y.display = "none"; // Reset the properties,
if the item has been hidden or shown if ( options.hide || options.show
) for ( var p in elem.curAnim ) jQuery.attr(y, p, elem.orig[p]); } //
If a callback was provided, execute it if ( done & return false; }
else { var n = t - this.startTime; // Figure out where in the
animation we are and set the number var p = n / options.duration; //
Perform the easing function, defaults to swing z.now =
jQuery.easing[options.easing](p, n, firstNum, (lastNum-firstNum),
options.duration); // Perform the next step of the animation z.a(); }
return true; }; } }); }
[1]
MEMBERS CLICK HERE TO LOG-IN [2]
