1 | /*! |
---|
2 | * jQuery UI Effects 1.10.1 |
---|
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 | ;(jQuery.effects || (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: $.fn.addClass, |
---|
843 | addClass: function( classNames, speed, easing, callback ) { |
---|
844 | return speed ? |
---|
845 | $.effects.animateClass.call( this, |
---|
846 | { add: classNames }, speed, easing, callback ) : |
---|
847 | this._addClass( classNames ); |
---|
848 | }, |
---|
849 | |
---|
850 | _removeClass: $.fn.removeClass, |
---|
851 | removeClass: function( classNames, speed, easing, callback ) { |
---|
852 | return arguments.length > 1 ? |
---|
853 | $.effects.animateClass.call( this, |
---|
854 | { remove: classNames }, speed, easing, callback ) : |
---|
855 | this._removeClass.apply( this, arguments ); |
---|
856 | }, |
---|
857 | |
---|
858 | _toggleClass: $.fn.toggleClass, |
---|
859 | toggleClass: function( classNames, force, speed, easing, callback ) { |
---|
860 | if ( typeof force === "boolean" || force === undefined ) { |
---|
861 | if ( !speed ) { |
---|
862 | // without speed parameter |
---|
863 | return this._toggleClass( classNames, force ); |
---|
864 | } else { |
---|
865 | return $.effects.animateClass.call( this, |
---|
866 | (force ? { add: classNames } : { remove: classNames }), |
---|
867 | speed, easing, callback ); |
---|
868 | } |
---|
869 | } else { |
---|
870 | // without force parameter |
---|
871 | return $.effects.animateClass.call( this, |
---|
872 | { toggle: classNames }, force, speed, easing ); |
---|
873 | } |
---|
874 | }, |
---|
875 | |
---|
876 | switchClass: function( remove, add, speed, easing, callback) { |
---|
877 | return $.effects.animateClass.call( this, { |
---|
878 | add: add, |
---|
879 | remove: remove |
---|
880 | }, speed, easing, callback ); |
---|
881 | } |
---|
882 | }); |
---|
883 | |
---|
884 | })(); |
---|
885 | |
---|
886 | /******************************************************************************/ |
---|
887 | /*********************************** EFFECTS **********************************/ |
---|
888 | /******************************************************************************/ |
---|
889 | |
---|
890 | (function() { |
---|
891 | |
---|
892 | $.extend( $.effects, { |
---|
893 | version: "1.10.1", |
---|
894 | |
---|
895 | // Saves a set of properties in a data storage |
---|
896 | save: function( element, set ) { |
---|
897 | for( var i=0; i < set.length; i++ ) { |
---|
898 | if ( set[ i ] !== null ) { |
---|
899 | element.data( dataSpace + set[ i ], element[ 0 ].style[ set[ i ] ] ); |
---|
900 | } |
---|
901 | } |
---|
902 | }, |
---|
903 | |
---|
904 | // Restores a set of previously saved properties from a data storage |
---|
905 | restore: function( element, set ) { |
---|
906 | var val, i; |
---|
907 | for( i=0; i < set.length; i++ ) { |
---|
908 | if ( set[ i ] !== null ) { |
---|
909 | val = element.data( dataSpace + set[ i ] ); |
---|
910 | // support: jQuery 1.6.2 |
---|
911 | // http://bugs.jquery.com/ticket/9917 |
---|
912 | // jQuery 1.6.2 incorrectly returns undefined for any falsy value. |
---|
913 | // We can't differentiate between "" and 0 here, so we just assume |
---|
914 | // empty string since it's likely to be a more common value... |
---|
915 | if ( val === undefined ) { |
---|
916 | val = ""; |
---|
917 | } |
---|
918 | element.css( set[ i ], val ); |
---|
919 | } |
---|
920 | } |
---|
921 | }, |
---|
922 | |
---|
923 | setMode: function( el, mode ) { |
---|
924 | if (mode === "toggle") { |
---|
925 | mode = el.is( ":hidden" ) ? "show" : "hide"; |
---|
926 | } |
---|
927 | return mode; |
---|
928 | }, |
---|
929 | |
---|
930 | // Translates a [top,left] array into a baseline value |
---|
931 | // this should be a little more flexible in the future to handle a string & hash |
---|
932 | getBaseline: function( origin, original ) { |
---|
933 | var y, x; |
---|
934 | switch ( origin[ 0 ] ) { |
---|
935 | case "top": y = 0; break; |
---|
936 | case "middle": y = 0.5; break; |
---|
937 | case "bottom": y = 1; break; |
---|
938 | default: y = origin[ 0 ] / original.height; |
---|
939 | } |
---|
940 | switch ( origin[ 1 ] ) { |
---|
941 | case "left": x = 0; break; |
---|
942 | case "center": x = 0.5; break; |
---|
943 | case "right": x = 1; break; |
---|
944 | default: x = origin[ 1 ] / original.width; |
---|
945 | } |
---|
946 | return { |
---|
947 | x: x, |
---|
948 | y: y |
---|
949 | }; |
---|
950 | }, |
---|
951 | |
---|
952 | // Wraps the element around a wrapper that copies position properties |
---|
953 | createWrapper: function( element ) { |
---|
954 | |
---|
955 | // if the element is already wrapped, return it |
---|
956 | if ( element.parent().is( ".ui-effects-wrapper" )) { |
---|
957 | return element.parent(); |
---|
958 | } |
---|
959 | |
---|
960 | // wrap the element |
---|
961 | var props = { |
---|
962 | width: element.outerWidth(true), |
---|
963 | height: element.outerHeight(true), |
---|
964 | "float": element.css( "float" ) |
---|
965 | }, |
---|
966 | wrapper = $( "<div></div>" ) |
---|
967 | .addClass( "ui-effects-wrapper" ) |
---|
968 | .css({ |
---|
969 | fontSize: "100%", |
---|
970 | background: "transparent", |
---|
971 | border: "none", |
---|
972 | margin: 0, |
---|
973 | padding: 0 |
---|
974 | }), |
---|
975 | // Store the size in case width/height are defined in % - Fixes #5245 |
---|
976 | size = { |
---|
977 | width: element.width(), |
---|
978 | height: element.height() |
---|
979 | }, |
---|
980 | active = document.activeElement; |
---|
981 | |
---|
982 | // support: Firefox |
---|
983 | // Firefox incorrectly exposes anonymous content |
---|
984 | // https://bugzilla.mozilla.org/show_bug.cgi?id=561664 |
---|
985 | try { |
---|
986 | active.id; |
---|
987 | } catch( e ) { |
---|
988 | active = document.body; |
---|
989 | } |
---|
990 | |
---|
991 | element.wrap( wrapper ); |
---|
992 | |
---|
993 | // Fixes #7595 - Elements lose focus when wrapped. |
---|
994 | if ( element[ 0 ] === active || $.contains( element[ 0 ], active ) ) { |
---|
995 | $( active ).focus(); |
---|
996 | } |
---|
997 | |
---|
998 | wrapper = element.parent(); //Hotfix for jQuery 1.4 since some change in wrap() seems to actually lose the reference to the wrapped element |
---|
999 | |
---|
1000 | // transfer positioning properties to the wrapper |
---|
1001 | if ( element.css( "position" ) === "static" ) { |
---|
1002 | wrapper.css({ position: "relative" }); |
---|
1003 | element.css({ position: "relative" }); |
---|
1004 | } else { |
---|
1005 | $.extend( props, { |
---|
1006 | position: element.css( "position" ), |
---|
1007 | zIndex: element.css( "z-index" ) |
---|
1008 | }); |
---|
1009 | $.each([ "top", "left", "bottom", "right" ], function(i, pos) { |
---|
1010 | props[ pos ] = element.css( pos ); |
---|
1011 | if ( isNaN( parseInt( props[ pos ], 10 ) ) ) { |
---|
1012 | props[ pos ] = "auto"; |
---|
1013 | } |
---|
1014 | }); |
---|
1015 | element.css({ |
---|
1016 | position: "relative", |
---|
1017 | top: 0, |
---|
1018 | left: 0, |
---|
1019 | right: "auto", |
---|
1020 | bottom: "auto" |
---|
1021 | }); |
---|
1022 | } |
---|
1023 | element.css(size); |
---|
1024 | |
---|
1025 | return wrapper.css( props ).show(); |
---|
1026 | }, |
---|
1027 | |
---|
1028 | removeWrapper: function( element ) { |
---|
1029 | var active = document.activeElement; |
---|
1030 | |
---|
1031 | if ( element.parent().is( ".ui-effects-wrapper" ) ) { |
---|
1032 | element.parent().replaceWith( element ); |
---|
1033 | |
---|
1034 | // Fixes #7595 - Elements lose focus when wrapped. |
---|
1035 | if ( element[ 0 ] === active || $.contains( element[ 0 ], active ) ) { |
---|
1036 | $( active ).focus(); |
---|
1037 | } |
---|
1038 | } |
---|
1039 | |
---|
1040 | |
---|
1041 | return element; |
---|
1042 | }, |
---|
1043 | |
---|
1044 | setTransition: function( element, list, factor, value ) { |
---|
1045 | value = value || {}; |
---|
1046 | $.each( list, function( i, x ) { |
---|
1047 | var unit = element.cssUnit( x ); |
---|
1048 | if ( unit[ 0 ] > 0 ) { |
---|
1049 | value[ x ] = unit[ 0 ] * factor + unit[ 1 ]; |
---|
1050 | } |
---|
1051 | }); |
---|
1052 | return value; |
---|
1053 | } |
---|
1054 | }); |
---|
1055 | |
---|
1056 | // return an effect options object for the given parameters: |
---|
1057 | function _normalizeArguments( effect, options, speed, callback ) { |
---|
1058 | |
---|
1059 | // allow passing all options as the first parameter |
---|
1060 | if ( $.isPlainObject( effect ) ) { |
---|
1061 | options = effect; |
---|
1062 | effect = effect.effect; |
---|
1063 | } |
---|
1064 | |
---|
1065 | // convert to an object |
---|
1066 | effect = { effect: effect }; |
---|
1067 | |
---|
1068 | // catch (effect, null, ...) |
---|
1069 | if ( options == null ) { |
---|
1070 | options = {}; |
---|
1071 | } |
---|
1072 | |
---|
1073 | // catch (effect, callback) |
---|
1074 | if ( $.isFunction( options ) ) { |
---|
1075 | callback = options; |
---|
1076 | speed = null; |
---|
1077 | options = {}; |
---|
1078 | } |
---|
1079 | |
---|
1080 | // catch (effect, speed, ?) |
---|
1081 | if ( typeof options === "number" || $.fx.speeds[ options ] ) { |
---|
1082 | callback = speed; |
---|
1083 | speed = options; |
---|
1084 | options = {}; |
---|
1085 | } |
---|
1086 | |
---|
1087 | // catch (effect, options, callback) |
---|
1088 | if ( $.isFunction( speed ) ) { |
---|
1089 | callback = speed; |
---|
1090 | speed = null; |
---|
1091 | } |
---|
1092 | |
---|
1093 | // add options to effect |
---|
1094 | if ( options ) { |
---|
1095 | $.extend( effect, options ); |
---|
1096 | } |
---|
1097 | |
---|
1098 | speed = speed || options.duration; |
---|
1099 | effect.duration = $.fx.off ? 0 : |
---|
1100 | typeof speed === "number" ? speed : |
---|
1101 | speed in $.fx.speeds ? $.fx.speeds[ speed ] : |
---|
1102 | $.fx.speeds._default; |
---|
1103 | |
---|
1104 | effect.complete = callback || options.complete; |
---|
1105 | |
---|
1106 | return effect; |
---|
1107 | } |
---|
1108 | |
---|
1109 | function standardSpeed( speed ) { |
---|
1110 | // valid standard speeds |
---|
1111 | if ( !speed || typeof speed === "number" || $.fx.speeds[ speed ] ) { |
---|
1112 | return true; |
---|
1113 | } |
---|
1114 | |
---|
1115 | // invalid strings - treat as "normal" speed |
---|
1116 | return typeof speed === "string" && !$.effects.effect[ speed ]; |
---|
1117 | } |
---|
1118 | |
---|
1119 | $.fn.extend({ |
---|
1120 | effect: function( /* effect, options, speed, callback */ ) { |
---|
1121 | var args = _normalizeArguments.apply( this, arguments ), |
---|
1122 | mode = args.mode, |
---|
1123 | queue = args.queue, |
---|
1124 | effectMethod = $.effects.effect[ args.effect ]; |
---|
1125 | |
---|
1126 | if ( $.fx.off || !effectMethod ) { |
---|
1127 | // delegate to the original method (e.g., .show()) if possible |
---|
1128 | if ( mode ) { |
---|
1129 | return this[ mode ]( args.duration, args.complete ); |
---|
1130 | } else { |
---|
1131 | return this.each( function() { |
---|
1132 | if ( args.complete ) { |
---|
1133 | args.complete.call( this ); |
---|
1134 | } |
---|
1135 | }); |
---|
1136 | } |
---|
1137 | } |
---|
1138 | |
---|
1139 | function run( next ) { |
---|
1140 | var elem = $( this ), |
---|
1141 | complete = args.complete, |
---|
1142 | mode = args.mode; |
---|
1143 | |
---|
1144 | function done() { |
---|
1145 | if ( $.isFunction( complete ) ) { |
---|
1146 | complete.call( elem[0] ); |
---|
1147 | } |
---|
1148 | if ( $.isFunction( next ) ) { |
---|
1149 | next(); |
---|
1150 | } |
---|
1151 | } |
---|
1152 | |
---|
1153 | // if the element is hiddden and mode is hide, |
---|
1154 | // or element is visible and mode is show |
---|
1155 | if ( elem.is( ":hidden" ) ? mode === "hide" : mode === "show" ) { |
---|
1156 | done(); |
---|
1157 | } else { |
---|
1158 | effectMethod.call( elem[0], args, done ); |
---|
1159 | } |
---|
1160 | } |
---|
1161 | |
---|
1162 | return queue === false ? this.each( run ) : this.queue( queue || "fx", run ); |
---|
1163 | }, |
---|
1164 | |
---|
1165 | _show: $.fn.show, |
---|
1166 | show: function( speed ) { |
---|
1167 | if ( standardSpeed( speed ) ) { |
---|
1168 | return this._show.apply( this, arguments ); |
---|
1169 | } else { |
---|
1170 | var args = _normalizeArguments.apply( this, arguments ); |
---|
1171 | args.mode = "show"; |
---|
1172 | return this.effect.call( this, args ); |
---|
1173 | } |
---|
1174 | }, |
---|
1175 | |
---|
1176 | _hide: $.fn.hide, |
---|
1177 | hide: function( speed ) { |
---|
1178 | if ( standardSpeed( speed ) ) { |
---|
1179 | return this._hide.apply( this, arguments ); |
---|
1180 | } else { |
---|
1181 | var args = _normalizeArguments.apply( this, arguments ); |
---|
1182 | args.mode = "hide"; |
---|
1183 | return this.effect.call( this, args ); |
---|
1184 | } |
---|
1185 | }, |
---|
1186 | |
---|
1187 | // jQuery core overloads toggle and creates _toggle |
---|
1188 | __toggle: $.fn.toggle, |
---|
1189 | toggle: function( speed ) { |
---|
1190 | if ( standardSpeed( speed ) || typeof speed === "boolean" || $.isFunction( speed ) ) { |
---|
1191 | return this.__toggle.apply( this, arguments ); |
---|
1192 | } else { |
---|
1193 | var args = _normalizeArguments.apply( this, arguments ); |
---|
1194 | args.mode = "toggle"; |
---|
1195 | return this.effect.call( this, args ); |
---|
1196 | } |
---|
1197 | }, |
---|
1198 | |
---|
1199 | // helper functions |
---|
1200 | cssUnit: function(key) { |
---|
1201 | var style = this.css( key ), |
---|
1202 | val = []; |
---|
1203 | |
---|
1204 | $.each( [ "em", "px", "%", "pt" ], function( i, unit ) { |
---|
1205 | if ( style.indexOf( unit ) > 0 ) { |
---|
1206 | val = [ parseFloat( style ), unit ]; |
---|
1207 | } |
---|
1208 | }); |
---|
1209 | return val; |
---|
1210 | } |
---|
1211 | }); |
---|
1212 | |
---|
1213 | })(); |
---|
1214 | |
---|
1215 | /******************************************************************************/ |
---|
1216 | /*********************************** EASING ***********************************/ |
---|
1217 | /******************************************************************************/ |
---|
1218 | |
---|
1219 | (function() { |
---|
1220 | |
---|
1221 | // based on easing equations from Robert Penner (http://www.robertpenner.com/easing) |
---|
1222 | |
---|
1223 | var baseEasings = {}; |
---|
1224 | |
---|
1225 | $.each( [ "Quad", "Cubic", "Quart", "Quint", "Expo" ], function( i, name ) { |
---|
1226 | baseEasings[ name ] = function( p ) { |
---|
1227 | return Math.pow( p, i + 2 ); |
---|
1228 | }; |
---|
1229 | }); |
---|
1230 | |
---|
1231 | $.extend( baseEasings, { |
---|
1232 | Sine: function ( p ) { |
---|
1233 | return 1 - Math.cos( p * Math.PI / 2 ); |
---|
1234 | }, |
---|
1235 | Circ: function ( p ) { |
---|
1236 | return 1 - Math.sqrt( 1 - p * p ); |
---|
1237 | }, |
---|
1238 | Elastic: function( p ) { |
---|
1239 | return p === 0 || p === 1 ? p : |
---|
1240 | -Math.pow( 2, 8 * (p - 1) ) * Math.sin( ( (p - 1) * 80 - 7.5 ) * Math.PI / 15 ); |
---|
1241 | }, |
---|
1242 | Back: function( p ) { |
---|
1243 | return p * p * ( 3 * p - 2 ); |
---|
1244 | }, |
---|
1245 | Bounce: function ( p ) { |
---|
1246 | var pow2, |
---|
1247 | bounce = 4; |
---|
1248 | |
---|
1249 | while ( p < ( ( pow2 = Math.pow( 2, --bounce ) ) - 1 ) / 11 ) {} |
---|
1250 | return 1 / Math.pow( 4, 3 - bounce ) - 7.5625 * Math.pow( ( pow2 * 3 - 2 ) / 22 - p, 2 ); |
---|
1251 | } |
---|
1252 | }); |
---|
1253 | |
---|
1254 | $.each( baseEasings, function( name, easeIn ) { |
---|
1255 | $.easing[ "easeIn" + name ] = easeIn; |
---|
1256 | $.easing[ "easeOut" + name ] = function( p ) { |
---|
1257 | return 1 - easeIn( 1 - p ); |
---|
1258 | }; |
---|
1259 | $.easing[ "easeInOut" + name ] = function( p ) { |
---|
1260 | return p < 0.5 ? |
---|
1261 | easeIn( p * 2 ) / 2 : |
---|
1262 | 1 - easeIn( p * -2 + 2 ) / 2; |
---|
1263 | }; |
---|
1264 | }); |
---|
1265 | |
---|
1266 | })(); |
---|
1267 | |
---|
1268 | })(jQuery)); |
---|