| /*! |
| * jQuery Color Animations v2.0pre |
| * http://jquery.org/ |
| * |
| * Copyright 2011 John Resig |
| * Dual licensed under the MIT or GPL Version 2 licenses. |
| * http://jquery.org/license |
| */ |
| |
| (function( jQuery, undefined ){ |
| var stepHooks = "backgroundColor borderBottomColor borderLeftColor borderRightColor borderTopColor color outlineColor".split(" "), |
| |
| // plusequals test for += 100 -= 100 |
| rplusequals = /^([\-+])=\s*(\d+\.?\d*)/, |
| // a set of RE's that can match strings and generate color tuples. |
| stringParsers = [{ |
| re: /rgba?\(\s*(\d{1,3})\s*,\s*(\d{1,3})\s*,\s*(\d{1,3})\s*(?:,\s*(\d+(?:\.\d+)?)\s*)?\)/, |
| parse: function( execResult ) { |
| return [ |
| execResult[ 1 ], |
| execResult[ 2 ], |
| execResult[ 3 ], |
| execResult[ 4 ] |
| ]; |
| } |
| }, { |
| re: /rgba?\(\s*(\d+(?:\.\d+)?)\%\s*,\s*(\d+(?:\.\d+)?)\%\s*,\s*(\d+(?:\.\d+)?)\%\s*(?:,\s*(\d+(?:\.\d+)?)\s*)?\)/, |
| parse: function( execResult ) { |
| return [ |
| 2.55 * execResult[1], |
| 2.55 * execResult[2], |
| 2.55 * execResult[3], |
| execResult[ 4 ] |
| ]; |
| } |
| }, { |
| re: /#([a-fA-F0-9]{2})([a-fA-F0-9]{2})([a-fA-F0-9]{2})/, |
| parse: function( execResult ) { |
| return [ |
| parseInt( execResult[ 1 ], 16 ), |
| parseInt( execResult[ 2 ], 16 ), |
| parseInt( execResult[ 3 ], 16 ) |
| ]; |
| } |
| }, { |
| re: /#([a-fA-F0-9])([a-fA-F0-9])([a-fA-F0-9])/, |
| parse: function( execResult ) { |
| return [ |
| parseInt( execResult[ 1 ] + execResult[ 1 ], 16 ), |
| parseInt( execResult[ 2 ] + execResult[ 2 ], 16 ), |
| parseInt( execResult[ 3 ] + execResult[ 3 ], 16 ) |
| ]; |
| } |
| }, { |
| re: /hsla?\(\s*(\d+(?:\.\d+)?)\s*,\s*(\d+(?:\.\d+)?)\%\s*,\s*(\d+(?:\.\d+)?)\%\s*(?:,\s*(\d+(?:\.\d+)?)\s*)?\)/, |
| space: "hsla", |
| parse: function( execResult ) { |
| return [ |
| execResult[1], |
| execResult[2] / 100, |
| execResult[3] / 100, |
| execResult[4] |
| ]; |
| } |
| }], |
| |
| // jQuery.Color( ) |
| color = jQuery.Color = function( color, green, blue, alpha ) { |
| return new jQuery.Color.fn.parse( color, green, blue, alpha ); |
| }, |
| spaces = { |
| rgba: { |
| cache: "_rgba", |
| props: { |
| red: { |
| idx: 0, |
| type: "byte", |
| empty: true |
| }, |
| green: { |
| idx: 1, |
| type: "byte", |
| empty: true |
| }, |
| blue: { |
| idx: 2, |
| type: "byte", |
| empty: true |
| }, |
| alpha: { |
| idx: 3, |
| type: "percent", |
| def: 1 |
| } |
| } |
| }, |
| hsla: { |
| cache: "_hsla", |
| props: { |
| hue: { |
| idx: 0, |
| type: "degrees", |
| empty: true |
| }, |
| saturation: { |
| idx: 1, |
| type: "percent", |
| empty: true |
| }, |
| lightness: { |
| idx: 2, |
| type: "percent", |
| empty: true |
| } |
| } |
| } |
| }, |
| propTypes = { |
| "byte": { |
| floor: true, |
| min: 0, |
| max: 255 |
| }, |
| "percent": { |
| min: 0, |
| max: 1 |
| }, |
| "degrees": { |
| mod: 360, |
| floor: true |
| } |
| }, |
| rgbaspace = spaces.rgba.props, |
| support = color.support = {}, |
| |
| // colors = jQuery.Color.names |
| colors, |
| |
| // local aliases of functions called often |
| each = jQuery.each; |
| |
| spaces.hsla.props.alpha = rgbaspace.alpha; |
| |
| function clamp( value, prop, alwaysAllowEmpty ) { |
| var type = propTypes[ prop.type ] || {}, |
| allowEmpty = prop.empty || alwaysAllowEmpty; |
| |
| if ( allowEmpty && value == null ) { |
| return null; |
| } |
| if ( prop.def && value == null ) { |
| return prop.def; |
| } |
| if ( type.floor ) { |
| value = ~~value; |
| } else { |
| value = parseFloat( value ); |
| } |
| if ( value == null || isNaN( value ) ) { |
| return prop.def; |
| } |
| if ( type.mod ) { |
| value = value % type.mod; |
| // -10 -> 350 |
| return value < 0 ? type.mod + value : value; |
| } |
| |
| // for now all property types without mod have min and max |
| return type.min > value ? type.min : type.max < value ? type.max : value; |
| } |
| |
| function stringParse( string ) { |
| var inst = color(), |
| rgba = inst._rgba = []; |
| |
| string = string.toLowerCase(); |
| |
| each( stringParsers, function( i, parser ) { |
| var match = parser.re.exec( string ), |
| values = match && parser.parse( match ), |
| parsed, |
| spaceName = parser.space || "rgba", |
| cache = spaces[ spaceName ].cache; |
| |
| |
| if ( values ) { |
| parsed = inst[ spaceName ]( values ); |
| |
| // if this was an rgba parse the assignment might happen twice |
| // oh well.... |
| inst[ cache ] = parsed[ cache ]; |
| rgba = inst._rgba = parsed._rgba; |
| |
| // exit each( stringParsers ) here because we matched |
| return false; |
| } |
| }); |
| |
| // Found a stringParser that handled it |
| if ( rgba.length !== 0 ) { |
| |
| // if this came from a parsed string, force "transparent" when alpha is 0 |
| // chrome, (and maybe others) return "transparent" as rgba(0,0,0,0) |
| if ( Math.max.apply( Math, rgba ) === 0 ) { |
| jQuery.extend( rgba, colors.transparent ); |
| } |
| return inst; |
| } |
| |
| // named colors / default - filter back through parse function |
| if ( string = colors[ string ] ) { |
| return string; |
| } |
| } |
| |
| color.fn = color.prototype = { |
| constructor: color, |
| parse: function( red, green, blue, alpha ) { |
| if ( red === undefined ) { |
| this._rgba = [ null, null, null, null ]; |
| return this; |
| } |
| if ( red instanceof jQuery || red.nodeType ) { |
| red = red instanceof jQuery ? red.css( green ) : jQuery( red ).css( green ); |
| green = undefined; |
| } |
| |
| var inst = this, |
| type = jQuery.type( red ), |
| rgba = this._rgba = [], |
| source; |
| |
| // more than 1 argument specified - assume ( red, green, blue, alpha ) |
| if ( green !== undefined ) { |
| red = [ red, green, blue, alpha ]; |
| type = "array"; |
| } |
| |
| if ( type === "string" ) { |
| return this.parse( stringParse( red ) || colors._default ); |
| } |
| |
| if ( type === "array" ) { |
| each( rgbaspace, function( key, prop ) { |
| rgba[ prop.idx ] = clamp( red[ prop.idx ], prop ); |
| }); |
| return this; |
| } |
| |
| if ( type === "object" ) { |
| if ( red instanceof color ) { |
| each( spaces, function( spaceName, space ) { |
| if ( red[ space.cache ] ) { |
| inst[ space.cache ] = red[ space.cache ].slice(); |
| } |
| }); |
| } else { |
| each( spaces, function( spaceName, space ) { |
| each( space.props, function( key, prop ) { |
| var cache = space.cache; |
| |
| // if the cache doesn't exist, and we know how to convert |
| if ( !inst[ cache ] && space.to ) { |
| |
| // if the value was null, we don't need to copy it |
| // if the key was alpha, we don't need to copy it either |
| if ( red[ key ] == null || key === "alpha") { |
| return; |
| } |
| inst[ cache ] = space.to( inst._rgba ); |
| } |
| |
| // this is the only case where we allow nulls for ALL properties. |
| // call clamp with alwaysAllowEmpty |
| inst[ cache ][ prop.idx ] = clamp( red[ key ], prop, true ); |
| }); |
| }); |
| } |
| return this; |
| } |
| }, |
| is: function( compare ) { |
| var is = color( compare ), |
| same = true, |
| myself = this; |
| |
| each( spaces, function( _, space ) { |
| var isCache = is[ space.cache ], |
| localCache; |
| if (isCache) { |
| localCache = myself[ space.cache ] || space.to && space.to( myself._rgba ) || []; |
| each( space.props, function( _, prop ) { |
| if ( isCache[ prop.idx ] != null ) { |
| same = ( isCache[ prop.idx ] === localCache[ prop.idx ] ); |
| return same; |
| } |
| }); |
| } |
| return same; |
| }); |
| return same; |
| }, |
| _space: function() { |
| var used = [], |
| inst = this; |
| each( spaces, function( spaceName, space ) { |
| if ( inst[ space.cache ] ) { |
| used.push( spaceName ); |
| } |
| }); |
| return used.pop(); |
| }, |
| transition: function( other, distance ) { |
| var end = color( other ), |
| spaceName = end._space(), |
| space = spaces[ spaceName ], |
| start = this[ space.cache ] || space.to( this._rgba ), |
| result = start.slice(); |
| |
| end = end[ space.cache ]; |
| each( space.props, function( key, prop ) { |
| var index = prop.idx, |
| startValue = start[ index ], |
| endValue = end[ index ], |
| type = propTypes[ prop.type ] || {}; |
| |
| // if null, don't override start value |
| if ( endValue === null ) { |
| return; |
| } |
| // if null - use end |
| if ( startValue === null ) { |
| result[ index ] = endValue; |
| } else { |
| if ( type.mod ) { |
| if ( endValue - startValue > type.mod / 2 ) { |
| startValue += type.mod; |
| } else if ( startValue - endValue > type.mod / 2 ) { |
| startValue -= type.mod; |
| } |
| } |
| result[ prop.idx ] = clamp( ( endValue - startValue ) * distance + startValue, prop ); |
| } |
| }); |
| return this[ spaceName ]( result ); |
| }, |
| blend: function( opaque ) { |
| // if we are already opaque - return ourself |
| if ( this._rgba[ 3 ] === 1 ) { |
| return this; |
| } |
| |
| var rgb = this._rgba.slice(), |
| a = rgb.pop(), |
| blend = color( opaque )._rgba; |
| |
| return color( jQuery.map( rgb, function( v, i ) { |
| return ( 1 - a ) * blend[ i ] + a * v; |
| })); |
| }, |
| toRgbaString: function() { |
| var prefix = "rgba(", |
| rgba = jQuery.map( this._rgba, function( v, i ) { |
| return v == null ? ( i > 2 ? 1 : 0 ) : v; |
| }); |
| |
| if ( rgba[ 3 ] === 1 ) { |
| rgba.pop(); |
| prefix = "rgb("; |
| } |
| |
| return prefix + rgba.join(",") + ")"; |
| }, |
| toHslaString: function() { |
| var prefix = "hsla(", |
| hsla = jQuery.map( this.hsla(), function( v, i ) { |
| if ( v == null ) { |
| v = i > 2 ? 1 : 0; |
| } |
| |
| // catch 1 and 2 |
| if ( i && i < 3 ) { |
| v = Math.round( v * 100 ) + "%"; |
| } |
| return v; |
| }); |
| |
| if ( hsla[ 3 ] === 1 ) { |
| hsla.pop(); |
| prefix = "hsl("; |
| } |
| return prefix + hsla.join(",") + ")"; |
| }, |
| toHexString: function( includeAlpha ) { |
| var rgba = this._rgba.slice(), |
| alpha = rgba.pop(); |
| |
| if ( includeAlpha ) { |
| rgba.push( ~~( alpha * 255 ) ); |
| } |
| |
| return "#" + jQuery.map( rgba, function( v, i ) { |
| |
| // default to 0 when nulls exist |
| v = ( v || 0 ).toString( 16 ); |
| return v.length === 1 ? "0" + v : v; |
| }).join(""); |
| }, |
| toString: function() { |
| return this._rgba[ 3 ] === 0 ? "transparent" : this.toRgbaString(); |
| } |
| }; |
| color.fn.parse.prototype = color.fn; |
| |
| // hsla conversions adapted from: |
| // http://www.google.com/codesearch/p#OAMlx_jo-ck/src/third_party/WebKit/Source/WebCore/inspector/front-end/Color.js&d=7&l=193 |
| |
| function hue2rgb( p, q, h ) { |
| h = ( h + 1 ) % 1; |
| if ( h * 6 < 1 ) { |
| return p + (q - p) * 6 * h; |
| } |
| if ( h * 2 < 1) { |
| return q; |
| } |
| if ( h * 3 < 2 ) { |
| return p + (q - p) * ((2/3) - h) * 6; |
| } |
| return p; |
| } |
| |
| spaces.hsla.to = function ( rgba ) { |
| if ( rgba[ 0 ] == null || rgba[ 1 ] == null || rgba[ 2 ] == null ) { |
| return [ null, null, null, rgba[ 3 ] ]; |
| } |
| var r = rgba[ 0 ] / 255, |
| g = rgba[ 1 ] / 255, |
| b = rgba[ 2 ] / 255, |
| a = rgba[ 3 ], |
| max = Math.max( r, g, b ), |
| min = Math.min( r, g, b ), |
| diff = max - min, |
| add = max + min, |
| l = add * 0.5, |
| h, s; |
| |
| if ( min === max ) { |
| h = 0; |
| } else if ( r === max ) { |
| h = ( 60 * ( g - b ) / diff ) + 360; |
| } else if ( g === max ) { |
| h = ( 60 * ( b - r ) / diff ) + 120; |
| } else { |
| h = ( 60 * ( r - g ) / diff ) + 240; |
| } |
| |
| if ( l === 0 || l === 1 ) { |
| s = l; |
| } else if ( l <= 0.5 ) { |
| s = diff / add; |
| } else { |
| s = diff / ( 2 - add ); |
| } |
| return [ Math.round(h) % 360, s, l, a == null ? 1 : a ]; |
| }; |
| |
| spaces.hsla.from = function ( hsla ) { |
| if ( hsla[ 0 ] == null || hsla[ 1 ] == null || hsla[ 2 ] == null ) { |
| return [ null, null, null, hsla[ 3 ] ]; |
| } |
| var h = hsla[ 0 ] / 360, |
| s = hsla[ 1 ], |
| l = hsla[ 2 ], |
| a = hsla[ 3 ], |
| q = l <= 0.5 ? l * ( 1 + s ) : l + s - l * s, |
| p = 2 * l - q, |
| r, g, b; |
| |
| return [ |
| Math.round( hue2rgb( p, q, h + ( 1 / 3 ) ) * 255 ), |
| Math.round( hue2rgb( p, q, h ) * 255 ), |
| Math.round( hue2rgb( p, q, h - ( 1 / 3 ) ) * 255 ), |
| a |
| ]; |
| }; |
| |
| |
| each( spaces, function( spaceName, space ) { |
| var props = space.props, |
| cache = space.cache, |
| to = space.to, |
| from = space.from; |
| |
| // makes rgba() and hsla() |
| color.fn[ spaceName ] = function( value ) { |
| |
| // generate a cache for this space if it doesn't exist |
| if ( to && !this[ cache ] ) { |
| this[ cache ] = to( this._rgba ); |
| } |
| if ( value === undefined ) { |
| return this[ cache ].slice(); |
| } |
| |
| var type = jQuery.type( value ), |
| arr = ( type === "array" || type === "object" ) ? value : arguments, |
| local = this[ cache ].slice(), |
| ret; |
| |
| each( props, function( key, prop ) { |
| var val = arr[ type === "object" ? key : prop.idx ]; |
| if ( val == null ) { |
| val = local[ prop.idx ]; |
| } |
| local[ prop.idx ] = clamp( val, prop ); |
| }); |
| |
| if ( from ) { |
| ret = color( from( local ) ); |
| ret[ cache ] = local; |
| return ret; |
| } else { |
| return color( local ); |
| } |
| }; |
| |
| // makes red() green() blue() alpha() hue() saturation() lightness() |
| each( props, function( key, prop ) { |
| // alpha is included in more than one space |
| if ( color.fn[ key ] ) { |
| return; |
| } |
| color.fn[ key ] = function( value ) { |
| var vtype = jQuery.type( value ), |
| fn = ( key === 'alpha' ? ( this._hsla ? 'hsla' : 'rgba' ) : spaceName ), |
| local = this[ fn ](), |
| cur = local[ prop.idx ], |
| match; |
| |
| if ( vtype === "undefined" ) { |
| return cur; |
| } |
| |
| if ( vtype === "function" ) { |
| value = value.call( this, cur ); |
| vtype = jQuery.type( value ); |
| } |
| if ( value == null && prop.empty ) { |
| return this; |
| } |
| if ( vtype === "string" ) { |
| match = rplusequals.exec( value ); |
| if ( match ) { |
| value = cur + parseFloat( match[ 2 ] ) * ( match[ 1 ] === "+" ? 1 : -1 ); |
| } |
| } |
| local[ prop.idx ] = value; |
| return this[ fn ]( local ); |
| }; |
| }); |
| }); |
| |
| // add .fx.step functions |
| each( stepHooks, function( i, hook ) { |
| jQuery.cssHooks[ hook ] = { |
| set: function( elem, value ) { |
| var parsed, backgroundColor, curElem; |
| |
| if ( jQuery.type( value ) !== 'string' || ( parsed = stringParse( value ) ) ) |
| { |
| value = color( parsed || value ); |
| if ( !support.rgba && value._rgba[ 3 ] !== 1 ) { |
| curElem = hook === "backgroundColor" ? elem.parentNode : elem; |
| do { |
| backgroundColor = jQuery.curCSS( curElem, "backgroundColor" ); |
| } while ( |
| ( backgroundColor === "" || backgroundColor === "transparent" ) && |
| ( curElem = curElem.parentNode ) && |
| curElem.style |
| ); |
| |
| value = value.blend( backgroundColor && backgroundColor !== "transparent" ? |
| backgroundColor : |
| "_default" ); |
| } |
| |
| value = value.toRgbaString(); |
| } |
| elem.style[ hook ] = value; |
| } |
| }; |
| jQuery.fx.step[ hook ] = function( fx ) { |
| if ( !fx.colorInit ) { |
| fx.start = color( fx.elem, hook ); |
| fx.end = color( fx.end ); |
| fx.colorInit = true; |
| } |
| jQuery.cssHooks[ hook ].set( fx.elem, fx.start.transition( fx.end, fx.pos ) ); |
| }; |
| }); |
| |
| // detect rgba support |
| jQuery(function() { |
| var div = document.createElement( "div" ), |
| div_style = div.style; |
| |
| div_style.cssText = "background-color:rgba(1,1,1,.5)"; |
| support.rgba = div_style.backgroundColor.indexOf( "rgba" ) > -1; |
| }); |
| |
| // Some named colors to work with |
| // From Interface by Stefan Petre |
| // http://interface.eyecon.ro/ |
| colors = jQuery.Color.names = { |
| aqua: "#00ffff", |
| azure: "#f0ffff", |
| beige: "#f5f5dc", |
| black: "#000000", |
| blue: "#0000ff", |
| brown: "#a52a2a", |
| cyan: "#00ffff", |
| darkblue: "#00008b", |
| darkcyan: "#008b8b", |
| darkgrey: "#a9a9a9", |
| darkgreen: "#006400", |
| darkkhaki: "#bdb76b", |
| darkmagenta: "#8b008b", |
| darkolivegreen: "#556b2f", |
| darkorange: "#ff8c00", |
| darkorchid: "#9932cc", |
| darkred: "#8b0000", |
| darksalmon: "#e9967a", |
| darkviolet: "#9400d3", |
| fuchsia: "#ff00ff", |
| gold: "#ffd700", |
| green: "#008000", |
| indigo: "#4b0082", |
| khaki: "#f0e68c", |
| lightblue: "#add8e6", |
| lightcyan: "#e0ffff", |
| lightgreen: "#90ee90", |
| lightgrey: "#d3d3d3", |
| lightpink: "#ffb6c1", |
| lightyellow: "#ffffe0", |
| lime: "#00ff00", |
| magenta: "#ff00ff", |
| maroon: "#800000", |
| navy: "#000080", |
| olive: "#808000", |
| orange: "#ffa500", |
| pink: "#ffc0cb", |
| purple: "#800080", |
| violet: "#800080", |
| red: "#ff0000", |
| silver: "#c0c0c0", |
| white: "#ffffff", |
| yellow: "#ffff00", |
| transparent: [ null, null, null, 0 ], |
| _default: "#ffffff" |
| }; |
| })( jQuery ); |