1 | /*!
|
---|
2 | * jQuery UI Effects 1.10.3
|
---|
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.3",
|
---|
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);
|
---|