comparison jquery-ui.js @ 1:440f4aa3db97 draft

Added option to dowload iReports
author saskia-hiltemann
date Wed, 30 Jul 2014 07:03:43 -0400
parents
children
comparison
equal deleted inserted replaced
0:ac5f9272033b 1:440f4aa3db97
1 /*! jQuery UI - v1.10.4 - 2014-01-17
2 * http://jqueryui.com
3 * Includes: jquery.ui.core.js, jquery.ui.widget.js, jquery.ui.mouse.js, jquery.ui.position.js, jquery.ui.accordion.js, jquery.ui.autocomplete.js, jquery.ui.button.js, jquery.ui.datepicker.js, jquery.ui.dialog.js, jquery.ui.draggable.js, jquery.ui.droppable.js, jquery.ui.effect.js, jquery.ui.effect-blind.js, jquery.ui.effect-bounce.js, jquery.ui.effect-clip.js, jquery.ui.effect-drop.js, jquery.ui.effect-explode.js, jquery.ui.effect-fade.js, jquery.ui.effect-fold.js, jquery.ui.effect-highlight.js, jquery.ui.effect-pulsate.js, jquery.ui.effect-scale.js, jquery.ui.effect-shake.js, jquery.ui.effect-slide.js, jquery.ui.effect-transfer.js, jquery.ui.menu.js, jquery.ui.progressbar.js, jquery.ui.resizable.js, jquery.ui.selectable.js, jquery.ui.slider.js, jquery.ui.sortable.js, jquery.ui.spinner.js, jquery.ui.tabs.js, jquery.ui.tooltip.js
4 * Copyright 2014 jQuery Foundation and other contributors; Licensed MIT */
5
6 (function( $, undefined ) {
7
8 var uuid = 0,
9 runiqueId = /^ui-id-\d+$/;
10
11 // $.ui might exist from components with no dependencies, e.g., $.ui.position
12 $.ui = $.ui || {};
13
14 $.extend( $.ui, {
15 version: "1.10.4",
16
17 keyCode: {
18 BACKSPACE: 8,
19 COMMA: 188,
20 DELETE: 46,
21 DOWN: 40,
22 END: 35,
23 ENTER: 13,
24 ESCAPE: 27,
25 HOME: 36,
26 LEFT: 37,
27 NUMPAD_ADD: 107,
28 NUMPAD_DECIMAL: 110,
29 NUMPAD_DIVIDE: 111,
30 NUMPAD_ENTER: 108,
31 NUMPAD_MULTIPLY: 106,
32 NUMPAD_SUBTRACT: 109,
33 PAGE_DOWN: 34,
34 PAGE_UP: 33,
35 PERIOD: 190,
36 RIGHT: 39,
37 SPACE: 32,
38 TAB: 9,
39 UP: 38
40 }
41 });
42
43 // plugins
44 $.fn.extend({
45 focus: (function( orig ) {
46 return function( delay, fn ) {
47 return typeof delay === "number" ?
48 this.each(function() {
49 var elem = this;
50 setTimeout(function() {
51 $( elem ).focus();
52 if ( fn ) {
53 fn.call( elem );
54 }
55 }, delay );
56 }) :
57 orig.apply( this, arguments );
58 };
59 })( $.fn.focus ),
60
61 scrollParent: function() {
62 var scrollParent;
63 if (($.ui.ie && (/(static|relative)/).test(this.css("position"))) || (/absolute/).test(this.css("position"))) {
64 scrollParent = this.parents().filter(function() {
65 return (/(relative|absolute|fixed)/).test($.css(this,"position")) && (/(auto|scroll)/).test($.css(this,"overflow")+$.css(this,"overflow-y")+$.css(this,"overflow-x"));
66 }).eq(0);
67 } else {
68 scrollParent = this.parents().filter(function() {
69 return (/(auto|scroll)/).test($.css(this,"overflow")+$.css(this,"overflow-y")+$.css(this,"overflow-x"));
70 }).eq(0);
71 }
72
73 return (/fixed/).test(this.css("position")) || !scrollParent.length ? $(document) : scrollParent;
74 },
75
76 zIndex: function( zIndex ) {
77 if ( zIndex !== undefined ) {
78 return this.css( "zIndex", zIndex );
79 }
80
81 if ( this.length ) {
82 var elem = $( this[ 0 ] ), position, value;
83 while ( elem.length && elem[ 0 ] !== document ) {
84 // Ignore z-index if position is set to a value where z-index is ignored by the browser
85 // This makes behavior of this function consistent across browsers
86 // WebKit always returns auto if the element is positioned
87 position = elem.css( "position" );
88 if ( position === "absolute" || position === "relative" || position === "fixed" ) {
89 // IE returns 0 when zIndex is not specified
90 // other browsers return a string
91 // we ignore the case of nested elements with an explicit value of 0
92 // <div style="z-index: -10;"><div style="z-index: 0;"></div></div>
93 value = parseInt( elem.css( "zIndex" ), 10 );
94 if ( !isNaN( value ) && value !== 0 ) {
95 return value;
96 }
97 }
98 elem = elem.parent();
99 }
100 }
101
102 return 0;
103 },
104
105 uniqueId: function() {
106 return this.each(function() {
107 if ( !this.id ) {
108 this.id = "ui-id-" + (++uuid);
109 }
110 });
111 },
112
113 removeUniqueId: function() {
114 return this.each(function() {
115 if ( runiqueId.test( this.id ) ) {
116 $( this ).removeAttr( "id" );
117 }
118 });
119 }
120 });
121
122 // selectors
123 function focusable( element, isTabIndexNotNaN ) {
124 var map, mapName, img,
125 nodeName = element.nodeName.toLowerCase();
126 if ( "area" === nodeName ) {
127 map = element.parentNode;
128 mapName = map.name;
129 if ( !element.href || !mapName || map.nodeName.toLowerCase() !== "map" ) {
130 return false;
131 }
132 img = $( "img[usemap=#" + mapName + "]" )[0];
133 return !!img && visible( img );
134 }
135 return ( /input|select|textarea|button|object/.test( nodeName ) ?
136 !element.disabled :
137 "a" === nodeName ?
138 element.href || isTabIndexNotNaN :
139 isTabIndexNotNaN) &&
140 // the element and all of its ancestors must be visible
141 visible( element );
142 }
143
144 function visible( element ) {
145 return $.expr.filters.visible( element ) &&
146 !$( element ).parents().addBack().filter(function() {
147 return $.css( this, "visibility" ) === "hidden";
148 }).length;
149 }
150
151 $.extend( $.expr[ ":" ], {
152 data: $.expr.createPseudo ?
153 $.expr.createPseudo(function( dataName ) {
154 return function( elem ) {
155 return !!$.data( elem, dataName );
156 };
157 }) :
158 // support: jQuery <1.8
159 function( elem, i, match ) {
160 return !!$.data( elem, match[ 3 ] );
161 },
162
163 focusable: function( element ) {
164 return focusable( element, !isNaN( $.attr( element, "tabindex" ) ) );
165 },
166
167 tabbable: function( element ) {
168 var tabIndex = $.attr( element, "tabindex" ),
169 isTabIndexNaN = isNaN( tabIndex );
170 return ( isTabIndexNaN || tabIndex >= 0 ) && focusable( element, !isTabIndexNaN );
171 }
172 });
173
174 // support: jQuery <1.8
175 if ( !$( "<a>" ).outerWidth( 1 ).jquery ) {
176 $.each( [ "Width", "Height" ], function( i, name ) {
177 var side = name === "Width" ? [ "Left", "Right" ] : [ "Top", "Bottom" ],
178 type = name.toLowerCase(),
179 orig = {
180 innerWidth: $.fn.innerWidth,
181 innerHeight: $.fn.innerHeight,
182 outerWidth: $.fn.outerWidth,
183 outerHeight: $.fn.outerHeight
184 };
185
186 function reduce( elem, size, border, margin ) {
187 $.each( side, function() {
188 size -= parseFloat( $.css( elem, "padding" + this ) ) || 0;
189 if ( border ) {
190 size -= parseFloat( $.css( elem, "border" + this + "Width" ) ) || 0;
191 }
192 if ( margin ) {
193 size -= parseFloat( $.css( elem, "margin" + this ) ) || 0;
194 }
195 });
196 return size;
197 }
198
199 $.fn[ "inner" + name ] = function( size ) {
200 if ( size === undefined ) {
201 return orig[ "inner" + name ].call( this );
202 }
203
204 return this.each(function() {
205 $( this ).css( type, reduce( this, size ) + "px" );
206 });
207 };
208
209 $.fn[ "outer" + name] = function( size, margin ) {
210 if ( typeof size !== "number" ) {
211 return orig[ "outer" + name ].call( this, size );
212 }
213
214 return this.each(function() {
215 $( this).css( type, reduce( this, size, true, margin ) + "px" );
216 });
217 };
218 });
219 }
220
221 // support: jQuery <1.8
222 if ( !$.fn.addBack ) {
223 $.fn.addBack = function( selector ) {
224 return this.add( selector == null ?
225 this.prevObject : this.prevObject.filter( selector )
226 );
227 };
228 }
229
230 // support: jQuery 1.6.1, 1.6.2 (http://bugs.jquery.com/ticket/9413)
231 if ( $( "<a>" ).data( "a-b", "a" ).removeData( "a-b" ).data( "a-b" ) ) {
232 $.fn.removeData = (function( removeData ) {
233 return function( key ) {
234 if ( arguments.length ) {
235 return removeData.call( this, $.camelCase( key ) );
236 } else {
237 return removeData.call( this );
238 }
239 };
240 })( $.fn.removeData );
241 }
242
243
244
245
246
247 // deprecated
248 $.ui.ie = !!/msie [\w.]+/.exec( navigator.userAgent.toLowerCase() );
249
250 $.support.selectstart = "onselectstart" in document.createElement( "div" );
251 $.fn.extend({
252 disableSelection: function() {
253 return this.bind( ( $.support.selectstart ? "selectstart" : "mousedown" ) +
254 ".ui-disableSelection", function( event ) {
255 event.preventDefault();
256 });
257 },
258
259 enableSelection: function() {
260 return this.unbind( ".ui-disableSelection" );
261 }
262 });
263
264 $.extend( $.ui, {
265 // $.ui.plugin is deprecated. Use $.widget() extensions instead.
266 plugin: {
267 add: function( module, option, set ) {
268 var i,
269 proto = $.ui[ module ].prototype;
270 for ( i in set ) {
271 proto.plugins[ i ] = proto.plugins[ i ] || [];
272 proto.plugins[ i ].push( [ option, set[ i ] ] );
273 }
274 },
275 call: function( instance, name, args ) {
276 var i,
277 set = instance.plugins[ name ];
278 if ( !set || !instance.element[ 0 ].parentNode || instance.element[ 0 ].parentNode.nodeType === 11 ) {
279 return;
280 }
281
282 for ( i = 0; i < set.length; i++ ) {
283 if ( instance.options[ set[ i ][ 0 ] ] ) {
284 set[ i ][ 1 ].apply( instance.element, args );
285 }
286 }
287 }
288 },
289
290 // only used by resizable
291 hasScroll: function( el, a ) {
292
293 //If overflow is hidden, the element might have extra content, but the user wants to hide it
294 if ( $( el ).css( "overflow" ) === "hidden") {
295 return false;
296 }
297
298 var scroll = ( a && a === "left" ) ? "scrollLeft" : "scrollTop",
299 has = false;
300
301 if ( el[ scroll ] > 0 ) {
302 return true;
303 }
304
305 // TODO: determine which cases actually cause this to happen
306 // if the element doesn't have the scroll set, see if it's possible to
307 // set the scroll
308 el[ scroll ] = 1;
309 has = ( el[ scroll ] > 0 );
310 el[ scroll ] = 0;
311 return has;
312 }
313 });
314
315 })( jQuery );
316 (function( $, undefined ) {
317
318 var uuid = 0,
319 slice = Array.prototype.slice,
320 _cleanData = $.cleanData;
321 $.cleanData = function( elems ) {
322 for ( var i = 0, elem; (elem = elems[i]) != null; i++ ) {
323 try {
324 $( elem ).triggerHandler( "remove" );
325 // http://bugs.jquery.com/ticket/8235
326 } catch( e ) {}
327 }
328 _cleanData( elems );
329 };
330
331 $.widget = function( name, base, prototype ) {
332 var fullName, existingConstructor, constructor, basePrototype,
333 // proxiedPrototype allows the provided prototype to remain unmodified
334 // so that it can be used as a mixin for multiple widgets (#8876)
335 proxiedPrototype = {},
336 namespace = name.split( "." )[ 0 ];
337
338 name = name.split( "." )[ 1 ];
339 fullName = namespace + "-" + name;
340
341 if ( !prototype ) {
342 prototype = base;
343 base = $.Widget;
344 }
345
346 // create selector for plugin
347 $.expr[ ":" ][ fullName.toLowerCase() ] = function( elem ) {
348 return !!$.data( elem, fullName );
349 };
350
351 $[ namespace ] = $[ namespace ] || {};
352 existingConstructor = $[ namespace ][ name ];
353 constructor = $[ namespace ][ name ] = function( options, element ) {
354 // allow instantiation without "new" keyword
355 if ( !this._createWidget ) {
356 return new constructor( options, element );
357 }
358
359 // allow instantiation without initializing for simple inheritance
360 // must use "new" keyword (the code above always passes args)
361 if ( arguments.length ) {
362 this._createWidget( options, element );
363 }
364 };
365 // extend with the existing constructor to carry over any static properties
366 $.extend( constructor, existingConstructor, {
367 version: prototype.version,
368 // copy the object used to create the prototype in case we need to
369 // redefine the widget later
370 _proto: $.extend( {}, prototype ),
371 // track widgets that inherit from this widget in case this widget is
372 // redefined after a widget inherits from it
373 _childConstructors: []
374 });
375
376 basePrototype = new base();
377 // we need to make the options hash a property directly on the new instance
378 // otherwise we'll modify the options hash on the prototype that we're
379 // inheriting from
380 basePrototype.options = $.widget.extend( {}, basePrototype.options );
381 $.each( prototype, function( prop, value ) {
382 if ( !$.isFunction( value ) ) {
383 proxiedPrototype[ prop ] = value;
384 return;
385 }
386 proxiedPrototype[ prop ] = (function() {
387 var _super = function() {
388 return base.prototype[ prop ].apply( this, arguments );
389 },
390 _superApply = function( args ) {
391 return base.prototype[ prop ].apply( this, args );
392 };
393 return function() {
394 var __super = this._super,
395 __superApply = this._superApply,
396 returnValue;
397
398 this._super = _super;
399 this._superApply = _superApply;
400
401 returnValue = value.apply( this, arguments );
402
403 this._super = __super;
404 this._superApply = __superApply;
405
406 return returnValue;
407 };
408 })();
409 });
410 constructor.prototype = $.widget.extend( basePrototype, {
411 // TODO: remove support for widgetEventPrefix
412 // always use the name + a colon as the prefix, e.g., draggable:start
413 // don't prefix for widgets that aren't DOM-based
414 widgetEventPrefix: existingConstructor ? (basePrototype.widgetEventPrefix || name) : name
415 }, proxiedPrototype, {
416 constructor: constructor,
417 namespace: namespace,
418 widgetName: name,
419 widgetFullName: fullName
420 });
421
422 // If this widget is being redefined then we need to find all widgets that
423 // are inheriting from it and redefine all of them so that they inherit from
424 // the new version of this widget. We're essentially trying to replace one
425 // level in the prototype chain.
426 if ( existingConstructor ) {
427 $.each( existingConstructor._childConstructors, function( i, child ) {
428 var childPrototype = child.prototype;
429
430 // redefine the child widget using the same prototype that was
431 // originally used, but inherit from the new version of the base
432 $.widget( childPrototype.namespace + "." + childPrototype.widgetName, constructor, child._proto );
433 });
434 // remove the list of existing child constructors from the old constructor
435 // so the old child constructors can be garbage collected
436 delete existingConstructor._childConstructors;
437 } else {
438 base._childConstructors.push( constructor );
439 }
440
441 $.widget.bridge( name, constructor );
442 };
443
444 $.widget.extend = function( target ) {
445 var input = slice.call( arguments, 1 ),
446 inputIndex = 0,
447 inputLength = input.length,
448 key,
449 value;
450 for ( ; inputIndex < inputLength; inputIndex++ ) {
451 for ( key in input[ inputIndex ] ) {
452 value = input[ inputIndex ][ key ];
453 if ( input[ inputIndex ].hasOwnProperty( key ) && value !== undefined ) {
454 // Clone objects
455 if ( $.isPlainObject( value ) ) {
456 target[ key ] = $.isPlainObject( target[ key ] ) ?
457 $.widget.extend( {}, target[ key ], value ) :
458 // Don't extend strings, arrays, etc. with objects
459 $.widget.extend( {}, value );
460 // Copy everything else by reference
461 } else {
462 target[ key ] = value;
463 }
464 }
465 }
466 }
467 return target;
468 };
469
470 $.widget.bridge = function( name, object ) {
471 var fullName = object.prototype.widgetFullName || name;
472 $.fn[ name ] = function( options ) {
473 var isMethodCall = typeof options === "string",
474 args = slice.call( arguments, 1 ),
475 returnValue = this;
476
477 // allow multiple hashes to be passed on init
478 options = !isMethodCall && args.length ?
479 $.widget.extend.apply( null, [ options ].concat(args) ) :
480 options;
481
482 if ( isMethodCall ) {
483 this.each(function() {
484 var methodValue,
485 instance = $.data( this, fullName );
486 if ( !instance ) {
487 return $.error( "cannot call methods on " + name + " prior to initialization; " +
488 "attempted to call method '" + options + "'" );
489 }
490 if ( !$.isFunction( instance[options] ) || options.charAt( 0 ) === "_" ) {
491 return $.error( "no such method '" + options + "' for " + name + " widget instance" );
492 }
493 methodValue = instance[ options ].apply( instance, args );
494 if ( methodValue !== instance && methodValue !== undefined ) {
495 returnValue = methodValue && methodValue.jquery ?
496 returnValue.pushStack( methodValue.get() ) :
497 methodValue;
498 return false;
499 }
500 });
501 } else {
502 this.each(function() {
503 var instance = $.data( this, fullName );
504 if ( instance ) {
505 instance.option( options || {} )._init();
506 } else {
507 $.data( this, fullName, new object( options, this ) );
508 }
509 });
510 }
511
512 return returnValue;
513 };
514 };
515
516 $.Widget = function( /* options, element */ ) {};
517 $.Widget._childConstructors = [];
518
519 $.Widget.prototype = {
520 widgetName: "widget",
521 widgetEventPrefix: "",
522 defaultElement: "<div>",
523 options: {
524 disabled: false,
525
526 // callbacks
527 create: null
528 },
529 _createWidget: function( options, element ) {
530 element = $( element || this.defaultElement || this )[ 0 ];
531 this.element = $( element );
532 this.uuid = uuid++;
533 this.eventNamespace = "." + this.widgetName + this.uuid;
534 this.options = $.widget.extend( {},
535 this.options,
536 this._getCreateOptions(),
537 options );
538
539 this.bindings = $();
540 this.hoverable = $();
541 this.focusable = $();
542
543 if ( element !== this ) {
544 $.data( element, this.widgetFullName, this );
545 this._on( true, this.element, {
546 remove: function( event ) {
547 if ( event.target === element ) {
548 this.destroy();
549 }
550 }
551 });
552 this.document = $( element.style ?
553 // element within the document
554 element.ownerDocument :
555 // element is window or document
556 element.document || element );
557 this.window = $( this.document[0].defaultView || this.document[0].parentWindow );
558 }
559
560 this._create();
561 this._trigger( "create", null, this._getCreateEventData() );
562 this._init();
563 },
564 _getCreateOptions: $.noop,
565 _getCreateEventData: $.noop,
566 _create: $.noop,
567 _init: $.noop,
568
569 destroy: function() {
570 this._destroy();
571 // we can probably remove the unbind calls in 2.0
572 // all event bindings should go through this._on()
573 this.element
574 .unbind( this.eventNamespace )
575 // 1.9 BC for #7810
576 // TODO remove dual storage
577 .removeData( this.widgetName )
578 .removeData( this.widgetFullName )
579 // support: jquery <1.6.3
580 // http://bugs.jquery.com/ticket/9413
581 .removeData( $.camelCase( this.widgetFullName ) );
582 this.widget()
583 .unbind( this.eventNamespace )
584 .removeAttr( "aria-disabled" )
585 .removeClass(
586 this.widgetFullName + "-disabled " +
587 "ui-state-disabled" );
588
589 // clean up events and states
590 this.bindings.unbind( this.eventNamespace );
591 this.hoverable.removeClass( "ui-state-hover" );
592 this.focusable.removeClass( "ui-state-focus" );
593 },
594 _destroy: $.noop,
595
596 widget: function() {
597 return this.element;
598 },
599
600 option: function( key, value ) {
601 var options = key,
602 parts,
603 curOption,
604 i;
605
606 if ( arguments.length === 0 ) {
607 // don't return a reference to the internal hash
608 return $.widget.extend( {}, this.options );
609 }
610
611 if ( typeof key === "string" ) {
612 // handle nested keys, e.g., "foo.bar" => { foo: { bar: ___ } }
613 options = {};
614 parts = key.split( "." );
615 key = parts.shift();
616 if ( parts.length ) {
617 curOption = options[ key ] = $.widget.extend( {}, this.options[ key ] );
618 for ( i = 0; i < parts.length - 1; i++ ) {
619 curOption[ parts[ i ] ] = curOption[ parts[ i ] ] || {};
620 curOption = curOption[ parts[ i ] ];
621 }
622 key = parts.pop();
623 if ( arguments.length === 1 ) {
624 return curOption[ key ] === undefined ? null : curOption[ key ];
625 }
626 curOption[ key ] = value;
627 } else {
628 if ( arguments.length === 1 ) {
629 return this.options[ key ] === undefined ? null : this.options[ key ];
630 }
631 options[ key ] = value;
632 }
633 }
634
635 this._setOptions( options );
636
637 return this;
638 },
639 _setOptions: function( options ) {
640 var key;
641
642 for ( key in options ) {
643 this._setOption( key, options[ key ] );
644 }
645
646 return this;
647 },
648 _setOption: function( key, value ) {
649 this.options[ key ] = value;
650
651 if ( key === "disabled" ) {
652 this.widget()
653 .toggleClass( this.widgetFullName + "-disabled ui-state-disabled", !!value )
654 .attr( "aria-disabled", value );
655 this.hoverable.removeClass( "ui-state-hover" );
656 this.focusable.removeClass( "ui-state-focus" );
657 }
658
659 return this;
660 },
661
662 enable: function() {
663 return this._setOption( "disabled", false );
664 },
665 disable: function() {
666 return this._setOption( "disabled", true );
667 },
668
669 _on: function( suppressDisabledCheck, element, handlers ) {
670 var delegateElement,
671 instance = this;
672
673 // no suppressDisabledCheck flag, shuffle arguments
674 if ( typeof suppressDisabledCheck !== "boolean" ) {
675 handlers = element;
676 element = suppressDisabledCheck;
677 suppressDisabledCheck = false;
678 }
679
680 // no element argument, shuffle and use this.element
681 if ( !handlers ) {
682 handlers = element;
683 element = this.element;
684 delegateElement = this.widget();
685 } else {
686 // accept selectors, DOM elements
687 element = delegateElement = $( element );
688 this.bindings = this.bindings.add( element );
689 }
690
691 $.each( handlers, function( event, handler ) {
692 function handlerProxy() {
693 // allow widgets to customize the disabled handling
694 // - disabled as an array instead of boolean
695 // - disabled class as method for disabling individual parts
696 if ( !suppressDisabledCheck &&
697 ( instance.options.disabled === true ||
698 $( this ).hasClass( "ui-state-disabled" ) ) ) {
699 return;
700 }
701 return ( typeof handler === "string" ? instance[ handler ] : handler )
702 .apply( instance, arguments );
703 }
704
705 // copy the guid so direct unbinding works
706 if ( typeof handler !== "string" ) {
707 handlerProxy.guid = handler.guid =
708 handler.guid || handlerProxy.guid || $.guid++;
709 }
710
711 var match = event.match( /^(\w+)\s*(.*)$/ ),
712 eventName = match[1] + instance.eventNamespace,
713 selector = match[2];
714 if ( selector ) {
715 delegateElement.delegate( selector, eventName, handlerProxy );
716 } else {
717 element.bind( eventName, handlerProxy );
718 }
719 });
720 },
721
722 _off: function( element, eventName ) {
723 eventName = (eventName || "").split( " " ).join( this.eventNamespace + " " ) + this.eventNamespace;
724 element.unbind( eventName ).undelegate( eventName );
725 },
726
727 _delay: function( handler, delay ) {
728 function handlerProxy() {
729 return ( typeof handler === "string" ? instance[ handler ] : handler )
730 .apply( instance, arguments );
731 }
732 var instance = this;
733 return setTimeout( handlerProxy, delay || 0 );
734 },
735
736 _hoverable: function( element ) {
737 this.hoverable = this.hoverable.add( element );
738 this._on( element, {
739 mouseenter: function( event ) {
740 $( event.currentTarget ).addClass( "ui-state-hover" );
741 },
742 mouseleave: function( event ) {
743 $( event.currentTarget ).removeClass( "ui-state-hover" );
744 }
745 });
746 },
747
748 _focusable: function( element ) {
749 this.focusable = this.focusable.add( element );
750 this._on( element, {
751 focusin: function( event ) {
752 $( event.currentTarget ).addClass( "ui-state-focus" );
753 },
754 focusout: function( event ) {
755 $( event.currentTarget ).removeClass( "ui-state-focus" );
756 }
757 });
758 },
759
760 _trigger: function( type, event, data ) {
761 var prop, orig,
762 callback = this.options[ type ];
763
764 data = data || {};
765 event = $.Event( event );
766 event.type = ( type === this.widgetEventPrefix ?
767 type :
768 this.widgetEventPrefix + type ).toLowerCase();
769 // the original event may come from any element
770 // so we need to reset the target on the new event
771 event.target = this.element[ 0 ];
772
773 // copy original event properties over to the new event
774 orig = event.originalEvent;
775 if ( orig ) {
776 for ( prop in orig ) {
777 if ( !( prop in event ) ) {
778 event[ prop ] = orig[ prop ];
779 }
780 }
781 }
782
783 this.element.trigger( event, data );
784 return !( $.isFunction( callback ) &&
785 callback.apply( this.element[0], [ event ].concat( data ) ) === false ||
786 event.isDefaultPrevented() );
787 }
788 };
789
790 $.each( { show: "fadeIn", hide: "fadeOut" }, function( method, defaultEffect ) {
791 $.Widget.prototype[ "_" + method ] = function( element, options, callback ) {
792 if ( typeof options === "string" ) {
793 options = { effect: options };
794 }
795 var hasOptions,
796 effectName = !options ?
797 method :
798 options === true || typeof options === "number" ?
799 defaultEffect :
800 options.effect || defaultEffect;
801 options = options || {};
802 if ( typeof options === "number" ) {
803 options = { duration: options };
804 }
805 hasOptions = !$.isEmptyObject( options );
806 options.complete = callback;
807 if ( options.delay ) {
808 element.delay( options.delay );
809 }
810 if ( hasOptions && $.effects && $.effects.effect[ effectName ] ) {
811 element[ method ]( options );
812 } else if ( effectName !== method && element[ effectName ] ) {
813 element[ effectName ]( options.duration, options.easing, callback );
814 } else {
815 element.queue(function( next ) {
816 $( this )[ method ]();
817 if ( callback ) {
818 callback.call( element[ 0 ] );
819 }
820 next();
821 });
822 }
823 };
824 });
825
826 })( jQuery );
827 (function( $, undefined ) {
828
829 var mouseHandled = false;
830 $( document ).mouseup( function() {
831 mouseHandled = false;
832 });
833
834 $.widget("ui.mouse", {
835 version: "1.10.4",
836 options: {
837 cancel: "input,textarea,button,select,option",
838 distance: 1,
839 delay: 0
840 },
841 _mouseInit: function() {
842 var that = this;
843
844 this.element
845 .bind("mousedown."+this.widgetName, function(event) {
846 return that._mouseDown(event);
847 })
848 .bind("click."+this.widgetName, function(event) {
849 if (true === $.data(event.target, that.widgetName + ".preventClickEvent")) {
850 $.removeData(event.target, that.widgetName + ".preventClickEvent");
851 event.stopImmediatePropagation();
852 return false;
853 }
854 });
855
856 this.started = false;
857 },
858
859 // TODO: make sure destroying one instance of mouse doesn't mess with
860 // other instances of mouse
861 _mouseDestroy: function() {
862 this.element.unbind("."+this.widgetName);
863 if ( this._mouseMoveDelegate ) {
864 $(document)
865 .unbind("mousemove."+this.widgetName, this._mouseMoveDelegate)
866 .unbind("mouseup."+this.widgetName, this._mouseUpDelegate);
867 }
868 },
869
870 _mouseDown: function(event) {
871 // don't let more than one widget handle mouseStart
872 if( mouseHandled ) { return; }
873
874 // we may have missed mouseup (out of window)
875 (this._mouseStarted && this._mouseUp(event));
876
877 this._mouseDownEvent = event;
878
879 var that = this,
880 btnIsLeft = (event.which === 1),
881 // event.target.nodeName works around a bug in IE 8 with
882 // disabled inputs (#7620)
883 elIsCancel = (typeof this.options.cancel === "string" && event.target.nodeName ? $(event.target).closest(this.options.cancel).length : false);
884 if (!btnIsLeft || elIsCancel || !this._mouseCapture(event)) {
885 return true;
886 }
887
888 this.mouseDelayMet = !this.options.delay;
889 if (!this.mouseDelayMet) {
890 this._mouseDelayTimer = setTimeout(function() {
891 that.mouseDelayMet = true;
892 }, this.options.delay);
893 }
894
895 if (this._mouseDistanceMet(event) && this._mouseDelayMet(event)) {
896 this._mouseStarted = (this._mouseStart(event) !== false);
897 if (!this._mouseStarted) {
898 event.preventDefault();
899 return true;
900 }
901 }
902
903 // Click event may never have fired (Gecko & Opera)
904 if (true === $.data(event.target, this.widgetName + ".preventClickEvent")) {
905 $.removeData(event.target, this.widgetName + ".preventClickEvent");
906 }
907
908 // these delegates are required to keep context
909 this._mouseMoveDelegate = function(event) {
910 return that._mouseMove(event);
911 };
912 this._mouseUpDelegate = function(event) {
913 return that._mouseUp(event);
914 };
915 $(document)
916 .bind("mousemove."+this.widgetName, this._mouseMoveDelegate)
917 .bind("mouseup."+this.widgetName, this._mouseUpDelegate);
918
919 event.preventDefault();
920
921 mouseHandled = true;
922 return true;
923 },
924
925 _mouseMove: function(event) {
926 // IE mouseup check - mouseup happened when mouse was out of window
927 if ($.ui.ie && ( !document.documentMode || document.documentMode < 9 ) && !event.button) {
928 return this._mouseUp(event);
929 }
930
931 if (this._mouseStarted) {
932 this._mouseDrag(event);
933 return event.preventDefault();
934 }
935
936 if (this._mouseDistanceMet(event) && this._mouseDelayMet(event)) {
937 this._mouseStarted =
938 (this._mouseStart(this._mouseDownEvent, event) !== false);
939 (this._mouseStarted ? this._mouseDrag(event) : this._mouseUp(event));
940 }
941
942 return !this._mouseStarted;
943 },
944
945 _mouseUp: function(event) {
946 $(document)
947 .unbind("mousemove."+this.widgetName, this._mouseMoveDelegate)
948 .unbind("mouseup."+this.widgetName, this._mouseUpDelegate);
949
950 if (this._mouseStarted) {
951 this._mouseStarted = false;
952
953 if (event.target === this._mouseDownEvent.target) {
954 $.data(event.target, this.widgetName + ".preventClickEvent", true);
955 }
956
957 this._mouseStop(event);
958 }
959
960 return false;
961 },
962
963 _mouseDistanceMet: function(event) {
964 return (Math.max(
965 Math.abs(this._mouseDownEvent.pageX - event.pageX),
966 Math.abs(this._mouseDownEvent.pageY - event.pageY)
967 ) >= this.options.distance
968 );
969 },
970
971 _mouseDelayMet: function(/* event */) {
972 return this.mouseDelayMet;
973 },
974
975 // These are placeholder methods, to be overriden by extending plugin
976 _mouseStart: function(/* event */) {},
977 _mouseDrag: function(/* event */) {},
978 _mouseStop: function(/* event */) {},
979 _mouseCapture: function(/* event */) { return true; }
980 });
981
982 })(jQuery);
983 (function( $, undefined ) {
984
985 $.ui = $.ui || {};
986
987 var cachedScrollbarWidth,
988 max = Math.max,
989 abs = Math.abs,
990 round = Math.round,
991 rhorizontal = /left|center|right/,
992 rvertical = /top|center|bottom/,
993 roffset = /[\+\-]\d+(\.[\d]+)?%?/,
994 rposition = /^\w+/,
995 rpercent = /%$/,
996 _position = $.fn.position;
997
998 function getOffsets( offsets, width, height ) {
999 return [
1000 parseFloat( offsets[ 0 ] ) * ( rpercent.test( offsets[ 0 ] ) ? width / 100 : 1 ),
1001 parseFloat( offsets[ 1 ] ) * ( rpercent.test( offsets[ 1 ] ) ? height / 100 : 1 )
1002 ];
1003 }
1004
1005 function parseCss( element, property ) {
1006 return parseInt( $.css( element, property ), 10 ) || 0;
1007 }
1008
1009 function getDimensions( elem ) {
1010 var raw = elem[0];
1011 if ( raw.nodeType === 9 ) {
1012 return {
1013 width: elem.width(),
1014 height: elem.height(),
1015 offset: { top: 0, left: 0 }
1016 };
1017 }
1018 if ( $.isWindow( raw ) ) {
1019 return {
1020 width: elem.width(),
1021 height: elem.height(),
1022 offset: { top: elem.scrollTop(), left: elem.scrollLeft() }
1023 };
1024 }
1025 if ( raw.preventDefault ) {
1026 return {
1027 width: 0,
1028 height: 0,
1029 offset: { top: raw.pageY, left: raw.pageX }
1030 };
1031 }
1032 return {
1033 width: elem.outerWidth(),
1034 height: elem.outerHeight(),
1035 offset: elem.offset()
1036 };
1037 }
1038
1039 $.position = {
1040 scrollbarWidth: function() {
1041 if ( cachedScrollbarWidth !== undefined ) {
1042 return cachedScrollbarWidth;
1043 }
1044 var w1, w2,
1045 div = $( "<div style='display:block;position:absolute;width:50px;height:50px;overflow:hidden;'><div style='height:100px;width:auto;'></div></div>" ),
1046 innerDiv = div.children()[0];
1047
1048 $( "body" ).append( div );
1049 w1 = innerDiv.offsetWidth;
1050 div.css( "overflow", "scroll" );
1051
1052 w2 = innerDiv.offsetWidth;
1053
1054 if ( w1 === w2 ) {
1055 w2 = div[0].clientWidth;
1056 }
1057
1058 div.remove();
1059
1060 return (cachedScrollbarWidth = w1 - w2);
1061 },
1062 getScrollInfo: function( within ) {
1063 var overflowX = within.isWindow || within.isDocument ? "" :
1064 within.element.css( "overflow-x" ),
1065 overflowY = within.isWindow || within.isDocument ? "" :
1066 within.element.css( "overflow-y" ),
1067 hasOverflowX = overflowX === "scroll" ||
1068 ( overflowX === "auto" && within.width < within.element[0].scrollWidth ),
1069 hasOverflowY = overflowY === "scroll" ||
1070 ( overflowY === "auto" && within.height < within.element[0].scrollHeight );
1071 return {
1072 width: hasOverflowY ? $.position.scrollbarWidth() : 0,
1073 height: hasOverflowX ? $.position.scrollbarWidth() : 0
1074 };
1075 },
1076 getWithinInfo: function( element ) {
1077 var withinElement = $( element || window ),
1078 isWindow = $.isWindow( withinElement[0] ),
1079 isDocument = !!withinElement[ 0 ] && withinElement[ 0 ].nodeType === 9;
1080 return {
1081 element: withinElement,
1082 isWindow: isWindow,
1083 isDocument: isDocument,
1084 offset: withinElement.offset() || { left: 0, top: 0 },
1085 scrollLeft: withinElement.scrollLeft(),
1086 scrollTop: withinElement.scrollTop(),
1087 width: isWindow ? withinElement.width() : withinElement.outerWidth(),
1088 height: isWindow ? withinElement.height() : withinElement.outerHeight()
1089 };
1090 }
1091 };
1092
1093 $.fn.position = function( options ) {
1094 if ( !options || !options.of ) {
1095 return _position.apply( this, arguments );
1096 }
1097
1098 // make a copy, we don't want to modify arguments
1099 options = $.extend( {}, options );
1100
1101 var atOffset, targetWidth, targetHeight, targetOffset, basePosition, dimensions,
1102 target = $( options.of ),
1103 within = $.position.getWithinInfo( options.within ),
1104 scrollInfo = $.position.getScrollInfo( within ),
1105 collision = ( options.collision || "flip" ).split( " " ),
1106 offsets = {};
1107
1108 dimensions = getDimensions( target );
1109 if ( target[0].preventDefault ) {
1110 // force left top to allow flipping
1111 options.at = "left top";
1112 }
1113 targetWidth = dimensions.width;
1114 targetHeight = dimensions.height;
1115 targetOffset = dimensions.offset;
1116 // clone to reuse original targetOffset later
1117 basePosition = $.extend( {}, targetOffset );
1118
1119 // force my and at to have valid horizontal and vertical positions
1120 // if a value is missing or invalid, it will be converted to center
1121 $.each( [ "my", "at" ], function() {
1122 var pos = ( options[ this ] || "" ).split( " " ),
1123 horizontalOffset,
1124 verticalOffset;
1125
1126 if ( pos.length === 1) {
1127 pos = rhorizontal.test( pos[ 0 ] ) ?
1128 pos.concat( [ "center" ] ) :
1129 rvertical.test( pos[ 0 ] ) ?
1130 [ "center" ].concat( pos ) :
1131 [ "center", "center" ];
1132 }
1133 pos[ 0 ] = rhorizontal.test( pos[ 0 ] ) ? pos[ 0 ] : "center";
1134 pos[ 1 ] = rvertical.test( pos[ 1 ] ) ? pos[ 1 ] : "center";
1135
1136 // calculate offsets
1137 horizontalOffset = roffset.exec( pos[ 0 ] );
1138 verticalOffset = roffset.exec( pos[ 1 ] );
1139 offsets[ this ] = [
1140 horizontalOffset ? horizontalOffset[ 0 ] : 0,
1141 verticalOffset ? verticalOffset[ 0 ] : 0
1142 ];
1143
1144 // reduce to just the positions without the offsets
1145 options[ this ] = [
1146 rposition.exec( pos[ 0 ] )[ 0 ],
1147 rposition.exec( pos[ 1 ] )[ 0 ]
1148 ];
1149 });
1150
1151 // normalize collision option
1152 if ( collision.length === 1 ) {
1153 collision[ 1 ] = collision[ 0 ];
1154 }
1155
1156 if ( options.at[ 0 ] === "right" ) {
1157 basePosition.left += targetWidth;
1158 } else if ( options.at[ 0 ] === "center" ) {
1159 basePosition.left += targetWidth / 2;
1160 }
1161
1162 if ( options.at[ 1 ] === "bottom" ) {
1163 basePosition.top += targetHeight;
1164 } else if ( options.at[ 1 ] === "center" ) {
1165 basePosition.top += targetHeight / 2;
1166 }
1167
1168 atOffset = getOffsets( offsets.at, targetWidth, targetHeight );
1169 basePosition.left += atOffset[ 0 ];
1170 basePosition.top += atOffset[ 1 ];
1171
1172 return this.each(function() {
1173 var collisionPosition, using,
1174 elem = $( this ),
1175 elemWidth = elem.outerWidth(),
1176 elemHeight = elem.outerHeight(),
1177 marginLeft = parseCss( this, "marginLeft" ),
1178 marginTop = parseCss( this, "marginTop" ),
1179 collisionWidth = elemWidth + marginLeft + parseCss( this, "marginRight" ) + scrollInfo.width,
1180 collisionHeight = elemHeight + marginTop + parseCss( this, "marginBottom" ) + scrollInfo.height,
1181 position = $.extend( {}, basePosition ),
1182 myOffset = getOffsets( offsets.my, elem.outerWidth(), elem.outerHeight() );
1183
1184 if ( options.my[ 0 ] === "right" ) {
1185 position.left -= elemWidth;
1186 } else if ( options.my[ 0 ] === "center" ) {
1187 position.left -= elemWidth / 2;
1188 }
1189
1190 if ( options.my[ 1 ] === "bottom" ) {
1191 position.top -= elemHeight;
1192 } else if ( options.my[ 1 ] === "center" ) {
1193 position.top -= elemHeight / 2;
1194 }
1195
1196 position.left += myOffset[ 0 ];
1197 position.top += myOffset[ 1 ];
1198
1199 // if the browser doesn't support fractions, then round for consistent results
1200 if ( !$.support.offsetFractions ) {
1201 position.left = round( position.left );
1202 position.top = round( position.top );
1203 }
1204
1205 collisionPosition = {
1206 marginLeft: marginLeft,
1207 marginTop: marginTop
1208 };
1209
1210 $.each( [ "left", "top" ], function( i, dir ) {
1211 if ( $.ui.position[ collision[ i ] ] ) {
1212 $.ui.position[ collision[ i ] ][ dir ]( position, {
1213 targetWidth: targetWidth,
1214 targetHeight: targetHeight,
1215 elemWidth: elemWidth,
1216 elemHeight: elemHeight,
1217 collisionPosition: collisionPosition,
1218 collisionWidth: collisionWidth,
1219 collisionHeight: collisionHeight,
1220 offset: [ atOffset[ 0 ] + myOffset[ 0 ], atOffset [ 1 ] + myOffset[ 1 ] ],
1221 my: options.my,
1222 at: options.at,
1223 within: within,
1224 elem : elem
1225 });
1226 }
1227 });
1228
1229 if ( options.using ) {
1230 // adds feedback as second argument to using callback, if present
1231 using = function( props ) {
1232 var left = targetOffset.left - position.left,
1233 right = left + targetWidth - elemWidth,
1234 top = targetOffset.top - position.top,
1235 bottom = top + targetHeight - elemHeight,
1236 feedback = {
1237 target: {
1238 element: target,
1239 left: targetOffset.left,
1240 top: targetOffset.top,
1241 width: targetWidth,
1242 height: targetHeight
1243 },
1244 element: {
1245 element: elem,
1246 left: position.left,
1247 top: position.top,
1248 width: elemWidth,
1249 height: elemHeight
1250 },
1251 horizontal: right < 0 ? "left" : left > 0 ? "right" : "center",
1252 vertical: bottom < 0 ? "top" : top > 0 ? "bottom" : "middle"
1253 };
1254 if ( targetWidth < elemWidth && abs( left + right ) < targetWidth ) {
1255 feedback.horizontal = "center";
1256 }
1257 if ( targetHeight < elemHeight && abs( top + bottom ) < targetHeight ) {
1258 feedback.vertical = "middle";
1259 }
1260 if ( max( abs( left ), abs( right ) ) > max( abs( top ), abs( bottom ) ) ) {
1261 feedback.important = "horizontal";
1262 } else {
1263 feedback.important = "vertical";
1264 }
1265 options.using.call( this, props, feedback );
1266 };
1267 }
1268
1269 elem.offset( $.extend( position, { using: using } ) );
1270 });
1271 };
1272
1273 $.ui.position = {
1274 fit: {
1275 left: function( position, data ) {
1276 var within = data.within,
1277 withinOffset = within.isWindow ? within.scrollLeft : within.offset.left,
1278 outerWidth = within.width,
1279 collisionPosLeft = position.left - data.collisionPosition.marginLeft,
1280 overLeft = withinOffset - collisionPosLeft,
1281 overRight = collisionPosLeft + data.collisionWidth - outerWidth - withinOffset,
1282 newOverRight;
1283
1284 // element is wider than within
1285 if ( data.collisionWidth > outerWidth ) {
1286 // element is initially over the left side of within
1287 if ( overLeft > 0 && overRight <= 0 ) {
1288 newOverRight = position.left + overLeft + data.collisionWidth - outerWidth - withinOffset;
1289 position.left += overLeft - newOverRight;
1290 // element is initially over right side of within
1291 } else if ( overRight > 0 && overLeft <= 0 ) {
1292 position.left = withinOffset;
1293 // element is initially over both left and right sides of within
1294 } else {
1295 if ( overLeft > overRight ) {
1296 position.left = withinOffset + outerWidth - data.collisionWidth;
1297 } else {
1298 position.left = withinOffset;
1299 }
1300 }
1301 // too far left -> align with left edge
1302 } else if ( overLeft > 0 ) {
1303 position.left += overLeft;
1304 // too far right -> align with right edge
1305 } else if ( overRight > 0 ) {
1306 position.left -= overRight;
1307 // adjust based on position and margin
1308 } else {
1309 position.left = max( position.left - collisionPosLeft, position.left );
1310 }
1311 },
1312 top: function( position, data ) {
1313 var within = data.within,
1314 withinOffset = within.isWindow ? within.scrollTop : within.offset.top,
1315 outerHeight = data.within.height,
1316 collisionPosTop = position.top - data.collisionPosition.marginTop,
1317 overTop = withinOffset - collisionPosTop,
1318 overBottom = collisionPosTop + data.collisionHeight - outerHeight - withinOffset,
1319 newOverBottom;
1320
1321 // element is taller than within
1322 if ( data.collisionHeight > outerHeight ) {
1323 // element is initially over the top of within
1324 if ( overTop > 0 && overBottom <= 0 ) {
1325 newOverBottom = position.top + overTop + data.collisionHeight - outerHeight - withinOffset;
1326 position.top += overTop - newOverBottom;
1327 // element is initially over bottom of within
1328 } else if ( overBottom > 0 && overTop <= 0 ) {
1329 position.top = withinOffset;
1330 // element is initially over both top and bottom of within
1331 } else {
1332 if ( overTop > overBottom ) {
1333 position.top = withinOffset + outerHeight - data.collisionHeight;
1334 } else {
1335 position.top = withinOffset;
1336 }
1337 }
1338 // too far up -> align with top
1339 } else if ( overTop > 0 ) {
1340 position.top += overTop;
1341 // too far down -> align with bottom edge
1342 } else if ( overBottom > 0 ) {
1343 position.top -= overBottom;
1344 // adjust based on position and margin
1345 } else {
1346 position.top = max( position.top - collisionPosTop, position.top );
1347 }
1348 }
1349 },
1350 flip: {
1351 left: function( position, data ) {
1352 var within = data.within,
1353 withinOffset = within.offset.left + within.scrollLeft,
1354 outerWidth = within.width,
1355 offsetLeft = within.isWindow ? within.scrollLeft : within.offset.left,
1356 collisionPosLeft = position.left - data.collisionPosition.marginLeft,
1357 overLeft = collisionPosLeft - offsetLeft,
1358 overRight = collisionPosLeft + data.collisionWidth - outerWidth - offsetLeft,
1359 myOffset = data.my[ 0 ] === "left" ?
1360 -data.elemWidth :
1361 data.my[ 0 ] === "right" ?
1362 data.elemWidth :
1363 0,
1364 atOffset = data.at[ 0 ] === "left" ?
1365 data.targetWidth :
1366 data.at[ 0 ] === "right" ?
1367 -data.targetWidth :
1368 0,
1369 offset = -2 * data.offset[ 0 ],
1370 newOverRight,
1371 newOverLeft;
1372
1373 if ( overLeft < 0 ) {
1374 newOverRight = position.left + myOffset + atOffset + offset + data.collisionWidth - outerWidth - withinOffset;
1375 if ( newOverRight < 0 || newOverRight < abs( overLeft ) ) {
1376 position.left += myOffset + atOffset + offset;
1377 }
1378 }
1379 else if ( overRight > 0 ) {
1380 newOverLeft = position.left - data.collisionPosition.marginLeft + myOffset + atOffset + offset - offsetLeft;
1381 if ( newOverLeft > 0 || abs( newOverLeft ) < overRight ) {
1382 position.left += myOffset + atOffset + offset;
1383 }
1384 }
1385 },
1386 top: function( position, data ) {
1387 var within = data.within,
1388 withinOffset = within.offset.top + within.scrollTop,
1389 outerHeight = within.height,
1390 offsetTop = within.isWindow ? within.scrollTop : within.offset.top,
1391 collisionPosTop = position.top - data.collisionPosition.marginTop,
1392 overTop = collisionPosTop - offsetTop,
1393 overBottom = collisionPosTop + data.collisionHeight - outerHeight - offsetTop,
1394 top = data.my[ 1 ] === "top",
1395 myOffset = top ?
1396 -data.elemHeight :
1397 data.my[ 1 ] === "bottom" ?
1398 data.elemHeight :
1399 0,
1400 atOffset = data.at[ 1 ] === "top" ?
1401 data.targetHeight :
1402 data.at[ 1 ] === "bottom" ?
1403 -data.targetHeight :
1404 0,
1405 offset = -2 * data.offset[ 1 ],
1406 newOverTop,
1407 newOverBottom;
1408 if ( overTop < 0 ) {
1409 newOverBottom = position.top + myOffset + atOffset + offset + data.collisionHeight - outerHeight - withinOffset;
1410 if ( ( position.top + myOffset + atOffset + offset) > overTop && ( newOverBottom < 0 || newOverBottom < abs( overTop ) ) ) {
1411 position.top += myOffset + atOffset + offset;
1412 }
1413 }
1414 else if ( overBottom > 0 ) {
1415 newOverTop = position.top - data.collisionPosition.marginTop + myOffset + atOffset + offset - offsetTop;
1416 if ( ( position.top + myOffset + atOffset + offset) > overBottom && ( newOverTop > 0 || abs( newOverTop ) < overBottom ) ) {
1417 position.top += myOffset + atOffset + offset;
1418 }
1419 }
1420 }
1421 },
1422 flipfit: {
1423 left: function() {
1424 $.ui.position.flip.left.apply( this, arguments );
1425 $.ui.position.fit.left.apply( this, arguments );
1426 },
1427 top: function() {
1428 $.ui.position.flip.top.apply( this, arguments );
1429 $.ui.position.fit.top.apply( this, arguments );
1430 }
1431 }
1432 };
1433
1434 // fraction support test
1435 (function () {
1436 var testElement, testElementParent, testElementStyle, offsetLeft, i,
1437 body = document.getElementsByTagName( "body" )[ 0 ],
1438 div = document.createElement( "div" );
1439
1440 //Create a "fake body" for testing based on method used in jQuery.support
1441 testElement = document.createElement( body ? "div" : "body" );
1442 testElementStyle = {
1443 visibility: "hidden",
1444 width: 0,
1445 height: 0,
1446 border: 0,
1447 margin: 0,
1448 background: "none"
1449 };
1450 if ( body ) {
1451 $.extend( testElementStyle, {
1452 position: "absolute",
1453 left: "-1000px",
1454 top: "-1000px"
1455 });
1456 }
1457 for ( i in testElementStyle ) {
1458 testElement.style[ i ] = testElementStyle[ i ];
1459 }
1460 testElement.appendChild( div );
1461 testElementParent = body || document.documentElement;
1462 testElementParent.insertBefore( testElement, testElementParent.firstChild );
1463
1464 div.style.cssText = "position: absolute; left: 10.7432222px;";
1465
1466 offsetLeft = $( div ).offset().left;
1467 $.support.offsetFractions = offsetLeft > 10 && offsetLeft < 11;
1468
1469 testElement.innerHTML = "";
1470 testElementParent.removeChild( testElement );
1471 })();
1472
1473 }( jQuery ) );
1474 (function( $, undefined ) {
1475
1476 var uid = 0,
1477 hideProps = {},
1478 showProps = {};
1479
1480 hideProps.height = hideProps.paddingTop = hideProps.paddingBottom =
1481 hideProps.borderTopWidth = hideProps.borderBottomWidth = "hide";
1482 showProps.height = showProps.paddingTop = showProps.paddingBottom =
1483 showProps.borderTopWidth = showProps.borderBottomWidth = "show";
1484
1485 $.widget( "ui.accordion", {
1486 version: "1.10.4",
1487 options: {
1488 active: 0,
1489 animate: {},
1490 collapsible: false,
1491 event: "click",
1492 header: "> li > :first-child,> :not(li):even",
1493 heightStyle: "auto",
1494 icons: {
1495 activeHeader: "ui-icon-triangle-1-s",
1496 header: "ui-icon-triangle-1-e"
1497 },
1498
1499 // callbacks
1500 activate: null,
1501 beforeActivate: null
1502 },
1503
1504 _create: function() {
1505 var options = this.options;
1506 this.prevShow = this.prevHide = $();
1507 this.element.addClass( "ui-accordion ui-widget ui-helper-reset" )
1508 // ARIA
1509 .attr( "role", "tablist" );
1510
1511 // don't allow collapsible: false and active: false / null
1512 if ( !options.collapsible && (options.active === false || options.active == null) ) {
1513 options.active = 0;
1514 }
1515
1516 this._processPanels();
1517 // handle negative values
1518 if ( options.active < 0 ) {
1519 options.active += this.headers.length;
1520 }
1521 this._refresh();
1522 },
1523
1524 _getCreateEventData: function() {
1525 return {
1526 header: this.active,
1527 panel: !this.active.length ? $() : this.active.next(),
1528 content: !this.active.length ? $() : this.active.next()
1529 };
1530 },
1531
1532 _createIcons: function() {
1533 var icons = this.options.icons;
1534 if ( icons ) {
1535 $( "<span>" )
1536 .addClass( "ui-accordion-header-icon ui-icon " + icons.header )
1537 .prependTo( this.headers );
1538 this.active.children( ".ui-accordion-header-icon" )
1539 .removeClass( icons.header )
1540 .addClass( icons.activeHeader );
1541 this.headers.addClass( "ui-accordion-icons" );
1542 }
1543 },
1544
1545 _destroyIcons: function() {
1546 this.headers
1547 .removeClass( "ui-accordion-icons" )
1548 .children( ".ui-accordion-header-icon" )
1549 .remove();
1550 },
1551
1552 _destroy: function() {
1553 var contents;
1554
1555 // clean up main element
1556 this.element
1557 .removeClass( "ui-accordion ui-widget ui-helper-reset" )
1558 .removeAttr( "role" );
1559
1560 // clean up headers
1561 this.headers
1562 .removeClass( "ui-accordion-header ui-accordion-header-active ui-helper-reset ui-state-default ui-corner-all ui-state-active ui-state-disabled ui-corner-top" )
1563 .removeAttr( "role" )
1564 .removeAttr( "aria-expanded" )
1565 .removeAttr( "aria-selected" )
1566 .removeAttr( "aria-controls" )
1567 .removeAttr( "tabIndex" )
1568 .each(function() {
1569 if ( /^ui-accordion/.test( this.id ) ) {
1570 this.removeAttribute( "id" );
1571 }
1572 });
1573 this._destroyIcons();
1574
1575 // clean up content panels
1576 contents = this.headers.next()
1577 .css( "display", "" )
1578 .removeAttr( "role" )
1579 .removeAttr( "aria-hidden" )
1580 .removeAttr( "aria-labelledby" )
1581 .removeClass( "ui-helper-reset ui-widget-content ui-corner-bottom ui-accordion-content ui-accordion-content-active ui-state-disabled" )
1582 .each(function() {
1583 if ( /^ui-accordion/.test( this.id ) ) {
1584 this.removeAttribute( "id" );
1585 }
1586 });
1587 if ( this.options.heightStyle !== "content" ) {
1588 contents.css( "height", "" );
1589 }
1590 },
1591
1592 _setOption: function( key, value ) {
1593 if ( key === "active" ) {
1594 // _activate() will handle invalid values and update this.options
1595 this._activate( value );
1596 return;
1597 }
1598
1599 if ( key === "event" ) {
1600 if ( this.options.event ) {
1601 this._off( this.headers, this.options.event );
1602 }
1603 this._setupEvents( value );
1604 }
1605
1606 this._super( key, value );
1607
1608 // setting collapsible: false while collapsed; open first panel
1609 if ( key === "collapsible" && !value && this.options.active === false ) {
1610 this._activate( 0 );
1611 }
1612
1613 if ( key === "icons" ) {
1614 this._destroyIcons();
1615 if ( value ) {
1616 this._createIcons();
1617 }
1618 }
1619
1620 // #5332 - opacity doesn't cascade to positioned elements in IE
1621 // so we need to add the disabled class to the headers and panels
1622 if ( key === "disabled" ) {
1623 this.headers.add( this.headers.next() )
1624 .toggleClass( "ui-state-disabled", !!value );
1625 }
1626 },
1627
1628 _keydown: function( event ) {
1629 if ( event.altKey || event.ctrlKey ) {
1630 return;
1631 }
1632
1633 var keyCode = $.ui.keyCode,
1634 length = this.headers.length,
1635 currentIndex = this.headers.index( event.target ),
1636 toFocus = false;
1637
1638 switch ( event.keyCode ) {
1639 case keyCode.RIGHT:
1640 case keyCode.DOWN:
1641 toFocus = this.headers[ ( currentIndex + 1 ) % length ];
1642 break;
1643 case keyCode.LEFT:
1644 case keyCode.UP:
1645 toFocus = this.headers[ ( currentIndex - 1 + length ) % length ];
1646 break;
1647 case keyCode.SPACE:
1648 case keyCode.ENTER:
1649 this._eventHandler( event );
1650 break;
1651 case keyCode.HOME:
1652 toFocus = this.headers[ 0 ];
1653 break;
1654 case keyCode.END:
1655 toFocus = this.headers[ length - 1 ];
1656 break;
1657 }
1658
1659 if ( toFocus ) {
1660 $( event.target ).attr( "tabIndex", -1 );
1661 $( toFocus ).attr( "tabIndex", 0 );
1662 toFocus.focus();
1663 event.preventDefault();
1664 }
1665 },
1666
1667 _panelKeyDown : function( event ) {
1668 if ( event.keyCode === $.ui.keyCode.UP && event.ctrlKey ) {
1669 $( event.currentTarget ).prev().focus();
1670 }
1671 },
1672
1673 refresh: function() {
1674 var options = this.options;
1675 this._processPanels();
1676
1677 // was collapsed or no panel
1678 if ( ( options.active === false && options.collapsible === true ) || !this.headers.length ) {
1679 options.active = false;
1680 this.active = $();
1681 // active false only when collapsible is true
1682 } else if ( options.active === false ) {
1683 this._activate( 0 );
1684 // was active, but active panel is gone
1685 } else if ( this.active.length && !$.contains( this.element[ 0 ], this.active[ 0 ] ) ) {
1686 // all remaining panel are disabled
1687 if ( this.headers.length === this.headers.find(".ui-state-disabled").length ) {
1688 options.active = false;
1689 this.active = $();
1690 // activate previous panel
1691 } else {
1692 this._activate( Math.max( 0, options.active - 1 ) );
1693 }
1694 // was active, active panel still exists
1695 } else {
1696 // make sure active index is correct
1697 options.active = this.headers.index( this.active );
1698 }
1699
1700 this._destroyIcons();
1701
1702 this._refresh();
1703 },
1704
1705 _processPanels: function() {
1706 this.headers = this.element.find( this.options.header )
1707 .addClass( "ui-accordion-header ui-helper-reset ui-state-default ui-corner-all" );
1708
1709 this.headers.next()
1710 .addClass( "ui-accordion-content ui-helper-reset ui-widget-content ui-corner-bottom" )
1711 .filter(":not(.ui-accordion-content-active)")
1712 .hide();
1713 },
1714
1715 _refresh: function() {
1716 var maxHeight,
1717 options = this.options,
1718 heightStyle = options.heightStyle,
1719 parent = this.element.parent(),
1720 accordionId = this.accordionId = "ui-accordion-" +
1721 (this.element.attr( "id" ) || ++uid);
1722
1723 this.active = this._findActive( options.active )
1724 .addClass( "ui-accordion-header-active ui-state-active ui-corner-top" )
1725 .removeClass( "ui-corner-all" );
1726 this.active.next()
1727 .addClass( "ui-accordion-content-active" )
1728 .show();
1729
1730 this.headers
1731 .attr( "role", "tab" )
1732 .each(function( i ) {
1733 var header = $( this ),
1734 headerId = header.attr( "id" ),
1735 panel = header.next(),
1736 panelId = panel.attr( "id" );
1737 if ( !headerId ) {
1738 headerId = accordionId + "-header-" + i;
1739 header.attr( "id", headerId );
1740 }
1741 if ( !panelId ) {
1742 panelId = accordionId + "-panel-" + i;
1743 panel.attr( "id", panelId );
1744 }
1745 header.attr( "aria-controls", panelId );
1746 panel.attr( "aria-labelledby", headerId );
1747 })
1748 .next()
1749 .attr( "role", "tabpanel" );
1750
1751 this.headers
1752 .not( this.active )
1753 .attr({
1754 "aria-selected": "false",
1755 "aria-expanded": "false",
1756 tabIndex: -1
1757 })
1758 .next()
1759 .attr({
1760 "aria-hidden": "true"
1761 })
1762 .hide();
1763
1764 // make sure at least one header is in the tab order
1765 if ( !this.active.length ) {
1766 this.headers.eq( 0 ).attr( "tabIndex", 0 );
1767 } else {
1768 this.active.attr({
1769 "aria-selected": "true",
1770 "aria-expanded": "true",
1771 tabIndex: 0
1772 })
1773 .next()
1774 .attr({
1775 "aria-hidden": "false"
1776 });
1777 }
1778
1779 this._createIcons();
1780
1781 this._setupEvents( options.event );
1782
1783 if ( heightStyle === "fill" ) {
1784 maxHeight = parent.height();
1785 this.element.siblings( ":visible" ).each(function() {
1786 var elem = $( this ),
1787 position = elem.css( "position" );
1788
1789 if ( position === "absolute" || position === "fixed" ) {
1790 return;
1791 }
1792 maxHeight -= elem.outerHeight( true );
1793 });
1794
1795 this.headers.each(function() {
1796 maxHeight -= $( this ).outerHeight( true );
1797 });
1798
1799 this.headers.next()
1800 .each(function() {
1801 $( this ).height( Math.max( 0, maxHeight -
1802 $( this ).innerHeight() + $( this ).height() ) );
1803 })
1804 .css( "overflow", "auto" );
1805 } else if ( heightStyle === "auto" ) {
1806 maxHeight = 0;
1807 this.headers.next()
1808 .each(function() {
1809 maxHeight = Math.max( maxHeight, $( this ).css( "height", "" ).height() );
1810 })
1811 .height( maxHeight );
1812 }
1813 },
1814
1815 _activate: function( index ) {
1816 var active = this._findActive( index )[ 0 ];
1817
1818 // trying to activate the already active panel
1819 if ( active === this.active[ 0 ] ) {
1820 return;
1821 }
1822
1823 // trying to collapse, simulate a click on the currently active header
1824 active = active || this.active[ 0 ];
1825
1826 this._eventHandler({
1827 target: active,
1828 currentTarget: active,
1829 preventDefault: $.noop
1830 });
1831 },
1832
1833 _findActive: function( selector ) {
1834 return typeof selector === "number" ? this.headers.eq( selector ) : $();
1835 },
1836
1837 _setupEvents: function( event ) {
1838 var events = {
1839 keydown: "_keydown"
1840 };
1841 if ( event ) {
1842 $.each( event.split(" "), function( index, eventName ) {
1843 events[ eventName ] = "_eventHandler";
1844 });
1845 }
1846
1847 this._off( this.headers.add( this.headers.next() ) );
1848 this._on( this.headers, events );
1849 this._on( this.headers.next(), { keydown: "_panelKeyDown" });
1850 this._hoverable( this.headers );
1851 this._focusable( this.headers );
1852 },
1853
1854 _eventHandler: function( event ) {
1855 var options = this.options,
1856 active = this.active,
1857 clicked = $( event.currentTarget ),
1858 clickedIsActive = clicked[ 0 ] === active[ 0 ],
1859 collapsing = clickedIsActive && options.collapsible,
1860 toShow = collapsing ? $() : clicked.next(),
1861 toHide = active.next(),
1862 eventData = {
1863 oldHeader: active,
1864 oldPanel: toHide,
1865 newHeader: collapsing ? $() : clicked,
1866 newPanel: toShow
1867 };
1868
1869 event.preventDefault();
1870
1871 if (
1872 // click on active header, but not collapsible
1873 ( clickedIsActive && !options.collapsible ) ||
1874 // allow canceling activation
1875 ( this._trigger( "beforeActivate", event, eventData ) === false ) ) {
1876 return;
1877 }
1878
1879 options.active = collapsing ? false : this.headers.index( clicked );
1880
1881 // when the call to ._toggle() comes after the class changes
1882 // it causes a very odd bug in IE 8 (see #6720)
1883 this.active = clickedIsActive ? $() : clicked;
1884 this._toggle( eventData );
1885
1886 // switch classes
1887 // corner classes on the previously active header stay after the animation
1888 active.removeClass( "ui-accordion-header-active ui-state-active" );
1889 if ( options.icons ) {
1890 active.children( ".ui-accordion-header-icon" )
1891 .removeClass( options.icons.activeHeader )
1892 .addClass( options.icons.header );
1893 }
1894
1895 if ( !clickedIsActive ) {
1896 clicked
1897 .removeClass( "ui-corner-all" )
1898 .addClass( "ui-accordion-header-active ui-state-active ui-corner-top" );
1899 if ( options.icons ) {
1900 clicked.children( ".ui-accordion-header-icon" )
1901 .removeClass( options.icons.header )
1902 .addClass( options.icons.activeHeader );
1903 }
1904
1905 clicked
1906 .next()
1907 .addClass( "ui-accordion-content-active" );
1908 }
1909 },
1910
1911 _toggle: function( data ) {
1912 var toShow = data.newPanel,
1913 toHide = this.prevShow.length ? this.prevShow : data.oldPanel;
1914
1915 // handle activating a panel during the animation for another activation
1916 this.prevShow.add( this.prevHide ).stop( true, true );
1917 this.prevShow = toShow;
1918 this.prevHide = toHide;
1919
1920 if ( this.options.animate ) {
1921 this._animate( toShow, toHide, data );
1922 } else {
1923 toHide.hide();
1924 toShow.show();
1925 this._toggleComplete( data );
1926 }
1927
1928 toHide.attr({
1929 "aria-hidden": "true"
1930 });
1931 toHide.prev().attr( "aria-selected", "false" );
1932 // if we're switching panels, remove the old header from the tab order
1933 // if we're opening from collapsed state, remove the previous header from the tab order
1934 // if we're collapsing, then keep the collapsing header in the tab order
1935 if ( toShow.length && toHide.length ) {
1936 toHide.prev().attr({
1937 "tabIndex": -1,
1938 "aria-expanded": "false"
1939 });
1940 } else if ( toShow.length ) {
1941 this.headers.filter(function() {
1942 return $( this ).attr( "tabIndex" ) === 0;
1943 })
1944 .attr( "tabIndex", -1 );
1945 }
1946
1947 toShow
1948 .attr( "aria-hidden", "false" )
1949 .prev()
1950 .attr({
1951 "aria-selected": "true",
1952 tabIndex: 0,
1953 "aria-expanded": "true"
1954 });
1955 },
1956
1957 _animate: function( toShow, toHide, data ) {
1958 var total, easing, duration,
1959 that = this,
1960 adjust = 0,
1961 down = toShow.length &&
1962 ( !toHide.length || ( toShow.index() < toHide.index() ) ),
1963 animate = this.options.animate || {},
1964 options = down && animate.down || animate,
1965 complete = function() {
1966 that._toggleComplete( data );
1967 };
1968
1969 if ( typeof options === "number" ) {
1970 duration = options;
1971 }
1972 if ( typeof options === "string" ) {
1973 easing = options;
1974 }
1975 // fall back from options to animation in case of partial down settings
1976 easing = easing || options.easing || animate.easing;
1977 duration = duration || options.duration || animate.duration;
1978
1979 if ( !toHide.length ) {
1980 return toShow.animate( showProps, duration, easing, complete );
1981 }
1982 if ( !toShow.length ) {
1983 return toHide.animate( hideProps, duration, easing, complete );
1984 }
1985
1986 total = toShow.show().outerHeight();
1987 toHide.animate( hideProps, {
1988 duration: duration,
1989 easing: easing,
1990 step: function( now, fx ) {
1991 fx.now = Math.round( now );
1992 }
1993 });
1994 toShow
1995 .hide()
1996 .animate( showProps, {
1997 duration: duration,
1998 easing: easing,
1999 complete: complete,
2000 step: function( now, fx ) {
2001 fx.now = Math.round( now );
2002 if ( fx.prop !== "height" ) {
2003 adjust += fx.now;
2004 } else if ( that.options.heightStyle !== "content" ) {
2005 fx.now = Math.round( total - toHide.outerHeight() - adjust );
2006 adjust = 0;
2007 }
2008 }
2009 });
2010 },
2011
2012 _toggleComplete: function( data ) {
2013 var toHide = data.oldPanel;
2014
2015 toHide
2016 .removeClass( "ui-accordion-content-active" )
2017 .prev()
2018 .removeClass( "ui-corner-top" )
2019 .addClass( "ui-corner-all" );
2020
2021 // Work around for rendering bug in IE (#5421)
2022 if ( toHide.length ) {
2023 toHide.parent()[0].className = toHide.parent()[0].className;
2024 }
2025 this._trigger( "activate", null, data );
2026 }
2027 });
2028
2029 })( jQuery );
2030 (function( $, undefined ) {
2031
2032 $.widget( "ui.autocomplete", {
2033 version: "1.10.4",
2034 defaultElement: "<input>",
2035 options: {
2036 appendTo: null,
2037 autoFocus: false,
2038 delay: 300,
2039 minLength: 1,
2040 position: {
2041 my: "left top",
2042 at: "left bottom",
2043 collision: "none"
2044 },
2045 source: null,
2046
2047 // callbacks
2048 change: null,
2049 close: null,
2050 focus: null,
2051 open: null,
2052 response: null,
2053 search: null,
2054 select: null
2055 },
2056
2057 requestIndex: 0,
2058 pending: 0,
2059
2060 _create: function() {
2061 // Some browsers only repeat keydown events, not keypress events,
2062 // so we use the suppressKeyPress flag to determine if we've already
2063 // handled the keydown event. #7269
2064 // Unfortunately the code for & in keypress is the same as the up arrow,
2065 // so we use the suppressKeyPressRepeat flag to avoid handling keypress
2066 // events when we know the keydown event was used to modify the
2067 // search term. #7799
2068 var suppressKeyPress, suppressKeyPressRepeat, suppressInput,
2069 nodeName = this.element[0].nodeName.toLowerCase(),
2070 isTextarea = nodeName === "textarea",
2071 isInput = nodeName === "input";
2072
2073 this.isMultiLine =
2074 // Textareas are always multi-line
2075 isTextarea ? true :
2076 // Inputs are always single-line, even if inside a contentEditable element
2077 // IE also treats inputs as contentEditable
2078 isInput ? false :
2079 // All other element types are determined by whether or not they're contentEditable
2080 this.element.prop( "isContentEditable" );
2081
2082 this.valueMethod = this.element[ isTextarea || isInput ? "val" : "text" ];
2083 this.isNewMenu = true;
2084
2085 this.element
2086 .addClass( "ui-autocomplete-input" )
2087 .attr( "autocomplete", "off" );
2088
2089 this._on( this.element, {
2090 keydown: function( event ) {
2091 if ( this.element.prop( "readOnly" ) ) {
2092 suppressKeyPress = true;
2093 suppressInput = true;
2094 suppressKeyPressRepeat = true;
2095 return;
2096 }
2097
2098 suppressKeyPress = false;
2099 suppressInput = false;
2100 suppressKeyPressRepeat = false;
2101 var keyCode = $.ui.keyCode;
2102 switch( event.keyCode ) {
2103 case keyCode.PAGE_UP:
2104 suppressKeyPress = true;
2105 this._move( "previousPage", event );
2106 break;
2107 case keyCode.PAGE_DOWN:
2108 suppressKeyPress = true;
2109 this._move( "nextPage", event );
2110 break;
2111 case keyCode.UP:
2112 suppressKeyPress = true;
2113 this._keyEvent( "previous", event );
2114 break;
2115 case keyCode.DOWN:
2116 suppressKeyPress = true;
2117 this._keyEvent( "next", event );
2118 break;
2119 case keyCode.ENTER:
2120 case keyCode.NUMPAD_ENTER:
2121 // when menu is open and has focus
2122 if ( this.menu.active ) {
2123 // #6055 - Opera still allows the keypress to occur
2124 // which causes forms to submit
2125 suppressKeyPress = true;
2126 event.preventDefault();
2127 this.menu.select( event );
2128 }
2129 break;
2130 case keyCode.TAB:
2131 if ( this.menu.active ) {
2132 this.menu.select( event );
2133 }
2134 break;
2135 case keyCode.ESCAPE:
2136 if ( this.menu.element.is( ":visible" ) ) {
2137 this._value( this.term );
2138 this.close( event );
2139 // Different browsers have different default behavior for escape
2140 // Single press can mean undo or clear
2141 // Double press in IE means clear the whole form
2142 event.preventDefault();
2143 }
2144 break;
2145 default:
2146 suppressKeyPressRepeat = true;
2147 // search timeout should be triggered before the input value is changed
2148 this._searchTimeout( event );
2149 break;
2150 }
2151 },
2152 keypress: function( event ) {
2153 if ( suppressKeyPress ) {
2154 suppressKeyPress = false;
2155 if ( !this.isMultiLine || this.menu.element.is( ":visible" ) ) {
2156 event.preventDefault();
2157 }
2158 return;
2159 }
2160 if ( suppressKeyPressRepeat ) {
2161 return;
2162 }
2163
2164 // replicate some key handlers to allow them to repeat in Firefox and Opera
2165 var keyCode = $.ui.keyCode;
2166 switch( event.keyCode ) {
2167 case keyCode.PAGE_UP:
2168 this._move( "previousPage", event );
2169 break;
2170 case keyCode.PAGE_DOWN:
2171 this._move( "nextPage", event );
2172 break;
2173 case keyCode.UP:
2174 this._keyEvent( "previous", event );
2175 break;
2176 case keyCode.DOWN:
2177 this._keyEvent( "next", event );
2178 break;
2179 }
2180 },
2181 input: function( event ) {
2182 if ( suppressInput ) {
2183 suppressInput = false;
2184 event.preventDefault();
2185 return;
2186 }
2187 this._searchTimeout( event );
2188 },
2189 focus: function() {
2190 this.selectedItem = null;
2191 this.previous = this._value();
2192 },
2193 blur: function( event ) {
2194 if ( this.cancelBlur ) {
2195 delete this.cancelBlur;
2196 return;
2197 }
2198
2199 clearTimeout( this.searching );
2200 this.close( event );
2201 this._change( event );
2202 }
2203 });
2204
2205 this._initSource();
2206 this.menu = $( "<ul>" )
2207 .addClass( "ui-autocomplete ui-front" )
2208 .appendTo( this._appendTo() )
2209 .menu({
2210 // disable ARIA support, the live region takes care of that
2211 role: null
2212 })
2213 .hide()
2214 .data( "ui-menu" );
2215
2216 this._on( this.menu.element, {
2217 mousedown: function( event ) {
2218 // prevent moving focus out of the text field
2219 event.preventDefault();
2220
2221 // IE doesn't prevent moving focus even with event.preventDefault()
2222 // so we set a flag to know when we should ignore the blur event
2223 this.cancelBlur = true;
2224 this._delay(function() {
2225 delete this.cancelBlur;
2226 });
2227
2228 // clicking on the scrollbar causes focus to shift to the body
2229 // but we can't detect a mouseup or a click immediately afterward
2230 // so we have to track the next mousedown and close the menu if
2231 // the user clicks somewhere outside of the autocomplete
2232 var menuElement = this.menu.element[ 0 ];
2233 if ( !$( event.target ).closest( ".ui-menu-item" ).length ) {
2234 this._delay(function() {
2235 var that = this;
2236 this.document.one( "mousedown", function( event ) {
2237 if ( event.target !== that.element[ 0 ] &&
2238 event.target !== menuElement &&
2239 !$.contains( menuElement, event.target ) ) {
2240 that.close();
2241 }
2242 });
2243 });
2244 }
2245 },
2246 menufocus: function( event, ui ) {
2247 // support: Firefox
2248 // Prevent accidental activation of menu items in Firefox (#7024 #9118)
2249 if ( this.isNewMenu ) {
2250 this.isNewMenu = false;
2251 if ( event.originalEvent && /^mouse/.test( event.originalEvent.type ) ) {
2252 this.menu.blur();
2253
2254 this.document.one( "mousemove", function() {
2255 $( event.target ).trigger( event.originalEvent );
2256 });
2257
2258 return;
2259 }
2260 }
2261
2262 var item = ui.item.data( "ui-autocomplete-item" );
2263 if ( false !== this._trigger( "focus", event, { item: item } ) ) {
2264 // use value to match what will end up in the input, if it was a key event
2265 if ( event.originalEvent && /^key/.test( event.originalEvent.type ) ) {
2266 this._value( item.value );
2267 }
2268 } else {
2269 // Normally the input is populated with the item's value as the
2270 // menu is navigated, causing screen readers to notice a change and
2271 // announce the item. Since the focus event was canceled, this doesn't
2272 // happen, so we update the live region so that screen readers can
2273 // still notice the change and announce it.
2274 this.liveRegion.text( item.value );
2275 }
2276 },
2277 menuselect: function( event, ui ) {
2278 var item = ui.item.data( "ui-autocomplete-item" ),
2279 previous = this.previous;
2280
2281 // only trigger when focus was lost (click on menu)
2282 if ( this.element[0] !== this.document[0].activeElement ) {
2283 this.element.focus();
2284 this.previous = previous;
2285 // #6109 - IE triggers two focus events and the second
2286 // is asynchronous, so we need to reset the previous
2287 // term synchronously and asynchronously :-(
2288 this._delay(function() {
2289 this.previous = previous;
2290 this.selectedItem = item;
2291 });
2292 }
2293
2294 if ( false !== this._trigger( "select", event, { item: item } ) ) {
2295 this._value( item.value );
2296 }
2297 // reset the term after the select event
2298 // this allows custom select handling to work properly
2299 this.term = this._value();
2300
2301 this.close( event );
2302 this.selectedItem = item;
2303 }
2304 });
2305
2306 this.liveRegion = $( "<span>", {
2307 role: "status",
2308 "aria-live": "polite"
2309 })
2310 .addClass( "ui-helper-hidden-accessible" )
2311 .insertBefore( this.element );
2312
2313 // turning off autocomplete prevents the browser from remembering the
2314 // value when navigating through history, so we re-enable autocomplete
2315 // if the page is unloaded before the widget is destroyed. #7790
2316 this._on( this.window, {
2317 beforeunload: function() {
2318 this.element.removeAttr( "autocomplete" );
2319 }
2320 });
2321 },
2322
2323 _destroy: function() {
2324 clearTimeout( this.searching );
2325 this.element
2326 .removeClass( "ui-autocomplete-input" )
2327 .removeAttr( "autocomplete" );
2328 this.menu.element.remove();
2329 this.liveRegion.remove();
2330 },
2331
2332 _setOption: function( key, value ) {
2333 this._super( key, value );
2334 if ( key === "source" ) {
2335 this._initSource();
2336 }
2337 if ( key === "appendTo" ) {
2338 this.menu.element.appendTo( this._appendTo() );
2339 }
2340 if ( key === "disabled" && value && this.xhr ) {
2341 this.xhr.abort();
2342 }
2343 },
2344
2345 _appendTo: function() {
2346 var element = this.options.appendTo;
2347
2348 if ( element ) {
2349 element = element.jquery || element.nodeType ?
2350 $( element ) :
2351 this.document.find( element ).eq( 0 );
2352 }
2353
2354 if ( !element ) {
2355 element = this.element.closest( ".ui-front" );
2356 }
2357
2358 if ( !element.length ) {
2359 element = this.document[0].body;
2360 }
2361
2362 return element;
2363 },
2364
2365 _initSource: function() {
2366 var array, url,
2367 that = this;
2368 if ( $.isArray(this.options.source) ) {
2369 array = this.options.source;
2370 this.source = function( request, response ) {
2371 response( $.ui.autocomplete.filter( array, request.term ) );
2372 };
2373 } else if ( typeof this.options.source === "string" ) {
2374 url = this.options.source;
2375 this.source = function( request, response ) {
2376 if ( that.xhr ) {
2377 that.xhr.abort();
2378 }
2379 that.xhr = $.ajax({
2380 url: url,
2381 data: request,
2382 dataType: "json",
2383 success: function( data ) {
2384 response( data );
2385 },
2386 error: function() {
2387 response( [] );
2388 }
2389 });
2390 };
2391 } else {
2392 this.source = this.options.source;
2393 }
2394 },
2395
2396 _searchTimeout: function( event ) {
2397 clearTimeout( this.searching );
2398 this.searching = this._delay(function() {
2399 // only search if the value has changed
2400 if ( this.term !== this._value() ) {
2401 this.selectedItem = null;
2402 this.search( null, event );
2403 }
2404 }, this.options.delay );
2405 },
2406
2407 search: function( value, event ) {
2408 value = value != null ? value : this._value();
2409
2410 // always save the actual value, not the one passed as an argument
2411 this.term = this._value();
2412
2413 if ( value.length < this.options.minLength ) {
2414 return this.close( event );
2415 }
2416
2417 if ( this._trigger( "search", event ) === false ) {
2418 return;
2419 }
2420
2421 return this._search( value );
2422 },
2423
2424 _search: function( value ) {
2425 this.pending++;
2426 this.element.addClass( "ui-autocomplete-loading" );
2427 this.cancelSearch = false;
2428
2429 this.source( { term: value }, this._response() );
2430 },
2431
2432 _response: function() {
2433 var index = ++this.requestIndex;
2434
2435 return $.proxy(function( content ) {
2436 if ( index === this.requestIndex ) {
2437 this.__response( content );
2438 }
2439
2440 this.pending--;
2441 if ( !this.pending ) {
2442 this.element.removeClass( "ui-autocomplete-loading" );
2443 }
2444 }, this );
2445 },
2446
2447 __response: function( content ) {
2448 if ( content ) {
2449 content = this._normalize( content );
2450 }
2451 this._trigger( "response", null, { content: content } );
2452 if ( !this.options.disabled && content && content.length && !this.cancelSearch ) {
2453 this._suggest( content );
2454 this._trigger( "open" );
2455 } else {
2456 // use ._close() instead of .close() so we don't cancel future searches
2457 this._close();
2458 }
2459 },
2460
2461 close: function( event ) {
2462 this.cancelSearch = true;
2463 this._close( event );
2464 },
2465
2466 _close: function( event ) {
2467 if ( this.menu.element.is( ":visible" ) ) {
2468 this.menu.element.hide();
2469 this.menu.blur();
2470 this.isNewMenu = true;
2471 this._trigger( "close", event );
2472 }
2473 },
2474
2475 _change: function( event ) {
2476 if ( this.previous !== this._value() ) {
2477 this._trigger( "change", event, { item: this.selectedItem } );
2478 }
2479 },
2480
2481 _normalize: function( items ) {
2482 // assume all items have the right format when the first item is complete
2483 if ( items.length && items[0].label && items[0].value ) {
2484 return items;
2485 }
2486 return $.map( items, function( item ) {
2487 if ( typeof item === "string" ) {
2488 return {
2489 label: item,
2490 value: item
2491 };
2492 }
2493 return $.extend({
2494 label: item.label || item.value,
2495 value: item.value || item.label
2496 }, item );
2497 });
2498 },
2499
2500 _suggest: function( items ) {
2501 var ul = this.menu.element.empty();
2502 this._renderMenu( ul, items );
2503 this.isNewMenu = true;
2504 this.menu.refresh();
2505
2506 // size and position menu
2507 ul.show();
2508 this._resizeMenu();
2509 ul.position( $.extend({
2510 of: this.element
2511 }, this.options.position ));
2512
2513 if ( this.options.autoFocus ) {
2514 this.menu.next();
2515 }
2516 },
2517
2518 _resizeMenu: function() {
2519 var ul = this.menu.element;
2520 ul.outerWidth( Math.max(
2521 // Firefox wraps long text (possibly a rounding bug)
2522 // so we add 1px to avoid the wrapping (#7513)
2523 ul.width( "" ).outerWidth() + 1,
2524 this.element.outerWidth()
2525 ) );
2526 },
2527
2528 _renderMenu: function( ul, items ) {
2529 var that = this;
2530 $.each( items, function( index, item ) {
2531 that._renderItemData( ul, item );
2532 });
2533 },
2534
2535 _renderItemData: function( ul, item ) {
2536 return this._renderItem( ul, item ).data( "ui-autocomplete-item", item );
2537 },
2538
2539 _renderItem: function( ul, item ) {
2540 return $( "<li>" )
2541 .append( $( "<a>" ).text( item.label ) )
2542 .appendTo( ul );
2543 },
2544
2545 _move: function( direction, event ) {
2546 if ( !this.menu.element.is( ":visible" ) ) {
2547 this.search( null, event );
2548 return;
2549 }
2550 if ( this.menu.isFirstItem() && /^previous/.test( direction ) ||
2551 this.menu.isLastItem() && /^next/.test( direction ) ) {
2552 this._value( this.term );
2553 this.menu.blur();
2554 return;
2555 }
2556 this.menu[ direction ]( event );
2557 },
2558
2559 widget: function() {
2560 return this.menu.element;
2561 },
2562
2563 _value: function() {
2564 return this.valueMethod.apply( this.element, arguments );
2565 },
2566
2567 _keyEvent: function( keyEvent, event ) {
2568 if ( !this.isMultiLine || this.menu.element.is( ":visible" ) ) {
2569 this._move( keyEvent, event );
2570
2571 // prevents moving cursor to beginning/end of the text field in some browsers
2572 event.preventDefault();
2573 }
2574 }
2575 });
2576
2577 $.extend( $.ui.autocomplete, {
2578 escapeRegex: function( value ) {
2579 return value.replace(/[\-\[\]{}()*+?.,\\\^$|#\s]/g, "\\$&");
2580 },
2581 filter: function(array, term) {
2582 var matcher = new RegExp( $.ui.autocomplete.escapeRegex(term), "i" );
2583 return $.grep( array, function(value) {
2584 return matcher.test( value.label || value.value || value );
2585 });
2586 }
2587 });
2588
2589
2590 // live region extension, adding a `messages` option
2591 // NOTE: This is an experimental API. We are still investigating
2592 // a full solution for string manipulation and internationalization.
2593 $.widget( "ui.autocomplete", $.ui.autocomplete, {
2594 options: {
2595 messages: {
2596 noResults: "No search results.",
2597 results: function( amount ) {
2598 return amount + ( amount > 1 ? " results are" : " result is" ) +
2599 " available, use up and down arrow keys to navigate.";
2600 }
2601 }
2602 },
2603
2604 __response: function( content ) {
2605 var message;
2606 this._superApply( arguments );
2607 if ( this.options.disabled || this.cancelSearch ) {
2608 return;
2609 }
2610 if ( content && content.length ) {
2611 message = this.options.messages.results( content.length );
2612 } else {
2613 message = this.options.messages.noResults;
2614 }
2615 this.liveRegion.text( message );
2616 }
2617 });
2618
2619 }( jQuery ));
2620 (function( $, undefined ) {
2621
2622 var lastActive,
2623 baseClasses = "ui-button ui-widget ui-state-default ui-corner-all",
2624 typeClasses = "ui-button-icons-only ui-button-icon-only ui-button-text-icons ui-button-text-icon-primary ui-button-text-icon-secondary ui-button-text-only",
2625 formResetHandler = function() {
2626 var form = $( this );
2627 setTimeout(function() {
2628 form.find( ":ui-button" ).button( "refresh" );
2629 }, 1 );
2630 },
2631 radioGroup = function( radio ) {
2632 var name = radio.name,
2633 form = radio.form,
2634 radios = $( [] );
2635 if ( name ) {
2636 name = name.replace( /'/g, "\\'" );
2637 if ( form ) {
2638 radios = $( form ).find( "[name='" + name + "']" );
2639 } else {
2640 radios = $( "[name='" + name + "']", radio.ownerDocument )
2641 .filter(function() {
2642 return !this.form;
2643 });
2644 }
2645 }
2646 return radios;
2647 };
2648
2649 $.widget( "ui.button", {
2650 version: "1.10.4",
2651 defaultElement: "<button>",
2652 options: {
2653 disabled: null,
2654 text: true,
2655 label: null,
2656 icons: {
2657 primary: null,
2658 secondary: null
2659 }
2660 },
2661 _create: function() {
2662 this.element.closest( "form" )
2663 .unbind( "reset" + this.eventNamespace )
2664 .bind( "reset" + this.eventNamespace, formResetHandler );
2665
2666 if ( typeof this.options.disabled !== "boolean" ) {
2667 this.options.disabled = !!this.element.prop( "disabled" );
2668 } else {
2669 this.element.prop( "disabled", this.options.disabled );
2670 }
2671
2672 this._determineButtonType();
2673 this.hasTitle = !!this.buttonElement.attr( "title" );
2674
2675 var that = this,
2676 options = this.options,
2677 toggleButton = this.type === "checkbox" || this.type === "radio",
2678 activeClass = !toggleButton ? "ui-state-active" : "";
2679
2680 if ( options.label === null ) {
2681 options.label = (this.type === "input" ? this.buttonElement.val() : this.buttonElement.html());
2682 }
2683
2684 this._hoverable( this.buttonElement );
2685
2686 this.buttonElement
2687 .addClass( baseClasses )
2688 .attr( "role", "button" )
2689 .bind( "mouseenter" + this.eventNamespace, function() {
2690 if ( options.disabled ) {
2691 return;
2692 }
2693 if ( this === lastActive ) {
2694 $( this ).addClass( "ui-state-active" );
2695 }
2696 })
2697 .bind( "mouseleave" + this.eventNamespace, function() {
2698 if ( options.disabled ) {
2699 return;
2700 }
2701 $( this ).removeClass( activeClass );
2702 })
2703 .bind( "click" + this.eventNamespace, function( event ) {
2704 if ( options.disabled ) {
2705 event.preventDefault();
2706 event.stopImmediatePropagation();
2707 }
2708 });
2709
2710 // Can't use _focusable() because the element that receives focus
2711 // and the element that gets the ui-state-focus class are different
2712 this._on({
2713 focus: function() {
2714 this.buttonElement.addClass( "ui-state-focus" );
2715 },
2716 blur: function() {
2717 this.buttonElement.removeClass( "ui-state-focus" );
2718 }
2719 });
2720
2721 if ( toggleButton ) {
2722 this.element.bind( "change" + this.eventNamespace, function() {
2723 that.refresh();
2724 });
2725 }
2726
2727 if ( this.type === "checkbox" ) {
2728 this.buttonElement.bind( "click" + this.eventNamespace, function() {
2729 if ( options.disabled ) {
2730 return false;
2731 }
2732 });
2733 } else if ( this.type === "radio" ) {
2734 this.buttonElement.bind( "click" + this.eventNamespace, function() {
2735 if ( options.disabled ) {
2736 return false;
2737 }
2738 $( this ).addClass( "ui-state-active" );
2739 that.buttonElement.attr( "aria-pressed", "true" );
2740
2741 var radio = that.element[ 0 ];
2742 radioGroup( radio )
2743 .not( radio )
2744 .map(function() {
2745 return $( this ).button( "widget" )[ 0 ];
2746 })
2747 .removeClass( "ui-state-active" )
2748 .attr( "aria-pressed", "false" );
2749 });
2750 } else {
2751 this.buttonElement
2752 .bind( "mousedown" + this.eventNamespace, function() {
2753 if ( options.disabled ) {
2754 return false;
2755 }
2756 $( this ).addClass( "ui-state-active" );
2757 lastActive = this;
2758 that.document.one( "mouseup", function() {
2759 lastActive = null;
2760 });
2761 })
2762 .bind( "mouseup" + this.eventNamespace, function() {
2763 if ( options.disabled ) {
2764 return false;
2765 }
2766 $( this ).removeClass( "ui-state-active" );
2767 })
2768 .bind( "keydown" + this.eventNamespace, function(event) {
2769 if ( options.disabled ) {
2770 return false;
2771 }
2772 if ( event.keyCode === $.ui.keyCode.SPACE || event.keyCode === $.ui.keyCode.ENTER ) {
2773 $( this ).addClass( "ui-state-active" );
2774 }
2775 })
2776 // see #8559, we bind to blur here in case the button element loses
2777 // focus between keydown and keyup, it would be left in an "active" state
2778 .bind( "keyup" + this.eventNamespace + " blur" + this.eventNamespace, function() {
2779 $( this ).removeClass( "ui-state-active" );
2780 });
2781
2782 if ( this.buttonElement.is("a") ) {
2783 this.buttonElement.keyup(function(event) {
2784 if ( event.keyCode === $.ui.keyCode.SPACE ) {
2785 // TODO pass through original event correctly (just as 2nd argument doesn't work)
2786 $( this ).click();
2787 }
2788 });
2789 }
2790 }
2791
2792 // TODO: pull out $.Widget's handling for the disabled option into
2793 // $.Widget.prototype._setOptionDisabled so it's easy to proxy and can
2794 // be overridden by individual plugins
2795 this._setOption( "disabled", options.disabled );
2796 this._resetButton();
2797 },
2798
2799 _determineButtonType: function() {
2800 var ancestor, labelSelector, checked;
2801
2802 if ( this.element.is("[type=checkbox]") ) {
2803 this.type = "checkbox";
2804 } else if ( this.element.is("[type=radio]") ) {
2805 this.type = "radio";
2806 } else if ( this.element.is("input") ) {
2807 this.type = "input";
2808 } else {
2809 this.type = "button";
2810 }
2811
2812 if ( this.type === "checkbox" || this.type === "radio" ) {
2813 // we don't search against the document in case the element
2814 // is disconnected from the DOM
2815 ancestor = this.element.parents().last();
2816 labelSelector = "label[for='" + this.element.attr("id") + "']";
2817 this.buttonElement = ancestor.find( labelSelector );
2818 if ( !this.buttonElement.length ) {
2819 ancestor = ancestor.length ? ancestor.siblings() : this.element.siblings();
2820 this.buttonElement = ancestor.filter( labelSelector );
2821 if ( !this.buttonElement.length ) {
2822 this.buttonElement = ancestor.find( labelSelector );
2823 }
2824 }
2825 this.element.addClass( "ui-helper-hidden-accessible" );
2826
2827 checked = this.element.is( ":checked" );
2828 if ( checked ) {
2829 this.buttonElement.addClass( "ui-state-active" );
2830 }
2831 this.buttonElement.prop( "aria-pressed", checked );
2832 } else {
2833 this.buttonElement = this.element;
2834 }
2835 },
2836
2837 widget: function() {
2838 return this.buttonElement;
2839 },
2840
2841 _destroy: function() {
2842 this.element
2843 .removeClass( "ui-helper-hidden-accessible" );
2844 this.buttonElement
2845 .removeClass( baseClasses + " ui-state-active " + typeClasses )
2846 .removeAttr( "role" )
2847 .removeAttr( "aria-pressed" )
2848 .html( this.buttonElement.find(".ui-button-text").html() );
2849
2850 if ( !this.hasTitle ) {
2851 this.buttonElement.removeAttr( "title" );
2852 }
2853 },
2854
2855 _setOption: function( key, value ) {
2856 this._super( key, value );
2857 if ( key === "disabled" ) {
2858 this.element.prop( "disabled", !!value );
2859 if ( value ) {
2860 this.buttonElement.removeClass( "ui-state-focus" );
2861 }
2862 return;
2863 }
2864 this._resetButton();
2865 },
2866
2867 refresh: function() {
2868 //See #8237 & #8828
2869 var isDisabled = this.element.is( "input, button" ) ? this.element.is( ":disabled" ) : this.element.hasClass( "ui-button-disabled" );
2870
2871 if ( isDisabled !== this.options.disabled ) {
2872 this._setOption( "disabled", isDisabled );
2873 }
2874 if ( this.type === "radio" ) {
2875 radioGroup( this.element[0] ).each(function() {
2876 if ( $( this ).is( ":checked" ) ) {
2877 $( this ).button( "widget" )
2878 .addClass( "ui-state-active" )
2879 .attr( "aria-pressed", "true" );
2880 } else {
2881 $( this ).button( "widget" )
2882 .removeClass( "ui-state-active" )
2883 .attr( "aria-pressed", "false" );
2884 }
2885 });
2886 } else if ( this.type === "checkbox" ) {
2887 if ( this.element.is( ":checked" ) ) {
2888 this.buttonElement
2889 .addClass( "ui-state-active" )
2890 .attr( "aria-pressed", "true" );
2891 } else {
2892 this.buttonElement
2893 .removeClass( "ui-state-active" )
2894 .attr( "aria-pressed", "false" );
2895 }
2896 }
2897 },
2898
2899 _resetButton: function() {
2900 if ( this.type === "input" ) {
2901 if ( this.options.label ) {
2902 this.element.val( this.options.label );
2903 }
2904 return;
2905 }
2906 var buttonElement = this.buttonElement.removeClass( typeClasses ),
2907 buttonText = $( "<span></span>", this.document[0] )
2908 .addClass( "ui-button-text" )
2909 .html( this.options.label )
2910 .appendTo( buttonElement.empty() )
2911 .text(),
2912 icons = this.options.icons,
2913 multipleIcons = icons.primary && icons.secondary,
2914 buttonClasses = [];
2915
2916 if ( icons.primary || icons.secondary ) {
2917 if ( this.options.text ) {
2918 buttonClasses.push( "ui-button-text-icon" + ( multipleIcons ? "s" : ( icons.primary ? "-primary" : "-secondary" ) ) );
2919 }
2920
2921 if ( icons.primary ) {
2922 buttonElement.prepend( "<span class='ui-button-icon-primary ui-icon " + icons.primary + "'></span>" );
2923 }
2924
2925 if ( icons.secondary ) {
2926 buttonElement.append( "<span class='ui-button-icon-secondary ui-icon " + icons.secondary + "'></span>" );
2927 }
2928
2929 if ( !this.options.text ) {
2930 buttonClasses.push( multipleIcons ? "ui-button-icons-only" : "ui-button-icon-only" );
2931
2932 if ( !this.hasTitle ) {
2933 buttonElement.attr( "title", $.trim( buttonText ) );
2934 }
2935 }
2936 } else {
2937 buttonClasses.push( "ui-button-text-only" );
2938 }
2939 buttonElement.addClass( buttonClasses.join( " " ) );
2940 }
2941 });
2942
2943 $.widget( "ui.buttonset", {
2944 version: "1.10.4",
2945 options: {
2946 items: "button, input[type=button], input[type=submit], input[type=reset], input[type=checkbox], input[type=radio], a, :data(ui-button)"
2947 },
2948
2949 _create: function() {
2950 this.element.addClass( "ui-buttonset" );
2951 },
2952
2953 _init: function() {
2954 this.refresh();
2955 },
2956
2957 _setOption: function( key, value ) {
2958 if ( key === "disabled" ) {
2959 this.buttons.button( "option", key, value );
2960 }
2961
2962 this._super( key, value );
2963 },
2964
2965 refresh: function() {
2966 var rtl = this.element.css( "direction" ) === "rtl";
2967
2968 this.buttons = this.element.find( this.options.items )
2969 .filter( ":ui-button" )
2970 .button( "refresh" )
2971 .end()
2972 .not( ":ui-button" )
2973 .button()
2974 .end()
2975 .map(function() {
2976 return $( this ).button( "widget" )[ 0 ];
2977 })
2978 .removeClass( "ui-corner-all ui-corner-left ui-corner-right" )
2979 .filter( ":first" )
2980 .addClass( rtl ? "ui-corner-right" : "ui-corner-left" )
2981 .end()
2982 .filter( ":last" )
2983 .addClass( rtl ? "ui-corner-left" : "ui-corner-right" )
2984 .end()
2985 .end();
2986 },
2987
2988 _destroy: function() {
2989 this.element.removeClass( "ui-buttonset" );
2990 this.buttons
2991 .map(function() {
2992 return $( this ).button( "widget" )[ 0 ];
2993 })
2994 .removeClass( "ui-corner-left ui-corner-right" )
2995 .end()
2996 .button( "destroy" );
2997 }
2998 });
2999
3000 }( jQuery ) );
3001 (function( $, undefined ) {
3002
3003 $.extend($.ui, { datepicker: { version: "1.10.4" } });
3004
3005 var PROP_NAME = "datepicker",
3006 instActive;
3007
3008 /* Date picker manager.
3009 Use the singleton instance of this class, $.datepicker, to interact with the date picker.
3010 Settings for (groups of) date pickers are maintained in an instance object,
3011 allowing multiple different settings on the same page. */
3012
3013 function Datepicker() {
3014 this._curInst = null; // The current instance in use
3015 this._keyEvent = false; // If the last event was a key event
3016 this._disabledInputs = []; // List of date picker inputs that have been disabled
3017 this._datepickerShowing = false; // True if the popup picker is showing , false if not
3018 this._inDialog = false; // True if showing within a "dialog", false if not
3019 this._mainDivId = "ui-datepicker-div"; // The ID of the main datepicker division
3020 this._inlineClass = "ui-datepicker-inline"; // The name of the inline marker class
3021 this._appendClass = "ui-datepicker-append"; // The name of the append marker class
3022 this._triggerClass = "ui-datepicker-trigger"; // The name of the trigger marker class
3023 this._dialogClass = "ui-datepicker-dialog"; // The name of the dialog marker class
3024 this._disableClass = "ui-datepicker-disabled"; // The name of the disabled covering marker class
3025 this._unselectableClass = "ui-datepicker-unselectable"; // The name of the unselectable cell marker class
3026 this._currentClass = "ui-datepicker-current-day"; // The name of the current day marker class
3027 this._dayOverClass = "ui-datepicker-days-cell-over"; // The name of the day hover marker class
3028 this.regional = []; // Available regional settings, indexed by language code
3029 this.regional[""] = { // Default regional settings
3030 closeText: "Done", // Display text for close link
3031 prevText: "Prev", // Display text for previous month link
3032 nextText: "Next", // Display text for next month link
3033 currentText: "Today", // Display text for current month link
3034 monthNames: ["January","February","March","April","May","June",
3035 "July","August","September","October","November","December"], // Names of months for drop-down and formatting
3036 monthNamesShort: ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"], // For formatting
3037 dayNames: ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"], // For formatting
3038 dayNamesShort: ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"], // For formatting
3039 dayNamesMin: ["Su","Mo","Tu","We","Th","Fr","Sa"], // Column headings for days starting at Sunday
3040 weekHeader: "Wk", // Column header for week of the year
3041 dateFormat: "mm/dd/yy", // See format options on parseDate
3042 firstDay: 0, // The first day of the week, Sun = 0, Mon = 1, ...
3043 isRTL: false, // True if right-to-left language, false if left-to-right
3044 showMonthAfterYear: false, // True if the year select precedes month, false for month then year
3045 yearSuffix: "" // Additional text to append to the year in the month headers
3046 };
3047 this._defaults = { // Global defaults for all the date picker instances
3048 showOn: "focus", // "focus" for popup on focus,
3049 // "button" for trigger button, or "both" for either
3050 showAnim: "fadeIn", // Name of jQuery animation for popup
3051 showOptions: {}, // Options for enhanced animations
3052 defaultDate: null, // Used when field is blank: actual date,
3053 // +/-number for offset from today, null for today
3054 appendText: "", // Display text following the input box, e.g. showing the format
3055 buttonText: "...", // Text for trigger button
3056 buttonImage: "", // URL for trigger button image
3057 buttonImageOnly: false, // True if the image appears alone, false if it appears on a button
3058 hideIfNoPrevNext: false, // True to hide next/previous month links
3059 // if not applicable, false to just disable them
3060 navigationAsDateFormat: false, // True if date formatting applied to prev/today/next links
3061 gotoCurrent: false, // True if today link goes back to current selection instead
3062 changeMonth: false, // True if month can be selected directly, false if only prev/next
3063 changeYear: false, // True if year can be selected directly, false if only prev/next
3064 yearRange: "c-10:c+10", // Range of years to display in drop-down,
3065 // either relative to today's year (-nn:+nn), relative to currently displayed year
3066 // (c-nn:c+nn), absolute (nnnn:nnnn), or a combination of the above (nnnn:-n)
3067 showOtherMonths: false, // True to show dates in other months, false to leave blank
3068 selectOtherMonths: false, // True to allow selection of dates in other months, false for unselectable
3069 showWeek: false, // True to show week of the year, false to not show it
3070 calculateWeek: this.iso8601Week, // How to calculate the week of the year,
3071 // takes a Date and returns the number of the week for it
3072 shortYearCutoff: "+10", // Short year values < this are in the current century,
3073 // > this are in the previous century,
3074 // string value starting with "+" for current year + value
3075 minDate: null, // The earliest selectable date, or null for no limit
3076 maxDate: null, // The latest selectable date, or null for no limit
3077 duration: "fast", // Duration of display/closure
3078 beforeShowDay: null, // Function that takes a date and returns an array with
3079 // [0] = true if selectable, false if not, [1] = custom CSS class name(s) or "",
3080 // [2] = cell title (optional), e.g. $.datepicker.noWeekends
3081 beforeShow: null, // Function that takes an input field and
3082 // returns a set of custom settings for the date picker
3083 onSelect: null, // Define a callback function when a date is selected
3084 onChangeMonthYear: null, // Define a callback function when the month or year is changed
3085 onClose: null, // Define a callback function when the datepicker is closed
3086 numberOfMonths: 1, // Number of months to show at a time
3087 showCurrentAtPos: 0, // The position in multipe months at which to show the current month (starting at 0)
3088 stepMonths: 1, // Number of months to step back/forward
3089 stepBigMonths: 12, // Number of months to step back/forward for the big links
3090 altField: "", // Selector for an alternate field to store selected dates into
3091 altFormat: "", // The date format to use for the alternate field
3092 constrainInput: true, // The input is constrained by the current date format
3093 showButtonPanel: false, // True to show button panel, false to not show it
3094 autoSize: false, // True to size the input for the date format, false to leave as is
3095 disabled: false // The initial disabled state
3096 };
3097 $.extend(this._defaults, this.regional[""]);
3098 this.dpDiv = bindHover($("<div id='" + this._mainDivId + "' class='ui-datepicker ui-widget ui-widget-content ui-helper-clearfix ui-corner-all'></div>"));
3099 }
3100
3101 $.extend(Datepicker.prototype, {
3102 /* Class name added to elements to indicate already configured with a date picker. */
3103 markerClassName: "hasDatepicker",
3104
3105 //Keep track of the maximum number of rows displayed (see #7043)
3106 maxRows: 4,
3107
3108 // TODO rename to "widget" when switching to widget factory
3109 _widgetDatepicker: function() {
3110 return this.dpDiv;
3111 },
3112
3113 /* Override the default settings for all instances of the date picker.
3114 * @param settings object - the new settings to use as defaults (anonymous object)
3115 * @return the manager object
3116 */
3117 setDefaults: function(settings) {
3118 extendRemove(this._defaults, settings || {});
3119 return this;
3120 },
3121
3122 /* Attach the date picker to a jQuery selection.
3123 * @param target element - the target input field or division or span
3124 * @param settings object - the new settings to use for this date picker instance (anonymous)
3125 */
3126 _attachDatepicker: function(target, settings) {
3127 var nodeName, inline, inst;
3128 nodeName = target.nodeName.toLowerCase();
3129 inline = (nodeName === "div" || nodeName === "span");
3130 if (!target.id) {
3131 this.uuid += 1;
3132 target.id = "dp" + this.uuid;
3133 }
3134 inst = this._newInst($(target), inline);
3135 inst.settings = $.extend({}, settings || {});
3136 if (nodeName === "input") {
3137 this._connectDatepicker(target, inst);
3138 } else if (inline) {
3139 this._inlineDatepicker(target, inst);
3140 }
3141 },
3142
3143 /* Create a new instance object. */
3144 _newInst: function(target, inline) {
3145 var id = target[0].id.replace(/([^A-Za-z0-9_\-])/g, "\\\\$1"); // escape jQuery meta chars
3146 return {id: id, input: target, // associated target
3147 selectedDay: 0, selectedMonth: 0, selectedYear: 0, // current selection
3148 drawMonth: 0, drawYear: 0, // month being drawn
3149 inline: inline, // is datepicker inline or not
3150 dpDiv: (!inline ? this.dpDiv : // presentation div
3151 bindHover($("<div class='" + this._inlineClass + " ui-datepicker ui-widget ui-widget-content ui-helper-clearfix ui-corner-all'></div>")))};
3152 },
3153
3154 /* Attach the date picker to an input field. */
3155 _connectDatepicker: function(target, inst) {
3156 var input = $(target);
3157 inst.append = $([]);
3158 inst.trigger = $([]);
3159 if (input.hasClass(this.markerClassName)) {
3160 return;
3161 }
3162 this._attachments(input, inst);
3163 input.addClass(this.markerClassName).keydown(this._doKeyDown).
3164 keypress(this._doKeyPress).keyup(this._doKeyUp);
3165 this._autoSize(inst);
3166 $.data(target, PROP_NAME, inst);
3167 //If disabled option is true, disable the datepicker once it has been attached to the input (see ticket #5665)
3168 if( inst.settings.disabled ) {
3169 this._disableDatepicker( target );
3170 }
3171 },
3172
3173 /* Make attachments based on settings. */
3174 _attachments: function(input, inst) {
3175 var showOn, buttonText, buttonImage,
3176 appendText = this._get(inst, "appendText"),
3177 isRTL = this._get(inst, "isRTL");
3178
3179 if (inst.append) {
3180 inst.append.remove();
3181 }
3182 if (appendText) {
3183 inst.append = $("<span class='" + this._appendClass + "'>" + appendText + "</span>");
3184 input[isRTL ? "before" : "after"](inst.append);
3185 }
3186
3187 input.unbind("focus", this._showDatepicker);
3188
3189 if (inst.trigger) {
3190 inst.trigger.remove();
3191 }
3192
3193 showOn = this._get(inst, "showOn");
3194 if (showOn === "focus" || showOn === "both") { // pop-up date picker when in the marked field
3195 input.focus(this._showDatepicker);
3196 }
3197 if (showOn === "button" || showOn === "both") { // pop-up date picker when button clicked
3198 buttonText = this._get(inst, "buttonText");
3199 buttonImage = this._get(inst, "buttonImage");
3200 inst.trigger = $(this._get(inst, "buttonImageOnly") ?
3201 $("<img/>").addClass(this._triggerClass).
3202 attr({ src: buttonImage, alt: buttonText, title: buttonText }) :
3203 $("<button type='button'></button>").addClass(this._triggerClass).
3204 html(!buttonImage ? buttonText : $("<img/>").attr(
3205 { src:buttonImage, alt:buttonText, title:buttonText })));
3206 input[isRTL ? "before" : "after"](inst.trigger);
3207 inst.trigger.click(function() {
3208 if ($.datepicker._datepickerShowing && $.datepicker._lastInput === input[0]) {
3209 $.datepicker._hideDatepicker();
3210 } else if ($.datepicker._datepickerShowing && $.datepicker._lastInput !== input[0]) {
3211 $.datepicker._hideDatepicker();
3212 $.datepicker._showDatepicker(input[0]);
3213 } else {
3214 $.datepicker._showDatepicker(input[0]);
3215 }
3216 return false;
3217 });
3218 }
3219 },
3220
3221 /* Apply the maximum length for the date format. */
3222 _autoSize: function(inst) {
3223 if (this._get(inst, "autoSize") && !inst.inline) {
3224 var findMax, max, maxI, i,
3225 date = new Date(2009, 12 - 1, 20), // Ensure double digits
3226 dateFormat = this._get(inst, "dateFormat");
3227
3228 if (dateFormat.match(/[DM]/)) {
3229 findMax = function(names) {
3230 max = 0;
3231 maxI = 0;
3232 for (i = 0; i < names.length; i++) {
3233 if (names[i].length > max) {
3234 max = names[i].length;
3235 maxI = i;
3236 }
3237 }
3238 return maxI;
3239 };
3240 date.setMonth(findMax(this._get(inst, (dateFormat.match(/MM/) ?
3241 "monthNames" : "monthNamesShort"))));
3242 date.setDate(findMax(this._get(inst, (dateFormat.match(/DD/) ?
3243 "dayNames" : "dayNamesShort"))) + 20 - date.getDay());
3244 }
3245 inst.input.attr("size", this._formatDate(inst, date).length);
3246 }
3247 },
3248
3249 /* Attach an inline date picker to a div. */
3250 _inlineDatepicker: function(target, inst) {
3251 var divSpan = $(target);
3252 if (divSpan.hasClass(this.markerClassName)) {
3253 return;
3254 }
3255 divSpan.addClass(this.markerClassName).append(inst.dpDiv);
3256 $.data(target, PROP_NAME, inst);
3257 this._setDate(inst, this._getDefaultDate(inst), true);
3258 this._updateDatepicker(inst);
3259 this._updateAlternate(inst);
3260 //If disabled option is true, disable the datepicker before showing it (see ticket #5665)
3261 if( inst.settings.disabled ) {
3262 this._disableDatepicker( target );
3263 }
3264 // Set display:block in place of inst.dpDiv.show() which won't work on disconnected elements
3265 // http://bugs.jqueryui.com/ticket/7552 - A Datepicker created on a detached div has zero height
3266 inst.dpDiv.css( "display", "block" );
3267 },
3268
3269 /* Pop-up the date picker in a "dialog" box.
3270 * @param input element - ignored
3271 * @param date string or Date - the initial date to display
3272 * @param onSelect function - the function to call when a date is selected
3273 * @param settings object - update the dialog date picker instance's settings (anonymous object)
3274 * @param pos int[2] - coordinates for the dialog's position within the screen or
3275 * event - with x/y coordinates or
3276 * leave empty for default (screen centre)
3277 * @return the manager object
3278 */
3279 _dialogDatepicker: function(input, date, onSelect, settings, pos) {
3280 var id, browserWidth, browserHeight, scrollX, scrollY,
3281 inst = this._dialogInst; // internal instance
3282
3283 if (!inst) {
3284 this.uuid += 1;
3285 id = "dp" + this.uuid;
3286 this._dialogInput = $("<input type='text' id='" + id +
3287 "' style='position: absolute; top: -100px; width: 0px;'/>");
3288 this._dialogInput.keydown(this._doKeyDown);
3289 $("body").append(this._dialogInput);
3290 inst = this._dialogInst = this._newInst(this._dialogInput, false);
3291 inst.settings = {};
3292 $.data(this._dialogInput[0], PROP_NAME, inst);
3293 }
3294 extendRemove(inst.settings, settings || {});
3295 date = (date && date.constructor === Date ? this._formatDate(inst, date) : date);
3296 this._dialogInput.val(date);
3297
3298 this._pos = (pos ? (pos.length ? pos : [pos.pageX, pos.pageY]) : null);
3299 if (!this._pos) {
3300 browserWidth = document.documentElement.clientWidth;
3301 browserHeight = document.documentElement.clientHeight;
3302 scrollX = document.documentElement.scrollLeft || document.body.scrollLeft;
3303 scrollY = document.documentElement.scrollTop || document.body.scrollTop;
3304 this._pos = // should use actual width/height below
3305 [(browserWidth / 2) - 100 + scrollX, (browserHeight / 2) - 150 + scrollY];
3306 }
3307
3308 // move input on screen for focus, but hidden behind dialog
3309 this._dialogInput.css("left", (this._pos[0] + 20) + "px").css("top", this._pos[1] + "px");
3310 inst.settings.onSelect = onSelect;
3311 this._inDialog = true;
3312 this.dpDiv.addClass(this._dialogClass);
3313 this._showDatepicker(this._dialogInput[0]);
3314 if ($.blockUI) {
3315 $.blockUI(this.dpDiv);
3316 }
3317 $.data(this._dialogInput[0], PROP_NAME, inst);
3318 return this;
3319 },
3320
3321 /* Detach a datepicker from its control.
3322 * @param target element - the target input field or division or span
3323 */
3324 _destroyDatepicker: function(target) {
3325 var nodeName,
3326 $target = $(target),
3327 inst = $.data(target, PROP_NAME);
3328
3329 if (!$target.hasClass(this.markerClassName)) {
3330 return;
3331 }
3332
3333 nodeName = target.nodeName.toLowerCase();
3334 $.removeData(target, PROP_NAME);
3335 if (nodeName === "input") {
3336 inst.append.remove();
3337 inst.trigger.remove();
3338 $target.removeClass(this.markerClassName).
3339 unbind("focus", this._showDatepicker).
3340 unbind("keydown", this._doKeyDown).
3341 unbind("keypress", this._doKeyPress).
3342 unbind("keyup", this._doKeyUp);
3343 } else if (nodeName === "div" || nodeName === "span") {
3344 $target.removeClass(this.markerClassName).empty();
3345 }
3346 },
3347
3348 /* Enable the date picker to a jQuery selection.
3349 * @param target element - the target input field or division or span
3350 */
3351 _enableDatepicker: function(target) {
3352 var nodeName, inline,
3353 $target = $(target),
3354 inst = $.data(target, PROP_NAME);
3355
3356 if (!$target.hasClass(this.markerClassName)) {
3357 return;
3358 }
3359
3360 nodeName = target.nodeName.toLowerCase();
3361 if (nodeName === "input") {
3362 target.disabled = false;
3363 inst.trigger.filter("button").
3364 each(function() { this.disabled = false; }).end().
3365 filter("img").css({opacity: "1.0", cursor: ""});
3366 } else if (nodeName === "div" || nodeName === "span") {
3367 inline = $target.children("." + this._inlineClass);
3368 inline.children().removeClass("ui-state-disabled");
3369 inline.find("select.ui-datepicker-month, select.ui-datepicker-year").
3370 prop("disabled", false);
3371 }
3372 this._disabledInputs = $.map(this._disabledInputs,
3373 function(value) { return (value === target ? null : value); }); // delete entry
3374 },
3375
3376 /* Disable the date picker to a jQuery selection.
3377 * @param target element - the target input field or division or span
3378 */
3379 _disableDatepicker: function(target) {
3380 var nodeName, inline,
3381 $target = $(target),
3382 inst = $.data(target, PROP_NAME);
3383
3384 if (!$target.hasClass(this.markerClassName)) {
3385 return;
3386 }
3387
3388 nodeName = target.nodeName.toLowerCase();
3389 if (nodeName === "input") {
3390 target.disabled = true;
3391 inst.trigger.filter("button").
3392 each(function() { this.disabled = true; }).end().
3393 filter("img").css({opacity: "0.5", cursor: "default"});
3394 } else if (nodeName === "div" || nodeName === "span") {
3395 inline = $target.children("." + this._inlineClass);
3396 inline.children().addClass("ui-state-disabled");
3397 inline.find("select.ui-datepicker-month, select.ui-datepicker-year").
3398 prop("disabled", true);
3399 }
3400 this._disabledInputs = $.map(this._disabledInputs,
3401 function(value) { return (value === target ? null : value); }); // delete entry
3402 this._disabledInputs[this._disabledInputs.length] = target;
3403 },
3404
3405 /* Is the first field in a jQuery collection disabled as a datepicker?
3406 * @param target element - the target input field or division or span
3407 * @return boolean - true if disabled, false if enabled
3408 */
3409 _isDisabledDatepicker: function(target) {
3410 if (!target) {
3411 return false;
3412 }
3413 for (var i = 0; i < this._disabledInputs.length; i++) {
3414 if (this._disabledInputs[i] === target) {
3415 return true;
3416 }
3417 }
3418 return false;
3419 },
3420
3421 /* Retrieve the instance data for the target control.
3422 * @param target element - the target input field or division or span
3423 * @return object - the associated instance data
3424 * @throws error if a jQuery problem getting data
3425 */
3426 _getInst: function(target) {
3427 try {
3428 return $.data(target, PROP_NAME);
3429 }
3430 catch (err) {
3431 throw "Missing instance data for this datepicker";
3432 }
3433 },
3434
3435 /* Update or retrieve the settings for a date picker attached to an input field or division.
3436 * @param target element - the target input field or division or span
3437 * @param name object - the new settings to update or
3438 * string - the name of the setting to change or retrieve,
3439 * when retrieving also "all" for all instance settings or
3440 * "defaults" for all global defaults
3441 * @param value any - the new value for the setting
3442 * (omit if above is an object or to retrieve a value)
3443 */
3444 _optionDatepicker: function(target, name, value) {
3445 var settings, date, minDate, maxDate,
3446 inst = this._getInst(target);
3447
3448 if (arguments.length === 2 && typeof name === "string") {
3449 return (name === "defaults" ? $.extend({}, $.datepicker._defaults) :
3450 (inst ? (name === "all" ? $.extend({}, inst.settings) :
3451 this._get(inst, name)) : null));
3452 }
3453
3454 settings = name || {};
3455 if (typeof name === "string") {
3456 settings = {};
3457 settings[name] = value;
3458 }
3459
3460 if (inst) {
3461 if (this._curInst === inst) {
3462 this._hideDatepicker();
3463 }
3464
3465 date = this._getDateDatepicker(target, true);
3466 minDate = this._getMinMaxDate(inst, "min");
3467 maxDate = this._getMinMaxDate(inst, "max");
3468 extendRemove(inst.settings, settings);
3469 // reformat the old minDate/maxDate values if dateFormat changes and a new minDate/maxDate isn't provided
3470 if (minDate !== null && settings.dateFormat !== undefined && settings.minDate === undefined) {
3471 inst.settings.minDate = this._formatDate(inst, minDate);
3472 }
3473 if (maxDate !== null && settings.dateFormat !== undefined && settings.maxDate === undefined) {
3474 inst.settings.maxDate = this._formatDate(inst, maxDate);
3475 }
3476 if ( "disabled" in settings ) {
3477 if ( settings.disabled ) {
3478 this._disableDatepicker(target);
3479 } else {
3480 this._enableDatepicker(target);
3481 }
3482 }
3483 this._attachments($(target), inst);
3484 this._autoSize(inst);
3485 this._setDate(inst, date);
3486 this._updateAlternate(inst);
3487 this._updateDatepicker(inst);
3488 }
3489 },
3490
3491 // change method deprecated
3492 _changeDatepicker: function(target, name, value) {
3493 this._optionDatepicker(target, name, value);
3494 },
3495
3496 /* Redraw the date picker attached to an input field or division.
3497 * @param target element - the target input field or division or span
3498 */
3499 _refreshDatepicker: function(target) {
3500 var inst = this._getInst(target);
3501 if (inst) {
3502 this._updateDatepicker(inst);
3503 }
3504 },
3505
3506 /* Set the dates for a jQuery selection.
3507 * @param target element - the target input field or division or span
3508 * @param date Date - the new date
3509 */
3510 _setDateDatepicker: function(target, date) {
3511 var inst = this._getInst(target);
3512 if (inst) {
3513 this._setDate(inst, date);
3514 this._updateDatepicker(inst);
3515 this._updateAlternate(inst);
3516 }
3517 },
3518
3519 /* Get the date(s) for the first entry in a jQuery selection.
3520 * @param target element - the target input field or division or span
3521 * @param noDefault boolean - true if no default date is to be used
3522 * @return Date - the current date
3523 */
3524 _getDateDatepicker: function(target, noDefault) {
3525 var inst = this._getInst(target);
3526 if (inst && !inst.inline) {
3527 this._setDateFromField(inst, noDefault);
3528 }
3529 return (inst ? this._getDate(inst) : null);
3530 },
3531
3532 /* Handle keystrokes. */
3533 _doKeyDown: function(event) {
3534 var onSelect, dateStr, sel,
3535 inst = $.datepicker._getInst(event.target),
3536 handled = true,
3537 isRTL = inst.dpDiv.is(".ui-datepicker-rtl");
3538
3539 inst._keyEvent = true;
3540 if ($.datepicker._datepickerShowing) {
3541 switch (event.keyCode) {
3542 case 9: $.datepicker._hideDatepicker();
3543 handled = false;
3544 break; // hide on tab out
3545 case 13: sel = $("td." + $.datepicker._dayOverClass + ":not(." +
3546 $.datepicker._currentClass + ")", inst.dpDiv);
3547 if (sel[0]) {
3548 $.datepicker._selectDay(event.target, inst.selectedMonth, inst.selectedYear, sel[0]);
3549 }
3550
3551 onSelect = $.datepicker._get(inst, "onSelect");
3552 if (onSelect) {
3553 dateStr = $.datepicker._formatDate(inst);
3554
3555 // trigger custom callback
3556 onSelect.apply((inst.input ? inst.input[0] : null), [dateStr, inst]);
3557 } else {
3558 $.datepicker._hideDatepicker();
3559 }
3560
3561 return false; // don't submit the form
3562 case 27: $.datepicker._hideDatepicker();
3563 break; // hide on escape
3564 case 33: $.datepicker._adjustDate(event.target, (event.ctrlKey ?
3565 -$.datepicker._get(inst, "stepBigMonths") :
3566 -$.datepicker._get(inst, "stepMonths")), "M");
3567 break; // previous month/year on page up/+ ctrl
3568 case 34: $.datepicker._adjustDate(event.target, (event.ctrlKey ?
3569 +$.datepicker._get(inst, "stepBigMonths") :
3570 +$.datepicker._get(inst, "stepMonths")), "M");
3571 break; // next month/year on page down/+ ctrl
3572 case 35: if (event.ctrlKey || event.metaKey) {
3573 $.datepicker._clearDate(event.target);
3574 }
3575 handled = event.ctrlKey || event.metaKey;
3576 break; // clear on ctrl or command +end
3577 case 36: if (event.ctrlKey || event.metaKey) {
3578 $.datepicker._gotoToday(event.target);
3579 }
3580 handled = event.ctrlKey || event.metaKey;
3581 break; // current on ctrl or command +home
3582 case 37: if (event.ctrlKey || event.metaKey) {
3583 $.datepicker._adjustDate(event.target, (isRTL ? +1 : -1), "D");
3584 }
3585 handled = event.ctrlKey || event.metaKey;
3586 // -1 day on ctrl or command +left
3587 if (event.originalEvent.altKey) {
3588 $.datepicker._adjustDate(event.target, (event.ctrlKey ?
3589 -$.datepicker._get(inst, "stepBigMonths") :
3590 -$.datepicker._get(inst, "stepMonths")), "M");
3591 }
3592 // next month/year on alt +left on Mac
3593 break;
3594 case 38: if (event.ctrlKey || event.metaKey) {
3595 $.datepicker._adjustDate(event.target, -7, "D");
3596 }
3597 handled = event.ctrlKey || event.metaKey;
3598 break; // -1 week on ctrl or command +up
3599 case 39: if (event.ctrlKey || event.metaKey) {
3600 $.datepicker._adjustDate(event.target, (isRTL ? -1 : +1), "D");
3601 }
3602 handled = event.ctrlKey || event.metaKey;
3603 // +1 day on ctrl or command +right
3604 if (event.originalEvent.altKey) {
3605 $.datepicker._adjustDate(event.target, (event.ctrlKey ?
3606 +$.datepicker._get(inst, "stepBigMonths") :
3607 +$.datepicker._get(inst, "stepMonths")), "M");
3608 }
3609 // next month/year on alt +right
3610 break;
3611 case 40: if (event.ctrlKey || event.metaKey) {
3612 $.datepicker._adjustDate(event.target, +7, "D");
3613 }
3614 handled = event.ctrlKey || event.metaKey;
3615 break; // +1 week on ctrl or command +down
3616 default: handled = false;
3617 }
3618 } else if (event.keyCode === 36 && event.ctrlKey) { // display the date picker on ctrl+home
3619 $.datepicker._showDatepicker(this);
3620 } else {
3621 handled = false;
3622 }
3623
3624 if (handled) {
3625 event.preventDefault();
3626 event.stopPropagation();
3627 }
3628 },
3629
3630 /* Filter entered characters - based on date format. */
3631 _doKeyPress: function(event) {
3632 var chars, chr,
3633 inst = $.datepicker._getInst(event.target);
3634
3635 if ($.datepicker._get(inst, "constrainInput")) {
3636 chars = $.datepicker._possibleChars($.datepicker._get(inst, "dateFormat"));
3637 chr = String.fromCharCode(event.charCode == null ? event.keyCode : event.charCode);
3638 return event.ctrlKey || event.metaKey || (chr < " " || !chars || chars.indexOf(chr) > -1);
3639 }
3640 },
3641
3642 /* Synchronise manual entry and field/alternate field. */
3643 _doKeyUp: function(event) {
3644 var date,
3645 inst = $.datepicker._getInst(event.target);
3646
3647 if (inst.input.val() !== inst.lastVal) {
3648 try {
3649 date = $.datepicker.parseDate($.datepicker._get(inst, "dateFormat"),
3650 (inst.input ? inst.input.val() : null),
3651 $.datepicker._getFormatConfig(inst));
3652
3653 if (date) { // only if valid
3654 $.datepicker._setDateFromField(inst);
3655 $.datepicker._updateAlternate(inst);
3656 $.datepicker._updateDatepicker(inst);
3657 }
3658 }
3659 catch (err) {
3660 }
3661 }
3662 return true;
3663 },
3664
3665 /* Pop-up the date picker for a given input field.
3666 * If false returned from beforeShow event handler do not show.
3667 * @param input element - the input field attached to the date picker or
3668 * event - if triggered by focus
3669 */
3670 _showDatepicker: function(input) {
3671 input = input.target || input;
3672 if (input.nodeName.toLowerCase() !== "input") { // find from button/image trigger
3673 input = $("input", input.parentNode)[0];
3674 }
3675
3676 if ($.datepicker._isDisabledDatepicker(input) || $.datepicker._lastInput === input) { // already here
3677 return;
3678 }
3679
3680 var inst, beforeShow, beforeShowSettings, isFixed,
3681 offset, showAnim, duration;
3682
3683 inst = $.datepicker._getInst(input);
3684 if ($.datepicker._curInst && $.datepicker._curInst !== inst) {
3685 $.datepicker._curInst.dpDiv.stop(true, true);
3686 if ( inst && $.datepicker._datepickerShowing ) {
3687 $.datepicker._hideDatepicker( $.datepicker._curInst.input[0] );
3688 }
3689 }
3690
3691 beforeShow = $.datepicker._get(inst, "beforeShow");
3692 beforeShowSettings = beforeShow ? beforeShow.apply(input, [input, inst]) : {};
3693 if(beforeShowSettings === false){
3694 return;
3695 }
3696 extendRemove(inst.settings, beforeShowSettings);
3697
3698 inst.lastVal = null;
3699 $.datepicker._lastInput = input;
3700 $.datepicker._setDateFromField(inst);
3701
3702 if ($.datepicker._inDialog) { // hide cursor
3703 input.value = "";
3704 }
3705 if (!$.datepicker._pos) { // position below input
3706 $.datepicker._pos = $.datepicker._findPos(input);
3707 $.datepicker._pos[1] += input.offsetHeight; // add the height
3708 }
3709
3710 isFixed = false;
3711 $(input).parents().each(function() {
3712 isFixed |= $(this).css("position") === "fixed";
3713 return !isFixed;
3714 });
3715
3716 offset = {left: $.datepicker._pos[0], top: $.datepicker._pos[1]};
3717 $.datepicker._pos = null;
3718 //to avoid flashes on Firefox
3719 inst.dpDiv.empty();
3720 // determine sizing offscreen
3721 inst.dpDiv.css({position: "absolute", display: "block", top: "-1000px"});
3722 $.datepicker._updateDatepicker(inst);
3723 // fix width for dynamic number of date pickers
3724 // and adjust position before showing
3725 offset = $.datepicker._checkOffset(inst, offset, isFixed);
3726 inst.dpDiv.css({position: ($.datepicker._inDialog && $.blockUI ?
3727 "static" : (isFixed ? "fixed" : "absolute")), display: "none",
3728 left: offset.left + "px", top: offset.top + "px"});
3729
3730 if (!inst.inline) {
3731 showAnim = $.datepicker._get(inst, "showAnim");
3732 duration = $.datepicker._get(inst, "duration");
3733 inst.dpDiv.zIndex($(input).zIndex()+1);
3734 $.datepicker._datepickerShowing = true;
3735
3736 if ( $.effects && $.effects.effect[ showAnim ] ) {
3737 inst.dpDiv.show(showAnim, $.datepicker._get(inst, "showOptions"), duration);
3738 } else {
3739 inst.dpDiv[showAnim || "show"](showAnim ? duration : null);
3740 }
3741
3742 if ( $.datepicker._shouldFocusInput( inst ) ) {
3743 inst.input.focus();
3744 }
3745
3746 $.datepicker._curInst = inst;
3747 }
3748 },
3749
3750 /* Generate the date picker content. */
3751 _updateDatepicker: function(inst) {
3752 this.maxRows = 4; //Reset the max number of rows being displayed (see #7043)
3753 instActive = inst; // for delegate hover events
3754 inst.dpDiv.empty().append(this._generateHTML(inst));
3755 this._attachHandlers(inst);
3756 inst.dpDiv.find("." + this._dayOverClass + " a").mouseover();
3757
3758 var origyearshtml,
3759 numMonths = this._getNumberOfMonths(inst),
3760 cols = numMonths[1],
3761 width = 17;
3762
3763 inst.dpDiv.removeClass("ui-datepicker-multi-2 ui-datepicker-multi-3 ui-datepicker-multi-4").width("");
3764 if (cols > 1) {
3765 inst.dpDiv.addClass("ui-datepicker-multi-" + cols).css("width", (width * cols) + "em");
3766 }
3767 inst.dpDiv[(numMonths[0] !== 1 || numMonths[1] !== 1 ? "add" : "remove") +
3768 "Class"]("ui-datepicker-multi");
3769 inst.dpDiv[(this._get(inst, "isRTL") ? "add" : "remove") +
3770 "Class"]("ui-datepicker-rtl");
3771
3772 if (inst === $.datepicker._curInst && $.datepicker._datepickerShowing && $.datepicker._shouldFocusInput( inst ) ) {
3773 inst.input.focus();
3774 }
3775
3776 // deffered render of the years select (to avoid flashes on Firefox)
3777 if( inst.yearshtml ){
3778 origyearshtml = inst.yearshtml;
3779 setTimeout(function(){
3780 //assure that inst.yearshtml didn't change.
3781 if( origyearshtml === inst.yearshtml && inst.yearshtml ){
3782 inst.dpDiv.find("select.ui-datepicker-year:first").replaceWith(inst.yearshtml);
3783 }
3784 origyearshtml = inst.yearshtml = null;
3785 }, 0);
3786 }
3787 },
3788
3789 // #6694 - don't focus the input if it's already focused
3790 // this breaks the change event in IE
3791 // Support: IE and jQuery <1.9
3792 _shouldFocusInput: function( inst ) {
3793 return inst.input && inst.input.is( ":visible" ) && !inst.input.is( ":disabled" ) && !inst.input.is( ":focus" );
3794 },
3795
3796 /* Check positioning to remain on screen. */
3797 _checkOffset: function(inst, offset, isFixed) {
3798 var dpWidth = inst.dpDiv.outerWidth(),
3799 dpHeight = inst.dpDiv.outerHeight(),
3800 inputWidth = inst.input ? inst.input.outerWidth() : 0,
3801 inputHeight = inst.input ? inst.input.outerHeight() : 0,
3802 viewWidth = document.documentElement.clientWidth + (isFixed ? 0 : $(document).scrollLeft()),
3803 viewHeight = document.documentElement.clientHeight + (isFixed ? 0 : $(document).scrollTop());
3804
3805 offset.left -= (this._get(inst, "isRTL") ? (dpWidth - inputWidth) : 0);
3806 offset.left -= (isFixed && offset.left === inst.input.offset().left) ? $(document).scrollLeft() : 0;
3807 offset.top -= (isFixed && offset.top === (inst.input.offset().top + inputHeight)) ? $(document).scrollTop() : 0;
3808
3809 // now check if datepicker is showing outside window viewport - move to a better place if so.
3810 offset.left -= Math.min(offset.left, (offset.left + dpWidth > viewWidth && viewWidth > dpWidth) ?
3811 Math.abs(offset.left + dpWidth - viewWidth) : 0);
3812 offset.top -= Math.min(offset.top, (offset.top + dpHeight > viewHeight && viewHeight > dpHeight) ?
3813 Math.abs(dpHeight + inputHeight) : 0);
3814
3815 return offset;
3816 },
3817
3818 /* Find an object's position on the screen. */
3819 _findPos: function(obj) {
3820 var position,
3821 inst = this._getInst(obj),
3822 isRTL = this._get(inst, "isRTL");
3823
3824 while (obj && (obj.type === "hidden" || obj.nodeType !== 1 || $.expr.filters.hidden(obj))) {
3825 obj = obj[isRTL ? "previousSibling" : "nextSibling"];
3826 }
3827
3828 position = $(obj).offset();
3829 return [position.left, position.top];
3830 },
3831
3832 /* Hide the date picker from view.
3833 * @param input element - the input field attached to the date picker
3834 */
3835 _hideDatepicker: function(input) {
3836 var showAnim, duration, postProcess, onClose,
3837 inst = this._curInst;
3838
3839 if (!inst || (input && inst !== $.data(input, PROP_NAME))) {
3840 return;
3841 }
3842
3843 if (this._datepickerShowing) {
3844 showAnim = this._get(inst, "showAnim");
3845 duration = this._get(inst, "duration");
3846 postProcess = function() {
3847 $.datepicker._tidyDialog(inst);
3848 };
3849
3850 // DEPRECATED: after BC for 1.8.x $.effects[ showAnim ] is not needed
3851 if ( $.effects && ( $.effects.effect[ showAnim ] || $.effects[ showAnim ] ) ) {
3852 inst.dpDiv.hide(showAnim, $.datepicker._get(inst, "showOptions"), duration, postProcess);
3853 } else {
3854 inst.dpDiv[(showAnim === "slideDown" ? "slideUp" :
3855 (showAnim === "fadeIn" ? "fadeOut" : "hide"))]((showAnim ? duration : null), postProcess);
3856 }
3857
3858 if (!showAnim) {
3859 postProcess();
3860 }
3861 this._datepickerShowing = false;
3862
3863 onClose = this._get(inst, "onClose");
3864 if (onClose) {
3865 onClose.apply((inst.input ? inst.input[0] : null), [(inst.input ? inst.input.val() : ""), inst]);
3866 }
3867
3868 this._lastInput = null;
3869 if (this._inDialog) {
3870 this._dialogInput.css({ position: "absolute", left: "0", top: "-100px" });
3871 if ($.blockUI) {
3872 $.unblockUI();
3873 $("body").append(this.dpDiv);
3874 }
3875 }
3876 this._inDialog = false;
3877 }
3878 },
3879
3880 /* Tidy up after a dialog display. */
3881 _tidyDialog: function(inst) {
3882 inst.dpDiv.removeClass(this._dialogClass).unbind(".ui-datepicker-calendar");
3883 },
3884
3885 /* Close date picker if clicked elsewhere. */
3886 _checkExternalClick: function(event) {
3887 if (!$.datepicker._curInst) {
3888 return;
3889 }
3890
3891 var $target = $(event.target),
3892 inst = $.datepicker._getInst($target[0]);
3893
3894 if ( ( ( $target[0].id !== $.datepicker._mainDivId &&
3895 $target.parents("#" + $.datepicker._mainDivId).length === 0 &&
3896 !$target.hasClass($.datepicker.markerClassName) &&
3897 !$target.closest("." + $.datepicker._triggerClass).length &&
3898 $.datepicker._datepickerShowing && !($.datepicker._inDialog && $.blockUI) ) ) ||
3899 ( $target.hasClass($.datepicker.markerClassName) && $.datepicker._curInst !== inst ) ) {
3900 $.datepicker._hideDatepicker();
3901 }
3902 },
3903
3904 /* Adjust one of the date sub-fields. */
3905 _adjustDate: function(id, offset, period) {
3906 var target = $(id),
3907 inst = this._getInst(target[0]);
3908
3909 if (this._isDisabledDatepicker(target[0])) {
3910 return;
3911 }
3912 this._adjustInstDate(inst, offset +
3913 (period === "M" ? this._get(inst, "showCurrentAtPos") : 0), // undo positioning
3914 period);
3915 this._updateDatepicker(inst);
3916 },
3917
3918 /* Action for current link. */
3919 _gotoToday: function(id) {
3920 var date,
3921 target = $(id),
3922 inst = this._getInst(target[0]);
3923
3924 if (this._get(inst, "gotoCurrent") && inst.currentDay) {
3925 inst.selectedDay = inst.currentDay;
3926 inst.drawMonth = inst.selectedMonth = inst.currentMonth;
3927 inst.drawYear = inst.selectedYear = inst.currentYear;
3928 } else {
3929 date = new Date();
3930 inst.selectedDay = date.getDate();
3931 inst.drawMonth = inst.selectedMonth = date.getMonth();
3932 inst.drawYear = inst.selectedYear = date.getFullYear();
3933 }
3934 this._notifyChange(inst);
3935 this._adjustDate(target);
3936 },
3937
3938 /* Action for selecting a new month/year. */
3939 _selectMonthYear: function(id, select, period) {
3940 var target = $(id),
3941 inst = this._getInst(target[0]);
3942
3943 inst["selected" + (period === "M" ? "Month" : "Year")] =
3944 inst["draw" + (period === "M" ? "Month" : "Year")] =
3945 parseInt(select.options[select.selectedIndex].value,10);
3946
3947 this._notifyChange(inst);
3948 this._adjustDate(target);
3949 },
3950
3951 /* Action for selecting a day. */
3952 _selectDay: function(id, month, year, td) {
3953 var inst,
3954 target = $(id);
3955
3956 if ($(td).hasClass(this._unselectableClass) || this._isDisabledDatepicker(target[0])) {
3957 return;
3958 }
3959
3960 inst = this._getInst(target[0]);
3961 inst.selectedDay = inst.currentDay = $("a", td).html();
3962 inst.selectedMonth = inst.currentMonth = month;
3963 inst.selectedYear = inst.currentYear = year;
3964 this._selectDate(id, this._formatDate(inst,
3965 inst.currentDay, inst.currentMonth, inst.currentYear));
3966 },
3967
3968 /* Erase the input field and hide the date picker. */
3969 _clearDate: function(id) {
3970 var target = $(id);
3971 this._selectDate(target, "");
3972 },
3973
3974 /* Update the input field with the selected date. */
3975 _selectDate: function(id, dateStr) {
3976 var onSelect,
3977 target = $(id),
3978 inst = this._getInst(target[0]);
3979
3980 dateStr = (dateStr != null ? dateStr : this._formatDate(inst));
3981 if (inst.input) {
3982 inst.input.val(dateStr);
3983 }
3984 this._updateAlternate(inst);
3985
3986 onSelect = this._get(inst, "onSelect");
3987 if (onSelect) {
3988 onSelect.apply((inst.input ? inst.input[0] : null), [dateStr, inst]); // trigger custom callback
3989 } else if (inst.input) {
3990 inst.input.trigger("change"); // fire the change event
3991 }
3992
3993 if (inst.inline){
3994 this._updateDatepicker(inst);
3995 } else {
3996 this._hideDatepicker();
3997 this._lastInput = inst.input[0];
3998 if (typeof(inst.input[0]) !== "object") {
3999 inst.input.focus(); // restore focus
4000 }
4001 this._lastInput = null;
4002 }
4003 },
4004
4005 /* Update any alternate field to synchronise with the main field. */
4006 _updateAlternate: function(inst) {
4007 var altFormat, date, dateStr,
4008 altField = this._get(inst, "altField");
4009
4010 if (altField) { // update alternate field too
4011 altFormat = this._get(inst, "altFormat") || this._get(inst, "dateFormat");
4012 date = this._getDate(inst);
4013 dateStr = this.formatDate(altFormat, date, this._getFormatConfig(inst));
4014 $(altField).each(function() { $(this).val(dateStr); });
4015 }
4016 },
4017
4018 /* Set as beforeShowDay function to prevent selection of weekends.
4019 * @param date Date - the date to customise
4020 * @return [boolean, string] - is this date selectable?, what is its CSS class?
4021 */
4022 noWeekends: function(date) {
4023 var day = date.getDay();
4024 return [(day > 0 && day < 6), ""];
4025 },
4026
4027 /* Set as calculateWeek to determine the week of the year based on the ISO 8601 definition.
4028 * @param date Date - the date to get the week for
4029 * @return number - the number of the week within the year that contains this date
4030 */
4031 iso8601Week: function(date) {
4032 var time,
4033 checkDate = new Date(date.getTime());
4034
4035 // Find Thursday of this week starting on Monday
4036 checkDate.setDate(checkDate.getDate() + 4 - (checkDate.getDay() || 7));
4037
4038 time = checkDate.getTime();
4039 checkDate.setMonth(0); // Compare with Jan 1
4040 checkDate.setDate(1);
4041 return Math.floor(Math.round((time - checkDate) / 86400000) / 7) + 1;
4042 },
4043
4044 /* Parse a string value into a date object.
4045 * See formatDate below for the possible formats.
4046 *
4047 * @param format string - the expected format of the date
4048 * @param value string - the date in the above format
4049 * @param settings Object - attributes include:
4050 * shortYearCutoff number - the cutoff year for determining the century (optional)
4051 * dayNamesShort string[7] - abbreviated names of the days from Sunday (optional)
4052 * dayNames string[7] - names of the days from Sunday (optional)
4053 * monthNamesShort string[12] - abbreviated names of the months (optional)
4054 * monthNames string[12] - names of the months (optional)
4055 * @return Date - the extracted date value or null if value is blank
4056 */
4057 parseDate: function (format, value, settings) {
4058 if (format == null || value == null) {
4059 throw "Invalid arguments";
4060 }
4061
4062 value = (typeof value === "object" ? value.toString() : value + "");
4063 if (value === "") {
4064 return null;
4065 }
4066
4067 var iFormat, dim, extra,
4068 iValue = 0,
4069 shortYearCutoffTemp = (settings ? settings.shortYearCutoff : null) || this._defaults.shortYearCutoff,
4070 shortYearCutoff = (typeof shortYearCutoffTemp !== "string" ? shortYearCutoffTemp :
4071 new Date().getFullYear() % 100 + parseInt(shortYearCutoffTemp, 10)),
4072 dayNamesShort = (settings ? settings.dayNamesShort : null) || this._defaults.dayNamesShort,
4073 dayNames = (settings ? settings.dayNames : null) || this._defaults.dayNames,
4074 monthNamesShort = (settings ? settings.monthNamesShort : null) || this._defaults.monthNamesShort,
4075 monthNames = (settings ? settings.monthNames : null) || this._defaults.monthNames,
4076 year = -1,
4077 month = -1,
4078 day = -1,
4079 doy = -1,
4080 literal = false,
4081 date,
4082 // Check whether a format character is doubled
4083 lookAhead = function(match) {
4084 var matches = (iFormat + 1 < format.length && format.charAt(iFormat + 1) === match);
4085 if (matches) {
4086 iFormat++;
4087 }
4088 return matches;
4089 },
4090 // Extract a number from the string value
4091 getNumber = function(match) {
4092 var isDoubled = lookAhead(match),
4093 size = (match === "@" ? 14 : (match === "!" ? 20 :
4094 (match === "y" && isDoubled ? 4 : (match === "o" ? 3 : 2)))),
4095 digits = new RegExp("^\\d{1," + size + "}"),
4096 num = value.substring(iValue).match(digits);
4097 if (!num) {
4098 throw "Missing number at position " + iValue;
4099 }
4100 iValue += num[0].length;
4101 return parseInt(num[0], 10);
4102 },
4103 // Extract a name from the string value and convert to an index
4104 getName = function(match, shortNames, longNames) {
4105 var index = -1,
4106 names = $.map(lookAhead(match) ? longNames : shortNames, function (v, k) {
4107 return [ [k, v] ];
4108 }).sort(function (a, b) {
4109 return -(a[1].length - b[1].length);
4110 });
4111
4112 $.each(names, function (i, pair) {
4113 var name = pair[1];
4114 if (value.substr(iValue, name.length).toLowerCase() === name.toLowerCase()) {
4115 index = pair[0];
4116 iValue += name.length;
4117 return false;
4118 }
4119 });
4120 if (index !== -1) {
4121 return index + 1;
4122 } else {
4123 throw "Unknown name at position " + iValue;
4124 }
4125 },
4126 // Confirm that a literal character matches the string value
4127 checkLiteral = function() {
4128 if (value.charAt(iValue) !== format.charAt(iFormat)) {
4129 throw "Unexpected literal at position " + iValue;
4130 }
4131 iValue++;
4132 };
4133
4134 for (iFormat = 0; iFormat < format.length; iFormat++) {
4135 if (literal) {
4136 if (format.charAt(iFormat) === "'" && !lookAhead("'")) {
4137 literal = false;
4138 } else {
4139 checkLiteral();
4140 }
4141 } else {
4142 switch (format.charAt(iFormat)) {
4143 case "d":
4144 day = getNumber("d");
4145 break;
4146 case "D":
4147 getName("D", dayNamesShort, dayNames);
4148 break;
4149 case "o":
4150 doy = getNumber("o");
4151 break;
4152 case "m":
4153 month = getNumber("m");
4154 break;
4155 case "M":
4156 month = getName("M", monthNamesShort, monthNames);
4157 break;
4158 case "y":
4159 year = getNumber("y");
4160 break;
4161 case "@":
4162 date = new Date(getNumber("@"));
4163 year = date.getFullYear();
4164 month = date.getMonth() + 1;
4165 day = date.getDate();
4166 break;
4167 case "!":
4168 date = new Date((getNumber("!") - this._ticksTo1970) / 10000);
4169 year = date.getFullYear();
4170 month = date.getMonth() + 1;
4171 day = date.getDate();
4172 break;
4173 case "'":
4174 if (lookAhead("'")){
4175 checkLiteral();
4176 } else {
4177 literal = true;
4178 }
4179 break;
4180 default:
4181 checkLiteral();
4182 }
4183 }
4184 }
4185
4186 if (iValue < value.length){
4187 extra = value.substr(iValue);
4188 if (!/^\s+/.test(extra)) {
4189 throw "Extra/unparsed characters found in date: " + extra;
4190 }
4191 }
4192
4193 if (year === -1) {
4194 year = new Date().getFullYear();
4195 } else if (year < 100) {
4196 year += new Date().getFullYear() - new Date().getFullYear() % 100 +
4197 (year <= shortYearCutoff ? 0 : -100);
4198 }
4199
4200 if (doy > -1) {
4201 month = 1;
4202 day = doy;
4203 do {
4204 dim = this._getDaysInMonth(year, month - 1);
4205 if (day <= dim) {
4206 break;
4207 }
4208 month++;
4209 day -= dim;
4210 } while (true);
4211 }
4212
4213 date = this._daylightSavingAdjust(new Date(year, month - 1, day));
4214 if (date.getFullYear() !== year || date.getMonth() + 1 !== month || date.getDate() !== day) {
4215 throw "Invalid date"; // E.g. 31/02/00
4216 }
4217 return date;
4218 },
4219
4220 /* Standard date formats. */
4221 ATOM: "yy-mm-dd", // RFC 3339 (ISO 8601)
4222 COOKIE: "D, dd M yy",
4223 ISO_8601: "yy-mm-dd",
4224 RFC_822: "D, d M y",
4225 RFC_850: "DD, dd-M-y",
4226 RFC_1036: "D, d M y",
4227 RFC_1123: "D, d M yy",
4228 RFC_2822: "D, d M yy",
4229 RSS: "D, d M y", // RFC 822
4230 TICKS: "!",
4231 TIMESTAMP: "@",
4232 W3C: "yy-mm-dd", // ISO 8601
4233
4234 _ticksTo1970: (((1970 - 1) * 365 + Math.floor(1970 / 4) - Math.floor(1970 / 100) +
4235 Math.floor(1970 / 400)) * 24 * 60 * 60 * 10000000),
4236
4237 /* Format a date object into a string value.
4238 * The format can be combinations of the following:
4239 * d - day of month (no leading zero)
4240 * dd - day of month (two digit)
4241 * o - day of year (no leading zeros)
4242 * oo - day of year (three digit)
4243 * D - day name short
4244 * DD - day name long
4245 * m - month of year (no leading zero)
4246 * mm - month of year (two digit)
4247 * M - month name short
4248 * MM - month name long
4249 * y - year (two digit)
4250 * yy - year (four digit)
4251 * @ - Unix timestamp (ms since 01/01/1970)
4252 * ! - Windows ticks (100ns since 01/01/0001)
4253 * "..." - literal text
4254 * '' - single quote
4255 *
4256 * @param format string - the desired format of the date
4257 * @param date Date - the date value to format
4258 * @param settings Object - attributes include:
4259 * dayNamesShort string[7] - abbreviated names of the days from Sunday (optional)
4260 * dayNames string[7] - names of the days from Sunday (optional)
4261 * monthNamesShort string[12] - abbreviated names of the months (optional)
4262 * monthNames string[12] - names of the months (optional)
4263 * @return string - the date in the above format
4264 */
4265 formatDate: function (format, date, settings) {
4266 if (!date) {
4267 return "";
4268 }
4269
4270 var iFormat,
4271 dayNamesShort = (settings ? settings.dayNamesShort : null) || this._defaults.dayNamesShort,
4272 dayNames = (settings ? settings.dayNames : null) || this._defaults.dayNames,
4273 monthNamesShort = (settings ? settings.monthNamesShort : null) || this._defaults.monthNamesShort,
4274 monthNames = (settings ? settings.monthNames : null) || this._defaults.monthNames,
4275 // Check whether a format character is doubled
4276 lookAhead = function(match) {
4277 var matches = (iFormat + 1 < format.length && format.charAt(iFormat + 1) === match);
4278 if (matches) {
4279 iFormat++;
4280 }
4281 return matches;
4282 },
4283 // Format a number, with leading zero if necessary
4284 formatNumber = function(match, value, len) {
4285 var num = "" + value;
4286 if (lookAhead(match)) {
4287 while (num.length < len) {
4288 num = "0" + num;
4289 }
4290 }
4291 return num;
4292 },
4293 // Format a name, short or long as requested
4294 formatName = function(match, value, shortNames, longNames) {
4295 return (lookAhead(match) ? longNames[value] : shortNames[value]);
4296 },
4297 output = "",
4298 literal = false;
4299
4300 if (date) {
4301 for (iFormat = 0; iFormat < format.length; iFormat++) {
4302 if (literal) {
4303 if (format.charAt(iFormat) === "'" && !lookAhead("'")) {
4304 literal = false;
4305 } else {
4306 output += format.charAt(iFormat);
4307 }
4308 } else {
4309 switch (format.charAt(iFormat)) {
4310 case "d":
4311 output += formatNumber("d", date.getDate(), 2);
4312 break;
4313 case "D":
4314 output += formatName("D", date.getDay(), dayNamesShort, dayNames);
4315 break;
4316 case "o":
4317 output += formatNumber("o",
4318 Math.round((new Date(date.getFullYear(), date.getMonth(), date.getDate()).getTime() - new Date(date.getFullYear(), 0, 0).getTime()) / 86400000), 3);
4319 break;
4320 case "m":
4321 output += formatNumber("m", date.getMonth() + 1, 2);
4322 break;
4323 case "M":
4324 output += formatName("M", date.getMonth(), monthNamesShort, monthNames);
4325 break;
4326 case "y":
4327 output += (lookAhead("y") ? date.getFullYear() :
4328 (date.getYear() % 100 < 10 ? "0" : "") + date.getYear() % 100);
4329 break;
4330 case "@":
4331 output += date.getTime();
4332 break;
4333 case "!":
4334 output += date.getTime() * 10000 + this._ticksTo1970;
4335 break;
4336 case "'":
4337 if (lookAhead("'")) {
4338 output += "'";
4339 } else {
4340 literal = true;
4341 }
4342 break;
4343 default:
4344 output += format.charAt(iFormat);
4345 }
4346 }
4347 }
4348 }
4349 return output;
4350 },
4351
4352 /* Extract all possible characters from the date format. */
4353 _possibleChars: function (format) {
4354 var iFormat,
4355 chars = "",
4356 literal = false,
4357 // Check whether a format character is doubled
4358 lookAhead = function(match) {
4359 var matches = (iFormat + 1 < format.length && format.charAt(iFormat + 1) === match);
4360 if (matches) {
4361 iFormat++;
4362 }
4363 return matches;
4364 };
4365
4366 for (iFormat = 0; iFormat < format.length; iFormat++) {
4367 if (literal) {
4368 if (format.charAt(iFormat) === "'" && !lookAhead("'")) {
4369 literal = false;
4370 } else {
4371 chars += format.charAt(iFormat);
4372 }
4373 } else {
4374 switch (format.charAt(iFormat)) {
4375 case "d": case "m": case "y": case "@":
4376 chars += "0123456789";
4377 break;
4378 case "D": case "M":
4379 return null; // Accept anything
4380 case "'":
4381 if (lookAhead("'")) {
4382 chars += "'";
4383 } else {
4384 literal = true;
4385 }
4386 break;
4387 default:
4388 chars += format.charAt(iFormat);
4389 }
4390 }
4391 }
4392 return chars;
4393 },
4394
4395 /* Get a setting value, defaulting if necessary. */
4396 _get: function(inst, name) {
4397 return inst.settings[name] !== undefined ?
4398 inst.settings[name] : this._defaults[name];
4399 },
4400
4401 /* Parse existing date and initialise date picker. */
4402 _setDateFromField: function(inst, noDefault) {
4403 if (inst.input.val() === inst.lastVal) {
4404 return;
4405 }
4406
4407 var dateFormat = this._get(inst, "dateFormat"),
4408 dates = inst.lastVal = inst.input ? inst.input.val() : null,
4409 defaultDate = this._getDefaultDate(inst),
4410 date = defaultDate,
4411 settings = this._getFormatConfig(inst);
4412
4413 try {
4414 date = this.parseDate(dateFormat, dates, settings) || defaultDate;
4415 } catch (event) {
4416 dates = (noDefault ? "" : dates);
4417 }
4418 inst.selectedDay = date.getDate();
4419 inst.drawMonth = inst.selectedMonth = date.getMonth();
4420 inst.drawYear = inst.selectedYear = date.getFullYear();
4421 inst.currentDay = (dates ? date.getDate() : 0);
4422 inst.currentMonth = (dates ? date.getMonth() : 0);
4423 inst.currentYear = (dates ? date.getFullYear() : 0);
4424 this._adjustInstDate(inst);
4425 },
4426
4427 /* Retrieve the default date shown on opening. */
4428 _getDefaultDate: function(inst) {
4429 return this._restrictMinMax(inst,
4430 this._determineDate(inst, this._get(inst, "defaultDate"), new Date()));
4431 },
4432
4433 /* A date may be specified as an exact value or a relative one. */
4434 _determineDate: function(inst, date, defaultDate) {
4435 var offsetNumeric = function(offset) {
4436 var date = new Date();
4437 date.setDate(date.getDate() + offset);
4438 return date;
4439 },
4440 offsetString = function(offset) {
4441 try {
4442 return $.datepicker.parseDate($.datepicker._get(inst, "dateFormat"),
4443 offset, $.datepicker._getFormatConfig(inst));
4444 }
4445 catch (e) {
4446 // Ignore
4447 }
4448
4449 var date = (offset.toLowerCase().match(/^c/) ?
4450 $.datepicker._getDate(inst) : null) || new Date(),
4451 year = date.getFullYear(),
4452 month = date.getMonth(),
4453 day = date.getDate(),
4454 pattern = /([+\-]?[0-9]+)\s*(d|D|w|W|m|M|y|Y)?/g,
4455 matches = pattern.exec(offset);
4456
4457 while (matches) {
4458 switch (matches[2] || "d") {
4459 case "d" : case "D" :
4460 day += parseInt(matches[1],10); break;
4461 case "w" : case "W" :
4462 day += parseInt(matches[1],10) * 7; break;
4463 case "m" : case "M" :
4464 month += parseInt(matches[1],10);
4465 day = Math.min(day, $.datepicker._getDaysInMonth(year, month));
4466 break;
4467 case "y": case "Y" :
4468 year += parseInt(matches[1],10);
4469 day = Math.min(day, $.datepicker._getDaysInMonth(year, month));
4470 break;
4471 }
4472 matches = pattern.exec(offset);
4473 }
4474 return new Date(year, month, day);
4475 },
4476 newDate = (date == null || date === "" ? defaultDate : (typeof date === "string" ? offsetString(date) :
4477 (typeof date === "number" ? (isNaN(date) ? defaultDate : offsetNumeric(date)) : new Date(date.getTime()))));
4478
4479 newDate = (newDate && newDate.toString() === "Invalid Date" ? defaultDate : newDate);
4480 if (newDate) {
4481 newDate.setHours(0);
4482 newDate.setMinutes(0);
4483 newDate.setSeconds(0);
4484 newDate.setMilliseconds(0);
4485 }
4486 return this._daylightSavingAdjust(newDate);
4487 },
4488
4489 /* Handle switch to/from daylight saving.
4490 * Hours may be non-zero on daylight saving cut-over:
4491 * > 12 when midnight changeover, but then cannot generate
4492 * midnight datetime, so jump to 1AM, otherwise reset.
4493 * @param date (Date) the date to check
4494 * @return (Date) the corrected date
4495 */
4496 _daylightSavingAdjust: function(date) {
4497 if (!date) {
4498 return null;
4499 }
4500 date.setHours(date.getHours() > 12 ? date.getHours() + 2 : 0);
4501 return date;
4502 },
4503
4504 /* Set the date(s) directly. */
4505 _setDate: function(inst, date, noChange) {
4506 var clear = !date,
4507 origMonth = inst.selectedMonth,
4508 origYear = inst.selectedYear,
4509 newDate = this._restrictMinMax(inst, this._determineDate(inst, date, new Date()));
4510
4511 inst.selectedDay = inst.currentDay = newDate.getDate();
4512 inst.drawMonth = inst.selectedMonth = inst.currentMonth = newDate.getMonth();
4513 inst.drawYear = inst.selectedYear = inst.currentYear = newDate.getFullYear();
4514 if ((origMonth !== inst.selectedMonth || origYear !== inst.selectedYear) && !noChange) {
4515 this._notifyChange(inst);
4516 }
4517 this._adjustInstDate(inst);
4518 if (inst.input) {
4519 inst.input.val(clear ? "" : this._formatDate(inst));
4520 }
4521 },
4522
4523 /* Retrieve the date(s) directly. */
4524 _getDate: function(inst) {
4525 var startDate = (!inst.currentYear || (inst.input && inst.input.val() === "") ? null :
4526 this._daylightSavingAdjust(new Date(
4527 inst.currentYear, inst.currentMonth, inst.currentDay)));
4528 return startDate;
4529 },
4530
4531 /* Attach the onxxx handlers. These are declared statically so
4532 * they work with static code transformers like Caja.
4533 */
4534 _attachHandlers: function(inst) {
4535 var stepMonths = this._get(inst, "stepMonths"),
4536 id = "#" + inst.id.replace( /\\\\/g, "\\" );
4537 inst.dpDiv.find("[data-handler]").map(function () {
4538 var handler = {
4539 prev: function () {
4540 $.datepicker._adjustDate(id, -stepMonths, "M");
4541 },
4542 next: function () {
4543 $.datepicker._adjustDate(id, +stepMonths, "M");
4544 },
4545 hide: function () {
4546 $.datepicker._hideDatepicker();
4547 },
4548 today: function () {
4549 $.datepicker._gotoToday(id);
4550 },
4551 selectDay: function () {
4552 $.datepicker._selectDay(id, +this.getAttribute("data-month"), +this.getAttribute("data-year"), this);
4553 return false;
4554 },
4555 selectMonth: function () {
4556 $.datepicker._selectMonthYear(id, this, "M");
4557 return false;
4558 },
4559 selectYear: function () {
4560 $.datepicker._selectMonthYear(id, this, "Y");
4561 return false;
4562 }
4563 };
4564 $(this).bind(this.getAttribute("data-event"), handler[this.getAttribute("data-handler")]);
4565 });
4566 },
4567
4568 /* Generate the HTML for the current state of the date picker. */
4569 _generateHTML: function(inst) {
4570 var maxDraw, prevText, prev, nextText, next, currentText, gotoDate,
4571 controls, buttonPanel, firstDay, showWeek, dayNames, dayNamesMin,
4572 monthNames, monthNamesShort, beforeShowDay, showOtherMonths,
4573 selectOtherMonths, defaultDate, html, dow, row, group, col, selectedDate,
4574 cornerClass, calender, thead, day, daysInMonth, leadDays, curRows, numRows,
4575 printDate, dRow, tbody, daySettings, otherMonth, unselectable,
4576 tempDate = new Date(),
4577 today = this._daylightSavingAdjust(
4578 new Date(tempDate.getFullYear(), tempDate.getMonth(), tempDate.getDate())), // clear time
4579 isRTL = this._get(inst, "isRTL"),
4580 showButtonPanel = this._get(inst, "showButtonPanel"),
4581 hideIfNoPrevNext = this._get(inst, "hideIfNoPrevNext"),
4582 navigationAsDateFormat = this._get(inst, "navigationAsDateFormat"),
4583 numMonths = this._getNumberOfMonths(inst),
4584 showCurrentAtPos = this._get(inst, "showCurrentAtPos"),
4585 stepMonths = this._get(inst, "stepMonths"),
4586 isMultiMonth = (numMonths[0] !== 1 || numMonths[1] !== 1),
4587 currentDate = this._daylightSavingAdjust((!inst.currentDay ? new Date(9999, 9, 9) :
4588 new Date(inst.currentYear, inst.currentMonth, inst.currentDay))),
4589 minDate = this._getMinMaxDate(inst, "min"),
4590 maxDate = this._getMinMaxDate(inst, "max"),
4591 drawMonth = inst.drawMonth - showCurrentAtPos,
4592 drawYear = inst.drawYear;
4593
4594 if (drawMonth < 0) {
4595 drawMonth += 12;
4596 drawYear--;
4597 }
4598 if (maxDate) {
4599 maxDraw = this._daylightSavingAdjust(new Date(maxDate.getFullYear(),
4600 maxDate.getMonth() - (numMonths[0] * numMonths[1]) + 1, maxDate.getDate()));
4601 maxDraw = (minDate && maxDraw < minDate ? minDate : maxDraw);
4602 while (this._daylightSavingAdjust(new Date(drawYear, drawMonth, 1)) > maxDraw) {
4603 drawMonth--;
4604 if (drawMonth < 0) {
4605 drawMonth = 11;
4606 drawYear--;
4607 }
4608 }
4609 }
4610 inst.drawMonth = drawMonth;
4611 inst.drawYear = drawYear;
4612
4613 prevText = this._get(inst, "prevText");
4614 prevText = (!navigationAsDateFormat ? prevText : this.formatDate(prevText,
4615 this._daylightSavingAdjust(new Date(drawYear, drawMonth - stepMonths, 1)),
4616 this._getFormatConfig(inst)));
4617
4618 prev = (this._canAdjustMonth(inst, -1, drawYear, drawMonth) ?
4619 "<a class='ui-datepicker-prev ui-corner-all' data-handler='prev' data-event='click'" +
4620 " title='" + prevText + "'><span class='ui-icon ui-icon-circle-triangle-" + ( isRTL ? "e" : "w") + "'>" + prevText + "</span></a>" :
4621 (hideIfNoPrevNext ? "" : "<a class='ui-datepicker-prev ui-corner-all ui-state-disabled' title='"+ prevText +"'><span class='ui-icon ui-icon-circle-triangle-" + ( isRTL ? "e" : "w") + "'>" + prevText + "</span></a>"));
4622
4623 nextText = this._get(inst, "nextText");
4624 nextText = (!navigationAsDateFormat ? nextText : this.formatDate(nextText,
4625 this._daylightSavingAdjust(new Date(drawYear, drawMonth + stepMonths, 1)),
4626 this._getFormatConfig(inst)));
4627
4628 next = (this._canAdjustMonth(inst, +1, drawYear, drawMonth) ?
4629 "<a class='ui-datepicker-next ui-corner-all' data-handler='next' data-event='click'" +
4630 " title='" + nextText + "'><span class='ui-icon ui-icon-circle-triangle-" + ( isRTL ? "w" : "e") + "'>" + nextText + "</span></a>" :
4631 (hideIfNoPrevNext ? "" : "<a class='ui-datepicker-next ui-corner-all ui-state-disabled' title='"+ nextText + "'><span class='ui-icon ui-icon-circle-triangle-" + ( isRTL ? "w" : "e") + "'>" + nextText + "</span></a>"));
4632
4633 currentText = this._get(inst, "currentText");
4634 gotoDate = (this._get(inst, "gotoCurrent") && inst.currentDay ? currentDate : today);
4635 currentText = (!navigationAsDateFormat ? currentText :
4636 this.formatDate(currentText, gotoDate, this._getFormatConfig(inst)));
4637
4638 controls = (!inst.inline ? "<button type='button' class='ui-datepicker-close ui-state-default ui-priority-primary ui-corner-all' data-handler='hide' data-event='click'>" +
4639 this._get(inst, "closeText") + "</button>" : "");
4640
4641 buttonPanel = (showButtonPanel) ? "<div class='ui-datepicker-buttonpane ui-widget-content'>" + (isRTL ? controls : "") +
4642 (this._isInRange(inst, gotoDate) ? "<button type='button' class='ui-datepicker-current ui-state-default ui-priority-secondary ui-corner-all' data-handler='today' data-event='click'" +
4643 ">" + currentText + "</button>" : "") + (isRTL ? "" : controls) + "</div>" : "";
4644
4645 firstDay = parseInt(this._get(inst, "firstDay"),10);
4646 firstDay = (isNaN(firstDay) ? 0 : firstDay);
4647
4648 showWeek = this._get(inst, "showWeek");
4649 dayNames = this._get(inst, "dayNames");
4650 dayNamesMin = this._get(inst, "dayNamesMin");
4651 monthNames = this._get(inst, "monthNames");
4652 monthNamesShort = this._get(inst, "monthNamesShort");
4653 beforeShowDay = this._get(inst, "beforeShowDay");
4654 showOtherMonths = this._get(inst, "showOtherMonths");
4655 selectOtherMonths = this._get(inst, "selectOtherMonths");
4656 defaultDate = this._getDefaultDate(inst);
4657 html = "";
4658 dow;
4659 for (row = 0; row < numMonths[0]; row++) {
4660 group = "";
4661 this.maxRows = 4;
4662 for (col = 0; col < numMonths[1]; col++) {
4663 selectedDate = this._daylightSavingAdjust(new Date(drawYear, drawMonth, inst.selectedDay));
4664 cornerClass = " ui-corner-all";
4665 calender = "";
4666 if (isMultiMonth) {
4667 calender += "<div class='ui-datepicker-group";
4668 if (numMonths[1] > 1) {
4669 switch (col) {
4670 case 0: calender += " ui-datepicker-group-first";
4671 cornerClass = " ui-corner-" + (isRTL ? "right" : "left"); break;
4672 case numMonths[1]-1: calender += " ui-datepicker-group-last";
4673 cornerClass = " ui-corner-" + (isRTL ? "left" : "right"); break;
4674 default: calender += " ui-datepicker-group-middle"; cornerClass = ""; break;
4675 }
4676 }
4677 calender += "'>";
4678 }
4679 calender += "<div class='ui-datepicker-header ui-widget-header ui-helper-clearfix" + cornerClass + "'>" +
4680 (/all|left/.test(cornerClass) && row === 0 ? (isRTL ? next : prev) : "") +
4681 (/all|right/.test(cornerClass) && row === 0 ? (isRTL ? prev : next) : "") +
4682 this._generateMonthYearHeader(inst, drawMonth, drawYear, minDate, maxDate,
4683 row > 0 || col > 0, monthNames, monthNamesShort) + // draw month headers
4684 "</div><table class='ui-datepicker-calendar'><thead>" +
4685 "<tr>";
4686 thead = (showWeek ? "<th class='ui-datepicker-week-col'>" + this._get(inst, "weekHeader") + "</th>" : "");
4687 for (dow = 0; dow < 7; dow++) { // days of the week
4688 day = (dow + firstDay) % 7;
4689 thead += "<th" + ((dow + firstDay + 6) % 7 >= 5 ? " class='ui-datepicker-week-end'" : "") + ">" +
4690 "<span title='" + dayNames[day] + "'>" + dayNamesMin[day] + "</span></th>";
4691 }
4692 calender += thead + "</tr></thead><tbody>";
4693 daysInMonth = this._getDaysInMonth(drawYear, drawMonth);
4694 if (drawYear === inst.selectedYear && drawMonth === inst.selectedMonth) {
4695 inst.selectedDay = Math.min(inst.selectedDay, daysInMonth);
4696 }
4697 leadDays = (this._getFirstDayOfMonth(drawYear, drawMonth) - firstDay + 7) % 7;
4698 curRows = Math.ceil((leadDays + daysInMonth) / 7); // calculate the number of rows to generate
4699 numRows = (isMultiMonth ? this.maxRows > curRows ? this.maxRows : curRows : curRows); //If multiple months, use the higher number of rows (see #7043)
4700 this.maxRows = numRows;
4701 printDate = this._daylightSavingAdjust(new Date(drawYear, drawMonth, 1 - leadDays));
4702 for (dRow = 0; dRow < numRows; dRow++) { // create date picker rows
4703 calender += "<tr>";
4704 tbody = (!showWeek ? "" : "<td class='ui-datepicker-week-col'>" +
4705 this._get(inst, "calculateWeek")(printDate) + "</td>");
4706 for (dow = 0; dow < 7; dow++) { // create date picker days
4707 daySettings = (beforeShowDay ?
4708 beforeShowDay.apply((inst.input ? inst.input[0] : null), [printDate]) : [true, ""]);
4709 otherMonth = (printDate.getMonth() !== drawMonth);
4710 unselectable = (otherMonth && !selectOtherMonths) || !daySettings[0] ||
4711 (minDate && printDate < minDate) || (maxDate && printDate > maxDate);
4712 tbody += "<td class='" +
4713 ((dow + firstDay + 6) % 7 >= 5 ? " ui-datepicker-week-end" : "") + // highlight weekends
4714 (otherMonth ? " ui-datepicker-other-month" : "") + // highlight days from other months
4715 ((printDate.getTime() === selectedDate.getTime() && drawMonth === inst.selectedMonth && inst._keyEvent) || // user pressed key
4716 (defaultDate.getTime() === printDate.getTime() && defaultDate.getTime() === selectedDate.getTime()) ?
4717 // or defaultDate is current printedDate and defaultDate is selectedDate
4718 " " + this._dayOverClass : "") + // highlight selected day
4719 (unselectable ? " " + this._unselectableClass + " ui-state-disabled": "") + // highlight unselectable days
4720 (otherMonth && !showOtherMonths ? "" : " " + daySettings[1] + // highlight custom dates
4721 (printDate.getTime() === currentDate.getTime() ? " " + this._currentClass : "") + // highlight selected day
4722 (printDate.getTime() === today.getTime() ? " ui-datepicker-today" : "")) + "'" + // highlight today (if different)
4723 ((!otherMonth || showOtherMonths) && daySettings[2] ? " title='" + daySettings[2].replace(/'/g, "&#39;") + "'" : "") + // cell title
4724 (unselectable ? "" : " data-handler='selectDay' data-event='click' data-month='" + printDate.getMonth() + "' data-year='" + printDate.getFullYear() + "'") + ">" + // actions
4725 (otherMonth && !showOtherMonths ? "&#xa0;" : // display for other months
4726 (unselectable ? "<span class='ui-state-default'>" + printDate.getDate() + "</span>" : "<a class='ui-state-default" +
4727 (printDate.getTime() === today.getTime() ? " ui-state-highlight" : "") +
4728 (printDate.getTime() === currentDate.getTime() ? " ui-state-active" : "") + // highlight selected day
4729 (otherMonth ? " ui-priority-secondary" : "") + // distinguish dates from other months
4730 "' href='#'>" + printDate.getDate() + "</a>")) + "</td>"; // display selectable date
4731 printDate.setDate(printDate.getDate() + 1);
4732 printDate = this._daylightSavingAdjust(printDate);
4733 }
4734 calender += tbody + "</tr>";
4735 }
4736 drawMonth++;
4737 if (drawMonth > 11) {
4738 drawMonth = 0;
4739 drawYear++;
4740 }
4741 calender += "</tbody></table>" + (isMultiMonth ? "</div>" +
4742 ((numMonths[0] > 0 && col === numMonths[1]-1) ? "<div class='ui-datepicker-row-break'></div>" : "") : "");
4743 group += calender;
4744 }
4745 html += group;
4746 }
4747 html += buttonPanel;
4748 inst._keyEvent = false;
4749 return html;
4750 },
4751
4752 /* Generate the month and year header. */
4753 _generateMonthYearHeader: function(inst, drawMonth, drawYear, minDate, maxDate,
4754 secondary, monthNames, monthNamesShort) {
4755
4756 var inMinYear, inMaxYear, month, years, thisYear, determineYear, year, endYear,
4757 changeMonth = this._get(inst, "changeMonth"),
4758 changeYear = this._get(inst, "changeYear"),
4759 showMonthAfterYear = this._get(inst, "showMonthAfterYear"),
4760 html = "<div class='ui-datepicker-title'>",
4761 monthHtml = "";
4762
4763 // month selection
4764 if (secondary || !changeMonth) {
4765 monthHtml += "<span class='ui-datepicker-month'>" + monthNames[drawMonth] + "</span>";
4766 } else {
4767 inMinYear = (minDate && minDate.getFullYear() === drawYear);
4768 inMaxYear = (maxDate && maxDate.getFullYear() === drawYear);
4769 monthHtml += "<select class='ui-datepicker-month' data-handler='selectMonth' data-event='change'>";
4770 for ( month = 0; month < 12; month++) {
4771 if ((!inMinYear || month >= minDate.getMonth()) && (!inMaxYear || month <= maxDate.getMonth())) {
4772 monthHtml += "<option value='" + month + "'" +
4773 (month === drawMonth ? " selected='selected'" : "") +
4774 ">" + monthNamesShort[month] + "</option>";
4775 }
4776 }
4777 monthHtml += "</select>";
4778 }
4779
4780 if (!showMonthAfterYear) {
4781 html += monthHtml + (secondary || !(changeMonth && changeYear) ? "&#xa0;" : "");
4782 }
4783
4784 // year selection
4785 if ( !inst.yearshtml ) {
4786 inst.yearshtml = "";
4787 if (secondary || !changeYear) {
4788 html += "<span class='ui-datepicker-year'>" + drawYear + "</span>";
4789 } else {
4790 // determine range of years to display
4791 years = this._get(inst, "yearRange").split(":");
4792 thisYear = new Date().getFullYear();
4793 determineYear = function(value) {
4794 var year = (value.match(/c[+\-].*/) ? drawYear + parseInt(value.substring(1), 10) :
4795 (value.match(/[+\-].*/) ? thisYear + parseInt(value, 10) :
4796 parseInt(value, 10)));
4797 return (isNaN(year) ? thisYear : year);
4798 };
4799 year = determineYear(years[0]);
4800 endYear = Math.max(year, determineYear(years[1] || ""));
4801 year = (minDate ? Math.max(year, minDate.getFullYear()) : year);
4802 endYear = (maxDate ? Math.min(endYear, maxDate.getFullYear()) : endYear);
4803 inst.yearshtml += "<select class='ui-datepicker-year' data-handler='selectYear' data-event='change'>";
4804 for (; year <= endYear; year++) {
4805 inst.yearshtml += "<option value='" + year + "'" +
4806 (year === drawYear ? " selected='selected'" : "") +
4807 ">" + year + "</option>";
4808 }
4809 inst.yearshtml += "</select>";
4810
4811 html += inst.yearshtml;
4812 inst.yearshtml = null;
4813 }
4814 }
4815
4816 html += this._get(inst, "yearSuffix");
4817 if (showMonthAfterYear) {
4818 html += (secondary || !(changeMonth && changeYear) ? "&#xa0;" : "") + monthHtml;
4819 }
4820 html += "</div>"; // Close datepicker_header
4821 return html;
4822 },
4823
4824 /* Adjust one of the date sub-fields. */
4825 _adjustInstDate: function(inst, offset, period) {
4826 var year = inst.drawYear + (period === "Y" ? offset : 0),
4827 month = inst.drawMonth + (period === "M" ? offset : 0),
4828 day = Math.min(inst.selectedDay, this._getDaysInMonth(year, month)) + (period === "D" ? offset : 0),
4829 date = this._restrictMinMax(inst, this._daylightSavingAdjust(new Date(year, month, day)));
4830
4831 inst.selectedDay = date.getDate();
4832 inst.drawMonth = inst.selectedMonth = date.getMonth();
4833 inst.drawYear = inst.selectedYear = date.getFullYear();
4834 if (period === "M" || period === "Y") {
4835 this._notifyChange(inst);
4836 }
4837 },
4838
4839 /* Ensure a date is within any min/max bounds. */
4840 _restrictMinMax: function(inst, date) {
4841 var minDate = this._getMinMaxDate(inst, "min"),
4842 maxDate = this._getMinMaxDate(inst, "max"),
4843 newDate = (minDate && date < minDate ? minDate : date);
4844 return (maxDate && newDate > maxDate ? maxDate : newDate);
4845 },
4846
4847 /* Notify change of month/year. */
4848 _notifyChange: function(inst) {
4849 var onChange = this._get(inst, "onChangeMonthYear");
4850 if (onChange) {
4851 onChange.apply((inst.input ? inst.input[0] : null),
4852 [inst.selectedYear, inst.selectedMonth + 1, inst]);
4853 }
4854 },
4855
4856 /* Determine the number of months to show. */
4857 _getNumberOfMonths: function(inst) {
4858 var numMonths = this._get(inst, "numberOfMonths");
4859 return (numMonths == null ? [1, 1] : (typeof numMonths === "number" ? [1, numMonths] : numMonths));
4860 },
4861
4862 /* Determine the current maximum date - ensure no time components are set. */
4863 _getMinMaxDate: function(inst, minMax) {
4864 return this._determineDate(inst, this._get(inst, minMax + "Date"), null);
4865 },
4866
4867 /* Find the number of days in a given month. */
4868 _getDaysInMonth: function(year, month) {
4869 return 32 - this._daylightSavingAdjust(new Date(year, month, 32)).getDate();
4870 },
4871
4872 /* Find the day of the week of the first of a month. */
4873 _getFirstDayOfMonth: function(year, month) {
4874 return new Date(year, month, 1).getDay();
4875 },
4876
4877 /* Determines if we should allow a "next/prev" month display change. */
4878 _canAdjustMonth: function(inst, offset, curYear, curMonth) {
4879 var numMonths = this._getNumberOfMonths(inst),
4880 date = this._daylightSavingAdjust(new Date(curYear,
4881 curMonth + (offset < 0 ? offset : numMonths[0] * numMonths[1]), 1));
4882
4883 if (offset < 0) {
4884 date.setDate(this._getDaysInMonth(date.getFullYear(), date.getMonth()));
4885 }
4886 return this._isInRange(inst, date);
4887 },
4888
4889 /* Is the given date in the accepted range? */
4890 _isInRange: function(inst, date) {
4891 var yearSplit, currentYear,
4892 minDate = this._getMinMaxDate(inst, "min"),
4893 maxDate = this._getMinMaxDate(inst, "max"),
4894 minYear = null,
4895 maxYear = null,
4896 years = this._get(inst, "yearRange");
4897 if (years){
4898 yearSplit = years.split(":");
4899 currentYear = new Date().getFullYear();
4900 minYear = parseInt(yearSplit[0], 10);
4901 maxYear = parseInt(yearSplit[1], 10);
4902 if ( yearSplit[0].match(/[+\-].*/) ) {
4903 minYear += currentYear;
4904 }
4905 if ( yearSplit[1].match(/[+\-].*/) ) {
4906 maxYear += currentYear;
4907 }
4908 }
4909
4910 return ((!minDate || date.getTime() >= minDate.getTime()) &&
4911 (!maxDate || date.getTime() <= maxDate.getTime()) &&
4912 (!minYear || date.getFullYear() >= minYear) &&
4913 (!maxYear || date.getFullYear() <= maxYear));
4914 },
4915
4916 /* Provide the configuration settings for formatting/parsing. */
4917 _getFormatConfig: function(inst) {
4918 var shortYearCutoff = this._get(inst, "shortYearCutoff");
4919 shortYearCutoff = (typeof shortYearCutoff !== "string" ? shortYearCutoff :
4920 new Date().getFullYear() % 100 + parseInt(shortYearCutoff, 10));
4921 return {shortYearCutoff: shortYearCutoff,
4922 dayNamesShort: this._get(inst, "dayNamesShort"), dayNames: this._get(inst, "dayNames"),
4923 monthNamesShort: this._get(inst, "monthNamesShort"), monthNames: this._get(inst, "monthNames")};
4924 },
4925
4926 /* Format the given date for display. */
4927 _formatDate: function(inst, day, month, year) {
4928 if (!day) {
4929 inst.currentDay = inst.selectedDay;
4930 inst.currentMonth = inst.selectedMonth;
4931 inst.currentYear = inst.selectedYear;
4932 }
4933 var date = (day ? (typeof day === "object" ? day :
4934 this._daylightSavingAdjust(new Date(year, month, day))) :
4935 this._daylightSavingAdjust(new Date(inst.currentYear, inst.currentMonth, inst.currentDay)));
4936 return this.formatDate(this._get(inst, "dateFormat"), date, this._getFormatConfig(inst));
4937 }
4938 });
4939
4940 /*
4941 * Bind hover events for datepicker elements.
4942 * Done via delegate so the binding only occurs once in the lifetime of the parent div.
4943 * Global instActive, set by _updateDatepicker allows the handlers to find their way back to the active picker.
4944 */
4945 function bindHover(dpDiv) {
4946 var selector = "button, .ui-datepicker-prev, .ui-datepicker-next, .ui-datepicker-calendar td a";
4947 return dpDiv.delegate(selector, "mouseout", function() {
4948 $(this).removeClass("ui-state-hover");
4949 if (this.className.indexOf("ui-datepicker-prev") !== -1) {
4950 $(this).removeClass("ui-datepicker-prev-hover");
4951 }
4952 if (this.className.indexOf("ui-datepicker-next") !== -1) {
4953 $(this).removeClass("ui-datepicker-next-hover");
4954 }
4955 })
4956 .delegate(selector, "mouseover", function(){
4957 if (!$.datepicker._isDisabledDatepicker( instActive.inline ? dpDiv.parent()[0] : instActive.input[0])) {
4958 $(this).parents(".ui-datepicker-calendar").find("a").removeClass("ui-state-hover");
4959 $(this).addClass("ui-state-hover");
4960 if (this.className.indexOf("ui-datepicker-prev") !== -1) {
4961 $(this).addClass("ui-datepicker-prev-hover");
4962 }
4963 if (this.className.indexOf("ui-datepicker-next") !== -1) {
4964 $(this).addClass("ui-datepicker-next-hover");
4965 }
4966 }
4967 });
4968 }
4969
4970 /* jQuery extend now ignores nulls! */
4971 function extendRemove(target, props) {
4972 $.extend(target, props);
4973 for (var name in props) {
4974 if (props[name] == null) {
4975 target[name] = props[name];
4976 }
4977 }
4978 return target;
4979 }
4980
4981 /* Invoke the datepicker functionality.
4982 @param options string - a command, optionally followed by additional parameters or
4983 Object - settings for attaching new datepicker functionality
4984 @return jQuery object */
4985 $.fn.datepicker = function(options){
4986
4987 /* Verify an empty collection wasn't passed - Fixes #6976 */
4988 if ( !this.length ) {
4989 return this;
4990 }
4991
4992 /* Initialise the date picker. */
4993 if (!$.datepicker.initialized) {
4994 $(document).mousedown($.datepicker._checkExternalClick);
4995 $.datepicker.initialized = true;
4996 }
4997
4998 /* Append datepicker main container to body if not exist. */
4999 if ($("#"+$.datepicker._mainDivId).length === 0) {
5000 $("body").append($.datepicker.dpDiv);
5001 }
5002
5003 var otherArgs = Array.prototype.slice.call(arguments, 1);
5004 if (typeof options === "string" && (options === "isDisabled" || options === "getDate" || options === "widget")) {
5005 return $.datepicker["_" + options + "Datepicker"].
5006 apply($.datepicker, [this[0]].concat(otherArgs));
5007 }
5008 if (options === "option" && arguments.length === 2 && typeof arguments[1] === "string") {
5009 return $.datepicker["_" + options + "Datepicker"].
5010 apply($.datepicker, [this[0]].concat(otherArgs));
5011 }
5012 return this.each(function() {
5013 typeof options === "string" ?
5014 $.datepicker["_" + options + "Datepicker"].
5015 apply($.datepicker, [this].concat(otherArgs)) :
5016 $.datepicker._attachDatepicker(this, options);
5017 });
5018 };
5019
5020 $.datepicker = new Datepicker(); // singleton instance
5021 $.datepicker.initialized = false;
5022 $.datepicker.uuid = new Date().getTime();
5023 $.datepicker.version = "1.10.4";
5024
5025 })(jQuery);
5026 (function( $, undefined ) {
5027
5028 var sizeRelatedOptions = {
5029 buttons: true,
5030 height: true,
5031 maxHeight: true,
5032 maxWidth: true,
5033 minHeight: true,
5034 minWidth: true,
5035 width: true
5036 },
5037 resizableRelatedOptions = {
5038 maxHeight: true,
5039 maxWidth: true,
5040 minHeight: true,
5041 minWidth: true
5042 };
5043
5044 $.widget( "ui.dialog", {
5045 version: "1.10.4",
5046 options: {
5047 appendTo: "body",
5048 autoOpen: true,
5049 buttons: [],
5050 closeOnEscape: true,
5051 closeText: "close",
5052 dialogClass: "",
5053 draggable: true,
5054 hide: null,
5055 height: "auto",
5056 maxHeight: null,
5057 maxWidth: null,
5058 minHeight: 150,
5059 minWidth: 150,
5060 modal: false,
5061 position: {
5062 my: "center",
5063 at: "center",
5064 of: window,
5065 collision: "fit",
5066 // Ensure the titlebar is always visible
5067 using: function( pos ) {
5068 var topOffset = $( this ).css( pos ).offset().top;
5069 if ( topOffset < 0 ) {
5070 $( this ).css( "top", pos.top - topOffset );
5071 }
5072 }
5073 },
5074 resizable: true,
5075 show: null,
5076 title: null,
5077 width: 300,
5078
5079 // callbacks
5080 beforeClose: null,
5081 close: null,
5082 drag: null,
5083 dragStart: null,
5084 dragStop: null,
5085 focus: null,
5086 open: null,
5087 resize: null,
5088 resizeStart: null,
5089 resizeStop: null
5090 },
5091
5092 _create: function() {
5093 this.originalCss = {
5094 display: this.element[0].style.display,
5095 width: this.element[0].style.width,
5096 minHeight: this.element[0].style.minHeight,
5097 maxHeight: this.element[0].style.maxHeight,
5098 height: this.element[0].style.height
5099 };
5100 this.originalPosition = {
5101 parent: this.element.parent(),
5102 index: this.element.parent().children().index( this.element )
5103 };
5104 this.originalTitle = this.element.attr("title");
5105 this.options.title = this.options.title || this.originalTitle;
5106
5107 this._createWrapper();
5108
5109 this.element
5110 .show()
5111 .removeAttr("title")
5112 .addClass("ui-dialog-content ui-widget-content")
5113 .appendTo( this.uiDialog );
5114
5115 this._createTitlebar();
5116 this._createButtonPane();
5117
5118 if ( this.options.draggable && $.fn.draggable ) {
5119 this._makeDraggable();
5120 }
5121 if ( this.options.resizable && $.fn.resizable ) {
5122 this._makeResizable();
5123 }
5124
5125 this._isOpen = false;
5126 },
5127
5128 _init: function() {
5129 if ( this.options.autoOpen ) {
5130 this.open();
5131 }
5132 },
5133
5134 _appendTo: function() {
5135 var element = this.options.appendTo;
5136 if ( element && (element.jquery || element.nodeType) ) {
5137 return $( element );
5138 }
5139 return this.document.find( element || "body" ).eq( 0 );
5140 },
5141
5142 _destroy: function() {
5143 var next,
5144 originalPosition = this.originalPosition;
5145
5146 this._destroyOverlay();
5147
5148 this.element
5149 .removeUniqueId()
5150 .removeClass("ui-dialog-content ui-widget-content")
5151 .css( this.originalCss )
5152 // Without detaching first, the following becomes really slow
5153 .detach();
5154
5155 this.uiDialog.stop( true, true ).remove();
5156
5157 if ( this.originalTitle ) {
5158 this.element.attr( "title", this.originalTitle );
5159 }
5160
5161 next = originalPosition.parent.children().eq( originalPosition.index );
5162 // Don't try to place the dialog next to itself (#8613)
5163 if ( next.length && next[0] !== this.element[0] ) {
5164 next.before( this.element );
5165 } else {
5166 originalPosition.parent.append( this.element );
5167 }
5168 },
5169
5170 widget: function() {
5171 return this.uiDialog;
5172 },
5173
5174 disable: $.noop,
5175 enable: $.noop,
5176
5177 close: function( event ) {
5178 var activeElement,
5179 that = this;
5180
5181 if ( !this._isOpen || this._trigger( "beforeClose", event ) === false ) {
5182 return;
5183 }
5184
5185 this._isOpen = false;
5186 this._destroyOverlay();
5187
5188 if ( !this.opener.filter(":focusable").focus().length ) {
5189
5190 // support: IE9
5191 // IE9 throws an "Unspecified error" accessing document.activeElement from an <iframe>
5192 try {
5193 activeElement = this.document[ 0 ].activeElement;
5194
5195 // Support: IE9, IE10
5196 // If the <body> is blurred, IE will switch windows, see #4520
5197 if ( activeElement && activeElement.nodeName.toLowerCase() !== "body" ) {
5198
5199 // Hiding a focused element doesn't trigger blur in WebKit
5200 // so in case we have nothing to focus on, explicitly blur the active element
5201 // https://bugs.webkit.org/show_bug.cgi?id=47182
5202 $( activeElement ).blur();
5203 }
5204 } catch ( error ) {}
5205 }
5206
5207 this._hide( this.uiDialog, this.options.hide, function() {
5208 that._trigger( "close", event );
5209 });
5210 },
5211
5212 isOpen: function() {
5213 return this._isOpen;
5214 },
5215
5216 moveToTop: function() {
5217 this._moveToTop();
5218 },
5219
5220 _moveToTop: function( event, silent ) {
5221 var moved = !!this.uiDialog.nextAll(":visible").insertBefore( this.uiDialog ).length;
5222 if ( moved && !silent ) {
5223 this._trigger( "focus", event );
5224 }
5225 return moved;
5226 },
5227
5228 open: function() {
5229 var that = this;
5230 if ( this._isOpen ) {
5231 if ( this._moveToTop() ) {
5232 this._focusTabbable();
5233 }
5234 return;
5235 }
5236
5237 this._isOpen = true;
5238 this.opener = $( this.document[0].activeElement );
5239
5240 this._size();
5241 this._position();
5242 this._createOverlay();
5243 this._moveToTop( null, true );
5244 this._show( this.uiDialog, this.options.show, function() {
5245 that._focusTabbable();
5246 that._trigger("focus");
5247 });
5248
5249 this._trigger("open");
5250 },
5251
5252 _focusTabbable: function() {
5253 // Set focus to the first match:
5254 // 1. First element inside the dialog matching [autofocus]
5255 // 2. Tabbable element inside the content element
5256 // 3. Tabbable element inside the buttonpane
5257 // 4. The close button
5258 // 5. The dialog itself
5259 var hasFocus = this.element.find("[autofocus]");
5260 if ( !hasFocus.length ) {
5261 hasFocus = this.element.find(":tabbable");
5262 }
5263 if ( !hasFocus.length ) {
5264 hasFocus = this.uiDialogButtonPane.find(":tabbable");
5265 }
5266 if ( !hasFocus.length ) {
5267 hasFocus = this.uiDialogTitlebarClose.filter(":tabbable");
5268 }
5269 if ( !hasFocus.length ) {
5270 hasFocus = this.uiDialog;
5271 }
5272 hasFocus.eq( 0 ).focus();
5273 },
5274
5275 _keepFocus: function( event ) {
5276 function checkFocus() {
5277 var activeElement = this.document[0].activeElement,
5278 isActive = this.uiDialog[0] === activeElement ||
5279 $.contains( this.uiDialog[0], activeElement );
5280 if ( !isActive ) {
5281 this._focusTabbable();
5282 }
5283 }
5284 event.preventDefault();
5285 checkFocus.call( this );
5286 // support: IE
5287 // IE <= 8 doesn't prevent moving focus even with event.preventDefault()
5288 // so we check again later
5289 this._delay( checkFocus );
5290 },
5291
5292 _createWrapper: function() {
5293 this.uiDialog = $("<div>")
5294 .addClass( "ui-dialog ui-widget ui-widget-content ui-corner-all ui-front " +
5295 this.options.dialogClass )
5296 .hide()
5297 .attr({
5298 // Setting tabIndex makes the div focusable
5299 tabIndex: -1,
5300 role: "dialog"
5301 })
5302 .appendTo( this._appendTo() );
5303
5304 this._on( this.uiDialog, {
5305 keydown: function( event ) {
5306 if ( this.options.closeOnEscape && !event.isDefaultPrevented() && event.keyCode &&
5307 event.keyCode === $.ui.keyCode.ESCAPE ) {
5308 event.preventDefault();
5309 this.close( event );
5310 return;
5311 }
5312
5313 // prevent tabbing out of dialogs
5314 if ( event.keyCode !== $.ui.keyCode.TAB ) {
5315 return;
5316 }
5317 var tabbables = this.uiDialog.find(":tabbable"),
5318 first = tabbables.filter(":first"),
5319 last = tabbables.filter(":last");
5320
5321 if ( ( event.target === last[0] || event.target === this.uiDialog[0] ) && !event.shiftKey ) {
5322 first.focus( 1 );
5323 event.preventDefault();
5324 } else if ( ( event.target === first[0] || event.target === this.uiDialog[0] ) && event.shiftKey ) {
5325 last.focus( 1 );
5326 event.preventDefault();
5327 }
5328 },
5329 mousedown: function( event ) {
5330 if ( this._moveToTop( event ) ) {
5331 this._focusTabbable();
5332 }
5333 }
5334 });
5335
5336 // We assume that any existing aria-describedby attribute means
5337 // that the dialog content is marked up properly
5338 // otherwise we brute force the content as the description
5339 if ( !this.element.find("[aria-describedby]").length ) {
5340 this.uiDialog.attr({
5341 "aria-describedby": this.element.uniqueId().attr("id")
5342 });
5343 }
5344 },
5345
5346 _createTitlebar: function() {
5347 var uiDialogTitle;
5348
5349 this.uiDialogTitlebar = $("<div>")
5350 .addClass("ui-dialog-titlebar ui-widget-header ui-corner-all ui-helper-clearfix")
5351 .prependTo( this.uiDialog );
5352 this._on( this.uiDialogTitlebar, {
5353 mousedown: function( event ) {
5354 // Don't prevent click on close button (#8838)
5355 // Focusing a dialog that is partially scrolled out of view
5356 // causes the browser to scroll it into view, preventing the click event
5357 if ( !$( event.target ).closest(".ui-dialog-titlebar-close") ) {
5358 // Dialog isn't getting focus when dragging (#8063)
5359 this.uiDialog.focus();
5360 }
5361 }
5362 });
5363
5364 // support: IE
5365 // Use type="button" to prevent enter keypresses in textboxes from closing the
5366 // dialog in IE (#9312)
5367 this.uiDialogTitlebarClose = $( "<button type='button'></button>" )
5368 .button({
5369 label: this.options.closeText,
5370 icons: {
5371 primary: "ui-icon-closethick"
5372 },
5373 text: false
5374 })
5375 .addClass("ui-dialog-titlebar-close")
5376 .appendTo( this.uiDialogTitlebar );
5377 this._on( this.uiDialogTitlebarClose, {
5378 click: function( event ) {
5379 event.preventDefault();
5380 this.close( event );
5381 }
5382 });
5383
5384 uiDialogTitle = $("<span>")
5385 .uniqueId()
5386 .addClass("ui-dialog-title")
5387 .prependTo( this.uiDialogTitlebar );
5388 this._title( uiDialogTitle );
5389
5390 this.uiDialog.attr({
5391 "aria-labelledby": uiDialogTitle.attr("id")
5392 });
5393 },
5394
5395 _title: function( title ) {
5396 if ( !this.options.title ) {
5397 title.html("&#160;");
5398 }
5399 title.text( this.options.title );
5400 },
5401
5402 _createButtonPane: function() {
5403 this.uiDialogButtonPane = $("<div>")
5404 .addClass("ui-dialog-buttonpane ui-widget-content ui-helper-clearfix");
5405
5406 this.uiButtonSet = $("<div>")
5407 .addClass("ui-dialog-buttonset")
5408 .appendTo( this.uiDialogButtonPane );
5409
5410 this._createButtons();
5411 },
5412
5413 _createButtons: function() {
5414 var that = this,
5415 buttons = this.options.buttons;
5416
5417 // if we already have a button pane, remove it
5418 this.uiDialogButtonPane.remove();
5419 this.uiButtonSet.empty();
5420
5421 if ( $.isEmptyObject( buttons ) || ($.isArray( buttons ) && !buttons.length) ) {
5422 this.uiDialog.removeClass("ui-dialog-buttons");
5423 return;
5424 }
5425
5426 $.each( buttons, function( name, props ) {
5427 var click, buttonOptions;
5428 props = $.isFunction( props ) ?
5429 { click: props, text: name } :
5430 props;
5431 // Default to a non-submitting button
5432 props = $.extend( { type: "button" }, props );
5433 // Change the context for the click callback to be the main element
5434 click = props.click;
5435 props.click = function() {
5436 click.apply( that.element[0], arguments );
5437 };
5438 buttonOptions = {
5439 icons: props.icons,
5440 text: props.showText
5441 };
5442 delete props.icons;
5443 delete props.showText;
5444 $( "<button></button>", props )
5445 .button( buttonOptions )
5446 .appendTo( that.uiButtonSet );
5447 });
5448 this.uiDialog.addClass("ui-dialog-buttons");
5449 this.uiDialogButtonPane.appendTo( this.uiDialog );
5450 },
5451
5452 _makeDraggable: function() {
5453 var that = this,
5454 options = this.options;
5455
5456 function filteredUi( ui ) {
5457 return {
5458 position: ui.position,
5459 offset: ui.offset
5460 };
5461 }
5462
5463 this.uiDialog.draggable({
5464 cancel: ".ui-dialog-content, .ui-dialog-titlebar-close",
5465 handle: ".ui-dialog-titlebar",
5466 containment: "document",
5467 start: function( event, ui ) {
5468 $( this ).addClass("ui-dialog-dragging");
5469 that._blockFrames();
5470 that._trigger( "dragStart", event, filteredUi( ui ) );
5471 },
5472 drag: function( event, ui ) {
5473 that._trigger( "drag", event, filteredUi( ui ) );
5474 },
5475 stop: function( event, ui ) {
5476 options.position = [
5477 ui.position.left - that.document.scrollLeft(),
5478 ui.position.top - that.document.scrollTop()
5479 ];
5480 $( this ).removeClass("ui-dialog-dragging");
5481 that._unblockFrames();
5482 that._trigger( "dragStop", event, filteredUi( ui ) );
5483 }
5484 });
5485 },
5486
5487 _makeResizable: function() {
5488 var that = this,
5489 options = this.options,
5490 handles = options.resizable,
5491 // .ui-resizable has position: relative defined in the stylesheet
5492 // but dialogs have to use absolute or fixed positioning
5493 position = this.uiDialog.css("position"),
5494 resizeHandles = typeof handles === "string" ?
5495 handles :
5496 "n,e,s,w,se,sw,ne,nw";
5497
5498 function filteredUi( ui ) {
5499 return {
5500 originalPosition: ui.originalPosition,
5501 originalSize: ui.originalSize,
5502 position: ui.position,
5503 size: ui.size
5504 };
5505 }
5506
5507 this.uiDialog.resizable({
5508 cancel: ".ui-dialog-content",
5509 containment: "document",
5510 alsoResize: this.element,
5511 maxWidth: options.maxWidth,
5512 maxHeight: options.maxHeight,
5513 minWidth: options.minWidth,
5514 minHeight: this._minHeight(),
5515 handles: resizeHandles,
5516 start: function( event, ui ) {
5517 $( this ).addClass("ui-dialog-resizing");
5518 that._blockFrames();
5519 that._trigger( "resizeStart", event, filteredUi( ui ) );
5520 },
5521 resize: function( event, ui ) {
5522 that._trigger( "resize", event, filteredUi( ui ) );
5523 },
5524 stop: function( event, ui ) {
5525 options.height = $( this ).height();
5526 options.width = $( this ).width();
5527 $( this ).removeClass("ui-dialog-resizing");
5528 that._unblockFrames();
5529 that._trigger( "resizeStop", event, filteredUi( ui ) );
5530 }
5531 })
5532 .css( "position", position );
5533 },
5534
5535 _minHeight: function() {
5536 var options = this.options;
5537
5538 return options.height === "auto" ?
5539 options.minHeight :
5540 Math.min( options.minHeight, options.height );
5541 },
5542
5543 _position: function() {
5544 // Need to show the dialog to get the actual offset in the position plugin
5545 var isVisible = this.uiDialog.is(":visible");
5546 if ( !isVisible ) {
5547 this.uiDialog.show();
5548 }
5549 this.uiDialog.position( this.options.position );
5550 if ( !isVisible ) {
5551 this.uiDialog.hide();
5552 }
5553 },
5554
5555 _setOptions: function( options ) {
5556 var that = this,
5557 resize = false,
5558 resizableOptions = {};
5559
5560 $.each( options, function( key, value ) {
5561 that._setOption( key, value );
5562
5563 if ( key in sizeRelatedOptions ) {
5564 resize = true;
5565 }
5566 if ( key in resizableRelatedOptions ) {
5567 resizableOptions[ key ] = value;
5568 }
5569 });
5570
5571 if ( resize ) {
5572 this._size();
5573 this._position();
5574 }
5575 if ( this.uiDialog.is(":data(ui-resizable)") ) {
5576 this.uiDialog.resizable( "option", resizableOptions );
5577 }
5578 },
5579
5580 _setOption: function( key, value ) {
5581 var isDraggable, isResizable,
5582 uiDialog = this.uiDialog;
5583
5584 if ( key === "dialogClass" ) {
5585 uiDialog
5586 .removeClass( this.options.dialogClass )
5587 .addClass( value );
5588 }
5589
5590 if ( key === "disabled" ) {
5591 return;
5592 }
5593
5594 this._super( key, value );
5595
5596 if ( key === "appendTo" ) {
5597 this.uiDialog.appendTo( this._appendTo() );
5598 }
5599
5600 if ( key === "buttons" ) {
5601 this._createButtons();
5602 }
5603
5604 if ( key === "closeText" ) {
5605 this.uiDialogTitlebarClose.button({
5606 // Ensure that we always pass a string
5607 label: "" + value
5608 });
5609 }
5610
5611 if ( key === "draggable" ) {
5612 isDraggable = uiDialog.is(":data(ui-draggable)");
5613 if ( isDraggable && !value ) {
5614 uiDialog.draggable("destroy");
5615 }
5616
5617 if ( !isDraggable && value ) {
5618 this._makeDraggable();
5619 }
5620 }
5621
5622 if ( key === "position" ) {
5623 this._position();
5624 }
5625
5626 if ( key === "resizable" ) {
5627 // currently resizable, becoming non-resizable
5628 isResizable = uiDialog.is(":data(ui-resizable)");
5629 if ( isResizable && !value ) {
5630 uiDialog.resizable("destroy");
5631 }
5632
5633 // currently resizable, changing handles
5634 if ( isResizable && typeof value === "string" ) {
5635 uiDialog.resizable( "option", "handles", value );
5636 }
5637
5638 // currently non-resizable, becoming resizable
5639 if ( !isResizable && value !== false ) {
5640 this._makeResizable();
5641 }
5642 }
5643
5644 if ( key === "title" ) {
5645 this._title( this.uiDialogTitlebar.find(".ui-dialog-title") );
5646 }
5647 },
5648
5649 _size: function() {
5650 // If the user has resized the dialog, the .ui-dialog and .ui-dialog-content
5651 // divs will both have width and height set, so we need to reset them
5652 var nonContentHeight, minContentHeight, maxContentHeight,
5653 options = this.options;
5654
5655 // Reset content sizing
5656 this.element.show().css({
5657 width: "auto",
5658 minHeight: 0,
5659 maxHeight: "none",
5660 height: 0
5661 });
5662
5663 if ( options.minWidth > options.width ) {
5664 options.width = options.minWidth;
5665 }
5666
5667 // reset wrapper sizing
5668 // determine the height of all the non-content elements
5669 nonContentHeight = this.uiDialog.css({
5670 height: "auto",
5671 width: options.width
5672 })
5673 .outerHeight();
5674 minContentHeight = Math.max( 0, options.minHeight - nonContentHeight );
5675 maxContentHeight = typeof options.maxHeight === "number" ?
5676 Math.max( 0, options.maxHeight - nonContentHeight ) :
5677 "none";
5678
5679 if ( options.height === "auto" ) {
5680 this.element.css({
5681 minHeight: minContentHeight,
5682 maxHeight: maxContentHeight,
5683 height: "auto"
5684 });
5685 } else {
5686 this.element.height( Math.max( 0, options.height - nonContentHeight ) );
5687 }
5688
5689 if (this.uiDialog.is(":data(ui-resizable)") ) {
5690 this.uiDialog.resizable( "option", "minHeight", this._minHeight() );
5691 }
5692 },
5693
5694 _blockFrames: function() {
5695 this.iframeBlocks = this.document.find( "iframe" ).map(function() {
5696 var iframe = $( this );
5697
5698 return $( "<div>" )
5699 .css({
5700 position: "absolute",
5701 width: iframe.outerWidth(),
5702 height: iframe.outerHeight()
5703 })
5704 .appendTo( iframe.parent() )
5705 .offset( iframe.offset() )[0];
5706 });
5707 },
5708
5709 _unblockFrames: function() {
5710 if ( this.iframeBlocks ) {
5711 this.iframeBlocks.remove();
5712 delete this.iframeBlocks;
5713 }
5714 },
5715
5716 _allowInteraction: function( event ) {
5717 if ( $( event.target ).closest(".ui-dialog").length ) {
5718 return true;
5719 }
5720
5721 // TODO: Remove hack when datepicker implements
5722 // the .ui-front logic (#8989)
5723 return !!$( event.target ).closest(".ui-datepicker").length;
5724 },
5725
5726 _createOverlay: function() {
5727 if ( !this.options.modal ) {
5728 return;
5729 }
5730
5731 var that = this,
5732 widgetFullName = this.widgetFullName;
5733 if ( !$.ui.dialog.overlayInstances ) {
5734 // Prevent use of anchors and inputs.
5735 // We use a delay in case the overlay is created from an
5736 // event that we're going to be cancelling. (#2804)
5737 this._delay(function() {
5738 // Handle .dialog().dialog("close") (#4065)
5739 if ( $.ui.dialog.overlayInstances ) {
5740 this.document.bind( "focusin.dialog", function( event ) {
5741 if ( !that._allowInteraction( event ) ) {
5742 event.preventDefault();
5743 $(".ui-dialog:visible:last .ui-dialog-content")
5744 .data( widgetFullName )._focusTabbable();
5745 }
5746 });
5747 }
5748 });
5749 }
5750
5751 this.overlay = $("<div>")
5752 .addClass("ui-widget-overlay ui-front")
5753 .appendTo( this._appendTo() );
5754 this._on( this.overlay, {
5755 mousedown: "_keepFocus"
5756 });
5757 $.ui.dialog.overlayInstances++;
5758 },
5759
5760 _destroyOverlay: function() {
5761 if ( !this.options.modal ) {
5762 return;
5763 }
5764
5765 if ( this.overlay ) {
5766 $.ui.dialog.overlayInstances--;
5767
5768 if ( !$.ui.dialog.overlayInstances ) {
5769 this.document.unbind( "focusin.dialog" );
5770 }
5771 this.overlay.remove();
5772 this.overlay = null;
5773 }
5774 }
5775 });
5776
5777 $.ui.dialog.overlayInstances = 0;
5778
5779 // DEPRECATED
5780 if ( $.uiBackCompat !== false ) {
5781 // position option with array notation
5782 // just override with old implementation
5783 $.widget( "ui.dialog", $.ui.dialog, {
5784 _position: function() {
5785 var position = this.options.position,
5786 myAt = [],
5787 offset = [ 0, 0 ],
5788 isVisible;
5789
5790 if ( position ) {
5791 if ( typeof position === "string" || (typeof position === "object" && "0" in position ) ) {
5792 myAt = position.split ? position.split(" ") : [ position[0], position[1] ];
5793 if ( myAt.length === 1 ) {
5794 myAt[1] = myAt[0];
5795 }
5796
5797 $.each( [ "left", "top" ], function( i, offsetPosition ) {
5798 if ( +myAt[ i ] === myAt[ i ] ) {
5799 offset[ i ] = myAt[ i ];
5800 myAt[ i ] = offsetPosition;
5801 }
5802 });
5803
5804 position = {
5805 my: myAt[0] + (offset[0] < 0 ? offset[0] : "+" + offset[0]) + " " +
5806 myAt[1] + (offset[1] < 0 ? offset[1] : "+" + offset[1]),
5807 at: myAt.join(" ")
5808 };
5809 }
5810
5811 position = $.extend( {}, $.ui.dialog.prototype.options.position, position );
5812 } else {
5813 position = $.ui.dialog.prototype.options.position;
5814 }
5815
5816 // need to show the dialog to get the actual offset in the position plugin
5817 isVisible = this.uiDialog.is(":visible");
5818 if ( !isVisible ) {
5819 this.uiDialog.show();
5820 }
5821 this.uiDialog.position( position );
5822 if ( !isVisible ) {
5823 this.uiDialog.hide();
5824 }
5825 }
5826 });
5827 }
5828
5829 }( jQuery ) );
5830 (function( $, undefined ) {
5831
5832 $.widget("ui.draggable", $.ui.mouse, {
5833 version: "1.10.4",
5834 widgetEventPrefix: "drag",
5835 options: {
5836 addClasses: true,
5837 appendTo: "parent",
5838 axis: false,
5839 connectToSortable: false,
5840 containment: false,
5841 cursor: "auto",
5842 cursorAt: false,
5843 grid: false,
5844 handle: false,
5845 helper: "original",
5846 iframeFix: false,
5847 opacity: false,
5848 refreshPositions: false,
5849 revert: false,
5850 revertDuration: 500,
5851 scope: "default",
5852 scroll: true,
5853 scrollSensitivity: 20,
5854 scrollSpeed: 20,
5855 snap: false,
5856 snapMode: "both",
5857 snapTolerance: 20,
5858 stack: false,
5859 zIndex: false,
5860
5861 // callbacks
5862 drag: null,
5863 start: null,
5864 stop: null
5865 },
5866 _create: function() {
5867
5868 if (this.options.helper === "original" && !(/^(?:r|a|f)/).test(this.element.css("position"))) {
5869 this.element[0].style.position = "relative";
5870 }
5871 if (this.options.addClasses){
5872 this.element.addClass("ui-draggable");
5873 }
5874 if (this.options.disabled){
5875 this.element.addClass("ui-draggable-disabled");
5876 }
5877
5878 this._mouseInit();
5879
5880 },
5881
5882 _destroy: function() {
5883 this.element.removeClass( "ui-draggable ui-draggable-dragging ui-draggable-disabled" );
5884 this._mouseDestroy();
5885 },
5886
5887 _mouseCapture: function(event) {
5888
5889 var o = this.options;
5890
5891 // among others, prevent a drag on a resizable-handle
5892 if (this.helper || o.disabled || $(event.target).closest(".ui-resizable-handle").length > 0) {
5893 return false;
5894 }
5895
5896 //Quit if we're not on a valid handle
5897 this.handle = this._getHandle(event);
5898 if (!this.handle) {
5899 return false;
5900 }
5901
5902 $(o.iframeFix === true ? "iframe" : o.iframeFix).each(function() {
5903 $("<div class='ui-draggable-iframeFix' style='background: #fff;'></div>")
5904 .css({
5905 width: this.offsetWidth+"px", height: this.offsetHeight+"px",
5906 position: "absolute", opacity: "0.001", zIndex: 1000
5907 })
5908 .css($(this).offset())
5909 .appendTo("body");
5910 });
5911
5912 return true;
5913
5914 },
5915
5916 _mouseStart: function(event) {
5917
5918 var o = this.options;
5919
5920 //Create and append the visible helper
5921 this.helper = this._createHelper(event);
5922
5923 this.helper.addClass("ui-draggable-dragging");
5924
5925 //Cache the helper size
5926 this._cacheHelperProportions();
5927
5928 //If ddmanager is used for droppables, set the global draggable
5929 if($.ui.ddmanager) {
5930 $.ui.ddmanager.current = this;
5931 }
5932
5933 /*
5934 * - Position generation -
5935 * This block generates everything position related - it's the core of draggables.
5936 */
5937
5938 //Cache the margins of the original element
5939 this._cacheMargins();
5940
5941 //Store the helper's css position
5942 this.cssPosition = this.helper.css( "position" );
5943 this.scrollParent = this.helper.scrollParent();
5944 this.offsetParent = this.helper.offsetParent();
5945 this.offsetParentCssPosition = this.offsetParent.css( "position" );
5946
5947 //The element's absolute position on the page minus margins
5948 this.offset = this.positionAbs = this.element.offset();
5949 this.offset = {
5950 top: this.offset.top - this.margins.top,
5951 left: this.offset.left - this.margins.left
5952 };
5953
5954 //Reset scroll cache
5955 this.offset.scroll = false;
5956
5957 $.extend(this.offset, {
5958 click: { //Where the click happened, relative to the element
5959 left: event.pageX - this.offset.left,
5960 top: event.pageY - this.offset.top
5961 },
5962 parent: this._getParentOffset(),
5963 relative: this._getRelativeOffset() //This is a relative to absolute position minus the actual position calculation - only used for relative positioned helper
5964 });
5965
5966 //Generate the original position
5967 this.originalPosition = this.position = this._generatePosition(event);
5968 this.originalPageX = event.pageX;
5969 this.originalPageY = event.pageY;
5970
5971 //Adjust the mouse offset relative to the helper if "cursorAt" is supplied
5972 (o.cursorAt && this._adjustOffsetFromHelper(o.cursorAt));
5973
5974 //Set a containment if given in the options
5975 this._setContainment();
5976
5977 //Trigger event + callbacks
5978 if(this._trigger("start", event) === false) {
5979 this._clear();
5980 return false;
5981 }
5982
5983 //Recache the helper size
5984 this._cacheHelperProportions();
5985
5986 //Prepare the droppable offsets
5987 if ($.ui.ddmanager && !o.dropBehaviour) {
5988 $.ui.ddmanager.prepareOffsets(this, event);
5989 }
5990
5991
5992 this._mouseDrag(event, true); //Execute the drag once - this causes the helper not to be visible before getting its correct position
5993
5994 //If the ddmanager is used for droppables, inform the manager that dragging has started (see #5003)
5995 if ( $.ui.ddmanager ) {
5996 $.ui.ddmanager.dragStart(this, event);
5997 }
5998
5999 return true;
6000 },
6001
6002 _mouseDrag: function(event, noPropagation) {
6003 // reset any necessary cached properties (see #5009)
6004 if ( this.offsetParentCssPosition === "fixed" ) {
6005 this.offset.parent = this._getParentOffset();
6006 }
6007
6008 //Compute the helpers position
6009 this.position = this._generatePosition(event);
6010 this.positionAbs = this._convertPositionTo("absolute");
6011
6012 //Call plugins and callbacks and use the resulting position if something is returned
6013 if (!noPropagation) {
6014 var ui = this._uiHash();
6015 if(this._trigger("drag", event, ui) === false) {
6016 this._mouseUp({});
6017 return false;
6018 }
6019 this.position = ui.position;
6020 }
6021
6022 if(!this.options.axis || this.options.axis !== "y") {
6023 this.helper[0].style.left = this.position.left+"px";
6024 }
6025 if(!this.options.axis || this.options.axis !== "x") {
6026 this.helper[0].style.top = this.position.top+"px";
6027 }
6028 if($.ui.ddmanager) {
6029 $.ui.ddmanager.drag(this, event);
6030 }
6031
6032 return false;
6033 },
6034
6035 _mouseStop: function(event) {
6036
6037 //If we are using droppables, inform the manager about the drop
6038 var that = this,
6039 dropped = false;
6040 if ($.ui.ddmanager && !this.options.dropBehaviour) {
6041 dropped = $.ui.ddmanager.drop(this, event);
6042 }
6043
6044 //if a drop comes from outside (a sortable)
6045 if(this.dropped) {
6046 dropped = this.dropped;
6047 this.dropped = false;
6048 }
6049
6050 //if the original element is no longer in the DOM don't bother to continue (see #8269)
6051 if ( this.options.helper === "original" && !$.contains( this.element[ 0 ].ownerDocument, this.element[ 0 ] ) ) {
6052 return false;
6053 }
6054
6055 if((this.options.revert === "invalid" && !dropped) || (this.options.revert === "valid" && dropped) || this.options.revert === true || ($.isFunction(this.options.revert) && this.options.revert.call(this.element, dropped))) {
6056 $(this.helper).animate(this.originalPosition, parseInt(this.options.revertDuration, 10), function() {
6057 if(that._trigger("stop", event) !== false) {
6058 that._clear();
6059 }
6060 });
6061 } else {
6062 if(this._trigger("stop", event) !== false) {
6063 this._clear();
6064 }
6065 }
6066
6067 return false;
6068 },
6069
6070 _mouseUp: function(event) {
6071 //Remove frame helpers
6072 $("div.ui-draggable-iframeFix").each(function() {
6073 this.parentNode.removeChild(this);
6074 });
6075
6076 //If the ddmanager is used for droppables, inform the manager that dragging has stopped (see #5003)
6077 if( $.ui.ddmanager ) {
6078 $.ui.ddmanager.dragStop(this, event);
6079 }
6080
6081 return $.ui.mouse.prototype._mouseUp.call(this, event);
6082 },
6083
6084 cancel: function() {
6085
6086 if(this.helper.is(".ui-draggable-dragging")) {
6087 this._mouseUp({});
6088 } else {
6089 this._clear();
6090 }
6091
6092 return this;
6093
6094 },
6095
6096 _getHandle: function(event) {
6097 return this.options.handle ?
6098 !!$( event.target ).closest( this.element.find( this.options.handle ) ).length :
6099 true;
6100 },
6101
6102 _createHelper: function(event) {
6103
6104 var o = this.options,
6105 helper = $.isFunction(o.helper) ? $(o.helper.apply(this.element[0], [event])) : (o.helper === "clone" ? this.element.clone().removeAttr("id") : this.element);
6106
6107 if(!helper.parents("body").length) {
6108 helper.appendTo((o.appendTo === "parent" ? this.element[0].parentNode : o.appendTo));
6109 }
6110
6111 if(helper[0] !== this.element[0] && !(/(fixed|absolute)/).test(helper.css("position"))) {
6112 helper.css("position", "absolute");
6113 }
6114
6115 return helper;
6116
6117 },
6118
6119 _adjustOffsetFromHelper: function(obj) {
6120 if (typeof obj === "string") {
6121 obj = obj.split(" ");
6122 }
6123 if ($.isArray(obj)) {
6124 obj = {left: +obj[0], top: +obj[1] || 0};
6125 }
6126 if ("left" in obj) {
6127 this.offset.click.left = obj.left + this.margins.left;
6128 }
6129 if ("right" in obj) {
6130 this.offset.click.left = this.helperProportions.width - obj.right + this.margins.left;
6131 }
6132 if ("top" in obj) {
6133 this.offset.click.top = obj.top + this.margins.top;
6134 }
6135 if ("bottom" in obj) {
6136 this.offset.click.top = this.helperProportions.height - obj.bottom + this.margins.top;
6137 }
6138 },
6139
6140 _getParentOffset: function() {
6141
6142 //Get the offsetParent and cache its position
6143 var po = this.offsetParent.offset();
6144
6145 // This is a special case where we need to modify a offset calculated on start, since the following happened:
6146 // 1. The position of the helper is absolute, so it's position is calculated based on the next positioned parent
6147 // 2. The actual offset parent is a child of the scroll parent, and the scroll parent isn't the document, which means that
6148 // the scroll is included in the initial calculation of the offset of the parent, and never recalculated upon drag
6149 if(this.cssPosition === "absolute" && this.scrollParent[0] !== document && $.contains(this.scrollParent[0], this.offsetParent[0])) {
6150 po.left += this.scrollParent.scrollLeft();
6151 po.top += this.scrollParent.scrollTop();
6152 }
6153
6154 //This needs to be actually done for all browsers, since pageX/pageY includes this information
6155 //Ugly IE fix
6156 if((this.offsetParent[0] === document.body) ||
6157 (this.offsetParent[0].tagName && this.offsetParent[0].tagName.toLowerCase() === "html" && $.ui.ie)) {
6158 po = { top: 0, left: 0 };
6159 }
6160
6161 return {
6162 top: po.top + (parseInt(this.offsetParent.css("borderTopWidth"),10) || 0),
6163 left: po.left + (parseInt(this.offsetParent.css("borderLeftWidth"),10) || 0)
6164 };
6165
6166 },
6167
6168 _getRelativeOffset: function() {
6169
6170 if(this.cssPosition === "relative") {
6171 var p = this.element.position();
6172 return {
6173 top: p.top - (parseInt(this.helper.css("top"),10) || 0) + this.scrollParent.scrollTop(),
6174 left: p.left - (parseInt(this.helper.css("left"),10) || 0) + this.scrollParent.scrollLeft()
6175 };
6176 } else {
6177 return { top: 0, left: 0 };
6178 }
6179
6180 },
6181
6182 _cacheMargins: function() {
6183 this.margins = {
6184 left: (parseInt(this.element.css("marginLeft"),10) || 0),
6185 top: (parseInt(this.element.css("marginTop"),10) || 0),
6186 right: (parseInt(this.element.css("marginRight"),10) || 0),
6187 bottom: (parseInt(this.element.css("marginBottom"),10) || 0)
6188 };
6189 },
6190
6191 _cacheHelperProportions: function() {
6192 this.helperProportions = {
6193 width: this.helper.outerWidth(),
6194 height: this.helper.outerHeight()
6195 };
6196 },
6197
6198 _setContainment: function() {
6199
6200 var over, c, ce,
6201 o = this.options;
6202
6203 if ( !o.containment ) {
6204 this.containment = null;
6205 return;
6206 }
6207
6208 if ( o.containment === "window" ) {
6209 this.containment = [
6210 $( window ).scrollLeft() - this.offset.relative.left - this.offset.parent.left,
6211 $( window ).scrollTop() - this.offset.relative.top - this.offset.parent.top,
6212 $( window ).scrollLeft() + $( window ).width() - this.helperProportions.width - this.margins.left,
6213 $( window ).scrollTop() + ( $( window ).height() || document.body.parentNode.scrollHeight ) - this.helperProportions.height - this.margins.top
6214 ];
6215 return;
6216 }
6217
6218 if ( o.containment === "document") {
6219 this.containment = [
6220 0,
6221 0,
6222 $( document ).width() - this.helperProportions.width - this.margins.left,
6223 ( $( document ).height() || document.body.parentNode.scrollHeight ) - this.helperProportions.height - this.margins.top
6224 ];
6225 return;
6226 }
6227
6228 if ( o.containment.constructor === Array ) {
6229 this.containment = o.containment;
6230 return;
6231 }
6232
6233 if ( o.containment === "parent" ) {
6234 o.containment = this.helper[ 0 ].parentNode;
6235 }
6236
6237 c = $( o.containment );
6238 ce = c[ 0 ];
6239
6240 if( !ce ) {
6241 return;
6242 }
6243
6244 over = c.css( "overflow" ) !== "hidden";
6245
6246 this.containment = [
6247 ( parseInt( c.css( "borderLeftWidth" ), 10 ) || 0 ) + ( parseInt( c.css( "paddingLeft" ), 10 ) || 0 ),
6248 ( parseInt( c.css( "borderTopWidth" ), 10 ) || 0 ) + ( parseInt( c.css( "paddingTop" ), 10 ) || 0 ) ,
6249 ( over ? Math.max( ce.scrollWidth, ce.offsetWidth ) : ce.offsetWidth ) - ( parseInt( c.css( "borderRightWidth" ), 10 ) || 0 ) - ( parseInt( c.css( "paddingRight" ), 10 ) || 0 ) - this.helperProportions.width - this.margins.left - this.margins.right,
6250 ( over ? Math.max( ce.scrollHeight, ce.offsetHeight ) : ce.offsetHeight ) - ( parseInt( c.css( "borderBottomWidth" ), 10 ) || 0 ) - ( parseInt( c.css( "paddingBottom" ), 10 ) || 0 ) - this.helperProportions.height - this.margins.top - this.margins.bottom
6251 ];
6252 this.relative_container = c;
6253 },
6254
6255 _convertPositionTo: function(d, pos) {
6256
6257 if(!pos) {
6258 pos = this.position;
6259 }
6260
6261 var mod = d === "absolute" ? 1 : -1,
6262 scroll = this.cssPosition === "absolute" && !( this.scrollParent[ 0 ] !== document && $.contains( this.scrollParent[ 0 ], this.offsetParent[ 0 ] ) ) ? this.offsetParent : this.scrollParent;
6263
6264 //Cache the scroll
6265 if (!this.offset.scroll) {
6266 this.offset.scroll = {top : scroll.scrollTop(), left : scroll.scrollLeft()};
6267 }
6268
6269 return {
6270 top: (
6271 pos.top + // The absolute mouse position
6272 this.offset.relative.top * mod + // Only for relative positioned nodes: Relative offset from element to offset parent
6273 this.offset.parent.top * mod - // The offsetParent's offset without borders (offset + border)
6274 ( ( this.cssPosition === "fixed" ? -this.scrollParent.scrollTop() : this.offset.scroll.top ) * mod )
6275 ),
6276 left: (
6277 pos.left + // The absolute mouse position
6278 this.offset.relative.left * mod + // Only for relative positioned nodes: Relative offset from element to offset parent
6279 this.offset.parent.left * mod - // The offsetParent's offset without borders (offset + border)
6280 ( ( this.cssPosition === "fixed" ? -this.scrollParent.scrollLeft() : this.offset.scroll.left ) * mod )
6281 )
6282 };
6283
6284 },
6285
6286 _generatePosition: function(event) {
6287
6288 var containment, co, top, left,
6289 o = this.options,
6290 scroll = this.cssPosition === "absolute" && !( this.scrollParent[ 0 ] !== document && $.contains( this.scrollParent[ 0 ], this.offsetParent[ 0 ] ) ) ? this.offsetParent : this.scrollParent,
6291 pageX = event.pageX,
6292 pageY = event.pageY;
6293
6294 //Cache the scroll
6295 if (!this.offset.scroll) {
6296 this.offset.scroll = {top : scroll.scrollTop(), left : scroll.scrollLeft()};
6297 }
6298
6299 /*
6300 * - Position constraining -
6301 * Constrain the position to a mix of grid, containment.
6302 */
6303
6304 // If we are not dragging yet, we won't check for options
6305 if ( this.originalPosition ) {
6306 if ( this.containment ) {
6307 if ( this.relative_container ){
6308 co = this.relative_container.offset();
6309 containment = [
6310 this.containment[ 0 ] + co.left,
6311 this.containment[ 1 ] + co.top,
6312 this.containment[ 2 ] + co.left,
6313 this.containment[ 3 ] + co.top
6314 ];
6315 }
6316 else {
6317 containment = this.containment;
6318 }
6319
6320 if(event.pageX - this.offset.click.left < containment[0]) {
6321 pageX = containment[0] + this.offset.click.left;
6322 }
6323 if(event.pageY - this.offset.click.top < containment[1]) {
6324 pageY = containment[1] + this.offset.click.top;
6325 }
6326 if(event.pageX - this.offset.click.left > containment[2]) {
6327 pageX = containment[2] + this.offset.click.left;
6328 }
6329 if(event.pageY - this.offset.click.top > containment[3]) {
6330 pageY = containment[3] + this.offset.click.top;
6331 }
6332 }
6333
6334 if(o.grid) {
6335 //Check for grid elements set to 0 to prevent divide by 0 error causing invalid argument errors in IE (see ticket #6950)
6336 top = o.grid[1] ? this.originalPageY + Math.round((pageY - this.originalPageY) / o.grid[1]) * o.grid[1] : this.originalPageY;
6337 pageY = containment ? ((top - this.offset.click.top >= containment[1] || top - this.offset.click.top > containment[3]) ? top : ((top - this.offset.click.top >= containment[1]) ? top - o.grid[1] : top + o.grid[1])) : top;
6338
6339 left = o.grid[0] ? this.originalPageX + Math.round((pageX - this.originalPageX) / o.grid[0]) * o.grid[0] : this.originalPageX;
6340 pageX = containment ? ((left - this.offset.click.left >= containment[0] || left - this.offset.click.left > containment[2]) ? left : ((left - this.offset.click.left >= containment[0]) ? left - o.grid[0] : left + o.grid[0])) : left;
6341 }
6342
6343 }
6344
6345 return {
6346 top: (
6347 pageY - // The absolute mouse position
6348 this.offset.click.top - // Click offset (relative to the element)
6349 this.offset.relative.top - // Only for relative positioned nodes: Relative offset from element to offset parent
6350 this.offset.parent.top + // The offsetParent's offset without borders (offset + border)
6351 ( this.cssPosition === "fixed" ? -this.scrollParent.scrollTop() : this.offset.scroll.top )
6352 ),
6353 left: (
6354 pageX - // The absolute mouse position
6355 this.offset.click.left - // Click offset (relative to the element)
6356 this.offset.relative.left - // Only for relative positioned nodes: Relative offset from element to offset parent
6357 this.offset.parent.left + // The offsetParent's offset without borders (offset + border)
6358 ( this.cssPosition === "fixed" ? -this.scrollParent.scrollLeft() : this.offset.scroll.left )
6359 )
6360 };
6361
6362 },
6363
6364 _clear: function() {
6365 this.helper.removeClass("ui-draggable-dragging");
6366 if(this.helper[0] !== this.element[0] && !this.cancelHelperRemoval) {
6367 this.helper.remove();
6368 }
6369 this.helper = null;
6370 this.cancelHelperRemoval = false;
6371 },
6372
6373 // From now on bulk stuff - mainly helpers
6374
6375 _trigger: function(type, event, ui) {
6376 ui = ui || this._uiHash();
6377 $.ui.plugin.call(this, type, [event, ui]);
6378 //The absolute position has to be recalculated after plugins
6379 if(type === "drag") {
6380 this.positionAbs = this._convertPositionTo("absolute");
6381 }
6382 return $.Widget.prototype._trigger.call(this, type, event, ui);
6383 },
6384
6385 plugins: {},
6386
6387 _uiHash: function() {
6388 return {
6389 helper: this.helper,
6390 position: this.position,
6391 originalPosition: this.originalPosition,
6392 offset: this.positionAbs
6393 };
6394 }
6395
6396 });
6397
6398 $.ui.plugin.add("draggable", "connectToSortable", {
6399 start: function(event, ui) {
6400
6401 var inst = $(this).data("ui-draggable"), o = inst.options,
6402 uiSortable = $.extend({}, ui, { item: inst.element });
6403 inst.sortables = [];
6404 $(o.connectToSortable).each(function() {
6405 var sortable = $.data(this, "ui-sortable");
6406 if (sortable && !sortable.options.disabled) {
6407 inst.sortables.push({
6408 instance: sortable,
6409 shouldRevert: sortable.options.revert
6410 });
6411 sortable.refreshPositions(); // Call the sortable's refreshPositions at drag start to refresh the containerCache since the sortable container cache is used in drag and needs to be up to date (this will ensure it's initialised as well as being kept in step with any changes that might have happened on the page).
6412 sortable._trigger("activate", event, uiSortable);
6413 }
6414 });
6415
6416 },
6417 stop: function(event, ui) {
6418
6419 //If we are still over the sortable, we fake the stop event of the sortable, but also remove helper
6420 var inst = $(this).data("ui-draggable"),
6421 uiSortable = $.extend({}, ui, { item: inst.element });
6422
6423 $.each(inst.sortables, function() {
6424 if(this.instance.isOver) {
6425
6426 this.instance.isOver = 0;
6427
6428 inst.cancelHelperRemoval = true; //Don't remove the helper in the draggable instance
6429 this.instance.cancelHelperRemoval = false; //Remove it in the sortable instance (so sortable plugins like revert still work)
6430
6431 //The sortable revert is supported, and we have to set a temporary dropped variable on the draggable to support revert: "valid/invalid"
6432 if(this.shouldRevert) {
6433 this.instance.options.revert = this.shouldRevert;
6434 }
6435
6436 //Trigger the stop of the sortable
6437 this.instance._mouseStop(event);
6438
6439 this.instance.options.helper = this.instance.options._helper;
6440
6441 //If the helper has been the original item, restore properties in the sortable
6442 if(inst.options.helper === "original") {
6443 this.instance.currentItem.css({ top: "auto", left: "auto" });
6444 }
6445
6446 } else {
6447 this.instance.cancelHelperRemoval = false; //Remove the helper in the sortable instance
6448 this.instance._trigger("deactivate", event, uiSortable);
6449 }
6450
6451 });
6452
6453 },
6454 drag: function(event, ui) {
6455
6456 var inst = $(this).data("ui-draggable"), that = this;
6457
6458 $.each(inst.sortables, function() {
6459
6460 var innermostIntersecting = false,
6461 thisSortable = this;
6462
6463 //Copy over some variables to allow calling the sortable's native _intersectsWith
6464 this.instance.positionAbs = inst.positionAbs;
6465 this.instance.helperProportions = inst.helperProportions;
6466 this.instance.offset.click = inst.offset.click;
6467
6468 if(this.instance._intersectsWith(this.instance.containerCache)) {
6469 innermostIntersecting = true;
6470 $.each(inst.sortables, function () {
6471 this.instance.positionAbs = inst.positionAbs;
6472 this.instance.helperProportions = inst.helperProportions;
6473 this.instance.offset.click = inst.offset.click;
6474 if (this !== thisSortable &&
6475 this.instance._intersectsWith(this.instance.containerCache) &&
6476 $.contains(thisSortable.instance.element[0], this.instance.element[0])
6477 ) {
6478 innermostIntersecting = false;
6479 }
6480 return innermostIntersecting;
6481 });
6482 }
6483
6484
6485 if(innermostIntersecting) {
6486 //If it intersects, we use a little isOver variable and set it once, so our move-in stuff gets fired only once
6487 if(!this.instance.isOver) {
6488
6489 this.instance.isOver = 1;
6490 //Now we fake the start of dragging for the sortable instance,
6491 //by cloning the list group item, appending it to the sortable and using it as inst.currentItem
6492 //We can then fire the start event of the sortable with our passed browser event, and our own helper (so it doesn't create a new one)
6493 this.instance.currentItem = $(that).clone().removeAttr("id").appendTo(this.instance.element).data("ui-sortable-item", true);
6494 this.instance.options._helper = this.instance.options.helper; //Store helper option to later restore it
6495 this.instance.options.helper = function() { return ui.helper[0]; };
6496
6497 event.target = this.instance.currentItem[0];
6498 this.instance._mouseCapture(event, true);
6499 this.instance._mouseStart(event, true, true);
6500
6501 //Because the browser event is way off the new appended portlet, we modify a couple of variables to reflect the changes
6502 this.instance.offset.click.top = inst.offset.click.top;
6503 this.instance.offset.click.left = inst.offset.click.left;
6504 this.instance.offset.parent.left -= inst.offset.parent.left - this.instance.offset.parent.left;
6505 this.instance.offset.parent.top -= inst.offset.parent.top - this.instance.offset.parent.top;
6506
6507 inst._trigger("toSortable", event);
6508 inst.dropped = this.instance.element; //draggable revert needs that
6509 //hack so receive/update callbacks work (mostly)
6510 inst.currentItem = inst.element;
6511 this.instance.fromOutside = inst;
6512
6513 }
6514
6515 //Provided we did all the previous steps, we can fire the drag event of the sortable on every draggable drag, when it intersects with the sortable
6516 if(this.instance.currentItem) {
6517 this.instance._mouseDrag(event);
6518 }
6519
6520 } else {
6521
6522 //If it doesn't intersect with the sortable, and it intersected before,
6523 //we fake the drag stop of the sortable, but make sure it doesn't remove the helper by using cancelHelperRemoval
6524 if(this.instance.isOver) {
6525
6526 this.instance.isOver = 0;
6527 this.instance.cancelHelperRemoval = true;
6528
6529 //Prevent reverting on this forced stop
6530 this.instance.options.revert = false;
6531
6532 // The out event needs to be triggered independently
6533 this.instance._trigger("out", event, this.instance._uiHash(this.instance));
6534
6535 this.instance._mouseStop(event, true);
6536 this.instance.options.helper = this.instance.options._helper;
6537
6538 //Now we remove our currentItem, the list group clone again, and the placeholder, and animate the helper back to it's original size
6539 this.instance.currentItem.remove();
6540 if(this.instance.placeholder) {
6541 this.instance.placeholder.remove();
6542 }
6543
6544 inst._trigger("fromSortable", event);
6545 inst.dropped = false; //draggable revert needs that
6546 }
6547
6548 }
6549
6550 });
6551
6552 }
6553 });
6554
6555 $.ui.plugin.add("draggable", "cursor", {
6556 start: function() {
6557 var t = $("body"), o = $(this).data("ui-draggable").options;
6558 if (t.css("cursor")) {
6559 o._cursor = t.css("cursor");
6560 }
6561 t.css("cursor", o.cursor);
6562 },
6563 stop: function() {
6564 var o = $(this).data("ui-draggable").options;
6565 if (o._cursor) {
6566 $("body").css("cursor", o._cursor);
6567 }
6568 }
6569 });
6570
6571 $.ui.plugin.add("draggable", "opacity", {
6572 start: function(event, ui) {
6573 var t = $(ui.helper), o = $(this).data("ui-draggable").options;
6574 if(t.css("opacity")) {
6575 o._opacity = t.css("opacity");
6576 }
6577 t.css("opacity", o.opacity);
6578 },
6579 stop: function(event, ui) {
6580 var o = $(this).data("ui-draggable").options;
6581 if(o._opacity) {
6582 $(ui.helper).css("opacity", o._opacity);
6583 }
6584 }
6585 });
6586
6587 $.ui.plugin.add("draggable", "scroll", {
6588 start: function() {
6589 var i = $(this).data("ui-draggable");
6590 if(i.scrollParent[0] !== document && i.scrollParent[0].tagName !== "HTML") {
6591 i.overflowOffset = i.scrollParent.offset();
6592 }
6593 },
6594 drag: function( event ) {
6595
6596 var i = $(this).data("ui-draggable"), o = i.options, scrolled = false;
6597
6598 if(i.scrollParent[0] !== document && i.scrollParent[0].tagName !== "HTML") {
6599
6600 if(!o.axis || o.axis !== "x") {
6601 if((i.overflowOffset.top + i.scrollParent[0].offsetHeight) - event.pageY < o.scrollSensitivity) {
6602 i.scrollParent[0].scrollTop = scrolled = i.scrollParent[0].scrollTop + o.scrollSpeed;
6603 } else if(event.pageY - i.overflowOffset.top < o.scrollSensitivity) {
6604 i.scrollParent[0].scrollTop = scrolled = i.scrollParent[0].scrollTop - o.scrollSpeed;
6605 }
6606 }
6607
6608 if(!o.axis || o.axis !== "y") {
6609 if((i.overflowOffset.left + i.scrollParent[0].offsetWidth) - event.pageX < o.scrollSensitivity) {
6610 i.scrollParent[0].scrollLeft = scrolled = i.scrollParent[0].scrollLeft + o.scrollSpeed;
6611 } else if(event.pageX - i.overflowOffset.left < o.scrollSensitivity) {
6612 i.scrollParent[0].scrollLeft = scrolled = i.scrollParent[0].scrollLeft - o.scrollSpeed;
6613 }
6614 }
6615
6616 } else {
6617
6618 if(!o.axis || o.axis !== "x") {
6619 if(event.pageY - $(document).scrollTop() < o.scrollSensitivity) {
6620 scrolled = $(document).scrollTop($(document).scrollTop() - o.scrollSpeed);
6621 } else if($(window).height() - (event.pageY - $(document).scrollTop()) < o.scrollSensitivity) {
6622 scrolled = $(document).scrollTop($(document).scrollTop() + o.scrollSpeed);
6623 }
6624 }
6625
6626 if(!o.axis || o.axis !== "y") {
6627 if(event.pageX - $(document).scrollLeft() < o.scrollSensitivity) {
6628 scrolled = $(document).scrollLeft($(document).scrollLeft() - o.scrollSpeed);
6629 } else if($(window).width() - (event.pageX - $(document).scrollLeft()) < o.scrollSensitivity) {
6630 scrolled = $(document).scrollLeft($(document).scrollLeft() + o.scrollSpeed);
6631 }
6632 }
6633
6634 }
6635
6636 if(scrolled !== false && $.ui.ddmanager && !o.dropBehaviour) {
6637 $.ui.ddmanager.prepareOffsets(i, event);
6638 }
6639
6640 }
6641 });
6642
6643 $.ui.plugin.add("draggable", "snap", {
6644 start: function() {
6645
6646 var i = $(this).data("ui-draggable"),
6647 o = i.options;
6648
6649 i.snapElements = [];
6650
6651 $(o.snap.constructor !== String ? ( o.snap.items || ":data(ui-draggable)" ) : o.snap).each(function() {
6652 var $t = $(this),
6653 $o = $t.offset();
6654 if(this !== i.element[0]) {
6655 i.snapElements.push({
6656 item: this,
6657 width: $t.outerWidth(), height: $t.outerHeight(),
6658 top: $o.top, left: $o.left
6659 });
6660 }
6661 });
6662
6663 },
6664 drag: function(event, ui) {
6665
6666 var ts, bs, ls, rs, l, r, t, b, i, first,
6667 inst = $(this).data("ui-draggable"),
6668 o = inst.options,
6669 d = o.snapTolerance,
6670 x1 = ui.offset.left, x2 = x1 + inst.helperProportions.width,
6671 y1 = ui.offset.top, y2 = y1 + inst.helperProportions.height;
6672
6673 for (i = inst.snapElements.length - 1; i >= 0; i--){
6674
6675 l = inst.snapElements[i].left;
6676 r = l + inst.snapElements[i].width;
6677 t = inst.snapElements[i].top;
6678 b = t + inst.snapElements[i].height;
6679
6680 if ( x2 < l - d || x1 > r + d || y2 < t - d || y1 > b + d || !$.contains( inst.snapElements[ i ].item.ownerDocument, inst.snapElements[ i ].item ) ) {
6681 if(inst.snapElements[i].snapping) {
6682 (inst.options.snap.release && inst.options.snap.release.call(inst.element, event, $.extend(inst._uiHash(), { snapItem: inst.snapElements[i].item })));
6683 }
6684 inst.snapElements[i].snapping = false;
6685 continue;
6686 }
6687
6688 if(o.snapMode !== "inner") {
6689 ts = Math.abs(t - y2) <= d;
6690 bs = Math.abs(b - y1) <= d;
6691 ls = Math.abs(l - x2) <= d;
6692 rs = Math.abs(r - x1) <= d;
6693 if(ts) {
6694 ui.position.top = inst._convertPositionTo("relative", { top: t - inst.helperProportions.height, left: 0 }).top - inst.margins.top;
6695 }
6696 if(bs) {
6697 ui.position.top = inst._convertPositionTo("relative", { top: b, left: 0 }).top - inst.margins.top;
6698 }
6699 if(ls) {
6700 ui.position.left = inst._convertPositionTo("relative", { top: 0, left: l - inst.helperProportions.width }).left - inst.margins.left;
6701 }
6702 if(rs) {
6703 ui.position.left = inst._convertPositionTo("relative", { top: 0, left: r }).left - inst.margins.left;
6704 }
6705 }
6706
6707 first = (ts || bs || ls || rs);
6708
6709 if(o.snapMode !== "outer") {
6710 ts = Math.abs(t - y1) <= d;
6711 bs = Math.abs(b - y2) <= d;
6712 ls = Math.abs(l - x1) <= d;
6713 rs = Math.abs(r - x2) <= d;
6714 if(ts) {
6715 ui.position.top = inst._convertPositionTo("relative", { top: t, left: 0 }).top - inst.margins.top;
6716 }
6717 if(bs) {
6718 ui.position.top = inst._convertPositionTo("relative", { top: b - inst.helperProportions.height, left: 0 }).top - inst.margins.top;
6719 }
6720 if(ls) {
6721 ui.position.left = inst._convertPositionTo("relative", { top: 0, left: l }).left - inst.margins.left;
6722 }
6723 if(rs) {
6724 ui.position.left = inst._convertPositionTo("relative", { top: 0, left: r - inst.helperProportions.width }).left - inst.margins.left;
6725 }
6726 }
6727
6728 if(!inst.snapElements[i].snapping && (ts || bs || ls || rs || first)) {
6729 (inst.options.snap.snap && inst.options.snap.snap.call(inst.element, event, $.extend(inst._uiHash(), { snapItem: inst.snapElements[i].item })));
6730 }
6731 inst.snapElements[i].snapping = (ts || bs || ls || rs || first);
6732
6733 }
6734
6735 }
6736 });
6737
6738 $.ui.plugin.add("draggable", "stack", {
6739 start: function() {
6740 var min,
6741 o = this.data("ui-draggable").options,
6742 group = $.makeArray($(o.stack)).sort(function(a,b) {
6743 return (parseInt($(a).css("zIndex"),10) || 0) - (parseInt($(b).css("zIndex"),10) || 0);
6744 });
6745
6746 if (!group.length) { return; }
6747
6748 min = parseInt($(group[0]).css("zIndex"), 10) || 0;
6749 $(group).each(function(i) {
6750 $(this).css("zIndex", min + i);
6751 });
6752 this.css("zIndex", (min + group.length));
6753 }
6754 });
6755
6756 $.ui.plugin.add("draggable", "zIndex", {
6757 start: function(event, ui) {
6758 var t = $(ui.helper), o = $(this).data("ui-draggable").options;
6759 if(t.css("zIndex")) {
6760 o._zIndex = t.css("zIndex");
6761 }
6762 t.css("zIndex", o.zIndex);
6763 },
6764 stop: function(event, ui) {
6765 var o = $(this).data("ui-draggable").options;
6766 if(o._zIndex) {
6767 $(ui.helper).css("zIndex", o._zIndex);
6768 }
6769 }
6770 });
6771
6772 })(jQuery);
6773 (function( $, undefined ) {
6774
6775 function isOverAxis( x, reference, size ) {
6776 return ( x > reference ) && ( x < ( reference + size ) );
6777 }
6778
6779 $.widget("ui.droppable", {
6780 version: "1.10.4",
6781 widgetEventPrefix: "drop",
6782 options: {
6783 accept: "*",
6784 activeClass: false,
6785 addClasses: true,
6786 greedy: false,
6787 hoverClass: false,
6788 scope: "default",
6789 tolerance: "intersect",
6790
6791 // callbacks
6792 activate: null,
6793 deactivate: null,
6794 drop: null,
6795 out: null,
6796 over: null
6797 },
6798 _create: function() {
6799
6800 var proportions,
6801 o = this.options,
6802 accept = o.accept;
6803
6804 this.isover = false;
6805 this.isout = true;
6806
6807 this.accept = $.isFunction(accept) ? accept : function(d) {
6808 return d.is(accept);
6809 };
6810
6811 this.proportions = function( /* valueToWrite */ ) {
6812 if ( arguments.length ) {
6813 // Store the droppable's proportions
6814 proportions = arguments[ 0 ];
6815 } else {
6816 // Retrieve or derive the droppable's proportions
6817 return proportions ?
6818 proportions :
6819 proportions = {
6820 width: this.element[ 0 ].offsetWidth,
6821 height: this.element[ 0 ].offsetHeight
6822 };
6823 }
6824 };
6825
6826 // Add the reference and positions to the manager
6827 $.ui.ddmanager.droppables[o.scope] = $.ui.ddmanager.droppables[o.scope] || [];
6828 $.ui.ddmanager.droppables[o.scope].push(this);
6829
6830 (o.addClasses && this.element.addClass("ui-droppable"));
6831
6832 },
6833
6834 _destroy: function() {
6835 var i = 0,
6836 drop = $.ui.ddmanager.droppables[this.options.scope];
6837
6838 for ( ; i < drop.length; i++ ) {
6839 if ( drop[i] === this ) {
6840 drop.splice(i, 1);
6841 }
6842 }
6843
6844 this.element.removeClass("ui-droppable ui-droppable-disabled");
6845 },
6846
6847 _setOption: function(key, value) {
6848
6849 if(key === "accept") {
6850 this.accept = $.isFunction(value) ? value : function(d) {
6851 return d.is(value);
6852 };
6853 }
6854 $.Widget.prototype._setOption.apply(this, arguments);
6855 },
6856
6857 _activate: function(event) {
6858 var draggable = $.ui.ddmanager.current;
6859 if(this.options.activeClass) {
6860 this.element.addClass(this.options.activeClass);
6861 }
6862 if(draggable){
6863 this._trigger("activate", event, this.ui(draggable));
6864 }
6865 },
6866
6867 _deactivate: function(event) {
6868 var draggable = $.ui.ddmanager.current;
6869 if(this.options.activeClass) {
6870 this.element.removeClass(this.options.activeClass);
6871 }
6872 if(draggable){
6873 this._trigger("deactivate", event, this.ui(draggable));
6874 }
6875 },
6876
6877 _over: function(event) {
6878
6879 var draggable = $.ui.ddmanager.current;
6880
6881 // Bail if draggable and droppable are same element
6882 if (!draggable || (draggable.currentItem || draggable.element)[0] === this.element[0]) {
6883 return;
6884 }
6885
6886 if (this.accept.call(this.element[0],(draggable.currentItem || draggable.element))) {
6887 if(this.options.hoverClass) {
6888 this.element.addClass(this.options.hoverClass);
6889 }
6890 this._trigger("over", event, this.ui(draggable));
6891 }
6892
6893 },
6894
6895 _out: function(event) {
6896
6897 var draggable = $.ui.ddmanager.current;
6898
6899 // Bail if draggable and droppable are same element
6900 if (!draggable || (draggable.currentItem || draggable.element)[0] === this.element[0]) {
6901 return;
6902 }
6903
6904 if (this.accept.call(this.element[0],(draggable.currentItem || draggable.element))) {
6905 if(this.options.hoverClass) {
6906 this.element.removeClass(this.options.hoverClass);
6907 }
6908 this._trigger("out", event, this.ui(draggable));
6909 }
6910
6911 },
6912
6913 _drop: function(event,custom) {
6914
6915 var draggable = custom || $.ui.ddmanager.current,
6916 childrenIntersection = false;
6917
6918 // Bail if draggable and droppable are same element
6919 if (!draggable || (draggable.currentItem || draggable.element)[0] === this.element[0]) {
6920 return false;
6921 }
6922
6923 this.element.find(":data(ui-droppable)").not(".ui-draggable-dragging").each(function() {
6924 var inst = $.data(this, "ui-droppable");
6925 if(
6926 inst.options.greedy &&
6927 !inst.options.disabled &&
6928 inst.options.scope === draggable.options.scope &&
6929 inst.accept.call(inst.element[0], (draggable.currentItem || draggable.element)) &&
6930 $.ui.intersect(draggable, $.extend(inst, { offset: inst.element.offset() }), inst.options.tolerance)
6931 ) { childrenIntersection = true; return false; }
6932 });
6933 if(childrenIntersection) {
6934 return false;
6935 }
6936
6937 if(this.accept.call(this.element[0],(draggable.currentItem || draggable.element))) {
6938 if(this.options.activeClass) {
6939 this.element.removeClass(this.options.activeClass);
6940 }
6941 if(this.options.hoverClass) {
6942 this.element.removeClass(this.options.hoverClass);
6943 }
6944 this._trigger("drop", event, this.ui(draggable));
6945 return this.element;
6946 }
6947
6948 return false;
6949
6950 },
6951
6952 ui: function(c) {
6953 return {
6954 draggable: (c.currentItem || c.element),
6955 helper: c.helper,
6956 position: c.position,
6957 offset: c.positionAbs
6958 };
6959 }
6960
6961 });
6962
6963 $.ui.intersect = function(draggable, droppable, toleranceMode) {
6964
6965 if (!droppable.offset) {
6966 return false;
6967 }
6968
6969 var draggableLeft, draggableTop,
6970 x1 = (draggable.positionAbs || draggable.position.absolute).left,
6971 y1 = (draggable.positionAbs || draggable.position.absolute).top,
6972 x2 = x1 + draggable.helperProportions.width,
6973 y2 = y1 + draggable.helperProportions.height,
6974 l = droppable.offset.left,
6975 t = droppable.offset.top,
6976 r = l + droppable.proportions().width,
6977 b = t + droppable.proportions().height;
6978
6979 switch (toleranceMode) {
6980 case "fit":
6981 return (l <= x1 && x2 <= r && t <= y1 && y2 <= b);
6982 case "intersect":
6983 return (l < x1 + (draggable.helperProportions.width / 2) && // Right Half
6984 x2 - (draggable.helperProportions.width / 2) < r && // Left Half
6985 t < y1 + (draggable.helperProportions.height / 2) && // Bottom Half
6986 y2 - (draggable.helperProportions.height / 2) < b ); // Top Half
6987 case "pointer":
6988 draggableLeft = ((draggable.positionAbs || draggable.position.absolute).left + (draggable.clickOffset || draggable.offset.click).left);
6989 draggableTop = ((draggable.positionAbs || draggable.position.absolute).top + (draggable.clickOffset || draggable.offset.click).top);
6990 return isOverAxis( draggableTop, t, droppable.proportions().height ) && isOverAxis( draggableLeft, l, droppable.proportions().width );
6991 case "touch":
6992 return (
6993 (y1 >= t && y1 <= b) || // Top edge touching
6994 (y2 >= t && y2 <= b) || // Bottom edge touching
6995 (y1 < t && y2 > b) // Surrounded vertically
6996 ) && (
6997 (x1 >= l && x1 <= r) || // Left edge touching
6998 (x2 >= l && x2 <= r) || // Right edge touching
6999 (x1 < l && x2 > r) // Surrounded horizontally
7000 );
7001 default:
7002 return false;
7003 }
7004
7005 };
7006
7007 /*
7008 This manager tracks offsets of draggables and droppables
7009 */
7010 $.ui.ddmanager = {
7011 current: null,
7012 droppables: { "default": [] },
7013 prepareOffsets: function(t, event) {
7014
7015 var i, j,
7016 m = $.ui.ddmanager.droppables[t.options.scope] || [],
7017 type = event ? event.type : null, // workaround for #2317
7018 list = (t.currentItem || t.element).find(":data(ui-droppable)").addBack();
7019
7020 droppablesLoop: for (i = 0; i < m.length; i++) {
7021
7022 //No disabled and non-accepted
7023 if(m[i].options.disabled || (t && !m[i].accept.call(m[i].element[0],(t.currentItem || t.element)))) {
7024 continue;
7025 }
7026
7027 // Filter out elements in the current dragged item
7028 for (j=0; j < list.length; j++) {
7029 if(list[j] === m[i].element[0]) {
7030 m[i].proportions().height = 0;
7031 continue droppablesLoop;
7032 }
7033 }
7034
7035 m[i].visible = m[i].element.css("display") !== "none";
7036 if(!m[i].visible) {
7037 continue;
7038 }
7039
7040 //Activate the droppable if used directly from draggables
7041 if(type === "mousedown") {
7042 m[i]._activate.call(m[i], event);
7043 }
7044
7045 m[ i ].offset = m[ i ].element.offset();
7046 m[ i ].proportions({ width: m[ i ].element[ 0 ].offsetWidth, height: m[ i ].element[ 0 ].offsetHeight });
7047
7048 }
7049
7050 },
7051 drop: function(draggable, event) {
7052
7053 var dropped = false;
7054 // Create a copy of the droppables in case the list changes during the drop (#9116)
7055 $.each(($.ui.ddmanager.droppables[draggable.options.scope] || []).slice(), function() {
7056
7057 if(!this.options) {
7058 return;
7059 }
7060 if (!this.options.disabled && this.visible && $.ui.intersect(draggable, this, this.options.tolerance)) {
7061 dropped = this._drop.call(this, event) || dropped;
7062 }
7063
7064 if (!this.options.disabled && this.visible && this.accept.call(this.element[0],(draggable.currentItem || draggable.element))) {
7065 this.isout = true;
7066 this.isover = false;
7067 this._deactivate.call(this, event);
7068 }
7069
7070 });
7071 return dropped;
7072
7073 },
7074 dragStart: function( draggable, event ) {
7075 //Listen for scrolling so that if the dragging causes scrolling the position of the droppables can be recalculated (see #5003)
7076 draggable.element.parentsUntil( "body" ).bind( "scroll.droppable", function() {
7077 if( !draggable.options.refreshPositions ) {
7078 $.ui.ddmanager.prepareOffsets( draggable, event );
7079 }
7080 });
7081 },
7082 drag: function(draggable, event) {
7083
7084 //If you have a highly dynamic page, you might try this option. It renders positions every time you move the mouse.
7085 if(draggable.options.refreshPositions) {
7086 $.ui.ddmanager.prepareOffsets(draggable, event);
7087 }
7088
7089 //Run through all droppables and check their positions based on specific tolerance options
7090 $.each($.ui.ddmanager.droppables[draggable.options.scope] || [], function() {
7091
7092 if(this.options.disabled || this.greedyChild || !this.visible) {
7093 return;
7094 }
7095
7096 var parentInstance, scope, parent,
7097 intersects = $.ui.intersect(draggable, this, this.options.tolerance),
7098 c = !intersects && this.isover ? "isout" : (intersects && !this.isover ? "isover" : null);
7099 if(!c) {
7100 return;
7101 }
7102
7103 if (this.options.greedy) {
7104 // find droppable parents with same scope
7105 scope = this.options.scope;
7106 parent = this.element.parents(":data(ui-droppable)").filter(function () {
7107 return $.data(this, "ui-droppable").options.scope === scope;
7108 });
7109
7110 if (parent.length) {
7111 parentInstance = $.data(parent[0], "ui-droppable");
7112 parentInstance.greedyChild = (c === "isover");
7113 }
7114 }
7115
7116 // we just moved into a greedy child
7117 if (parentInstance && c === "isover") {
7118 parentInstance.isover = false;
7119 parentInstance.isout = true;
7120 parentInstance._out.call(parentInstance, event);
7121 }
7122
7123 this[c] = true;
7124 this[c === "isout" ? "isover" : "isout"] = false;
7125 this[c === "isover" ? "_over" : "_out"].call(this, event);
7126
7127 // we just moved out of a greedy child
7128 if (parentInstance && c === "isout") {
7129 parentInstance.isout = false;
7130 parentInstance.isover = true;
7131 parentInstance._over.call(parentInstance, event);
7132 }
7133 });
7134
7135 },
7136 dragStop: function( draggable, event ) {
7137 draggable.element.parentsUntil( "body" ).unbind( "scroll.droppable" );
7138 //Call prepareOffsets one final time since IE does not fire return scroll events when overflow was caused by drag (see #5003)
7139 if( !draggable.options.refreshPositions ) {
7140 $.ui.ddmanager.prepareOffsets( draggable, event );
7141 }
7142 }
7143 };
7144
7145 })(jQuery);
7146 (function($, undefined) {
7147
7148 var dataSpace = "ui-effects-";
7149
7150 $.effects = {
7151 effect: {}
7152 };
7153
7154 /*!
7155 * jQuery Color Animations v2.1.2
7156 * https://github.com/jquery/jquery-color
7157 *
7158 * Copyright 2013 jQuery Foundation and other contributors
7159 * Released under the MIT license.
7160 * http://jquery.org/license
7161 *
7162 * Date: Wed Jan 16 08:47:09 2013 -0600
7163 */
7164 (function( jQuery, undefined ) {
7165
7166 var stepHooks = "backgroundColor borderBottomColor borderLeftColor borderRightColor borderTopColor color columnRuleColor outlineColor textDecorationColor textEmphasisColor",
7167
7168 // plusequals test for += 100 -= 100
7169 rplusequals = /^([\-+])=\s*(\d+\.?\d*)/,
7170 // a set of RE's that can match strings and generate color tuples.
7171 stringParsers = [{
7172 re: /rgba?\(\s*(\d{1,3})\s*,\s*(\d{1,3})\s*,\s*(\d{1,3})\s*(?:,\s*(\d?(?:\.\d+)?)\s*)?\)/,
7173 parse: function( execResult ) {
7174 return [
7175 execResult[ 1 ],
7176 execResult[ 2 ],
7177 execResult[ 3 ],
7178 execResult[ 4 ]
7179 ];
7180 }
7181 }, {
7182 re: /rgba?\(\s*(\d+(?:\.\d+)?)\%\s*,\s*(\d+(?:\.\d+)?)\%\s*,\s*(\d+(?:\.\d+)?)\%\s*(?:,\s*(\d?(?:\.\d+)?)\s*)?\)/,
7183 parse: function( execResult ) {
7184 return [
7185 execResult[ 1 ] * 2.55,
7186 execResult[ 2 ] * 2.55,
7187 execResult[ 3 ] * 2.55,
7188 execResult[ 4 ]
7189 ];
7190 }
7191 }, {
7192 // this regex ignores A-F because it's compared against an already lowercased string
7193 re: /#([a-f0-9]{2})([a-f0-9]{2})([a-f0-9]{2})/,
7194 parse: function( execResult ) {
7195 return [
7196 parseInt( execResult[ 1 ], 16 ),
7197 parseInt( execResult[ 2 ], 16 ),
7198 parseInt( execResult[ 3 ], 16 )
7199 ];
7200 }
7201 }, {
7202 // this regex ignores A-F because it's compared against an already lowercased string
7203 re: /#([a-f0-9])([a-f0-9])([a-f0-9])/,
7204 parse: function( execResult ) {
7205 return [
7206 parseInt( execResult[ 1 ] + execResult[ 1 ], 16 ),
7207 parseInt( execResult[ 2 ] + execResult[ 2 ], 16 ),
7208 parseInt( execResult[ 3 ] + execResult[ 3 ], 16 )
7209 ];
7210 }
7211 }, {
7212 re: /hsla?\(\s*(\d+(?:\.\d+)?)\s*,\s*(\d+(?:\.\d+)?)\%\s*,\s*(\d+(?:\.\d+)?)\%\s*(?:,\s*(\d?(?:\.\d+)?)\s*)?\)/,
7213 space: "hsla",
7214 parse: function( execResult ) {
7215 return [
7216 execResult[ 1 ],
7217 execResult[ 2 ] / 100,
7218 execResult[ 3 ] / 100,
7219 execResult[ 4 ]
7220 ];
7221 }
7222 }],
7223
7224 // jQuery.Color( )
7225 color = jQuery.Color = function( color, green, blue, alpha ) {
7226 return new jQuery.Color.fn.parse( color, green, blue, alpha );
7227 },
7228 spaces = {
7229 rgba: {
7230 props: {
7231 red: {
7232 idx: 0,
7233 type: "byte"
7234 },
7235 green: {
7236 idx: 1,
7237 type: "byte"
7238 },
7239 blue: {
7240 idx: 2,
7241 type: "byte"
7242 }
7243 }
7244 },
7245
7246 hsla: {
7247 props: {
7248 hue: {
7249 idx: 0,
7250 type: "degrees"
7251 },
7252 saturation: {
7253 idx: 1,
7254 type: "percent"
7255 },
7256 lightness: {
7257 idx: 2,
7258 type: "percent"
7259 }
7260 }
7261 }
7262 },
7263 propTypes = {
7264 "byte": {
7265 floor: true,
7266 max: 255
7267 },
7268 "percent": {
7269 max: 1
7270 },
7271 "degrees": {
7272 mod: 360,
7273 floor: true
7274 }
7275 },
7276 support = color.support = {},
7277
7278 // element for support tests
7279 supportElem = jQuery( "<p>" )[ 0 ],
7280
7281 // colors = jQuery.Color.names
7282 colors,
7283
7284 // local aliases of functions called often
7285 each = jQuery.each;
7286
7287 // determine rgba support immediately
7288 supportElem.style.cssText = "background-color:rgba(1,1,1,.5)";
7289 support.rgba = supportElem.style.backgroundColor.indexOf( "rgba" ) > -1;
7290
7291 // define cache name and alpha properties
7292 // for rgba and hsla spaces
7293 each( spaces, function( spaceName, space ) {
7294 space.cache = "_" + spaceName;
7295 space.props.alpha = {
7296 idx: 3,
7297 type: "percent",
7298 def: 1
7299 };
7300 });
7301
7302 function clamp( value, prop, allowEmpty ) {
7303 var type = propTypes[ prop.type ] || {};
7304
7305 if ( value == null ) {
7306 return (allowEmpty || !prop.def) ? null : prop.def;
7307 }
7308
7309 // ~~ is an short way of doing floor for positive numbers
7310 value = type.floor ? ~~value : parseFloat( value );
7311
7312 // IE will pass in empty strings as value for alpha,
7313 // which will hit this case
7314 if ( isNaN( value ) ) {
7315 return prop.def;
7316 }
7317
7318 if ( type.mod ) {
7319 // we add mod before modding to make sure that negatives values
7320 // get converted properly: -10 -> 350
7321 return (value + type.mod) % type.mod;
7322 }
7323
7324 // for now all property types without mod have min and max
7325 return 0 > value ? 0 : type.max < value ? type.max : value;
7326 }
7327
7328 function stringParse( string ) {
7329 var inst = color(),
7330 rgba = inst._rgba = [];
7331
7332 string = string.toLowerCase();
7333
7334 each( stringParsers, function( i, parser ) {
7335 var parsed,
7336 match = parser.re.exec( string ),
7337 values = match && parser.parse( match ),
7338 spaceName = parser.space || "rgba";
7339
7340 if ( values ) {
7341 parsed = inst[ spaceName ]( values );
7342
7343 // if this was an rgba parse the assignment might happen twice
7344 // oh well....
7345 inst[ spaces[ spaceName ].cache ] = parsed[ spaces[ spaceName ].cache ];
7346 rgba = inst._rgba = parsed._rgba;
7347
7348 // exit each( stringParsers ) here because we matched
7349 return false;
7350 }
7351 });
7352
7353 // Found a stringParser that handled it
7354 if ( rgba.length ) {
7355
7356 // if this came from a parsed string, force "transparent" when alpha is 0
7357 // chrome, (and maybe others) return "transparent" as rgba(0,0,0,0)
7358 if ( rgba.join() === "0,0,0,0" ) {
7359 jQuery.extend( rgba, colors.transparent );
7360 }
7361 return inst;
7362 }
7363
7364 // named colors
7365 return colors[ string ];
7366 }
7367
7368 color.fn = jQuery.extend( color.prototype, {
7369 parse: function( red, green, blue, alpha ) {
7370 if ( red === undefined ) {
7371 this._rgba = [ null, null, null, null ];
7372 return this;
7373 }
7374 if ( red.jquery || red.nodeType ) {
7375 red = jQuery( red ).css( green );
7376 green = undefined;
7377 }
7378
7379 var inst = this,
7380 type = jQuery.type( red ),
7381 rgba = this._rgba = [];
7382
7383 // more than 1 argument specified - assume ( red, green, blue, alpha )
7384 if ( green !== undefined ) {
7385 red = [ red, green, blue, alpha ];
7386 type = "array";
7387 }
7388
7389 if ( type === "string" ) {
7390 return this.parse( stringParse( red ) || colors._default );
7391 }
7392
7393 if ( type === "array" ) {
7394 each( spaces.rgba.props, function( key, prop ) {
7395 rgba[ prop.idx ] = clamp( red[ prop.idx ], prop );
7396 });
7397 return this;
7398 }
7399
7400 if ( type === "object" ) {
7401 if ( red instanceof color ) {
7402 each( spaces, function( spaceName, space ) {
7403 if ( red[ space.cache ] ) {
7404 inst[ space.cache ] = red[ space.cache ].slice();
7405 }
7406 });
7407 } else {
7408 each( spaces, function( spaceName, space ) {
7409 var cache = space.cache;
7410 each( space.props, function( key, prop ) {
7411
7412 // if the cache doesn't exist, and we know how to convert
7413 if ( !inst[ cache ] && space.to ) {
7414
7415 // if the value was null, we don't need to copy it
7416 // if the key was alpha, we don't need to copy it either
7417 if ( key === "alpha" || red[ key ] == null ) {
7418 return;
7419 }
7420 inst[ cache ] = space.to( inst._rgba );
7421 }
7422
7423 // this is the only case where we allow nulls for ALL properties.
7424 // call clamp with alwaysAllowEmpty
7425 inst[ cache ][ prop.idx ] = clamp( red[ key ], prop, true );
7426 });
7427
7428 // everything defined but alpha?
7429 if ( inst[ cache ] && jQuery.inArray( null, inst[ cache ].slice( 0, 3 ) ) < 0 ) {
7430 // use the default of 1
7431 inst[ cache ][ 3 ] = 1;
7432 if ( space.from ) {
7433 inst._rgba = space.from( inst[ cache ] );
7434 }
7435 }
7436 });
7437 }
7438 return this;
7439 }
7440 },
7441 is: function( compare ) {
7442 var is = color( compare ),
7443 same = true,
7444 inst = this;
7445
7446 each( spaces, function( _, space ) {
7447 var localCache,
7448 isCache = is[ space.cache ];
7449 if (isCache) {
7450 localCache = inst[ space.cache ] || space.to && space.to( inst._rgba ) || [];
7451 each( space.props, function( _, prop ) {
7452 if ( isCache[ prop.idx ] != null ) {
7453 same = ( isCache[ prop.idx ] === localCache[ prop.idx ] );
7454 return same;
7455 }
7456 });
7457 }
7458 return same;
7459 });
7460 return same;
7461 },
7462 _space: function() {
7463 var used = [],
7464 inst = this;
7465 each( spaces, function( spaceName, space ) {
7466 if ( inst[ space.cache ] ) {
7467 used.push( spaceName );
7468 }
7469 });
7470 return used.pop();
7471 },
7472 transition: function( other, distance ) {
7473 var end = color( other ),
7474 spaceName = end._space(),
7475 space = spaces[ spaceName ],
7476 startColor = this.alpha() === 0 ? color( "transparent" ) : this,
7477 start = startColor[ space.cache ] || space.to( startColor._rgba ),
7478 result = start.slice();
7479
7480 end = end[ space.cache ];
7481 each( space.props, function( key, prop ) {
7482 var index = prop.idx,
7483 startValue = start[ index ],
7484 endValue = end[ index ],
7485 type = propTypes[ prop.type ] || {};
7486
7487 // if null, don't override start value
7488 if ( endValue === null ) {
7489 return;
7490 }
7491 // if null - use end
7492 if ( startValue === null ) {
7493 result[ index ] = endValue;
7494 } else {
7495 if ( type.mod ) {
7496 if ( endValue - startValue > type.mod / 2 ) {
7497 startValue += type.mod;
7498 } else if ( startValue - endValue > type.mod / 2 ) {
7499 startValue -= type.mod;
7500 }
7501 }
7502 result[ index ] = clamp( ( endValue - startValue ) * distance + startValue, prop );
7503 }
7504 });
7505 return this[ spaceName ]( result );
7506 },
7507 blend: function( opaque ) {
7508 // if we are already opaque - return ourself
7509 if ( this._rgba[ 3 ] === 1 ) {
7510 return this;
7511 }
7512
7513 var rgb = this._rgba.slice(),
7514 a = rgb.pop(),
7515 blend = color( opaque )._rgba;
7516
7517 return color( jQuery.map( rgb, function( v, i ) {
7518 return ( 1 - a ) * blend[ i ] + a * v;
7519 }));
7520 },
7521 toRgbaString: function() {
7522 var prefix = "rgba(",
7523 rgba = jQuery.map( this._rgba, function( v, i ) {
7524 return v == null ? ( i > 2 ? 1 : 0 ) : v;
7525 });
7526
7527 if ( rgba[ 3 ] === 1 ) {
7528 rgba.pop();
7529 prefix = "rgb(";
7530 }
7531
7532 return prefix + rgba.join() + ")";
7533 },
7534 toHslaString: function() {
7535 var prefix = "hsla(",
7536 hsla = jQuery.map( this.hsla(), function( v, i ) {
7537 if ( v == null ) {
7538 v = i > 2 ? 1 : 0;
7539 }
7540
7541 // catch 1 and 2
7542 if ( i && i < 3 ) {
7543 v = Math.round( v * 100 ) + "%";
7544 }
7545 return v;
7546 });
7547
7548 if ( hsla[ 3 ] === 1 ) {
7549 hsla.pop();
7550 prefix = "hsl(";
7551 }
7552 return prefix + hsla.join() + ")";
7553 },
7554 toHexString: function( includeAlpha ) {
7555 var rgba = this._rgba.slice(),
7556 alpha = rgba.pop();
7557
7558 if ( includeAlpha ) {
7559 rgba.push( ~~( alpha * 255 ) );
7560 }
7561
7562 return "#" + jQuery.map( rgba, function( v ) {
7563
7564 // default to 0 when nulls exist
7565 v = ( v || 0 ).toString( 16 );
7566 return v.length === 1 ? "0" + v : v;
7567 }).join("");
7568 },
7569 toString: function() {
7570 return this._rgba[ 3 ] === 0 ? "transparent" : this.toRgbaString();
7571 }
7572 });
7573 color.fn.parse.prototype = color.fn;
7574
7575 // hsla conversions adapted from:
7576 // https://code.google.com/p/maashaack/source/browse/packages/graphics/trunk/src/graphics/colors/HUE2RGB.as?r=5021
7577
7578 function hue2rgb( p, q, h ) {
7579 h = ( h + 1 ) % 1;
7580 if ( h * 6 < 1 ) {
7581 return p + (q - p) * h * 6;
7582 }
7583 if ( h * 2 < 1) {
7584 return q;
7585 }
7586 if ( h * 3 < 2 ) {
7587 return p + (q - p) * ((2/3) - h) * 6;
7588 }
7589 return p;
7590 }
7591
7592 spaces.hsla.to = function ( rgba ) {
7593 if ( rgba[ 0 ] == null || rgba[ 1 ] == null || rgba[ 2 ] == null ) {
7594 return [ null, null, null, rgba[ 3 ] ];
7595 }
7596 var r = rgba[ 0 ] / 255,
7597 g = rgba[ 1 ] / 255,
7598 b = rgba[ 2 ] / 255,
7599 a = rgba[ 3 ],
7600 max = Math.max( r, g, b ),
7601 min = Math.min( r, g, b ),
7602 diff = max - min,
7603 add = max + min,
7604 l = add * 0.5,
7605 h, s;
7606
7607 if ( min === max ) {
7608 h = 0;
7609 } else if ( r === max ) {
7610 h = ( 60 * ( g - b ) / diff ) + 360;
7611 } else if ( g === max ) {
7612 h = ( 60 * ( b - r ) / diff ) + 120;
7613 } else {
7614 h = ( 60 * ( r - g ) / diff ) + 240;
7615 }
7616
7617 // chroma (diff) == 0 means greyscale which, by definition, saturation = 0%
7618 // otherwise, saturation is based on the ratio of chroma (diff) to lightness (add)
7619 if ( diff === 0 ) {
7620 s = 0;
7621 } else if ( l <= 0.5 ) {
7622 s = diff / add;
7623 } else {
7624 s = diff / ( 2 - add );
7625 }
7626 return [ Math.round(h) % 360, s, l, a == null ? 1 : a ];
7627 };
7628
7629 spaces.hsla.from = function ( hsla ) {
7630 if ( hsla[ 0 ] == null || hsla[ 1 ] == null || hsla[ 2 ] == null ) {
7631 return [ null, null, null, hsla[ 3 ] ];
7632 }
7633 var h = hsla[ 0 ] / 360,
7634 s = hsla[ 1 ],
7635 l = hsla[ 2 ],
7636 a = hsla[ 3 ],
7637 q = l <= 0.5 ? l * ( 1 + s ) : l + s - l * s,
7638 p = 2 * l - q;
7639
7640 return [
7641 Math.round( hue2rgb( p, q, h + ( 1 / 3 ) ) * 255 ),
7642 Math.round( hue2rgb( p, q, h ) * 255 ),
7643 Math.round( hue2rgb( p, q, h - ( 1 / 3 ) ) * 255 ),
7644 a
7645 ];
7646 };
7647
7648
7649 each( spaces, function( spaceName, space ) {
7650 var props = space.props,
7651 cache = space.cache,
7652 to = space.to,
7653 from = space.from;
7654
7655 // makes rgba() and hsla()
7656 color.fn[ spaceName ] = function( value ) {
7657
7658 // generate a cache for this space if it doesn't exist
7659 if ( to && !this[ cache ] ) {
7660 this[ cache ] = to( this._rgba );
7661 }
7662 if ( value === undefined ) {
7663 return this[ cache ].slice();
7664 }
7665
7666 var ret,
7667 type = jQuery.type( value ),
7668 arr = ( type === "array" || type === "object" ) ? value : arguments,
7669 local = this[ cache ].slice();
7670
7671 each( props, function( key, prop ) {
7672 var val = arr[ type === "object" ? key : prop.idx ];
7673 if ( val == null ) {
7674 val = local[ prop.idx ];
7675 }
7676 local[ prop.idx ] = clamp( val, prop );
7677 });
7678
7679 if ( from ) {
7680 ret = color( from( local ) );
7681 ret[ cache ] = local;
7682 return ret;
7683 } else {
7684 return color( local );
7685 }
7686 };
7687
7688 // makes red() green() blue() alpha() hue() saturation() lightness()
7689 each( props, function( key, prop ) {
7690 // alpha is included in more than one space
7691 if ( color.fn[ key ] ) {
7692 return;
7693 }
7694 color.fn[ key ] = function( value ) {
7695 var vtype = jQuery.type( value ),
7696 fn = ( key === "alpha" ? ( this._hsla ? "hsla" : "rgba" ) : spaceName ),
7697 local = this[ fn ](),
7698 cur = local[ prop.idx ],
7699 match;
7700
7701 if ( vtype === "undefined" ) {
7702 return cur;
7703 }
7704
7705 if ( vtype === "function" ) {
7706 value = value.call( this, cur );
7707 vtype = jQuery.type( value );
7708 }
7709 if ( value == null && prop.empty ) {
7710 return this;
7711 }
7712 if ( vtype === "string" ) {
7713 match = rplusequals.exec( value );
7714 if ( match ) {
7715 value = cur + parseFloat( match[ 2 ] ) * ( match[ 1 ] === "+" ? 1 : -1 );
7716 }
7717 }
7718 local[ prop.idx ] = value;
7719 return this[ fn ]( local );
7720 };
7721 });
7722 });
7723
7724 // add cssHook and .fx.step function for each named hook.
7725 // accept a space separated string of properties
7726 color.hook = function( hook ) {
7727 var hooks = hook.split( " " );
7728 each( hooks, function( i, hook ) {
7729 jQuery.cssHooks[ hook ] = {
7730 set: function( elem, value ) {
7731 var parsed, curElem,
7732 backgroundColor = "";
7733
7734 if ( value !== "transparent" && ( jQuery.type( value ) !== "string" || ( parsed = stringParse( value ) ) ) ) {
7735 value = color( parsed || value );
7736 if ( !support.rgba && value._rgba[ 3 ] !== 1 ) {
7737 curElem = hook === "backgroundColor" ? elem.parentNode : elem;
7738 while (
7739 (backgroundColor === "" || backgroundColor === "transparent") &&
7740 curElem && curElem.style
7741 ) {
7742 try {
7743 backgroundColor = jQuery.css( curElem, "backgroundColor" );
7744 curElem = curElem.parentNode;
7745 } catch ( e ) {
7746 }
7747 }
7748
7749 value = value.blend( backgroundColor && backgroundColor !== "transparent" ?
7750 backgroundColor :
7751 "_default" );
7752 }
7753
7754 value = value.toRgbaString();
7755 }
7756 try {
7757 elem.style[ hook ] = value;
7758 } catch( e ) {
7759 // wrapped to prevent IE from throwing errors on "invalid" values like 'auto' or 'inherit'
7760 }
7761 }
7762 };
7763 jQuery.fx.step[ hook ] = function( fx ) {
7764 if ( !fx.colorInit ) {
7765 fx.start = color( fx.elem, hook );
7766 fx.end = color( fx.end );
7767 fx.colorInit = true;
7768 }
7769 jQuery.cssHooks[ hook ].set( fx.elem, fx.start.transition( fx.end, fx.pos ) );
7770 };
7771 });
7772
7773 };
7774
7775 color.hook( stepHooks );
7776
7777 jQuery.cssHooks.borderColor = {
7778 expand: function( value ) {
7779 var expanded = {};
7780
7781 each( [ "Top", "Right", "Bottom", "Left" ], function( i, part ) {
7782 expanded[ "border" + part + "Color" ] = value;
7783 });
7784 return expanded;
7785 }
7786 };
7787
7788 // Basic color names only.
7789 // Usage of any of the other color names requires adding yourself or including
7790 // jquery.color.svg-names.js.
7791 colors = jQuery.Color.names = {
7792 // 4.1. Basic color keywords
7793 aqua: "#00ffff",
7794 black: "#000000",
7795 blue: "#0000ff",
7796 fuchsia: "#ff00ff",
7797 gray: "#808080",
7798 green: "#008000",
7799 lime: "#00ff00",
7800 maroon: "#800000",
7801 navy: "#000080",
7802 olive: "#808000",
7803 purple: "#800080",
7804 red: "#ff0000",
7805 silver: "#c0c0c0",
7806 teal: "#008080",
7807 white: "#ffffff",
7808 yellow: "#ffff00",
7809
7810 // 4.2.3. "transparent" color keyword
7811 transparent: [ null, null, null, 0 ],
7812
7813 _default: "#ffffff"
7814 };
7815
7816 })( jQuery );
7817
7818
7819 /******************************************************************************/
7820 /****************************** CLASS ANIMATIONS ******************************/
7821 /******************************************************************************/
7822 (function() {
7823
7824 var classAnimationActions = [ "add", "remove", "toggle" ],
7825 shorthandStyles = {
7826 border: 1,
7827 borderBottom: 1,
7828 borderColor: 1,
7829 borderLeft: 1,
7830 borderRight: 1,
7831 borderTop: 1,
7832 borderWidth: 1,
7833 margin: 1,
7834 padding: 1
7835 };
7836
7837 $.each([ "borderLeftStyle", "borderRightStyle", "borderBottomStyle", "borderTopStyle" ], function( _, prop ) {
7838 $.fx.step[ prop ] = function( fx ) {
7839 if ( fx.end !== "none" && !fx.setAttr || fx.pos === 1 && !fx.setAttr ) {
7840 jQuery.style( fx.elem, prop, fx.end );
7841 fx.setAttr = true;
7842 }
7843 };
7844 });
7845
7846 function getElementStyles( elem ) {
7847 var key, len,
7848 style = elem.ownerDocument.defaultView ?
7849 elem.ownerDocument.defaultView.getComputedStyle( elem, null ) :
7850 elem.currentStyle,
7851 styles = {};
7852
7853 if ( style && style.length && style[ 0 ] && style[ style[ 0 ] ] ) {
7854 len = style.length;
7855 while ( len-- ) {
7856 key = style[ len ];
7857 if ( typeof style[ key ] === "string" ) {
7858 styles[ $.camelCase( key ) ] = style[ key ];
7859 }
7860 }
7861 // support: Opera, IE <9
7862 } else {
7863 for ( key in style ) {
7864 if ( typeof style[ key ] === "string" ) {
7865 styles[ key ] = style[ key ];
7866 }
7867 }
7868 }
7869
7870 return styles;
7871 }
7872
7873
7874 function styleDifference( oldStyle, newStyle ) {
7875 var diff = {},
7876 name, value;
7877
7878 for ( name in newStyle ) {
7879 value = newStyle[ name ];
7880 if ( oldStyle[ name ] !== value ) {
7881 if ( !shorthandStyles[ name ] ) {
7882 if ( $.fx.step[ name ] || !isNaN( parseFloat( value ) ) ) {
7883 diff[ name ] = value;
7884 }
7885 }
7886 }
7887 }
7888
7889 return diff;
7890 }
7891
7892 // support: jQuery <1.8
7893 if ( !$.fn.addBack ) {
7894 $.fn.addBack = function( selector ) {
7895 return this.add( selector == null ?
7896 this.prevObject : this.prevObject.filter( selector )
7897 );
7898 };
7899 }
7900
7901 $.effects.animateClass = function( value, duration, easing, callback ) {
7902 var o = $.speed( duration, easing, callback );
7903
7904 return this.queue( function() {
7905 var animated = $( this ),
7906 baseClass = animated.attr( "class" ) || "",
7907 applyClassChange,
7908 allAnimations = o.children ? animated.find( "*" ).addBack() : animated;
7909
7910 // map the animated objects to store the original styles.
7911 allAnimations = allAnimations.map(function() {
7912 var el = $( this );
7913 return {
7914 el: el,
7915 start: getElementStyles( this )
7916 };
7917 });
7918
7919 // apply class change
7920 applyClassChange = function() {
7921 $.each( classAnimationActions, function(i, action) {
7922 if ( value[ action ] ) {
7923 animated[ action + "Class" ]( value[ action ] );
7924 }
7925 });
7926 };
7927 applyClassChange();
7928
7929 // map all animated objects again - calculate new styles and diff
7930 allAnimations = allAnimations.map(function() {
7931 this.end = getElementStyles( this.el[ 0 ] );
7932 this.diff = styleDifference( this.start, this.end );
7933 return this;
7934 });
7935
7936 // apply original class
7937 animated.attr( "class", baseClass );
7938
7939 // map all animated objects again - this time collecting a promise
7940 allAnimations = allAnimations.map(function() {
7941 var styleInfo = this,
7942 dfd = $.Deferred(),
7943 opts = $.extend({}, o, {
7944 queue: false,
7945 complete: function() {
7946 dfd.resolve( styleInfo );
7947 }
7948 });
7949
7950 this.el.animate( this.diff, opts );
7951 return dfd.promise();
7952 });
7953
7954 // once all animations have completed:
7955 $.when.apply( $, allAnimations.get() ).done(function() {
7956
7957 // set the final class
7958 applyClassChange();
7959
7960 // for each animated element,
7961 // clear all css properties that were animated
7962 $.each( arguments, function() {
7963 var el = this.el;
7964 $.each( this.diff, function(key) {
7965 el.css( key, "" );
7966 });
7967 });
7968
7969 // this is guarnteed to be there if you use jQuery.speed()
7970 // it also handles dequeuing the next anim...
7971 o.complete.call( animated[ 0 ] );
7972 });
7973 });
7974 };
7975
7976 $.fn.extend({
7977 addClass: (function( orig ) {
7978 return function( classNames, speed, easing, callback ) {
7979 return speed ?
7980 $.effects.animateClass.call( this,
7981 { add: classNames }, speed, easing, callback ) :
7982 orig.apply( this, arguments );
7983 };
7984 })( $.fn.addClass ),
7985
7986 removeClass: (function( orig ) {
7987 return function( classNames, speed, easing, callback ) {
7988 return arguments.length > 1 ?
7989 $.effects.animateClass.call( this,
7990 { remove: classNames }, speed, easing, callback ) :
7991 orig.apply( this, arguments );
7992 };
7993 })( $.fn.removeClass ),
7994
7995 toggleClass: (function( orig ) {
7996 return function( classNames, force, speed, easing, callback ) {
7997 if ( typeof force === "boolean" || force === undefined ) {
7998 if ( !speed ) {
7999 // without speed parameter
8000 return orig.apply( this, arguments );
8001 } else {
8002 return $.effects.animateClass.call( this,
8003 (force ? { add: classNames } : { remove: classNames }),
8004 speed, easing, callback );
8005 }
8006 } else {
8007 // without force parameter
8008 return $.effects.animateClass.call( this,
8009 { toggle: classNames }, force, speed, easing );
8010 }
8011 };
8012 })( $.fn.toggleClass ),
8013
8014 switchClass: function( remove, add, speed, easing, callback) {
8015 return $.effects.animateClass.call( this, {
8016 add: add,
8017 remove: remove
8018 }, speed, easing, callback );
8019 }
8020 });
8021
8022 })();
8023
8024 /******************************************************************************/
8025 /*********************************** EFFECTS **********************************/
8026 /******************************************************************************/
8027
8028 (function() {
8029
8030 $.extend( $.effects, {
8031 version: "1.10.4",
8032
8033 // Saves a set of properties in a data storage
8034 save: function( element, set ) {
8035 for( var i=0; i < set.length; i++ ) {
8036 if ( set[ i ] !== null ) {
8037 element.data( dataSpace + set[ i ], element[ 0 ].style[ set[ i ] ] );
8038 }
8039 }
8040 },
8041
8042 // Restores a set of previously saved properties from a data storage
8043 restore: function( element, set ) {
8044 var val, i;
8045 for( i=0; i < set.length; i++ ) {
8046 if ( set[ i ] !== null ) {
8047 val = element.data( dataSpace + set[ i ] );
8048 // support: jQuery 1.6.2
8049 // http://bugs.jquery.com/ticket/9917
8050 // jQuery 1.6.2 incorrectly returns undefined for any falsy value.
8051 // We can't differentiate between "" and 0 here, so we just assume
8052 // empty string since it's likely to be a more common value...
8053 if ( val === undefined ) {
8054 val = "";
8055 }
8056 element.css( set[ i ], val );
8057 }
8058 }
8059 },
8060
8061 setMode: function( el, mode ) {
8062 if (mode === "toggle") {
8063 mode = el.is( ":hidden" ) ? "show" : "hide";
8064 }
8065 return mode;
8066 },
8067
8068 // Translates a [top,left] array into a baseline value
8069 // this should be a little more flexible in the future to handle a string & hash
8070 getBaseline: function( origin, original ) {
8071 var y, x;
8072 switch ( origin[ 0 ] ) {
8073 case "top": y = 0; break;
8074 case "middle": y = 0.5; break;
8075 case "bottom": y = 1; break;
8076 default: y = origin[ 0 ] / original.height;
8077 }
8078 switch ( origin[ 1 ] ) {
8079 case "left": x = 0; break;
8080 case "center": x = 0.5; break;
8081 case "right": x = 1; break;
8082 default: x = origin[ 1 ] / original.width;
8083 }
8084 return {
8085 x: x,
8086 y: y
8087 };
8088 },
8089
8090 // Wraps the element around a wrapper that copies position properties
8091 createWrapper: function( element ) {
8092
8093 // if the element is already wrapped, return it
8094 if ( element.parent().is( ".ui-effects-wrapper" )) {
8095 return element.parent();
8096 }
8097
8098 // wrap the element
8099 var props = {
8100 width: element.outerWidth(true),
8101 height: element.outerHeight(true),
8102 "float": element.css( "float" )
8103 },
8104 wrapper = $( "<div></div>" )
8105 .addClass( "ui-effects-wrapper" )
8106 .css({
8107 fontSize: "100%",
8108 background: "transparent",
8109 border: "none",
8110 margin: 0,
8111 padding: 0
8112 }),
8113 // Store the size in case width/height are defined in % - Fixes #5245
8114 size = {
8115 width: element.width(),
8116 height: element.height()
8117 },
8118 active = document.activeElement;
8119
8120 // support: Firefox
8121 // Firefox incorrectly exposes anonymous content
8122 // https://bugzilla.mozilla.org/show_bug.cgi?id=561664
8123 try {
8124 active.id;
8125 } catch( e ) {
8126 active = document.body;
8127 }
8128
8129 element.wrap( wrapper );
8130
8131 // Fixes #7595 - Elements lose focus when wrapped.
8132 if ( element[ 0 ] === active || $.contains( element[ 0 ], active ) ) {
8133 $( active ).focus();
8134 }
8135
8136 wrapper = element.parent(); //Hotfix for jQuery 1.4 since some change in wrap() seems to actually lose the reference to the wrapped element
8137
8138 // transfer positioning properties to the wrapper
8139 if ( element.css( "position" ) === "static" ) {
8140 wrapper.css({ position: "relative" });
8141 element.css({ position: "relative" });
8142 } else {
8143 $.extend( props, {
8144 position: element.css( "position" ),
8145 zIndex: element.css( "z-index" )
8146 });
8147 $.each([ "top", "left", "bottom", "right" ], function(i, pos) {
8148 props[ pos ] = element.css( pos );
8149 if ( isNaN( parseInt( props[ pos ], 10 ) ) ) {
8150 props[ pos ] = "auto";
8151 }
8152 });
8153 element.css({
8154 position: "relative",
8155 top: 0,
8156 left: 0,
8157 right: "auto",
8158 bottom: "auto"
8159 });
8160 }
8161 element.css(size);
8162
8163 return wrapper.css( props ).show();
8164 },
8165
8166 removeWrapper: function( element ) {
8167 var active = document.activeElement;
8168
8169 if ( element.parent().is( ".ui-effects-wrapper" ) ) {
8170 element.parent().replaceWith( element );
8171
8172 // Fixes #7595 - Elements lose focus when wrapped.
8173 if ( element[ 0 ] === active || $.contains( element[ 0 ], active ) ) {
8174 $( active ).focus();
8175 }
8176 }
8177
8178
8179 return element;
8180 },
8181
8182 setTransition: function( element, list, factor, value ) {
8183 value = value || {};
8184 $.each( list, function( i, x ) {
8185 var unit = element.cssUnit( x );
8186 if ( unit[ 0 ] > 0 ) {
8187 value[ x ] = unit[ 0 ] * factor + unit[ 1 ];
8188 }
8189 });
8190 return value;
8191 }
8192 });
8193
8194 // return an effect options object for the given parameters:
8195 function _normalizeArguments( effect, options, speed, callback ) {
8196
8197 // allow passing all options as the first parameter
8198 if ( $.isPlainObject( effect ) ) {
8199 options = effect;
8200 effect = effect.effect;
8201 }
8202
8203 // convert to an object
8204 effect = { effect: effect };
8205
8206 // catch (effect, null, ...)
8207 if ( options == null ) {
8208 options = {};
8209 }
8210
8211 // catch (effect, callback)
8212 if ( $.isFunction( options ) ) {
8213 callback = options;
8214 speed = null;
8215 options = {};
8216 }
8217
8218 // catch (effect, speed, ?)
8219 if ( typeof options === "number" || $.fx.speeds[ options ] ) {
8220 callback = speed;
8221 speed = options;
8222 options = {};
8223 }
8224
8225 // catch (effect, options, callback)
8226 if ( $.isFunction( speed ) ) {
8227 callback = speed;
8228 speed = null;
8229 }
8230
8231 // add options to effect
8232 if ( options ) {
8233 $.extend( effect, options );
8234 }
8235
8236 speed = speed || options.duration;
8237 effect.duration = $.fx.off ? 0 :
8238 typeof speed === "number" ? speed :
8239 speed in $.fx.speeds ? $.fx.speeds[ speed ] :
8240 $.fx.speeds._default;
8241
8242 effect.complete = callback || options.complete;
8243
8244 return effect;
8245 }
8246
8247 function standardAnimationOption( option ) {
8248 // Valid standard speeds (nothing, number, named speed)
8249 if ( !option || typeof option === "number" || $.fx.speeds[ option ] ) {
8250 return true;
8251 }
8252
8253 // Invalid strings - treat as "normal" speed
8254 if ( typeof option === "string" && !$.effects.effect[ option ] ) {
8255 return true;
8256 }
8257
8258 // Complete callback
8259 if ( $.isFunction( option ) ) {
8260 return true;
8261 }
8262
8263 // Options hash (but not naming an effect)
8264 if ( typeof option === "object" && !option.effect ) {
8265 return true;
8266 }
8267
8268 // Didn't match any standard API
8269 return false;
8270 }
8271
8272 $.fn.extend({
8273 effect: function( /* effect, options, speed, callback */ ) {
8274 var args = _normalizeArguments.apply( this, arguments ),
8275 mode = args.mode,
8276 queue = args.queue,
8277 effectMethod = $.effects.effect[ args.effect ];
8278
8279 if ( $.fx.off || !effectMethod ) {
8280 // delegate to the original method (e.g., .show()) if possible
8281 if ( mode ) {
8282 return this[ mode ]( args.duration, args.complete );
8283 } else {
8284 return this.each( function() {
8285 if ( args.complete ) {
8286 args.complete.call( this );
8287 }
8288 });
8289 }
8290 }
8291
8292 function run( next ) {
8293 var elem = $( this ),
8294 complete = args.complete,
8295 mode = args.mode;
8296
8297 function done() {
8298 if ( $.isFunction( complete ) ) {
8299 complete.call( elem[0] );
8300 }
8301 if ( $.isFunction( next ) ) {
8302 next();
8303 }
8304 }
8305
8306 // If the element already has the correct final state, delegate to
8307 // the core methods so the internal tracking of "olddisplay" works.
8308 if ( elem.is( ":hidden" ) ? mode === "hide" : mode === "show" ) {
8309 elem[ mode ]();
8310 done();
8311 } else {
8312 effectMethod.call( elem[0], args, done );
8313 }
8314 }
8315
8316 return queue === false ? this.each( run ) : this.queue( queue || "fx", run );
8317 },
8318
8319 show: (function( orig ) {
8320 return function( option ) {
8321 if ( standardAnimationOption( option ) ) {
8322 return orig.apply( this, arguments );
8323 } else {
8324 var args = _normalizeArguments.apply( this, arguments );
8325 args.mode = "show";
8326 return this.effect.call( this, args );
8327 }
8328 };
8329 })( $.fn.show ),
8330
8331 hide: (function( orig ) {
8332 return function( option ) {
8333 if ( standardAnimationOption( option ) ) {
8334 return orig.apply( this, arguments );
8335 } else {
8336 var args = _normalizeArguments.apply( this, arguments );
8337 args.mode = "hide";
8338 return this.effect.call( this, args );
8339 }
8340 };
8341 })( $.fn.hide ),
8342
8343 toggle: (function( orig ) {
8344 return function( option ) {
8345 if ( standardAnimationOption( option ) || typeof option === "boolean" ) {
8346 return orig.apply( this, arguments );
8347 } else {
8348 var args = _normalizeArguments.apply( this, arguments );
8349 args.mode = "toggle";
8350 return this.effect.call( this, args );
8351 }
8352 };
8353 })( $.fn.toggle ),
8354
8355 // helper functions
8356 cssUnit: function(key) {
8357 var style = this.css( key ),
8358 val = [];
8359
8360 $.each( [ "em", "px", "%", "pt" ], function( i, unit ) {
8361 if ( style.indexOf( unit ) > 0 ) {
8362 val = [ parseFloat( style ), unit ];
8363 }
8364 });
8365 return val;
8366 }
8367 });
8368
8369 })();
8370
8371 /******************************************************************************/
8372 /*********************************** EASING ***********************************/
8373 /******************************************************************************/
8374
8375 (function() {
8376
8377 // based on easing equations from Robert Penner (http://www.robertpenner.com/easing)
8378
8379 var baseEasings = {};
8380
8381 $.each( [ "Quad", "Cubic", "Quart", "Quint", "Expo" ], function( i, name ) {
8382 baseEasings[ name ] = function( p ) {
8383 return Math.pow( p, i + 2 );
8384 };
8385 });
8386
8387 $.extend( baseEasings, {
8388 Sine: function ( p ) {
8389 return 1 - Math.cos( p * Math.PI / 2 );
8390 },
8391 Circ: function ( p ) {
8392 return 1 - Math.sqrt( 1 - p * p );
8393 },
8394 Elastic: function( p ) {
8395 return p === 0 || p === 1 ? p :
8396 -Math.pow( 2, 8 * (p - 1) ) * Math.sin( ( (p - 1) * 80 - 7.5 ) * Math.PI / 15 );
8397 },
8398 Back: function( p ) {
8399 return p * p * ( 3 * p - 2 );
8400 },
8401 Bounce: function ( p ) {
8402 var pow2,
8403 bounce = 4;
8404
8405 while ( p < ( ( pow2 = Math.pow( 2, --bounce ) ) - 1 ) / 11 ) {}
8406 return 1 / Math.pow( 4, 3 - bounce ) - 7.5625 * Math.pow( ( pow2 * 3 - 2 ) / 22 - p, 2 );
8407 }
8408 });
8409
8410 $.each( baseEasings, function( name, easeIn ) {
8411 $.easing[ "easeIn" + name ] = easeIn;
8412 $.easing[ "easeOut" + name ] = function( p ) {
8413 return 1 - easeIn( 1 - p );
8414 };
8415 $.easing[ "easeInOut" + name ] = function( p ) {
8416 return p < 0.5 ?
8417 easeIn( p * 2 ) / 2 :
8418 1 - easeIn( p * -2 + 2 ) / 2;
8419 };
8420 });
8421
8422 })();
8423
8424 })(jQuery);
8425 (function( $, undefined ) {
8426
8427 var rvertical = /up|down|vertical/,
8428 rpositivemotion = /up|left|vertical|horizontal/;
8429
8430 $.effects.effect.blind = function( o, done ) {
8431 // Create element
8432 var el = $( this ),
8433 props = [ "position", "top", "bottom", "left", "right", "height", "width" ],
8434 mode = $.effects.setMode( el, o.mode || "hide" ),
8435 direction = o.direction || "up",
8436 vertical = rvertical.test( direction ),
8437 ref = vertical ? "height" : "width",
8438 ref2 = vertical ? "top" : "left",
8439 motion = rpositivemotion.test( direction ),
8440 animation = {},
8441 show = mode === "show",
8442 wrapper, distance, margin;
8443
8444 // if already wrapped, the wrapper's properties are my property. #6245
8445 if ( el.parent().is( ".ui-effects-wrapper" ) ) {
8446 $.effects.save( el.parent(), props );
8447 } else {
8448 $.effects.save( el, props );
8449 }
8450 el.show();
8451 wrapper = $.effects.createWrapper( el ).css({
8452 overflow: "hidden"
8453 });
8454
8455 distance = wrapper[ ref ]();
8456 margin = parseFloat( wrapper.css( ref2 ) ) || 0;
8457
8458 animation[ ref ] = show ? distance : 0;
8459 if ( !motion ) {
8460 el
8461 .css( vertical ? "bottom" : "right", 0 )
8462 .css( vertical ? "top" : "left", "auto" )
8463 .css({ position: "absolute" });
8464
8465 animation[ ref2 ] = show ? margin : distance + margin;
8466 }
8467
8468 // start at 0 if we are showing
8469 if ( show ) {
8470 wrapper.css( ref, 0 );
8471 if ( ! motion ) {
8472 wrapper.css( ref2, margin + distance );
8473 }
8474 }
8475
8476 // Animate
8477 wrapper.animate( animation, {
8478 duration: o.duration,
8479 easing: o.easing,
8480 queue: false,
8481 complete: function() {
8482 if ( mode === "hide" ) {
8483 el.hide();
8484 }
8485 $.effects.restore( el, props );
8486 $.effects.removeWrapper( el );
8487 done();
8488 }
8489 });
8490
8491 };
8492
8493 })(jQuery);
8494 (function( $, undefined ) {
8495
8496 $.effects.effect.bounce = function( o, done ) {
8497 var el = $( this ),
8498 props = [ "position", "top", "bottom", "left", "right", "height", "width" ],
8499
8500 // defaults:
8501 mode = $.effects.setMode( el, o.mode || "effect" ),
8502 hide = mode === "hide",
8503 show = mode === "show",
8504 direction = o.direction || "up",
8505 distance = o.distance,
8506 times = o.times || 5,
8507
8508 // number of internal animations
8509 anims = times * 2 + ( show || hide ? 1 : 0 ),
8510 speed = o.duration / anims,
8511 easing = o.easing,
8512
8513 // utility:
8514 ref = ( direction === "up" || direction === "down" ) ? "top" : "left",
8515 motion = ( direction === "up" || direction === "left" ),
8516 i,
8517 upAnim,
8518 downAnim,
8519
8520 // we will need to re-assemble the queue to stack our animations in place
8521 queue = el.queue(),
8522 queuelen = queue.length;
8523
8524 // Avoid touching opacity to prevent clearType and PNG issues in IE
8525 if ( show || hide ) {
8526 props.push( "opacity" );
8527 }
8528
8529 $.effects.save( el, props );
8530 el.show();
8531 $.effects.createWrapper( el ); // Create Wrapper
8532
8533 // default distance for the BIGGEST bounce is the outer Distance / 3
8534 if ( !distance ) {
8535 distance = el[ ref === "top" ? "outerHeight" : "outerWidth" ]() / 3;
8536 }
8537
8538 if ( show ) {
8539 downAnim = { opacity: 1 };
8540 downAnim[ ref ] = 0;
8541
8542 // if we are showing, force opacity 0 and set the initial position
8543 // then do the "first" animation
8544 el.css( "opacity", 0 )
8545 .css( ref, motion ? -distance * 2 : distance * 2 )
8546 .animate( downAnim, speed, easing );
8547 }
8548
8549 // start at the smallest distance if we are hiding
8550 if ( hide ) {
8551 distance = distance / Math.pow( 2, times - 1 );
8552 }
8553
8554 downAnim = {};
8555 downAnim[ ref ] = 0;
8556 // Bounces up/down/left/right then back to 0 -- times * 2 animations happen here
8557 for ( i = 0; i < times; i++ ) {
8558 upAnim = {};
8559 upAnim[ ref ] = ( motion ? "-=" : "+=" ) + distance;
8560
8561 el.animate( upAnim, speed, easing )
8562 .animate( downAnim, speed, easing );
8563
8564 distance = hide ? distance * 2 : distance / 2;
8565 }
8566
8567 // Last Bounce when Hiding
8568 if ( hide ) {
8569 upAnim = { opacity: 0 };
8570 upAnim[ ref ] = ( motion ? "-=" : "+=" ) + distance;
8571
8572 el.animate( upAnim, speed, easing );
8573 }
8574
8575 el.queue(function() {
8576 if ( hide ) {
8577 el.hide();
8578 }
8579 $.effects.restore( el, props );
8580 $.effects.removeWrapper( el );
8581 done();
8582 });
8583
8584 // inject all the animations we just queued to be first in line (after "inprogress")
8585 if ( queuelen > 1) {
8586 queue.splice.apply( queue,
8587 [ 1, 0 ].concat( queue.splice( queuelen, anims + 1 ) ) );
8588 }
8589 el.dequeue();
8590
8591 };
8592
8593 })(jQuery);
8594 (function( $, undefined ) {
8595
8596 $.effects.effect.clip = function( o, done ) {
8597 // Create element
8598 var el = $( this ),
8599 props = [ "position", "top", "bottom", "left", "right", "height", "width" ],
8600 mode = $.effects.setMode( el, o.mode || "hide" ),
8601 show = mode === "show",
8602 direction = o.direction || "vertical",
8603 vert = direction === "vertical",
8604 size = vert ? "height" : "width",
8605 position = vert ? "top" : "left",
8606 animation = {},
8607 wrapper, animate, distance;
8608
8609 // Save & Show
8610 $.effects.save( el, props );
8611 el.show();
8612
8613 // Create Wrapper
8614 wrapper = $.effects.createWrapper( el ).css({
8615 overflow: "hidden"
8616 });
8617 animate = ( el[0].tagName === "IMG" ) ? wrapper : el;
8618 distance = animate[ size ]();
8619
8620 // Shift
8621 if ( show ) {
8622 animate.css( size, 0 );
8623 animate.css( position, distance / 2 );
8624 }
8625
8626 // Create Animation Object:
8627 animation[ size ] = show ? distance : 0;
8628 animation[ position ] = show ? 0 : distance / 2;
8629
8630 // Animate
8631 animate.animate( animation, {
8632 queue: false,
8633 duration: o.duration,
8634 easing: o.easing,
8635 complete: function() {
8636 if ( !show ) {
8637 el.hide();
8638 }
8639 $.effects.restore( el, props );
8640 $.effects.removeWrapper( el );
8641 done();
8642 }
8643 });
8644
8645 };
8646
8647 })(jQuery);
8648 (function( $, undefined ) {
8649
8650 $.effects.effect.drop = function( o, done ) {
8651
8652 var el = $( this ),
8653 props = [ "position", "top", "bottom", "left", "right", "opacity", "height", "width" ],
8654 mode = $.effects.setMode( el, o.mode || "hide" ),
8655 show = mode === "show",
8656 direction = o.direction || "left",
8657 ref = ( direction === "up" || direction === "down" ) ? "top" : "left",
8658 motion = ( direction === "up" || direction === "left" ) ? "pos" : "neg",
8659 animation = {
8660 opacity: show ? 1 : 0
8661 },
8662 distance;
8663
8664 // Adjust
8665 $.effects.save( el, props );
8666 el.show();
8667 $.effects.createWrapper( el );
8668
8669 distance = o.distance || el[ ref === "top" ? "outerHeight": "outerWidth" ]( true ) / 2;
8670
8671 if ( show ) {
8672 el
8673 .css( "opacity", 0 )
8674 .css( ref, motion === "pos" ? -distance : distance );
8675 }
8676
8677 // Animation
8678 animation[ ref ] = ( show ?
8679 ( motion === "pos" ? "+=" : "-=" ) :
8680 ( motion === "pos" ? "-=" : "+=" ) ) +
8681 distance;
8682
8683 // Animate
8684 el.animate( animation, {
8685 queue: false,
8686 duration: o.duration,
8687 easing: o.easing,
8688 complete: function() {
8689 if ( mode === "hide" ) {
8690 el.hide();
8691 }
8692 $.effects.restore( el, props );
8693 $.effects.removeWrapper( el );
8694 done();
8695 }
8696 });
8697 };
8698
8699 })(jQuery);
8700 (function( $, undefined ) {
8701
8702 $.effects.effect.explode = function( o, done ) {
8703
8704 var rows = o.pieces ? Math.round( Math.sqrt( o.pieces ) ) : 3,
8705 cells = rows,
8706 el = $( this ),
8707 mode = $.effects.setMode( el, o.mode || "hide" ),
8708 show = mode === "show",
8709
8710 // show and then visibility:hidden the element before calculating offset
8711 offset = el.show().css( "visibility", "hidden" ).offset(),
8712
8713 // width and height of a piece
8714 width = Math.ceil( el.outerWidth() / cells ),
8715 height = Math.ceil( el.outerHeight() / rows ),
8716 pieces = [],
8717
8718 // loop
8719 i, j, left, top, mx, my;
8720
8721 // children animate complete:
8722 function childComplete() {
8723 pieces.push( this );
8724 if ( pieces.length === rows * cells ) {
8725 animComplete();
8726 }
8727 }
8728
8729 // clone the element for each row and cell.
8730 for( i = 0; i < rows ; i++ ) { // ===>
8731 top = offset.top + i * height;
8732 my = i - ( rows - 1 ) / 2 ;
8733
8734 for( j = 0; j < cells ; j++ ) { // |||
8735 left = offset.left + j * width;
8736 mx = j - ( cells - 1 ) / 2 ;
8737
8738 // Create a clone of the now hidden main element that will be absolute positioned
8739 // within a wrapper div off the -left and -top equal to size of our pieces
8740 el
8741 .clone()
8742 .appendTo( "body" )
8743 .wrap( "<div></div>" )
8744 .css({
8745 position: "absolute",
8746 visibility: "visible",
8747 left: -j * width,
8748 top: -i * height
8749 })
8750
8751 // select the wrapper - make it overflow: hidden and absolute positioned based on
8752 // where the original was located +left and +top equal to the size of pieces
8753 .parent()
8754 .addClass( "ui-effects-explode" )
8755 .css({
8756 position: "absolute",
8757 overflow: "hidden",
8758 width: width,
8759 height: height,
8760 left: left + ( show ? mx * width : 0 ),
8761 top: top + ( show ? my * height : 0 ),
8762 opacity: show ? 0 : 1
8763 }).animate({
8764 left: left + ( show ? 0 : mx * width ),
8765 top: top + ( show ? 0 : my * height ),
8766 opacity: show ? 1 : 0
8767 }, o.duration || 500, o.easing, childComplete );
8768 }
8769 }
8770
8771 function animComplete() {
8772 el.css({
8773 visibility: "visible"
8774 });
8775 $( pieces ).remove();
8776 if ( !show ) {
8777 el.hide();
8778 }
8779 done();
8780 }
8781 };
8782
8783 })(jQuery);
8784 (function( $, undefined ) {
8785
8786 $.effects.effect.fade = function( o, done ) {
8787 var el = $( this ),
8788 mode = $.effects.setMode( el, o.mode || "toggle" );
8789
8790 el.animate({
8791 opacity: mode
8792 }, {
8793 queue: false,
8794 duration: o.duration,
8795 easing: o.easing,
8796 complete: done
8797 });
8798 };
8799
8800 })( jQuery );
8801 (function( $, undefined ) {
8802
8803 $.effects.effect.fold = function( o, done ) {
8804
8805 // Create element
8806 var el = $( this ),
8807 props = [ "position", "top", "bottom", "left", "right", "height", "width" ],
8808 mode = $.effects.setMode( el, o.mode || "hide" ),
8809 show = mode === "show",
8810 hide = mode === "hide",
8811 size = o.size || 15,
8812 percent = /([0-9]+)%/.exec( size ),
8813 horizFirst = !!o.horizFirst,
8814 widthFirst = show !== horizFirst,
8815 ref = widthFirst ? [ "width", "height" ] : [ "height", "width" ],
8816 duration = o.duration / 2,
8817 wrapper, distance,
8818 animation1 = {},
8819 animation2 = {};
8820
8821 $.effects.save( el, props );
8822 el.show();
8823
8824 // Create Wrapper
8825 wrapper = $.effects.createWrapper( el ).css({
8826 overflow: "hidden"
8827 });
8828 distance = widthFirst ?
8829 [ wrapper.width(), wrapper.height() ] :
8830 [ wrapper.height(), wrapper.width() ];
8831
8832 if ( percent ) {
8833 size = parseInt( percent[ 1 ], 10 ) / 100 * distance[ hide ? 0 : 1 ];
8834 }
8835 if ( show ) {
8836 wrapper.css( horizFirst ? {
8837 height: 0,
8838 width: size
8839 } : {
8840 height: size,
8841 width: 0
8842 });
8843 }
8844
8845 // Animation
8846 animation1[ ref[ 0 ] ] = show ? distance[ 0 ] : size;
8847 animation2[ ref[ 1 ] ] = show ? distance[ 1 ] : 0;
8848
8849 // Animate
8850 wrapper
8851 .animate( animation1, duration, o.easing )
8852 .animate( animation2, duration, o.easing, function() {
8853 if ( hide ) {
8854 el.hide();
8855 }
8856 $.effects.restore( el, props );
8857 $.effects.removeWrapper( el );
8858 done();
8859 });
8860
8861 };
8862
8863 })(jQuery);
8864 (function( $, undefined ) {
8865
8866 $.effects.effect.highlight = function( o, done ) {
8867 var elem = $( this ),
8868 props = [ "backgroundImage", "backgroundColor", "opacity" ],
8869 mode = $.effects.setMode( elem, o.mode || "show" ),
8870 animation = {
8871 backgroundColor: elem.css( "backgroundColor" )
8872 };
8873
8874 if (mode === "hide") {
8875 animation.opacity = 0;
8876 }
8877
8878 $.effects.save( elem, props );
8879
8880 elem
8881 .show()
8882 .css({
8883 backgroundImage: "none",
8884 backgroundColor: o.color || "#ffff99"
8885 })
8886 .animate( animation, {
8887 queue: false,
8888 duration: o.duration,
8889 easing: o.easing,
8890 complete: function() {
8891 if ( mode === "hide" ) {
8892 elem.hide();
8893 }
8894 $.effects.restore( elem, props );
8895 done();
8896 }
8897 });
8898 };
8899
8900 })(jQuery);
8901 (function( $, undefined ) {
8902
8903 $.effects.effect.pulsate = function( o, done ) {
8904 var elem = $( this ),
8905 mode = $.effects.setMode( elem, o.mode || "show" ),
8906 show = mode === "show",
8907 hide = mode === "hide",
8908 showhide = ( show || mode === "hide" ),
8909
8910 // showing or hiding leaves of the "last" animation
8911 anims = ( ( o.times || 5 ) * 2 ) + ( showhide ? 1 : 0 ),
8912 duration = o.duration / anims,
8913 animateTo = 0,
8914 queue = elem.queue(),
8915 queuelen = queue.length,
8916 i;
8917
8918 if ( show || !elem.is(":visible")) {
8919 elem.css( "opacity", 0 ).show();
8920 animateTo = 1;
8921 }
8922
8923 // anims - 1 opacity "toggles"
8924 for ( i = 1; i < anims; i++ ) {
8925 elem.animate({
8926 opacity: animateTo
8927 }, duration, o.easing );
8928 animateTo = 1 - animateTo;
8929 }
8930
8931 elem.animate({
8932 opacity: animateTo
8933 }, duration, o.easing);
8934
8935 elem.queue(function() {
8936 if ( hide ) {
8937 elem.hide();
8938 }
8939 done();
8940 });
8941
8942 // We just queued up "anims" animations, we need to put them next in the queue
8943 if ( queuelen > 1 ) {
8944 queue.splice.apply( queue,
8945 [ 1, 0 ].concat( queue.splice( queuelen, anims + 1 ) ) );
8946 }
8947 elem.dequeue();
8948 };
8949
8950 })(jQuery);
8951 (function( $, undefined ) {
8952
8953 $.effects.effect.puff = function( o, done ) {
8954 var elem = $( this ),
8955 mode = $.effects.setMode( elem, o.mode || "hide" ),
8956 hide = mode === "hide",
8957 percent = parseInt( o.percent, 10 ) || 150,
8958 factor = percent / 100,
8959 original = {
8960 height: elem.height(),
8961 width: elem.width(),
8962 outerHeight: elem.outerHeight(),
8963 outerWidth: elem.outerWidth()
8964 };
8965
8966 $.extend( o, {
8967 effect: "scale",
8968 queue: false,
8969 fade: true,
8970 mode: mode,
8971 complete: done,
8972 percent: hide ? percent : 100,
8973 from: hide ?
8974 original :
8975 {
8976 height: original.height * factor,
8977 width: original.width * factor,
8978 outerHeight: original.outerHeight * factor,
8979 outerWidth: original.outerWidth * factor
8980 }
8981 });
8982
8983 elem.effect( o );
8984 };
8985
8986 $.effects.effect.scale = function( o, done ) {
8987
8988 // Create element
8989 var el = $( this ),
8990 options = $.extend( true, {}, o ),
8991 mode = $.effects.setMode( el, o.mode || "effect" ),
8992 percent = parseInt( o.percent, 10 ) ||
8993 ( parseInt( o.percent, 10 ) === 0 ? 0 : ( mode === "hide" ? 0 : 100 ) ),
8994 direction = o.direction || "both",
8995 origin = o.origin,
8996 original = {
8997 height: el.height(),
8998 width: el.width(),
8999 outerHeight: el.outerHeight(),
9000 outerWidth: el.outerWidth()
9001 },
9002 factor = {
9003 y: direction !== "horizontal" ? (percent / 100) : 1,
9004 x: direction !== "vertical" ? (percent / 100) : 1
9005 };
9006
9007 // We are going to pass this effect to the size effect:
9008 options.effect = "size";
9009 options.queue = false;
9010 options.complete = done;
9011
9012 // Set default origin and restore for show/hide
9013 if ( mode !== "effect" ) {
9014 options.origin = origin || ["middle","center"];
9015 options.restore = true;
9016 }
9017
9018 options.from = o.from || ( mode === "show" ? {
9019 height: 0,
9020 width: 0,
9021 outerHeight: 0,
9022 outerWidth: 0
9023 } : original );
9024 options.to = {
9025 height: original.height * factor.y,
9026 width: original.width * factor.x,
9027 outerHeight: original.outerHeight * factor.y,
9028 outerWidth: original.outerWidth * factor.x
9029 };
9030
9031 // Fade option to support puff
9032 if ( options.fade ) {
9033 if ( mode === "show" ) {
9034 options.from.opacity = 0;
9035 options.to.opacity = 1;
9036 }
9037 if ( mode === "hide" ) {
9038 options.from.opacity = 1;
9039 options.to.opacity = 0;
9040 }
9041 }
9042
9043 // Animate
9044 el.effect( options );
9045
9046 };
9047
9048 $.effects.effect.size = function( o, done ) {
9049
9050 // Create element
9051 var original, baseline, factor,
9052 el = $( this ),
9053 props0 = [ "position", "top", "bottom", "left", "right", "width", "height", "overflow", "opacity" ],
9054
9055 // Always restore
9056 props1 = [ "position", "top", "bottom", "left", "right", "overflow", "opacity" ],
9057
9058 // Copy for children
9059 props2 = [ "width", "height", "overflow" ],
9060 cProps = [ "fontSize" ],
9061 vProps = [ "borderTopWidth", "borderBottomWidth", "paddingTop", "paddingBottom" ],
9062 hProps = [ "borderLeftWidth", "borderRightWidth", "paddingLeft", "paddingRight" ],
9063
9064 // Set options
9065 mode = $.effects.setMode( el, o.mode || "effect" ),
9066 restore = o.restore || mode !== "effect",
9067 scale = o.scale || "both",
9068 origin = o.origin || [ "middle", "center" ],
9069 position = el.css( "position" ),
9070 props = restore ? props0 : props1,
9071 zero = {
9072 height: 0,
9073 width: 0,
9074 outerHeight: 0,
9075 outerWidth: 0
9076 };
9077
9078 if ( mode === "show" ) {
9079 el.show();
9080 }
9081 original = {
9082 height: el.height(),
9083 width: el.width(),
9084 outerHeight: el.outerHeight(),
9085 outerWidth: el.outerWidth()
9086 };
9087
9088 if ( o.mode === "toggle" && mode === "show" ) {
9089 el.from = o.to || zero;
9090 el.to = o.from || original;
9091 } else {
9092 el.from = o.from || ( mode === "show" ? zero : original );
9093 el.to = o.to || ( mode === "hide" ? zero : original );
9094 }
9095
9096 // Set scaling factor
9097 factor = {
9098 from: {
9099 y: el.from.height / original.height,
9100 x: el.from.width / original.width
9101 },
9102 to: {
9103 y: el.to.height / original.height,
9104 x: el.to.width / original.width
9105 }
9106 };
9107
9108 // Scale the css box
9109 if ( scale === "box" || scale === "both" ) {
9110
9111 // Vertical props scaling
9112 if ( factor.from.y !== factor.to.y ) {
9113 props = props.concat( vProps );
9114 el.from = $.effects.setTransition( el, vProps, factor.from.y, el.from );
9115 el.to = $.effects.setTransition( el, vProps, factor.to.y, el.to );
9116 }
9117
9118 // Horizontal props scaling
9119 if ( factor.from.x !== factor.to.x ) {
9120 props = props.concat( hProps );
9121 el.from = $.effects.setTransition( el, hProps, factor.from.x, el.from );
9122 el.to = $.effects.setTransition( el, hProps, factor.to.x, el.to );
9123 }
9124 }
9125
9126 // Scale the content
9127 if ( scale === "content" || scale === "both" ) {
9128
9129 // Vertical props scaling
9130 if ( factor.from.y !== factor.to.y ) {
9131 props = props.concat( cProps ).concat( props2 );
9132 el.from = $.effects.setTransition( el, cProps, factor.from.y, el.from );
9133 el.to = $.effects.setTransition( el, cProps, factor.to.y, el.to );
9134 }
9135 }
9136
9137 $.effects.save( el, props );
9138 el.show();
9139 $.effects.createWrapper( el );
9140 el.css( "overflow", "hidden" ).css( el.from );
9141
9142 // Adjust
9143 if (origin) { // Calculate baseline shifts
9144 baseline = $.effects.getBaseline( origin, original );
9145 el.from.top = ( original.outerHeight - el.outerHeight() ) * baseline.y;
9146 el.from.left = ( original.outerWidth - el.outerWidth() ) * baseline.x;
9147 el.to.top = ( original.outerHeight - el.to.outerHeight ) * baseline.y;
9148 el.to.left = ( original.outerWidth - el.to.outerWidth ) * baseline.x;
9149 }
9150 el.css( el.from ); // set top & left
9151
9152 // Animate
9153 if ( scale === "content" || scale === "both" ) { // Scale the children
9154
9155 // Add margins/font-size
9156 vProps = vProps.concat([ "marginTop", "marginBottom" ]).concat(cProps);
9157 hProps = hProps.concat([ "marginLeft", "marginRight" ]);
9158 props2 = props0.concat(vProps).concat(hProps);
9159
9160 el.find( "*[width]" ).each( function(){
9161 var child = $( this ),
9162 c_original = {
9163 height: child.height(),
9164 width: child.width(),
9165 outerHeight: child.outerHeight(),
9166 outerWidth: child.outerWidth()
9167 };
9168 if (restore) {
9169 $.effects.save(child, props2);
9170 }
9171
9172 child.from = {
9173 height: c_original.height * factor.from.y,
9174 width: c_original.width * factor.from.x,
9175 outerHeight: c_original.outerHeight * factor.from.y,
9176 outerWidth: c_original.outerWidth * factor.from.x
9177 };
9178 child.to = {
9179 height: c_original.height * factor.to.y,
9180 width: c_original.width * factor.to.x,
9181 outerHeight: c_original.height * factor.to.y,
9182 outerWidth: c_original.width * factor.to.x
9183 };
9184
9185 // Vertical props scaling
9186 if ( factor.from.y !== factor.to.y ) {
9187 child.from = $.effects.setTransition( child, vProps, factor.from.y, child.from );
9188 child.to = $.effects.setTransition( child, vProps, factor.to.y, child.to );
9189 }
9190
9191 // Horizontal props scaling
9192 if ( factor.from.x !== factor.to.x ) {
9193 child.from = $.effects.setTransition( child, hProps, factor.from.x, child.from );
9194 child.to = $.effects.setTransition( child, hProps, factor.to.x, child.to );
9195 }
9196
9197 // Animate children
9198 child.css( child.from );
9199 child.animate( child.to, o.duration, o.easing, function() {
9200
9201 // Restore children
9202 if ( restore ) {
9203 $.effects.restore( child, props2 );
9204 }
9205 });
9206 });
9207 }
9208
9209 // Animate
9210 el.animate( el.to, {
9211 queue: false,
9212 duration: o.duration,
9213 easing: o.easing,
9214 complete: function() {
9215 if ( el.to.opacity === 0 ) {
9216 el.css( "opacity", el.from.opacity );
9217 }
9218 if( mode === "hide" ) {
9219 el.hide();
9220 }
9221 $.effects.restore( el, props );
9222 if ( !restore ) {
9223
9224 // we need to calculate our new positioning based on the scaling
9225 if ( position === "static" ) {
9226 el.css({
9227 position: "relative",
9228 top: el.to.top,
9229 left: el.to.left
9230 });
9231 } else {
9232 $.each([ "top", "left" ], function( idx, pos ) {
9233 el.css( pos, function( _, str ) {
9234 var val = parseInt( str, 10 ),
9235 toRef = idx ? el.to.left : el.to.top;
9236
9237 // if original was "auto", recalculate the new value from wrapper
9238 if ( str === "auto" ) {
9239 return toRef + "px";
9240 }
9241
9242 return val + toRef + "px";
9243 });
9244 });
9245 }
9246 }
9247
9248 $.effects.removeWrapper( el );
9249 done();
9250 }
9251 });
9252
9253 };
9254
9255 })(jQuery);
9256 (function( $, undefined ) {
9257
9258 $.effects.effect.shake = function( o, done ) {
9259
9260 var el = $( this ),
9261 props = [ "position", "top", "bottom", "left", "right", "height", "width" ],
9262 mode = $.effects.setMode( el, o.mode || "effect" ),
9263 direction = o.direction || "left",
9264 distance = o.distance || 20,
9265 times = o.times || 3,
9266 anims = times * 2 + 1,
9267 speed = Math.round(o.duration/anims),
9268 ref = (direction === "up" || direction === "down") ? "top" : "left",
9269 positiveMotion = (direction === "up" || direction === "left"),
9270 animation = {},
9271 animation1 = {},
9272 animation2 = {},
9273 i,
9274
9275 // we will need to re-assemble the queue to stack our animations in place
9276 queue = el.queue(),
9277 queuelen = queue.length;
9278
9279 $.effects.save( el, props );
9280 el.show();
9281 $.effects.createWrapper( el );
9282
9283 // Animation
9284 animation[ ref ] = ( positiveMotion ? "-=" : "+=" ) + distance;
9285 animation1[ ref ] = ( positiveMotion ? "+=" : "-=" ) + distance * 2;
9286 animation2[ ref ] = ( positiveMotion ? "-=" : "+=" ) + distance * 2;
9287
9288 // Animate
9289 el.animate( animation, speed, o.easing );
9290
9291 // Shakes
9292 for ( i = 1; i < times; i++ ) {
9293 el.animate( animation1, speed, o.easing ).animate( animation2, speed, o.easing );
9294 }
9295 el
9296 .animate( animation1, speed, o.easing )
9297 .animate( animation, speed / 2, o.easing )
9298 .queue(function() {
9299 if ( mode === "hide" ) {
9300 el.hide();
9301 }
9302 $.effects.restore( el, props );
9303 $.effects.removeWrapper( el );
9304 done();
9305 });
9306
9307 // inject all the animations we just queued to be first in line (after "inprogress")
9308 if ( queuelen > 1) {
9309 queue.splice.apply( queue,
9310 [ 1, 0 ].concat( queue.splice( queuelen, anims + 1 ) ) );
9311 }
9312 el.dequeue();
9313
9314 };
9315
9316 })(jQuery);
9317 (function( $, undefined ) {
9318
9319 $.effects.effect.slide = function( o, done ) {
9320
9321 // Create element
9322 var el = $( this ),
9323 props = [ "position", "top", "bottom", "left", "right", "width", "height" ],
9324 mode = $.effects.setMode( el, o.mode || "show" ),
9325 show = mode === "show",
9326 direction = o.direction || "left",
9327 ref = (direction === "up" || direction === "down") ? "top" : "left",
9328 positiveMotion = (direction === "up" || direction === "left"),
9329 distance,
9330 animation = {};
9331
9332 // Adjust
9333 $.effects.save( el, props );
9334 el.show();
9335 distance = o.distance || el[ ref === "top" ? "outerHeight" : "outerWidth" ]( true );
9336
9337 $.effects.createWrapper( el ).css({
9338 overflow: "hidden"
9339 });
9340
9341 if ( show ) {
9342 el.css( ref, positiveMotion ? (isNaN(distance) ? "-" + distance : -distance) : distance );
9343 }
9344
9345 // Animation
9346 animation[ ref ] = ( show ?
9347 ( positiveMotion ? "+=" : "-=") :
9348 ( positiveMotion ? "-=" : "+=")) +
9349 distance;
9350
9351 // Animate
9352 el.animate( animation, {
9353 queue: false,
9354 duration: o.duration,
9355 easing: o.easing,
9356 complete: function() {
9357 if ( mode === "hide" ) {
9358 el.hide();
9359 }
9360 $.effects.restore( el, props );
9361 $.effects.removeWrapper( el );
9362 done();
9363 }
9364 });
9365 };
9366
9367 })(jQuery);
9368 (function( $, undefined ) {
9369
9370 $.effects.effect.transfer = function( o, done ) {
9371 var elem = $( this ),
9372 target = $( o.to ),
9373 targetFixed = target.css( "position" ) === "fixed",
9374 body = $("body"),
9375 fixTop = targetFixed ? body.scrollTop() : 0,
9376 fixLeft = targetFixed ? body.scrollLeft() : 0,
9377 endPosition = target.offset(),
9378 animation = {
9379 top: endPosition.top - fixTop ,
9380 left: endPosition.left - fixLeft ,
9381 height: target.innerHeight(),
9382 width: target.innerWidth()
9383 },
9384 startPosition = elem.offset(),
9385 transfer = $( "<div class='ui-effects-transfer'></div>" )
9386 .appendTo( document.body )
9387 .addClass( o.className )
9388 .css({
9389 top: startPosition.top - fixTop ,
9390 left: startPosition.left - fixLeft ,
9391 height: elem.innerHeight(),
9392 width: elem.innerWidth(),
9393 position: targetFixed ? "fixed" : "absolute"
9394 })
9395 .animate( animation, o.duration, o.easing, function() {
9396 transfer.remove();
9397 done();
9398 });
9399 };
9400
9401 })(jQuery);
9402 (function( $, undefined ) {
9403
9404 $.widget( "ui.menu", {
9405 version: "1.10.4",
9406 defaultElement: "<ul>",
9407 delay: 300,
9408 options: {
9409 icons: {
9410 submenu: "ui-icon-carat-1-e"
9411 },
9412 menus: "ul",
9413 position: {
9414 my: "left top",
9415 at: "right top"
9416 },
9417 role: "menu",
9418
9419 // callbacks
9420 blur: null,
9421 focus: null,
9422 select: null
9423 },
9424
9425 _create: function() {
9426 this.activeMenu = this.element;
9427 // flag used to prevent firing of the click handler
9428 // as the event bubbles up through nested menus
9429 this.mouseHandled = false;
9430 this.element
9431 .uniqueId()
9432 .addClass( "ui-menu ui-widget ui-widget-content ui-corner-all" )
9433 .toggleClass( "ui-menu-icons", !!this.element.find( ".ui-icon" ).length )
9434 .attr({
9435 role: this.options.role,
9436 tabIndex: 0
9437 })
9438 // need to catch all clicks on disabled menu
9439 // not possible through _on
9440 .bind( "click" + this.eventNamespace, $.proxy(function( event ) {
9441 if ( this.options.disabled ) {
9442 event.preventDefault();
9443 }
9444 }, this ));
9445
9446 if ( this.options.disabled ) {
9447 this.element
9448 .addClass( "ui-state-disabled" )
9449 .attr( "aria-disabled", "true" );
9450 }
9451
9452 this._on({
9453 // Prevent focus from sticking to links inside menu after clicking
9454 // them (focus should always stay on UL during navigation).
9455 "mousedown .ui-menu-item > a": function( event ) {
9456 event.preventDefault();
9457 },
9458 "click .ui-state-disabled > a": function( event ) {
9459 event.preventDefault();
9460 },
9461 "click .ui-menu-item:has(a)": function( event ) {
9462 var target = $( event.target ).closest( ".ui-menu-item" );
9463 if ( !this.mouseHandled && target.not( ".ui-state-disabled" ).length ) {
9464 this.select( event );
9465
9466 // Only set the mouseHandled flag if the event will bubble, see #9469.
9467 if ( !event.isPropagationStopped() ) {
9468 this.mouseHandled = true;
9469 }
9470
9471 // Open submenu on click
9472 if ( target.has( ".ui-menu" ).length ) {
9473 this.expand( event );
9474 } else if ( !this.element.is( ":focus" ) && $( this.document[ 0 ].activeElement ).closest( ".ui-menu" ).length ) {
9475
9476 // Redirect focus to the menu
9477 this.element.trigger( "focus", [ true ] );
9478
9479 // If the active item is on the top level, let it stay active.
9480 // Otherwise, blur the active item since it is no longer visible.
9481 if ( this.active && this.active.parents( ".ui-menu" ).length === 1 ) {
9482 clearTimeout( this.timer );
9483 }
9484 }
9485 }
9486 },
9487 "mouseenter .ui-menu-item": function( event ) {
9488 var target = $( event.currentTarget );
9489 // Remove ui-state-active class from siblings of the newly focused menu item
9490 // to avoid a jump caused by adjacent elements both having a class with a border
9491 target.siblings().children( ".ui-state-active" ).removeClass( "ui-state-active" );
9492 this.focus( event, target );
9493 },
9494 mouseleave: "collapseAll",
9495 "mouseleave .ui-menu": "collapseAll",
9496 focus: function( event, keepActiveItem ) {
9497 // If there's already an active item, keep it active
9498 // If not, activate the first item
9499 var item = this.active || this.element.children( ".ui-menu-item" ).eq( 0 );
9500
9501 if ( !keepActiveItem ) {
9502 this.focus( event, item );
9503 }
9504 },
9505 blur: function( event ) {
9506 this._delay(function() {
9507 if ( !$.contains( this.element[0], this.document[0].activeElement ) ) {
9508 this.collapseAll( event );
9509 }
9510 });
9511 },
9512 keydown: "_keydown"
9513 });
9514
9515 this.refresh();
9516
9517 // Clicks outside of a menu collapse any open menus
9518 this._on( this.document, {
9519 click: function( event ) {
9520 if ( !$( event.target ).closest( ".ui-menu" ).length ) {
9521 this.collapseAll( event );
9522 }
9523
9524 // Reset the mouseHandled flag
9525 this.mouseHandled = false;
9526 }
9527 });
9528 },
9529
9530 _destroy: function() {
9531 // Destroy (sub)menus
9532 this.element
9533 .removeAttr( "aria-activedescendant" )
9534 .find( ".ui-menu" ).addBack()
9535 .removeClass( "ui-menu ui-widget ui-widget-content ui-corner-all ui-menu-icons" )
9536 .removeAttr( "role" )
9537 .removeAttr( "tabIndex" )
9538 .removeAttr( "aria-labelledby" )
9539 .removeAttr( "aria-expanded" )
9540 .removeAttr( "aria-hidden" )
9541 .removeAttr( "aria-disabled" )
9542 .removeUniqueId()
9543 .show();
9544
9545 // Destroy menu items
9546 this.element.find( ".ui-menu-item" )
9547 .removeClass( "ui-menu-item" )
9548 .removeAttr( "role" )
9549 .removeAttr( "aria-disabled" )
9550 .children( "a" )
9551 .removeUniqueId()
9552 .removeClass( "ui-corner-all ui-state-hover" )
9553 .removeAttr( "tabIndex" )
9554 .removeAttr( "role" )
9555 .removeAttr( "aria-haspopup" )
9556 .children().each( function() {
9557 var elem = $( this );
9558 if ( elem.data( "ui-menu-submenu-carat" ) ) {
9559 elem.remove();
9560 }
9561 });
9562
9563 // Destroy menu dividers
9564 this.element.find( ".ui-menu-divider" ).removeClass( "ui-menu-divider ui-widget-content" );
9565 },
9566
9567 _keydown: function( event ) {
9568 var match, prev, character, skip, regex,
9569 preventDefault = true;
9570
9571 function escape( value ) {
9572 return value.replace( /[\-\[\]{}()*+?.,\\\^$|#\s]/g, "\\$&" );
9573 }
9574
9575 switch ( event.keyCode ) {
9576 case $.ui.keyCode.PAGE_UP:
9577 this.previousPage( event );
9578 break;
9579 case $.ui.keyCode.PAGE_DOWN:
9580 this.nextPage( event );
9581 break;
9582 case $.ui.keyCode.HOME:
9583 this._move( "first", "first", event );
9584 break;
9585 case $.ui.keyCode.END:
9586 this._move( "last", "last", event );
9587 break;
9588 case $.ui.keyCode.UP:
9589 this.previous( event );
9590 break;
9591 case $.ui.keyCode.DOWN:
9592 this.next( event );
9593 break;
9594 case $.ui.keyCode.LEFT:
9595 this.collapse( event );
9596 break;
9597 case $.ui.keyCode.RIGHT:
9598 if ( this.active && !this.active.is( ".ui-state-disabled" ) ) {
9599 this.expand( event );
9600 }
9601 break;
9602 case $.ui.keyCode.ENTER:
9603 case $.ui.keyCode.SPACE:
9604 this._activate( event );
9605 break;
9606 case $.ui.keyCode.ESCAPE:
9607 this.collapse( event );
9608 break;
9609 default:
9610 preventDefault = false;
9611 prev = this.previousFilter || "";
9612 character = String.fromCharCode( event.keyCode );
9613 skip = false;
9614
9615 clearTimeout( this.filterTimer );
9616
9617 if ( character === prev ) {
9618 skip = true;
9619 } else {
9620 character = prev + character;
9621 }
9622
9623 regex = new RegExp( "^" + escape( character ), "i" );
9624 match = this.activeMenu.children( ".ui-menu-item" ).filter(function() {
9625 return regex.test( $( this ).children( "a" ).text() );
9626 });
9627 match = skip && match.index( this.active.next() ) !== -1 ?
9628 this.active.nextAll( ".ui-menu-item" ) :
9629 match;
9630
9631 // If no matches on the current filter, reset to the last character pressed
9632 // to move down the menu to the first item that starts with that character
9633 if ( !match.length ) {
9634 character = String.fromCharCode( event.keyCode );
9635 regex = new RegExp( "^" + escape( character ), "i" );
9636 match = this.activeMenu.children( ".ui-menu-item" ).filter(function() {
9637 return regex.test( $( this ).children( "a" ).text() );
9638 });
9639 }
9640
9641 if ( match.length ) {
9642 this.focus( event, match );
9643 if ( match.length > 1 ) {
9644 this.previousFilter = character;
9645 this.filterTimer = this._delay(function() {
9646 delete this.previousFilter;
9647 }, 1000 );
9648 } else {
9649 delete this.previousFilter;
9650 }
9651 } else {
9652 delete this.previousFilter;
9653 }
9654 }
9655
9656 if ( preventDefault ) {
9657 event.preventDefault();
9658 }
9659 },
9660
9661 _activate: function( event ) {
9662 if ( !this.active.is( ".ui-state-disabled" ) ) {
9663 if ( this.active.children( "a[aria-haspopup='true']" ).length ) {
9664 this.expand( event );
9665 } else {
9666 this.select( event );
9667 }
9668 }
9669 },
9670
9671 refresh: function() {
9672 var menus,
9673 icon = this.options.icons.submenu,
9674 submenus = this.element.find( this.options.menus );
9675
9676 this.element.toggleClass( "ui-menu-icons", !!this.element.find( ".ui-icon" ).length );
9677
9678 // Initialize nested menus
9679 submenus.filter( ":not(.ui-menu)" )
9680 .addClass( "ui-menu ui-widget ui-widget-content ui-corner-all" )
9681 .hide()
9682 .attr({
9683 role: this.options.role,
9684 "aria-hidden": "true",
9685 "aria-expanded": "false"
9686 })
9687 .each(function() {
9688 var menu = $( this ),
9689 item = menu.prev( "a" ),
9690 submenuCarat = $( "<span>" )
9691 .addClass( "ui-menu-icon ui-icon " + icon )
9692 .data( "ui-menu-submenu-carat", true );
9693
9694 item
9695 .attr( "aria-haspopup", "true" )
9696 .prepend( submenuCarat );
9697 menu.attr( "aria-labelledby", item.attr( "id" ) );
9698 });
9699
9700 menus = submenus.add( this.element );
9701
9702 // Don't refresh list items that are already adapted
9703 menus.children( ":not(.ui-menu-item):has(a)" )
9704 .addClass( "ui-menu-item" )
9705 .attr( "role", "presentation" )
9706 .children( "a" )
9707 .uniqueId()
9708 .addClass( "ui-corner-all" )
9709 .attr({
9710 tabIndex: -1,
9711 role: this._itemRole()
9712 });
9713
9714 // Initialize unlinked menu-items containing spaces and/or dashes only as dividers
9715 menus.children( ":not(.ui-menu-item)" ).each(function() {
9716 var item = $( this );
9717 // hyphen, em dash, en dash
9718 if ( !/[^\-\u2014\u2013\s]/.test( item.text() ) ) {
9719 item.addClass( "ui-widget-content ui-menu-divider" );
9720 }
9721 });
9722
9723 // Add aria-disabled attribute to any disabled menu item
9724 menus.children( ".ui-state-disabled" ).attr( "aria-disabled", "true" );
9725
9726 // If the active item has been removed, blur the menu
9727 if ( this.active && !$.contains( this.element[ 0 ], this.active[ 0 ] ) ) {
9728 this.blur();
9729 }
9730 },
9731
9732 _itemRole: function() {
9733 return {
9734 menu: "menuitem",
9735 listbox: "option"
9736 }[ this.options.role ];
9737 },
9738
9739 _setOption: function( key, value ) {
9740 if ( key === "icons" ) {
9741 this.element.find( ".ui-menu-icon" )
9742 .removeClass( this.options.icons.submenu )
9743 .addClass( value.submenu );
9744 }
9745 this._super( key, value );
9746 },
9747
9748 focus: function( event, item ) {
9749 var nested, focused;
9750 this.blur( event, event && event.type === "focus" );
9751
9752 this._scrollIntoView( item );
9753
9754 this.active = item.first();
9755 focused = this.active.children( "a" ).addClass( "ui-state-focus" );
9756 // Only update aria-activedescendant if there's a role
9757 // otherwise we assume focus is managed elsewhere
9758 if ( this.options.role ) {
9759 this.element.attr( "aria-activedescendant", focused.attr( "id" ) );
9760 }
9761
9762 // Highlight active parent menu item, if any
9763 this.active
9764 .parent()
9765 .closest( ".ui-menu-item" )
9766 .children( "a:first" )
9767 .addClass( "ui-state-active" );
9768
9769 if ( event && event.type === "keydown" ) {
9770 this._close();
9771 } else {
9772 this.timer = this._delay(function() {
9773 this._close();
9774 }, this.delay );
9775 }
9776
9777 nested = item.children( ".ui-menu" );
9778 if ( nested.length && event && ( /^mouse/.test( event.type ) ) ) {
9779 this._startOpening(nested);
9780 }
9781 this.activeMenu = item.parent();
9782
9783 this._trigger( "focus", event, { item: item } );
9784 },
9785
9786 _scrollIntoView: function( item ) {
9787 var borderTop, paddingTop, offset, scroll, elementHeight, itemHeight;
9788 if ( this._hasScroll() ) {
9789 borderTop = parseFloat( $.css( this.activeMenu[0], "borderTopWidth" ) ) || 0;
9790 paddingTop = parseFloat( $.css( this.activeMenu[0], "paddingTop" ) ) || 0;
9791 offset = item.offset().top - this.activeMenu.offset().top - borderTop - paddingTop;
9792 scroll = this.activeMenu.scrollTop();
9793 elementHeight = this.activeMenu.height();
9794 itemHeight = item.height();
9795
9796 if ( offset < 0 ) {
9797 this.activeMenu.scrollTop( scroll + offset );
9798 } else if ( offset + itemHeight > elementHeight ) {
9799 this.activeMenu.scrollTop( scroll + offset - elementHeight + itemHeight );
9800 }
9801 }
9802 },
9803
9804 blur: function( event, fromFocus ) {
9805 if ( !fromFocus ) {
9806 clearTimeout( this.timer );
9807 }
9808
9809 if ( !this.active ) {
9810 return;
9811 }
9812
9813 this.active.children( "a" ).removeClass( "ui-state-focus" );
9814 this.active = null;
9815
9816 this._trigger( "blur", event, { item: this.active } );
9817 },
9818
9819 _startOpening: function( submenu ) {
9820 clearTimeout( this.timer );
9821
9822 // Don't open if already open fixes a Firefox bug that caused a .5 pixel
9823 // shift in the submenu position when mousing over the carat icon
9824 if ( submenu.attr( "aria-hidden" ) !== "true" ) {
9825 return;
9826 }
9827
9828 this.timer = this._delay(function() {
9829 this._close();
9830 this._open( submenu );
9831 }, this.delay );
9832 },
9833
9834 _open: function( submenu ) {
9835 var position = $.extend({
9836 of: this.active
9837 }, this.options.position );
9838
9839 clearTimeout( this.timer );
9840 this.element.find( ".ui-menu" ).not( submenu.parents( ".ui-menu" ) )
9841 .hide()
9842 .attr( "aria-hidden", "true" );
9843
9844 submenu
9845 .show()
9846 .removeAttr( "aria-hidden" )
9847 .attr( "aria-expanded", "true" )
9848 .position( position );
9849 },
9850
9851 collapseAll: function( event, all ) {
9852 clearTimeout( this.timer );
9853 this.timer = this._delay(function() {
9854 // If we were passed an event, look for the submenu that contains the event
9855 var currentMenu = all ? this.element :
9856 $( event && event.target ).closest( this.element.find( ".ui-menu" ) );
9857
9858 // If we found no valid submenu ancestor, use the main menu to close all sub menus anyway
9859 if ( !currentMenu.length ) {
9860 currentMenu = this.element;
9861 }
9862
9863 this._close( currentMenu );
9864
9865 this.blur( event );
9866 this.activeMenu = currentMenu;
9867 }, this.delay );
9868 },
9869
9870 // With no arguments, closes the currently active menu - if nothing is active
9871 // it closes all menus. If passed an argument, it will search for menus BELOW
9872 _close: function( startMenu ) {
9873 if ( !startMenu ) {
9874 startMenu = this.active ? this.active.parent() : this.element;
9875 }
9876
9877 startMenu
9878 .find( ".ui-menu" )
9879 .hide()
9880 .attr( "aria-hidden", "true" )
9881 .attr( "aria-expanded", "false" )
9882 .end()
9883 .find( "a.ui-state-active" )
9884 .removeClass( "ui-state-active" );
9885 },
9886
9887 collapse: function( event ) {
9888 var newItem = this.active &&
9889 this.active.parent().closest( ".ui-menu-item", this.element );
9890 if ( newItem && newItem.length ) {
9891 this._close();
9892 this.focus( event, newItem );
9893 }
9894 },
9895
9896 expand: function( event ) {
9897 var newItem = this.active &&
9898 this.active
9899 .children( ".ui-menu " )
9900 .children( ".ui-menu-item" )
9901 .first();
9902
9903 if ( newItem && newItem.length ) {
9904 this._open( newItem.parent() );
9905
9906 // Delay so Firefox will not hide activedescendant change in expanding submenu from AT
9907 this._delay(function() {
9908 this.focus( event, newItem );
9909 });
9910 }
9911 },
9912
9913 next: function( event ) {
9914 this._move( "next", "first", event );
9915 },
9916
9917 previous: function( event ) {
9918 this._move( "prev", "last", event );
9919 },
9920
9921 isFirstItem: function() {
9922 return this.active && !this.active.prevAll( ".ui-menu-item" ).length;
9923 },
9924
9925 isLastItem: function() {
9926 return this.active && !this.active.nextAll( ".ui-menu-item" ).length;
9927 },
9928
9929 _move: function( direction, filter, event ) {
9930 var next;
9931 if ( this.active ) {
9932 if ( direction === "first" || direction === "last" ) {
9933 next = this.active
9934 [ direction === "first" ? "prevAll" : "nextAll" ]( ".ui-menu-item" )
9935 .eq( -1 );
9936 } else {
9937 next = this.active
9938 [ direction + "All" ]( ".ui-menu-item" )
9939 .eq( 0 );
9940 }
9941 }
9942 if ( !next || !next.length || !this.active ) {
9943 next = this.activeMenu.children( ".ui-menu-item" )[ filter ]();
9944 }
9945
9946 this.focus( event, next );
9947 },
9948
9949 nextPage: function( event ) {
9950 var item, base, height;
9951
9952 if ( !this.active ) {
9953 this.next( event );
9954 return;
9955 }
9956 if ( this.isLastItem() ) {
9957 return;
9958 }
9959 if ( this._hasScroll() ) {
9960 base = this.active.offset().top;
9961 height = this.element.height();
9962 this.active.nextAll( ".ui-menu-item" ).each(function() {
9963 item = $( this );
9964 return item.offset().top - base - height < 0;
9965 });
9966
9967 this.focus( event, item );
9968 } else {
9969 this.focus( event, this.activeMenu.children( ".ui-menu-item" )
9970 [ !this.active ? "first" : "last" ]() );
9971 }
9972 },
9973
9974 previousPage: function( event ) {
9975 var item, base, height;
9976 if ( !this.active ) {
9977 this.next( event );
9978 return;
9979 }
9980 if ( this.isFirstItem() ) {
9981 return;
9982 }
9983 if ( this._hasScroll() ) {
9984 base = this.active.offset().top;
9985 height = this.element.height();
9986 this.active.prevAll( ".ui-menu-item" ).each(function() {
9987 item = $( this );
9988 return item.offset().top - base + height > 0;
9989 });
9990
9991 this.focus( event, item );
9992 } else {
9993 this.focus( event, this.activeMenu.children( ".ui-menu-item" ).first() );
9994 }
9995 },
9996
9997 _hasScroll: function() {
9998 return this.element.outerHeight() < this.element.prop( "scrollHeight" );
9999 },
10000
10001 select: function( event ) {
10002 // TODO: It should never be possible to not have an active item at this
10003 // point, but the tests don't trigger mouseenter before click.
10004 this.active = this.active || $( event.target ).closest( ".ui-menu-item" );
10005 var ui = { item: this.active };
10006 if ( !this.active.has( ".ui-menu" ).length ) {
10007 this.collapseAll( event, true );
10008 }
10009 this._trigger( "select", event, ui );
10010 }
10011 });
10012
10013 }( jQuery ));
10014 (function( $, undefined ) {
10015
10016 $.widget( "ui.progressbar", {
10017 version: "1.10.4",
10018 options: {
10019 max: 100,
10020 value: 0,
10021
10022 change: null,
10023 complete: null
10024 },
10025
10026 min: 0,
10027
10028 _create: function() {
10029 // Constrain initial value
10030 this.oldValue = this.options.value = this._constrainedValue();
10031
10032 this.element
10033 .addClass( "ui-progressbar ui-widget ui-widget-content ui-corner-all" )
10034 .attr({
10035 // Only set static values, aria-valuenow and aria-valuemax are
10036 // set inside _refreshValue()
10037 role: "progressbar",
10038 "aria-valuemin": this.min
10039 });
10040
10041 this.valueDiv = $( "<div class='ui-progressbar-value ui-widget-header ui-corner-left'></div>" )
10042 .appendTo( this.element );
10043
10044 this._refreshValue();
10045 },
10046
10047 _destroy: function() {
10048 this.element
10049 .removeClass( "ui-progressbar ui-widget ui-widget-content ui-corner-all" )
10050 .removeAttr( "role" )
10051 .removeAttr( "aria-valuemin" )
10052 .removeAttr( "aria-valuemax" )
10053 .removeAttr( "aria-valuenow" );
10054
10055 this.valueDiv.remove();
10056 },
10057
10058 value: function( newValue ) {
10059 if ( newValue === undefined ) {
10060 return this.options.value;
10061 }
10062
10063 this.options.value = this._constrainedValue( newValue );
10064 this._refreshValue();
10065 },
10066
10067 _constrainedValue: function( newValue ) {
10068 if ( newValue === undefined ) {
10069 newValue = this.options.value;
10070 }
10071
10072 this.indeterminate = newValue === false;
10073
10074 // sanitize value
10075 if ( typeof newValue !== "number" ) {
10076 newValue = 0;
10077 }
10078
10079 return this.indeterminate ? false :
10080 Math.min( this.options.max, Math.max( this.min, newValue ) );
10081 },
10082
10083 _setOptions: function( options ) {
10084 // Ensure "value" option is set after other values (like max)
10085 var value = options.value;
10086 delete options.value;
10087
10088 this._super( options );
10089
10090 this.options.value = this._constrainedValue( value );
10091 this._refreshValue();
10092 },
10093
10094 _setOption: function( key, value ) {
10095 if ( key === "max" ) {
10096 // Don't allow a max less than min
10097 value = Math.max( this.min, value );
10098 }
10099
10100 this._super( key, value );
10101 },
10102
10103 _percentage: function() {
10104 return this.indeterminate ? 100 : 100 * ( this.options.value - this.min ) / ( this.options.max - this.min );
10105 },
10106
10107 _refreshValue: function() {
10108 var value = this.options.value,
10109 percentage = this._percentage();
10110
10111 this.valueDiv
10112 .toggle( this.indeterminate || value > this.min )
10113 .toggleClass( "ui-corner-right", value === this.options.max )
10114 .width( percentage.toFixed(0) + "%" );
10115
10116 this.element.toggleClass( "ui-progressbar-indeterminate", this.indeterminate );
10117
10118 if ( this.indeterminate ) {
10119 this.element.removeAttr( "aria-valuenow" );
10120 if ( !this.overlayDiv ) {
10121 this.overlayDiv = $( "<div class='ui-progressbar-overlay'></div>" ).appendTo( this.valueDiv );
10122 }
10123 } else {
10124 this.element.attr({
10125 "aria-valuemax": this.options.max,
10126 "aria-valuenow": value
10127 });
10128 if ( this.overlayDiv ) {
10129 this.overlayDiv.remove();
10130 this.overlayDiv = null;
10131 }
10132 }
10133
10134 if ( this.oldValue !== value ) {
10135 this.oldValue = value;
10136 this._trigger( "change" );
10137 }
10138 if ( value === this.options.max ) {
10139 this._trigger( "complete" );
10140 }
10141 }
10142 });
10143
10144 })( jQuery );
10145 (function( $, undefined ) {
10146
10147 function num(v) {
10148 return parseInt(v, 10) || 0;
10149 }
10150
10151 function isNumber(value) {
10152 return !isNaN(parseInt(value, 10));
10153 }
10154
10155 $.widget("ui.resizable", $.ui.mouse, {
10156 version: "1.10.4",
10157 widgetEventPrefix: "resize",
10158 options: {
10159 alsoResize: false,
10160 animate: false,
10161 animateDuration: "slow",
10162 animateEasing: "swing",
10163 aspectRatio: false,
10164 autoHide: false,
10165 containment: false,
10166 ghost: false,
10167 grid: false,
10168 handles: "e,s,se",
10169 helper: false,
10170 maxHeight: null,
10171 maxWidth: null,
10172 minHeight: 10,
10173 minWidth: 10,
10174 // See #7960
10175 zIndex: 90,
10176
10177 // callbacks
10178 resize: null,
10179 start: null,
10180 stop: null
10181 },
10182 _create: function() {
10183
10184 var n, i, handle, axis, hname,
10185 that = this,
10186 o = this.options;
10187 this.element.addClass("ui-resizable");
10188
10189 $.extend(this, {
10190 _aspectRatio: !!(o.aspectRatio),
10191 aspectRatio: o.aspectRatio,
10192 originalElement: this.element,
10193 _proportionallyResizeElements: [],
10194 _helper: o.helper || o.ghost || o.animate ? o.helper || "ui-resizable-helper" : null
10195 });
10196
10197 //Wrap the element if it cannot hold child nodes
10198 if(this.element[0].nodeName.match(/canvas|textarea|input|select|button|img/i)) {
10199
10200 //Create a wrapper element and set the wrapper to the new current internal element
10201 this.element.wrap(
10202 $("<div class='ui-wrapper' style='overflow: hidden;'></div>").css({
10203 position: this.element.css("position"),
10204 width: this.element.outerWidth(),
10205 height: this.element.outerHeight(),
10206 top: this.element.css("top"),
10207 left: this.element.css("left")
10208 })
10209 );
10210
10211 //Overwrite the original this.element
10212 this.element = this.element.parent().data(
10213 "ui-resizable", this.element.data("ui-resizable")
10214 );
10215
10216 this.elementIsWrapper = true;
10217
10218 //Move margins to the wrapper
10219 this.element.css({ marginLeft: this.originalElement.css("marginLeft"), marginTop: this.originalElement.css("marginTop"), marginRight: this.originalElement.css("marginRight"), marginBottom: this.originalElement.css("marginBottom") });
10220 this.originalElement.css({ marginLeft: 0, marginTop: 0, marginRight: 0, marginBottom: 0});
10221
10222 //Prevent Safari textarea resize
10223 this.originalResizeStyle = this.originalElement.css("resize");
10224 this.originalElement.css("resize", "none");
10225
10226 //Push the actual element to our proportionallyResize internal array
10227 this._proportionallyResizeElements.push(this.originalElement.css({ position: "static", zoom: 1, display: "block" }));
10228
10229 // avoid IE jump (hard set the margin)
10230 this.originalElement.css({ margin: this.originalElement.css("margin") });
10231
10232 // fix handlers offset
10233 this._proportionallyResize();
10234
10235 }
10236
10237 this.handles = o.handles || (!$(".ui-resizable-handle", this.element).length ? "e,s,se" : { n: ".ui-resizable-n", e: ".ui-resizable-e", s: ".ui-resizable-s", w: ".ui-resizable-w", se: ".ui-resizable-se", sw: ".ui-resizable-sw", ne: ".ui-resizable-ne", nw: ".ui-resizable-nw" });
10238 if(this.handles.constructor === String) {
10239
10240 if ( this.handles === "all") {
10241 this.handles = "n,e,s,w,se,sw,ne,nw";
10242 }
10243
10244 n = this.handles.split(",");
10245 this.handles = {};
10246
10247 for(i = 0; i < n.length; i++) {
10248
10249 handle = $.trim(n[i]);
10250 hname = "ui-resizable-"+handle;
10251 axis = $("<div class='ui-resizable-handle " + hname + "'></div>");
10252
10253 // Apply zIndex to all handles - see #7960
10254 axis.css({ zIndex: o.zIndex });
10255
10256 //TODO : What's going on here?
10257 if ("se" === handle) {
10258 axis.addClass("ui-icon ui-icon-gripsmall-diagonal-se");
10259 }
10260
10261 //Insert into internal handles object and append to element
10262 this.handles[handle] = ".ui-resizable-"+handle;
10263 this.element.append(axis);
10264 }
10265
10266 }
10267
10268 this._renderAxis = function(target) {
10269
10270 var i, axis, padPos, padWrapper;
10271
10272 target = target || this.element;
10273
10274 for(i in this.handles) {
10275
10276 if(this.handles[i].constructor === String) {
10277 this.handles[i] = $(this.handles[i], this.element).show();
10278 }
10279
10280 //Apply pad to wrapper element, needed to fix axis position (textarea, inputs, scrolls)
10281 if (this.elementIsWrapper && this.originalElement[0].nodeName.match(/textarea|input|select|button/i)) {
10282
10283 axis = $(this.handles[i], this.element);
10284
10285 //Checking the correct pad and border
10286 padWrapper = /sw|ne|nw|se|n|s/.test(i) ? axis.outerHeight() : axis.outerWidth();
10287
10288 //The padding type i have to apply...
10289 padPos = [ "padding",
10290 /ne|nw|n/.test(i) ? "Top" :
10291 /se|sw|s/.test(i) ? "Bottom" :
10292 /^e$/.test(i) ? "Right" : "Left" ].join("");
10293
10294 target.css(padPos, padWrapper);
10295
10296 this._proportionallyResize();
10297
10298 }
10299
10300 //TODO: What's that good for? There's not anything to be executed left
10301 if(!$(this.handles[i]).length) {
10302 continue;
10303 }
10304 }
10305 };
10306
10307 //TODO: make renderAxis a prototype function
10308 this._renderAxis(this.element);
10309
10310 this._handles = $(".ui-resizable-handle", this.element)
10311 .disableSelection();
10312
10313 //Matching axis name
10314 this._handles.mouseover(function() {
10315 if (!that.resizing) {
10316 if (this.className) {
10317 axis = this.className.match(/ui-resizable-(se|sw|ne|nw|n|e|s|w)/i);
10318 }
10319 //Axis, default = se
10320 that.axis = axis && axis[1] ? axis[1] : "se";
10321 }
10322 });
10323
10324 //If we want to auto hide the elements
10325 if (o.autoHide) {
10326 this._handles.hide();
10327 $(this.element)
10328 .addClass("ui-resizable-autohide")
10329 .mouseenter(function() {
10330 if (o.disabled) {
10331 return;
10332 }
10333 $(this).removeClass("ui-resizable-autohide");
10334 that._handles.show();
10335 })
10336 .mouseleave(function(){
10337 if (o.disabled) {
10338 return;
10339 }
10340 if (!that.resizing) {
10341 $(this).addClass("ui-resizable-autohide");
10342 that._handles.hide();
10343 }
10344 });
10345 }
10346
10347 //Initialize the mouse interaction
10348 this._mouseInit();
10349
10350 },
10351
10352 _destroy: function() {
10353
10354 this._mouseDestroy();
10355
10356 var wrapper,
10357 _destroy = function(exp) {
10358 $(exp).removeClass("ui-resizable ui-resizable-disabled ui-resizable-resizing")
10359 .removeData("resizable").removeData("ui-resizable").unbind(".resizable").find(".ui-resizable-handle").remove();
10360 };
10361
10362 //TODO: Unwrap at same DOM position
10363 if (this.elementIsWrapper) {
10364 _destroy(this.element);
10365 wrapper = this.element;
10366 this.originalElement.css({
10367 position: wrapper.css("position"),
10368 width: wrapper.outerWidth(),
10369 height: wrapper.outerHeight(),
10370 top: wrapper.css("top"),
10371 left: wrapper.css("left")
10372 }).insertAfter( wrapper );
10373 wrapper.remove();
10374 }
10375
10376 this.originalElement.css("resize", this.originalResizeStyle);
10377 _destroy(this.originalElement);
10378
10379 return this;
10380 },
10381
10382 _mouseCapture: function(event) {
10383 var i, handle,
10384 capture = false;
10385
10386 for (i in this.handles) {
10387 handle = $(this.handles[i])[0];
10388 if (handle === event.target || $.contains(handle, event.target)) {
10389 capture = true;
10390 }
10391 }
10392
10393 return !this.options.disabled && capture;
10394 },
10395
10396 _mouseStart: function(event) {
10397
10398 var curleft, curtop, cursor,
10399 o = this.options,
10400 iniPos = this.element.position(),
10401 el = this.element;
10402
10403 this.resizing = true;
10404
10405 // bugfix for http://dev.jquery.com/ticket/1749
10406 if ( (/absolute/).test( el.css("position") ) ) {
10407 el.css({ position: "absolute", top: el.css("top"), left: el.css("left") });
10408 } else if (el.is(".ui-draggable")) {
10409 el.css({ position: "absolute", top: iniPos.top, left: iniPos.left });
10410 }
10411
10412 this._renderProxy();
10413
10414 curleft = num(this.helper.css("left"));
10415 curtop = num(this.helper.css("top"));
10416
10417 if (o.containment) {
10418 curleft += $(o.containment).scrollLeft() || 0;
10419 curtop += $(o.containment).scrollTop() || 0;
10420 }
10421
10422 //Store needed variables
10423 this.offset = this.helper.offset();
10424 this.position = { left: curleft, top: curtop };
10425 this.size = this._helper ? { width: this.helper.width(), height: this.helper.height() } : { width: el.width(), height: el.height() };
10426 this.originalSize = this._helper ? { width: el.outerWidth(), height: el.outerHeight() } : { width: el.width(), height: el.height() };
10427 this.originalPosition = { left: curleft, top: curtop };
10428 this.sizeDiff = { width: el.outerWidth() - el.width(), height: el.outerHeight() - el.height() };
10429 this.originalMousePosition = { left: event.pageX, top: event.pageY };
10430
10431 //Aspect Ratio
10432 this.aspectRatio = (typeof o.aspectRatio === "number") ? o.aspectRatio : ((this.originalSize.width / this.originalSize.height) || 1);
10433
10434 cursor = $(".ui-resizable-" + this.axis).css("cursor");
10435 $("body").css("cursor", cursor === "auto" ? this.axis + "-resize" : cursor);
10436
10437 el.addClass("ui-resizable-resizing");
10438 this._propagate("start", event);
10439 return true;
10440 },
10441
10442 _mouseDrag: function(event) {
10443
10444 //Increase performance, avoid regex
10445 var data,
10446 el = this.helper, props = {},
10447 smp = this.originalMousePosition,
10448 a = this.axis,
10449 prevTop = this.position.top,
10450 prevLeft = this.position.left,
10451 prevWidth = this.size.width,
10452 prevHeight = this.size.height,
10453 dx = (event.pageX-smp.left)||0,
10454 dy = (event.pageY-smp.top)||0,
10455 trigger = this._change[a];
10456
10457 if (!trigger) {
10458 return false;
10459 }
10460
10461 // Calculate the attrs that will be change
10462 data = trigger.apply(this, [event, dx, dy]);
10463
10464 // Put this in the mouseDrag handler since the user can start pressing shift while resizing
10465 this._updateVirtualBoundaries(event.shiftKey);
10466 if (this._aspectRatio || event.shiftKey) {
10467 data = this._updateRatio(data, event);
10468 }
10469
10470 data = this._respectSize(data, event);
10471
10472 this._updateCache(data);
10473
10474 // plugins callbacks need to be called first
10475 this._propagate("resize", event);
10476
10477 if (this.position.top !== prevTop) {
10478 props.top = this.position.top + "px";
10479 }
10480 if (this.position.left !== prevLeft) {
10481 props.left = this.position.left + "px";
10482 }
10483 if (this.size.width !== prevWidth) {
10484 props.width = this.size.width + "px";
10485 }
10486 if (this.size.height !== prevHeight) {
10487 props.height = this.size.height + "px";
10488 }
10489 el.css(props);
10490
10491 if (!this._helper && this._proportionallyResizeElements.length) {
10492 this._proportionallyResize();
10493 }
10494
10495 // Call the user callback if the element was resized
10496 if ( ! $.isEmptyObject(props) ) {
10497 this._trigger("resize", event, this.ui());
10498 }
10499
10500 return false;
10501 },
10502
10503 _mouseStop: function(event) {
10504
10505 this.resizing = false;
10506 var pr, ista, soffseth, soffsetw, s, left, top,
10507 o = this.options, that = this;
10508
10509 if(this._helper) {
10510
10511 pr = this._proportionallyResizeElements;
10512 ista = pr.length && (/textarea/i).test(pr[0].nodeName);
10513 soffseth = ista && $.ui.hasScroll(pr[0], "left") /* TODO - jump height */ ? 0 : that.sizeDiff.height;
10514 soffsetw = ista ? 0 : that.sizeDiff.width;
10515
10516 s = { width: (that.helper.width() - soffsetw), height: (that.helper.height() - soffseth) };
10517 left = (parseInt(that.element.css("left"), 10) + (that.position.left - that.originalPosition.left)) || null;
10518 top = (parseInt(that.element.css("top"), 10) + (that.position.top - that.originalPosition.top)) || null;
10519
10520 if (!o.animate) {
10521 this.element.css($.extend(s, { top: top, left: left }));
10522 }
10523
10524 that.helper.height(that.size.height);
10525 that.helper.width(that.size.width);
10526
10527 if (this._helper && !o.animate) {
10528 this._proportionallyResize();
10529 }
10530 }
10531
10532 $("body").css("cursor", "auto");
10533
10534 this.element.removeClass("ui-resizable-resizing");
10535
10536 this._propagate("stop", event);
10537
10538 if (this._helper) {
10539 this.helper.remove();
10540 }
10541
10542 return false;
10543
10544 },
10545
10546 _updateVirtualBoundaries: function(forceAspectRatio) {
10547 var pMinWidth, pMaxWidth, pMinHeight, pMaxHeight, b,
10548 o = this.options;
10549
10550 b = {
10551 minWidth: isNumber(o.minWidth) ? o.minWidth : 0,
10552 maxWidth: isNumber(o.maxWidth) ? o.maxWidth : Infinity,
10553 minHeight: isNumber(o.minHeight) ? o.minHeight : 0,
10554 maxHeight: isNumber(o.maxHeight) ? o.maxHeight : Infinity
10555 };
10556
10557 if(this._aspectRatio || forceAspectRatio) {
10558 // We want to create an enclosing box whose aspect ration is the requested one
10559 // First, compute the "projected" size for each dimension based on the aspect ratio and other dimension
10560 pMinWidth = b.minHeight * this.aspectRatio;
10561 pMinHeight = b.minWidth / this.aspectRatio;
10562 pMaxWidth = b.maxHeight * this.aspectRatio;
10563 pMaxHeight = b.maxWidth / this.aspectRatio;
10564
10565 if(pMinWidth > b.minWidth) {
10566 b.minWidth = pMinWidth;
10567 }
10568 if(pMinHeight > b.minHeight) {
10569 b.minHeight = pMinHeight;
10570 }
10571 if(pMaxWidth < b.maxWidth) {
10572 b.maxWidth = pMaxWidth;
10573 }
10574 if(pMaxHeight < b.maxHeight) {
10575 b.maxHeight = pMaxHeight;
10576 }
10577 }
10578 this._vBoundaries = b;
10579 },
10580
10581 _updateCache: function(data) {
10582 this.offset = this.helper.offset();
10583 if (isNumber(data.left)) {
10584 this.position.left = data.left;
10585 }
10586 if (isNumber(data.top)) {
10587 this.position.top = data.top;
10588 }
10589 if (isNumber(data.height)) {
10590 this.size.height = data.height;
10591 }
10592 if (isNumber(data.width)) {
10593 this.size.width = data.width;
10594 }
10595 },
10596
10597 _updateRatio: function( data ) {
10598
10599 var cpos = this.position,
10600 csize = this.size,
10601 a = this.axis;
10602
10603 if (isNumber(data.height)) {
10604 data.width = (data.height * this.aspectRatio);
10605 } else if (isNumber(data.width)) {
10606 data.height = (data.width / this.aspectRatio);
10607 }
10608
10609 if (a === "sw") {
10610 data.left = cpos.left + (csize.width - data.width);
10611 data.top = null;
10612 }
10613 if (a === "nw") {
10614 data.top = cpos.top + (csize.height - data.height);
10615 data.left = cpos.left + (csize.width - data.width);
10616 }
10617
10618 return data;
10619 },
10620
10621 _respectSize: function( data ) {
10622
10623 var o = this._vBoundaries,
10624 a = this.axis,
10625 ismaxw = isNumber(data.width) && o.maxWidth && (o.maxWidth < data.width), ismaxh = isNumber(data.height) && o.maxHeight && (o.maxHeight < data.height),
10626 isminw = isNumber(data.width) && o.minWidth && (o.minWidth > data.width), isminh = isNumber(data.height) && o.minHeight && (o.minHeight > data.height),
10627 dw = this.originalPosition.left + this.originalSize.width,
10628 dh = this.position.top + this.size.height,
10629 cw = /sw|nw|w/.test(a), ch = /nw|ne|n/.test(a);
10630 if (isminw) {
10631 data.width = o.minWidth;
10632 }
10633 if (isminh) {
10634 data.height = o.minHeight;
10635 }
10636 if (ismaxw) {
10637 data.width = o.maxWidth;
10638 }
10639 if (ismaxh) {
10640 data.height = o.maxHeight;
10641 }
10642
10643 if (isminw && cw) {
10644 data.left = dw - o.minWidth;
10645 }
10646 if (ismaxw && cw) {
10647 data.left = dw - o.maxWidth;
10648 }
10649 if (isminh && ch) {
10650 data.top = dh - o.minHeight;
10651 }
10652 if (ismaxh && ch) {
10653 data.top = dh - o.maxHeight;
10654 }
10655
10656 // fixing jump error on top/left - bug #2330
10657 if (!data.width && !data.height && !data.left && data.top) {
10658 data.top = null;
10659 } else if (!data.width && !data.height && !data.top && data.left) {
10660 data.left = null;
10661 }
10662
10663 return data;
10664 },
10665
10666 _proportionallyResize: function() {
10667
10668 if (!this._proportionallyResizeElements.length) {
10669 return;
10670 }
10671
10672 var i, j, borders, paddings, prel,
10673 element = this.helper || this.element;
10674
10675 for ( i=0; i < this._proportionallyResizeElements.length; i++) {
10676
10677 prel = this._proportionallyResizeElements[i];
10678
10679 if (!this.borderDif) {
10680 this.borderDif = [];
10681 borders = [prel.css("borderTopWidth"), prel.css("borderRightWidth"), prel.css("borderBottomWidth"), prel.css("borderLeftWidth")];
10682 paddings = [prel.css("paddingTop"), prel.css("paddingRight"), prel.css("paddingBottom"), prel.css("paddingLeft")];
10683
10684 for ( j = 0; j < borders.length; j++ ) {
10685 this.borderDif[ j ] = ( parseInt( borders[ j ], 10 ) || 0 ) + ( parseInt( paddings[ j ], 10 ) || 0 );
10686 }
10687 }
10688
10689 prel.css({
10690 height: (element.height() - this.borderDif[0] - this.borderDif[2]) || 0,
10691 width: (element.width() - this.borderDif[1] - this.borderDif[3]) || 0
10692 });
10693
10694 }
10695
10696 },
10697
10698 _renderProxy: function() {
10699
10700 var el = this.element, o = this.options;
10701 this.elementOffset = el.offset();
10702
10703 if(this._helper) {
10704
10705 this.helper = this.helper || $("<div style='overflow:hidden;'></div>");
10706
10707 this.helper.addClass(this._helper).css({
10708 width: this.element.outerWidth() - 1,
10709 height: this.element.outerHeight() - 1,
10710 position: "absolute",
10711 left: this.elementOffset.left +"px",
10712 top: this.elementOffset.top +"px",
10713 zIndex: ++o.zIndex //TODO: Don't modify option
10714 });
10715
10716 this.helper
10717 .appendTo("body")
10718 .disableSelection();
10719
10720 } else {
10721 this.helper = this.element;
10722 }
10723
10724 },
10725
10726 _change: {
10727 e: function(event, dx) {
10728 return { width: this.originalSize.width + dx };
10729 },
10730 w: function(event, dx) {
10731 var cs = this.originalSize, sp = this.originalPosition;
10732 return { left: sp.left + dx, width: cs.width - dx };
10733 },
10734 n: function(event, dx, dy) {
10735 var cs = this.originalSize, sp = this.originalPosition;
10736 return { top: sp.top + dy, height: cs.height - dy };
10737 },
10738 s: function(event, dx, dy) {
10739 return { height: this.originalSize.height + dy };
10740 },
10741 se: function(event, dx, dy) {
10742 return $.extend(this._change.s.apply(this, arguments), this._change.e.apply(this, [event, dx, dy]));
10743 },
10744 sw: function(event, dx, dy) {
10745 return $.extend(this._change.s.apply(this, arguments), this._change.w.apply(this, [event, dx, dy]));
10746 },
10747 ne: function(event, dx, dy) {
10748 return $.extend(this._change.n.apply(this, arguments), this._change.e.apply(this, [event, dx, dy]));
10749 },
10750 nw: function(event, dx, dy) {
10751 return $.extend(this._change.n.apply(this, arguments), this._change.w.apply(this, [event, dx, dy]));
10752 }
10753 },
10754
10755 _propagate: function(n, event) {
10756 $.ui.plugin.call(this, n, [event, this.ui()]);
10757 (n !== "resize" && this._trigger(n, event, this.ui()));
10758 },
10759
10760 plugins: {},
10761
10762 ui: function() {
10763 return {
10764 originalElement: this.originalElement,
10765 element: this.element,
10766 helper: this.helper,
10767 position: this.position,
10768 size: this.size,
10769 originalSize: this.originalSize,
10770 originalPosition: this.originalPosition
10771 };
10772 }
10773
10774 });
10775
10776 /*
10777 * Resizable Extensions
10778 */
10779
10780 $.ui.plugin.add("resizable", "animate", {
10781
10782 stop: function( event ) {
10783 var that = $(this).data("ui-resizable"),
10784 o = that.options,
10785 pr = that._proportionallyResizeElements,
10786 ista = pr.length && (/textarea/i).test(pr[0].nodeName),
10787 soffseth = ista && $.ui.hasScroll(pr[0], "left") /* TODO - jump height */ ? 0 : that.sizeDiff.height,
10788 soffsetw = ista ? 0 : that.sizeDiff.width,
10789 style = { width: (that.size.width - soffsetw), height: (that.size.height - soffseth) },
10790 left = (parseInt(that.element.css("left"), 10) + (that.position.left - that.originalPosition.left)) || null,
10791 top = (parseInt(that.element.css("top"), 10) + (that.position.top - that.originalPosition.top)) || null;
10792
10793 that.element.animate(
10794 $.extend(style, top && left ? { top: top, left: left } : {}), {
10795 duration: o.animateDuration,
10796 easing: o.animateEasing,
10797 step: function() {
10798
10799 var data = {
10800 width: parseInt(that.element.css("width"), 10),
10801 height: parseInt(that.element.css("height"), 10),
10802 top: parseInt(that.element.css("top"), 10),
10803 left: parseInt(that.element.css("left"), 10)
10804 };
10805
10806 if (pr && pr.length) {
10807 $(pr[0]).css({ width: data.width, height: data.height });
10808 }
10809
10810 // propagating resize, and updating values for each animation step
10811 that._updateCache(data);
10812 that._propagate("resize", event);
10813
10814 }
10815 }
10816 );
10817 }
10818
10819 });
10820
10821 $.ui.plugin.add("resizable", "containment", {
10822
10823 start: function() {
10824 var element, p, co, ch, cw, width, height,
10825 that = $(this).data("ui-resizable"),
10826 o = that.options,
10827 el = that.element,
10828 oc = o.containment,
10829 ce = (oc instanceof $) ? oc.get(0) : (/parent/.test(oc)) ? el.parent().get(0) : oc;
10830
10831 if (!ce) {
10832 return;
10833 }
10834
10835 that.containerElement = $(ce);
10836
10837 if (/document/.test(oc) || oc === document) {
10838 that.containerOffset = { left: 0, top: 0 };
10839 that.containerPosition = { left: 0, top: 0 };
10840
10841 that.parentData = {
10842 element: $(document), left: 0, top: 0,
10843 width: $(document).width(), height: $(document).height() || document.body.parentNode.scrollHeight
10844 };
10845 }
10846
10847 // i'm a node, so compute top, left, right, bottom
10848 else {
10849 element = $(ce);
10850 p = [];
10851 $([ "Top", "Right", "Left", "Bottom" ]).each(function(i, name) { p[i] = num(element.css("padding" + name)); });
10852
10853 that.containerOffset = element.offset();
10854 that.containerPosition = element.position();
10855 that.containerSize = { height: (element.innerHeight() - p[3]), width: (element.innerWidth() - p[1]) };
10856
10857 co = that.containerOffset;
10858 ch = that.containerSize.height;
10859 cw = that.containerSize.width;
10860 width = ($.ui.hasScroll(ce, "left") ? ce.scrollWidth : cw );
10861 height = ($.ui.hasScroll(ce) ? ce.scrollHeight : ch);
10862
10863 that.parentData = {
10864 element: ce, left: co.left, top: co.top, width: width, height: height
10865 };
10866 }
10867 },
10868
10869 resize: function( event ) {
10870 var woset, hoset, isParent, isOffsetRelative,
10871 that = $(this).data("ui-resizable"),
10872 o = that.options,
10873 co = that.containerOffset, cp = that.position,
10874 pRatio = that._aspectRatio || event.shiftKey,
10875 cop = { top:0, left:0 }, ce = that.containerElement;
10876
10877 if (ce[0] !== document && (/static/).test(ce.css("position"))) {
10878 cop = co;
10879 }
10880
10881 if (cp.left < (that._helper ? co.left : 0)) {
10882 that.size.width = that.size.width + (that._helper ? (that.position.left - co.left) : (that.position.left - cop.left));
10883 if (pRatio) {
10884 that.size.height = that.size.width / that.aspectRatio;
10885 }
10886 that.position.left = o.helper ? co.left : 0;
10887 }
10888
10889 if (cp.top < (that._helper ? co.top : 0)) {
10890 that.size.height = that.size.height + (that._helper ? (that.position.top - co.top) : that.position.top);
10891 if (pRatio) {
10892 that.size.width = that.size.height * that.aspectRatio;
10893 }
10894 that.position.top = that._helper ? co.top : 0;
10895 }
10896
10897 that.offset.left = that.parentData.left+that.position.left;
10898 that.offset.top = that.parentData.top+that.position.top;
10899
10900 woset = Math.abs( (that._helper ? that.offset.left - cop.left : (that.offset.left - cop.left)) + that.sizeDiff.width );
10901 hoset = Math.abs( (that._helper ? that.offset.top - cop.top : (that.offset.top - co.top)) + that.sizeDiff.height );
10902
10903 isParent = that.containerElement.get(0) === that.element.parent().get(0);
10904 isOffsetRelative = /relative|absolute/.test(that.containerElement.css("position"));
10905
10906 if ( isParent && isOffsetRelative ) {
10907 woset -= Math.abs( that.parentData.left );
10908 }
10909
10910 if (woset + that.size.width >= that.parentData.width) {
10911 that.size.width = that.parentData.width - woset;
10912 if (pRatio) {
10913 that.size.height = that.size.width / that.aspectRatio;
10914 }
10915 }
10916
10917 if (hoset + that.size.height >= that.parentData.height) {
10918 that.size.height = that.parentData.height - hoset;
10919 if (pRatio) {
10920 that.size.width = that.size.height * that.aspectRatio;
10921 }
10922 }
10923 },
10924
10925 stop: function(){
10926 var that = $(this).data("ui-resizable"),
10927 o = that.options,
10928 co = that.containerOffset,
10929 cop = that.containerPosition,
10930 ce = that.containerElement,
10931 helper = $(that.helper),
10932 ho = helper.offset(),
10933 w = helper.outerWidth() - that.sizeDiff.width,
10934 h = helper.outerHeight() - that.sizeDiff.height;
10935
10936 if (that._helper && !o.animate && (/relative/).test(ce.css("position"))) {
10937 $(this).css({ left: ho.left - cop.left - co.left, width: w, height: h });
10938 }
10939
10940 if (that._helper && !o.animate && (/static/).test(ce.css("position"))) {
10941 $(this).css({ left: ho.left - cop.left - co.left, width: w, height: h });
10942 }
10943
10944 }
10945 });
10946
10947 $.ui.plugin.add("resizable", "alsoResize", {
10948
10949 start: function () {
10950 var that = $(this).data("ui-resizable"),
10951 o = that.options,
10952 _store = function (exp) {
10953 $(exp).each(function() {
10954 var el = $(this);
10955 el.data("ui-resizable-alsoresize", {
10956 width: parseInt(el.width(), 10), height: parseInt(el.height(), 10),
10957 left: parseInt(el.css("left"), 10), top: parseInt(el.css("top"), 10)
10958 });
10959 });
10960 };
10961
10962 if (typeof(o.alsoResize) === "object" && !o.alsoResize.parentNode) {
10963 if (o.alsoResize.length) { o.alsoResize = o.alsoResize[0]; _store(o.alsoResize); }
10964 else { $.each(o.alsoResize, function (exp) { _store(exp); }); }
10965 }else{
10966 _store(o.alsoResize);
10967 }
10968 },
10969
10970 resize: function (event, ui) {
10971 var that = $(this).data("ui-resizable"),
10972 o = that.options,
10973 os = that.originalSize,
10974 op = that.originalPosition,
10975 delta = {
10976 height: (that.size.height - os.height) || 0, width: (that.size.width - os.width) || 0,
10977 top: (that.position.top - op.top) || 0, left: (that.position.left - op.left) || 0
10978 },
10979
10980 _alsoResize = function (exp, c) {
10981 $(exp).each(function() {
10982 var el = $(this), start = $(this).data("ui-resizable-alsoresize"), style = {},
10983 css = c && c.length ? c : el.parents(ui.originalElement[0]).length ? ["width", "height"] : ["width", "height", "top", "left"];
10984
10985 $.each(css, function (i, prop) {
10986 var sum = (start[prop]||0) + (delta[prop]||0);
10987 if (sum && sum >= 0) {
10988 style[prop] = sum || null;
10989 }
10990 });
10991
10992 el.css(style);
10993 });
10994 };
10995
10996 if (typeof(o.alsoResize) === "object" && !o.alsoResize.nodeType) {
10997 $.each(o.alsoResize, function (exp, c) { _alsoResize(exp, c); });
10998 }else{
10999 _alsoResize(o.alsoResize);
11000 }
11001 },
11002
11003 stop: function () {
11004 $(this).removeData("resizable-alsoresize");
11005 }
11006 });
11007
11008 $.ui.plugin.add("resizable", "ghost", {
11009
11010 start: function() {
11011
11012 var that = $(this).data("ui-resizable"), o = that.options, cs = that.size;
11013
11014 that.ghost = that.originalElement.clone();
11015 that.ghost
11016 .css({ opacity: 0.25, display: "block", position: "relative", height: cs.height, width: cs.width, margin: 0, left: 0, top: 0 })
11017 .addClass("ui-resizable-ghost")
11018 .addClass(typeof o.ghost === "string" ? o.ghost : "");
11019
11020 that.ghost.appendTo(that.helper);
11021
11022 },
11023
11024 resize: function(){
11025 var that = $(this).data("ui-resizable");
11026 if (that.ghost) {
11027 that.ghost.css({ position: "relative", height: that.size.height, width: that.size.width });
11028 }
11029 },
11030
11031 stop: function() {
11032 var that = $(this).data("ui-resizable");
11033 if (that.ghost && that.helper) {
11034 that.helper.get(0).removeChild(that.ghost.get(0));
11035 }
11036 }
11037
11038 });
11039
11040 $.ui.plugin.add("resizable", "grid", {
11041
11042 resize: function() {
11043 var that = $(this).data("ui-resizable"),
11044 o = that.options,
11045 cs = that.size,
11046 os = that.originalSize,
11047 op = that.originalPosition,
11048 a = that.axis,
11049 grid = typeof o.grid === "number" ? [o.grid, o.grid] : o.grid,
11050 gridX = (grid[0]||1),
11051 gridY = (grid[1]||1),
11052 ox = Math.round((cs.width - os.width) / gridX) * gridX,
11053 oy = Math.round((cs.height - os.height) / gridY) * gridY,
11054 newWidth = os.width + ox,
11055 newHeight = os.height + oy,
11056 isMaxWidth = o.maxWidth && (o.maxWidth < newWidth),
11057 isMaxHeight = o.maxHeight && (o.maxHeight < newHeight),
11058 isMinWidth = o.minWidth && (o.minWidth > newWidth),
11059 isMinHeight = o.minHeight && (o.minHeight > newHeight);
11060
11061 o.grid = grid;
11062
11063 if (isMinWidth) {
11064 newWidth = newWidth + gridX;
11065 }
11066 if (isMinHeight) {
11067 newHeight = newHeight + gridY;
11068 }
11069 if (isMaxWidth) {
11070 newWidth = newWidth - gridX;
11071 }
11072 if (isMaxHeight) {
11073 newHeight = newHeight - gridY;
11074 }
11075
11076 if (/^(se|s|e)$/.test(a)) {
11077 that.size.width = newWidth;
11078 that.size.height = newHeight;
11079 } else if (/^(ne)$/.test(a)) {
11080 that.size.width = newWidth;
11081 that.size.height = newHeight;
11082 that.position.top = op.top - oy;
11083 } else if (/^(sw)$/.test(a)) {
11084 that.size.width = newWidth;
11085 that.size.height = newHeight;
11086 that.position.left = op.left - ox;
11087 } else {
11088 if ( newHeight - gridY > 0 ) {
11089 that.size.height = newHeight;
11090 that.position.top = op.top - oy;
11091 } else {
11092 that.size.height = gridY;
11093 that.position.top = op.top + os.height - gridY;
11094 }
11095 if ( newWidth - gridX > 0 ) {
11096 that.size.width = newWidth;
11097 that.position.left = op.left - ox;
11098 } else {
11099 that.size.width = gridX;
11100 that.position.left = op.left + os.width - gridX;
11101 }
11102 }
11103 }
11104
11105 });
11106
11107 })(jQuery);
11108 (function( $, undefined ) {
11109
11110 $.widget("ui.selectable", $.ui.mouse, {
11111 version: "1.10.4",
11112 options: {
11113 appendTo: "body",
11114 autoRefresh: true,
11115 distance: 0,
11116 filter: "*",
11117 tolerance: "touch",
11118
11119 // callbacks
11120 selected: null,
11121 selecting: null,
11122 start: null,
11123 stop: null,
11124 unselected: null,
11125 unselecting: null
11126 },
11127 _create: function() {
11128 var selectees,
11129 that = this;
11130
11131 this.element.addClass("ui-selectable");
11132
11133 this.dragged = false;
11134
11135 // cache selectee children based on filter
11136 this.refresh = function() {
11137 selectees = $(that.options.filter, that.element[0]);
11138 selectees.addClass("ui-selectee");
11139 selectees.each(function() {
11140 var $this = $(this),
11141 pos = $this.offset();
11142 $.data(this, "selectable-item", {
11143 element: this,
11144 $element: $this,
11145 left: pos.left,
11146 top: pos.top,
11147 right: pos.left + $this.outerWidth(),
11148 bottom: pos.top + $this.outerHeight(),
11149 startselected: false,
11150 selected: $this.hasClass("ui-selected"),
11151 selecting: $this.hasClass("ui-selecting"),
11152 unselecting: $this.hasClass("ui-unselecting")
11153 });
11154 });
11155 };
11156 this.refresh();
11157
11158 this.selectees = selectees.addClass("ui-selectee");
11159
11160 this._mouseInit();
11161
11162 this.helper = $("<div class='ui-selectable-helper'></div>");
11163 },
11164
11165 _destroy: function() {
11166 this.selectees
11167 .removeClass("ui-selectee")
11168 .removeData("selectable-item");
11169 this.element
11170 .removeClass("ui-selectable ui-selectable-disabled");
11171 this._mouseDestroy();
11172 },
11173
11174 _mouseStart: function(event) {
11175 var that = this,
11176 options = this.options;
11177
11178 this.opos = [event.pageX, event.pageY];
11179
11180 if (this.options.disabled) {
11181 return;
11182 }
11183
11184 this.selectees = $(options.filter, this.element[0]);
11185
11186 this._trigger("start", event);
11187
11188 $(options.appendTo).append(this.helper);
11189 // position helper (lasso)
11190 this.helper.css({
11191 "left": event.pageX,
11192 "top": event.pageY,
11193 "width": 0,
11194 "height": 0
11195 });
11196
11197 if (options.autoRefresh) {
11198 this.refresh();
11199 }
11200
11201 this.selectees.filter(".ui-selected").each(function() {
11202 var selectee = $.data(this, "selectable-item");
11203 selectee.startselected = true;
11204 if (!event.metaKey && !event.ctrlKey) {
11205 selectee.$element.removeClass("ui-selected");
11206 selectee.selected = false;
11207 selectee.$element.addClass("ui-unselecting");
11208 selectee.unselecting = true;
11209 // selectable UNSELECTING callback
11210 that._trigger("unselecting", event, {
11211 unselecting: selectee.element
11212 });
11213 }
11214 });
11215
11216 $(event.target).parents().addBack().each(function() {
11217 var doSelect,
11218 selectee = $.data(this, "selectable-item");
11219 if (selectee) {
11220 doSelect = (!event.metaKey && !event.ctrlKey) || !selectee.$element.hasClass("ui-selected");
11221 selectee.$element
11222 .removeClass(doSelect ? "ui-unselecting" : "ui-selected")
11223 .addClass(doSelect ? "ui-selecting" : "ui-unselecting");
11224 selectee.unselecting = !doSelect;
11225 selectee.selecting = doSelect;
11226 selectee.selected = doSelect;
11227 // selectable (UN)SELECTING callback
11228 if (doSelect) {
11229 that._trigger("selecting", event, {
11230 selecting: selectee.element
11231 });
11232 } else {
11233 that._trigger("unselecting", event, {
11234 unselecting: selectee.element
11235 });
11236 }
11237 return false;
11238 }
11239 });
11240
11241 },
11242
11243 _mouseDrag: function(event) {
11244
11245 this.dragged = true;
11246
11247 if (this.options.disabled) {
11248 return;
11249 }
11250
11251 var tmp,
11252 that = this,
11253 options = this.options,
11254 x1 = this.opos[0],
11255 y1 = this.opos[1],
11256 x2 = event.pageX,
11257 y2 = event.pageY;
11258
11259 if (x1 > x2) { tmp = x2; x2 = x1; x1 = tmp; }
11260 if (y1 > y2) { tmp = y2; y2 = y1; y1 = tmp; }
11261 this.helper.css({left: x1, top: y1, width: x2-x1, height: y2-y1});
11262
11263 this.selectees.each(function() {
11264 var selectee = $.data(this, "selectable-item"),
11265 hit = false;
11266
11267 //prevent helper from being selected if appendTo: selectable
11268 if (!selectee || selectee.element === that.element[0]) {
11269 return;
11270 }
11271
11272 if (options.tolerance === "touch") {
11273 hit = ( !(selectee.left > x2 || selectee.right < x1 || selectee.top > y2 || selectee.bottom < y1) );
11274 } else if (options.tolerance === "fit") {
11275 hit = (selectee.left > x1 && selectee.right < x2 && selectee.top > y1 && selectee.bottom < y2);
11276 }
11277
11278 if (hit) {
11279 // SELECT
11280 if (selectee.selected) {
11281 selectee.$element.removeClass("ui-selected");
11282 selectee.selected = false;
11283 }
11284 if (selectee.unselecting) {
11285 selectee.$element.removeClass("ui-unselecting");
11286 selectee.unselecting = false;
11287 }
11288 if (!selectee.selecting) {
11289 selectee.$element.addClass("ui-selecting");
11290 selectee.selecting = true;
11291 // selectable SELECTING callback
11292 that._trigger("selecting", event, {
11293 selecting: selectee.element
11294 });
11295 }
11296 } else {
11297 // UNSELECT
11298 if (selectee.selecting) {
11299 if ((event.metaKey || event.ctrlKey) && selectee.startselected) {
11300 selectee.$element.removeClass("ui-selecting");
11301 selectee.selecting = false;
11302 selectee.$element.addClass("ui-selected");
11303 selectee.selected = true;
11304 } else {
11305 selectee.$element.removeClass("ui-selecting");
11306 selectee.selecting = false;
11307 if (selectee.startselected) {
11308 selectee.$element.addClass("ui-unselecting");
11309 selectee.unselecting = true;
11310 }
11311 // selectable UNSELECTING callback
11312 that._trigger("unselecting", event, {
11313 unselecting: selectee.element
11314 });
11315 }
11316 }
11317 if (selectee.selected) {
11318 if (!event.metaKey && !event.ctrlKey && !selectee.startselected) {
11319 selectee.$element.removeClass("ui-selected");
11320 selectee.selected = false;
11321
11322 selectee.$element.addClass("ui-unselecting");
11323 selectee.unselecting = true;
11324 // selectable UNSELECTING callback
11325 that._trigger("unselecting", event, {
11326 unselecting: selectee.element
11327 });
11328 }
11329 }
11330 }
11331 });
11332
11333 return false;
11334 },
11335
11336 _mouseStop: function(event) {
11337 var that = this;
11338
11339 this.dragged = false;
11340
11341 $(".ui-unselecting", this.element[0]).each(function() {
11342 var selectee = $.data(this, "selectable-item");
11343 selectee.$element.removeClass("ui-unselecting");
11344 selectee.unselecting = false;
11345 selectee.startselected = false;
11346 that._trigger("unselected", event, {
11347 unselected: selectee.element
11348 });
11349 });
11350 $(".ui-selecting", this.element[0]).each(function() {
11351 var selectee = $.data(this, "selectable-item");
11352 selectee.$element.removeClass("ui-selecting").addClass("ui-selected");
11353 selectee.selecting = false;
11354 selectee.selected = true;
11355 selectee.startselected = true;
11356 that._trigger("selected", event, {
11357 selected: selectee.element
11358 });
11359 });
11360 this._trigger("stop", event);
11361
11362 this.helper.remove();
11363
11364 return false;
11365 }
11366
11367 });
11368
11369 })(jQuery);
11370 (function( $, undefined ) {
11371
11372 // number of pages in a slider
11373 // (how many times can you page up/down to go through the whole range)
11374 var numPages = 5;
11375
11376 $.widget( "ui.slider", $.ui.mouse, {
11377 version: "1.10.4",
11378 widgetEventPrefix: "slide",
11379
11380 options: {
11381 animate: false,
11382 distance: 0,
11383 max: 100,
11384 min: 0,
11385 orientation: "horizontal",
11386 range: false,
11387 step: 1,
11388 value: 0,
11389 values: null,
11390
11391 // callbacks
11392 change: null,
11393 slide: null,
11394 start: null,
11395 stop: null
11396 },
11397
11398 _create: function() {
11399 this._keySliding = false;
11400 this._mouseSliding = false;
11401 this._animateOff = true;
11402 this._handleIndex = null;
11403 this._detectOrientation();
11404 this._mouseInit();
11405
11406 this.element
11407 .addClass( "ui-slider" +
11408 " ui-slider-" + this.orientation +
11409 " ui-widget" +
11410 " ui-widget-content" +
11411 " ui-corner-all");
11412
11413 this._refresh();
11414 this._setOption( "disabled", this.options.disabled );
11415
11416 this._animateOff = false;
11417 },
11418
11419 _refresh: function() {
11420 this._createRange();
11421 this._createHandles();
11422 this._setupEvents();
11423 this._refreshValue();
11424 },
11425
11426 _createHandles: function() {
11427 var i, handleCount,
11428 options = this.options,
11429 existingHandles = this.element.find( ".ui-slider-handle" ).addClass( "ui-state-default ui-corner-all" ),
11430 handle = "<a class='ui-slider-handle ui-state-default ui-corner-all' href='#'></a>",
11431 handles = [];
11432
11433 handleCount = ( options.values && options.values.length ) || 1;
11434
11435 if ( existingHandles.length > handleCount ) {
11436 existingHandles.slice( handleCount ).remove();
11437 existingHandles = existingHandles.slice( 0, handleCount );
11438 }
11439
11440 for ( i = existingHandles.length; i < handleCount; i++ ) {
11441 handles.push( handle );
11442 }
11443
11444 this.handles = existingHandles.add( $( handles.join( "" ) ).appendTo( this.element ) );
11445
11446 this.handle = this.handles.eq( 0 );
11447
11448 this.handles.each(function( i ) {
11449 $( this ).data( "ui-slider-handle-index", i );
11450 });
11451 },
11452
11453 _createRange: function() {
11454 var options = this.options,
11455 classes = "";
11456
11457 if ( options.range ) {
11458 if ( options.range === true ) {
11459 if ( !options.values ) {
11460 options.values = [ this._valueMin(), this._valueMin() ];
11461 } else if ( options.values.length && options.values.length !== 2 ) {
11462 options.values = [ options.values[0], options.values[0] ];
11463 } else if ( $.isArray( options.values ) ) {
11464 options.values = options.values.slice(0);
11465 }
11466 }
11467
11468 if ( !this.range || !this.range.length ) {
11469 this.range = $( "<div></div>" )
11470 .appendTo( this.element );
11471
11472 classes = "ui-slider-range" +
11473 // note: this isn't the most fittingly semantic framework class for this element,
11474 // but worked best visually with a variety of themes
11475 " ui-widget-header ui-corner-all";
11476 } else {
11477 this.range.removeClass( "ui-slider-range-min ui-slider-range-max" )
11478 // Handle range switching from true to min/max
11479 .css({
11480 "left": "",
11481 "bottom": ""
11482 });
11483 }
11484
11485 this.range.addClass( classes +
11486 ( ( options.range === "min" || options.range === "max" ) ? " ui-slider-range-" + options.range : "" ) );
11487 } else {
11488 if ( this.range ) {
11489 this.range.remove();
11490 }
11491 this.range = null;
11492 }
11493 },
11494
11495 _setupEvents: function() {
11496 var elements = this.handles.add( this.range ).filter( "a" );
11497 this._off( elements );
11498 this._on( elements, this._handleEvents );
11499 this._hoverable( elements );
11500 this._focusable( elements );
11501 },
11502
11503 _destroy: function() {
11504 this.handles.remove();
11505 if ( this.range ) {
11506 this.range.remove();
11507 }
11508
11509 this.element
11510 .removeClass( "ui-slider" +
11511 " ui-slider-horizontal" +
11512 " ui-slider-vertical" +
11513 " ui-widget" +
11514 " ui-widget-content" +
11515 " ui-corner-all" );
11516
11517 this._mouseDestroy();
11518 },
11519
11520 _mouseCapture: function( event ) {
11521 var position, normValue, distance, closestHandle, index, allowed, offset, mouseOverHandle,
11522 that = this,
11523 o = this.options;
11524
11525 if ( o.disabled ) {
11526 return false;
11527 }
11528
11529 this.elementSize = {
11530 width: this.element.outerWidth(),
11531 height: this.element.outerHeight()
11532 };
11533 this.elementOffset = this.element.offset();
11534
11535 position = { x: event.pageX, y: event.pageY };
11536 normValue = this._normValueFromMouse( position );
11537 distance = this._valueMax() - this._valueMin() + 1;
11538 this.handles.each(function( i ) {
11539 var thisDistance = Math.abs( normValue - that.values(i) );
11540 if (( distance > thisDistance ) ||
11541 ( distance === thisDistance &&
11542 (i === that._lastChangedValue || that.values(i) === o.min ))) {
11543 distance = thisDistance;
11544 closestHandle = $( this );
11545 index = i;
11546 }
11547 });
11548
11549 allowed = this._start( event, index );
11550 if ( allowed === false ) {
11551 return false;
11552 }
11553 this._mouseSliding = true;
11554
11555 this._handleIndex = index;
11556
11557 closestHandle
11558 .addClass( "ui-state-active" )
11559 .focus();
11560
11561 offset = closestHandle.offset();
11562 mouseOverHandle = !$( event.target ).parents().addBack().is( ".ui-slider-handle" );
11563 this._clickOffset = mouseOverHandle ? { left: 0, top: 0 } : {
11564 left: event.pageX - offset.left - ( closestHandle.width() / 2 ),
11565 top: event.pageY - offset.top -
11566 ( closestHandle.height() / 2 ) -
11567 ( parseInt( closestHandle.css("borderTopWidth"), 10 ) || 0 ) -
11568 ( parseInt( closestHandle.css("borderBottomWidth"), 10 ) || 0) +
11569 ( parseInt( closestHandle.css("marginTop"), 10 ) || 0)
11570 };
11571
11572 if ( !this.handles.hasClass( "ui-state-hover" ) ) {
11573 this._slide( event, index, normValue );
11574 }
11575 this._animateOff = true;
11576 return true;
11577 },
11578
11579 _mouseStart: function() {
11580 return true;
11581 },
11582
11583 _mouseDrag: function( event ) {
11584 var position = { x: event.pageX, y: event.pageY },
11585 normValue = this._normValueFromMouse( position );
11586
11587 this._slide( event, this._handleIndex, normValue );
11588
11589 return false;
11590 },
11591
11592 _mouseStop: function( event ) {
11593 this.handles.removeClass( "ui-state-active" );
11594 this._mouseSliding = false;
11595
11596 this._stop( event, this._handleIndex );
11597 this._change( event, this._handleIndex );
11598
11599 this._handleIndex = null;
11600 this._clickOffset = null;
11601 this._animateOff = false;
11602
11603 return false;
11604 },
11605
11606 _detectOrientation: function() {
11607 this.orientation = ( this.options.orientation === "vertical" ) ? "vertical" : "horizontal";
11608 },
11609
11610 _normValueFromMouse: function( position ) {
11611 var pixelTotal,
11612 pixelMouse,
11613 percentMouse,
11614 valueTotal,
11615 valueMouse;
11616
11617 if ( this.orientation === "horizontal" ) {
11618 pixelTotal = this.elementSize.width;
11619 pixelMouse = position.x - this.elementOffset.left - ( this._clickOffset ? this._clickOffset.left : 0 );
11620 } else {
11621 pixelTotal = this.elementSize.height;
11622 pixelMouse = position.y - this.elementOffset.top - ( this._clickOffset ? this._clickOffset.top : 0 );
11623 }
11624
11625 percentMouse = ( pixelMouse / pixelTotal );
11626 if ( percentMouse > 1 ) {
11627 percentMouse = 1;
11628 }
11629 if ( percentMouse < 0 ) {
11630 percentMouse = 0;
11631 }
11632 if ( this.orientation === "vertical" ) {
11633 percentMouse = 1 - percentMouse;
11634 }
11635
11636 valueTotal = this._valueMax() - this._valueMin();
11637 valueMouse = this._valueMin() + percentMouse * valueTotal;
11638
11639 return this._trimAlignValue( valueMouse );
11640 },
11641
11642 _start: function( event, index ) {
11643 var uiHash = {
11644 handle: this.handles[ index ],
11645 value: this.value()
11646 };
11647 if ( this.options.values && this.options.values.length ) {
11648 uiHash.value = this.values( index );
11649 uiHash.values = this.values();
11650 }
11651 return this._trigger( "start", event, uiHash );
11652 },
11653
11654 _slide: function( event, index, newVal ) {
11655 var otherVal,
11656 newValues,
11657 allowed;
11658
11659 if ( this.options.values && this.options.values.length ) {
11660 otherVal = this.values( index ? 0 : 1 );
11661
11662 if ( ( this.options.values.length === 2 && this.options.range === true ) &&
11663 ( ( index === 0 && newVal > otherVal) || ( index === 1 && newVal < otherVal ) )
11664 ) {
11665 newVal = otherVal;
11666 }
11667
11668 if ( newVal !== this.values( index ) ) {
11669 newValues = this.values();
11670 newValues[ index ] = newVal;
11671 // A slide can be canceled by returning false from the slide callback
11672 allowed = this._trigger( "slide", event, {
11673 handle: this.handles[ index ],
11674 value: newVal,
11675 values: newValues
11676 } );
11677 otherVal = this.values( index ? 0 : 1 );
11678 if ( allowed !== false ) {
11679 this.values( index, newVal );
11680 }
11681 }
11682 } else {
11683 if ( newVal !== this.value() ) {
11684 // A slide can be canceled by returning false from the slide callback
11685 allowed = this._trigger( "slide", event, {
11686 handle: this.handles[ index ],
11687 value: newVal
11688 } );
11689 if ( allowed !== false ) {
11690 this.value( newVal );
11691 }
11692 }
11693 }
11694 },
11695
11696 _stop: function( event, index ) {
11697 var uiHash = {
11698 handle: this.handles[ index ],
11699 value: this.value()
11700 };
11701 if ( this.options.values && this.options.values.length ) {
11702 uiHash.value = this.values( index );
11703 uiHash.values = this.values();
11704 }
11705
11706 this._trigger( "stop", event, uiHash );
11707 },
11708
11709 _change: function( event, index ) {
11710 if ( !this._keySliding && !this._mouseSliding ) {
11711 var uiHash = {
11712 handle: this.handles[ index ],
11713 value: this.value()
11714 };
11715 if ( this.options.values && this.options.values.length ) {
11716 uiHash.value = this.values( index );
11717 uiHash.values = this.values();
11718 }
11719
11720 //store the last changed value index for reference when handles overlap
11721 this._lastChangedValue = index;
11722
11723 this._trigger( "change", event, uiHash );
11724 }
11725 },
11726
11727 value: function( newValue ) {
11728 if ( arguments.length ) {
11729 this.options.value = this._trimAlignValue( newValue );
11730 this._refreshValue();
11731 this._change( null, 0 );
11732 return;
11733 }
11734
11735 return this._value();
11736 },
11737
11738 values: function( index, newValue ) {
11739 var vals,
11740 newValues,
11741 i;
11742
11743 if ( arguments.length > 1 ) {
11744 this.options.values[ index ] = this._trimAlignValue( newValue );
11745 this._refreshValue();
11746 this._change( null, index );
11747 return;
11748 }
11749
11750 if ( arguments.length ) {
11751 if ( $.isArray( arguments[ 0 ] ) ) {
11752 vals = this.options.values;
11753 newValues = arguments[ 0 ];
11754 for ( i = 0; i < vals.length; i += 1 ) {
11755 vals[ i ] = this._trimAlignValue( newValues[ i ] );
11756 this._change( null, i );
11757 }
11758 this._refreshValue();
11759 } else {
11760 if ( this.options.values && this.options.values.length ) {
11761 return this._values( index );
11762 } else {
11763 return this.value();
11764 }
11765 }
11766 } else {
11767 return this._values();
11768 }
11769 },
11770
11771 _setOption: function( key, value ) {
11772 var i,
11773 valsLength = 0;
11774
11775 if ( key === "range" && this.options.range === true ) {
11776 if ( value === "min" ) {
11777 this.options.value = this._values( 0 );
11778 this.options.values = null;
11779 } else if ( value === "max" ) {
11780 this.options.value = this._values( this.options.values.length-1 );
11781 this.options.values = null;
11782 }
11783 }
11784
11785 if ( $.isArray( this.options.values ) ) {
11786 valsLength = this.options.values.length;
11787 }
11788
11789 $.Widget.prototype._setOption.apply( this, arguments );
11790
11791 switch ( key ) {
11792 case "orientation":
11793 this._detectOrientation();
11794 this.element
11795 .removeClass( "ui-slider-horizontal ui-slider-vertical" )
11796 .addClass( "ui-slider-" + this.orientation );
11797 this._refreshValue();
11798 break;
11799 case "value":
11800 this._animateOff = true;
11801 this._refreshValue();
11802 this._change( null, 0 );
11803 this._animateOff = false;
11804 break;
11805 case "values":
11806 this._animateOff = true;
11807 this._refreshValue();
11808 for ( i = 0; i < valsLength; i += 1 ) {
11809 this._change( null, i );
11810 }
11811 this._animateOff = false;
11812 break;
11813 case "min":
11814 case "max":
11815 this._animateOff = true;
11816 this._refreshValue();
11817 this._animateOff = false;
11818 break;
11819 case "range":
11820 this._animateOff = true;
11821 this._refresh();
11822 this._animateOff = false;
11823 break;
11824 }
11825 },
11826
11827 //internal value getter
11828 // _value() returns value trimmed by min and max, aligned by step
11829 _value: function() {
11830 var val = this.options.value;
11831 val = this._trimAlignValue( val );
11832
11833 return val;
11834 },
11835
11836 //internal values getter
11837 // _values() returns array of values trimmed by min and max, aligned by step
11838 // _values( index ) returns single value trimmed by min and max, aligned by step
11839 _values: function( index ) {
11840 var val,
11841 vals,
11842 i;
11843
11844 if ( arguments.length ) {
11845 val = this.options.values[ index ];
11846 val = this._trimAlignValue( val );
11847
11848 return val;
11849 } else if ( this.options.values && this.options.values.length ) {
11850 // .slice() creates a copy of the array
11851 // this copy gets trimmed by min and max and then returned
11852 vals = this.options.values.slice();
11853 for ( i = 0; i < vals.length; i+= 1) {
11854 vals[ i ] = this._trimAlignValue( vals[ i ] );
11855 }
11856
11857 return vals;
11858 } else {
11859 return [];
11860 }
11861 },
11862
11863 // returns the step-aligned value that val is closest to, between (inclusive) min and max
11864 _trimAlignValue: function( val ) {
11865 if ( val <= this._valueMin() ) {
11866 return this._valueMin();
11867 }
11868 if ( val >= this._valueMax() ) {
11869 return this._valueMax();
11870 }
11871 var step = ( this.options.step > 0 ) ? this.options.step : 1,
11872 valModStep = (val - this._valueMin()) % step,
11873 alignValue = val - valModStep;
11874
11875 if ( Math.abs(valModStep) * 2 >= step ) {
11876 alignValue += ( valModStep > 0 ) ? step : ( -step );
11877 }
11878
11879 // Since JavaScript has problems with large floats, round
11880 // the final value to 5 digits after the decimal point (see #4124)
11881 return parseFloat( alignValue.toFixed(5) );
11882 },
11883
11884 _valueMin: function() {
11885 return this.options.min;
11886 },
11887
11888 _valueMax: function() {
11889 return this.options.max;
11890 },
11891
11892 _refreshValue: function() {
11893 var lastValPercent, valPercent, value, valueMin, valueMax,
11894 oRange = this.options.range,
11895 o = this.options,
11896 that = this,
11897 animate = ( !this._animateOff ) ? o.animate : false,
11898 _set = {};
11899
11900 if ( this.options.values && this.options.values.length ) {
11901 this.handles.each(function( i ) {
11902 valPercent = ( that.values(i) - that._valueMin() ) / ( that._valueMax() - that._valueMin() ) * 100;
11903 _set[ that.orientation === "horizontal" ? "left" : "bottom" ] = valPercent + "%";
11904 $( this ).stop( 1, 1 )[ animate ? "animate" : "css" ]( _set, o.animate );
11905 if ( that.options.range === true ) {
11906 if ( that.orientation === "horizontal" ) {
11907 if ( i === 0 ) {
11908 that.range.stop( 1, 1 )[ animate ? "animate" : "css" ]( { left: valPercent + "%" }, o.animate );
11909 }
11910 if ( i === 1 ) {
11911 that.range[ animate ? "animate" : "css" ]( { width: ( valPercent - lastValPercent ) + "%" }, { queue: false, duration: o.animate } );
11912 }
11913 } else {
11914 if ( i === 0 ) {
11915 that.range.stop( 1, 1 )[ animate ? "animate" : "css" ]( { bottom: ( valPercent ) + "%" }, o.animate );
11916 }
11917 if ( i === 1 ) {
11918 that.range[ animate ? "animate" : "css" ]( { height: ( valPercent - lastValPercent ) + "%" }, { queue: false, duration: o.animate } );
11919 }
11920 }
11921 }
11922 lastValPercent = valPercent;
11923 });
11924 } else {
11925 value = this.value();
11926 valueMin = this._valueMin();
11927 valueMax = this._valueMax();
11928 valPercent = ( valueMax !== valueMin ) ?
11929 ( value - valueMin ) / ( valueMax - valueMin ) * 100 :
11930 0;
11931 _set[ this.orientation === "horizontal" ? "left" : "bottom" ] = valPercent + "%";
11932 this.handle.stop( 1, 1 )[ animate ? "animate" : "css" ]( _set, o.animate );
11933
11934 if ( oRange === "min" && this.orientation === "horizontal" ) {
11935 this.range.stop( 1, 1 )[ animate ? "animate" : "css" ]( { width: valPercent + "%" }, o.animate );
11936 }
11937 if ( oRange === "max" && this.orientation === "horizontal" ) {
11938 this.range[ animate ? "animate" : "css" ]( { width: ( 100 - valPercent ) + "%" }, { queue: false, duration: o.animate } );
11939 }
11940 if ( oRange === "min" && this.orientation === "vertical" ) {
11941 this.range.stop( 1, 1 )[ animate ? "animate" : "css" ]( { height: valPercent + "%" }, o.animate );
11942 }
11943 if ( oRange === "max" && this.orientation === "vertical" ) {
11944 this.range[ animate ? "animate" : "css" ]( { height: ( 100 - valPercent ) + "%" }, { queue: false, duration: o.animate } );
11945 }
11946 }
11947 },
11948
11949 _handleEvents: {
11950 keydown: function( event ) {
11951 var allowed, curVal, newVal, step,
11952 index = $( event.target ).data( "ui-slider-handle-index" );
11953
11954 switch ( event.keyCode ) {
11955 case $.ui.keyCode.HOME:
11956 case $.ui.keyCode.END:
11957 case $.ui.keyCode.PAGE_UP:
11958 case $.ui.keyCode.PAGE_DOWN:
11959 case $.ui.keyCode.UP:
11960 case $.ui.keyCode.RIGHT:
11961 case $.ui.keyCode.DOWN:
11962 case $.ui.keyCode.LEFT:
11963 event.preventDefault();
11964 if ( !this._keySliding ) {
11965 this._keySliding = true;
11966 $( event.target ).addClass( "ui-state-active" );
11967 allowed = this._start( event, index );
11968 if ( allowed === false ) {
11969 return;
11970 }
11971 }
11972 break;
11973 }
11974
11975 step = this.options.step;
11976 if ( this.options.values && this.options.values.length ) {
11977 curVal = newVal = this.values( index );
11978 } else {
11979 curVal = newVal = this.value();
11980 }
11981
11982 switch ( event.keyCode ) {
11983 case $.ui.keyCode.HOME:
11984 newVal = this._valueMin();
11985 break;
11986 case $.ui.keyCode.END:
11987 newVal = this._valueMax();
11988 break;
11989 case $.ui.keyCode.PAGE_UP:
11990 newVal = this._trimAlignValue( curVal + ( (this._valueMax() - this._valueMin()) / numPages ) );
11991 break;
11992 case $.ui.keyCode.PAGE_DOWN:
11993 newVal = this._trimAlignValue( curVal - ( (this._valueMax() - this._valueMin()) / numPages ) );
11994 break;
11995 case $.ui.keyCode.UP:
11996 case $.ui.keyCode.RIGHT:
11997 if ( curVal === this._valueMax() ) {
11998 return;
11999 }
12000 newVal = this._trimAlignValue( curVal + step );
12001 break;
12002 case $.ui.keyCode.DOWN:
12003 case $.ui.keyCode.LEFT:
12004 if ( curVal === this._valueMin() ) {
12005 return;
12006 }
12007 newVal = this._trimAlignValue( curVal - step );
12008 break;
12009 }
12010
12011 this._slide( event, index, newVal );
12012 },
12013 click: function( event ) {
12014 event.preventDefault();
12015 },
12016 keyup: function( event ) {
12017 var index = $( event.target ).data( "ui-slider-handle-index" );
12018
12019 if ( this._keySliding ) {
12020 this._keySliding = false;
12021 this._stop( event, index );
12022 this._change( event, index );
12023 $( event.target ).removeClass( "ui-state-active" );
12024 }
12025 }
12026 }
12027
12028 });
12029
12030 }(jQuery));
12031 (function( $, undefined ) {
12032
12033 function isOverAxis( x, reference, size ) {
12034 return ( x > reference ) && ( x < ( reference + size ) );
12035 }
12036
12037 function isFloating(item) {
12038 return (/left|right/).test(item.css("float")) || (/inline|table-cell/).test(item.css("display"));
12039 }
12040
12041 $.widget("ui.sortable", $.ui.mouse, {
12042 version: "1.10.4",
12043 widgetEventPrefix: "sort",
12044 ready: false,
12045 options: {
12046 appendTo: "parent",
12047 axis: false,
12048 connectWith: false,
12049 containment: false,
12050 cursor: "auto",
12051 cursorAt: false,
12052 dropOnEmpty: true,
12053 forcePlaceholderSize: false,
12054 forceHelperSize: false,
12055 grid: false,
12056 handle: false,
12057 helper: "original",
12058 items: "> *",
12059 opacity: false,
12060 placeholder: false,
12061 revert: false,
12062 scroll: true,
12063 scrollSensitivity: 20,
12064 scrollSpeed: 20,
12065 scope: "default",
12066 tolerance: "intersect",
12067 zIndex: 1000,
12068
12069 // callbacks
12070 activate: null,
12071 beforeStop: null,
12072 change: null,
12073 deactivate: null,
12074 out: null,
12075 over: null,
12076 receive: null,
12077 remove: null,
12078 sort: null,
12079 start: null,
12080 stop: null,
12081 update: null
12082 },
12083 _create: function() {
12084
12085 var o = this.options;
12086 this.containerCache = {};
12087 this.element.addClass("ui-sortable");
12088
12089 //Get the items
12090 this.refresh();
12091
12092 //Let's determine if the items are being displayed horizontally
12093 this.floating = this.items.length ? o.axis === "x" || isFloating(this.items[0].item) : false;
12094
12095 //Let's determine the parent's offset
12096 this.offset = this.element.offset();
12097
12098 //Initialize mouse events for interaction
12099 this._mouseInit();
12100
12101 //We're ready to go
12102 this.ready = true;
12103
12104 },
12105
12106 _destroy: function() {
12107 this.element
12108 .removeClass("ui-sortable ui-sortable-disabled");
12109 this._mouseDestroy();
12110
12111 for ( var i = this.items.length - 1; i >= 0; i-- ) {
12112 this.items[i].item.removeData(this.widgetName + "-item");
12113 }
12114
12115 return this;
12116 },
12117
12118 _setOption: function(key, value){
12119 if ( key === "disabled" ) {
12120 this.options[ key ] = value;
12121
12122 this.widget().toggleClass( "ui-sortable-disabled", !!value );
12123 } else {
12124 // Don't call widget base _setOption for disable as it adds ui-state-disabled class
12125 $.Widget.prototype._setOption.apply(this, arguments);
12126 }
12127 },
12128
12129 _mouseCapture: function(event, overrideHandle) {
12130 var currentItem = null,
12131 validHandle = false,
12132 that = this;
12133
12134 if (this.reverting) {
12135 return false;
12136 }
12137
12138 if(this.options.disabled || this.options.type === "static") {
12139 return false;
12140 }
12141
12142 //We have to refresh the items data once first
12143 this._refreshItems(event);
12144
12145 //Find out if the clicked node (or one of its parents) is a actual item in this.items
12146 $(event.target).parents().each(function() {
12147 if($.data(this, that.widgetName + "-item") === that) {
12148 currentItem = $(this);
12149 return false;
12150 }
12151 });
12152 if($.data(event.target, that.widgetName + "-item") === that) {
12153 currentItem = $(event.target);
12154 }
12155
12156 if(!currentItem) {
12157 return false;
12158 }
12159 if(this.options.handle && !overrideHandle) {
12160 $(this.options.handle, currentItem).find("*").addBack().each(function() {
12161 if(this === event.target) {
12162 validHandle = true;
12163 }
12164 });
12165 if(!validHandle) {
12166 return false;
12167 }
12168 }
12169
12170 this.currentItem = currentItem;
12171 this._removeCurrentsFromItems();
12172 return true;
12173
12174 },
12175
12176 _mouseStart: function(event, overrideHandle, noActivation) {
12177
12178 var i, body,
12179 o = this.options;
12180
12181 this.currentContainer = this;
12182
12183 //We only need to call refreshPositions, because the refreshItems call has been moved to mouseCapture
12184 this.refreshPositions();
12185
12186 //Create and append the visible helper
12187 this.helper = this._createHelper(event);
12188
12189 //Cache the helper size
12190 this._cacheHelperProportions();
12191
12192 /*
12193 * - Position generation -
12194 * This block generates everything position related - it's the core of draggables.
12195 */
12196
12197 //Cache the margins of the original element
12198 this._cacheMargins();
12199
12200 //Get the next scrolling parent
12201 this.scrollParent = this.helper.scrollParent();
12202
12203 //The element's absolute position on the page minus margins
12204 this.offset = this.currentItem.offset();
12205 this.offset = {
12206 top: this.offset.top - this.margins.top,
12207 left: this.offset.left - this.margins.left
12208 };
12209
12210 $.extend(this.offset, {
12211 click: { //Where the click happened, relative to the element
12212 left: event.pageX - this.offset.left,
12213 top: event.pageY - this.offset.top
12214 },
12215 parent: this._getParentOffset(),
12216 relative: this._getRelativeOffset() //This is a relative to absolute position minus the actual position calculation - only used for relative positioned helper
12217 });
12218
12219 // Only after we got the offset, we can change the helper's position to absolute
12220 // TODO: Still need to figure out a way to make relative sorting possible
12221 this.helper.css("position", "absolute");
12222 this.cssPosition = this.helper.css("position");
12223
12224 //Generate the original position
12225 this.originalPosition = this._generatePosition(event);
12226 this.originalPageX = event.pageX;
12227 this.originalPageY = event.pageY;
12228
12229 //Adjust the mouse offset relative to the helper if "cursorAt" is supplied
12230 (o.cursorAt && this._adjustOffsetFromHelper(o.cursorAt));
12231
12232 //Cache the former DOM position
12233 this.domPosition = { prev: this.currentItem.prev()[0], parent: this.currentItem.parent()[0] };
12234
12235 //If the helper is not the original, hide the original so it's not playing any role during the drag, won't cause anything bad this way
12236 if(this.helper[0] !== this.currentItem[0]) {
12237 this.currentItem.hide();
12238 }
12239
12240 //Create the placeholder
12241 this._createPlaceholder();
12242
12243 //Set a containment if given in the options
12244 if(o.containment) {
12245 this._setContainment();
12246 }
12247
12248 if( o.cursor && o.cursor !== "auto" ) { // cursor option
12249 body = this.document.find( "body" );
12250
12251 // support: IE
12252 this.storedCursor = body.css( "cursor" );
12253 body.css( "cursor", o.cursor );
12254
12255 this.storedStylesheet = $( "<style>*{ cursor: "+o.cursor+" !important; }</style>" ).appendTo( body );
12256 }
12257
12258 if(o.opacity) { // opacity option
12259 if (this.helper.css("opacity")) {
12260 this._storedOpacity = this.helper.css("opacity");
12261 }
12262 this.helper.css("opacity", o.opacity);
12263 }
12264
12265 if(o.zIndex) { // zIndex option
12266 if (this.helper.css("zIndex")) {
12267 this._storedZIndex = this.helper.css("zIndex");
12268 }
12269 this.helper.css("zIndex", o.zIndex);
12270 }
12271
12272 //Prepare scrolling
12273 if(this.scrollParent[0] !== document && this.scrollParent[0].tagName !== "HTML") {
12274 this.overflowOffset = this.scrollParent.offset();
12275 }
12276
12277 //Call callbacks
12278 this._trigger("start", event, this._uiHash());
12279
12280 //Recache the helper size
12281 if(!this._preserveHelperProportions) {
12282 this._cacheHelperProportions();
12283 }
12284
12285
12286 //Post "activate" events to possible containers
12287 if( !noActivation ) {
12288 for ( i = this.containers.length - 1; i >= 0; i-- ) {
12289 this.containers[ i ]._trigger( "activate", event, this._uiHash( this ) );
12290 }
12291 }
12292
12293 //Prepare possible droppables
12294 if($.ui.ddmanager) {
12295 $.ui.ddmanager.current = this;
12296 }
12297
12298 if ($.ui.ddmanager && !o.dropBehaviour) {
12299 $.ui.ddmanager.prepareOffsets(this, event);
12300 }
12301
12302 this.dragging = true;
12303
12304 this.helper.addClass("ui-sortable-helper");
12305 this._mouseDrag(event); //Execute the drag once - this causes the helper not to be visible before getting its correct position
12306 return true;
12307
12308 },
12309
12310 _mouseDrag: function(event) {
12311 var i, item, itemElement, intersection,
12312 o = this.options,
12313 scrolled = false;
12314
12315 //Compute the helpers position
12316 this.position = this._generatePosition(event);
12317 this.positionAbs = this._convertPositionTo("absolute");
12318
12319 if (!this.lastPositionAbs) {
12320 this.lastPositionAbs = this.positionAbs;
12321 }
12322
12323 //Do scrolling
12324 if(this.options.scroll) {
12325 if(this.scrollParent[0] !== document && this.scrollParent[0].tagName !== "HTML") {
12326
12327 if((this.overflowOffset.top + this.scrollParent[0].offsetHeight) - event.pageY < o.scrollSensitivity) {
12328 this.scrollParent[0].scrollTop = scrolled = this.scrollParent[0].scrollTop + o.scrollSpeed;
12329 } else if(event.pageY - this.overflowOffset.top < o.scrollSensitivity) {
12330 this.scrollParent[0].scrollTop = scrolled = this.scrollParent[0].scrollTop - o.scrollSpeed;
12331 }
12332
12333 if((this.overflowOffset.left + this.scrollParent[0].offsetWidth) - event.pageX < o.scrollSensitivity) {
12334 this.scrollParent[0].scrollLeft = scrolled = this.scrollParent[0].scrollLeft + o.scrollSpeed;
12335 } else if(event.pageX - this.overflowOffset.left < o.scrollSensitivity) {
12336 this.scrollParent[0].scrollLeft = scrolled = this.scrollParent[0].scrollLeft - o.scrollSpeed;
12337 }
12338
12339 } else {
12340
12341 if(event.pageY - $(document).scrollTop() < o.scrollSensitivity) {
12342 scrolled = $(document).scrollTop($(document).scrollTop() - o.scrollSpeed);
12343 } else if($(window).height() - (event.pageY - $(document).scrollTop()) < o.scrollSensitivity) {
12344 scrolled = $(document).scrollTop($(document).scrollTop() + o.scrollSpeed);
12345 }
12346
12347 if(event.pageX - $(document).scrollLeft() < o.scrollSensitivity) {
12348 scrolled = $(document).scrollLeft($(document).scrollLeft() - o.scrollSpeed);
12349 } else if($(window).width() - (event.pageX - $(document).scrollLeft()) < o.scrollSensitivity) {
12350 scrolled = $(document).scrollLeft($(document).scrollLeft() + o.scrollSpeed);
12351 }
12352
12353 }
12354
12355 if(scrolled !== false && $.ui.ddmanager && !o.dropBehaviour) {
12356 $.ui.ddmanager.prepareOffsets(this, event);
12357 }
12358 }
12359
12360 //Regenerate the absolute position used for position checks
12361 this.positionAbs = this._convertPositionTo("absolute");
12362
12363 //Set the helper position
12364 if(!this.options.axis || this.options.axis !== "y") {
12365 this.helper[0].style.left = this.position.left+"px";
12366 }
12367 if(!this.options.axis || this.options.axis !== "x") {
12368 this.helper[0].style.top = this.position.top+"px";
12369 }
12370
12371 //Rearrange
12372 for (i = this.items.length - 1; i >= 0; i--) {
12373
12374 //Cache variables and intersection, continue if no intersection
12375 item = this.items[i];
12376 itemElement = item.item[0];
12377 intersection = this._intersectsWithPointer(item);
12378 if (!intersection) {
12379 continue;
12380 }
12381
12382 // Only put the placeholder inside the current Container, skip all
12383 // items from other containers. This works because when moving
12384 // an item from one container to another the
12385 // currentContainer is switched before the placeholder is moved.
12386 //
12387 // Without this, moving items in "sub-sortables" can cause
12388 // the placeholder to jitter beetween the outer and inner container.
12389 if (item.instance !== this.currentContainer) {
12390 continue;
12391 }
12392
12393 // cannot intersect with itself
12394 // no useless actions that have been done before
12395 // no action if the item moved is the parent of the item checked
12396 if (itemElement !== this.currentItem[0] &&
12397 this.placeholder[intersection === 1 ? "next" : "prev"]()[0] !== itemElement &&
12398 !$.contains(this.placeholder[0], itemElement) &&
12399 (this.options.type === "semi-dynamic" ? !$.contains(this.element[0], itemElement) : true)
12400 ) {
12401
12402 this.direction = intersection === 1 ? "down" : "up";
12403
12404 if (this.options.tolerance === "pointer" || this._intersectsWithSides(item)) {
12405 this._rearrange(event, item);
12406 } else {
12407 break;
12408 }
12409
12410 this._trigger("change", event, this._uiHash());
12411 break;
12412 }
12413 }
12414
12415 //Post events to containers
12416 this._contactContainers(event);
12417
12418 //Interconnect with droppables
12419 if($.ui.ddmanager) {
12420 $.ui.ddmanager.drag(this, event);
12421 }
12422
12423 //Call callbacks
12424 this._trigger("sort", event, this._uiHash());
12425
12426 this.lastPositionAbs = this.positionAbs;
12427 return false;
12428
12429 },
12430
12431 _mouseStop: function(event, noPropagation) {
12432
12433 if(!event) {
12434 return;
12435 }
12436
12437 //If we are using droppables, inform the manager about the drop
12438 if ($.ui.ddmanager && !this.options.dropBehaviour) {
12439 $.ui.ddmanager.drop(this, event);
12440 }
12441
12442 if(this.options.revert) {
12443 var that = this,
12444 cur = this.placeholder.offset(),
12445 axis = this.options.axis,
12446 animation = {};
12447
12448 if ( !axis || axis === "x" ) {
12449 animation.left = cur.left - this.offset.parent.left - this.margins.left + (this.offsetParent[0] === document.body ? 0 : this.offsetParent[0].scrollLeft);
12450 }
12451 if ( !axis || axis === "y" ) {
12452 animation.top = cur.top - this.offset.parent.top - this.margins.top + (this.offsetParent[0] === document.body ? 0 : this.offsetParent[0].scrollTop);
12453 }
12454 this.reverting = true;
12455 $(this.helper).animate( animation, parseInt(this.options.revert, 10) || 500, function() {
12456 that._clear(event);
12457 });
12458 } else {
12459 this._clear(event, noPropagation);
12460 }
12461
12462 return false;
12463
12464 },
12465
12466 cancel: function() {
12467
12468 if(this.dragging) {
12469
12470 this._mouseUp({ target: null });
12471
12472 if(this.options.helper === "original") {
12473 this.currentItem.css(this._storedCSS).removeClass("ui-sortable-helper");
12474 } else {
12475 this.currentItem.show();
12476 }
12477
12478 //Post deactivating events to containers
12479 for (var i = this.containers.length - 1; i >= 0; i--){
12480 this.containers[i]._trigger("deactivate", null, this._uiHash(this));
12481 if(this.containers[i].containerCache.over) {
12482 this.containers[i]._trigger("out", null, this._uiHash(this));
12483 this.containers[i].containerCache.over = 0;
12484 }
12485 }
12486
12487 }
12488
12489 if (this.placeholder) {
12490 //$(this.placeholder[0]).remove(); would have been the jQuery way - unfortunately, it unbinds ALL events from the original node!
12491 if(this.placeholder[0].parentNode) {
12492 this.placeholder[0].parentNode.removeChild(this.placeholder[0]);
12493 }
12494 if(this.options.helper !== "original" && this.helper && this.helper[0].parentNode) {
12495 this.helper.remove();
12496 }
12497
12498 $.extend(this, {
12499 helper: null,
12500 dragging: false,
12501 reverting: false,
12502 _noFinalSort: null
12503 });
12504
12505 if(this.domPosition.prev) {
12506 $(this.domPosition.prev).after(this.currentItem);
12507 } else {
12508 $(this.domPosition.parent).prepend(this.currentItem);
12509 }
12510 }
12511
12512 return this;
12513
12514 },
12515
12516 serialize: function(o) {
12517
12518 var items = this._getItemsAsjQuery(o && o.connected),
12519 str = [];
12520 o = o || {};
12521
12522 $(items).each(function() {
12523 var res = ($(o.item || this).attr(o.attribute || "id") || "").match(o.expression || (/(.+)[\-=_](.+)/));
12524 if (res) {
12525 str.push((o.key || res[1]+"[]")+"="+(o.key && o.expression ? res[1] : res[2]));
12526 }
12527 });
12528
12529 if(!str.length && o.key) {
12530 str.push(o.key + "=");
12531 }
12532
12533 return str.join("&");
12534
12535 },
12536
12537 toArray: function(o) {
12538
12539 var items = this._getItemsAsjQuery(o && o.connected),
12540 ret = [];
12541
12542 o = o || {};
12543
12544 items.each(function() { ret.push($(o.item || this).attr(o.attribute || "id") || ""); });
12545 return ret;
12546
12547 },
12548
12549 /* Be careful with the following core functions */
12550 _intersectsWith: function(item) {
12551
12552 var x1 = this.positionAbs.left,
12553 x2 = x1 + this.helperProportions.width,
12554 y1 = this.positionAbs.top,
12555 y2 = y1 + this.helperProportions.height,
12556 l = item.left,
12557 r = l + item.width,
12558 t = item.top,
12559 b = t + item.height,
12560 dyClick = this.offset.click.top,
12561 dxClick = this.offset.click.left,
12562 isOverElementHeight = ( this.options.axis === "x" ) || ( ( y1 + dyClick ) > t && ( y1 + dyClick ) < b ),
12563 isOverElementWidth = ( this.options.axis === "y" ) || ( ( x1 + dxClick ) > l && ( x1 + dxClick ) < r ),
12564 isOverElement = isOverElementHeight && isOverElementWidth;
12565
12566 if ( this.options.tolerance === "pointer" ||
12567 this.options.forcePointerForContainers ||
12568 (this.options.tolerance !== "pointer" && this.helperProportions[this.floating ? "width" : "height"] > item[this.floating ? "width" : "height"])
12569 ) {
12570 return isOverElement;
12571 } else {
12572
12573 return (l < x1 + (this.helperProportions.width / 2) && // Right Half
12574 x2 - (this.helperProportions.width / 2) < r && // Left Half
12575 t < y1 + (this.helperProportions.height / 2) && // Bottom Half
12576 y2 - (this.helperProportions.height / 2) < b ); // Top Half
12577
12578 }
12579 },
12580
12581 _intersectsWithPointer: function(item) {
12582
12583 var isOverElementHeight = (this.options.axis === "x") || isOverAxis(this.positionAbs.top + this.offset.click.top, item.top, item.height),
12584 isOverElementWidth = (this.options.axis === "y") || isOverAxis(this.positionAbs.left + this.offset.click.left, item.left, item.width),
12585 isOverElement = isOverElementHeight && isOverElementWidth,
12586 verticalDirection = this._getDragVerticalDirection(),
12587 horizontalDirection = this._getDragHorizontalDirection();
12588
12589 if (!isOverElement) {
12590 return false;
12591 }
12592
12593 return this.floating ?
12594 ( ((horizontalDirection && horizontalDirection === "right") || verticalDirection === "down") ? 2 : 1 )
12595 : ( verticalDirection && (verticalDirection === "down" ? 2 : 1) );
12596
12597 },
12598
12599 _intersectsWithSides: function(item) {
12600
12601 var isOverBottomHalf = isOverAxis(this.positionAbs.top + this.offset.click.top, item.top + (item.height/2), item.height),
12602 isOverRightHalf = isOverAxis(this.positionAbs.left + this.offset.click.left, item.left + (item.width/2), item.width),
12603 verticalDirection = this._getDragVerticalDirection(),
12604 horizontalDirection = this._getDragHorizontalDirection();
12605
12606 if (this.floating && horizontalDirection) {
12607 return ((horizontalDirection === "right" && isOverRightHalf) || (horizontalDirection === "left" && !isOverRightHalf));
12608 } else {
12609 return verticalDirection && ((verticalDirection === "down" && isOverBottomHalf) || (verticalDirection === "up" && !isOverBottomHalf));
12610 }
12611
12612 },
12613
12614 _getDragVerticalDirection: function() {
12615 var delta = this.positionAbs.top - this.lastPositionAbs.top;
12616 return delta !== 0 && (delta > 0 ? "down" : "up");
12617 },
12618
12619 _getDragHorizontalDirection: function() {
12620 var delta = this.positionAbs.left - this.lastPositionAbs.left;
12621 return delta !== 0 && (delta > 0 ? "right" : "left");
12622 },
12623
12624 refresh: function(event) {
12625 this._refreshItems(event);
12626 this.refreshPositions();
12627 return this;
12628 },
12629
12630 _connectWith: function() {
12631 var options = this.options;
12632 return options.connectWith.constructor === String ? [options.connectWith] : options.connectWith;
12633 },
12634
12635 _getItemsAsjQuery: function(connected) {
12636
12637 var i, j, cur, inst,
12638 items = [],
12639 queries = [],
12640 connectWith = this._connectWith();
12641
12642 if(connectWith && connected) {
12643 for (i = connectWith.length - 1; i >= 0; i--){
12644 cur = $(connectWith[i]);
12645 for ( j = cur.length - 1; j >= 0; j--){
12646 inst = $.data(cur[j], this.widgetFullName);
12647 if(inst && inst !== this && !inst.options.disabled) {
12648 queries.push([$.isFunction(inst.options.items) ? inst.options.items.call(inst.element) : $(inst.options.items, inst.element).not(".ui-sortable-helper").not(".ui-sortable-placeholder"), inst]);
12649 }
12650 }
12651 }
12652 }
12653
12654 queries.push([$.isFunction(this.options.items) ? this.options.items.call(this.element, null, { options: this.options, item: this.currentItem }) : $(this.options.items, this.element).not(".ui-sortable-helper").not(".ui-sortable-placeholder"), this]);
12655
12656 function addItems() {
12657 items.push( this );
12658 }
12659 for (i = queries.length - 1; i >= 0; i--){
12660 queries[i][0].each( addItems );
12661 }
12662
12663 return $(items);
12664
12665 },
12666
12667 _removeCurrentsFromItems: function() {
12668
12669 var list = this.currentItem.find(":data(" + this.widgetName + "-item)");
12670
12671 this.items = $.grep(this.items, function (item) {
12672 for (var j=0; j < list.length; j++) {
12673 if(list[j] === item.item[0]) {
12674 return false;
12675 }
12676 }
12677 return true;
12678 });
12679
12680 },
12681
12682 _refreshItems: function(event) {
12683
12684 this.items = [];
12685 this.containers = [this];
12686
12687 var i, j, cur, inst, targetData, _queries, item, queriesLength,
12688 items = this.items,
12689 queries = [[$.isFunction(this.options.items) ? this.options.items.call(this.element[0], event, { item: this.currentItem }) : $(this.options.items, this.element), this]],
12690 connectWith = this._connectWith();
12691
12692 if(connectWith && this.ready) { //Shouldn't be run the first time through due to massive slow-down
12693 for (i = connectWith.length - 1; i >= 0; i--){
12694 cur = $(connectWith[i]);
12695 for (j = cur.length - 1; j >= 0; j--){
12696 inst = $.data(cur[j], this.widgetFullName);
12697 if(inst && inst !== this && !inst.options.disabled) {
12698 queries.push([$.isFunction(inst.options.items) ? inst.options.items.call(inst.element[0], event, { item: this.currentItem }) : $(inst.options.items, inst.element), inst]);
12699 this.containers.push(inst);
12700 }
12701 }
12702 }
12703 }
12704
12705 for (i = queries.length - 1; i >= 0; i--) {
12706 targetData = queries[i][1];
12707 _queries = queries[i][0];
12708
12709 for (j=0, queriesLength = _queries.length; j < queriesLength; j++) {
12710 item = $(_queries[j]);
12711
12712 item.data(this.widgetName + "-item", targetData); // Data for target checking (mouse manager)
12713
12714 items.push({
12715 item: item,
12716 instance: targetData,
12717 width: 0, height: 0,
12718 left: 0, top: 0
12719 });
12720 }
12721 }
12722
12723 },
12724
12725 refreshPositions: function(fast) {
12726
12727 //This has to be redone because due to the item being moved out/into the offsetParent, the offsetParent's position will change
12728 if(this.offsetParent && this.helper) {
12729 this.offset.parent = this._getParentOffset();
12730 }
12731
12732 var i, item, t, p;
12733
12734 for (i = this.items.length - 1; i >= 0; i--){
12735 item = this.items[i];
12736
12737 //We ignore calculating positions of all connected containers when we're not over them
12738 if(item.instance !== this.currentContainer && this.currentContainer && item.item[0] !== this.currentItem[0]) {
12739 continue;
12740 }
12741
12742 t = this.options.toleranceElement ? $(this.options.toleranceElement, item.item) : item.item;
12743
12744 if (!fast) {
12745 item.width = t.outerWidth();
12746 item.height = t.outerHeight();
12747 }
12748
12749 p = t.offset();
12750 item.left = p.left;
12751 item.top = p.top;
12752 }
12753
12754 if(this.options.custom && this.options.custom.refreshContainers) {
12755 this.options.custom.refreshContainers.call(this);
12756 } else {
12757 for (i = this.containers.length - 1; i >= 0; i--){
12758 p = this.containers[i].element.offset();
12759 this.containers[i].containerCache.left = p.left;
12760 this.containers[i].containerCache.top = p.top;
12761 this.containers[i].containerCache.width = this.containers[i].element.outerWidth();
12762 this.containers[i].containerCache.height = this.containers[i].element.outerHeight();
12763 }
12764 }
12765
12766 return this;
12767 },
12768
12769 _createPlaceholder: function(that) {
12770 that = that || this;
12771 var className,
12772 o = that.options;
12773
12774 if(!o.placeholder || o.placeholder.constructor === String) {
12775 className = o.placeholder;
12776 o.placeholder = {
12777 element: function() {
12778
12779 var nodeName = that.currentItem[0].nodeName.toLowerCase(),
12780 element = $( "<" + nodeName + ">", that.document[0] )
12781 .addClass(className || that.currentItem[0].className+" ui-sortable-placeholder")
12782 .removeClass("ui-sortable-helper");
12783
12784 if ( nodeName === "tr" ) {
12785 that.currentItem.children().each(function() {
12786 $( "<td>&#160;</td>", that.document[0] )
12787 .attr( "colspan", $( this ).attr( "colspan" ) || 1 )
12788 .appendTo( element );
12789 });
12790 } else if ( nodeName === "img" ) {
12791 element.attr( "src", that.currentItem.attr( "src" ) );
12792 }
12793
12794 if ( !className ) {
12795 element.css( "visibility", "hidden" );
12796 }
12797
12798 return element;
12799 },
12800 update: function(container, p) {
12801
12802 // 1. If a className is set as 'placeholder option, we don't force sizes - the class is responsible for that
12803 // 2. The option 'forcePlaceholderSize can be enabled to force it even if a class name is specified
12804 if(className && !o.forcePlaceholderSize) {
12805 return;
12806 }
12807
12808 //If the element doesn't have a actual height by itself (without styles coming from a stylesheet), it receives the inline height from the dragged item
12809 if(!p.height()) { p.height(that.currentItem.innerHeight() - parseInt(that.currentItem.css("paddingTop")||0, 10) - parseInt(that.currentItem.css("paddingBottom")||0, 10)); }
12810 if(!p.width()) { p.width(that.currentItem.innerWidth() - parseInt(that.currentItem.css("paddingLeft")||0, 10) - parseInt(that.currentItem.css("paddingRight")||0, 10)); }
12811 }
12812 };
12813 }
12814
12815 //Create the placeholder
12816 that.placeholder = $(o.placeholder.element.call(that.element, that.currentItem));
12817
12818 //Append it after the actual current item
12819 that.currentItem.after(that.placeholder);
12820
12821 //Update the size of the placeholder (TODO: Logic to fuzzy, see line 316/317)
12822 o.placeholder.update(that, that.placeholder);
12823
12824 },
12825
12826 _contactContainers: function(event) {
12827 var i, j, dist, itemWithLeastDistance, posProperty, sizeProperty, base, cur, nearBottom, floating,
12828 innermostContainer = null,
12829 innermostIndex = null;
12830
12831 // get innermost container that intersects with item
12832 for (i = this.containers.length - 1; i >= 0; i--) {
12833
12834 // never consider a container that's located within the item itself
12835 if($.contains(this.currentItem[0], this.containers[i].element[0])) {
12836 continue;
12837 }
12838
12839 if(this._intersectsWith(this.containers[i].containerCache)) {
12840
12841 // if we've already found a container and it's more "inner" than this, then continue
12842 if(innermostContainer && $.contains(this.containers[i].element[0], innermostContainer.element[0])) {
12843 continue;
12844 }
12845
12846 innermostContainer = this.containers[i];
12847 innermostIndex = i;
12848
12849 } else {
12850 // container doesn't intersect. trigger "out" event if necessary
12851 if(this.containers[i].containerCache.over) {
12852 this.containers[i]._trigger("out", event, this._uiHash(this));
12853 this.containers[i].containerCache.over = 0;
12854 }
12855 }
12856
12857 }
12858
12859 // if no intersecting containers found, return
12860 if(!innermostContainer) {
12861 return;
12862 }
12863
12864 // move the item into the container if it's not there already
12865 if(this.containers.length === 1) {
12866 if (!this.containers[innermostIndex].containerCache.over) {
12867 this.containers[innermostIndex]._trigger("over", event, this._uiHash(this));
12868 this.containers[innermostIndex].containerCache.over = 1;
12869 }
12870 } else {
12871
12872 //When entering a new container, we will find the item with the least distance and append our item near it
12873 dist = 10000;
12874 itemWithLeastDistance = null;
12875 floating = innermostContainer.floating || isFloating(this.currentItem);
12876 posProperty = floating ? "left" : "top";
12877 sizeProperty = floating ? "width" : "height";
12878 base = this.positionAbs[posProperty] + this.offset.click[posProperty];
12879 for (j = this.items.length - 1; j >= 0; j--) {
12880 if(!$.contains(this.containers[innermostIndex].element[0], this.items[j].item[0])) {
12881 continue;
12882 }
12883 if(this.items[j].item[0] === this.currentItem[0]) {
12884 continue;
12885 }
12886 if (floating && !isOverAxis(this.positionAbs.top + this.offset.click.top, this.items[j].top, this.items[j].height)) {
12887 continue;
12888 }
12889 cur = this.items[j].item.offset()[posProperty];
12890 nearBottom = false;
12891 if(Math.abs(cur - base) > Math.abs(cur + this.items[j][sizeProperty] - base)){
12892 nearBottom = true;
12893 cur += this.items[j][sizeProperty];
12894 }
12895
12896 if(Math.abs(cur - base) < dist) {
12897 dist = Math.abs(cur - base); itemWithLeastDistance = this.items[j];
12898 this.direction = nearBottom ? "up": "down";
12899 }
12900 }
12901
12902 //Check if dropOnEmpty is enabled
12903 if(!itemWithLeastDistance && !this.options.dropOnEmpty) {
12904 return;
12905 }
12906
12907 if(this.currentContainer === this.containers[innermostIndex]) {
12908 return;
12909 }
12910
12911 itemWithLeastDistance ? this._rearrange(event, itemWithLeastDistance, null, true) : this._rearrange(event, null, this.containers[innermostIndex].element, true);
12912 this._trigger("change", event, this._uiHash());
12913 this.containers[innermostIndex]._trigger("change", event, this._uiHash(this));
12914 this.currentContainer = this.containers[innermostIndex];
12915
12916 //Update the placeholder
12917 this.options.placeholder.update(this.currentContainer, this.placeholder);
12918
12919 this.containers[innermostIndex]._trigger("over", event, this._uiHash(this));
12920 this.containers[innermostIndex].containerCache.over = 1;
12921 }
12922
12923
12924 },
12925
12926 _createHelper: function(event) {
12927
12928 var o = this.options,
12929 helper = $.isFunction(o.helper) ? $(o.helper.apply(this.element[0], [event, this.currentItem])) : (o.helper === "clone" ? this.currentItem.clone() : this.currentItem);
12930
12931 //Add the helper to the DOM if that didn't happen already
12932 if(!helper.parents("body").length) {
12933 $(o.appendTo !== "parent" ? o.appendTo : this.currentItem[0].parentNode)[0].appendChild(helper[0]);
12934 }
12935
12936 if(helper[0] === this.currentItem[0]) {
12937 this._storedCSS = { width: this.currentItem[0].style.width, height: this.currentItem[0].style.height, position: this.currentItem.css("position"), top: this.currentItem.css("top"), left: this.currentItem.css("left") };
12938 }
12939
12940 if(!helper[0].style.width || o.forceHelperSize) {
12941 helper.width(this.currentItem.width());
12942 }
12943 if(!helper[0].style.height || o.forceHelperSize) {
12944 helper.height(this.currentItem.height());
12945 }
12946
12947 return helper;
12948
12949 },
12950
12951 _adjustOffsetFromHelper: function(obj) {
12952 if (typeof obj === "string") {
12953 obj = obj.split(" ");
12954 }
12955 if ($.isArray(obj)) {
12956 obj = {left: +obj[0], top: +obj[1] || 0};
12957 }
12958 if ("left" in obj) {
12959 this.offset.click.left = obj.left + this.margins.left;
12960 }
12961 if ("right" in obj) {
12962 this.offset.click.left = this.helperProportions.width - obj.right + this.margins.left;
12963 }
12964 if ("top" in obj) {
12965 this.offset.click.top = obj.top + this.margins.top;
12966 }
12967 if ("bottom" in obj) {
12968 this.offset.click.top = this.helperProportions.height - obj.bottom + this.margins.top;
12969 }
12970 },
12971
12972 _getParentOffset: function() {
12973
12974
12975 //Get the offsetParent and cache its position
12976 this.offsetParent = this.helper.offsetParent();
12977 var po = this.offsetParent.offset();
12978
12979 // This is a special case where we need to modify a offset calculated on start, since the following happened:
12980 // 1. The position of the helper is absolute, so it's position is calculated based on the next positioned parent
12981 // 2. The actual offset parent is a child of the scroll parent, and the scroll parent isn't the document, which means that
12982 // the scroll is included in the initial calculation of the offset of the parent, and never recalculated upon drag
12983 if(this.cssPosition === "absolute" && this.scrollParent[0] !== document && $.contains(this.scrollParent[0], this.offsetParent[0])) {
12984 po.left += this.scrollParent.scrollLeft();
12985 po.top += this.scrollParent.scrollTop();
12986 }
12987
12988 // This needs to be actually done for all browsers, since pageX/pageY includes this information
12989 // with an ugly IE fix
12990 if( this.offsetParent[0] === document.body || (this.offsetParent[0].tagName && this.offsetParent[0].tagName.toLowerCase() === "html" && $.ui.ie)) {
12991 po = { top: 0, left: 0 };
12992 }
12993
12994 return {
12995 top: po.top + (parseInt(this.offsetParent.css("borderTopWidth"),10) || 0),
12996 left: po.left + (parseInt(this.offsetParent.css("borderLeftWidth"),10) || 0)
12997 };
12998
12999 },
13000
13001 _getRelativeOffset: function() {
13002
13003 if(this.cssPosition === "relative") {
13004 var p = this.currentItem.position();
13005 return {
13006 top: p.top - (parseInt(this.helper.css("top"),10) || 0) + this.scrollParent.scrollTop(),
13007 left: p.left - (parseInt(this.helper.css("left"),10) || 0) + this.scrollParent.scrollLeft()
13008 };
13009 } else {
13010 return { top: 0, left: 0 };
13011 }
13012
13013 },
13014
13015 _cacheMargins: function() {
13016 this.margins = {
13017 left: (parseInt(this.currentItem.css("marginLeft"),10) || 0),
13018 top: (parseInt(this.currentItem.css("marginTop"),10) || 0)
13019 };
13020 },
13021
13022 _cacheHelperProportions: function() {
13023 this.helperProportions = {
13024 width: this.helper.outerWidth(),
13025 height: this.helper.outerHeight()
13026 };
13027 },
13028
13029 _setContainment: function() {
13030
13031 var ce, co, over,
13032 o = this.options;
13033 if(o.containment === "parent") {
13034 o.containment = this.helper[0].parentNode;
13035 }
13036 if(o.containment === "document" || o.containment === "window") {
13037 this.containment = [
13038 0 - this.offset.relative.left - this.offset.parent.left,
13039 0 - this.offset.relative.top - this.offset.parent.top,
13040 $(o.containment === "document" ? document : window).width() - this.helperProportions.width - this.margins.left,
13041 ($(o.containment === "document" ? document : window).height() || document.body.parentNode.scrollHeight) - this.helperProportions.height - this.margins.top
13042 ];
13043 }
13044
13045 if(!(/^(document|window|parent)$/).test(o.containment)) {
13046 ce = $(o.containment)[0];
13047 co = $(o.containment).offset();
13048 over = ($(ce).css("overflow") !== "hidden");
13049
13050 this.containment = [
13051 co.left + (parseInt($(ce).css("borderLeftWidth"),10) || 0) + (parseInt($(ce).css("paddingLeft"),10) || 0) - this.margins.left,
13052 co.top + (parseInt($(ce).css("borderTopWidth"),10) || 0) + (parseInt($(ce).css("paddingTop"),10) || 0) - this.margins.top,
13053 co.left+(over ? Math.max(ce.scrollWidth,ce.offsetWidth) : ce.offsetWidth) - (parseInt($(ce).css("borderLeftWidth"),10) || 0) - (parseInt($(ce).css("paddingRight"),10) || 0) - this.helperProportions.width - this.margins.left,
13054 co.top+(over ? Math.max(ce.scrollHeight,ce.offsetHeight) : ce.offsetHeight) - (parseInt($(ce).css("borderTopWidth"),10) || 0) - (parseInt($(ce).css("paddingBottom"),10) || 0) - this.helperProportions.height - this.margins.top
13055 ];
13056 }
13057
13058 },
13059
13060 _convertPositionTo: function(d, pos) {
13061
13062 if(!pos) {
13063 pos = this.position;
13064 }
13065 var mod = d === "absolute" ? 1 : -1,
13066 scroll = this.cssPosition === "absolute" && !(this.scrollParent[0] !== document && $.contains(this.scrollParent[0], this.offsetParent[0])) ? this.offsetParent : this.scrollParent,
13067 scrollIsRootNode = (/(html|body)/i).test(scroll[0].tagName);
13068
13069 return {
13070 top: (
13071 pos.top + // The absolute mouse position
13072 this.offset.relative.top * mod + // Only for relative positioned nodes: Relative offset from element to offset parent
13073 this.offset.parent.top * mod - // The offsetParent's offset without borders (offset + border)
13074 ( ( this.cssPosition === "fixed" ? -this.scrollParent.scrollTop() : ( scrollIsRootNode ? 0 : scroll.scrollTop() ) ) * mod)
13075 ),
13076 left: (
13077 pos.left + // The absolute mouse position
13078 this.offset.relative.left * mod + // Only for relative positioned nodes: Relative offset from element to offset parent
13079 this.offset.parent.left * mod - // The offsetParent's offset without borders (offset + border)
13080 ( ( this.cssPosition === "fixed" ? -this.scrollParent.scrollLeft() : scrollIsRootNode ? 0 : scroll.scrollLeft() ) * mod)
13081 )
13082 };
13083
13084 },
13085
13086 _generatePosition: function(event) {
13087
13088 var top, left,
13089 o = this.options,
13090 pageX = event.pageX,
13091 pageY = event.pageY,
13092 scroll = this.cssPosition === "absolute" && !(this.scrollParent[0] !== document && $.contains(this.scrollParent[0], this.offsetParent[0])) ? this.offsetParent : this.scrollParent, scrollIsRootNode = (/(html|body)/i).test(scroll[0].tagName);
13093
13094 // This is another very weird special case that only happens for relative elements:
13095 // 1. If the css position is relative
13096 // 2. and the scroll parent is the document or similar to the offset parent
13097 // we have to refresh the relative offset during the scroll so there are no jumps
13098 if(this.cssPosition === "relative" && !(this.scrollParent[0] !== document && this.scrollParent[0] !== this.offsetParent[0])) {
13099 this.offset.relative = this._getRelativeOffset();
13100 }
13101
13102 /*
13103 * - Position constraining -
13104 * Constrain the position to a mix of grid, containment.
13105 */
13106
13107 if(this.originalPosition) { //If we are not dragging yet, we won't check for options
13108
13109 if(this.containment) {
13110 if(event.pageX - this.offset.click.left < this.containment[0]) {
13111 pageX = this.containment[0] + this.offset.click.left;
13112 }
13113 if(event.pageY - this.offset.click.top < this.containment[1]) {
13114 pageY = this.containment[1] + this.offset.click.top;
13115 }
13116 if(event.pageX - this.offset.click.left > this.containment[2]) {
13117 pageX = this.containment[2] + this.offset.click.left;
13118 }
13119 if(event.pageY - this.offset.click.top > this.containment[3]) {
13120 pageY = this.containment[3] + this.offset.click.top;
13121 }
13122 }
13123
13124 if(o.grid) {
13125 top = this.originalPageY + Math.round((pageY - this.originalPageY) / o.grid[1]) * o.grid[1];
13126 pageY = this.containment ? ( (top - this.offset.click.top >= this.containment[1] && top - this.offset.click.top <= this.containment[3]) ? top : ((top - this.offset.click.top >= this.containment[1]) ? top - o.grid[1] : top + o.grid[1])) : top;
13127
13128 left = this.originalPageX + Math.round((pageX - this.originalPageX) / o.grid[0]) * o.grid[0];
13129 pageX = this.containment ? ( (left - this.offset.click.left >= this.containment[0] && left - this.offset.click.left <= this.containment[2]) ? left : ((left - this.offset.click.left >= this.containment[0]) ? left - o.grid[0] : left + o.grid[0])) : left;
13130 }
13131
13132 }
13133
13134 return {
13135 top: (
13136 pageY - // The absolute mouse position
13137 this.offset.click.top - // Click offset (relative to the element)
13138 this.offset.relative.top - // Only for relative positioned nodes: Relative offset from element to offset parent
13139 this.offset.parent.top + // The offsetParent's offset without borders (offset + border)
13140 ( ( this.cssPosition === "fixed" ? -this.scrollParent.scrollTop() : ( scrollIsRootNode ? 0 : scroll.scrollTop() ) ))
13141 ),
13142 left: (
13143 pageX - // The absolute mouse position
13144 this.offset.click.left - // Click offset (relative to the element)
13145 this.offset.relative.left - // Only for relative positioned nodes: Relative offset from element to offset parent
13146 this.offset.parent.left + // The offsetParent's offset without borders (offset + border)
13147 ( ( this.cssPosition === "fixed" ? -this.scrollParent.scrollLeft() : scrollIsRootNode ? 0 : scroll.scrollLeft() ))
13148 )
13149 };
13150
13151 },
13152
13153 _rearrange: function(event, i, a, hardRefresh) {
13154
13155 a ? a[0].appendChild(this.placeholder[0]) : i.item[0].parentNode.insertBefore(this.placeholder[0], (this.direction === "down" ? i.item[0] : i.item[0].nextSibling));
13156
13157 //Various things done here to improve the performance:
13158 // 1. we create a setTimeout, that calls refreshPositions
13159 // 2. on the instance, we have a counter variable, that get's higher after every append
13160 // 3. on the local scope, we copy the counter variable, and check in the timeout, if it's still the same
13161 // 4. this lets only the last addition to the timeout stack through
13162 this.counter = this.counter ? ++this.counter : 1;
13163 var counter = this.counter;
13164
13165 this._delay(function() {
13166 if(counter === this.counter) {
13167 this.refreshPositions(!hardRefresh); //Precompute after each DOM insertion, NOT on mousemove
13168 }
13169 });
13170
13171 },
13172
13173 _clear: function(event, noPropagation) {
13174
13175 this.reverting = false;
13176 // We delay all events that have to be triggered to after the point where the placeholder has been removed and
13177 // everything else normalized again
13178 var i,
13179 delayedTriggers = [];
13180
13181 // We first have to update the dom position of the actual currentItem
13182 // Note: don't do it if the current item is already removed (by a user), or it gets reappended (see #4088)
13183 if(!this._noFinalSort && this.currentItem.parent().length) {
13184 this.placeholder.before(this.currentItem);
13185 }
13186 this._noFinalSort = null;
13187
13188 if(this.helper[0] === this.currentItem[0]) {
13189 for(i in this._storedCSS) {
13190 if(this._storedCSS[i] === "auto" || this._storedCSS[i] === "static") {
13191 this._storedCSS[i] = "";
13192 }
13193 }
13194 this.currentItem.css(this._storedCSS).removeClass("ui-sortable-helper");
13195 } else {
13196 this.currentItem.show();
13197 }
13198
13199 if(this.fromOutside && !noPropagation) {
13200 delayedTriggers.push(function(event) { this._trigger("receive", event, this._uiHash(this.fromOutside)); });
13201 }
13202 if((this.fromOutside || this.domPosition.prev !== this.currentItem.prev().not(".ui-sortable-helper")[0] || this.domPosition.parent !== this.currentItem.parent()[0]) && !noPropagation) {
13203 delayedTriggers.push(function(event) { this._trigger("update", event, this._uiHash()); }); //Trigger update callback if the DOM position has changed
13204 }
13205
13206 // Check if the items Container has Changed and trigger appropriate
13207 // events.
13208 if (this !== this.currentContainer) {
13209 if(!noPropagation) {
13210 delayedTriggers.push(function(event) { this._trigger("remove", event, this._uiHash()); });
13211 delayedTriggers.push((function(c) { return function(event) { c._trigger("receive", event, this._uiHash(this)); }; }).call(this, this.currentContainer));
13212 delayedTriggers.push((function(c) { return function(event) { c._trigger("update", event, this._uiHash(this)); }; }).call(this, this.currentContainer));
13213 }
13214 }
13215
13216
13217 //Post events to containers
13218 function delayEvent( type, instance, container ) {
13219 return function( event ) {
13220 container._trigger( type, event, instance._uiHash( instance ) );
13221 };
13222 }
13223 for (i = this.containers.length - 1; i >= 0; i--){
13224 if (!noPropagation) {
13225 delayedTriggers.push( delayEvent( "deactivate", this, this.containers[ i ] ) );
13226 }
13227 if(this.containers[i].containerCache.over) {
13228 delayedTriggers.push( delayEvent( "out", this, this.containers[ i ] ) );
13229 this.containers[i].containerCache.over = 0;
13230 }
13231 }
13232
13233 //Do what was originally in plugins
13234 if ( this.storedCursor ) {
13235 this.document.find( "body" ).css( "cursor", this.storedCursor );
13236 this.storedStylesheet.remove();
13237 }
13238 if(this._storedOpacity) {
13239 this.helper.css("opacity", this._storedOpacity);
13240 }
13241 if(this._storedZIndex) {
13242 this.helper.css("zIndex", this._storedZIndex === "auto" ? "" : this._storedZIndex);
13243 }
13244
13245 this.dragging = false;
13246 if(this.cancelHelperRemoval) {
13247 if(!noPropagation) {
13248 this._trigger("beforeStop", event, this._uiHash());
13249 for (i=0; i < delayedTriggers.length; i++) {
13250 delayedTriggers[i].call(this, event);
13251 } //Trigger all delayed events
13252 this._trigger("stop", event, this._uiHash());
13253 }
13254
13255 this.fromOutside = false;
13256 return false;
13257 }
13258
13259 if(!noPropagation) {
13260 this._trigger("beforeStop", event, this._uiHash());
13261 }
13262
13263 //$(this.placeholder[0]).remove(); would have been the jQuery way - unfortunately, it unbinds ALL events from the original node!
13264 this.placeholder[0].parentNode.removeChild(this.placeholder[0]);
13265
13266 if(this.helper[0] !== this.currentItem[0]) {
13267 this.helper.remove();
13268 }
13269 this.helper = null;
13270
13271 if(!noPropagation) {
13272 for (i=0; i < delayedTriggers.length; i++) {
13273 delayedTriggers[i].call(this, event);
13274 } //Trigger all delayed events
13275 this._trigger("stop", event, this._uiHash());
13276 }
13277
13278 this.fromOutside = false;
13279 return true;
13280
13281 },
13282
13283 _trigger: function() {
13284 if ($.Widget.prototype._trigger.apply(this, arguments) === false) {
13285 this.cancel();
13286 }
13287 },
13288
13289 _uiHash: function(_inst) {
13290 var inst = _inst || this;
13291 return {
13292 helper: inst.helper,
13293 placeholder: inst.placeholder || $([]),
13294 position: inst.position,
13295 originalPosition: inst.originalPosition,
13296 offset: inst.positionAbs,
13297 item: inst.currentItem,
13298 sender: _inst ? _inst.element : null
13299 };
13300 }
13301
13302 });
13303
13304 })(jQuery);
13305 (function( $ ) {
13306
13307 function modifier( fn ) {
13308 return function() {
13309 var previous = this.element.val();
13310 fn.apply( this, arguments );
13311 this._refresh();
13312 if ( previous !== this.element.val() ) {
13313 this._trigger( "change" );
13314 }
13315 };
13316 }
13317
13318 $.widget( "ui.spinner", {
13319 version: "1.10.4",
13320 defaultElement: "<input>",
13321 widgetEventPrefix: "spin",
13322 options: {
13323 culture: null,
13324 icons: {
13325 down: "ui-icon-triangle-1-s",
13326 up: "ui-icon-triangle-1-n"
13327 },
13328 incremental: true,
13329 max: null,
13330 min: null,
13331 numberFormat: null,
13332 page: 10,
13333 step: 1,
13334
13335 change: null,
13336 spin: null,
13337 start: null,
13338 stop: null
13339 },
13340
13341 _create: function() {
13342 // handle string values that need to be parsed
13343 this._setOption( "max", this.options.max );
13344 this._setOption( "min", this.options.min );
13345 this._setOption( "step", this.options.step );
13346
13347 // Only format if there is a value, prevents the field from being marked
13348 // as invalid in Firefox, see #9573.
13349 if ( this.value() !== "" ) {
13350 // Format the value, but don't constrain.
13351 this._value( this.element.val(), true );
13352 }
13353
13354 this._draw();
13355 this._on( this._events );
13356 this._refresh();
13357
13358 // turning off autocomplete prevents the browser from remembering the
13359 // value when navigating through history, so we re-enable autocomplete
13360 // if the page is unloaded before the widget is destroyed. #7790
13361 this._on( this.window, {
13362 beforeunload: function() {
13363 this.element.removeAttr( "autocomplete" );
13364 }
13365 });
13366 },
13367
13368 _getCreateOptions: function() {
13369 var options = {},
13370 element = this.element;
13371
13372 $.each( [ "min", "max", "step" ], function( i, option ) {
13373 var value = element.attr( option );
13374 if ( value !== undefined && value.length ) {
13375 options[ option ] = value;
13376 }
13377 });
13378
13379 return options;
13380 },
13381
13382 _events: {
13383 keydown: function( event ) {
13384 if ( this._start( event ) && this._keydown( event ) ) {
13385 event.preventDefault();
13386 }
13387 },
13388 keyup: "_stop",
13389 focus: function() {
13390 this.previous = this.element.val();
13391 },
13392 blur: function( event ) {
13393 if ( this.cancelBlur ) {
13394 delete this.cancelBlur;
13395 return;
13396 }
13397
13398 this._stop();
13399 this._refresh();
13400 if ( this.previous !== this.element.val() ) {
13401 this._trigger( "change", event );
13402 }
13403 },
13404 mousewheel: function( event, delta ) {
13405 if ( !delta ) {
13406 return;
13407 }
13408 if ( !this.spinning && !this._start( event ) ) {
13409 return false;
13410 }
13411
13412 this._spin( (delta > 0 ? 1 : -1) * this.options.step, event );
13413 clearTimeout( this.mousewheelTimer );
13414 this.mousewheelTimer = this._delay(function() {
13415 if ( this.spinning ) {
13416 this._stop( event );
13417 }
13418 }, 100 );
13419 event.preventDefault();
13420 },
13421 "mousedown .ui-spinner-button": function( event ) {
13422 var previous;
13423
13424 // We never want the buttons to have focus; whenever the user is
13425 // interacting with the spinner, the focus should be on the input.
13426 // If the input is focused then this.previous is properly set from
13427 // when the input first received focus. If the input is not focused
13428 // then we need to set this.previous based on the value before spinning.
13429 previous = this.element[0] === this.document[0].activeElement ?
13430 this.previous : this.element.val();
13431 function checkFocus() {
13432 var isActive = this.element[0] === this.document[0].activeElement;
13433 if ( !isActive ) {
13434 this.element.focus();
13435 this.previous = previous;
13436 // support: IE
13437 // IE sets focus asynchronously, so we need to check if focus
13438 // moved off of the input because the user clicked on the button.
13439 this._delay(function() {
13440 this.previous = previous;
13441 });
13442 }
13443 }
13444
13445 // ensure focus is on (or stays on) the text field
13446 event.preventDefault();
13447 checkFocus.call( this );
13448
13449 // support: IE
13450 // IE doesn't prevent moving focus even with event.preventDefault()
13451 // so we set a flag to know when we should ignore the blur event
13452 // and check (again) if focus moved off of the input.
13453 this.cancelBlur = true;
13454 this._delay(function() {
13455 delete this.cancelBlur;
13456 checkFocus.call( this );
13457 });
13458
13459 if ( this._start( event ) === false ) {
13460 return;
13461 }
13462
13463 this._repeat( null, $( event.currentTarget ).hasClass( "ui-spinner-up" ) ? 1 : -1, event );
13464 },
13465 "mouseup .ui-spinner-button": "_stop",
13466 "mouseenter .ui-spinner-button": function( event ) {
13467 // button will add ui-state-active if mouse was down while mouseleave and kept down
13468 if ( !$( event.currentTarget ).hasClass( "ui-state-active" ) ) {
13469 return;
13470 }
13471
13472 if ( this._start( event ) === false ) {
13473 return false;
13474 }
13475 this._repeat( null, $( event.currentTarget ).hasClass( "ui-spinner-up" ) ? 1 : -1, event );
13476 },
13477 // TODO: do we really want to consider this a stop?
13478 // shouldn't we just stop the repeater and wait until mouseup before
13479 // we trigger the stop event?
13480 "mouseleave .ui-spinner-button": "_stop"
13481 },
13482
13483 _draw: function() {
13484 var uiSpinner = this.uiSpinner = this.element
13485 .addClass( "ui-spinner-input" )
13486 .attr( "autocomplete", "off" )
13487 .wrap( this._uiSpinnerHtml() )
13488 .parent()
13489 // add buttons
13490 .append( this._buttonHtml() );
13491
13492 this.element.attr( "role", "spinbutton" );
13493
13494 // button bindings
13495 this.buttons = uiSpinner.find( ".ui-spinner-button" )
13496 .attr( "tabIndex", -1 )
13497 .button()
13498 .removeClass( "ui-corner-all" );
13499
13500 // IE 6 doesn't understand height: 50% for the buttons
13501 // unless the wrapper has an explicit height
13502 if ( this.buttons.height() > Math.ceil( uiSpinner.height() * 0.5 ) &&
13503 uiSpinner.height() > 0 ) {
13504 uiSpinner.height( uiSpinner.height() );
13505 }
13506
13507 // disable spinner if element was already disabled
13508 if ( this.options.disabled ) {
13509 this.disable();
13510 }
13511 },
13512
13513 _keydown: function( event ) {
13514 var options = this.options,
13515 keyCode = $.ui.keyCode;
13516
13517 switch ( event.keyCode ) {
13518 case keyCode.UP:
13519 this._repeat( null, 1, event );
13520 return true;
13521 case keyCode.DOWN:
13522 this._repeat( null, -1, event );
13523 return true;
13524 case keyCode.PAGE_UP:
13525 this._repeat( null, options.page, event );
13526 return true;
13527 case keyCode.PAGE_DOWN:
13528 this._repeat( null, -options.page, event );
13529 return true;
13530 }
13531
13532 return false;
13533 },
13534
13535 _uiSpinnerHtml: function() {
13536 return "<span class='ui-spinner ui-widget ui-widget-content ui-corner-all'></span>";
13537 },
13538
13539 _buttonHtml: function() {
13540 return "" +
13541 "<a class='ui-spinner-button ui-spinner-up ui-corner-tr'>" +
13542 "<span class='ui-icon " + this.options.icons.up + "'>&#9650;</span>" +
13543 "</a>" +
13544 "<a class='ui-spinner-button ui-spinner-down ui-corner-br'>" +
13545 "<span class='ui-icon " + this.options.icons.down + "'>&#9660;</span>" +
13546 "</a>";
13547 },
13548
13549 _start: function( event ) {
13550 if ( !this.spinning && this._trigger( "start", event ) === false ) {
13551 return false;
13552 }
13553
13554 if ( !this.counter ) {
13555 this.counter = 1;
13556 }
13557 this.spinning = true;
13558 return true;
13559 },
13560
13561 _repeat: function( i, steps, event ) {
13562 i = i || 500;
13563
13564 clearTimeout( this.timer );
13565 this.timer = this._delay(function() {
13566 this._repeat( 40, steps, event );
13567 }, i );
13568
13569 this._spin( steps * this.options.step, event );
13570 },
13571
13572 _spin: function( step, event ) {
13573 var value = this.value() || 0;
13574
13575 if ( !this.counter ) {
13576 this.counter = 1;
13577 }
13578
13579 value = this._adjustValue( value + step * this._increment( this.counter ) );
13580
13581 if ( !this.spinning || this._trigger( "spin", event, { value: value } ) !== false) {
13582 this._value( value );
13583 this.counter++;
13584 }
13585 },
13586
13587 _increment: function( i ) {
13588 var incremental = this.options.incremental;
13589
13590 if ( incremental ) {
13591 return $.isFunction( incremental ) ?
13592 incremental( i ) :
13593 Math.floor( i*i*i/50000 - i*i/500 + 17*i/200 + 1 );
13594 }
13595
13596 return 1;
13597 },
13598
13599 _precision: function() {
13600 var precision = this._precisionOf( this.options.step );
13601 if ( this.options.min !== null ) {
13602 precision = Math.max( precision, this._precisionOf( this.options.min ) );
13603 }
13604 return precision;
13605 },
13606
13607 _precisionOf: function( num ) {
13608 var str = num.toString(),
13609 decimal = str.indexOf( "." );
13610 return decimal === -1 ? 0 : str.length - decimal - 1;
13611 },
13612
13613 _adjustValue: function( value ) {
13614 var base, aboveMin,
13615 options = this.options;
13616
13617 // make sure we're at a valid step
13618 // - find out where we are relative to the base (min or 0)
13619 base = options.min !== null ? options.min : 0;
13620 aboveMin = value - base;
13621 // - round to the nearest step
13622 aboveMin = Math.round(aboveMin / options.step) * options.step;
13623 // - rounding is based on 0, so adjust back to our base
13624 value = base + aboveMin;
13625
13626 // fix precision from bad JS floating point math
13627 value = parseFloat( value.toFixed( this._precision() ) );
13628
13629 // clamp the value
13630 if ( options.max !== null && value > options.max) {
13631 return options.max;
13632 }
13633 if ( options.min !== null && value < options.min ) {
13634 return options.min;
13635 }
13636
13637 return value;
13638 },
13639
13640 _stop: function( event ) {
13641 if ( !this.spinning ) {
13642 return;
13643 }
13644
13645 clearTimeout( this.timer );
13646 clearTimeout( this.mousewheelTimer );
13647 this.counter = 0;
13648 this.spinning = false;
13649 this._trigger( "stop", event );
13650 },
13651
13652 _setOption: function( key, value ) {
13653 if ( key === "culture" || key === "numberFormat" ) {
13654 var prevValue = this._parse( this.element.val() );
13655 this.options[ key ] = value;
13656 this.element.val( this._format( prevValue ) );
13657 return;
13658 }
13659
13660 if ( key === "max" || key === "min" || key === "step" ) {
13661 if ( typeof value === "string" ) {
13662 value = this._parse( value );
13663 }
13664 }
13665 if ( key === "icons" ) {
13666 this.buttons.first().find( ".ui-icon" )
13667 .removeClass( this.options.icons.up )
13668 .addClass( value.up );
13669 this.buttons.last().find( ".ui-icon" )
13670 .removeClass( this.options.icons.down )
13671 .addClass( value.down );
13672 }
13673
13674 this._super( key, value );
13675
13676 if ( key === "disabled" ) {
13677 if ( value ) {
13678 this.element.prop( "disabled", true );
13679 this.buttons.button( "disable" );
13680 } else {
13681 this.element.prop( "disabled", false );
13682 this.buttons.button( "enable" );
13683 }
13684 }
13685 },
13686
13687 _setOptions: modifier(function( options ) {
13688 this._super( options );
13689 this._value( this.element.val() );
13690 }),
13691
13692 _parse: function( val ) {
13693 if ( typeof val === "string" && val !== "" ) {
13694 val = window.Globalize && this.options.numberFormat ?
13695 Globalize.parseFloat( val, 10, this.options.culture ) : +val;
13696 }
13697 return val === "" || isNaN( val ) ? null : val;
13698 },
13699
13700 _format: function( value ) {
13701 if ( value === "" ) {
13702 return "";
13703 }
13704 return window.Globalize && this.options.numberFormat ?
13705 Globalize.format( value, this.options.numberFormat, this.options.culture ) :
13706 value;
13707 },
13708
13709 _refresh: function() {
13710 this.element.attr({
13711 "aria-valuemin": this.options.min,
13712 "aria-valuemax": this.options.max,
13713 // TODO: what should we do with values that can't be parsed?
13714 "aria-valuenow": this._parse( this.element.val() )
13715 });
13716 },
13717
13718 // update the value without triggering change
13719 _value: function( value, allowAny ) {
13720 var parsed;
13721 if ( value !== "" ) {
13722 parsed = this._parse( value );
13723 if ( parsed !== null ) {
13724 if ( !allowAny ) {
13725 parsed = this._adjustValue( parsed );
13726 }
13727 value = this._format( parsed );
13728 }
13729 }
13730 this.element.val( value );
13731 this._refresh();
13732 },
13733
13734 _destroy: function() {
13735 this.element
13736 .removeClass( "ui-spinner-input" )
13737 .prop( "disabled", false )
13738 .removeAttr( "autocomplete" )
13739 .removeAttr( "role" )
13740 .removeAttr( "aria-valuemin" )
13741 .removeAttr( "aria-valuemax" )
13742 .removeAttr( "aria-valuenow" );
13743 this.uiSpinner.replaceWith( this.element );
13744 },
13745
13746 stepUp: modifier(function( steps ) {
13747 this._stepUp( steps );
13748 }),
13749 _stepUp: function( steps ) {
13750 if ( this._start() ) {
13751 this._spin( (steps || 1) * this.options.step );
13752 this._stop();
13753 }
13754 },
13755
13756 stepDown: modifier(function( steps ) {
13757 this._stepDown( steps );
13758 }),
13759 _stepDown: function( steps ) {
13760 if ( this._start() ) {
13761 this._spin( (steps || 1) * -this.options.step );
13762 this._stop();
13763 }
13764 },
13765
13766 pageUp: modifier(function( pages ) {
13767 this._stepUp( (pages || 1) * this.options.page );
13768 }),
13769
13770 pageDown: modifier(function( pages ) {
13771 this._stepDown( (pages || 1) * this.options.page );
13772 }),
13773
13774 value: function( newVal ) {
13775 if ( !arguments.length ) {
13776 return this._parse( this.element.val() );
13777 }
13778 modifier( this._value ).call( this, newVal );
13779 },
13780
13781 widget: function() {
13782 return this.uiSpinner;
13783 }
13784 });
13785
13786 }( jQuery ) );
13787 (function( $, undefined ) {
13788
13789 var tabId = 0,
13790 rhash = /#.*$/;
13791
13792 function getNextTabId() {
13793 return ++tabId;
13794 }
13795
13796 function isLocal( anchor ) {
13797 // support: IE7
13798 // IE7 doesn't normalize the href property when set via script (#9317)
13799 anchor = anchor.cloneNode( false );
13800
13801 return anchor.hash.length > 1 &&
13802 decodeURIComponent( anchor.href.replace( rhash, "" ) ) ===
13803 decodeURIComponent( location.href.replace( rhash, "" ) );
13804 }
13805
13806 $.widget( "ui.tabs", {
13807 version: "1.10.4",
13808 delay: 300,
13809 options: {
13810 active: null,
13811 collapsible: false,
13812 event: "click",
13813 heightStyle: "content",
13814 hide: null,
13815 show: null,
13816
13817 // callbacks
13818 activate: null,
13819 beforeActivate: null,
13820 beforeLoad: null,
13821 load: null
13822 },
13823
13824 _create: function() {
13825 var that = this,
13826 options = this.options;
13827
13828 this.running = false;
13829
13830 this.element
13831 .addClass( "ui-tabs ui-widget ui-widget-content ui-corner-all" )
13832 .toggleClass( "ui-tabs-collapsible", options.collapsible )
13833 // Prevent users from focusing disabled tabs via click
13834 .delegate( ".ui-tabs-nav > li", "mousedown" + this.eventNamespace, function( event ) {
13835 if ( $( this ).is( ".ui-state-disabled" ) ) {
13836 event.preventDefault();
13837 }
13838 })
13839 // support: IE <9
13840 // Preventing the default action in mousedown doesn't prevent IE
13841 // from focusing the element, so if the anchor gets focused, blur.
13842 // We don't have to worry about focusing the previously focused
13843 // element since clicking on a non-focusable element should focus
13844 // the body anyway.
13845 .delegate( ".ui-tabs-anchor", "focus" + this.eventNamespace, function() {
13846 if ( $( this ).closest( "li" ).is( ".ui-state-disabled" ) ) {
13847 this.blur();
13848 }
13849 });
13850
13851 this._processTabs();
13852 options.active = this._initialActive();
13853
13854 // Take disabling tabs via class attribute from HTML
13855 // into account and update option properly.
13856 if ( $.isArray( options.disabled ) ) {
13857 options.disabled = $.unique( options.disabled.concat(
13858 $.map( this.tabs.filter( ".ui-state-disabled" ), function( li ) {
13859 return that.tabs.index( li );
13860 })
13861 ) ).sort();
13862 }
13863
13864 // check for length avoids error when initializing empty list
13865 if ( this.options.active !== false && this.anchors.length ) {
13866 this.active = this._findActive( options.active );
13867 } else {
13868 this.active = $();
13869 }
13870
13871 this._refresh();
13872
13873 if ( this.active.length ) {
13874 this.load( options.active );
13875 }
13876 },
13877
13878 _initialActive: function() {
13879 var active = this.options.active,
13880 collapsible = this.options.collapsible,
13881 locationHash = location.hash.substring( 1 );
13882
13883 if ( active === null ) {
13884 // check the fragment identifier in the URL
13885 if ( locationHash ) {
13886 this.tabs.each(function( i, tab ) {
13887 if ( $( tab ).attr( "aria-controls" ) === locationHash ) {
13888 active = i;
13889 return false;
13890 }
13891 });
13892 }
13893
13894 // check for a tab marked active via a class
13895 if ( active === null ) {
13896 active = this.tabs.index( this.tabs.filter( ".ui-tabs-active" ) );
13897 }
13898
13899 // no active tab, set to false
13900 if ( active === null || active === -1 ) {
13901 active = this.tabs.length ? 0 : false;
13902 }
13903 }
13904
13905 // handle numbers: negative, out of range
13906 if ( active !== false ) {
13907 active = this.tabs.index( this.tabs.eq( active ) );
13908 if ( active === -1 ) {
13909 active = collapsible ? false : 0;
13910 }
13911 }
13912
13913 // don't allow collapsible: false and active: false
13914 if ( !collapsible && active === false && this.anchors.length ) {
13915 active = 0;
13916 }
13917
13918 return active;
13919 },
13920
13921 _getCreateEventData: function() {
13922 return {
13923 tab: this.active,
13924 panel: !this.active.length ? $() : this._getPanelForTab( this.active )
13925 };
13926 },
13927
13928 _tabKeydown: function( event ) {
13929 var focusedTab = $( this.document[0].activeElement ).closest( "li" ),
13930 selectedIndex = this.tabs.index( focusedTab ),
13931 goingForward = true;
13932
13933 if ( this._handlePageNav( event ) ) {
13934 return;
13935 }
13936
13937 switch ( event.keyCode ) {
13938 case $.ui.keyCode.RIGHT:
13939 case $.ui.keyCode.DOWN:
13940 selectedIndex++;
13941 break;
13942 case $.ui.keyCode.UP:
13943 case $.ui.keyCode.LEFT:
13944 goingForward = false;
13945 selectedIndex--;
13946 break;
13947 case $.ui.keyCode.END:
13948 selectedIndex = this.anchors.length - 1;
13949 break;
13950 case $.ui.keyCode.HOME:
13951 selectedIndex = 0;
13952 break;
13953 case $.ui.keyCode.SPACE:
13954 // Activate only, no collapsing
13955 event.preventDefault();
13956 clearTimeout( this.activating );
13957 this._activate( selectedIndex );
13958 return;
13959 case $.ui.keyCode.ENTER:
13960 // Toggle (cancel delayed activation, allow collapsing)
13961 event.preventDefault();
13962 clearTimeout( this.activating );
13963 // Determine if we should collapse or activate
13964 this._activate( selectedIndex === this.options.active ? false : selectedIndex );
13965 return;
13966 default:
13967 return;
13968 }
13969
13970 // Focus the appropriate tab, based on which key was pressed
13971 event.preventDefault();
13972 clearTimeout( this.activating );
13973 selectedIndex = this._focusNextTab( selectedIndex, goingForward );
13974
13975 // Navigating with control key will prevent automatic activation
13976 if ( !event.ctrlKey ) {
13977 // Update aria-selected immediately so that AT think the tab is already selected.
13978 // Otherwise AT may confuse the user by stating that they need to activate the tab,
13979 // but the tab will already be activated by the time the announcement finishes.
13980 focusedTab.attr( "aria-selected", "false" );
13981 this.tabs.eq( selectedIndex ).attr( "aria-selected", "true" );
13982
13983 this.activating = this._delay(function() {
13984 this.option( "active", selectedIndex );
13985 }, this.delay );
13986 }
13987 },
13988
13989 _panelKeydown: function( event ) {
13990 if ( this._handlePageNav( event ) ) {
13991 return;
13992 }
13993
13994 // Ctrl+up moves focus to the current tab
13995 if ( event.ctrlKey && event.keyCode === $.ui.keyCode.UP ) {
13996 event.preventDefault();
13997 this.active.focus();
13998 }
13999 },
14000
14001 // Alt+page up/down moves focus to the previous/next tab (and activates)
14002 _handlePageNav: function( event ) {
14003 if ( event.altKey && event.keyCode === $.ui.keyCode.PAGE_UP ) {
14004 this._activate( this._focusNextTab( this.options.active - 1, false ) );
14005 return true;
14006 }
14007 if ( event.altKey && event.keyCode === $.ui.keyCode.PAGE_DOWN ) {
14008 this._activate( this._focusNextTab( this.options.active + 1, true ) );
14009 return true;
14010 }
14011 },
14012
14013 _findNextTab: function( index, goingForward ) {
14014 var lastTabIndex = this.tabs.length - 1;
14015
14016 function constrain() {
14017 if ( index > lastTabIndex ) {
14018 index = 0;
14019 }
14020 if ( index < 0 ) {
14021 index = lastTabIndex;
14022 }
14023 return index;
14024 }
14025
14026 while ( $.inArray( constrain(), this.options.disabled ) !== -1 ) {
14027 index = goingForward ? index + 1 : index - 1;
14028 }
14029
14030 return index;
14031 },
14032
14033 _focusNextTab: function( index, goingForward ) {
14034 index = this._findNextTab( index, goingForward );
14035 this.tabs.eq( index ).focus();
14036 return index;
14037 },
14038
14039 _setOption: function( key, value ) {
14040 if ( key === "active" ) {
14041 // _activate() will handle invalid values and update this.options
14042 this._activate( value );
14043 return;
14044 }
14045
14046 if ( key === "disabled" ) {
14047 // don't use the widget factory's disabled handling
14048 this._setupDisabled( value );
14049 return;
14050 }
14051
14052 this._super( key, value);
14053
14054 if ( key === "collapsible" ) {
14055 this.element.toggleClass( "ui-tabs-collapsible", value );
14056 // Setting collapsible: false while collapsed; open first panel
14057 if ( !value && this.options.active === false ) {
14058 this._activate( 0 );
14059 }
14060 }
14061
14062 if ( key === "event" ) {
14063 this._setupEvents( value );
14064 }
14065
14066 if ( key === "heightStyle" ) {
14067 this._setupHeightStyle( value );
14068 }
14069 },
14070
14071 _tabId: function( tab ) {
14072 return tab.attr( "aria-controls" ) || "ui-tabs-" + getNextTabId();
14073 },
14074
14075 _sanitizeSelector: function( hash ) {
14076 return hash ? hash.replace( /[!"$%&'()*+,.\/:;<=>?@\[\]\^`{|}~]/g, "\\$&" ) : "";
14077 },
14078
14079 refresh: function() {
14080 var options = this.options,
14081 lis = this.tablist.children( ":has(a[href])" );
14082
14083 // get disabled tabs from class attribute from HTML
14084 // this will get converted to a boolean if needed in _refresh()
14085 options.disabled = $.map( lis.filter( ".ui-state-disabled" ), function( tab ) {
14086 return lis.index( tab );
14087 });
14088
14089 this._processTabs();
14090
14091 // was collapsed or no tabs
14092 if ( options.active === false || !this.anchors.length ) {
14093 options.active = false;
14094 this.active = $();
14095 // was active, but active tab is gone
14096 } else if ( this.active.length && !$.contains( this.tablist[ 0 ], this.active[ 0 ] ) ) {
14097 // all remaining tabs are disabled
14098 if ( this.tabs.length === options.disabled.length ) {
14099 options.active = false;
14100 this.active = $();
14101 // activate previous tab
14102 } else {
14103 this._activate( this._findNextTab( Math.max( 0, options.active - 1 ), false ) );
14104 }
14105 // was active, active tab still exists
14106 } else {
14107 // make sure active index is correct
14108 options.active = this.tabs.index( this.active );
14109 }
14110
14111 this._refresh();
14112 },
14113
14114 _refresh: function() {
14115 this._setupDisabled( this.options.disabled );
14116 this._setupEvents( this.options.event );
14117 this._setupHeightStyle( this.options.heightStyle );
14118
14119 this.tabs.not( this.active ).attr({
14120 "aria-selected": "false",
14121 tabIndex: -1
14122 });
14123 this.panels.not( this._getPanelForTab( this.active ) )
14124 .hide()
14125 .attr({
14126 "aria-expanded": "false",
14127 "aria-hidden": "true"
14128 });
14129
14130 // Make sure one tab is in the tab order
14131 if ( !this.active.length ) {
14132 this.tabs.eq( 0 ).attr( "tabIndex", 0 );
14133 } else {
14134 this.active
14135 .addClass( "ui-tabs-active ui-state-active" )
14136 .attr({
14137 "aria-selected": "true",
14138 tabIndex: 0
14139 });
14140 this._getPanelForTab( this.active )
14141 .show()
14142 .attr({
14143 "aria-expanded": "true",
14144 "aria-hidden": "false"
14145 });
14146 }
14147 },
14148
14149 _processTabs: function() {
14150 var that = this;
14151
14152 this.tablist = this._getList()
14153 .addClass( "ui-tabs-nav ui-helper-reset ui-helper-clearfix ui-widget-header ui-corner-all" )
14154 .attr( "role", "tablist" );
14155
14156 this.tabs = this.tablist.find( "> li:has(a[href])" )
14157 .addClass( "ui-state-default ui-corner-top" )
14158 .attr({
14159 role: "tab",
14160 tabIndex: -1
14161 });
14162
14163 this.anchors = this.tabs.map(function() {
14164 return $( "a", this )[ 0 ];
14165 })
14166 .addClass( "ui-tabs-anchor" )
14167 .attr({
14168 role: "presentation",
14169 tabIndex: -1
14170 });
14171
14172 this.panels = $();
14173
14174 this.anchors.each(function( i, anchor ) {
14175 var selector, panel, panelId,
14176 anchorId = $( anchor ).uniqueId().attr( "id" ),
14177 tab = $( anchor ).closest( "li" ),
14178 originalAriaControls = tab.attr( "aria-controls" );
14179
14180 // inline tab
14181 if ( isLocal( anchor ) ) {
14182 selector = anchor.hash;
14183 panel = that.element.find( that._sanitizeSelector( selector ) );
14184 // remote tab
14185 } else {
14186 panelId = that._tabId( tab );
14187 selector = "#" + panelId;
14188 panel = that.element.find( selector );
14189 if ( !panel.length ) {
14190 panel = that._createPanel( panelId );
14191 panel.insertAfter( that.panels[ i - 1 ] || that.tablist );
14192 }
14193 panel.attr( "aria-live", "polite" );
14194 }
14195
14196 if ( panel.length) {
14197 that.panels = that.panels.add( panel );
14198 }
14199 if ( originalAriaControls ) {
14200 tab.data( "ui-tabs-aria-controls", originalAriaControls );
14201 }
14202 tab.attr({
14203 "aria-controls": selector.substring( 1 ),
14204 "aria-labelledby": anchorId
14205 });
14206 panel.attr( "aria-labelledby", anchorId );
14207 });
14208
14209 this.panels
14210 .addClass( "ui-tabs-panel ui-widget-content ui-corner-bottom" )
14211 .attr( "role", "tabpanel" );
14212 },
14213
14214 // allow overriding how to find the list for rare usage scenarios (#7715)
14215 _getList: function() {
14216 return this.tablist || this.element.find( "ol,ul" ).eq( 0 );
14217 },
14218
14219 _createPanel: function( id ) {
14220 return $( "<div>" )
14221 .attr( "id", id )
14222 .addClass( "ui-tabs-panel ui-widget-content ui-corner-bottom" )
14223 .data( "ui-tabs-destroy", true );
14224 },
14225
14226 _setupDisabled: function( disabled ) {
14227 if ( $.isArray( disabled ) ) {
14228 if ( !disabled.length ) {
14229 disabled = false;
14230 } else if ( disabled.length === this.anchors.length ) {
14231 disabled = true;
14232 }
14233 }
14234
14235 // disable tabs
14236 for ( var i = 0, li; ( li = this.tabs[ i ] ); i++ ) {
14237 if ( disabled === true || $.inArray( i, disabled ) !== -1 ) {
14238 $( li )
14239 .addClass( "ui-state-disabled" )
14240 .attr( "aria-disabled", "true" );
14241 } else {
14242 $( li )
14243 .removeClass( "ui-state-disabled" )
14244 .removeAttr( "aria-disabled" );
14245 }
14246 }
14247
14248 this.options.disabled = disabled;
14249 },
14250
14251 _setupEvents: function( event ) {
14252 var events = {
14253 click: function( event ) {
14254 event.preventDefault();
14255 }
14256 };
14257 if ( event ) {
14258 $.each( event.split(" "), function( index, eventName ) {
14259 events[ eventName ] = "_eventHandler";
14260 });
14261 }
14262
14263 this._off( this.anchors.add( this.tabs ).add( this.panels ) );
14264 this._on( this.anchors, events );
14265 this._on( this.tabs, { keydown: "_tabKeydown" } );
14266 this._on( this.panels, { keydown: "_panelKeydown" } );
14267
14268 this._focusable( this.tabs );
14269 this._hoverable( this.tabs );
14270 },
14271
14272 _setupHeightStyle: function( heightStyle ) {
14273 var maxHeight,
14274 parent = this.element.parent();
14275
14276 if ( heightStyle === "fill" ) {
14277 maxHeight = parent.height();
14278 maxHeight -= this.element.outerHeight() - this.element.height();
14279
14280 this.element.siblings( ":visible" ).each(function() {
14281 var elem = $( this ),
14282 position = elem.css( "position" );
14283
14284 if ( position === "absolute" || position === "fixed" ) {
14285 return;
14286 }
14287 maxHeight -= elem.outerHeight( true );
14288 });
14289
14290 this.element.children().not( this.panels ).each(function() {
14291 maxHeight -= $( this ).outerHeight( true );
14292 });
14293
14294 this.panels.each(function() {
14295 $( this ).height( Math.max( 0, maxHeight -
14296 $( this ).innerHeight() + $( this ).height() ) );
14297 })
14298 .css( "overflow", "auto" );
14299 } else if ( heightStyle === "auto" ) {
14300 maxHeight = 0;
14301 this.panels.each(function() {
14302 maxHeight = Math.max( maxHeight, $( this ).height( "" ).height() );
14303 }).height( maxHeight );
14304 }
14305 },
14306
14307 _eventHandler: function( event ) {
14308 var options = this.options,
14309 active = this.active,
14310 anchor = $( event.currentTarget ),
14311 tab = anchor.closest( "li" ),
14312 clickedIsActive = tab[ 0 ] === active[ 0 ],
14313 collapsing = clickedIsActive && options.collapsible,
14314 toShow = collapsing ? $() : this._getPanelForTab( tab ),
14315 toHide = !active.length ? $() : this._getPanelForTab( active ),
14316 eventData = {
14317 oldTab: active,
14318 oldPanel: toHide,
14319 newTab: collapsing ? $() : tab,
14320 newPanel: toShow
14321 };
14322
14323 event.preventDefault();
14324
14325 if ( tab.hasClass( "ui-state-disabled" ) ||
14326 // tab is already loading
14327 tab.hasClass( "ui-tabs-loading" ) ||
14328 // can't switch durning an animation
14329 this.running ||
14330 // click on active header, but not collapsible
14331 ( clickedIsActive && !options.collapsible ) ||
14332 // allow canceling activation
14333 ( this._trigger( "beforeActivate", event, eventData ) === false ) ) {
14334 return;
14335 }
14336
14337 options.active = collapsing ? false : this.tabs.index( tab );
14338
14339 this.active = clickedIsActive ? $() : tab;
14340 if ( this.xhr ) {
14341 this.xhr.abort();
14342 }
14343
14344 if ( !toHide.length && !toShow.length ) {
14345 $.error( "jQuery UI Tabs: Mismatching fragment identifier." );
14346 }
14347
14348 if ( toShow.length ) {
14349 this.load( this.tabs.index( tab ), event );
14350 }
14351 this._toggle( event, eventData );
14352 },
14353
14354 // handles show/hide for selecting tabs
14355 _toggle: function( event, eventData ) {
14356 var that = this,
14357 toShow = eventData.newPanel,
14358 toHide = eventData.oldPanel;
14359
14360 this.running = true;
14361
14362 function complete() {
14363 that.running = false;
14364 that._trigger( "activate", event, eventData );
14365 }
14366
14367 function show() {
14368 eventData.newTab.closest( "li" ).addClass( "ui-tabs-active ui-state-active" );
14369
14370 if ( toShow.length && that.options.show ) {
14371 that._show( toShow, that.options.show, complete );
14372 } else {
14373 toShow.show();
14374 complete();
14375 }
14376 }
14377
14378 // start out by hiding, then showing, then completing
14379 if ( toHide.length && this.options.hide ) {
14380 this._hide( toHide, this.options.hide, function() {
14381 eventData.oldTab.closest( "li" ).removeClass( "ui-tabs-active ui-state-active" );
14382 show();
14383 });
14384 } else {
14385 eventData.oldTab.closest( "li" ).removeClass( "ui-tabs-active ui-state-active" );
14386 toHide.hide();
14387 show();
14388 }
14389
14390 toHide.attr({
14391 "aria-expanded": "false",
14392 "aria-hidden": "true"
14393 });
14394 eventData.oldTab.attr( "aria-selected", "false" );
14395 // If we're switching tabs, remove the old tab from the tab order.
14396 // If we're opening from collapsed state, remove the previous tab from the tab order.
14397 // If we're collapsing, then keep the collapsing tab in the tab order.
14398 if ( toShow.length && toHide.length ) {
14399 eventData.oldTab.attr( "tabIndex", -1 );
14400 } else if ( toShow.length ) {
14401 this.tabs.filter(function() {
14402 return $( this ).attr( "tabIndex" ) === 0;
14403 })
14404 .attr( "tabIndex", -1 );
14405 }
14406
14407 toShow.attr({
14408 "aria-expanded": "true",
14409 "aria-hidden": "false"
14410 });
14411 eventData.newTab.attr({
14412 "aria-selected": "true",
14413 tabIndex: 0
14414 });
14415 },
14416
14417 _activate: function( index ) {
14418 var anchor,
14419 active = this._findActive( index );
14420
14421 // trying to activate the already active panel
14422 if ( active[ 0 ] === this.active[ 0 ] ) {
14423 return;
14424 }
14425
14426 // trying to collapse, simulate a click on the current active header
14427 if ( !active.length ) {
14428 active = this.active;
14429 }
14430
14431 anchor = active.find( ".ui-tabs-anchor" )[ 0 ];
14432 this._eventHandler({
14433 target: anchor,
14434 currentTarget: anchor,
14435 preventDefault: $.noop
14436 });
14437 },
14438
14439 _findActive: function( index ) {
14440 return index === false ? $() : this.tabs.eq( index );
14441 },
14442
14443 _getIndex: function( index ) {
14444 // meta-function to give users option to provide a href string instead of a numerical index.
14445 if ( typeof index === "string" ) {
14446 index = this.anchors.index( this.anchors.filter( "[href$='" + index + "']" ) );
14447 }
14448
14449 return index;
14450 },
14451
14452 _destroy: function() {
14453 if ( this.xhr ) {
14454 this.xhr.abort();
14455 }
14456
14457 this.element.removeClass( "ui-tabs ui-widget ui-widget-content ui-corner-all ui-tabs-collapsible" );
14458
14459 this.tablist
14460 .removeClass( "ui-tabs-nav ui-helper-reset ui-helper-clearfix ui-widget-header ui-corner-all" )
14461 .removeAttr( "role" );
14462
14463 this.anchors
14464 .removeClass( "ui-tabs-anchor" )
14465 .removeAttr( "role" )
14466 .removeAttr( "tabIndex" )
14467 .removeUniqueId();
14468
14469 this.tabs.add( this.panels ).each(function() {
14470 if ( $.data( this, "ui-tabs-destroy" ) ) {
14471 $( this ).remove();
14472 } else {
14473 $( this )
14474 .removeClass( "ui-state-default ui-state-active ui-state-disabled " +
14475 "ui-corner-top ui-corner-bottom ui-widget-content ui-tabs-active ui-tabs-panel" )
14476 .removeAttr( "tabIndex" )
14477 .removeAttr( "aria-live" )
14478 .removeAttr( "aria-busy" )
14479 .removeAttr( "aria-selected" )
14480 .removeAttr( "aria-labelledby" )
14481 .removeAttr( "aria-hidden" )
14482 .removeAttr( "aria-expanded" )
14483 .removeAttr( "role" );
14484 }
14485 });
14486
14487 this.tabs.each(function() {
14488 var li = $( this ),
14489 prev = li.data( "ui-tabs-aria-controls" );
14490 if ( prev ) {
14491 li
14492 .attr( "aria-controls", prev )
14493 .removeData( "ui-tabs-aria-controls" );
14494 } else {
14495 li.removeAttr( "aria-controls" );
14496 }
14497 });
14498
14499 this.panels.show();
14500
14501 if ( this.options.heightStyle !== "content" ) {
14502 this.panels.css( "height", "" );
14503 }
14504 },
14505
14506 enable: function( index ) {
14507 var disabled = this.options.disabled;
14508 if ( disabled === false ) {
14509 return;
14510 }
14511
14512 if ( index === undefined ) {
14513 disabled = false;
14514 } else {
14515 index = this._getIndex( index );
14516 if ( $.isArray( disabled ) ) {
14517 disabled = $.map( disabled, function( num ) {
14518 return num !== index ? num : null;
14519 });
14520 } else {
14521 disabled = $.map( this.tabs, function( li, num ) {
14522 return num !== index ? num : null;
14523 });
14524 }
14525 }
14526 this._setupDisabled( disabled );
14527 },
14528
14529 disable: function( index ) {
14530 var disabled = this.options.disabled;
14531 if ( disabled === true ) {
14532 return;
14533 }
14534
14535 if ( index === undefined ) {
14536 disabled = true;
14537 } else {
14538 index = this._getIndex( index );
14539 if ( $.inArray( index, disabled ) !== -1 ) {
14540 return;
14541 }
14542 if ( $.isArray( disabled ) ) {
14543 disabled = $.merge( [ index ], disabled ).sort();
14544 } else {
14545 disabled = [ index ];
14546 }
14547 }
14548 this._setupDisabled( disabled );
14549 },
14550
14551 load: function( index, event ) {
14552 index = this._getIndex( index );
14553 var that = this,
14554 tab = this.tabs.eq( index ),
14555 anchor = tab.find( ".ui-tabs-anchor" ),
14556 panel = this._getPanelForTab( tab ),
14557 eventData = {
14558 tab: tab,
14559 panel: panel
14560 };
14561
14562 // not remote
14563 if ( isLocal( anchor[ 0 ] ) ) {
14564 return;
14565 }
14566
14567 this.xhr = $.ajax( this._ajaxSettings( anchor, event, eventData ) );
14568
14569 // support: jQuery <1.8
14570 // jQuery <1.8 returns false if the request is canceled in beforeSend,
14571 // but as of 1.8, $.ajax() always returns a jqXHR object.
14572 if ( this.xhr && this.xhr.statusText !== "canceled" ) {
14573 tab.addClass( "ui-tabs-loading" );
14574 panel.attr( "aria-busy", "true" );
14575
14576 this.xhr
14577 .success(function( response ) {
14578 // support: jQuery <1.8
14579 // http://bugs.jquery.com/ticket/11778
14580 setTimeout(function() {
14581 panel.html( response );
14582 that._trigger( "load", event, eventData );
14583 }, 1 );
14584 })
14585 .complete(function( jqXHR, status ) {
14586 // support: jQuery <1.8
14587 // http://bugs.jquery.com/ticket/11778
14588 setTimeout(function() {
14589 if ( status === "abort" ) {
14590 that.panels.stop( false, true );
14591 }
14592
14593 tab.removeClass( "ui-tabs-loading" );
14594 panel.removeAttr( "aria-busy" );
14595
14596 if ( jqXHR === that.xhr ) {
14597 delete that.xhr;
14598 }
14599 }, 1 );
14600 });
14601 }
14602 },
14603
14604 _ajaxSettings: function( anchor, event, eventData ) {
14605 var that = this;
14606 return {
14607 url: anchor.attr( "href" ),
14608 beforeSend: function( jqXHR, settings ) {
14609 return that._trigger( "beforeLoad", event,
14610 $.extend( { jqXHR : jqXHR, ajaxSettings: settings }, eventData ) );
14611 }
14612 };
14613 },
14614
14615 _getPanelForTab: function( tab ) {
14616 var id = $( tab ).attr( "aria-controls" );
14617 return this.element.find( this._sanitizeSelector( "#" + id ) );
14618 }
14619 });
14620
14621 })( jQuery );
14622 (function( $ ) {
14623
14624 var increments = 0;
14625
14626 function addDescribedBy( elem, id ) {
14627 var describedby = (elem.attr( "aria-describedby" ) || "").split( /\s+/ );
14628 describedby.push( id );
14629 elem
14630 .data( "ui-tooltip-id", id )
14631 .attr( "aria-describedby", $.trim( describedby.join( " " ) ) );
14632 }
14633
14634 function removeDescribedBy( elem ) {
14635 var id = elem.data( "ui-tooltip-id" ),
14636 describedby = (elem.attr( "aria-describedby" ) || "").split( /\s+/ ),
14637 index = $.inArray( id, describedby );
14638 if ( index !== -1 ) {
14639 describedby.splice( index, 1 );
14640 }
14641
14642 elem.removeData( "ui-tooltip-id" );
14643 describedby = $.trim( describedby.join( " " ) );
14644 if ( describedby ) {
14645 elem.attr( "aria-describedby", describedby );
14646 } else {
14647 elem.removeAttr( "aria-describedby" );
14648 }
14649 }
14650
14651 $.widget( "ui.tooltip", {
14652 version: "1.10.4",
14653 options: {
14654 content: function() {
14655 // support: IE<9, Opera in jQuery <1.7
14656 // .text() can't accept undefined, so coerce to a string
14657 var title = $( this ).attr( "title" ) || "";
14658 // Escape title, since we're going from an attribute to raw HTML
14659 return $( "<a>" ).text( title ).html();
14660 },
14661 hide: true,
14662 // Disabled elements have inconsistent behavior across browsers (#8661)
14663 items: "[title]:not([disabled])",
14664 position: {
14665 my: "left top+15",
14666 at: "left bottom",
14667 collision: "flipfit flip"
14668 },
14669 show: true,
14670 tooltipClass: null,
14671 track: false,
14672
14673 // callbacks
14674 close: null,
14675 open: null
14676 },
14677
14678 _create: function() {
14679 this._on({
14680 mouseover: "open",
14681 focusin: "open"
14682 });
14683
14684 // IDs of generated tooltips, needed for destroy
14685 this.tooltips = {};
14686 // IDs of parent tooltips where we removed the title attribute
14687 this.parents = {};
14688
14689 if ( this.options.disabled ) {
14690 this._disable();
14691 }
14692 },
14693
14694 _setOption: function( key, value ) {
14695 var that = this;
14696
14697 if ( key === "disabled" ) {
14698 this[ value ? "_disable" : "_enable" ]();
14699 this.options[ key ] = value;
14700 // disable element style changes
14701 return;
14702 }
14703
14704 this._super( key, value );
14705
14706 if ( key === "content" ) {
14707 $.each( this.tooltips, function( id, element ) {
14708 that._updateContent( element );
14709 });
14710 }
14711 },
14712
14713 _disable: function() {
14714 var that = this;
14715
14716 // close open tooltips
14717 $.each( this.tooltips, function( id, element ) {
14718 var event = $.Event( "blur" );
14719 event.target = event.currentTarget = element[0];
14720 that.close( event, true );
14721 });
14722
14723 // remove title attributes to prevent native tooltips
14724 this.element.find( this.options.items ).addBack().each(function() {
14725 var element = $( this );
14726 if ( element.is( "[title]" ) ) {
14727 element
14728 .data( "ui-tooltip-title", element.attr( "title" ) )
14729 .attr( "title", "" );
14730 }
14731 });
14732 },
14733
14734 _enable: function() {
14735 // restore title attributes
14736 this.element.find( this.options.items ).addBack().each(function() {
14737 var element = $( this );
14738 if ( element.data( "ui-tooltip-title" ) ) {
14739 element.attr( "title", element.data( "ui-tooltip-title" ) );
14740 }
14741 });
14742 },
14743
14744 open: function( event ) {
14745 var that = this,
14746 target = $( event ? event.target : this.element )
14747 // we need closest here due to mouseover bubbling,
14748 // but always pointing at the same event target
14749 .closest( this.options.items );
14750
14751 // No element to show a tooltip for or the tooltip is already open
14752 if ( !target.length || target.data( "ui-tooltip-id" ) ) {
14753 return;
14754 }
14755
14756 if ( target.attr( "title" ) ) {
14757 target.data( "ui-tooltip-title", target.attr( "title" ) );
14758 }
14759
14760 target.data( "ui-tooltip-open", true );
14761
14762 // kill parent tooltips, custom or native, for hover
14763 if ( event && event.type === "mouseover" ) {
14764 target.parents().each(function() {
14765 var parent = $( this ),
14766 blurEvent;
14767 if ( parent.data( "ui-tooltip-open" ) ) {
14768 blurEvent = $.Event( "blur" );
14769 blurEvent.target = blurEvent.currentTarget = this;
14770 that.close( blurEvent, true );
14771 }
14772 if ( parent.attr( "title" ) ) {
14773 parent.uniqueId();
14774 that.parents[ this.id ] = {
14775 element: this,
14776 title: parent.attr( "title" )
14777 };
14778 parent.attr( "title", "" );
14779 }
14780 });
14781 }
14782
14783 this._updateContent( target, event );
14784 },
14785
14786 _updateContent: function( target, event ) {
14787 var content,
14788 contentOption = this.options.content,
14789 that = this,
14790 eventType = event ? event.type : null;
14791
14792 if ( typeof contentOption === "string" ) {
14793 return this._open( event, target, contentOption );
14794 }
14795
14796 content = contentOption.call( target[0], function( response ) {
14797 // ignore async response if tooltip was closed already
14798 if ( !target.data( "ui-tooltip-open" ) ) {
14799 return;
14800 }
14801 // IE may instantly serve a cached response for ajax requests
14802 // delay this call to _open so the other call to _open runs first
14803 that._delay(function() {
14804 // jQuery creates a special event for focusin when it doesn't
14805 // exist natively. To improve performance, the native event
14806 // object is reused and the type is changed. Therefore, we can't
14807 // rely on the type being correct after the event finished
14808 // bubbling, so we set it back to the previous value. (#8740)
14809 if ( event ) {
14810 event.type = eventType;
14811 }
14812 this._open( event, target, response );
14813 });
14814 });
14815 if ( content ) {
14816 this._open( event, target, content );
14817 }
14818 },
14819
14820 _open: function( event, target, content ) {
14821 var tooltip, events, delayedShow,
14822 positionOption = $.extend( {}, this.options.position );
14823
14824 if ( !content ) {
14825 return;
14826 }
14827
14828 // Content can be updated multiple times. If the tooltip already
14829 // exists, then just update the content and bail.
14830 tooltip = this._find( target );
14831 if ( tooltip.length ) {
14832 tooltip.find( ".ui-tooltip-content" ).html( content );
14833 return;
14834 }
14835
14836 // if we have a title, clear it to prevent the native tooltip
14837 // we have to check first to avoid defining a title if none exists
14838 // (we don't want to cause an element to start matching [title])
14839 //
14840 // We use removeAttr only for key events, to allow IE to export the correct
14841 // accessible attributes. For mouse events, set to empty string to avoid
14842 // native tooltip showing up (happens only when removing inside mouseover).
14843 if ( target.is( "[title]" ) ) {
14844 if ( event && event.type === "mouseover" ) {
14845 target.attr( "title", "" );
14846 } else {
14847 target.removeAttr( "title" );
14848 }
14849 }
14850
14851 tooltip = this._tooltip( target );
14852 addDescribedBy( target, tooltip.attr( "id" ) );
14853 tooltip.find( ".ui-tooltip-content" ).html( content );
14854
14855 function position( event ) {
14856 positionOption.of = event;
14857 if ( tooltip.is( ":hidden" ) ) {
14858 return;
14859 }
14860 tooltip.position( positionOption );
14861 }
14862 if ( this.options.track && event && /^mouse/.test( event.type ) ) {
14863 this._on( this.document, {
14864 mousemove: position
14865 });
14866 // trigger once to override element-relative positioning
14867 position( event );
14868 } else {
14869 tooltip.position( $.extend({
14870 of: target
14871 }, this.options.position ) );
14872 }
14873
14874 tooltip.hide();
14875
14876 this._show( tooltip, this.options.show );
14877 // Handle tracking tooltips that are shown with a delay (#8644). As soon
14878 // as the tooltip is visible, position the tooltip using the most recent
14879 // event.
14880 if ( this.options.show && this.options.show.delay ) {
14881 delayedShow = this.delayedShow = setInterval(function() {
14882 if ( tooltip.is( ":visible" ) ) {
14883 position( positionOption.of );
14884 clearInterval( delayedShow );
14885 }
14886 }, $.fx.interval );
14887 }
14888
14889 this._trigger( "open", event, { tooltip: tooltip } );
14890
14891 events = {
14892 keyup: function( event ) {
14893 if ( event.keyCode === $.ui.keyCode.ESCAPE ) {
14894 var fakeEvent = $.Event(event);
14895 fakeEvent.currentTarget = target[0];
14896 this.close( fakeEvent, true );
14897 }
14898 },
14899 remove: function() {
14900 this._removeTooltip( tooltip );
14901 }
14902 };
14903 if ( !event || event.type === "mouseover" ) {
14904 events.mouseleave = "close";
14905 }
14906 if ( !event || event.type === "focusin" ) {
14907 events.focusout = "close";
14908 }
14909 this._on( true, target, events );
14910 },
14911
14912 close: function( event ) {
14913 var that = this,
14914 target = $( event ? event.currentTarget : this.element ),
14915 tooltip = this._find( target );
14916
14917 // disabling closes the tooltip, so we need to track when we're closing
14918 // to avoid an infinite loop in case the tooltip becomes disabled on close
14919 if ( this.closing ) {
14920 return;
14921 }
14922
14923 // Clear the interval for delayed tracking tooltips
14924 clearInterval( this.delayedShow );
14925
14926 // only set title if we had one before (see comment in _open())
14927 if ( target.data( "ui-tooltip-title" ) ) {
14928 target.attr( "title", target.data( "ui-tooltip-title" ) );
14929 }
14930
14931 removeDescribedBy( target );
14932
14933 tooltip.stop( true );
14934 this._hide( tooltip, this.options.hide, function() {
14935 that._removeTooltip( $( this ) );
14936 });
14937
14938 target.removeData( "ui-tooltip-open" );
14939 this._off( target, "mouseleave focusout keyup" );
14940 // Remove 'remove' binding only on delegated targets
14941 if ( target[0] !== this.element[0] ) {
14942 this._off( target, "remove" );
14943 }
14944 this._off( this.document, "mousemove" );
14945
14946 if ( event && event.type === "mouseleave" ) {
14947 $.each( this.parents, function( id, parent ) {
14948 $( parent.element ).attr( "title", parent.title );
14949 delete that.parents[ id ];
14950 });
14951 }
14952
14953 this.closing = true;
14954 this._trigger( "close", event, { tooltip: tooltip } );
14955 this.closing = false;
14956 },
14957
14958 _tooltip: function( element ) {
14959 var id = "ui-tooltip-" + increments++,
14960 tooltip = $( "<div>" )
14961 .attr({
14962 id: id,
14963 role: "tooltip"
14964 })
14965 .addClass( "ui-tooltip ui-widget ui-corner-all ui-widget-content " +
14966 ( this.options.tooltipClass || "" ) );
14967 $( "<div>" )
14968 .addClass( "ui-tooltip-content" )
14969 .appendTo( tooltip );
14970 tooltip.appendTo( this.document[0].body );
14971 this.tooltips[ id ] = element;
14972 return tooltip;
14973 },
14974
14975 _find: function( target ) {
14976 var id = target.data( "ui-tooltip-id" );
14977 return id ? $( "#" + id ) : $();
14978 },
14979
14980 _removeTooltip: function( tooltip ) {
14981 tooltip.remove();
14982 delete this.tooltips[ tooltip.attr( "id" ) ];
14983 },
14984
14985 _destroy: function() {
14986 var that = this;
14987
14988 // close open tooltips
14989 $.each( this.tooltips, function( id, element ) {
14990 // Delegate to close method to handle common cleanup
14991 var event = $.Event( "blur" );
14992 event.target = event.currentTarget = element[0];
14993 that.close( event, true );
14994
14995 // Remove immediately; destroying an open tooltip doesn't use the
14996 // hide animation
14997 $( "#" + id ).remove();
14998
14999 // Restore the title
15000 if ( element.data( "ui-tooltip-title" ) ) {
15001 element.attr( "title", element.data( "ui-tooltip-title" ) );
15002 element.removeData( "ui-tooltip-title" );
15003 }
15004 });
15005 }
15006 });
15007
15008 }( jQuery ) );