third-party/jquery-ui-1.10.2/ui/jquery.ui.effect.js

   1 /*!
   2  * jQuery UI Effects 1.10.2
   3  * http://jqueryui.com
   4  *
   5  * Copyright 2013 jQuery Foundation and other contributors
   6  * Released under the MIT license.
   7  * http://jquery.org/license
   8  *
   9  * http://api.jqueryui.com/category/effects-core/
  10  */
  11 (function($, undefined) {
  12
  13 var dataSpace = "ui-effects-";
  14
  15 $.effects = {
  16         effect: {}
  17 };
  18
  19 /*!
  20  * jQuery Color Animations v2.1.2
  21  * https://github.com/jquery/jquery-color
  22  *
  23  * Copyright 2013 jQuery Foundation and other contributors
  24  * Released under the MIT license.
  25  * http://jquery.org/license
  26  *
  27  * Date: Wed Jan 16 08:47:09 2013 -0600
  28  */
  29 (function( jQuery, undefined ) {
  30
  31         var stepHooks = "backgroundColor borderBottomColor borderLeftColor borderRightColor borderTopColor color columnRuleColor outlineColor textDecorationColor textEmphasisColor",
  32
  33         // plusequals test for += 100 -= 100
  34         rplusequals = /^([\-+])=\s*(\d+\.?\d*)/,
  35         // a set of RE's that can match strings and generate color tuples.
  36         stringParsers = [{
  37                         re: /rgba?\(\s*(\d{1,3})\s*,\s*(\d{1,3})\s*,\s*(\d{1,3})\s*(?:,\s*(\d?(?:\.\d+)?)\s*)?\)/,
  38                         parse: function( execResult ) {
  39                                 return [
  40                                         execResult[ 1 ],
  41                                         execResult[ 2 ],
  42                                         execResult[ 3 ],
  43                                         execResult[ 4 ]
  44                                 ];
  45                         }
  46                 }, {
  47                         re: /rgba?\(\s*(\d+(?:\.\d+)?)\%\s*,\s*(\d+(?:\.\d+)?)\%\s*,\s*(\d+(?:\.\d+)?)\%\s*(?:,\s*(\d?(?:\.\d+)?)\s*)?\)/,
  48                         parse: function( execResult ) {
  49                                 return [
  50                                         execResult[ 1 ] * 2.55,
  51                                         execResult[ 2 ] * 2.55,
  52                                         execResult[ 3 ] * 2.55,
  53                                         execResult[ 4 ]
  54                                 ];
  55                         }
  56                 }, {
  57                         // this regex ignores A-F because it's compared against an already lowercased string
  58                         re: /#([a-f0-9]{2})([a-f0-9]{2})([a-f0-9]{2})/,
  59                         parse: function( execResult ) {
  60                                 return [
  61                                         parseInt( execResult[ 1 ], 16 ),
  62                                         parseInt( execResult[ 2 ], 16 ),
  63                                         parseInt( execResult[ 3 ], 16 )
  64                                 ];
  65                         }
  66                 }, {
  67                         // this regex ignores A-F because it's compared against an already lowercased string
  68                         re: /#([a-f0-9])([a-f0-9])([a-f0-9])/,
  69                         parse: function( execResult ) {
  70                                 return [
  71                                         parseInt( execResult[ 1 ] + execResult[ 1 ], 16 ),
  72                                         parseInt( execResult[ 2 ] + execResult[ 2 ], 16 ),
  73                                         parseInt( execResult[ 3 ] + execResult[ 3 ], 16 )
  74                                 ];
  75                         }
  76                 }, {
  77                         re: /hsla?\(\s*(\d+(?:\.\d+)?)\s*,\s*(\d+(?:\.\d+)?)\%\s*,\s*(\d+(?:\.\d+)?)\%\s*(?:,\s*(\d?(?:\.\d+)?)\s*)?\)/,
  78                         space: "hsla",
  79                         parse: function( execResult ) {
  80                                 return [
  81                                         execResult[ 1 ],
  82                                         execResult[ 2 ] / 100,
  83                                         execResult[ 3 ] / 100,
  84                                         execResult[ 4 ]
  85                                 ];
  86                         }
  87                 }],
  88
  89         // jQuery.Color( )
  90         color = jQuery.Color = function( color, green, blue, alpha ) {
  91                 return new jQuery.Color.fn.parse( color, green, blue, alpha );
  92         },
  93         spaces = {
  94                 rgba: {
  95                         props: {
  96                                 red: {
  97                                         idx: 0,
  98                                         type: "byte"
  99                                 },
 100                                 green: {
 101                                         idx: 1,
 102                                         type: "byte"
 103                                 },
 104                                 blue: {
 105                                         idx: 2,
 106                                         type: "byte"
 107                                 }
 108                         }
 109                 },
 110
 111                 hsla: {
 112                         props: {
 113                                 hue: {
 114                                         idx: 0,
 115                                         type: "degrees"
 116                                 },
 117                                 saturation: {
 118                                         idx: 1,
 119                                         type: "percent"
 120                                 },
 121                                 lightness: {
 122                                         idx: 2,
 123                                         type: "percent"
 124                                 }
 125                         }
 126                 }
 127         },
 128         propTypes = {
 129                 "byte": {
 130                         floor: true,
 131                         max: 255
 132                 },
 133                 "percent": {
 134                         max: 1
 135                 },
 136                 "degrees": {
 137                         mod: 360,
 138                         floor: true
 139                 }
 140         },
 141         support = color.support = {},
 142
 143         // element for support tests
 144         supportElem = jQuery( "<p>" )[ 0 ],
 145
 146         // colors = jQuery.Color.names
 147         colors,
 148
 149         // local aliases of functions called often
 150         each = jQuery.each;
 151
 152 // determine rgba support immediately
 153 supportElem.style.cssText = "background-color:rgba(1,1,1,.5)";
 154 support.rgba = supportElem.style.backgroundColor.indexOf( "rgba" ) > -1;
 155
 156 // define cache name and alpha properties
 157 // for rgba and hsla spaces
 158 each( spaces, function( spaceName, space ) {
 159         space.cache = "_" + spaceName;
 160         space.props.alpha = {
 161                 idx: 3,
 162                 type: "percent",
 163                 def: 1
 164         };
 165 });
 166
 167 function clamp( value, prop, allowEmpty ) {
 168         var type = propTypes[ prop.type ] || {};
 169
 170         if ( value == null ) {
 171                 return (allowEmpty || !prop.def) ? null : prop.def;
 172         }
 173
 174         // ~~ is an short way of doing floor for positive numbers
 175         value = type.floor ? ~~value : parseFloat( value );
 176
 177         // IE will pass in empty strings as value for alpha,
 178         // which will hit this case
 179         if ( isNaN( value ) ) {
 180                 return prop.def;
 181         }
 182
 183         if ( type.mod ) {
 184                 // we add mod before modding to make sure that negatives values
 185                 // get converted properly: -10 -> 350
 186                 return (value + type.mod) % type.mod;
 187         }
 188
 189         // for now all property types without mod have min and max
 190         return 0 > value ? 0 : type.max < value ? type.max : value;
 191 }
 192
 193 function stringParse( string ) {
 194         var inst = color(),
 195                 rgba = inst._rgba = [];
 196
 197         string = string.toLowerCase();
 198
 199         each( stringParsers, function( i, parser ) {
 200                 var parsed,
 201                         match = parser.re.exec( string ),
 202                         values = match && parser.parse( match ),
 203                         spaceName = parser.space || "rgba";
 204
 205                 if ( values ) {
 206                         parsed = inst[ spaceName ]( values );
 207
 208                         // if this was an rgba parse the assignment might happen twice
 209                         // oh well....
 210                         inst[ spaces[ spaceName ].cache ] = parsed[ spaces[ spaceName ].cache ];
 211                         rgba = inst._rgba = parsed._rgba;
 212
 213                         // exit each( stringParsers ) here because we matched
 214                         return false;
 215                 }
 216         });
 217
 218         // Found a stringParser that handled it
 219         if ( rgba.length ) {
 220
 221                 // if this came from a parsed string, force "transparent" when alpha is 0
 222                 // chrome, (and maybe others) return "transparent" as rgba(0,0,0,0)
 223                 if ( rgba.join() === "0,0,0,0" ) {
 224                         jQuery.extend( rgba, colors.transparent );
 225                 }
 226                 return inst;
 227         }
 228
 229         // named colors
 230         return colors[ string ];
 231 }
 232
 233 color.fn = jQuery.extend( color.prototype, {
 234         parse: function( red, green, blue, alpha ) {
 235                 if ( red === undefined ) {
 236                         this._rgba = [ null, null, null, null ];
 237                         return this;
 238                 }
 239                 if ( red.jquery || red.nodeType ) {
 240                         red = jQuery( red ).css( green );
 241                         green = undefined;
 242                 }
 243
 244                 var inst = this,
 245                         type = jQuery.type( red ),
 246                         rgba = this._rgba = [];
 247
 248                 // more than 1 argument specified - assume ( red, green, blue, alpha )
 249                 if ( green !== undefined ) {
 250                         red = [ red, green, blue, alpha ];
 251                         type = "array";
 252                 }
 253
 254                 if ( type === "string" ) {
 255                         return this.parse( stringParse( red ) || colors._default );
 256                 }
 257
 258                 if ( type === "array" ) {
 259                         each( spaces.rgba.props, function( key, prop ) {
 260                                 rgba[ prop.idx ] = clamp( red[ prop.idx ], prop );
 261                         });
 262                         return this;
 263                 }
 264
 265                 if ( type === "object" ) {
 266                         if ( red instanceof color ) {
 267                                 each( spaces, function( spaceName, space ) {
 268                                         if ( red[ space.cache ] ) {
 269                                                 inst[ space.cache ] = red[ space.cache ].slice();
 270                                         }
 271                                 });
 272                         } else {
 273                                 each( spaces, function( spaceName, space ) {
 274                                         var cache = space.cache;
 275                                         each( space.props, function( key, prop ) {
 276
 277                                                 // if the cache doesn't exist, and we know how to convert
 278                                                 if ( !inst[ cache ] && space.to ) {
 279
 280                                                         // if the value was null, we don't need to copy it
 281                                                         // if the key was alpha, we don't need to copy it either
 282                                                         if ( key === "alpha" || red[ key ] == null ) {
 283                                                                 return;
 284                                                         }
 285                                                         inst[ cache ] = space.to( inst._rgba );
 286                                                 }
 287
 288                                                 // this is the only case where we allow nulls for ALL properties.
 289                                                 // call clamp with alwaysAllowEmpty
 290                                                 inst[ cache ][ prop.idx ] = clamp( red[ key ], prop, true );
 291                                         });
 292
 293                                         // everything defined but alpha?
 294                                         if ( inst[ cache ] && jQuery.inArray( null, inst[ cache ].slice( 0, 3 ) ) < 0 ) {
 295                                                 // use the default of 1
 296                                                 inst[ cache ][ 3 ] = 1;
 297                                                 if ( space.from ) {
 298                                                         inst._rgba = space.from( inst[ cache ] );
 299                                                 }
 300                                         }
 301                                 });
 302                         }
 303                         return this;
 304                 }
 305         },
 306         is: function( compare ) {
 307                 var is = color( compare ),
 308                         same = true,
 309                         inst = this;
 310
 311                 each( spaces, function( _, space ) {
 312                         var localCache,
 313                                 isCache = is[ space.cache ];
 314                         if (isCache) {
 315                                 localCache = inst[ space.cache ] || space.to && space.to( inst._rgba ) || [];
 316                                 each( space.props, function( _, prop ) {
 317                                         if ( isCache[ prop.idx ] != null ) {
 318                                                 same = ( isCache[ prop.idx ] === localCache[ prop.idx ] );
 319                                                 return same;
 320                                         }
 321                                 });
 322                         }
 323                         return same;
 324                 });
 325                 return same;
 326         },
 327         _space: function() {
 328                 var used = [],
 329                         inst = this;
 330                 each( spaces, function( spaceName, space ) {
 331                         if ( inst[ space.cache ] ) {
 332                                 used.push( spaceName );
 333                         }
 334                 });
 335                 return used.pop();
 336         },
 337         transition: function( other, distance ) {
 338                 var end = color( other ),
 339                         spaceName = end._space(),
 340                         space = spaces[ spaceName ],
 341                         startColor = this.alpha() === 0 ? color( "transparent" ) : this,
 342                         start = startColor[ space.cache ] || space.to( startColor._rgba ),
 343                         result = start.slice();
 344
 345                 end = end[ space.cache ];
 346                 each( space.props, function( key, prop ) {
 347                         var index = prop.idx,
 348                                 startValue = start[ index ],
 349                                 endValue = end[ index ],
 350                                 type = propTypes[ prop.type ] || {};
 351
 352                         // if null, don't override start value
 353                         if ( endValue === null ) {
 354                                 return;
 355                         }
 356                         // if null - use end
 357                         if ( startValue === null ) {
 358                                 result[ index ] = endValue;
 359                         } else {
 360                                 if ( type.mod ) {
 361                                         if ( endValue - startValue > type.mod / 2 ) {
 362                                                 startValue += type.mod;
 363                                         } else if ( startValue - endValue > type.mod / 2 ) {
 364                                                 startValue -= type.mod;
 365                                         }
 366                                 }
 367                                 result[ index ] = clamp( ( endValue - startValue ) * distance + startValue, prop );
 368                         }
 369                 });
 370                 return this[ spaceName ]( result );
 371         },
 372         blend: function( opaque ) {
 373                 // if we are already opaque - return ourself
 374                 if ( this._rgba[ 3 ] === 1 ) {
 375                         return this;
 376                 }
 377
 378                 var rgb = this._rgba.slice(),
 379                         a = rgb.pop(),
 380                         blend = color( opaque )._rgba;
 381
 382                 return color( jQuery.map( rgb, function( v, i ) {
 383                         return ( 1 - a ) * blend[ i ] + a * v;
 384                 }));
 385         },
 386         toRgbaString: function() {
 387                 var prefix = "rgba(",
 388                         rgba = jQuery.map( this._rgba, function( v, i ) {
 389                                 return v == null ? ( i > 2 ? 1 : 0 ) : v;
 390                         });
 391
 392                 if ( rgba[ 3 ] === 1 ) {
 393                         rgba.pop();
 394                         prefix = "rgb(";
 395                 }
 396
 397                 return prefix + rgba.join() + ")";
 398         },
 399         toHslaString: function() {
 400                 var prefix = "hsla(",
 401                         hsla = jQuery.map( this.hsla(), function( v, i ) {
 402                                 if ( v == null ) {
 403                                         v = i > 2 ? 1 : 0;
 404                                 }
 405
 406                                 // catch 1 and 2
 407                                 if ( i && i < 3 ) {
 408                                         v = Math.round( v * 100 ) + "%";
 409                                 }
 410                                 return v;
 411                         });
 412
 413                 if ( hsla[ 3 ] === 1 ) {
 414                         hsla.pop();
 415                         prefix = "hsl(";
 416                 }
 417                 return prefix + hsla.join() + ")";
 418         },
 419         toHexString: function( includeAlpha ) {
 420                 var rgba = this._rgba.slice(),
 421                         alpha = rgba.pop();
 422
 423                 if ( includeAlpha ) {
 424                         rgba.push( ~~( alpha * 255 ) );
 425                 }
 426
 427                 return "#" + jQuery.map( rgba, function( v ) {
 428
 429                         // default to 0 when nulls exist
 430                         v = ( v || 0 ).toString( 16 );
 431                         return v.length === 1 ? "0" + v : v;
 432                 }).join("");
 433         },
 434         toString: function() {
 435                 return this._rgba[ 3 ] === 0 ? "transparent" : this.toRgbaString();
 436         }
 437 });
 438 color.fn.parse.prototype = color.fn;
 439
 440 // hsla conversions adapted from:
 441 // https://code.google.com/p/maashaack/source/browse/packages/graphics/trunk/src/graphics/colors/HUE2RGB.as?r=5021
 442
 443 function hue2rgb( p, q, h ) {
 444         h = ( h + 1 ) % 1;
 445         if ( h * 6 < 1 ) {
 446                 return p + (q - p) * h * 6;
 447         }
 448         if ( h * 2 < 1) {
 449                 return q;
 450         }
 451         if ( h * 3 < 2 ) {
 452                 return p + (q - p) * ((2/3) - h) * 6;
 453         }
 454         return p;
 455 }
 456
 457 spaces.hsla.to = function ( rgba ) {
 458         if ( rgba[ 0 ] == null || rgba[ 1 ] == null || rgba[ 2 ] == null ) {
 459                 return [ null, null, null, rgba[ 3 ] ];
 460         }
 461         var r = rgba[ 0 ] / 255,
 462                 g = rgba[ 1 ] / 255,
 463                 b = rgba[ 2 ] / 255,
 464                 a = rgba[ 3 ],
 465                 max = Math.max( r, g, b ),
 466                 min = Math.min( r, g, b ),
 467                 diff = max - min,
 468                 add = max + min,
 469                 l = add * 0.5,
 470                 h, s;
 471
 472         if ( min === max ) {
 473                 h = 0;
 474         } else if ( r === max ) {
 475                 h = ( 60 * ( g - b ) / diff ) + 360;
 476         } else if ( g === max ) {
 477                 h = ( 60 * ( b - r ) / diff ) + 120;
 478         } else {
 479                 h = ( 60 * ( r - g ) / diff ) + 240;
 480         }
 481
 482         // chroma (diff) == 0 means greyscale which, by definition, saturation = 0%
 483         // otherwise, saturation is based on the ratio of chroma (diff) to lightness (add)
 484         if ( diff === 0 ) {
 485                 s = 0;
 486         } else if ( l <= 0.5 ) {
 487                 s = diff / add;
 488         } else {
 489                 s = diff / ( 2 - add );
 490         }
 491         return [ Math.round(h) % 360, s, l, a == null ? 1 : a ];
 492 };
 493
 494 spaces.hsla.from = function ( hsla ) {
 495         if ( hsla[ 0 ] == null || hsla[ 1 ] == null || hsla[ 2 ] == null ) {
 496                 return [ null, null, null, hsla[ 3 ] ];
 497         }
 498         var h = hsla[ 0 ] / 360,
 499                 s = hsla[ 1 ],
 500                 l = hsla[ 2 ],
 501                 a = hsla[ 3 ],
 502                 q = l <= 0.5 ? l * ( 1 + s ) : l + s - l * s,
 503                 p = 2 * l - q;
 504
 505         return [
 506                 Math.round( hue2rgb( p, q, h + ( 1 / 3 ) ) * 255 ),
 507                 Math.round( hue2rgb( p, q, h ) * 255 ),
 508                 Math.round( hue2rgb( p, q, h - ( 1 / 3 ) ) * 255 ),
 509                 a
 510         ];
 511 };
 512
 513
 514 each( spaces, function( spaceName, space ) {
 515         var props = space.props,
 516                 cache = space.cache,
 517                 to = space.to,
 518                 from = space.from;
 519
 520         // makes rgba() and hsla()
 521         color.fn[ spaceName ] = function( value ) {
 522
 523                 // generate a cache for this space if it doesn't exist
 524                 if ( to && !this[ cache ] ) {
 525                         this[ cache ] = to( this._rgba );
 526                 }
 527                 if ( value === undefined ) {
 528                         return this[ cache ].slice();
 529                 }
 530
 531                 var ret,
 532                         type = jQuery.type( value ),
 533                         arr = ( type === "array" || type === "object" ) ? value : arguments,
 534                         local = this[ cache ].slice();
 535
 536                 each( props, function( key, prop ) {
 537                         var val = arr[ type === "object" ? key : prop.idx ];
 538                         if ( val == null ) {
 539                                 val = local[ prop.idx ];
 540                         }
 541                         local[ prop.idx ] = clamp( val, prop );
 542                 });
 543
 544                 if ( from ) {
 545                         ret = color( from( local ) );
 546                         ret[ cache ] = local;
 547                         return ret;
 548                 } else {
 549                         return color( local );
 550                 }
 551         };
 552
 553         // makes red() green() blue() alpha() hue() saturation() lightness()
 554         each( props, function( key, prop ) {
 555                 // alpha is included in more than one space
 556                 if ( color.fn[ key ] ) {
 557                         return;
 558                 }
 559                 color.fn[ key ] = function( value ) {
 560                         var vtype = jQuery.type( value ),
 561                                 fn = ( key === "alpha" ? ( this._hsla ? "hsla" : "rgba" ) : spaceName ),
 562                                 local = this[ fn ](),
 563                                 cur = local[ prop.idx ],
 564                                 match;
 565
 566                         if ( vtype === "undefined" ) {
 567                                 return cur;
 568                         }
 569
 570                         if ( vtype === "function" ) {
 571                                 value = value.call( this, cur );
 572                                 vtype = jQuery.type( value );
 573                         }
 574                         if ( value == null && prop.empty ) {
 575                                 return this;
 576                         }
 577                         if ( vtype === "string" ) {
 578                                 match = rplusequals.exec( value );
 579                                 if ( match ) {
 580                                         value = cur + parseFloat( match[ 2 ] ) * ( match[ 1 ] === "+" ? 1 : -1 );
 581                                 }
 582                         }
 583                         local[ prop.idx ] = value;
 584                         return this[ fn ]( local );
 585                 };
 586         });
 587 });
 588
 589 // add cssHook and .fx.step function for each named hook.
 590 // accept a space separated string of properties
 591 color.hook = function( hook ) {
 592         var hooks = hook.split( " " );
 593         each( hooks, function( i, hook ) {
 594                 jQuery.cssHooks[ hook ] = {
 595                         set: function( elem, value ) {
 596                                 var parsed, curElem,
 597                                         backgroundColor = "";
 598
 599                                 if ( value !== "transparent" && ( jQuery.type( value ) !== "string" || ( parsed = stringParse( value ) ) ) ) {
 600                                         value = color( parsed || value );
 601                                         if ( !support.rgba && value._rgba[ 3 ] !== 1 ) {
 602                                                 curElem = hook === "backgroundColor" ? elem.parentNode : elem;
 603                                                 while (
 604                                                         (backgroundColor === "" || backgroundColor === "transparent") &&
 605                                                         curElem && curElem.style
 606                                                 ) {
 607                                                         try {
 608                                                                 backgroundColor = jQuery.css( curElem, "backgroundColor" );
 609                                                                 curElem = curElem.parentNode;
 610                                                         } catch ( e ) {
 611                                                         }
 612                                                 }
 613
 614                                                 value = value.blend( backgroundColor && backgroundColor !== "transparent" ?
 615                                                         backgroundColor :
 616                                                         "_default" );
 617                                         }
 618
 619                                         value = value.toRgbaString();
 620                                 }
 621                                 try {
 622                                         elem.style[ hook ] = value;
 623                                 } catch( e ) {
 624                                         // wrapped to prevent IE from throwing errors on "invalid" values like 'auto' or 'inherit'
 625                                 }
 626                         }
 627                 };
 628                 jQuery.fx.step[ hook ] = function( fx ) {
 629                         if ( !fx.colorInit ) {
 630                                 fx.start = color( fx.elem, hook );
 631                                 fx.end = color( fx.end );
 632                                 fx.colorInit = true;
 633                         }
 634                         jQuery.cssHooks[ hook ].set( fx.elem, fx.start.transition( fx.end, fx.pos ) );
 635                 };
 636         });
 637
 638 };
 639
 640 color.hook( stepHooks );
 641
 642 jQuery.cssHooks.borderColor = {
 643         expand: function( value ) {
 644                 var expanded = {};
 645
 646                 each( [ "Top", "Right", "Bottom", "Left" ], function( i, part ) {
 647                         expanded[ "border" + part + "Color" ] = value;
 648                 });
 649                 return expanded;
 650         }
 651 };
 652
 653 // Basic color names only.
 654 // Usage of any of the other color names requires adding yourself or including
 655 // jquery.color.svg-names.js.
 656 colors = jQuery.Color.names = {
 657         // 4.1. Basic color keywords
 658         aqua: "#00ffff",
 659         black: "#000000",
 660         blue: "#0000ff",
 661         fuchsia: "#ff00ff",
 662         gray: "#808080",
 663         green: "#008000",
 664         lime: "#00ff00",
 665         maroon: "#800000",
 666         navy: "#000080",
 667         olive: "#808000",
 668         purple: "#800080",
 669         red: "#ff0000",
 670         silver: "#c0c0c0",
 671         teal: "#008080",
 672         white: "#ffffff",
 673         yellow: "#ffff00",
 674
 675         // 4.2.3. "transparent" color keyword
 676         transparent: [ null, null, null, 0 ],
 677
 678         _default: "#ffffff"
 679 };
 680
 681 })( jQuery );
 682
 683
 684 /******************************************************************************/
 685 /****************************** CLASS ANIMATIONS ******************************/
 686 /******************************************************************************/
 687 (function() {
 688
 689 var classAnimationActions = [ "add", "remove", "toggle" ],
 690         shorthandStyles = {
 691                 border: 1,
 692                 borderBottom: 1,
 693                 borderColor: 1,
 694                 borderLeft: 1,
 695                 borderRight: 1,
 696                 borderTop: 1,
 697                 borderWidth: 1,
 698                 margin: 1,
 699                 padding: 1
 700         };
 701
 702 $.each([ "borderLeftStyle", "borderRightStyle", "borderBottomStyle", "borderTopStyle" ], function( _, prop ) {
 703         $.fx.step[ prop ] = function( fx ) {
 704                 if ( fx.end !== "none" && !fx.setAttr || fx.pos === 1 && !fx.setAttr ) {
 705                         jQuery.style( fx.elem, prop, fx.end );
 706                         fx.setAttr = true;
 707                 }
 708         };
 709 });
 710
 711 function getElementStyles( elem ) {
 712         var key, len,
 713                 style = elem.ownerDocument.defaultView ?
 714                         elem.ownerDocument.defaultView.getComputedStyle( elem, null ) :
 715                         elem.currentStyle,
 716                 styles = {};
 717
 718         if ( style && style.length && style[ 0 ] && style[ style[ 0 ] ] ) {
 719                 len = style.length;
 720                 while ( len-- ) {
 721                         key = style[ len ];
 722                         if ( typeof style[ key ] === "string" ) {
 723                                 styles[ $.camelCase( key ) ] = style[ key ];
 724                         }
 725                 }
 726         // support: Opera, IE <9
 727         } else {
 728                 for ( key in style ) {
 729                         if ( typeof style[ key ] === "string" ) {
 730                                 styles[ key ] = style[ key ];
 731                         }
 732                 }
 733         }
 734
 735         return styles;
 736 }
 737
 738
 739 function styleDifference( oldStyle, newStyle ) {
 740         var diff = {},
 741                 name, value;
 742
 743         for ( name in newStyle ) {
 744                 value = newStyle[ name ];
 745                 if ( oldStyle[ name ] !== value ) {
 746                         if ( !shorthandStyles[ name ] ) {
 747                                 if ( $.fx.step[ name ] || !isNaN( parseFloat( value ) ) ) {
 748                                         diff[ name ] = value;
 749                                 }
 750                         }
 751                 }
 752         }
 753
 754         return diff;
 755 }
 756
 757 // support: jQuery <1.8
 758 if ( !$.fn.addBack ) {
 759         $.fn.addBack = function( selector ) {
 760                 return this.add( selector == null ?
 761                         this.prevObject : this.prevObject.filter( selector )
 762                 );
 763         };
 764 }
 765
 766 $.effects.animateClass = function( value, duration, easing, callback ) {
 767         var o = $.speed( duration, easing, callback );
 768
 769         return this.queue( function() {
 770                 var animated = $( this ),
 771                         baseClass = animated.attr( "class" ) || "",
 772                         applyClassChange,
 773                         allAnimations = o.children ? animated.find( "*" ).addBack() : animated;
 774
 775                 // map the animated objects to store the original styles.
 776                 allAnimations = allAnimations.map(function() {
 777                         var el = $( this );
 778                         return {
 779                                 el: el,
 780                                 start: getElementStyles( this )
 781                         };
 782                 });
 783
 784                 // apply class change
 785                 applyClassChange = function() {
 786                         $.each( classAnimationActions, function(i, action) {
 787                                 if ( value[ action ] ) {
 788                                         animated[ action + "Class" ]( value[ action ] );
 789                                 }
 790                         });
 791                 };
 792                 applyClassChange();
 793
 794                 // map all animated objects again - calculate new styles and diff
 795                 allAnimations = allAnimations.map(function() {
 796                         this.end = getElementStyles( this.el[ 0 ] );
 797                         this.diff = styleDifference( this.start, this.end );
 798                         return this;
 799                 });
 800
 801                 // apply original class
 802                 animated.attr( "class", baseClass );
 803
 804                 // map all animated objects again - this time collecting a promise
 805                 allAnimations = allAnimations.map(function() {
 806                         var styleInfo = this,
 807                                 dfd = $.Deferred(),
 808                                 opts = $.extend({}, o, {
 809                                         queue: false,
 810                                         complete: function() {
 811                                                 dfd.resolve( styleInfo );
 812                                         }
 813                                 });
 814
 815                         this.el.animate( this.diff, opts );
 816                         return dfd.promise();
 817                 });
 818
 819                 // once all animations have completed:
 820                 $.when.apply( $, allAnimations.get() ).done(function() {
 821
 822                         // set the final class
 823                         applyClassChange();
 824
 825                         // for each animated element,
 826                         // clear all css properties that were animated
 827                         $.each( arguments, function() {
 828                                 var el = this.el;
 829                                 $.each( this.diff, function(key) {
 830                                         el.css( key, "" );
 831                                 });
 832                         });
 833
 834                         // this is guarnteed to be there if you use jQuery.speed()
 835                         // it also handles dequeuing the next anim...
 836                         o.complete.call( animated[ 0 ] );
 837                 });
 838         });
 839 };
 840
 841 $.fn.extend({
 842         addClass: (function( orig ) {
 843                 return function( classNames, speed, easing, callback ) {
 844                         return speed ?
 845                                 $.effects.animateClass.call( this,
 846                                         { add: classNames }, speed, easing, callback ) :
 847                                 orig.apply( this, arguments );
 848                 };
 849         })( $.fn.addClass ),
 850
 851         removeClass: (function( orig ) {
 852                 return function( classNames, speed, easing, callback ) {
 853                         return arguments.length > 1 ?
 854                                 $.effects.animateClass.call( this,
 855                                         { remove: classNames }, speed, easing, callback ) :
 856                                 orig.apply( this, arguments );
 857                 };
 858         })( $.fn.removeClass ),
 859
 860         toggleClass: (function( orig ) {
 861                 return function( classNames, force, speed, easing, callback ) {
 862                         if ( typeof force === "boolean" || force === undefined ) {
 863                                 if ( !speed ) {
 864                                         // without speed parameter
 865                                         return orig.apply( this, arguments );
 866                                 } else {
 867                                         return $.effects.animateClass.call( this,
 868                                                 (force ? { add: classNames } : { remove: classNames }),
 869                                                 speed, easing, callback );
 870                                 }
 871                         } else {
 872                                 // without force parameter
 873                                 return $.effects.animateClass.call( this,
 874                                         { toggle: classNames }, force, speed, easing );
 875                         }
 876                 };
 877         })( $.fn.toggleClass ),
 878
 879         switchClass: function( remove, add, speed, easing, callback) {
 880                 return $.effects.animateClass.call( this, {
 881                         add: add,
 882                         remove: remove
 883                 }, speed, easing, callback );
 884         }
 885 });
 886
 887 })();
 888
 889 /******************************************************************************/
 890 /*********************************** EFFECTS **********************************/
 891 /******************************************************************************/
 892
 893 (function() {
 894
 895 $.extend( $.effects, {
 896         version: "1.10.2",
 897
 898         // Saves a set of properties in a data storage
 899         save: function( element, set ) {
 900                 for( var i=0; i < set.length; i++ ) {
 901                         if ( set[ i ] !== null ) {
 902                                 element.data( dataSpace + set[ i ], element[ 0 ].style[ set[ i ] ] );
 903                         }
 904                 }
 905         },
 906
 907         // Restores a set of previously saved properties from a data storage
 908         restore: function( element, set ) {
 909                 var val, i;
 910                 for( i=0; i < set.length; i++ ) {
 911                         if ( set[ i ] !== null ) {
 912                                 val = element.data( dataSpace + set[ i ] );
 913                                 // support: jQuery 1.6.2
 914                                 // http://bugs.jquery.com/ticket/9917
 915                                 // jQuery 1.6.2 incorrectly returns undefined for any falsy value.
 916                                 // We can't differentiate between "" and 0 here, so we just assume
 917                                 // empty string since it's likely to be a more common value...
 918                                 if ( val === undefined ) {
 919                                         val = "";
 920                                 }
 921                                 element.css( set[ i ], val );
 922                         }
 923                 }
 924         },
 925
 926         setMode: function( el, mode ) {
 927                 if (mode === "toggle") {
 928                         mode = el.is( ":hidden" ) ? "show" : "hide";
 929                 }
 930                 return mode;
 931         },
 932
 933         // Translates a [top,left] array into a baseline value
 934         // this should be a little more flexible in the future to handle a string & hash
 935         getBaseline: function( origin, original ) {
 936                 var y, x;
 937                 switch ( origin[ 0 ] ) {
 938                         case "top": y = 0; break;
 939                         case "middle": y = 0.5; break;
 940                         case "bottom": y = 1; break;
 941                         default: y = origin[ 0 ] / original.height;
 942                 }
 943                 switch ( origin[ 1 ] ) {
 944                         case "left": x = 0; break;
 945                         case "center": x = 0.5; break;
 946                         case "right": x = 1; break;
 947                         default: x = origin[ 1 ] / original.width;
 948                 }
 949                 return {
 950                         x: x,
 951                         y: y
 952                 };
 953         },
 954
 955         // Wraps the element around a wrapper that copies position properties
 956         createWrapper: function( element ) {
 957
 958                 // if the element is already wrapped, return it
 959                 if ( element.parent().is( ".ui-effects-wrapper" )) {
 960                         return element.parent();
 961                 }
 962
 963                 // wrap the element
 964                 var props = {
 965                                 width: element.outerWidth(true),
 966                                 height: element.outerHeight(true),
 967                                 "float": element.css( "float" )
 968                         },
 969                         wrapper = $( "<div></div>" )
 970                                 .addClass( "ui-effects-wrapper" )
 971                                 .css({
 972                                         fontSize: "100%",
 973                                         background: "transparent",
 974                                         border: "none",
 975                                         margin: 0,
 976                                         padding: 0
 977                                 }),
 978                         // Store the size in case width/height are defined in % - Fixes #5245
 979                         size = {
 980                                 width: element.width(),
 981                                 height: element.height()
 982                         },
 983                         active = document.activeElement;
 984
 985                 // support: Firefox
 986                 // Firefox incorrectly exposes anonymous content
 987                 // https://bugzilla.mozilla.org/show_bug.cgi?id=561664
 988                 try {
 989                         active.id;
 990                 } catch( e ) {
 991                         active = document.body;
 992                 }
 993
 994                 element.wrap( wrapper );
 995
 996                 // Fixes #7595 - Elements lose focus when wrapped.
 997                 if ( element[ 0 ] === active || $.contains( element[ 0 ], active ) ) {
 998                         $( active ).focus();
 999                 }
1000
1001                 wrapper = element.parent(); //Hotfix for jQuery 1.4 since some change in wrap() seems to actually lose the reference to the wrapped element
1002
1003                 // transfer positioning properties to the wrapper
1004                 if ( element.css( "position" ) === "static" ) {
1005                         wrapper.css({ position: "relative" });
1006                         element.css({ position: "relative" });
1007                 } else {
1008                         $.extend( props, {
1009                                 position: element.css( "position" ),
1010                                 zIndex: element.css( "z-index" )
1011                         });
1012                         $.each([ "top", "left", "bottom", "right" ], function(i, pos) {
1013                                 props[ pos ] = element.css( pos );
1014                                 if ( isNaN( parseInt( props[ pos ], 10 ) ) ) {
1015                                         props[ pos ] = "auto";
1016                                 }
1017                         });
1018                         element.css({
1019                                 position: "relative",
1020                                 top: 0,
1021                                 left: 0,
1022                                 right: "auto",
1023                                 bottom: "auto"
1024                         });
1025                 }
1026                 element.css(size);
1027
1028                 return wrapper.css( props ).show();
1029         },
1030
1031         removeWrapper: function( element ) {
1032                 var active = document.activeElement;
1033
1034                 if ( element.parent().is( ".ui-effects-wrapper" ) ) {
1035                         element.parent().replaceWith( element );
1036
1037                         // Fixes #7595 - Elements lose focus when wrapped.
1038                         if ( element[ 0 ] === active || $.contains( element[ 0 ], active ) ) {
1039                                 $( active ).focus();
1040                         }
1041                 }
1042
1043
1044                 return element;
1045         },
1046
1047         setTransition: function( element, list, factor, value ) {
1048                 value = value || {};
1049                 $.each( list, function( i, x ) {
1050                         var unit = element.cssUnit( x );
1051                         if ( unit[ 0 ] > 0 ) {
1052                                 value[ x ] = unit[ 0 ] * factor + unit[ 1 ];
1053                         }
1054                 });
1055                 return value;
1056         }
1057 });
1058
1059 // return an effect options object for the given parameters:
1060 function _normalizeArguments( effect, options, speed, callback ) {
1061
1062         // allow passing all options as the first parameter
1063         if ( $.isPlainObject( effect ) ) {
1064                 options = effect;
1065                 effect = effect.effect;
1066         }
1067
1068         // convert to an object
1069         effect = { effect: effect };
1070
1071         // catch (effect, null, ...)
1072         if ( options == null ) {
1073                 options = {};
1074         }
1075
1076         // catch (effect, callback)
1077         if ( $.isFunction( options ) ) {
1078                 callback = options;
1079                 speed = null;
1080                 options = {};
1081         }
1082
1083         // catch (effect, speed, ?)
1084         if ( typeof options === "number" || $.fx.speeds[ options ] ) {
1085                 callback = speed;
1086                 speed = options;
1087                 options = {};
1088         }
1089
1090         // catch (effect, options, callback)
1091         if ( $.isFunction( speed ) ) {
1092                 callback = speed;
1093                 speed = null;
1094         }
1095
1096         // add options to effect
1097         if ( options ) {
1098                 $.extend( effect, options );
1099         }
1100
1101         speed = speed || options.duration;
1102         effect.duration = $.fx.off ? 0 :
1103                 typeof speed === "number" ? speed :
1104                 speed in $.fx.speeds ? $.fx.speeds[ speed ] :
1105                 $.fx.speeds._default;
1106
1107         effect.complete = callback || options.complete;
1108
1109         return effect;
1110 }
1111
1112 function standardAnimationOption( option ) {
1113         // Valid standard speeds (nothing, number, named speed)
1114         if ( !option || typeof option === "number" || $.fx.speeds[ option ] ) {
1115                 return true;
1116         }
1117
1118         // Invalid strings - treat as "normal" speed
1119         if ( typeof option === "string" && !$.effects.effect[ option ] ) {
1120                 return true;
1121         }
1122
1123         // Complete callback
1124         if ( $.isFunction( option ) ) {
1125                 return true;
1126         }
1127
1128         // Options hash (but not naming an effect)
1129         if ( typeof option === "object" && !option.effect ) {
1130                 return true;
1131         }
1132
1133         // Didn't match any standard API
1134         return false;
1135 }
1136
1137 $.fn.extend({
1138         effect: function( /* effect, options, speed, callback */ ) {
1139                 var args = _normalizeArguments.apply( this, arguments ),
1140                         mode = args.mode,
1141                         queue = args.queue,
1142                         effectMethod = $.effects.effect[ args.effect ];
1143
1144                 if ( $.fx.off || !effectMethod ) {
1145                         // delegate to the original method (e.g., .show()) if possible
1146                         if ( mode ) {
1147                                 return this[ mode ]( args.duration, args.complete );
1148                         } else {
1149                                 return this.each( function() {
1150                                         if ( args.complete ) {
1151                                                 args.complete.call( this );
1152                                         }
1153                                 });
1154                         }
1155                 }
1156
1157                 function run( next ) {
1158                         var elem = $( this ),
1159                                 complete = args.complete,
1160                                 mode = args.mode;
1161
1162                         function done() {
1163                                 if ( $.isFunction( complete ) ) {
1164                                         complete.call( elem[0] );
1165                                 }
1166                                 if ( $.isFunction( next ) ) {
1167                                         next();
1168                                 }
1169                         }
1170
1171                         // If the element already has the correct final state, delegate to
1172                         // the core methods so the internal tracking of "olddisplay" works.
1173                         if ( elem.is( ":hidden" ) ? mode === "hide" : mode === "show" ) {
1174                                 elem[ mode ]();
1175                                 done();
1176                         } else {
1177                                 effectMethod.call( elem[0], args, done );
1178                         }
1179                 }
1180
1181                 return queue === false ? this.each( run ) : this.queue( queue || "fx", run );
1182         },
1183
1184         show: (function( orig ) {
1185                 return function( option ) {
1186                         if ( standardAnimationOption( option ) ) {
1187                                 return orig.apply( this, arguments );
1188                         } else {
1189                                 var args = _normalizeArguments.apply( this, arguments );
1190                                 args.mode = "show";
1191                                 return this.effect.call( this, args );
1192                         }
1193                 };
1194         })( $.fn.show ),
1195
1196         hide: (function( orig ) {
1197                 return function( option ) {
1198                         if ( standardAnimationOption( option ) ) {
1199                                 return orig.apply( this, arguments );
1200                         } else {
1201                                 var args = _normalizeArguments.apply( this, arguments );
1202                                 args.mode = "hide";
1203                                 return this.effect.call( this, args );
1204                         }
1205                 };
1206         })( $.fn.hide ),
1207
1208         toggle: (function( orig ) {
1209                 return function( option ) {
1210                         if ( standardAnimationOption( option ) || typeof option === "boolean" ) {
1211                                 return orig.apply( this, arguments );
1212                         } else {
1213                                 var args = _normalizeArguments.apply( this, arguments );
1214                                 args.mode = "toggle";
1215                                 return this.effect.call( this, args );
1216                         }
1217                 };
1218         })( $.fn.toggle ),
1219
1220         // helper functions
1221         cssUnit: function(key) {
1222                 var style = this.css( key ),
1223                         val = [];
1224
1225                 $.each( [ "em", "px", "%", "pt" ], function( i, unit ) {
1226                         if ( style.indexOf( unit ) > 0 ) {
1227                                 val = [ parseFloat( style ), unit ];
1228                         }
1229                 });
1230                 return val;
1231         }
1232 });
1233
1234 })();
1235
1236 /******************************************************************************/
1237 /*********************************** EASING ***********************************/
1238 /******************************************************************************/
1239
1240 (function() {
1241
1242 // based on easing equations from Robert Penner (http://www.robertpenner.com/easing)
1243
1244 var baseEasings = {};
1245
1246 $.each( [ "Quad", "Cubic", "Quart", "Quint", "Expo" ], function( i, name ) {
1247         baseEasings[ name ] = function( p ) {
1248                 return Math.pow( p, i + 2 );
1249         };
1250 });
1251
1252 $.extend( baseEasings, {
1253         Sine: function ( p ) {
1254                 return 1 - Math.cos( p * Math.PI / 2 );
1255         },
1256         Circ: function ( p ) {
1257                 return 1 - Math.sqrt( 1 - p * p );
1258         },
1259         Elastic: function( p ) {
1260                 return p === 0 || p === 1 ? p :
1261                         -Math.pow( 2, 8 * (p - 1) ) * Math.sin( ( (p - 1) * 80 - 7.5 ) * Math.PI / 15 );
1262         },
1263         Back: function( p ) {
1264                 return p * p * ( 3 * p - 2 );
1265         },
1266         Bounce: function ( p ) {
1267                 var pow2,
1268                         bounce = 4;
1269
1270                 while ( p < ( ( pow2 = Math.pow( 2, --bounce ) ) - 1 ) / 11 ) {}
1271                 return 1 / Math.pow( 4, 3 - bounce ) - 7.5625 * Math.pow( ( pow2 * 3 - 2 ) / 22 - p, 2 );
1272         }
1273 });
1274
1275 $.each( baseEasings, function( name, easeIn ) {
1276         $.easing[ "easeIn" + name ] = easeIn;
1277         $.easing[ "easeOut" + name ] = function( p ) {
1278                 return 1 - easeIn( 1 - p );
1279         };
1280         $.easing[ "easeInOut" + name ] = function( p ) {
1281                 return p < 0.5 ?
1282                         easeIn( p * 2 ) / 2 :
1283                         1 - easeIn( p * -2 + 2 ) / 2;
1284         };
1285 });
1286
1287 })();
1288
1289 })(jQuery);