1/*! jQuery UI - v1.11.4 - 2016-04-01 2* http://jqueryui.com 3* Includes: core.js, widget.js, mouse.js, position.js, draggable.js, droppable.js, resizable.js, selectable.js, sortable.js, accordion.js, autocomplete.js, button.js, datepicker.js, dialog.js, menu.js, progressbar.js, selectmenu.js, slider.js, spinner.js, tabs.js, effect.js, effect-blind.js, effect-bounce.js, effect-clip.js, effect-drop.js, effect-explode.js, effect-fade.js, effect-fold.js, effect-highlight.js, effect-puff.js, effect-pulsate.js, effect-scale.js, effect-shake.js, effect-size.js, effect-slide.js, effect-transfer.js 4* Copyright
vendor: 32,932 bytes, lines 4-1203
4 jQuery Foundation and other contributors; Licensed MIT */ 5 6(function( factory ) { 7 if ( typeof define === "function" && define.amd ) { 8 9 // AMD. Register as an anonymous module. 10 define([ "jquery" ], factory ); 11 } else { 12 13 // Browser globals 14 factory( jQuery ); 15 } 16}(function( $ ) { 17/*! 18 * jQuery UI Core 1.11.4 19 * http://jqueryui.com 20 * 21 * Copyright jQuery Foundation and other contributors 22 * Released under the MIT license. 23 * http://jquery.org/license 24 * 25 * http://api.jqueryui.com/category/ui-core/ 26 */ 27 28 29// $.ui might exist from components with no dependencies, e.g., $.ui.position 30$.ui = $.ui || {}; 31 32$.extend( $.ui, { 33 version: "1.11.4", 34 35 keyCode: { 36 BACKSPACE: 8, 37 COMMA: 188, 38 DELETE: 46, 39 DOWN: 40, 40 END: 35, 41 ENTER: 13, 42 ESCAPE: 27, 43 HOME: 36, 44 LEFT: 37, 45 PAGE_DOWN: 34, 46 PAGE_UP: 33, 47 PERIOD: 190, 48 RIGHT: 39, 49 SPACE: 32, 50 TAB: 9, 51 UP: 38 52 } 53}); 54 55// plugins 56$.fn.extend({ 57 scrollParent: function( includeHidden ) { 58 var position = this.css( "position" ), 59 excludeStaticParent = position === "absolute", 60 overflowRegex = includeHidden ? /(auto|scroll|hidden)/ : /(auto|scroll)/, 61 scrollParent = this.parents().filter( function() { 62 var parent = $( this ); 63 if ( excludeStaticParent && parent.css( "position" ) === "static" ) { 64 return false; 65 } 66 return overflowRegex.test( parent.css( "overflow" ) + parent.css( "overflow-y" ) + parent.css( "overflow-x" ) ); 67 }).eq( 0 ); 68 69 return position === "fixed" || !scrollParent.length ? $( this[ 0 ].ownerDocument || document ) : scrollParent; 70 }, 71 72 uniqueId: (function() { 73 var uuid = 0; 74 75 return function() { 76 return this.each(function() { 77 if ( !this.id ) { 78 this.id = "ui-id-" + ( ++uuid ); 79 } 80 }); 81 }; 82 })(), 83 84 removeUniqueId: function() { 85 return this.each(function() { 86 if ( /^ui-id-\d+$/.test( this.id ) ) { 87 $( this ).removeAttr( "id" ); 88 } 89 }); 90 } 91}); 92 93// selectors 94function focusable( element, isTabIndexNotNaN ) { 95 var map, mapName, img, 96 nodeName = element.nodeName.toLowerCase(); 97 if ( "area" === nodeName ) { 98 map = element.parentNode; 99 mapName = map.name; 100 if ( !element.href || !mapName || map.nodeName.toLowerCase() !== "map" ) { 101 return false; 102 } 103 img = $( "img[usemap='#" + mapName + "']" )[ 0 ]; 104 return !!img && visible( img ); 105 } 106 return ( /^(input|select|textarea|button|object)$/.test( nodeName ) ? 107 !element.disabled : 108 "a" === nodeName ? 109 element.href || isTabIndexNotNaN : 110 isTabIndexNotNaN) && 111 // the element and all of its ancestors must be visible 112 visible( element ); 113} 114 115function visible( element ) { 116 return $.expr.filters.visible( element ) && 117 !$( element ).parents().addBack().filter(function() { 118 return $.css( this, "visibility" ) === "hidden"; 119 }).length; 120} 121 122$.extend( $.expr[ ":" ], { 123 data: $.expr.createPseudo ? 124 $.expr.createPseudo(function( dataName ) { 125 return function( elem ) { 126 return !!$.data( elem, dataName ); 127 }; 128 }) : 129 // support: jQuery <1.8 130 function( elem, i, match ) { 131 return !!$.data( elem, match[ 3 ] ); 132 }, 133 134 focusable: function( element ) { 135 return focusable( element, !isNaN( $.attr( element, "tabindex" ) ) ); 136 }, 137 138 tabbable: function( element ) { 139 var tabIndex = $.attr( element, "tabindex" ), 140 isTabIndexNaN = isNaN( tabIndex ); 141 return ( isTabIndexNaN || tabIndex >= 0 ) && focusable( element, !isTabIndexNaN ); 142 } 143}); 144 145// support: jQuery <1.8 146if ( !$( "<a>" ).outerWidth( 1 ).jquery ) { 147 $.each( [ "Width", "Height" ], function( i, name ) { 148 var side = name === "Width" ? [ "Left", "Right" ] : [ "Top", "Bottom" ], 149 type = name.toLowerCase(), 150 orig = { 151 innerWidth: $.fn.innerWidth, 152 innerHeight: $.fn.innerHeight, 153 outerWidth: $.fn.outerWidth, 154 outerHeight: $.fn.outerHeight 155 }; 156 157 function reduce( elem, size, border, margin ) { 158 $.each( side, function() { 159 size -= parseFloat( $.css( elem, "padding" + this ) ) || 0; 160 if ( border ) { 161 size -= parseFloat( $.css( elem, "border" + this + "Width" ) ) || 0; 162 } 163 if ( margin ) { 164 size -= parseFloat( $.css( elem, "margin" + this ) ) || 0; 165 } 166 }); 167 return size; 168 } 169 170 $.fn[ "inner" + name ] = function( size ) { 171 if ( size === undefined ) { 172 return orig[ "inner" + name ].call( this ); 173 } 174 175 return this.each(function() { 176 $( this ).css( type, reduce( this, size ) + "px" ); 177 }); 178 }; 179 180 $.fn[ "outer" + name] = function( size, margin ) { 181 if ( typeof size !== "number" ) { 182 return orig[ "outer" + name ].call( this, size ); 183 } 184 185 return this.each(function() { 186 $( this).css( type, reduce( this, size, true, margin ) + "px" ); 187 }); 188 }; 189 }); 190} 191 192// support: jQuery <1.8 193if ( !$.fn.addBack ) { 194 $.fn.addBack = function( selector ) { 195 return this.add( selector == null ? 196 this.prevObject : this.prevObject.filter( selector ) 197 ); 198 }; 199} 200 201// support: jQuery 1.6.1, 1.6.2 (http://bugs.jquery.com/ticket/9413) 202if ( $( "<a>" ).data( "a-b", "a" ).removeData( "a-b" ).data( "a-b" ) ) { 203 $.fn.removeData = (function( removeData ) { 204 return function( key ) { 205 if ( arguments.length ) { 206 return removeData.call( this, $.camelCase( key ) ); 207 } else { 208 return removeData.call( this ); 209 } 210 }; 211 })( $.fn.removeData ); 212} 213 214// deprecated 215$.ui.ie = !!/msie [\w.]+/.exec( navigator.userAgent.toLowerCase() ); 216 217$.fn.extend({ 218 focus: (function( orig ) { 219 return function( delay, fn ) { 220 return typeof delay === "number" ? 221 this.each(function() { 222 var elem = this; 223 setTimeout(function() { 224 $( elem ).focus(); 225 if ( fn ) { 226 fn.call( elem ); 227 } 228 }, delay ); 229 }) : 230 orig.apply( this, arguments ); 231 }; 232 })( $.fn.focus ), 233 234 disableSelection: (function() { 235 var eventType = "onselectstart" in document.createElement( "div" ) ? 236 "selectstart" : 237 "mousedown"; 238 239 return function() { 240 return this.bind( eventType + ".ui-disableSelection", function( event ) { 241 event.preventDefault(); 242 }); 243 }; 244 })(), 245 246 enableSelection: function() { 247 return this.unbind( ".ui-disableSelection" ); 248 }, 249 250 zIndex: function( zIndex ) { 251 if ( zIndex !== undefined ) { 252 return this.css( "zIndex", zIndex ); 253 } 254 255 if ( this.length ) { 256 var elem = $( this[ 0 ] ), position, value; 257 while ( elem.length && elem[ 0 ] !== document ) { 258 // Ignore z-index if position is set to a value where z-index is ignored by the browser 259 // This makes behavior of this function consistent across browsers 260 // WebKit always returns auto if the element is positioned 261 position = elem.css( "position" ); 262 if ( position === "absolute" || position === "relative" || position === "fixed" ) { 263 // IE returns 0 when zIndex is not specified 264 // other browsers return a string 265 // we ignore the case of nested elements with an explicit value of 0 266 // <div style="z-index: -10;"><div style="z-index: 0;"></div></div> 267 value = parseInt( elem.css( "zIndex" ), 10 ); 268 if ( !isNaN( value ) && value !== 0 ) { 269 return value; 270 } 271 } 272 elem = elem.parent(); 273 } 274 } 275 276 return 0; 277 } 278}); 279 280// $.ui.plugin is deprecated. Use $.widget() extensions instead. 281$.ui.plugin = { 282 add: function( module, option, set ) { 283 var i, 284 proto = $.ui[ module ].prototype; 285 for ( i in set ) { 286 proto.plugins[ i ] = proto.plugins[ i ] || []; 287 proto.plugins[ i ].push( [ option, set[ i ] ] ); 288 } 289 }, 290 call: function( instance, name, args, allowDisconnected ) { 291 var i, 292 set = instance.plugins[ name ]; 293 294 if ( !set ) { 295 return; 296 } 297 298 if ( !allowDisconnected && ( !instance.element[ 0 ].parentNode || instance.element[ 0 ].parentNode.nodeType === 11 ) ) { 299 return; 300 } 301 302 for ( i = 0; i < set.length; i++ ) { 303 if ( instance.options[ set[ i ][ 0 ] ] ) { 304 set[ i ][ 1 ].apply( instance.element, args ); 305 } 306 } 307 } 308}; 309 310 311/*! 312 * jQuery UI Widget 1.11.4 313 * http://jqueryui.com 314 * 315 * Copyright jQuery Foundation and other contributors 316 * Released under the MIT license. 317 * http://jquery.org/license 318 * 319 * http://api.jqueryui.com/jQuery.widget/ 320 */ 321 322 323var widget_uuid = 0, 324 widget_slice = Array.prototype.slice; 325 326$.cleanData = (function( orig ) { 327 return function( elems ) { 328 var events, elem, i; 329 for ( i = 0; (elem = elems[i]) != null; i++ ) { 330 try { 331 332 // Only trigger remove when necessary to save time 333 events = $._data( elem, "events" ); 334 if ( events && events.remove ) { 335 $( elem ).triggerHandler( "remove" ); 336 } 337 338 // http://bugs.jquery.com/ticket/8235 339 } catch ( e ) {} 340 } 341 orig( elems ); 342 }; 343})( $.cleanData ); 344 345$.widget = function( name, base, prototype ) { 346 var fullName, existingConstructor, constructor, basePrototype, 347 // proxiedPrototype allows the provided prototype to remain unmodified 348 // so that it can be used as a mixin for multiple widgets (#8876) 349 proxiedPrototype = {}, 350 namespace = name.split( "." )[ 0 ]; 351 352 name = name.split( "." )[ 1 ]; 353 fullName = namespace + "-" + name; 354 355 if ( !prototype ) { 356 prototype = base; 357 base = $.Widget; 358 } 359 360 // create selector for plugin 361 $.expr[ ":" ][ fullName.toLowerCase() ] = function( elem ) { 362 return !!$.data( elem, fullName ); 363 }; 364 365 $[ namespace ] = $[ namespace ] || {}; 366 existingConstructor = $[ namespace ][ name ]; 367 constructor = $[ namespace ][ name ] = function( options, element ) { 368 // allow instantiation without "new" keyword 369 if ( !this._createWidget ) { 370 return new constructor( options, element ); 371 } 372 373 // allow instantiation without initializing for simple inheritance 374 // must use "new" keyword (the code above always passes args) 375 if ( arguments.length ) { 376 this._createWidget( options, element ); 377 } 378 }; 379 // extend with the existing constructor to carry over any static properties 380 $.extend( constructor, existingConstructor, { 381 version: prototype.version, 382 // copy the object used to create the prototype in case we need to 383 // redefine the widget later 384 _proto: $.extend( {}, prototype ), 385 // track widgets that inherit from this widget in case this widget is 386 // redefined after a widget inherits from it 387 _childConstructors: [] 388 }); 389 390 basePrototype = new base(); 391 // we need to make the options hash a property directly on the new instance 392 // otherwise we'll modify the options hash on the prototype that we're 393 // inheriting from 394 basePrototype.options = $.widget.extend( {}, basePrototype.options ); 395 $.each( prototype, function( prop, value ) { 396 if ( !$.isFunction( value ) ) { 397 proxiedPrototype[ prop ] = value; 398 return; 399 } 400 proxiedPrototype[ prop ] = (function() { 401 var _super = function() { 402 return base.prototype[ prop ].apply( this, arguments ); 403 }, 404 _superApply = function( args ) { 405 return base.prototype[ prop ].apply( this, args ); 406 }; 407 return function() { 408 var __super = this._super, 409 __superApply = this._superApply, 410 returnValue; 411 412 this._super = _super; 413 this._superApply = _superApply; 414 415 returnValue = value.apply( this, arguments ); 416 417 this._super = __super; 418 this._superApply = __superApply; 419 420 return returnValue; 421 }; 422 })(); 423 }); 424 constructor.prototype = $.widget.extend( basePrototype, { 425 // TODO: remove support for widgetEventPrefix 426 // always use the name + a colon as the prefix, e.g., draggable:start 427 // don't prefix for widgets that aren't DOM-based 428 widgetEventPrefix: existingConstructor ? (basePrototype.widgetEventPrefix || name) : name 429 }, proxiedPrototype, { 430 constructor: constructor, 431 namespace: namespace, 432 widgetName: name, 433 widgetFullName: fullName 434 }); 435 436 // If this widget is being redefined then we need to find all widgets that 437 // are inheriting from it and redefine all of them so that they inherit from 438 // the new version of this widget. We're essentially trying to replace one 439 // level in the prototype chain. 440 if ( existingConstructor ) { 441 $.each( existingConstructor._childConstructors, function( i, child ) { 442 var childPrototype = child.prototype; 443 444 // redefine the child widget using the same prototype that was 445 // originally used, but inherit from the new version of the base 446 $.widget( childPrototype.namespace + "." + childPrototype.widgetName, constructor, child._proto ); 447 }); 448 // remove the list of existing child constructors from the old constructor 449 // so the old child constructors can be garbage collected 450 delete existingConstructor._childConstructors; 451 } else { 452 base._childConstructors.push( constructor ); 453 } 454 455 $.widget.bridge( name, constructor ); 456 457 return constructor; 458}; 459 460$.widget.extend = function( target ) { 461 var input = widget_slice.call( arguments, 1 ), 462 inputIndex = 0, 463 inputLength = input.length, 464 key, 465 value; 466 for ( ; inputIndex < inputLength; inputIndex++ ) { 467 for ( key in input[ inputIndex ] ) { 468 value = input[ inputIndex ][ key ]; 469 if ( input[ inputIndex ].hasOwnProperty( key ) && value !== undefined ) { 470 // Clone objects 471 if ( $.isPlainObject( value ) ) { 472 target[ key ] = $.isPlainObject( target[ key ] ) ? 473 $.widget.extend( {}, target[ key ], value ) : 474 // Don't extend strings, arrays, etc. with objects 475 $.widget.extend( {}, value ); 476 // Copy everything else by reference 477 } else { 478 target[ key ] = value; 479 } 480 } 481 } 482 } 483 return target; 484}; 485 486$.widget.bridge = function( name, object ) { 487 var fullName = object.prototype.widgetFullName || name; 488 $.fn[ name ] = function( options ) { 489 var isMethodCall = typeof options === "string", 490 args = widget_slice.call( arguments, 1 ), 491 returnValue = this; 492 493 if ( isMethodCall ) { 494 this.each(function() { 495 var methodValue, 496 instance = $.data( this, fullName ); 497 if ( options === "instance" ) { 498 returnValue = instance; 499 return false; 500 } 501 if ( !instance ) { 502 return $.error( "cannot call methods on " + name + " prior to initialization; " + 503 "attempted to call method '" + options + "'" ); 504 } 505 if ( !$.isFunction( instance[options] ) || options.charAt( 0 ) === "_" ) { 506 return $.error( "no such method '" + options + "' for " + name + " widget instance" ); 507 } 508 methodValue = instance[ options ].apply( instance, args ); 509 if ( methodValue !== instance && methodValue !== undefined ) { 510 returnValue = methodValue && methodValue.jquery ? 511 returnValue.pushStack( methodValue.get() ) : 512 methodValue; 513 return false; 514 } 515 }); 516 } else { 517 518 // Allow multiple hashes to be passed on init 519 if ( args.length ) { 520 options = $.widget.extend.apply( null, [ options ].concat(args) ); 521 } 522 523 this.each(function() { 524 var instance = $.data( this, fullName ); 525 if ( instance ) { 526 instance.option( options || {} ); 527 if ( instance._init ) { 528 instance._init(); 529 } 530 } else { 531 $.data( this, fullName, new object( options, this ) ); 532 } 533 }); 534 } 535 536 return returnValue; 537 }; 538}; 539 540$.Widget = function( /* options, element */ ) {}; 541$.Widget._childConstructors = []; 542 543$.Widget.prototype = { 544 widgetName: "widget", 545 widgetEventPrefix: "", 546 defaultElement: "<div>", 547 options: { 548 disabled: false, 549 550 // callbacks 551 create: null 552 }, 553 _createWidget: function( options, element ) { 554 element = $( element || this.defaultElement || this )[ 0 ]; 555 this.element = $( element ); 556 this.uuid = widget_uuid++; 557 this.eventNamespace = "." + this.widgetName + this.uuid; 558 559 this.bindings = $(); 560 this.hoverable = $(); 561 this.focusable = $(); 562 563 if ( element !== this ) { 564 $.data( element, this.widgetFullName, this ); 565 this._on( true, this.element, { 566 remove: function( event ) { 567 if ( event.target === element ) { 568 this.destroy(); 569 } 570 } 571 }); 572 this.document = $( element.style ? 573 // element within the document 574 element.ownerDocument : 575 // element is window or document 576 element.document || element ); 577 this.window = $( this.document[0].defaultView || this.document[0].parentWindow ); 578 } 579 580 this.options = $.widget.extend( {}, 581 this.options, 582 this._getCreateOptions(), 583 options ); 584 585 this._create(); 586 this._trigger( "create", null, this._getCreateEventData() ); 587 this._init(); 588 }, 589 _getCreateOptions: $.noop, 590 _getCreateEventData: $.noop, 591 _create: $.noop, 592 _init: $.noop, 593 594 destroy: function() { 595 this._destroy(); 596 // we can probably remove the unbind calls in 2.0 597 // all event bindings should go through this._on() 598 this.element 599 .unbind( this.eventNamespace ) 600 .removeData( this.widgetFullName ) 601 // support: jquery <1.6.3 602 // http://bugs.jquery.com/ticket/9413 603 .removeData( $.camelCase( this.widgetFullName ) ); 604 this.widget() 605 .unbind( this.eventNamespace ) 606 .removeAttr( "aria-disabled" ) 607 .removeClass( 608 this.widgetFullName + "-disabled " + 609 "ui-state-disabled" ); 610 611 // clean up events and states 612 this.bindings.unbind( this.eventNamespace ); 613 this.hoverable.removeClass( "ui-state-hover" ); 614 this.focusable.removeClass( "ui-state-focus" ); 615 }, 616 _destroy: $.noop, 617 618 widget: function() { 619 return this.element; 620 }, 621 622 option: function( key, value ) { 623 var options = key, 624 parts, 625 curOption, 626 i; 627 628 if ( arguments.length === 0 ) { 629 // don't return a reference to the internal hash 630 return $.widget.extend( {}, this.options ); 631 } 632 633 if ( typeof key === "string" ) { 634 // handle nested keys, e.g., "foo.bar" => { foo: { bar: ___ } } 635 options = {}; 636 parts = key.split( "." ); 637 key = parts.shift(); 638 if ( parts.length ) { 639 curOption = options[ key ] = $.widget.extend( {}, this.options[ key ] ); 640 for ( i = 0; i < parts.length - 1; i++ ) { 641 curOption[ parts[ i ] ] = curOption[ parts[ i ] ] || {}; 642 curOption = curOption[ parts[ i ] ]; 643 } 644 key = parts.pop(); 645 if ( arguments.length === 1 ) { 646 return curOption[ key ] === undefined ? null : curOption[ key ]; 647 } 648 curOption[ key ] = value; 649 } else { 650 if ( arguments.length === 1 ) { 651 return this.options[ key ] === undefined ? null : this.options[ key ]; 652 } 653 options[ key ] = value; 654 } 655 } 656 657 this._setOptions( options ); 658 659 return this; 660 }, 661 _setOptions: function( options ) { 662 var key; 663 664 for ( key in options ) { 665 this._setOption( key, options[ key ] ); 666 } 667 668 return this; 669 }, 670 _setOption: function( key, value ) { 671 this.options[ key ] = value; 672 673 if ( key === "disabled" ) { 674 this.widget() 675 .toggleClass( this.widgetFullName + "-disabled", !!value ); 676 677 // If the widget is becoming disabled, then nothing is interactive 678 if ( value ) { 679 this.hoverable.removeClass( "ui-state-hover" ); 680 this.focusable.removeClass( "ui-state-focus" ); 681 } 682 } 683 684 return this; 685 }, 686 687 enable: function() { 688 return this._setOptions({ disabled: false }); 689 }, 690 disable: function() { 691 return this._setOptions({ disabled: true }); 692 }, 693 694 _on: function( suppressDisabledCheck, element, handlers ) { 695 var delegateElement, 696 instance = this; 697 698 // no suppressDisabledCheck flag, shuffle arguments 699 if ( typeof suppressDisabledCheck !== "boolean" ) { 700 handlers = element; 701 element = suppressDisabledCheck; 702 suppressDisabledCheck = false; 703 } 704 705 // no element argument, shuffle and use this.element 706 if ( !handlers ) { 707 handlers = element; 708 element = this.element; 709 delegateElement = this.widget(); 710 } else { 711 element = delegateElement = $( element ); 712 this.bindings = this.bindings.add( element ); 713 } 714 715 $.each( handlers, function( event, handler ) { 716 function handlerProxy() { 717 // allow widgets to customize the disabled handling 718 // - disabled as an array instead of boolean 719 // - disabled class as method for disabling individual parts 720 if ( !suppressDisabledCheck && 721 ( instance.options.disabled === true || 722 $( this ).hasClass( "ui-state-disabled" ) ) ) { 723 return; 724 } 725 return ( typeof handler === "string" ? instance[ handler ] : handler ) 726 .apply( instance, arguments ); 727 } 728 729 // copy the guid so direct unbinding works 730 if ( typeof handler !== "string" ) { 731 handlerProxy.guid = handler.guid = 732 handler.guid || handlerProxy.guid || $.guid++; 733 } 734 735 var match = event.match( /^([\w:-]*)\s*(.*)$/ ), 736 eventName = match[1] + instance.eventNamespace, 737 selector = match[2]; 738 if ( selector ) { 739 delegateElement.delegate( selector, eventName, handlerProxy ); 740 } else { 741 element.bind( eventName, handlerProxy ); 742 } 743 }); 744 }, 745 746 _off: function( element, eventName ) { 747 eventName = (eventName || "").split( " " ).join( this.eventNamespace + " " ) + 748 this.eventNamespace; 749 element.unbind( eventName ).undelegate( eventName ); 750 751 // Clear the stack to avoid memory leaks (#10056) 752 this.bindings = $( this.bindings.not( element ).get() ); 753 this.focusable = $( this.focusable.not( element ).get() ); 754 this.hoverable = $( this.hoverable.not( element ).get() ); 755 }, 756 757 _delay: function( handler, delay ) { 758 function handlerProxy() { 759 return ( typeof handler === "string" ? instance[ handler ] : handler ) 760 .apply( instance, arguments ); 761 } 762 var instance = this; 763 return setTimeout( handlerProxy, delay || 0 ); 764 }, 765 766 _hoverable: function( element ) { 767 this.hoverable = this.hoverable.add( element ); 768 this._on( element, { 769 mouseenter: function( event ) { 770 $( event.currentTarget ).addClass( "ui-state-hover" ); 771 }, 772 mouseleave: function( event ) { 773 $( event.currentTarget ).removeClass( "ui-state-hover" ); 774 } 775 }); 776 }, 777 778 _focusable: function( element ) { 779 this.focusable = this.focusable.add( element ); 780 this._on( element, { 781 focusin: function( event ) { 782 $( event.currentTarget ).addClass( "ui-state-focus" ); 783 }, 784 focusout: function( event ) { 785 $( event.currentTarget ).removeClass( "ui-state-focus" ); 786 } 787 }); 788 }, 789 790 _trigger: function( type, event, data ) { 791 var prop, orig, 792 callback = this.options[ type ]; 793 794 data = data || {}; 795 event = $.Event( event ); 796 event.type = ( type === this.widgetEventPrefix ? 797 type : 798 this.widgetEventPrefix + type ).toLowerCase(); 799 // the original event may come from any element 800 // so we need to reset the target on the new event 801 event.target = this.element[ 0 ]; 802 803 // copy original event properties over to the new event 804 orig = event.originalEvent; 805 if ( orig ) { 806 for ( prop in orig ) { 807 if ( !( prop in event ) ) { 808 event[ prop ] = orig[ prop ]; 809 } 810 } 811 } 812 813 this.element.trigger( event, data ); 814 return !( $.isFunction( callback ) && 815 callback.apply( this.element[0], [ event ].concat( data ) ) === false || 816 event.isDefaultPrevented() ); 817 } 818}; 819 820$.each( { show: "fadeIn", hide: "fadeOut" }, function( method, defaultEffect ) { 821 $.Widget.prototype[ "_" + method ] = function( element, options, callback ) { 822 if ( typeof options === "string" ) { 823 options = { effect: options }; 824 } 825 var hasOptions, 826 effectName = !options ? 827 method : 828 options === true || typeof options === "number" ? 829 defaultEffect : 830 options.effect || defaultEffect; 831 options = options || {}; 832 if ( typeof options === "number" ) { 833 options = { duration: options }; 834 } 835 hasOptions = !$.isEmptyObject( options ); 836 options.complete = callback; 837 if ( options.delay ) { 838 element.delay( options.delay ); 839 } 840 if ( hasOptions && $.effects && $.effects.effect[ effectName ] ) { 841 element[ method ]( options ); 842 } else if ( effectName !== method && element[ effectName ] ) { 843 element[ effectName ]( options.duration, options.easing, callback ); 844 } else { 845 element.queue(function( next ) { 846 $( this )[ method ](); 847 if ( callback ) { 848 callback.call( element[ 0 ] ); 849 } 850 next(); 851 }); 852 } 853 }; 854}); 855 856var widget = $.widget; 857 858 859/*! 860 * jQuery UI Mouse 1.11.4 861 * http://jqueryui.com 862 * 863 * Copyright jQuery Foundation and other contributors 864 * Released under the MIT license. 865 * http://jquery.org/license 866 * 867 * http://api.jqueryui.com/mouse/ 868 */ 869 870 871var mouseHandled = false; 872$( document ).mouseup( function() { 873 mouseHandled = false; 874}); 875 876var mouse = $.widget("ui.mouse", { 877 version: "1.11.4", 878 options: { 879 cancel: "input,textarea,button,select,option", 880 distance: 1, 881 delay: 0 882 }, 883 _mouseInit: function() { 884 var that = this; 885 886 this.element 887 .bind("mousedown." + this.widgetName, function(event) { 888 return that._mouseDown(event); 889 }) 890 .bind("click." + this.widgetName, function(event) { 891 if (true === $.data(event.target, that.widgetName + ".preventClickEvent")) { 892 $.removeData(event.target, that.widgetName + ".preventClickEvent"); 893 event.stopImmediatePropagation(); 894 return false; 895 } 896 }); 897 898 this.started = false; 899 }, 900 901 // TODO: make sure destroying one instance of mouse doesn't mess with 902 // other instances of mouse 903 _mouseDestroy: function() { 904 this.element.unbind("." + this.widgetName); 905 if ( this._mouseMoveDelegate ) { 906 this.document 907 .unbind("mousemove." + this.widgetName, this._mouseMoveDelegate) 908 .unbind("mouseup." + this.widgetName, this._mouseUpDelegate); 909 } 910 }, 911 912 _mouseDown: function(event) { 913 // don't let more than one widget handle mouseStart 914 if ( mouseHandled ) { 915 return; 916 } 917 918 this._mouseMoved = false; 919 920 // we may have missed mouseup (out of window) 921 (this._mouseStarted && this._mouseUp(event)); 922 923 this._mouseDownEvent = event; 924 925 var that = this, 926 btnIsLeft = (event.which === 1), 927 // event.target.nodeName works around a bug in IE 8 with 928 // disabled inputs (#7620) 929 elIsCancel = (typeof this.options.cancel === "string" && event.target.nodeName ? $(event.target).closest(this.options.cancel).length : false); 930 if (!btnIsLeft || elIsCancel || !this._mouseCapture(event)) { 931 return true; 932 } 933 934 this.mouseDelayMet = !this.options.delay; 935 if (!this.mouseDelayMet) { 936 this._mouseDelayTimer = setTimeout(function() { 937 that.mouseDelayMet = true; 938 }, this.options.delay); 939 } 940 941 if (this._mouseDistanceMet(event) && this._mouseDelayMet(event)) { 942 this._mouseStarted = (this._mouseStart(event) !== false); 943 if (!this._mouseStarted) { 944 event.preventDefault(); 945 return true; 946 } 947 } 948 949 // Click event may never have fired (Gecko & Opera) 950 if (true === $.data(event.target, this.widgetName + ".preventClickEvent")) { 951 $.removeData(event.target, this.widgetName + ".preventClickEvent"); 952 } 953 954 // these delegates are required to keep context 955 this._mouseMoveDelegate = function(event) { 956 return that._mouseMove(event); 957 }; 958 this._mouseUpDelegate = function(event) { 959 return that._mouseUp(event); 960 }; 961 962 this.document 963 .bind( "mousemove." + this.widgetName, this._mouseMoveDelegate ) 964 .bind( "mouseup." + this.widgetName, this._mouseUpDelegate ); 965 966 event.preventDefault(); 967 968 mouseHandled = true; 969 return true; 970 }, 971 972 _mouseMove: function(event) { 973 // Only check for mouseups outside the document if you've moved inside the document 974 // at least once. This prevents the firing of mouseup in the case of IE<9, which will 975 // fire a mousemove event if content is placed under the cursor. See #7778 976 // Support: IE <9 977 if ( this._mouseMoved ) { 978 // IE mouseup check - mouseup happened when mouse was out of window 979 if ($.ui.ie && ( !document.documentMode || document.documentMode < 9 ) && !event.button) { 980 return this._mouseUp(event); 981 982 // Iframe mouseup check - mouseup occurred in another document 983 } else if ( !event.which ) { 984 return this._mouseUp( event ); 985 } 986 } 987 988 if ( event.which || event.button ) { 989 this._mouseMoved = true; 990 } 991 992 if (this._mouseStarted) { 993 this._mouseDrag(event); 994 return event.preventDefault(); 995 } 996 997 if (this._mouseDistanceMet(event) && this._mouseDelayMet(event)) { 998 this._mouseStarted = 999 (this._mouseStart(this._mouseDownEvent, event) !== false); 1000 (this._mouseStarted ? this._mouseDrag(event) : this._mouseUp(event)); 1001 } 1002 1003 return !this._mouseStarted; 1004 }, 1005 1006 _mouseUp: function(event) { 1007 this.document 1008 .unbind( "mousemove." + this.widgetName, this._mouseMoveDelegate ) 1009 .unbind( "mouseup." + this.widgetName, this._mouseUpDelegate ); 1010 1011 if (this._mouseStarted) { 1012 this._mouseStarted = false; 1013 1014 if (event.target === this._mouseDownEvent.target) { 1015 $.data(event.target, this.widgetName + ".preventClickEvent", true); 1016 } 1017 1018 this._mouseStop(event); 1019 } 1020 1021 mouseHandled = false; 1022 return false; 1023 }, 1024 1025 _mouseDistanceMet: function(event) { 1026 return (Math.max( 1027 Math.abs(this._mouseDownEvent.pageX - event.pageX), 1028 Math.abs(this._mouseDownEvent.pageY - event.pageY) 1029 ) >= this.options.distance 1030 ); 1031 }, 1032 1033 _mouseDelayMet: function(/* event */) { 1034 return this.mouseDelayMet; 1035 }, 1036 1037 // These are placeholder methods, to be overriden by extending plugin 1038 _mouseStart: function(/* event */) {}, 1039 _mouseDrag: function(/* event */) {}, 1040 _mouseStop: function(/* event */) {}, 1041 _mouseCapture: function(/* event */) { return true; } 1042}); 1043 1044 1045/*! 1046 * jQuery UI Position 1.11.4 1047 * http://jqueryui.com 1048 * 1049 * Copyright jQuery Foundation and other contributors 1050 * Released under the MIT license. 1051 * http://jquery.org/license 1052 * 1053 * http://api.jqueryui.com/position/ 1054 */ 1055 1056(function() { 1057 1058$.ui = $.ui || {}; 1059 1060var cachedScrollbarWidth, supportsOffsetFractions, 1061 max = Math.max, 1062 abs = Math.abs, 1063 round = Math.round, 1064 rhorizontal = /left|center|right/, 1065 rvertical = /top|center|bottom/, 1066 roffset = /[\+\-]\d+(\.[\d]+)?%?/, 1067 rposition = /^\w+/, 1068 rpercent = /%$/, 1069 _position = $.fn.position; 1070 1071function getOffsets( offsets, width, height ) { 1072 return [ 1073 parseFloat( offsets[ 0 ] ) * ( rpercent.test( offsets[ 0 ] ) ? width / 100 : 1 ), 1074 parseFloat( offsets[ 1 ] ) * ( rpercent.test( offsets[ 1 ] ) ? height / 100 : 1 ) 1075 ]; 1076} 1077 1078function parseCss( element, property ) { 1079 return parseInt( $.css( element, property ), 10 ) || 0; 1080} 1081 1082function getDimensions( elem ) { 1083 var raw = elem[0]; 1084 if ( raw.nodeType === 9 ) { 1085 return { 1086 width: elem.width(), 1087 height: elem.height(), 1088 offset: { top: 0, left: 0 } 1089 }; 1090 } 1091 if ( $.isWindow( raw ) ) { 1092 return { 1093 width: elem.width(), 1094 height: elem.height(), 1095 offset: { top: elem.scrollTop(), left: elem.scrollLeft() } 1096 }; 1097 } 1098 if ( raw.preventDefault ) { 1099 return { 1100 width: 0, 1101 height: 0, 1102 offset: { top: raw.pageY, left: raw.pageX } 1103 }; 1104 } 1105 return { 1106 width: elem.outerWidth(), 1107 height: elem.outerHeight(), 1108 offset: elem.offset() 1109 }; 1110} 1111 1112$.position = { 1113 scrollbarWidth: function() { 1114 if ( cachedScrollbarWidth !== undefined ) { 1115 return cachedScrollbarWidth; 1116 } 1117 var w1, w2, 1118 div = $( "<div style='display:block;position:absolute;width:50px;height:50px;overflow:hidden;'><div style='height:100px;width:auto;'></div></div>" ), 1119 innerDiv = div.children()[0]; 1120 1121 $( "body" ).append( div ); 1122 w1 = innerDiv.offsetWidth; 1123 div.css( "overflow", "scroll" ); 1124 1125 w2 = innerDiv.offsetWidth; 1126 1127 if ( w1 === w2 ) { 1128 w2 = div[0].clientWidth; 1129 } 1130 1131 div.remove(); 1132 1133 return (cachedScrollbarWidth = w1 - w2); 1134 }, 1135 getScrollInfo: function( within ) { 1136 var overflowX = within.isWindow || within.isDocument ? "" : 1137 within.element.css( "overflow-x" ), 1138 overflowY = within.isWindow || within.isDocument ? "" : 1139 within.element.css( "overflow-y" ), 1140 hasOverflowX = overflowX === "scroll" || 1141 ( overflowX === "auto" && within.width < within.element[0].scrollWidth ), 1142 hasOverflowY = overflowY === "scroll" || 1143 ( overflowY === "auto" && within.height < within.element[0].scrollHeight ); 1144 return { 1145 width: hasOverflowY ? $.position.scrollbarWidth() : 0, 1146 height: hasOverflowX ? $.position.scrollbarWidth() : 0 1147 }; 1148 }, 1149 getWithinInfo: function( element ) { 1150 var withinElement = $( element || window ), 1151 isWindow = $.isWindow( withinElement[0] ), 1152 isDocument = !!withinElement[ 0 ] && withinElement[ 0 ].nodeType === 9; 1153 return { 1154 element: withinElement, 1155 isWindow: isWindow, 1156 isDocument: isDocument, 1157 offset: withinElement.offset() || { left: 0, top: 0 }, 1158 scrollLeft: withinElement.scrollLeft(), 1159 scrollTop: withinElement.scrollTop(), 1160 1161 // support: jQuery 1.6.x 1162 // jQuery 1.6 doesn't support .outerWidth/Height() on documents or windows 1163 width: isWindow || isDocument ? withinElement.width() : withinElement.outerWidth(), 1164 height: isWindow || isDocument ? withinElement.height() : withinElement.outerHeight() 1165 }; 1166 } 1167}; 1168 1169$.fn.position = function( options ) { 1170 if ( !options || !options.of ) { 1171 return _position.apply( this, arguments ); 1172 } 1173 1174 // make a copy, we don't want to modify arguments 1175 options = $.extend( {}, options ); 1176 1177 var atOffset, targetWidth, targetHeight, targetOffset, basePosition, dimensions, 1178 target = $( options.of ), 1179 within = $.position.getWithinInfo( options.within ), 1180 scrollInfo = $.position.getScrollInfo( within ), 1181 collision = ( options.collision || "flip" ).split( " " ), 1182 offsets = {}; 1183 1184 dimensions = getDimensions( target ); 1185 if ( target[0].preventDefault ) { 1186 // force left top to allow flipping 1187 options.at = "left top"; 1188 } 1189 targetWidth = dimensions.width; 1190 targetHeight = dimensions.height; 1191 targetOffset = dimensions.offset; 1192 // clone to reuse original targetOffset later 1193 basePosition = $.extend( {}, targetOffset ); 1194 1195 // force my and at to have valid horizontal and vertical positions 1196 // if a value is missing or invalid, it will be converted to center 1197 $.each( [ "my", "at" ], function() { 1198 var pos = ( options[ this ] || "" ).split( " " ), 1199 horizontalOffset, 1200 verticalOffset; 1201 1202 if ( pos.length === 1) { 1203 pos = rhorizontal.test( pos[ 0 ] ) ?
vendor: 9,546 bytes, lines 1204-1485
1204 pos.concat( [ "center" ] ) : 1205 rvertical.test( pos[ 0 ] ) ? 1206 [ "center" ].concat( pos ) : 1207 [ "center", "center" ]; 1208 } 1209 pos[ 0 ] = rhorizontal.test( pos[ 0 ] ) ? pos[ 0 ] : "center"; 1210 pos[ 1 ] = rvertical.test( pos[ 1 ] ) ? pos[ 1 ] : "center"; 1211 1212 // calculate offsets 1213 horizontalOffset = roffset.exec( pos[ 0 ] ); 1214 verticalOffset = roffset.exec( pos[ 1 ] ); 1215 offsets[ this ] = [ 1216 horizontalOffset ? horizontalOffset[ 0 ] : 0, 1217 verticalOffset ? verticalOffset[ 0 ] : 0 1218 ]; 1219 1220 // reduce to just the positions without the offsets 1221 options[ this ] = [ 1222 rposition.exec( pos[ 0 ] )[ 0 ], 1223 rposition.exec( pos[ 1 ] )[ 0 ] 1224 ]; 1225 }); 1226 1227 // normalize collision option 1228 if ( collision.length === 1 ) { 1229 collision[ 1 ] = collision[ 0 ]; 1230 } 1231 1232 if ( options.at[ 0 ] === "right" ) { 1233 basePosition.left += targetWidth; 1234 } else if ( options.at[ 0 ] === "center" ) { 1235 basePosition.left += targetWidth / 2; 1236 } 1237 1238 if ( options.at[ 1 ] === "bottom" ) { 1239 basePosition.top += targetHeight; 1240 } else if ( options.at[ 1 ] === "center" ) { 1241 basePosition.top += targetHeight / 2; 1242 } 1243 1244 atOffset = getOffsets( offsets.at, targetWidth, targetHeight ); 1245 basePosition.left += atOffset[ 0 ]; 1246 basePosition.top += atOffset[ 1 ]; 1247 1248 return this.each(function() { 1249 var collisionPosition, using, 1250 elem = $( this ), 1251 elemWidth = elem.outerWidth(), 1252 elemHeight = elem.outerHeight(), 1253 marginLeft = parseCss( this, "marginLeft" ), 1254 marginTop = parseCss( this, "marginTop" ), 1255 collisionWidth = elemWidth + marginLeft + parseCss( this, "marginRight" ) + scrollInfo.width, 1256 collisionHeight = elemHeight + marginTop + parseCss( this, "marginBottom" ) + scrollInfo.height, 1257 position = $.extend( {}, basePosition ), 1258 myOffset = getOffsets( offsets.my, elem.outerWidth(), elem.outerHeight() ); 1259 1260 if ( options.my[ 0 ] === "right" ) { 1261 position.left -= elemWidth; 1262 } else if ( options.my[ 0 ] === "center" ) { 1263 position.left -= elemWidth / 2; 1264 } 1265 1266 if ( options.my[ 1 ] === "bottom" ) { 1267 position.top -= elemHeight; 1268 } else if ( options.my[ 1 ] === "center" ) { 1269 position.top -= elemHeight / 2; 1270 } 1271 1272 position.left += myOffset[ 0 ]; 1273 position.top += myOffset[ 1 ]; 1274 1275 // if the browser doesn't support fractions, then round for consistent results 1276 if ( !supportsOffsetFractions ) { 1277 position.left = round( position.left ); 1278 position.top = round( position.top ); 1279 } 1280 1281 collisionPosition = { 1282 marginLeft: marginLeft, 1283 marginTop: marginTop 1284 }; 1285 1286 $.each( [ "left", "top" ], function( i, dir ) { 1287 if ( $.ui.position[ collision[ i ] ] ) { 1288 $.ui.position[ collision[ i ] ][ dir ]( position, { 1289 targetWidth: targetWidth, 1290 targetHeight: targetHeight, 1291 elemWidth: elemWidth, 1292 elemHeight: elemHeight, 1293 collisionPosition: collisionPosition, 1294 collisionWidth: collisionWidth, 1295 collisionHeight: collisionHeight, 1296 offset: [ atOffset[ 0 ] + myOffset[ 0 ], atOffset [ 1 ] + myOffset[ 1 ] ], 1297 my: options.my, 1298 at: options.at, 1299 within: within, 1300 elem: elem 1301 }); 1302 } 1303 }); 1304 1305 if ( options.using ) { 1306 // adds feedback as second argument to using callback, if present 1307 using = function( props ) { 1308 var left = targetOffset.left - position.left, 1309 right = left + targetWidth - elemWidth, 1310 top = targetOffset.top - position.top, 1311 bottom = top + targetHeight - elemHeight, 1312 feedback = { 1313 target: { 1314 element: target, 1315 left: targetOffset.left, 1316 top: targetOffset.top, 1317 width: targetWidth, 1318 height: targetHeight 1319 }, 1320 element: { 1321 element: elem, 1322 left: position.left, 1323 top: position.top, 1324 width: elemWidth, 1325 height: elemHeight 1326 }, 1327 horizontal: right < 0 ? "left" : left > 0 ? "right" : "center", 1328 vertical: bottom < 0 ? "top" : top > 0 ? "bottom" : "middle" 1329 }; 1330 if ( targetWidth < elemWidth && abs( left + right ) < targetWidth ) { 1331 feedback.horizontal = "center"; 1332 } 1333 if ( targetHeight < elemHeight && abs( top + bottom ) < targetHeight ) { 1334 feedback.vertical = "middle"; 1335 } 1336 if ( max( abs( left ), abs( right ) ) > max( abs( top ), abs( bottom ) ) ) { 1337 feedback.important = "horizontal"; 1338 } else { 1339 feedback.important = "vertical"; 1340 } 1341 options.using.call( this, props, feedback ); 1342 }; 1343 } 1344 1345 elem.offset( $.extend( position, { using: using } ) ); 1346 }); 1347}; 1348 1349$.ui.position = { 1350 fit: { 1351 left: function( position, data ) { 1352 var within = data.within, 1353 withinOffset = within.isWindow ? within.scrollLeft : within.offset.left, 1354 outerWidth = within.width, 1355 collisionPosLeft = position.left - data.collisionPosition.marginLeft, 1356 overLeft = withinOffset - collisionPosLeft, 1357 overRight = collisionPosLeft + data.collisionWidth - outerWidth - withinOffset, 1358 newOverRight; 1359 1360 // element is wider than within 1361 if ( data.collisionWidth > outerWidth ) { 1362 // element is initially over the left side of within 1363 if ( overLeft > 0 && overRight <= 0 ) { 1364 newOverRight = position.left + overLeft + data.collisionWidth - outerWidth - withinOffset; 1365 position.left += overLeft - newOverRight; 1366 // element is initially over right side of within 1367 } else if ( overRight > 0 && overLeft <= 0 ) { 1368 position.left = withinOffset; 1369 // element is initially over both left and right sides of within 1370 } else { 1371 if ( overLeft > overRight ) { 1372 position.left = withinOffset + outerWidth - data.collisionWidth; 1373 } else { 1374 position.left = withinOffset; 1375 } 1376 } 1377 // too far left -> align with left edge 1378 } else if ( overLeft > 0 ) { 1379 position.left += overLeft; 1380 // too far right -> align with right edge 1381 } else if ( overRight > 0 ) { 1382 position.left -= overRight; 1383 // adjust based on position and margin 1384 } else { 1385 position.left = max( position.left - collisionPosLeft, position.left ); 1386 } 1387 }, 1388 top: function( position, data ) { 1389 var within = data.within, 1390 withinOffset = within.isWindow ? within.scrollTop : within.offset.top, 1391 outerHeight = data.within.height, 1392 collisionPosTop = position.top - data.collisionPosition.marginTop, 1393 overTop = withinOffset - collisionPosTop, 1394 overBottom = collisionPosTop + data.collisionHeight - outerHeight - withinOffset, 1395 newOverBottom; 1396 1397 // element is taller than within 1398 if ( data.collisionHeight > outerHeight ) { 1399 // element is initially over the top of within 1400 if ( overTop > 0 && overBottom <= 0 ) { 1401 newOverBottom = position.top + overTop + data.collisionHeight - outerHeight - withinOffset; 1402 position.top += overTop - newOverBottom; 1403 // element is initially over bottom of within 1404 } else if ( overBottom > 0 && overTop <= 0 ) { 1405 position.top = withinOffset; 1406 // element is initially over both top and bottom of within 1407 } else { 1408 if ( overTop > overBottom ) { 1409 position.top = withinOffset + outerHeight - data.collisionHeight; 1410 } else { 1411 position.top = withinOffset; 1412 } 1413 } 1414 // too far up -> align with top 1415 } else if ( overTop > 0 ) { 1416 position.top += overTop; 1417 // too far down -> align with bottom edge 1418 } else if ( overBottom > 0 ) { 1419 position.top -= overBottom; 1420 // adjust based on position and margin 1421 } else { 1422 position.top = max( position.top - collisionPosTop, position.top ); 1423 } 1424 } 1425 }, 1426 flip: { 1427 left: function( position, data ) { 1428 var within = data.within, 1429 withinOffset = within.offset.left + within.scrollLeft, 1430 outerWidth = within.width, 1431 offsetLeft = within.isWindow ? within.scrollLeft : within.offset.left, 1432 collisionPosLeft = position.left - data.collisionPosition.marginLeft, 1433 overLeft = collisionPosLeft - offsetLeft, 1434 overRight = collisionPosLeft + data.collisionWidth - outerWidth - offsetLeft, 1435 myOffset = data.my[ 0 ] === "left" ? 1436 -data.elemWidth : 1437 data.my[ 0 ] === "right" ? 1438 data.elemWidth : 1439 0, 1440 atOffset = data.at[ 0 ] === "left" ? 1441 data.targetWidth : 1442 data.at[ 0 ] === "right" ? 1443 -data.targetWidth : 1444 0, 1445 offset = -2 * data.offset[ 0 ], 1446 newOverRight, 1447 newOverLeft; 1448 1449 if ( overLeft < 0 ) { 1450 newOverRight = position.left + myOffset + atOffset + offset + data.collisionWidth - outerWidth - withinOffset; 1451 if ( newOverRight < 0 || newOverRight < abs( overLeft ) ) { 1452 position.left += myOffset + atOffset + offset; 1453 } 1454 } else if ( overRight > 0 ) { 1455 newOverLeft = position.left - data.collisionPosition.marginLeft + myOffset + atOffset + offset - offsetLeft; 1456 if ( newOverLeft > 0 || abs( newOverLeft ) < overRight ) { 1457 position.left += myOffset + atOffset + offset; 1458 } 1459 } 1460 }, 1461 top: function( position, data ) { 1462 var within = data.within, 1463 withinOffset = within.offset.top + within.scrollTop, 1464 outerHeight = within.height, 1465 offsetTop = within.isWindow ? within.scrollTop : within.offset.top, 1466 collisionPosTop = position.top - data.collisionPosition.marginTop, 1467 overTop = collisionPosTop - offsetTop, 1468 overBottom = collisionPosTop + data.collisionHeight - outerHeight - offsetTop, 1469 top = data.my[ 1 ] === "top", 1470 myOffset = top ? 1471 -data.elemHeight : 1472 data.my[ 1 ] === "bottom" ? 1473 data.elemHeight : 1474 0, 1475 atOffset = data.at[ 1 ] === "top" ? 1476 data.targetHeight : 1477 data.at[ 1 ] === "bottom" ? 1478 -data.targetHeight : 1479 0, 1480 offset = -2 * data.offset[ 1 ], 1481 newOverTop, 1482 newOverBottom; 1483 if ( overTop < 0 ) { 1484 newOverBottom = position.top + myOffset + atOffset + offset + data.collisionHeight - outerHeight - withinOffset; 1485 if (
vendor: 1,789 bytes, lines 1485-1549
1485newOverBottom < 0 || newOverBottom < abs( overTop ) ) { 1486 position.top += myOffset + atOffset + offset; 1487 } 1488 } else if ( overBottom > 0 ) { 1489 newOverTop = position.top - data.collisionPosition.marginTop + myOffset + atOffset + offset - offsetTop; 1490 if ( newOverTop > 0 || abs( newOverTop ) < overBottom ) { 1491 position.top += myOffset + atOffset + offset; 1492 } 1493 } 1494 } 1495 }, 1496 flipfit: { 1497 left: function() { 1498 $.ui.position.flip.left.apply( this, arguments ); 1499 $.ui.position.fit.left.apply( this, arguments ); 1500 }, 1501 top: function() { 1502 $.ui.position.flip.top.apply( this, arguments ); 1503 $.ui.position.fit.top.apply( this, arguments ); 1504 } 1505 } 1506}; 1507 1508// fraction support test 1509(function() { 1510 var testElement, testElementParent, testElementStyle, offsetLeft, i, 1511 body = document.getElementsByTagName( "body" )[ 0 ], 1512 div = document.createElement( "div" ); 1513 1514 //Create a "fake body" for testing based on method used in jQuery.support 1515 testElement = document.createElement( body ? "div" : "body" ); 1516 testElementStyle = { 1517 visibility: "hidden", 1518 width: 0, 1519 height: 0, 1520 border: 0, 1521 margin: 0, 1522 background: "none" 1523 }; 1524 if ( body ) { 1525 $.extend( testElementStyle, { 1526 position: "absolute", 1527 left: "-1000px", 1528 top: "-1000px" 1529 }); 1530 } 1531 for ( i in testElementStyle ) { 1532 testElement.style[ i ] = testElementStyle[ i ]; 1533 } 1534 testElement.appendChild( div ); 1535 testElementParent = body || document.documentElement; 1536 testElementParent.insertBefore( testElement, testElementParent.firstChild ); 1537 1538 div.style.cssText = "position: absolute; left: 10.7432222px;"; 1539 1540 offsetLeft = $( div ).offset().left; 1541 supportsOffsetFractions = offsetLeft > 10 && offsetLeft < 11; 1542 1543 testElement.innerHTML = ""; 1544 testElementParent.removeChild( testElement ); 1545})(); 1546 1547})(); 1548 1549var position = $.ui.position
vendor: 74,430 bytes, lines 1549-4204
1549; 1550 1551 1552/*! 1553 * jQuery UI Draggable 1.11.4 1554 * http://jqueryui.com 1555 * 1556 * Copyright jQuery Foundation and other contributors 1557 * Released under the MIT license. 1558 * http://jquery.org/license 1559 * 1560 * http://api.jqueryui.com/draggable/ 1561 */ 1562 1563 1564$.widget("ui.draggable", $.ui.mouse, { 1565 version: "1.11.4", 1566 widgetEventPrefix: "drag", 1567 options: { 1568 addClasses: true, 1569 appendTo: "parent", 1570 axis: false, 1571 connectToSortable: false, 1572 containment: false, 1573 cursor: "auto", 1574 cursorAt: false, 1575 grid: false, 1576 handle: false, 1577 helper: "original", 1578 iframeFix: false, 1579 opacity: false, 1580 refreshPositions: false, 1581 revert: false, 1582 revertDuration: 500, 1583 scope: "default", 1584 scroll: true, 1585 scrollSensitivity: 20, 1586 scrollSpeed: 20, 1587 snap: false, 1588 snapMode: "both", 1589 snapTolerance: 20, 1590 stack: false, 1591 zIndex: false, 1592 1593 // callbacks 1594 drag: null, 1595 start: null, 1596 stop: null 1597 }, 1598 _create: function() { 1599 1600 if ( this.options.helper === "original" ) { 1601 this._setPositionRelative(); 1602 } 1603 if (this.options.addClasses){ 1604 this.element.addClass("ui-draggable"); 1605 } 1606 if (this.options.disabled){ 1607 this.element.addClass("ui-draggable-disabled"); 1608 } 1609 this._setHandleClassName(); 1610 1611 this._mouseInit(); 1612 }, 1613 1614 _setOption: function( key, value ) { 1615 this._super( key, value ); 1616 if ( key === "handle" ) { 1617 this._removeHandleClassName(); 1618 this._setHandleClassName(); 1619 } 1620 }, 1621 1622 _destroy: function() { 1623 if ( ( this.helper || this.element ).is( ".ui-draggable-dragging" ) ) { 1624 this.destroyOnClear = true; 1625 return; 1626 } 1627 this.element.removeClass( "ui-draggable ui-draggable-dragging ui-draggable-disabled" ); 1628 this._removeHandleClassName(); 1629 this._mouseDestroy(); 1630 }, 1631 1632 _mouseCapture: function(event) { 1633 var o = this.options; 1634 1635 this._blurActiveElement( event ); 1636 1637 // among others, prevent a drag on a resizable-handle 1638 if (this.helper || o.disabled || $(event.target).closest(".ui-resizable-handle").length > 0) { 1639 return false; 1640 } 1641 1642 //Quit if we're not on a valid handle 1643 this.handle = this._getHandle(event); 1644 if (!this.handle) { 1645 return false; 1646 } 1647 1648 this._blockFrames( o.iframeFix === true ? "iframe" : o.iframeFix ); 1649 1650 return true; 1651 1652 }, 1653 1654 _blockFrames: function( selector ) { 1655 this.iframeBlocks = this.document.find( selector ).map(function() { 1656 var iframe = $( this ); 1657 1658 return $( "<div>" ) 1659 .css( "position", "absolute" ) 1660 .appendTo( iframe.parent() ) 1661 .outerWidth( iframe.outerWidth() ) 1662 .outerHeight( iframe.outerHeight() ) 1663 .offset( iframe.offset() )[ 0 ]; 1664 }); 1665 }, 1666 1667 _unblockFrames: function() { 1668 if ( this.iframeBlocks ) { 1669 this.iframeBlocks.remove(); 1670 delete this.iframeBlocks; 1671 } 1672 }, 1673 1674 _blurActiveElement: function( event ) { 1675 var document = this.document[ 0 ]; 1676 1677 // Only need to blur if the event occurred on the draggable itself, see #10527 1678 if ( !this.handleElement.is( event.target ) ) { 1679 return; 1680 } 1681 1682 // support: IE9 1683 // IE9 throws an "Unspecified error" accessing document.activeElement from an <iframe> 1684 try { 1685 1686 // Support: IE9, IE10 1687 // If the <body> is blurred, IE will switch windows, see #9520 1688 if ( document.activeElement && document.activeElement.nodeName.toLowerCase() !== "body" ) { 1689 1690 // Blur any element that currently has focus, see #4261 1691 $( document.activeElement ).blur(); 1692 } 1693 } catch ( error ) {} 1694 }, 1695 1696 _mouseStart: function(event) { 1697 1698 var o = this.options; 1699 1700 //Create and append the visible helper 1701 this.helper = this._createHelper(event); 1702 1703 this.helper.addClass("ui-draggable-dragging"); 1704 1705 //Cache the helper size 1706 this._cacheHelperProportions(); 1707 1708 //If ddmanager is used for droppables, set the global draggable 1709 if ($.ui.ddmanager) { 1710 $.ui.ddmanager.current = this; 1711 } 1712 1713 /* 1714 * - Position generation - 1715 * This block generates everything position related - it's the core of draggables. 1716 */ 1717 1718 //Cache the margins of the original element 1719 this._cacheMargins(); 1720 1721 //Store the helper's css position 1722 this.cssPosition = this.helper.css( "position" ); 1723 this.scrollParent = this.helper.scrollParent( true ); 1724 this.offsetParent = this.helper.offsetParent(); 1725 this.hasFixedAncestor = this.helper.parents().filter(function() { 1726 return $( this ).css( "position" ) === "fixed"; 1727 }).length > 0; 1728 1729 //The element's absolute position on the page minus margins 1730 this.positionAbs = this.element.offset(); 1731 this._refreshOffsets( event ); 1732 1733 //Generate the original position 1734 this.originalPosition = this.position = this._generatePosition( event, false ); 1735 this.originalPageX = event.pageX; 1736 this.originalPageY = event.pageY; 1737 1738 //Adjust the mouse offset relative to the helper if "cursorAt" is supplied 1739 (o.cursorAt && this._adjustOffsetFromHelper(o.cursorAt)); 1740 1741 //Set a containment if given in the options 1742 this._setContainment(); 1743 1744 //Trigger event + callbacks 1745 if (this._trigger("start", event) === false) { 1746 this._clear(); 1747 return false; 1748 } 1749 1750 //Recache the helper size 1751 this._cacheHelperProportions(); 1752 1753 //Prepare the droppable offsets 1754 if ($.ui.ddmanager && !o.dropBehaviour) { 1755 $.ui.ddmanager.prepareOffsets(this, event); 1756 } 1757 1758 // Reset helper's right/bottom css if they're set and set explicit width/height instead 1759 // as this prevents resizing of elements with right/bottom set (see #7772) 1760 this._normalizeRightBottom(); 1761 1762 this._mouseDrag(event, true); //Execute the drag once - this causes the helper not to be visible before getting its correct position 1763 1764 //If the ddmanager is used for droppables, inform the manager that dragging has started (see #5003) 1765 if ( $.ui.ddmanager ) { 1766 $.ui.ddmanager.dragStart(this, event); 1767 } 1768 1769 return true; 1770 }, 1771 1772 _refreshOffsets: function( event ) { 1773 this.offset = { 1774 top: this.positionAbs.top - this.margins.top, 1775 left: this.positionAbs.left - this.margins.left, 1776 scroll: false, 1777 parent: this._getParentOffset(), 1778 relative: this._getRelativeOffset() 1779 }; 1780 1781 this.offset.click = { 1782 left: event.pageX - this.offset.left, 1783 top: event.pageY - this.offset.top 1784 }; 1785 }, 1786 1787 _mouseDrag: function(event, noPropagation) { 1788 // reset any necessary cached properties (see #5009) 1789 if ( this.hasFixedAncestor ) { 1790 this.offset.parent = this._getParentOffset(); 1791 } 1792 1793 //Compute the helpers position 1794 this.position = this._generatePosition( event, true ); 1795 this.positionAbs = this._convertPositionTo("absolute"); 1796 1797 //Call plugins and callbacks and use the resulting position if something is returned 1798 if (!noPropagation) { 1799 var ui = this._uiHash(); 1800 if (this._trigger("drag", event, ui) === false) { 1801 this._mouseUp({}); 1802 return false; 1803 } 1804 this.position = ui.position; 1805 } 1806 1807 this.helper[ 0 ].style.left = this.position.left + "px"; 1808 this.helper[ 0 ].style.top = this.position.top + "px"; 1809 1810 if ($.ui.ddmanager) { 1811 $.ui.ddmanager.drag(this, event); 1812 } 1813 1814 return false; 1815 }, 1816 1817 _mouseStop: function(event) { 1818 1819 //If we are using droppables, inform the manager about the drop 1820 var that = this, 1821 dropped = false; 1822 if ($.ui.ddmanager && !this.options.dropBehaviour) { 1823 dropped = $.ui.ddmanager.drop(this, event); 1824 } 1825 1826 //if a drop comes from outside (a sortable) 1827 if (this.dropped) { 1828 dropped = this.dropped; 1829 this.dropped = false; 1830 } 1831 1832 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))) { 1833 $(this.helper).animate(this.originalPosition, parseInt(this.options.revertDuration, 10), function() { 1834 if (that._trigger("stop", event) !== false) { 1835 that._clear(); 1836 } 1837 }); 1838 } else { 1839 if (this._trigger("stop", event) !== false) { 1840 this._clear(); 1841 } 1842 } 1843 1844 return false; 1845 }, 1846 1847 _mouseUp: function( event ) { 1848 this._unblockFrames(); 1849 1850 //If the ddmanager is used for droppables, inform the manager that dragging has stopped (see #5003) 1851 if ( $.ui.ddmanager ) { 1852 $.ui.ddmanager.dragStop(this, event); 1853 } 1854 1855 // Only need to focus if the event occurred on the draggable itself, see #10527 1856 if ( this.handleElement.is( event.target ) ) { 1857 // The interaction is over; whether or not the click resulted in a drag, focus the element 1858 this.element.focus(); 1859 } 1860 1861 return $.ui.mouse.prototype._mouseUp.call(this, event); 1862 }, 1863 1864 cancel: function() { 1865 1866 if (this.helper.is(".ui-draggable-dragging")) { 1867 this._mouseUp({}); 1868 } else { 1869 this._clear(); 1870 } 1871 1872 return this; 1873 1874 }, 1875 1876 _getHandle: function(event) { 1877 return this.options.handle ? 1878 !!$( event.target ).closest( this.element.find( this.options.handle ) ).length : 1879 true; 1880 }, 1881 1882 _setHandleClassName: function() { 1883 this.handleElement = this.options.handle ? 1884 this.element.find( this.options.handle ) : this.element; 1885 this.handleElement.addClass( "ui-draggable-handle" ); 1886 }, 1887 1888 _removeHandleClassName: function() { 1889 this.handleElement.removeClass( "ui-draggable-handle" ); 1890 }, 1891 1892 _createHelper: function(event) { 1893 1894 var o = this.options, 1895 helperIsFunction = $.isFunction( o.helper ), 1896 helper = helperIsFunction ? 1897 $( o.helper.apply( this.element[ 0 ], [ event ] ) ) : 1898 ( o.helper === "clone" ? 1899 this.element.clone().removeAttr( "id" ) : 1900 this.element ); 1901 1902 if (!helper.parents("body").length) { 1903 helper.appendTo((o.appendTo === "parent" ? this.element[0].parentNode : o.appendTo)); 1904 } 1905 1906 // http://bugs.jqueryui.com/ticket/9446 1907 // a helper function can return the original element 1908 // which wouldn't have been set to relative in _create 1909 if ( helperIsFunction && helper[ 0 ] === this.element[ 0 ] ) { 1910 this._setPositionRelative(); 1911 } 1912 1913 if (helper[0] !== this.element[0] && !(/(fixed|absolute)/).test(helper.css("position"))) { 1914 helper.css("position", "absolute"); 1915 } 1916 1917 return helper; 1918 1919 }, 1920 1921 _setPositionRelative: function() { 1922 if ( !( /^(?:r|a|f)/ ).test( this.element.css( "position" ) ) ) { 1923 this.element[ 0 ].style.position = "relative"; 1924 } 1925 }, 1926 1927 _adjustOffsetFromHelper: function(obj) { 1928 if (typeof obj === "string") { 1929 obj = obj.split(" "); 1930 } 1931 if ($.isArray(obj)) { 1932 obj = { left: +obj[0], top: +obj[1] || 0 }; 1933 } 1934 if ("left" in obj) { 1935 this.offset.click.left = obj.left + this.margins.left; 1936 } 1937 if ("right" in obj) { 1938 this.offset.click.left = this.helperProportions.width - obj.right + this.margins.left; 1939 } 1940 if ("top" in obj) { 1941 this.offset.click.top = obj.top + this.margins.top; 1942 } 1943 if ("bottom" in obj) { 1944 this.offset.click.top = this.helperProportions.height - obj.bottom + this.margins.top; 1945 } 1946 }, 1947 1948 _isRootNode: function( element ) { 1949 return ( /(html|body)/i ).test( element.tagName ) || element === this.document[ 0 ]; 1950 }, 1951 1952 _getParentOffset: function() { 1953 1954 //Get the offsetParent and cache its position 1955 var po = this.offsetParent.offset(), 1956 document = this.document[ 0 ]; 1957 1958 // This is a special case where we need to modify a offset calculated on start, since the following happened: 1959 // 1. The position of the helper is absolute, so it's position is calculated based on the next positioned parent 1960 // 2. The actual offset parent is a child of the scroll parent, and the scroll parent isn't the document, which means that 1961 // the scroll is included in the initial calculation of the offset of the parent, and never recalculated upon drag 1962 if (this.cssPosition === "absolute" && this.scrollParent[0] !== document && $.contains(this.scrollParent[0], this.offsetParent[0])) { 1963 po.left += this.scrollParent.scrollLeft(); 1964 po.top += this.scrollParent.scrollTop(); 1965 } 1966 1967 if ( this._isRootNode( this.offsetParent[ 0 ] ) ) { 1968 po = { top: 0, left: 0 }; 1969 } 1970 1971 return { 1972 top: po.top + (parseInt(this.offsetParent.css("borderTopWidth"), 10) || 0), 1973 left: po.left + (parseInt(this.offsetParent.css("borderLeftWidth"), 10) || 0) 1974 }; 1975 1976 }, 1977 1978 _getRelativeOffset: function() { 1979 if ( this.cssPosition !== "relative" ) { 1980 return { top: 0, left: 0 }; 1981 } 1982 1983 var p = this.element.position(), 1984 scrollIsRootNode = this._isRootNode( this.scrollParent[ 0 ] ); 1985 1986 return { 1987 top: p.top - ( parseInt(this.helper.css( "top" ), 10) || 0 ) + ( !scrollIsRootNode ? this.scrollParent.scrollTop() : 0 ), 1988 left: p.left - ( parseInt(this.helper.css( "left" ), 10) || 0 ) + ( !scrollIsRootNode ? this.scrollParent.scrollLeft() : 0 ) 1989 }; 1990 1991 }, 1992 1993 _cacheMargins: function() { 1994 this.margins = { 1995 left: (parseInt(this.element.css("marginLeft"), 10) || 0), 1996 top: (parseInt(this.element.css("marginTop"), 10) || 0), 1997 right: (parseInt(this.element.css("marginRight"), 10) || 0), 1998 bottom: (parseInt(this.element.css("marginBottom"), 10) || 0) 1999 }; 2000 }, 2001 2002 _cacheHelperProportions: function() { 2003 this.helperProportions = { 2004 width: this.helper.outerWidth(), 2005 height: this.helper.outerHeight() 2006 }; 2007 }, 2008 2009 _setContainment: function() { 2010 2011 var isUserScrollable, c, ce, 2012 o = this.options, 2013 document = this.document[ 0 ]; 2014 2015 this.relativeContainer = null; 2016 2017 if ( !o.containment ) { 2018 this.containment = null; 2019 return; 2020 } 2021 2022 if ( o.containment === "window" ) { 2023 this.containment = [ 2024 $( window ).scrollLeft() - this.offset.relative.left - this.offset.parent.left, 2025 $( window ).scrollTop() - this.offset.relative.top - this.offset.parent.top, 2026 $( window ).scrollLeft() + $( window ).width() - this.helperProportions.width - this.margins.left, 2027 $( window ).scrollTop() + ( $( window ).height() || document.body.parentNode.scrollHeight ) - this.helperProportions.height - this.margins.top 2028 ]; 2029 return; 2030 } 2031 2032 if ( o.containment === "document") { 2033 this.containment = [ 2034 0, 2035 0, 2036 $( document ).width() - this.helperProportions.width - this.margins.left, 2037 ( $( document ).height() || document.body.parentNode.scrollHeight ) - this.helperProportions.height - this.margins.top 2038 ]; 2039 return; 2040 } 2041 2042 if ( o.containment.constructor === Array ) { 2043 this.containment = o.containment; 2044 return; 2045 } 2046 2047 if ( o.containment === "parent" ) { 2048 o.containment = this.helper[ 0 ].parentNode; 2049 } 2050 2051 c = $( o.containment ); 2052 ce = c[ 0 ]; 2053 2054 if ( !ce ) { 2055 return; 2056 } 2057 2058 isUserScrollable = /(scroll|auto)/.test( c.css( "overflow" ) ); 2059 2060 this.containment = [ 2061 ( parseInt( c.css( "borderLeftWidth" ), 10 ) || 0 ) + ( parseInt( c.css( "paddingLeft" ), 10 ) || 0 ), 2062 ( parseInt( c.css( "borderTopWidth" ), 10 ) || 0 ) + ( parseInt( c.css( "paddingTop" ), 10 ) || 0 ), 2063 ( isUserScrollable ? Math.max( ce.scrollWidth, ce.offsetWidth ) : ce.offsetWidth ) - 2064 ( parseInt( c.css( "borderRightWidth" ), 10 ) || 0 ) - 2065 ( parseInt( c.css( "paddingRight" ), 10 ) || 0 ) - 2066 this.helperProportions.width - 2067 this.margins.left - 2068 this.margins.right, 2069 ( isUserScrollable ? Math.max( ce.scrollHeight, ce.offsetHeight ) : ce.offsetHeight ) - 2070 ( parseInt( c.css( "borderBottomWidth" ), 10 ) || 0 ) - 2071 ( parseInt( c.css( "paddingBottom" ), 10 ) || 0 ) - 2072 this.helperProportions.height - 2073 this.margins.top - 2074 this.margins.bottom 2075 ]; 2076 this.relativeContainer = c; 2077 }, 2078 2079 _convertPositionTo: function(d, pos) { 2080 2081 if (!pos) { 2082 pos = this.position; 2083 } 2084 2085 var mod = d === "absolute" ? 1 : -1, 2086 scrollIsRootNode = this._isRootNode( this.scrollParent[ 0 ] ); 2087 2088 return { 2089 top: ( 2090 pos.top + // The absolute mouse position 2091 this.offset.relative.top * mod + // Only for relative positioned nodes: Relative offset from element to offset parent 2092 this.offset.parent.top * mod - // The offsetParent's offset without borders (offset + border) 2093 ( ( this.cssPosition === "fixed" ? -this.offset.scroll.top : ( scrollIsRootNode ? 0 : this.offset.scroll.top ) ) * mod) 2094 ), 2095 left: ( 2096 pos.left + // The absolute mouse position 2097 this.offset.relative.left * mod + // Only for relative positioned nodes: Relative offset from element to offset parent 2098 this.offset.parent.left * mod - // The offsetParent's offset without borders (offset + border) 2099 ( ( this.cssPosition === "fixed" ? -this.offset.scroll.left : ( scrollIsRootNode ? 0 : this.offset.scroll.left ) ) * mod) 2100 ) 2101 }; 2102 2103 }, 2104 2105 _generatePosition: function( event, constrainPosition ) { 2106 2107 var containment, co, top, left, 2108 o = this.options, 2109 scrollIsRootNode = this._isRootNode( this.scrollParent[ 0 ] ), 2110 pageX = event.pageX, 2111 pageY = event.pageY; 2112 2113 // Cache the scroll 2114 if ( !scrollIsRootNode || !this.offset.scroll ) { 2115 this.offset.scroll = { 2116 top: this.scrollParent.scrollTop(), 2117 left: this.scrollParent.scrollLeft() 2118 }; 2119 } 2120 2121 /* 2122 * - Position constraining - 2123 * Constrain the position to a mix of grid, containment. 2124 */ 2125 2126 // If we are not dragging yet, we won't check for options 2127 if ( constrainPosition ) { 2128 if ( this.containment ) { 2129 if ( this.relativeContainer ){ 2130 co = this.relativeContainer.offset(); 2131 containment = [ 2132 this.containment[ 0 ] + co.left, 2133 this.containment[ 1 ] + co.top, 2134 this.containment[ 2 ] + co.left, 2135 this.containment[ 3 ] + co.top 2136 ]; 2137 } else { 2138 containment = this.containment; 2139 } 2140 2141 if (event.pageX - this.offset.click.left < containment[0]) { 2142 pageX = containment[0] + this.offset.click.left; 2143 } 2144 if (event.pageY - this.offset.click.top < containment[1]) { 2145 pageY = containment[1] + this.offset.click.top; 2146 } 2147 if (event.pageX - this.offset.click.left > containment[2]) { 2148 pageX = containment[2] + this.offset.click.left; 2149 } 2150 if (event.pageY - this.offset.click.top > containment[3]) { 2151 pageY = containment[3] + this.offset.click.top; 2152 } 2153 } 2154 2155 if (o.grid) { 2156 //Check for grid elements set to 0 to prevent divide by 0 error causing invalid argument errors in IE (see ticket #6950) 2157 top = o.grid[1] ? this.originalPageY + Math.round((pageY - this.originalPageY) / o.grid[1]) * o.grid[1] : this.originalPageY; 2158 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; 2159 2160 left = o.grid[0] ? this.originalPageX + Math.round((pageX - this.originalPageX) / o.grid[0]) * o.grid[0] : this.originalPageX; 2161 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; 2162 } 2163 2164 if ( o.axis === "y" ) { 2165 pageX = this.originalPageX; 2166 } 2167 2168 if ( o.axis === "x" ) { 2169 pageY = this.originalPageY; 2170 } 2171 } 2172 2173 return { 2174 top: ( 2175 pageY - // The absolute mouse position 2176 this.offset.click.top - // Click offset (relative to the element) 2177 this.offset.relative.top - // Only for relative positioned nodes: Relative offset from element to offset parent 2178 this.offset.parent.top + // The offsetParent's offset without borders (offset + border) 2179 ( this.cssPosition === "fixed" ? -this.offset.scroll.top : ( scrollIsRootNode ? 0 : this.offset.scroll.top ) ) 2180 ), 2181 left: ( 2182 pageX - // The absolute mouse position 2183 this.offset.click.left - // Click offset (relative to the element) 2184 this.offset.relative.left - // Only for relative positioned nodes: Relative offset from element to offset parent 2185 this.offset.parent.left + // The offsetParent's offset without borders (offset + border) 2186 ( this.cssPosition === "fixed" ? -this.offset.scroll.left : ( scrollIsRootNode ? 0 : this.offset.scroll.left ) ) 2187 ) 2188 }; 2189 2190 }, 2191 2192 _clear: function() { 2193 this.helper.removeClass("ui-draggable-dragging"); 2194 if (this.helper[0] !== this.element[0] && !this.cancelHelperRemoval) { 2195 this.helper.remove(); 2196 } 2197 this.helper = null; 2198 this.cancelHelperRemoval = false; 2199 if ( this.destroyOnClear ) { 2200 this.destroy(); 2201 } 2202 }, 2203 2204 _normalizeRightBottom: function() { 2205 if ( this.options.axis !== "y" && this.helper.css( "right" ) !== "auto" ) { 2206 this.helper.width( this.helper.width() ); 2207 this.helper.css( "right", "auto" ); 2208 } 2209 if ( this.options.axis !== "x" && this.helper.css( "bottom" ) !== "auto" ) { 2210 this.helper.height( this.helper.height() ); 2211 this.helper.css( "bottom", "auto" ); 2212 } 2213 }, 2214 2215 // From now on bulk stuff - mainly helpers 2216 2217 _trigger: function( type, event, ui ) { 2218 ui = ui || this._uiHash(); 2219 $.ui.plugin.call( this, type, [ event, ui, this ], true ); 2220 2221 // Absolute position and offset (see #6884 ) have to be recalculated after plugins 2222 if ( /^(drag|start|stop)/.test( type ) ) { 2223 this.positionAbs = this._convertPositionTo( "absolute" ); 2224 ui.offset = this.positionAbs; 2225 } 2226 return $.Widget.prototype._trigger.call( this, type, event, ui ); 2227 }, 2228 2229 plugins: {}, 2230 2231 _uiHash: function() { 2232 return { 2233 helper: this.helper, 2234 position: this.position, 2235 originalPosition: this.originalPosition, 2236 offset: this.positionAbs 2237 }; 2238 } 2239 2240}); 2241 2242$.ui.plugin.add( "draggable", "connectToSortable", { 2243 start: function( event, ui, draggable ) { 2244 var uiSortable = $.extend( {}, ui, { 2245 item: draggable.element 2246 }); 2247 2248 draggable.sortables = []; 2249 $( draggable.options.connectToSortable ).each(function() { 2250 var sortable = $( this ).sortable( "instance" ); 2251 2252 if ( sortable && !sortable.options.disabled ) { 2253 draggable.sortables.push( sortable ); 2254 2255 // refreshPositions is called at drag start to refresh the containerCache 2256 // which is used in drag. This ensures it's initialized and synchronized 2257 // with any changes that might have happened on the page since initialization. 2258 sortable.refreshPositions(); 2259 sortable._trigger("activate", event, uiSortable); 2260 } 2261 }); 2262 }, 2263 stop: function( event, ui, draggable ) { 2264 var uiSortable = $.extend( {}, ui, { 2265 item: draggable.element 2266 }); 2267 2268 draggable.cancelHelperRemoval = false; 2269 2270 $.each( draggable.sortables, function() { 2271 var sortable = this; 2272 2273 if ( sortable.isOver ) { 2274 sortable.isOver = 0; 2275 2276 // Allow this sortable to handle removing the helper 2277 draggable.cancelHelperRemoval = true; 2278 sortable.cancelHelperRemoval = false; 2279 2280 // Use _storedCSS To restore properties in the sortable, 2281 // as this also handles revert (#9675) since the draggable 2282 // may have modified them in unexpected ways (#8809) 2283 sortable._storedCSS = { 2284 position: sortable.placeholder.css( "position" ), 2285 top: sortable.placeholder.css( "top" ), 2286 left: sortable.placeholder.css( "left" ) 2287 }; 2288 2289 sortable._mouseStop(event); 2290 2291 // Once drag has ended, the sortable should return to using 2292 // its original helper, not the shared helper from draggable 2293 sortable.options.helper = sortable.options._helper; 2294 } else { 2295 // Prevent this Sortable from removing the helper. 2296 // However, don't set the draggable to remove the helper 2297 // either as another connected Sortable may yet handle the removal. 2298 sortable.cancelHelperRemoval = true; 2299 2300 sortable._trigger( "deactivate", event, uiSortable ); 2301 } 2302 }); 2303 }, 2304 drag: function( event, ui, draggable ) { 2305 $.each( draggable.sortables, function() { 2306 var innermostIntersecting = false, 2307 sortable = this; 2308 2309 // Copy over variables that sortable's _intersectsWith uses 2310 sortable.positionAbs = draggable.positionAbs; 2311 sortable.helperProportions = draggable.helperProportions; 2312 sortable.offset.click = draggable.offset.click; 2313 2314 if ( sortable._intersectsWith( sortable.containerCache ) ) { 2315 innermostIntersecting = true; 2316 2317 $.each( draggable.sortables, function() { 2318 // Copy over variables that sortable's _intersectsWith uses 2319 this.positionAbs = draggable.positionAbs; 2320 this.helperProportions = draggable.helperProportions; 2321 this.offset.click = draggable.offset.click; 2322 2323 if ( this !== sortable && 2324 this._intersectsWith( this.containerCache ) && 2325 $.contains( sortable.element[ 0 ], this.element[ 0 ] ) ) { 2326 innermostIntersecting = false; 2327 } 2328 2329 return innermostIntersecting; 2330 }); 2331 } 2332 2333 if ( innermostIntersecting ) { 2334 // If it intersects, we use a little isOver variable and set it once, 2335 // so that the move-in stuff gets fired only once. 2336 if ( !sortable.isOver ) { 2337 sortable.isOver = 1; 2338 2339 // Store draggable's parent in case we need to reappend to it later. 2340 draggable._parent = ui.helper.parent(); 2341 2342 sortable.currentItem = ui.helper 2343 .appendTo( sortable.element ) 2344 .data( "ui-sortable-item", true ); 2345 2346 // Store helper option to later restore it 2347 sortable.options._helper = sortable.options.helper; 2348 2349 sortable.options.helper = function() { 2350 return ui.helper[ 0 ]; 2351 }; 2352 2353 // Fire the start events of the sortable with our passed browser event, 2354 // and our own helper (so it doesn't create a new one) 2355 event.target = sortable.currentItem[ 0 ]; 2356 sortable._mouseCapture( event, true ); 2357 sortable._mouseStart( event, true, true ); 2358 2359 // Because the browser event is way off the new appended portlet, 2360 // modify necessary variables to reflect the changes 2361 sortable.offset.click.top = draggable.offset.click.top; 2362 sortable.offset.click.left = draggable.offset.click.left; 2363 sortable.offset.parent.left -= draggable.offset.parent.left - 2364 sortable.offset.parent.left; 2365 sortable.offset.parent.top -= draggable.offset.parent.top - 2366 sortable.offset.parent.top; 2367 2368 draggable._trigger( "toSortable", event ); 2369 2370 // Inform draggable that the helper is in a valid drop zone, 2371 // used solely in the revert option to handle "valid/invalid". 2372 draggable.dropped = sortable.element; 2373 2374 // Need to refreshPositions of all sortables in the case that 2375 // adding to one sortable changes the location of the other sortables (#9675) 2376 $.each( draggable.sortables, function() { 2377 this.refreshPositions(); 2378 }); 2379 2380 // hack so receive/update callbacks work (mostly) 2381 draggable.currentItem = draggable.element; 2382 sortable.fromOutside = draggable; 2383 } 2384 2385 if ( sortable.currentItem ) { 2386 sortable._mouseDrag( event ); 2387 // Copy the sortable's position because the draggable's can potentially reflect 2388 // a relative position, while sortable is always absolute, which the dragged 2389 // element has now become. (#8809) 2390 ui.position = sortable.position; 2391 } 2392 } else { 2393 // If it doesn't intersect with the sortable, and it intersected before, 2394 // we fake the drag stop of the sortable, but make sure it doesn't remove 2395 // the helper by using cancelHelperRemoval. 2396 if ( sortable.isOver ) { 2397 2398 sortable.isOver = 0; 2399 sortable.cancelHelperRemoval = true; 2400 2401 // Calling sortable's mouseStop would trigger a revert, 2402 // so revert must be temporarily false until after mouseStop is called. 2403 sortable.options._revert = sortable.options.revert; 2404 sortable.options.revert = false; 2405 2406 sortable._trigger( "out", event, sortable._uiHash( sortable ) ); 2407 sortable._mouseStop( event, true ); 2408 2409 // restore sortable behaviors that were modfied 2410 // when the draggable entered the sortable area (#9481) 2411 sortable.options.revert = sortable.options._revert; 2412 sortable.options.helper = sortable.options._helper; 2413 2414 if ( sortable.placeholder ) { 2415 sortable.placeholder.remove(); 2416 } 2417 2418 // Restore and recalculate the draggable's offset considering the sortable 2419 // may have modified them in unexpected ways. (#8809, #10669) 2420 ui.helper.appendTo( draggable._parent ); 2421 draggable._refreshOffsets( event ); 2422 ui.position = draggable._generatePosition( event, true ); 2423 2424 draggable._trigger( "fromSortable", event ); 2425 2426 // Inform draggable that the helper is no longer in a valid drop zone 2427 draggable.dropped = false; 2428 2429 // Need to refreshPositions of all sortables just in case removing 2430 // from one sortable changes the location of other sortables (#9675) 2431 $.each( draggable.sortables, function() { 2432 this.refreshPositions(); 2433 }); 2434 } 2435 } 2436 }); 2437 } 2438}); 2439 2440$.ui.plugin.add("draggable", "cursor", { 2441 start: function( event, ui, instance ) { 2442 var t = $( "body" ), 2443 o = instance.options; 2444 2445 if (t.css("cursor")) { 2446 o._cursor = t.css("cursor"); 2447 } 2448 t.css("cursor", o.cursor); 2449 }, 2450 stop: function( event, ui, instance ) { 2451 var o = instance.options; 2452 if (o._cursor) { 2453 $("body").css("cursor", o._cursor); 2454 } 2455 } 2456}); 2457 2458$.ui.plugin.add("draggable", "opacity", { 2459 start: function( event, ui, instance ) { 2460 var t = $( ui.helper ), 2461 o = instance.options; 2462 if (t.css("opacity")) { 2463 o._opacity = t.css("opacity"); 2464 } 2465 t.css("opacity", o.opacity); 2466 }, 2467 stop: function( event, ui, instance ) { 2468 var o = instance.options; 2469 if (o._opacity) { 2470 $(ui.helper).css("opacity", o._opacity); 2471 } 2472 } 2473}); 2474 2475$.ui.plugin.add("draggable", "scroll", { 2476 start: function( event, ui, i ) { 2477 if ( !i.scrollParentNotHidden ) { 2478 i.scrollParentNotHidden = i.helper.scrollParent( false ); 2479 } 2480 2481 if ( i.scrollParentNotHidden[ 0 ] !== i.document[ 0 ] && i.scrollParentNotHidden[ 0 ].tagName !== "HTML" ) { 2482 i.overflowOffset = i.scrollParentNotHidden.offset(); 2483 } 2484 }, 2485 drag: function( event, ui, i ) { 2486 2487 var o = i.options, 2488 scrolled = false, 2489 scrollParent = i.scrollParentNotHidden[ 0 ], 2490 document = i.document[ 0 ]; 2491 2492 if ( scrollParent !== document && scrollParent.tagName !== "HTML" ) { 2493 if ( !o.axis || o.axis !== "x" ) { 2494 if ( ( i.overflowOffset.top + scrollParent.offsetHeight ) - event.pageY < o.scrollSensitivity ) { 2495 scrollParent.scrollTop = scrolled = scrollParent.scrollTop + o.scrollSpeed; 2496 } else if ( event.pageY - i.overflowOffset.top < o.scrollSensitivity ) { 2497 scrollParent.scrollTop = scrolled = scrollParent.scrollTop - o.scrollSpeed; 2498 } 2499 } 2500 2501 if ( !o.axis || o.axis !== "y" ) { 2502 if ( ( i.overflowOffset.left + scrollParent.offsetWidth ) - event.pageX < o.scrollSensitivity ) { 2503 scrollParent.scrollLeft = scrolled = scrollParent.scrollLeft + o.scrollSpeed; 2504 } else if ( event.pageX - i.overflowOffset.left < o.scrollSensitivity ) { 2505 scrollParent.scrollLeft = scrolled = scrollParent.scrollLeft - o.scrollSpeed; 2506 } 2507 } 2508 2509 } else { 2510 2511 if (!o.axis || o.axis !== "x") { 2512 if (event.pageY - $(document).scrollTop() < o.scrollSensitivity) { 2513 scrolled = $(document).scrollTop($(document).scrollTop() - o.scrollSpeed); 2514 } else if ($(window).height() - (event.pageY - $(document).scrollTop()) < o.scrollSensitivity) { 2515 scrolled = $(document).scrollTop($(document).scrollTop() + o.scrollSpeed); 2516 } 2517 } 2518 2519 if (!o.axis || o.axis !== "y") { 2520 if (event.pageX - $(document).scrollLeft() < o.scrollSensitivity) { 2521 scrolled = $(document).scrollLeft($(document).scrollLeft() - o.scrollSpeed); 2522 } else if ($(window).width() - (event.pageX - $(document).scrollLeft()) < o.scrollSensitivity) { 2523 scrolled = $(document).scrollLeft($(document).scrollLeft() + o.scrollSpeed); 2524 } 2525 } 2526 2527 } 2528 2529 if (scrolled !== false && $.ui.ddmanager && !o.dropBehaviour) { 2530 $.ui.ddmanager.prepareOffsets(i, event); 2531 } 2532 2533 } 2534}); 2535 2536$.ui.plugin.add("draggable", "snap", { 2537 start: function( event, ui, i ) { 2538 2539 var o = i.options; 2540 2541 i.snapElements = []; 2542 2543 $(o.snap.constructor !== String ? ( o.snap.items || ":data(ui-draggable)" ) : o.snap).each(function() { 2544 var $t = $(this), 2545 $o = $t.offset(); 2546 if (this !== i.element[0]) { 2547 i.snapElements.push({ 2548 item: this, 2549 width: $t.outerWidth(), height: $t.outerHeight(), 2550 top: $o.top, left: $o.left 2551 }); 2552 } 2553 }); 2554 2555 }, 2556 drag: function( event, ui, inst ) { 2557 2558 var ts, bs, ls, rs, l, r, t, b, i, first, 2559 o = inst.options, 2560 d = o.snapTolerance, 2561 x1 = ui.offset.left, x2 = x1 + inst.helperProportions.width, 2562 y1 = ui.offset.top, y2 = y1 + inst.helperProportions.height; 2563 2564 for (i = inst.snapElements.length - 1; i >= 0; i--){ 2565 2566 l = inst.snapElements[i].left - inst.margins.left; 2567 r = l + inst.snapElements[i].width; 2568 t = inst.snapElements[i].top - inst.margins.top; 2569 b = t + inst.snapElements[i].height; 2570 2571 if ( x2 < l - d || x1 > r + d || y2 < t - d || y1 > b + d || !$.contains( inst.snapElements[ i ].item.ownerDocument, inst.snapElements[ i ].item ) ) { 2572 if (inst.snapElements[i].snapping) { 2573 (inst.options.snap.release && inst.options.snap.release.call(inst.element, event, $.extend(inst._uiHash(), { snapItem: inst.snapElements[i].item }))); 2574 } 2575 inst.snapElements[i].snapping = false; 2576 continue; 2577 } 2578 2579 if (o.snapMode !== "inner") { 2580 ts = Math.abs(t - y2) <= d; 2581 bs = Math.abs(b - y1) <= d; 2582 ls = Math.abs(l - x2) <= d; 2583 rs = Math.abs(r - x1) <= d; 2584 if (ts) { 2585 ui.position.top = inst._convertPositionTo("relative", { top: t - inst.helperProportions.height, left: 0 }).top; 2586 } 2587 if (bs) { 2588 ui.position.top = inst._convertPositionTo("relative", { top: b, left: 0 }).top; 2589 } 2590 if (ls) { 2591 ui.position.left = inst._convertPositionTo("relative", { top: 0, left: l - inst.helperProportions.width }).left; 2592 } 2593 if (rs) { 2594 ui.position.left = inst._convertPositionTo("relative", { top: 0, left: r }).left; 2595 } 2596 } 2597 2598 first = (ts || bs || ls || rs); 2599 2600 if (o.snapMode !== "outer") { 2601 ts = Math.abs(t - y1) <= d; 2602 bs = Math.abs(b - y2) <= d; 2603 ls = Math.abs(l - x1) <= d; 2604 rs = Math.abs(r - x2) <= d; 2605 if (ts) { 2606 ui.position.top = inst._convertPositionTo("relative", { top: t, left: 0 }).top; 2607 } 2608 if (bs) { 2609 ui.position.top = inst._convertPositionTo("relative", { top: b - inst.helperProportions.height, left: 0 }).top; 2610 } 2611 if (ls) { 2612 ui.position.left = inst._convertPositionTo("relative", { top: 0, left: l }).left; 2613 } 2614 if (rs) { 2615 ui.position.left = inst._convertPositionTo("relative", { top: 0, left: r - inst.helperProportions.width }).left; 2616 } 2617 } 2618 2619 if (!inst.snapElements[i].snapping && (ts || bs || ls || rs || first)) { 2620 (inst.options.snap.snap && inst.options.snap.snap.call(inst.element, event, $.extend(inst._uiHash(), { snapItem: inst.snapElements[i].item }))); 2621 } 2622 inst.snapElements[i].snapping = (ts || bs || ls || rs || first); 2623 2624 } 2625 2626 } 2627}); 2628 2629$.ui.plugin.add("draggable", "stack", { 2630 start: function( event, ui, instance ) { 2631 var min, 2632 o = instance.options, 2633 group = $.makeArray($(o.stack)).sort(function(a, b) { 2634 return (parseInt($(a).css("zIndex"), 10) || 0) - (parseInt($(b).css("zIndex"), 10) || 0); 2635 }); 2636 2637 if (!group.length) { return; } 2638 2639 min = parseInt($(group[0]).css("zIndex"), 10) || 0; 2640 $(group).each(function(i) { 2641 $(this).css("zIndex", min + i); 2642 }); 2643 this.css("zIndex", (min + group.length)); 2644 } 2645}); 2646 2647$.ui.plugin.add("draggable", "zIndex", { 2648 start: function( event, ui, instance ) { 2649 var t = $( ui.helper ), 2650 o = instance.options; 2651 2652 if (t.css("zIndex")) { 2653 o._zIndex = t.css("zIndex"); 2654 } 2655 t.css("zIndex", o.zIndex); 2656 }, 2657 stop: function( event, ui, instance ) { 2658 var o = instance.options; 2659 2660 if (o._zIndex) { 2661 $(ui.helper).css("zIndex", o._zIndex); 2662 } 2663 } 2664}); 2665 2666var draggable = $.ui.draggable; 2667 2668 2669/*! 2670 * jQuery UI Droppable 1.11.4 2671 * http://jqueryui.com 2672 * 2673 * Copyright jQuery Foundation and other contributors 2674 * Released under the MIT license. 2675 * http://jquery.org/license 2676 * 2677 * http://api.jqueryui.com/droppable/ 2678 */ 2679 2680 2681$.widget( "ui.droppable", { 2682 version: "1.11.4", 2683 widgetEventPrefix: "drop", 2684 options: { 2685 accept: "*", 2686 activeClass: false, 2687 addClasses: true, 2688 greedy: false, 2689 hoverClass: false, 2690 scope: "default", 2691 tolerance: "intersect", 2692 2693 // callbacks 2694 activate: null, 2695 deactivate: null, 2696 drop: null, 2697 out: null, 2698 over: null 2699 }, 2700 _create: function() { 2701 2702 var proportions, 2703 o = this.options, 2704 accept = o.accept; 2705 2706 this.isover = false; 2707 this.isout = true; 2708 2709 this.accept = $.isFunction( accept ) ? accept : function( d ) { 2710 return d.is( accept ); 2711 }; 2712 2713 this.proportions = function( /* valueToWrite */ ) { 2714 if ( arguments.length ) { 2715 // Store the droppable's proportions 2716 proportions = arguments[ 0 ]; 2717 } else { 2718 // Retrieve or derive the droppable's proportions 2719 return proportions ? 2720 proportions : 2721 proportions = { 2722 width: this.element[ 0 ].offsetWidth, 2723 height: this.element[ 0 ].offsetHeight 2724 }; 2725 } 2726 }; 2727 2728 this._addToManager( o.scope ); 2729 2730 o.addClasses && this.element.addClass( "ui-droppable" ); 2731 2732 }, 2733 2734 _addToManager: function( scope ) { 2735 // Add the reference and positions to the manager 2736 $.ui.ddmanager.droppables[ scope ] = $.ui.ddmanager.droppables[ scope ] || []; 2737 $.ui.ddmanager.droppables[ scope ].push( this ); 2738 }, 2739 2740 _splice: function( drop ) { 2741 var i = 0; 2742 for ( ; i < drop.length; i++ ) { 2743 if ( drop[ i ] === this ) { 2744 drop.splice( i, 1 ); 2745 } 2746 } 2747 }, 2748 2749 _destroy: function() { 2750 var drop = $.ui.ddmanager.droppables[ this.options.scope ]; 2751 2752 this._splice( drop ); 2753 2754 this.element.removeClass( "ui-droppable ui-droppable-disabled" ); 2755 }, 2756 2757 _setOption: function( key, value ) { 2758 2759 if ( key === "accept" ) { 2760 this.accept = $.isFunction( value ) ? value : function( d ) { 2761 return d.is( value ); 2762 }; 2763 } else if ( key === "scope" ) { 2764 var drop = $.ui.ddmanager.droppables[ this.options.scope ]; 2765 2766 this._splice( drop ); 2767 this._addToManager( value ); 2768 } 2769 2770 this._super( key, value ); 2771 }, 2772 2773 _activate: function( event ) { 2774 var draggable = $.ui.ddmanager.current; 2775 if ( this.options.activeClass ) { 2776 this.element.addClass( this.options.activeClass ); 2777 } 2778 if ( draggable ){ 2779 this._trigger( "activate", event, this.ui( draggable ) ); 2780 } 2781 }, 2782 2783 _deactivate: function( event ) { 2784 var draggable = $.ui.ddmanager.current; 2785 if ( this.options.activeClass ) { 2786 this.element.removeClass( this.options.activeClass ); 2787 } 2788 if ( draggable ){ 2789 this._trigger( "deactivate", event, this.ui( draggable ) ); 2790 } 2791 }, 2792 2793 _over: function( event ) { 2794 2795 var draggable = $.ui.ddmanager.current; 2796 2797 // Bail if draggable and droppable are same element 2798 if ( !draggable || ( draggable.currentItem || draggable.element )[ 0 ] === this.element[ 0 ] ) { 2799 return; 2800 } 2801 2802 if ( this.accept.call( this.element[ 0 ], ( draggable.currentItem || draggable.element ) ) ) { 2803 if ( this.options.hoverClass ) { 2804 this.element.addClass( this.options.hoverClass ); 2805 } 2806 this._trigger( "over", event, this.ui( draggable ) ); 2807 } 2808 2809 }, 2810 2811 _out: function( event ) { 2812 2813 var draggable = $.ui.ddmanager.current; 2814 2815 // Bail if draggable and droppable are same element 2816 if ( !draggable || ( draggable.currentItem || draggable.element )[ 0 ] === this.element[ 0 ] ) { 2817 return; 2818 } 2819 2820 if ( this.accept.call( this.element[ 0 ], ( draggable.currentItem || draggable.element ) ) ) { 2821 if ( this.options.hoverClass ) { 2822 this.element.removeClass( this.options.hoverClass ); 2823 } 2824 this._trigger( "out", event, this.ui( draggable ) ); 2825 } 2826 2827 }, 2828 2829 _drop: function( event, custom ) { 2830 2831 var draggable = custom || $.ui.ddmanager.current, 2832 childrenIntersection = false; 2833 2834 // Bail if draggable and droppable are same element 2835 if ( !draggable || ( draggable.currentItem || draggable.element )[ 0 ] === this.element[ 0 ] ) { 2836 return false; 2837 } 2838 2839 this.element.find( ":data(ui-droppable)" ).not( ".ui-draggable-dragging" ).each(function() { 2840 var inst = $( this ).droppable( "instance" ); 2841 if ( 2842 inst.options.greedy && 2843 !inst.options.disabled && 2844 inst.options.scope === draggable.options.scope && 2845 inst.accept.call( inst.element[ 0 ], ( draggable.currentItem || draggable.element ) ) && 2846 $.ui.intersect( draggable, $.extend( inst, { offset: inst.element.offset() } ), inst.options.tolerance, event ) 2847 ) { childrenIntersection = true; return false; } 2848 }); 2849 if ( childrenIntersection ) { 2850 return false; 2851 } 2852 2853 if ( this.accept.call( this.element[ 0 ], ( draggable.currentItem || draggable.element ) ) ) { 2854 if ( this.options.activeClass ) { 2855 this.element.removeClass( this.options.activeClass ); 2856 } 2857 if ( this.options.hoverClass ) { 2858 this.element.removeClass( this.options.hoverClass ); 2859 } 2860 this._trigger( "drop", event, this.ui( draggable ) ); 2861 return this.element; 2862 } 2863 2864 return false; 2865 2866 }, 2867 2868 ui: function( c ) { 2869 return { 2870 draggable: ( c.currentItem || c.element ), 2871 helper: c.helper, 2872 position: c.position, 2873 offset: c.positionAbs 2874 }; 2875 } 2876 2877}); 2878 2879$.ui.intersect = (function() { 2880 function isOverAxis( x, reference, size ) { 2881 return ( x >= reference ) && ( x < ( reference + size ) ); 2882 } 2883 2884 return function( draggable, droppable, toleranceMode, event ) { 2885 2886 if ( !droppable.offset ) { 2887 return false; 2888 } 2889 2890 var x1 = ( draggable.positionAbs || draggable.position.absolute ).left + draggable.margins.left, 2891 y1 = ( draggable.positionAbs || draggable.position.absolute ).top + draggable.margins.top, 2892 x2 = x1 + draggable.helperProportions.width, 2893 y2 = y1 + draggable.helperProportions.height, 2894 l = droppable.offset.left, 2895 t = droppable.offset.top, 2896 r = l + droppable.proportions().width, 2897 b = t + droppable.proportions().height; 2898 2899 switch ( toleranceMode ) { 2900 case "fit": 2901 return ( l <= x1 && x2 <= r && t <= y1 && y2 <= b ); 2902 case "intersect": 2903 return ( l < x1 + ( draggable.helperProportions.width / 2 ) && // Right Half 2904 x2 - ( draggable.helperProportions.width / 2 ) < r && // Left Half 2905 t < y1 + ( draggable.helperProportions.height / 2 ) && // Bottom Half 2906 y2 - ( draggable.helperProportions.height / 2 ) < b ); // Top Half 2907 case "pointer": 2908 return isOverAxis( event.pageY, t, droppable.proportions().height ) && isOverAxis( event.pageX, l, droppable.proportions().width ); 2909 case "touch": 2910 return ( 2911 ( y1 >= t && y1 <= b ) || // Top edge touching 2912 ( y2 >= t && y2 <= b ) || // Bottom edge touching 2913 ( y1 < t && y2 > b ) // Surrounded vertically 2914 ) && ( 2915 ( x1 >= l && x1 <= r ) || // Left edge touching 2916 ( x2 >= l && x2 <= r ) || // Right edge touching 2917 ( x1 < l && x2 > r ) // Surrounded horizontally 2918 ); 2919 default: 2920 return false; 2921 } 2922 }; 2923})(); 2924 2925/* 2926 This manager tracks offsets of draggables and droppables 2927*/ 2928$.ui.ddmanager = { 2929 current: null, 2930 droppables: { "default": [] }, 2931 prepareOffsets: function( t, event ) { 2932 2933 var i, j, 2934 m = $.ui.ddmanager.droppables[ t.options.scope ] || [], 2935 type = event ? event.type : null, // workaround for #2317 2936 list = ( t.currentItem || t.element ).find( ":data(ui-droppable)" ).addBack(); 2937 2938 droppablesLoop: for ( i = 0; i < m.length; i++ ) { 2939 2940 // No disabled and non-accepted 2941 if ( m[ i ].options.disabled || ( t && !m[ i ].accept.call( m[ i ].element[ 0 ], ( t.currentItem || t.element ) ) ) ) { 2942 continue; 2943 } 2944 2945 // Filter out elements in the current dragged item 2946 for ( j = 0; j < list.length; j++ ) { 2947 if ( list[ j ] === m[ i ].element[ 0 ] ) { 2948 m[ i ].proportions().height = 0; 2949 continue droppablesLoop; 2950 } 2951 } 2952 2953 m[ i ].visible = m[ i ].element.css( "display" ) !== "none"; 2954 if ( !m[ i ].visible ) { 2955 continue; 2956 } 2957 2958 // Activate the droppable if used directly from draggables 2959 if ( type === "mousedown" ) { 2960 m[ i ]._activate.call( m[ i ], event ); 2961 } 2962 2963 m[ i ].offset = m[ i ].element.offset(); 2964 m[ i ].proportions({ width: m[ i ].element[ 0 ].offsetWidth, height: m[ i ].element[ 0 ].offsetHeight }); 2965 2966 } 2967 2968 }, 2969 drop: function( draggable, event ) { 2970 2971 var dropped = false; 2972 // Create a copy of the droppables in case the list changes during the drop (#9116) 2973 $.each( ( $.ui.ddmanager.droppables[ draggable.options.scope ] || [] ).slice(), function() { 2974 2975 if ( !this.options ) { 2976 return; 2977 } 2978 if ( !this.options.disabled && this.visible && $.ui.intersect( draggable, this, this.options.tolerance, event ) ) { 2979 dropped = this._drop.call( this, event ) || dropped; 2980 } 2981 2982 if ( !this.options.disabled && this.visible && this.accept.call( this.element[ 0 ], ( draggable.currentItem || draggable.element ) ) ) { 2983 this.isout = true; 2984 this.isover = false; 2985 this._deactivate.call( this, event ); 2986 } 2987 2988 }); 2989 return dropped; 2990 2991 }, 2992 dragStart: function( draggable, event ) { 2993 // Listen for scrolling so that if the dragging causes scrolling the position of the droppables can be recalculated (see #5003) 2994 draggable.element.parentsUntil( "body" ).bind( "scroll.droppable", function() { 2995 if ( !draggable.options.refreshPositions ) { 2996 $.ui.ddmanager.prepareOffsets( draggable, event ); 2997 } 2998 }); 2999 }, 3000 drag: function( draggable, event ) { 3001 3002 // If you have a highly dynamic page, you might try this option. It renders positions every time you move the mouse. 3003 if ( draggable.options.refreshPositions ) { 3004 $.ui.ddmanager.prepareOffsets( draggable, event ); 3005 } 3006 3007 // Run through all droppables and check their positions based on specific tolerance options 3008 $.each( $.ui.ddmanager.droppables[ draggable.options.scope ] || [], function() { 3009 3010 if ( this.options.disabled || this.greedyChild || !this.visible ) { 3011 return; 3012 } 3013 3014 var parentInstance, scope, parent, 3015 intersects = $.ui.intersect( draggable, this, this.options.tolerance, event ), 3016 c = !intersects && this.isover ? "isout" : ( intersects && !this.isover ? "isover" : null ); 3017 if ( !c ) { 3018 return; 3019 } 3020 3021 if ( this.options.greedy ) { 3022 // find droppable parents with same scope 3023 scope = this.options.scope; 3024 parent = this.element.parents( ":data(ui-droppable)" ).filter(function() { 3025 return $( this ).droppable( "instance" ).options.scope === scope; 3026 }); 3027 3028 if ( parent.length ) { 3029 parentInstance = $( parent[ 0 ] ).droppable( "instance" ); 3030 parentInstance.greedyChild = ( c === "isover" ); 3031 } 3032 } 3033 3034 // we just moved into a greedy child 3035 if ( parentInstance && c === "isover" ) { 3036 parentInstance.isover = false; 3037 parentInstance.isout = true; 3038 parentInstance._out.call( parentInstance, event ); 3039 } 3040 3041 this[ c ] = true; 3042 this[c === "isout" ? "isover" : "isout"] = false; 3043 this[c === "isover" ? "_over" : "_out"].call( this, event ); 3044 3045 // we just moved out of a greedy child 3046 if ( parentInstance && c === "isout" ) { 3047 parentInstance.isout = false; 3048 parentInstance.isover = true; 3049 parentInstance._over.call( parentInstance, event ); 3050 } 3051 }); 3052 3053 }, 3054 dragStop: function( draggable, event ) { 3055 draggable.element.parentsUntil( "body" ).unbind( "scroll.droppable" ); 3056 // Call prepareOffsets one final time since IE does not fire return scroll events when overflow was caused by drag (see #5003) 3057 if ( !draggable.options.refreshPositions ) { 3058 $.ui.ddmanager.prepareOffsets( draggable, event ); 3059 } 3060 } 3061}; 3062 3063var droppable = $.ui.droppable; 3064 3065 3066/*! 3067 * jQuery UI Resizable 1.11.4 3068 * http://jqueryui.com 3069 * 3070 * Copyright jQuery Foundation and other contributors 3071 * Released under the MIT license. 3072 * http://jquery.org/license 3073 * 3074 * http://api.jqueryui.com/resizable/ 3075 */ 3076 3077 3078$.widget("ui.resizable", $.ui.mouse, { 3079 version: "1.11.4", 3080 widgetEventPrefix: "resize", 3081 options: { 3082 alsoResize: false, 3083 animate: false, 3084 animateDuration: "slow", 3085 animateEasing: "swing", 3086 aspectRatio: false, 3087 autoHide: false, 3088 containment: false, 3089 ghost: false, 3090 grid: false, 3091 handles: "e,s,se", 3092 helper: false, 3093 maxHeight: null, 3094 maxWidth: null, 3095 minHeight: 10, 3096 minWidth: 10, 3097 // See #7960 3098 zIndex: 90, 3099 3100 // callbacks 3101 resize: null, 3102 start: null, 3103 stop: null 3104 }, 3105 3106 _num: function( value ) { 3107 return parseInt( value, 10 ) || 0; 3108 }, 3109 3110 _isNumber: function( value ) { 3111 return !isNaN( parseInt( value, 10 ) ); 3112 }, 3113 3114 _hasScroll: function( el, a ) { 3115 3116 if ( $( el ).css( "overflow" ) === "hidden") { 3117 return false; 3118 } 3119 3120 var scroll = ( a && a === "left" ) ? "scrollLeft" : "scrollTop", 3121 has = false; 3122 3123 if ( el[ scroll ] > 0 ) { 3124 return true; 3125 } 3126 3127 // TODO: determine which cases actually cause this to happen 3128 // if the element doesn't have the scroll set, see if it's possible to 3129 // set the scroll 3130 el[ scroll ] = 1; 3131 has = ( el[ scroll ] > 0 ); 3132 el[ scroll ] = 0; 3133 return has; 3134 }, 3135 3136 _create: function() { 3137 3138 var n, i, handle, axis, hname, 3139 that = this, 3140 o = this.options; 3141 this.element.addClass("ui-resizable"); 3142 3143 $.extend(this, { 3144 _aspectRatio: !!(o.aspectRatio), 3145 aspectRatio: o.aspectRatio, 3146 originalElement: this.element, 3147 _proportionallyResizeElements: [], 3148 _helper: o.helper || o.ghost || o.animate ? o.helper || "ui-resizable-helper" : null 3149 }); 3150 3151 // Wrap the element if it cannot hold child nodes 3152 if (this.element[0].nodeName.match(/^(canvas|textarea|input|select|button|img)$/i)) { 3153 3154 this.element.wrap( 3155 $("<div class='ui-wrapper' style='overflow: hidden;'></div>").css({ 3156 position: this.element.css("position"), 3157 width: this.element.outerWidth(), 3158 height: this.element.outerHeight(), 3159 top: this.element.css("top"), 3160 left: this.element.css("left") 3161 }) 3162 ); 3163 3164 this.element = this.element.parent().data( 3165 "ui-resizable", this.element.resizable( "instance" ) 3166 ); 3167 3168 this.elementIsWrapper = true; 3169 3170 this.element.css({ 3171 marginLeft: this.originalElement.css("marginLeft"), 3172 marginTop: this.originalElement.css("marginTop"), 3173 marginRight: this.originalElement.css("marginRight"), 3174 marginBottom: this.originalElement.css("marginBottom") 3175 }); 3176 this.originalElement.css({ 3177 marginLeft: 0, 3178 marginTop: 0, 3179 marginRight: 0, 3180 marginBottom: 0 3181 }); 3182 // support: Safari 3183 // Prevent Safari textarea resize 3184 this.originalResizeStyle = this.originalElement.css("resize"); 3185 this.originalElement.css("resize", "none"); 3186 3187 this._proportionallyResizeElements.push( this.originalElement.css({ 3188 position: "static", 3189 zoom: 1, 3190 display: "block" 3191 }) ); 3192 3193 // support: IE9 3194 // avoid IE jump (hard set the margin) 3195 this.originalElement.css({ margin: this.originalElement.css("margin") }); 3196 3197 this._proportionallyResize(); 3198 } 3199 3200 this.handles = o.handles || 3201 ( !$(".ui-resizable-handle", this.element).length ? 3202 "e,s,se" : { 3203 n: ".ui-resizable-n", 3204 e: ".ui-resizable-e", 3205 s: ".ui-resizable-s", 3206 w: ".ui-resizable-w", 3207 se: ".ui-resizable-se", 3208 sw: ".ui-resizable-sw", 3209 ne: ".ui-resizable-ne", 3210 nw: ".ui-resizable-nw" 3211 } ); 3212 3213 this._handles = $(); 3214 if ( this.handles.constructor === String ) { 3215 3216 if ( this.handles === "all") { 3217 this.handles = "n,e,s,w,se,sw,ne,nw"; 3218 } 3219 3220 n = this.handles.split(","); 3221 this.handles = {}; 3222 3223 for (i = 0; i < n.length; i++) { 3224 3225 handle = $.trim(n[i]); 3226 hname = "ui-resizable-" + handle; 3227 axis = $("<div class='ui-resizable-handle " + hname + "'></div>"); 3228 3229 axis.css({ zIndex: o.zIndex }); 3230 3231 // TODO : What's going on here? 3232 if ("se" === handle) { 3233 axis.addClass("ui-icon ui-icon-gripsmall-diagonal-se"); 3234 } 3235 3236 this.handles[handle] = ".ui-resizable-" + handle; 3237 this.element.append(axis); 3238 } 3239 3240 } 3241 3242 this._renderAxis = function(target) { 3243 3244 var i, axis, padPos, padWrapper; 3245 3246 target = target || this.element; 3247 3248 for (i in this.handles) { 3249 3250 if (this.handles[i].constructor === String) { 3251 this.handles[i] = this.element.children( this.handles[ i ] ).first().show(); 3252 } else if ( this.handles[ i ].jquery || this.handles[ i ].nodeType ) { 3253 this.handles[ i ] = $( this.handles[ i ] ); 3254 this._on( this.handles[ i ], { "mousedown": that._mouseDown }); 3255 } 3256 3257 if (this.elementIsWrapper && this.originalElement[0].nodeName.match(/^(textarea|input|select|button)$/i)) { 3258 3259 axis = $(this.handles[i], this.element); 3260 3261 padWrapper = /sw|ne|nw|se|n|s/.test(i) ? axis.outerHeight() : axis.outerWidth(); 3262 3263 padPos = [ "padding", 3264 /ne|nw|n/.test(i) ? "Top" : 3265 /se|sw|s/.test(i) ? "Bottom" : 3266 /^e$/.test(i) ? "Right" : "Left" ].join(""); 3267 3268 target.css(padPos, padWrapper); 3269 3270 this._proportionallyResize(); 3271 } 3272 3273 this._handles = this._handles.add( this.handles[ i ] ); 3274 } 3275 }; 3276 3277 // TODO: make renderAxis a prototype function 3278 this._renderAxis(this.element); 3279 3280 this._handles = this._handles.add( this.element.find( ".ui-resizable-handle" ) ); 3281 this._handles.disableSelection(); 3282 3283 this._handles.mouseover(function() { 3284 if (!that.resizing) { 3285 if (this.className) { 3286 axis = this.className.match(/ui-resizable-(se|sw|ne|nw|n|e|s|w)/i); 3287 } 3288 that.axis = axis && axis[1] ? axis[1] : "se"; 3289 } 3290 }); 3291 3292 if (o.autoHide) { 3293 this._handles.hide(); 3294 $(this.element) 3295 .addClass("ui-resizable-autohide") 3296 .mouseenter(function() { 3297 if (o.disabled) { 3298 return; 3299 } 3300 $(this).removeClass("ui-resizable-autohide"); 3301 that._handles.show(); 3302 }) 3303 .mouseleave(function() { 3304 if (o.disabled) { 3305 return; 3306 } 3307 if (!that.resizing) { 3308 $(this).addClass("ui-resizable-autohide"); 3309 that._handles.hide(); 3310 } 3311 }); 3312 } 3313 3314 this._mouseInit(); 3315 }, 3316 3317 _destroy: function() { 3318 3319 this._mouseDestroy(); 3320 3321 var wrapper, 3322 _destroy = function(exp) { 3323 $(exp) 3324 .removeClass("ui-resizable ui-resizable-disabled ui-resizable-resizing") 3325 .removeData("resizable") 3326 .removeData("ui-resizable") 3327 .unbind(".resizable") 3328 .find(".ui-resizable-handle") 3329 .remove(); 3330 }; 3331 3332 // TODO: Unwrap at same DOM position 3333 if (this.elementIsWrapper) { 3334 _destroy(this.element); 3335 wrapper = this.element; 3336 this.originalElement.css({ 3337 position: wrapper.css("position"), 3338 width: wrapper.outerWidth(), 3339 height: wrapper.outerHeight(), 3340 top: wrapper.css("top"), 3341 left: wrapper.css("left") 3342 }).insertAfter( wrapper ); 3343 wrapper.remove(); 3344 } 3345 3346 this.originalElement.css("resize", this.originalResizeStyle); 3347 _destroy(this.originalElement); 3348 3349 return this; 3350 }, 3351 3352 _mouseCapture: function(event) { 3353 var i, handle, 3354 capture = false; 3355 3356 for (i in this.handles) { 3357 handle = $(this.handles[i])[0]; 3358 if (handle === event.target || $.contains(handle, event.target)) { 3359 capture = true; 3360 } 3361 } 3362 3363 return !this.options.disabled && capture; 3364 }, 3365 3366 _mouseStart: function(event) { 3367 3368 var curleft, curtop, cursor, 3369 o = this.options, 3370 el = this.element; 3371 3372 this.resizing = true; 3373 3374 this._renderProxy(); 3375 3376 curleft = this._num(this.helper.css("left")); 3377 curtop = this._num(this.helper.css("top")); 3378 3379 if (o.containment) { 3380 curleft += $(o.containment).scrollLeft() || 0; 3381 curtop += $(o.containment).scrollTop() || 0; 3382 } 3383 3384 this.offset = this.helper.offset(); 3385 this.position = { left: curleft, top: curtop }; 3386 3387 this.size = this._helper ? { 3388 width: this.helper.width(), 3389 height: this.helper.height() 3390 } : { 3391 width: el.width(), 3392 height: el.height() 3393 }; 3394 3395 this.originalSize = this._helper ? { 3396 width: el.outerWidth(), 3397 height: el.outerHeight() 3398 } : { 3399 width: el.width(), 3400 height: el.height() 3401 }; 3402 3403 this.sizeDiff = { 3404 width: el.outerWidth() - el.width(), 3405 height: el.outerHeight() - el.height() 3406 }; 3407 3408 this.originalPosition = { left: curleft, top: curtop }; 3409 this.originalMousePosition = { left: event.pageX, top: event.pageY }; 3410 3411 this.aspectRatio = (typeof o.aspectRatio === "number") ? 3412 o.aspectRatio : 3413 ((this.originalSize.width / this.originalSize.height) || 1); 3414 3415 cursor = $(".ui-resizable-" + this.axis).css("cursor"); 3416 $("body").css("cursor", cursor === "auto" ? this.axis + "-resize" : cursor); 3417 3418 el.addClass("ui-resizable-resizing"); 3419 this._propagate("start", event); 3420 return true; 3421 }, 3422 3423 _mouseDrag: function(event) { 3424 3425 var data, props, 3426 smp = this.originalMousePosition, 3427 a = this.axis, 3428 dx = (event.pageX - smp.left) || 0, 3429 dy = (event.pageY - smp.top) || 0, 3430 trigger = this._change[a]; 3431 3432 this._updatePrevProperties(); 3433 3434 if (!trigger) { 3435 return false; 3436 } 3437 3438 data = trigger.apply(this, [ event, dx, dy ]); 3439 3440 this._updateVirtualBoundaries(event.shiftKey); 3441 if (this._aspectRatio || event.shiftKey) { 3442 data = this._updateRatio(data, event); 3443 } 3444 3445 data = this._respectSize(data, event); 3446 3447 this._updateCache(data); 3448 3449 this._propagate("resize", event); 3450 3451 props = this._applyChanges(); 3452 3453 if ( !this._helper && this._proportionallyResizeElements.length ) { 3454 this._proportionallyResize(); 3455 } 3456 3457 if ( !$.isEmptyObject( props ) ) { 3458 this._updatePrevProperties(); 3459 this._trigger( "resize", event, this.ui() ); 3460 this._applyChanges(); 3461 } 3462 3463 return false; 3464 }, 3465 3466 _mouseStop: function(event) { 3467 3468 this.resizing = false; 3469 var pr, ista, soffseth, soffsetw, s, left, top, 3470 o = this.options, that = this; 3471 3472 if (this._helper) { 3473 3474 pr = this._proportionallyResizeElements; 3475 ista = pr.length && (/textarea/i).test(pr[0].nodeName); 3476 soffseth = ista && this._hasScroll(pr[0], "left") ? 0 : that.sizeDiff.height; 3477 soffsetw = ista ? 0 : that.sizeDiff.width; 3478 3479 s = { 3480 width: (that.helper.width() - soffsetw), 3481 height: (that.helper.height() - soffseth) 3482 }; 3483 left = (parseInt(that.element.css("left"), 10) + 3484 (that.position.left - that.originalPosition.left)) || null; 3485 top = (parseInt(that.element.css("top"), 10) + 3486 (that.position.top - that.originalPosition.top)) || null; 3487 3488 if (!o.animate) { 3489 this.element.css($.extend(s, { top: top, left: left })); 3490 } 3491 3492 that.helper.height(that.size.height); 3493 that.helper.width(that.size.width); 3494 3495 if (this._helper && !o.animate) { 3496 this._proportionallyResize(); 3497 } 3498 } 3499 3500 $("body").css("cursor", "auto"); 3501 3502 this.element.removeClass("ui-resizable-resizing"); 3503 3504 this._propagate("stop", event); 3505 3506 if (this._helper) { 3507 this.helper.remove(); 3508 } 3509 3510 return false; 3511 3512 }, 3513 3514 _updatePrevProperties: function() { 3515 this.prevPosition = { 3516 top: this.position.top, 3517 left: this.position.left 3518 }; 3519 this.prevSize = { 3520 width: this.size.width, 3521 height: this.size.height 3522 }; 3523 }, 3524 3525 _applyChanges: function() { 3526 var props = {}; 3527 3528 if ( this.position.top !== this.prevPosition.top ) { 3529 props.top = this.position.top + "px"; 3530 } 3531 if ( this.position.left !== this.prevPosition.left ) { 3532 props.left = this.position.left + "px"; 3533 } 3534 if ( this.size.width !== this.prevSize.width ) { 3535 props.width = this.size.width + "px"; 3536 } 3537 if ( this.size.height !== this.prevSize.height ) { 3538 props.height = this.size.height + "px"; 3539 } 3540 3541 this.helper.css( props ); 3542 3543 return props; 3544 }, 3545 3546 _updateVirtualBoundaries: function(forceAspectRatio) { 3547 var pMinWidth, pMaxWidth, pMinHeight, pMaxHeight, b, 3548 o = this.options; 3549 3550 b = { 3551 minWidth: this._isNumber(o.minWidth) ? o.minWidth : 0, 3552 maxWidth: this._isNumber(o.maxWidth) ? o.maxWidth : Infinity, 3553 minHeight: this._isNumber(o.minHeight) ? o.minHeight : 0, 3554 maxHeight: this._isNumber(o.maxHeight) ? o.maxHeight : Infinity 3555 }; 3556 3557 if (this._aspectRatio || forceAspectRatio) { 3558 pMinWidth = b.minHeight * this.aspectRatio; 3559 pMinHeight = b.minWidth / this.aspectRatio; 3560 pMaxWidth = b.maxHeight * this.aspectRatio; 3561 pMaxHeight = b.maxWidth / this.aspectRatio; 3562 3563 if (pMinWidth > b.minWidth) { 3564 b.minWidth = pMinWidth; 3565 } 3566 if (pMinHeight > b.minHeight) { 3567 b.minHeight = pMinHeight; 3568 } 3569 if (pMaxWidth < b.maxWidth) { 3570 b.maxWidth = pMaxWidth; 3571 } 3572 if (pMaxHeight < b.maxHeight) { 3573 b.maxHeight = pMaxHeight; 3574 } 3575 } 3576 this._vBoundaries = b; 3577 }, 3578 3579 _updateCache: function(data) { 3580 this.offset = this.helper.offset(); 3581 if (this._isNumber(data.left)) { 3582 this.position.left = data.left; 3583 } 3584 if (this._isNumber(data.top)) { 3585 this.position.top = data.top; 3586 } 3587 if (this._isNumber(data.height)) { 3588 this.size.height = data.height; 3589 } 3590 if (this._isNumber(data.width)) { 3591 this.size.width = data.width; 3592 } 3593 }, 3594 3595 _updateRatio: function( data ) { 3596 3597 var cpos = this.position, 3598 csize = this.size, 3599 a = this.axis; 3600 3601 if (this._isNumber(data.height)) { 3602 data.width = (data.height * this.aspectRatio); 3603 } else if (this._isNumber(data.width)) { 3604 data.height = (data.width / this.aspectRatio); 3605 } 3606 3607 if (a === "sw") { 3608 data.left = cpos.left + (csize.width - data.width); 3609 data.top = null; 3610 } 3611 if (a === "nw") { 3612 data.top = cpos.top + (csize.height - data.height); 3613 data.left = cpos.left + (csize.width - data.width); 3614 } 3615 3616 return data; 3617 }, 3618 3619 _respectSize: function( data ) { 3620 3621 var o = this._vBoundaries, 3622 a = this.axis, 3623 ismaxw = this._isNumber(data.width) && o.maxWidth && (o.maxWidth < data.width), 3624 ismaxh = this._isNumber(data.height) && o.maxHeight && (o.maxHeight < data.height), 3625 isminw = this._isNumber(data.width) && o.minWidth && (o.minWidth > data.width), 3626 isminh = this._isNumber(data.height) && o.minHeight && (o.minHeight > data.height), 3627 dw = this.originalPosition.left + this.originalSize.width, 3628 dh = this.position.top + this.size.height, 3629 cw = /sw|nw|w/.test(a), ch = /nw|ne|n/.test(a); 3630 if (isminw) { 3631 data.width = o.minWidth; 3632 } 3633 if (isminh) { 3634 data.height = o.minHeight; 3635 } 3636 if (ismaxw) { 3637 data.width = o.maxWidth; 3638 } 3639 if (ismaxh) { 3640 data.height = o.maxHeight; 3641 } 3642 3643 if (isminw && cw) { 3644 data.left = dw - o.minWidth; 3645 } 3646 if (ismaxw && cw) { 3647 data.left = dw - o.maxWidth; 3648 } 3649 if (isminh && ch) { 3650 data.top = dh - o.minHeight; 3651 } 3652 if (ismaxh && ch) { 3653 data.top = dh - o.maxHeight; 3654 } 3655 3656 // Fixing jump error on top/left - bug #2330 3657 if (!data.width && !data.height && !data.left && data.top) { 3658 data.top = null; 3659 } else if (!data.width && !data.height && !data.top && data.left) { 3660 data.left = null; 3661 } 3662 3663 return data; 3664 }, 3665 3666 _getPaddingPlusBorderDimensions: function( element ) { 3667 var i = 0, 3668 widths = [], 3669 borders = [ 3670 element.css( "borderTopWidth" ), 3671 element.css( "borderRightWidth" ), 3672 element.css( "borderBottomWidth" ), 3673 element.css( "borderLeftWidth" ) 3674 ], 3675 paddings = [ 3676 element.css( "paddingTop" ), 3677 element.css( "paddingRight" ), 3678 element.css( "paddingBottom" ), 3679 element.css( "paddingLeft" ) 3680 ]; 3681 3682 for ( ; i < 4; i++ ) { 3683 widths[ i ] = ( parseInt( borders[ i ], 10 ) || 0 ); 3684 widths[ i ] += ( parseInt( paddings[ i ], 10 ) || 0 ); 3685 } 3686 3687 return { 3688 height: widths[ 0 ] + widths[ 2 ], 3689 width: widths[ 1 ] + widths[ 3 ] 3690 }; 3691 }, 3692 3693 _proportionallyResize: function() { 3694 3695 if (!this._proportionallyResizeElements.length) { 3696 return; 3697 } 3698 3699 var prel, 3700 i = 0, 3701 element = this.helper || this.element; 3702 3703 for ( ; i < this._proportionallyResizeElements.length; i++) { 3704 3705 prel = this._proportionallyResizeElements[i]; 3706 3707 // TODO: Seems like a bug to cache this.outerDimensions 3708 // considering that we are in a loop. 3709 if (!this.outerDimensions) { 3710 this.outerDimensions = this._getPaddingPlusBorderDimensions( prel ); 3711 } 3712 3713 prel.css({ 3714 height: (element.height() - this.outerDimensions.height) || 0, 3715 width: (element.width() - this.outerDimensions.width) || 0 3716 }); 3717 3718 } 3719 3720 }, 3721 3722 _renderProxy: function() { 3723 3724 var el = this.element, o = this.options; 3725 this.elementOffset = el.offset(); 3726 3727 if (this._helper) { 3728 3729 this.helper = this.helper || $("<div style='overflow:hidden;'></div>"); 3730 3731 this.helper.addClass(this._helper).css({ 3732 width: this.element.outerWidth() - 1, 3733 height: this.element.outerHeight() - 1, 3734 position: "absolute", 3735 left: this.elementOffset.left + "px", 3736 top: this.elementOffset.top + "px", 3737 zIndex: ++o.zIndex //TODO: Don't modify option 3738 }); 3739 3740 this.helper 3741 .appendTo("body") 3742 .disableSelection(); 3743 3744 } else { 3745 this.helper = this.element; 3746 } 3747 3748 }, 3749 3750 _change: { 3751 e: function(event, dx) { 3752 return { width: this.originalSize.width + dx }; 3753 }, 3754 w: function(event, dx) { 3755 var cs = this.originalSize, sp = this.originalPosition; 3756 return { left: sp.left + dx, width: cs.width - dx }; 3757 }, 3758 n: function(event, dx, dy) { 3759 var cs = this.originalSize, sp = this.originalPosition; 3760 return { top: sp.top + dy, height: cs.height - dy }; 3761 }, 3762 s: function(event, dx, dy) { 3763 return { height: this.originalSize.height + dy }; 3764 }, 3765 se: function(event, dx, dy) { 3766 return $.extend(this._change.s.apply(this, arguments), 3767 this._change.e.apply(this, [ event, dx, dy ])); 3768 }, 3769 sw: function(event, dx, dy) { 3770 return $.extend(this._change.s.apply(this, arguments), 3771 this._change.w.apply(this, [ event, dx, dy ])); 3772 }, 3773 ne: function(event, dx, dy) { 3774 return $.extend(this._change.n.apply(this, arguments), 3775 this._change.e.apply(this, [ event, dx, dy ])); 3776 }, 3777 nw: function(event, dx, dy) { 3778 return $.extend(this._change.n.apply(this, arguments), 3779 this._change.w.apply(this, [ event, dx, dy ])); 3780 } 3781 }, 3782 3783 _propagate: function(n, event) { 3784 $.ui.plugin.call(this, n, [ event, this.ui() ]); 3785 (n !== "resize" && this._trigger(n, event, this.ui())); 3786 }, 3787 3788 plugins: {}, 3789 3790 ui: function() { 3791 return { 3792 originalElement: this.originalElement, 3793 element: this.element, 3794 helper: this.helper, 3795 position: this.position, 3796 size: this.size, 3797 originalSize: this.originalSize, 3798 originalPosition: this.originalPosition 3799 }; 3800 } 3801 3802}); 3803 3804/* 3805 * Resizable Extensions 3806 */ 3807 3808$.ui.plugin.add("resizable", "animate", { 3809 3810 stop: function( event ) { 3811 var that = $(this).resizable( "instance" ), 3812 o = that.options, 3813 pr = that._proportionallyResizeElements, 3814 ista = pr.length && (/textarea/i).test(pr[0].nodeName), 3815 soffseth = ista && that._hasScroll(pr[0], "left") ? 0 : that.sizeDiff.height, 3816 soffsetw = ista ? 0 : that.sizeDiff.width, 3817 style = { width: (that.size.width - soffsetw), height: (that.size.height - soffseth) }, 3818 left = (parseInt(that.element.css("left"), 10) + 3819 (that.position.left - that.originalPosition.left)) || null, 3820 top = (parseInt(that.element.css("top"), 10) + 3821 (that.position.top - that.originalPosition.top)) || null; 3822 3823 that.element.animate( 3824 $.extend(style, top && left ? { top: top, left: left } : {}), { 3825 duration: o.animateDuration, 3826 easing: o.animateEasing, 3827 step: function() { 3828 3829 var data = { 3830 width: parseInt(that.element.css("width"), 10), 3831 height: parseInt(that.element.css("height"), 10), 3832 top: parseInt(that.element.css("top"), 10), 3833 left: parseInt(that.element.css("left"), 10) 3834 }; 3835 3836 if (pr && pr.length) { 3837 $(pr[0]).css({ width: data.width, height: data.height }); 3838 } 3839 3840 // propagating resize, and updating values for each animation step 3841 that._updateCache(data); 3842 that._propagate("resize", event); 3843 3844 } 3845 } 3846 ); 3847 } 3848 3849}); 3850 3851$.ui.plugin.add( "resizable", "containment", { 3852 3853 start: function() { 3854 var element, p, co, ch, cw, width, height, 3855 that = $( this ).resizable( "instance" ), 3856 o = that.options, 3857 el = that.element, 3858 oc = o.containment, 3859 ce = ( oc instanceof $ ) ? oc.get( 0 ) : ( /parent/.test( oc ) ) ? el.parent().get( 0 ) : oc; 3860 3861 if ( !ce ) { 3862 return; 3863 } 3864 3865 that.containerElement = $( ce ); 3866 3867 if ( /document/.test( oc ) || oc === document ) { 3868 that.containerOffset = { 3869 left: 0, 3870 top: 0 3871 }; 3872 that.containerPosition = { 3873 left: 0, 3874 top: 0 3875 }; 3876 3877 that.parentData = { 3878 element: $( document ), 3879 left: 0, 3880 top: 0, 3881 width: $( document ).width(), 3882 height: $( document ).height() || document.body.parentNode.scrollHeight 3883 }; 3884 } else { 3885 element = $( ce ); 3886 p = []; 3887 $([ "Top", "Right", "Left", "Bottom" ]).each(function( i, name ) { 3888 p[ i ] = that._num( element.css( "padding" + name ) ); 3889 }); 3890 3891 that.containerOffset = element.offset(); 3892 that.containerPosition = element.position(); 3893 that.containerSize = { 3894 height: ( element.innerHeight() - p[ 3 ] ), 3895 width: ( element.innerWidth() - p[ 1 ] ) 3896 }; 3897 3898 co = that.containerOffset; 3899 ch = that.containerSize.height; 3900 cw = that.containerSize.width; 3901 width = ( that._hasScroll ( ce, "left" ) ? ce.scrollWidth : cw ); 3902 height = ( that._hasScroll ( ce ) ? ce.scrollHeight : ch ) ; 3903 3904 that.parentData = { 3905 element: ce, 3906 left: co.left, 3907 top: co.top, 3908 width: width, 3909 height: height 3910 }; 3911 } 3912 }, 3913 3914 resize: function( event ) { 3915 var woset, hoset, isParent, isOffsetRelative, 3916 that = $( this ).resizable( "instance" ), 3917 o = that.options, 3918 co = that.containerOffset, 3919 cp = that.position, 3920 pRatio = that._aspectRatio || event.shiftKey, 3921 cop = { 3922 top: 0, 3923 left: 0 3924 }, 3925 ce = that.containerElement, 3926 continueResize = true; 3927 3928 if ( ce[ 0 ] !== document && ( /static/ ).test( ce.css( "position" ) ) ) { 3929 cop = co; 3930 } 3931 3932 if ( cp.left < ( that._helper ? co.left : 0 ) ) { 3933 that.size.width = that.size.width + 3934 ( that._helper ? 3935 ( that.position.left - co.left ) : 3936 ( that.position.left - cop.left ) ); 3937 3938 if ( pRatio ) { 3939 that.size.height = that.size.width / that.aspectRatio; 3940 continueResize = false; 3941 } 3942 that.position.left = o.helper ? co.left : 0; 3943 } 3944 3945 if ( cp.top < ( that._helper ? co.top : 0 ) ) { 3946 that.size.height = that.size.height + 3947 ( that._helper ? 3948 ( that.position.top - co.top ) : 3949 that.position.top ); 3950 3951 if ( pRatio ) { 3952 that.size.width = that.size.height * that.aspectRatio; 3953 continueResize = false; 3954 } 3955 that.position.top = that._helper ? co.top : 0; 3956 } 3957 3958 isParent = that.containerElement.get( 0 ) === that.element.parent().get( 0 ); 3959 isOffsetRelative = /relative|absolute/.test( that.containerElement.css( "position" ) ); 3960 3961 if ( isParent && isOffsetRelative ) { 3962 that.offset.left = that.parentData.left + that.position.left; 3963 that.offset.top = that.parentData.top + that.position.top; 3964 } else { 3965 that.offset.left = that.element.offset().left; 3966 that.offset.top = that.element.offset().top; 3967 } 3968 3969 woset = Math.abs( that.sizeDiff.width + 3970 (that._helper ? 3971 that.offset.left - cop.left : 3972 (that.offset.left - co.left)) ); 3973 3974 hoset = Math.abs( that.sizeDiff.height + 3975 (that._helper ? 3976 that.offset.top - cop.top : 3977 (that.offset.top - co.top)) ); 3978 3979 if ( woset + that.size.width >= that.parentData.width ) { 3980 that.size.width = that.parentData.width - woset; 3981 if ( pRatio ) { 3982 that.size.height = that.size.width / that.aspectRatio; 3983 continueResize = false; 3984 } 3985 } 3986 3987 if ( hoset + that.size.height >= that.parentData.height ) { 3988 that.size.height = that.parentData.height - hoset; 3989 if ( pRatio ) { 3990 that.size.width = that.size.height * that.aspectRatio; 3991 continueResize = false; 3992 } 3993 } 3994 3995 if ( !continueResize ) { 3996 that.position.left = that.prevPosition.left; 3997 that.position.top = that.prevPosition.top; 3998 that.size.width = that.prevSize.width; 3999 that.size.height = that.prevSize.height; 4000 } 4001 }, 4002 4003 stop: function() { 4004 var that = $( this ).resizable( "instance" ), 4005 o = that.options, 4006 co = that.containerOffset, 4007 cop = that.containerPosition, 4008 ce = that.containerElement, 4009 helper = $( that.helper ), 4010 ho = helper.offset(), 4011 w = helper.outerWidth() - that.sizeDiff.width, 4012 h = helper.outerHeight() - that.sizeDiff.height; 4013 4014 if ( that._helper && !o.animate && ( /relative/ ).test( ce.css( "position" ) ) ) { 4015 $( this ).css({ 4016 left: ho.left - cop.left - co.left, 4017 width: w, 4018 height: h 4019 }); 4020 } 4021 4022 if ( that._helper && !o.animate && ( /static/ ).test( ce.css( "position" ) ) ) { 4023 $( this ).css({ 4024 left: ho.left - cop.left - co.left, 4025 width: w, 4026 height: h 4027 }); 4028 } 4029 } 4030}); 4031 4032$.ui.plugin.add("resizable", "alsoResize", { 4033 4034 start: function() { 4035 var that = $(this).resizable( "instance" ), 4036 o = that.options; 4037 4038 $(o.alsoResize).each(function() { 4039 var el = $(this); 4040 el.data("ui-resizable-alsoresize", { 4041 width: parseInt(el.width(), 10), height: parseInt(el.height(), 10), 4042 left: parseInt(el.css("left"), 10), top: parseInt(el.css("top"), 10) 4043 }); 4044 }); 4045 }, 4046 4047 resize: function(event, ui) { 4048 var that = $(this).resizable( "instance" ), 4049 o = that.options, 4050 os = that.originalSize, 4051 op = that.originalPosition, 4052 delta = { 4053 height: (that.size.height - os.height) || 0, 4054 width: (that.size.width - os.width) || 0, 4055 top: (that.position.top - op.top) || 0, 4056 left: (that.position.left - op.left) || 0 4057 }; 4058 4059 $(o.alsoResize).each(function() { 4060 var el = $(this), start = $(this).data("ui-resizable-alsoresize"), style = {}, 4061 css = el.parents(ui.originalElement[0]).length ? 4062 [ "width", "height" ] : 4063 [ "width", "height", "top", "left" ]; 4064 4065 $.each(css, function(i, prop) { 4066 var sum = (start[prop] || 0) + (delta[prop] || 0); 4067 if (sum && sum >= 0) { 4068 style[prop] = sum || null; 4069 } 4070 }); 4071 4072 el.css(style); 4073 }); 4074 }, 4075 4076 stop: function() { 4077 $(this).removeData("resizable-alsoresize"); 4078 } 4079}); 4080 4081$.ui.plugin.add("resizable", "ghost", { 4082 4083 start: function() { 4084 4085 var that = $(this).resizable( "instance" ), o = that.options, cs = that.size; 4086 4087 that.ghost = that.originalElement.clone(); 4088 that.ghost 4089 .css({ 4090 opacity: 0.25, 4091 display: "block", 4092 position: "relative", 4093 height: cs.height, 4094 width: cs.width, 4095 margin: 0, 4096 left: 0, 4097 top: 0 4098 }) 4099 .addClass("ui-resizable-ghost") 4100 .addClass(typeof o.ghost === "string" ? o.ghost : ""); 4101 4102 that.ghost.appendTo(that.helper); 4103 4104 }, 4105 4106 resize: function() { 4107 var that = $(this).resizable( "instance" ); 4108 if (that.ghost) { 4109 that.ghost.css({ 4110 position: "relative", 4111 height: that.size.height, 4112 width: that.size.width 4113 }); 4114 } 4115 }, 4116 4117 stop: function() { 4118 var that = $(this).resizable( "instance" ); 4119 if (that.ghost && that.helper) { 4120 that.helper.get(0).removeChild(that.ghost.get(0)); 4121 } 4122 } 4123 4124}); 4125 4126$.ui.plugin.add("resizable", "grid", { 4127 4128 resize: function() { 4129 var outerDimensions, 4130 that = $(this).resizable( "instance" ), 4131 o = that.options, 4132 cs = that.size, 4133 os = that.originalSize, 4134 op = that.originalPosition, 4135 a = that.axis, 4136 grid = typeof o.grid === "number" ? [ o.grid, o.grid ] : o.grid, 4137 gridX = (grid[0] || 1), 4138 gridY = (grid[1] || 1), 4139 ox = Math.round((cs.width - os.width) / gridX) * gridX, 4140 oy = Math.round((cs.height - os.height) / gridY) * gridY, 4141 newWidth = os.width + ox, 4142 newHeight = os.height + oy, 4143 isMaxWidth = o.maxWidth && (o.maxWidth < newWidth), 4144 isMaxHeight = o.maxHeight && (o.maxHeight < newHeight), 4145 isMinWidth = o.minWidth && (o.minWidth > newWidth), 4146 isMinHeight = o.minHeight && (o.minHeight > newHeight); 4147 4148 o.grid = grid; 4149 4150 if (isMinWidth) { 4151 newWidth += gridX; 4152 } 4153 if (isMinHeight) { 4154 newHeight += gridY; 4155 } 4156 if (isMaxWidth) { 4157 newWidth -= gridX; 4158 } 4159 if (isMaxHeight) { 4160 newHeight -= gridY; 4161 } 4162 4163 if (/^(se|s|e)$/.test(a)) { 4164 that.size.width = newWidth; 4165 that.size.height = newHeight; 4166 } else if (/^(ne)$/.test(a)) { 4167 that.size.width = newWidth; 4168 that.size.height = newHeight; 4169 that.position.top = op.top - oy; 4170 } else if (/^(sw)$/.test(a)) { 4171 that.size.width = newWidth; 4172 that.size.height = newHeight; 4173 that.position.left = op.left - ox; 4174 } else { 4175 if ( newHeight - gridY <= 0 || newWidth - gridX <= 0) { 4176 outerDimensions = that._getPaddingPlusBorderDimensions( this ); 4177 } 4178 4179 if ( newHeight - gridY > 0 ) { 4180 that.size.height = newHeight; 4181 that.position.top = op.top - oy; 4182 } else { 4183 newHeight = gridY - outerDimensions.height; 4184 that.size.height = newHeight; 4185 that.position.top = op.top + os.height - newHeight; 4186 } 4187 if ( newWidth - gridX > 0 ) { 4188 that.size.width = newWidth; 4189 that.position.left = op.left - ox; 4190 } else { 4191 newWidth = gridX - outerDimensions.width; 4192 that.size.width = newWidth; 4193 that.position.left = op.left + os.width - newWidth; 4194 } 4195 } 4196 } 4197 4198}); 4199 4200var resizable = $.ui.resizable; 4201 4202 4203/*! 4204 * jQuery UI
vendor: 6,622 bytes, lines 4204-4458
4204Selectable 1.11.4 4205 * http://jqueryui.com 4206 * 4207 * Copyright jQuery Foundation and other contributors 4208 * Released under the MIT license. 4209 * http://jquery.org/license 4210 * 4211 * http://api.jqueryui.com/selectable/ 4212 */ 4213 4214 4215var selectable = $.widget("ui.selectable", $.ui.mouse, { 4216 version: "1.11.4", 4217 options: { 4218 appendTo: "body", 4219 autoRefresh: true, 4220 distance: 0, 4221 filter: "*", 4222 tolerance: "touch", 4223 4224 // callbacks 4225 selected: null, 4226 selecting: null, 4227 start: null, 4228 stop: null, 4229 unselected: null, 4230 unselecting: null 4231 }, 4232 _create: function() { 4233 var selectees, 4234 that = this; 4235 4236 this.element.addClass("ui-selectable"); 4237 4238 this.dragged = false; 4239 4240 // cache selectee children based on filter 4241 this.refresh = function() { 4242 selectees = $(that.options.filter, that.element[0]); 4243 selectees.addClass("ui-selectee"); 4244 selectees.each(function() { 4245 var $this = $(this), 4246 pos = $this.offset(); 4247 $.data(this, "selectable-item", { 4248 element: this, 4249 $element: $this, 4250 left: pos.left, 4251 top: pos.top, 4252 right: pos.left + $this.outerWidth(), 4253 bottom: pos.top + $this.outerHeight(), 4254 startselected: false, 4255 selected: $this.hasClass("ui-selected"), 4256 selecting: $this.hasClass("ui-selecting"), 4257 unselecting: $this.hasClass("ui-unselecting") 4258 }); 4259 }); 4260 }; 4261 this.refresh(); 4262 4263 this.selectees = selectees.addClass("ui-selectee"); 4264 4265 this._mouseInit(); 4266 4267 this.helper = $("<div class='ui-selectable-helper'></div>"); 4268 }, 4269 4270 _destroy: function() { 4271 this.selectees 4272 .removeClass("ui-selectee") 4273 .removeData("selectable-item"); 4274 this.element 4275 .removeClass("ui-selectable ui-selectable-disabled"); 4276 this._mouseDestroy(); 4277 }, 4278 4279 _mouseStart: function(event) { 4280 var that = this, 4281 options = this.options; 4282 4283 this.opos = [ event.pageX, event.pageY ]; 4284 4285 if (this.options.disabled) { 4286 return; 4287 } 4288 4289 this.selectees = $(options.filter, this.element[0]); 4290 4291 this._trigger("start", event); 4292 4293 $(options.appendTo).append(this.helper); 4294 // position helper (lasso) 4295 this.helper.css({ 4296 "left": event.pageX, 4297 "top": event.pageY, 4298 "width": 0, 4299 "height": 0 4300 }); 4301 4302 if (options.autoRefresh) { 4303 this.refresh(); 4304 } 4305 4306 this.selectees.filter(".ui-selected").each(function() { 4307 var selectee = $.data(this, "selectable-item"); 4308 selectee.startselected = true; 4309 if (!event.metaKey && !event.ctrlKey) { 4310 selectee.$element.removeClass("ui-selected"); 4311 selectee.selected = false; 4312 selectee.$element.addClass("ui-unselecting"); 4313 selectee.unselecting = true; 4314 // selectable UNSELECTING callback 4315 that._trigger("unselecting", event, { 4316 unselecting: selectee.element 4317 }); 4318 } 4319 }); 4320 4321 $(event.target).parents().addBack().each(function() { 4322 var doSelect, 4323 selectee = $.data(this, "selectable-item"); 4324 if (selectee) { 4325 doSelect = (!event.metaKey && !event.ctrlKey) || !selectee.$element.hasClass("ui-selected"); 4326 selectee.$element 4327 .removeClass(doSelect ? "ui-unselecting" : "ui-selected") 4328 .addClass(doSelect ? "ui-selecting" : "ui-unselecting"); 4329 selectee.unselecting = !doSelect; 4330 selectee.selecting = doSelect; 4331 selectee.selected = doSelect; 4332 // selectable (UN)SELECTING callback 4333 if (doSelect) { 4334 that._trigger("selecting", event, { 4335 selecting: selectee.element 4336 }); 4337 } else { 4338 that._trigger("unselecting", event, { 4339 unselecting: selectee.element 4340 }); 4341 } 4342 return false; 4343 } 4344 }); 4345 4346 }, 4347 4348 _mouseDrag: function(event) { 4349 4350 this.dragged = true; 4351 4352 if (this.options.disabled) { 4353 return; 4354 } 4355 4356 var tmp, 4357 that = this, 4358 options = this.options, 4359 x1 = this.opos[0], 4360 y1 = this.opos[1], 4361 x2 = event.pageX, 4362 y2 = event.pageY; 4363 4364 if (x1 > x2) { tmp = x2; x2 = x1; x1 = tmp; } 4365 if (y1 > y2) { tmp = y2; y2 = y1; y1 = tmp; } 4366 this.helper.css({ left: x1, top: y1, width: x2 - x1, height: y2 - y1 }); 4367 4368 this.selectees.each(function() { 4369 var selectee = $.data(this, "selectable-item"), 4370 hit = false; 4371 4372 //prevent helper from being selected if appendTo: selectable 4373 if (!selectee || selectee.element === that.element[0]) { 4374 return; 4375 } 4376 4377 if (options.tolerance === "touch") { 4378 hit = ( !(selectee.left > x2 || selectee.right < x1 || selectee.top > y2 || selectee.bottom < y1) ); 4379 } else if (options.tolerance === "fit") { 4380 hit = (selectee.left > x1 && selectee.right < x2 && selectee.top > y1 && selectee.bottom < y2); 4381 } 4382 4383 if (hit) { 4384 // SELECT 4385 if (selectee.selected) { 4386 selectee.$element.removeClass("ui-selected"); 4387 selectee.selected = false; 4388 } 4389 if (selectee.unselecting) { 4390 selectee.$element.removeClass("ui-unselecting"); 4391 selectee.unselecting = false; 4392 } 4393 if (!selectee.selecting) { 4394 selectee.$element.addClass("ui-selecting"); 4395 selectee.selecting = true; 4396 // selectable SELECTING callback 4397 that._trigger("selecting", event, { 4398 selecting: selectee.element 4399 }); 4400 } 4401 } else { 4402 // UNSELECT 4403 if (selectee.selecting) { 4404 if ((event.metaKey || event.ctrlKey) && selectee.startselected) { 4405 selectee.$element.removeClass("ui-selecting"); 4406 selectee.selecting = false; 4407 selectee.$element.addClass("ui-selected"); 4408 selectee.selected = true; 4409 } else { 4410 selectee.$element.removeClass("ui-selecting"); 4411 selectee.selecting = false; 4412 if (selectee.startselected) { 4413 selectee.$element.addClass("ui-unselecting"); 4414 selectee.unselecting = true; 4415 } 4416 // selectable UNSELECTING callback 4417 that._trigger("unselecting", event, { 4418 unselecting: selectee.element 4419 }); 4420 } 4421 } 4422 if (selectee.selected) { 4423 if (!event.metaKey && !event.ctrlKey && !selectee.startselected) { 4424 selectee.$element.removeClass("ui-selected"); 4425 selectee.selected = false; 4426 4427 selectee.$element.addClass("ui-unselecting"); 4428 selectee.unselecting = true; 4429 // selectable UNSELECTING callback 4430 that._trigger("unselecting", event, { 4431 unselecting: selectee.element 4432 }); 4433 } 4434 } 4435 } 4436 }); 4437 4438 return false; 4439 }, 4440 4441 _mouseStop: function(event) { 4442 var that = this; 4443 4444 this.dragged = false; 4445 4446 $(".ui-unselecting", this.element[0]).each(function() { 4447 var selectee = $.data(this, "selectable-item"); 4448 selectee.$element.removeClass("ui-unselecting"); 4449 selectee.unselecting = false; 4450 selectee.startselected = false; 4451 that._trigger("unselected", event, { 4452 unselected: selectee.element 4453 }); 4454 }); 4455 $(".ui-selecting", this.element[0]).each(function() { 4456 var selectee = $.data(this, "selectable-item"); 4457 selectee.$element.removeClass("ui-selecting").addClass("ui-selected"); 4458 selectee.selecting = false;
4459 selectee.selected = true; 4460 selectee.startselected = true; 4461 that._trigger("selected", event, { 4462 selected: selectee.element 4463 }); 4464 }); 4465 this._trigger("stop", event); 4466 4467 this.helper.remove(); 4468 4469 return false; 4470 }
vendor: 65,728 bytes, lines 4471-6645
4471 4472}); 4473 4474 4475/*! 4476 * jQuery UI Sortable 1.11.4 4477 * http://jqueryui.com 4478 * 4479 * Copyright jQuery Foundation and other contributors 4480 * Released under the MIT license. 4481 * http://jquery.org/license 4482 * 4483 * http://api.jqueryui.com/sortable/ 4484 */ 4485 4486 4487var sortable = $.widget("ui.sortable", $.ui.mouse, { 4488 version: "1.11.4", 4489 widgetEventPrefix: "sort", 4490 ready: false, 4491 options: { 4492 appendTo: "parent", 4493 axis: false, 4494 connectWith: false, 4495 containment: false, 4496 cursor: "auto", 4497 cursorAt: false, 4498 dropOnEmpty: true, 4499 forcePlaceholderSize: false, 4500 forceHelperSize: false, 4501 grid: false, 4502 handle: false, 4503 helper: "original", 4504 items: "> *", 4505 opacity: false, 4506 placeholder: false, 4507 revert: false, 4508 scroll: true, 4509 scrollSensitivity: 20, 4510 scrollSpeed: 20, 4511 scope: "default", 4512 tolerance: "intersect", 4513 zIndex: 1000, 4514 4515 // callbacks 4516 activate: null, 4517 beforeStop: null, 4518 change: null, 4519 deactivate: null, 4520 out: null, 4521 over: null, 4522 receive: null, 4523 remove: null, 4524 sort: null, 4525 start: null, 4526 stop: null, 4527 update: null 4528 }, 4529 4530 _isOverAxis: function( x, reference, size ) { 4531 return ( x >= reference ) && ( x < ( reference + size ) ); 4532 }, 4533 4534 _isFloating: function( item ) { 4535 return (/left|right/).test(item.css("float")) || (/inline|table-cell/).test(item.css("display")); 4536 }, 4537 4538 _create: function() { 4539 this.containerCache = {}; 4540 this.element.addClass("ui-sortable"); 4541 4542 //Get the items 4543 this.refresh(); 4544 4545 //Let's determine the parent's offset 4546 this.offset = this.element.offset(); 4547 4548 //Initialize mouse events for interaction 4549 this._mouseInit(); 4550 4551 this._setHandleClassName(); 4552 4553 //We're ready to go 4554 this.ready = true; 4555 4556 }, 4557 4558 _setOption: function( key, value ) { 4559 this._super( key, value ); 4560 4561 if ( key === "handle" ) { 4562 this._setHandleClassName(); 4563 } 4564 }, 4565 4566 _setHandleClassName: function() { 4567 this.element.find( ".ui-sortable-handle" ).removeClass( "ui-sortable-handle" ); 4568 $.each( this.items, function() { 4569 ( this.instance.options.handle ? 4570 this.item.find( this.instance.options.handle ) : this.item ) 4571 .addClass( "ui-sortable-handle" ); 4572 }); 4573 }, 4574 4575 _destroy: function() { 4576 this.element 4577 .removeClass( "ui-sortable ui-sortable-disabled" ) 4578 .find( ".ui-sortable-handle" ) 4579 .removeClass( "ui-sortable-handle" ); 4580 this._mouseDestroy(); 4581 4582 for ( var i = this.items.length - 1; i >= 0; i-- ) { 4583 this.items[i].item.removeData(this.widgetName + "-item"); 4584 } 4585 4586 return this; 4587 }, 4588 4589 _mouseCapture: function(event, overrideHandle) { 4590 var currentItem = null, 4591 validHandle = false, 4592 that = this; 4593 4594 if (this.reverting) { 4595 return false; 4596 } 4597 4598 if(this.options.disabled || this.options.type === "static") { 4599 return false; 4600 } 4601 4602 //We have to refresh the items data once first 4603 this._refreshItems(event); 4604 4605 //Find out if the clicked node (or one of its parents) is a actual item in this.items 4606 $(event.target).parents().each(function() { 4607 if($.data(this, that.widgetName + "-item") === that) { 4608 currentItem = $(this); 4609 return false; 4610 } 4611 }); 4612 if($.data(event.target, that.widgetName + "-item") === that) { 4613 currentItem = $(event.target); 4614 } 4615 4616 if(!currentItem) { 4617 return false; 4618 } 4619 if(this.options.handle && !overrideHandle) { 4620 $(this.options.handle, currentItem).find("*").addBack().each(function() { 4621 if(this === event.target) { 4622 validHandle = true; 4623 } 4624 }); 4625 if(!validHandle) { 4626 return false; 4627 } 4628 } 4629 4630 this.currentItem = currentItem; 4631 this._removeCurrentsFromItems(); 4632 return true; 4633 4634 }, 4635 4636 _mouseStart: function(event, overrideHandle, noActivation) { 4637 4638 var i, body, 4639 o = this.options; 4640 4641 this.currentContainer = this; 4642 4643 //We only need to call refreshPositions, because the refreshItems call has been moved to mouseCapture 4644 this.refreshPositions(); 4645 4646 //Create and append the visible helper 4647 this.helper = this._createHelper(event); 4648 4649 //Cache the helper size 4650 this._cacheHelperProportions(); 4651 4652 /* 4653 * - Position generation - 4654 * This block generates everything position related - it's the core of draggables. 4655 */ 4656 4657 //Cache the margins of the original element 4658 this._cacheMargins(); 4659 4660 //Get the next scrolling parent 4661 this.scrollParent = this.helper.scrollParent(); 4662 4663 //The element's absolute position on the page minus margins 4664 this.offset = this.currentItem.offset(); 4665 this.offset = { 4666 top: this.offset.top - this.margins.top, 4667 left: this.offset.left - this.margins.left 4668 }; 4669 4670 $.extend(this.offset, { 4671 click: { //Where the click happened, relative to the element 4672 left: event.pageX - this.offset.left, 4673 top: event.pageY - this.offset.top 4674 }, 4675 parent: this._getParentOffset(), 4676 relative: this._getRelativeOffset() //This is a relative to absolute position minus the actual position calculation - only used for relative positioned helper 4677 }); 4678 4679 // Only after we got the offset, we can change the helper's position to absolute 4680 // TODO: Still need to figure out a way to make relative sorting possible 4681 this.helper.css("position", "absolute"); 4682 this.cssPosition = this.helper.css("position"); 4683 4684 //Generate the original position 4685 this.originalPosition = this._generatePosition(event); 4686 this.originalPageX = event.pageX; 4687 this.originalPageY = event.pageY; 4688 4689 //Adjust the mouse offset relative to the helper if "cursorAt" is supplied 4690 (o.cursorAt && this._adjustOffsetFromHelper(o.cursorAt)); 4691 4692 //Cache the former DOM position 4693 this.domPosition = { prev: this.currentItem.prev()[0], parent: this.currentItem.parent()[0] }; 4694 4695 //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 4696 if(this.helper[0] !== this.currentItem[0]) { 4697 this.currentItem.hide(); 4698 } 4699 4700 //Create the placeholder 4701 this._createPlaceholder(); 4702 4703 //Set a containment if given in the options 4704 if(o.containment) { 4705 this._setContainment(); 4706 } 4707 4708 if( o.cursor && o.cursor !== "auto" ) { // cursor option 4709 body = this.document.find( "body" ); 4710 4711 // support: IE 4712 this.storedCursor = body.css( "cursor" ); 4713 body.css( "cursor", o.cursor ); 4714 4715 this.storedStylesheet = $( "<style>*{ cursor: "+o.cursor+" !important; }</style>" ).appendTo( body ); 4716 } 4717 4718 if(o.opacity) { // opacity option 4719 if (this.helper.css("opacity")) { 4720 this._storedOpacity = this.helper.css("opacity"); 4721 } 4722 this.helper.css("opacity", o.opacity); 4723 } 4724 4725 if(o.zIndex) { // zIndex option 4726 if (this.helper.css("zIndex")) { 4727 this._storedZIndex = this.helper.css("zIndex"); 4728 } 4729 this.helper.css("zIndex", o.zIndex); 4730 } 4731 4732 //Prepare scrolling 4733 if(this.scrollParent[0] !== this.document[0] && this.scrollParent[0].tagName !== "HTML") { 4734 this.overflowOffset = this.scrollParent.offset(); 4735 } 4736 4737 //Call callbacks 4738 this._trigger("start", event, this._uiHash()); 4739 4740 //Recache the helper size 4741 if(!this._preserveHelperProportions) { 4742 this._cacheHelperProportions(); 4743 } 4744 4745 4746 //Post "activate" events to possible containers 4747 if( !noActivation ) { 4748 for ( i = this.containers.length - 1; i >= 0; i-- ) { 4749 this.containers[ i ]._trigger( "activate", event, this._uiHash( this ) ); 4750 } 4751 } 4752 4753 //Prepare possible droppables 4754 if($.ui.ddmanager) { 4755 $.ui.ddmanager.current = this; 4756 } 4757 4758 if ($.ui.ddmanager && !o.dropBehaviour) { 4759 $.ui.ddmanager.prepareOffsets(this, event); 4760 } 4761 4762 this.dragging = true; 4763 4764 this.helper.addClass("ui-sortable-helper"); 4765 this._mouseDrag(event); //Execute the drag once - this causes the helper not to be visible before getting its correct position 4766 return true; 4767 4768 }, 4769 4770 _mouseDrag: function(event) { 4771 var i, item, itemElement, intersection, 4772 o = this.options, 4773 scrolled = false; 4774 4775 //Compute the helpers position 4776 this.position = this._generatePosition(event); 4777 this.positionAbs = this._convertPositionTo("absolute"); 4778 4779 if (!this.lastPositionAbs) { 4780 this.lastPositionAbs = this.positionAbs; 4781 } 4782 4783 //Do scrolling 4784 if(this.options.scroll) { 4785 if(this.scrollParent[0] !== this.document[0] && this.scrollParent[0].tagName !== "HTML") { 4786 4787 if((this.overflowOffset.top + this.scrollParent[0].offsetHeight) - event.pageY < o.scrollSensitivity) { 4788 this.scrollParent[0].scrollTop = scrolled = this.scrollParent[0].scrollTop + o.scrollSpeed; 4789 } else if(event.pageY - this.overflowOffset.top < o.scrollSensitivity) { 4790 this.scrollParent[0].scrollTop = scrolled = this.scrollParent[0].scrollTop - o.scrollSpeed; 4791 } 4792 4793 if((this.overflowOffset.left + this.scrollParent[0].offsetWidth) - event.pageX < o.scrollSensitivity) { 4794 this.scrollParent[0].scrollLeft = scrolled = this.scrollParent[0].scrollLeft + o.scrollSpeed; 4795 } else if(event.pageX - this.overflowOffset.left < o.scrollSensitivity) { 4796 this.scrollParent[0].scrollLeft = scrolled = this.scrollParent[0].scrollLeft - o.scrollSpeed; 4797 } 4798 4799 } else { 4800 4801 if(event.pageY - this.document.scrollTop() < o.scrollSensitivity) { 4802 scrolled = this.document.scrollTop(this.document.scrollTop() - o.scrollSpeed); 4803 } else if(this.window.height() - (event.pageY - this.document.scrollTop()) < o.scrollSensitivity) { 4804 scrolled = this.document.scrollTop(this.document.scrollTop() + o.scrollSpeed); 4805 } 4806 4807 if(event.pageX - this.document.scrollLeft() < o.scrollSensitivity) { 4808 scrolled = this.document.scrollLeft(this.document.scrollLeft() - o.scrollSpeed); 4809 } else if(this.window.width() - (event.pageX - this.document.scrollLeft()) < o.scrollSensitivity) { 4810 scrolled = this.document.scrollLeft(this.document.scrollLeft() + o.scrollSpeed); 4811 } 4812 4813 } 4814 4815 if(scrolled !== false && $.ui.ddmanager && !o.dropBehaviour) { 4816 $.ui.ddmanager.prepareOffsets(this, event); 4817 } 4818 } 4819 4820 //Regenerate the absolute position used for position checks 4821 this.positionAbs = this._convertPositionTo("absolute"); 4822 4823 //Set the helper position 4824 if(!this.options.axis || this.options.axis !== "y") { 4825 this.helper[0].style.left = this.position.left+"px"; 4826 } 4827 if(!this.options.axis || this.options.axis !== "x") { 4828 this.helper[0].style.top = this.position.top+"px"; 4829 } 4830 4831 //Rearrange 4832 for (i = this.items.length - 1; i >= 0; i--) { 4833 4834 //Cache variables and intersection, continue if no intersection 4835 item = this.items[i]; 4836 itemElement = item.item[0]; 4837 intersection = this._intersectsWithPointer(item); 4838 if (!intersection) { 4839 continue; 4840 } 4841 4842 // Only put the placeholder inside the current Container, skip all 4843 // items from other containers. This works because when moving 4844 // an item from one container to another the 4845 // currentContainer is switched before the placeholder is moved. 4846 // 4847 // Without this, moving items in "sub-sortables" can cause 4848 // the placeholder to jitter between the outer and inner container. 4849 if (item.instance !== this.currentContainer) { 4850 continue; 4851 } 4852 4853 // cannot intersect with itself 4854 // no useless actions that have been done before 4855 // no action if the item moved is the parent of the item checked 4856 if (itemElement !== this.currentItem[0] && 4857 this.placeholder[intersection === 1 ? "next" : "prev"]()[0] !== itemElement && 4858 !$.contains(this.placeholder[0], itemElement) && 4859 (this.options.type === "semi-dynamic" ? !$.contains(this.element[0], itemElement) : true) 4860 ) { 4861 4862 this.direction = intersection === 1 ? "down" : "up"; 4863 4864 if (this.options.tolerance === "pointer" || this._intersectsWithSides(item)) { 4865 this._rearrange(event, item); 4866 } else { 4867 break; 4868 } 4869 4870 this._trigger("change", event, this._uiHash()); 4871 break; 4872 } 4873 } 4874 4875 //Post events to containers 4876 this._contactContainers(event); 4877 4878 //Interconnect with droppables 4879 if($.ui.ddmanager) { 4880 $.ui.ddmanager.drag(this, event); 4881 } 4882 4883 //Call callbacks 4884 this._trigger("sort", event, this._uiHash()); 4885 4886 this.lastPositionAbs = this.positionAbs; 4887 return false; 4888 4889 }, 4890 4891 _mouseStop: function(event, noPropagation) { 4892 4893 if(!event) { 4894 return; 4895 } 4896 4897 //If we are using droppables, inform the manager about the drop 4898 if ($.ui.ddmanager && !this.options.dropBehaviour) { 4899 $.ui.ddmanager.drop(this, event); 4900 } 4901 4902 if(this.options.revert) { 4903 var that = this, 4904 cur = this.placeholder.offset(), 4905 axis = this.options.axis, 4906 animation = {}; 4907 4908 if ( !axis || axis === "x" ) { 4909 animation.left = cur.left - this.offset.parent.left - this.margins.left + (this.offsetParent[0] === this.document[0].body ? 0 : this.offsetParent[0].scrollLeft); 4910 } 4911 if ( !axis || axis === "y" ) { 4912 animation.top = cur.top - this.offset.parent.top - this.margins.top + (this.offsetParent[0] === this.document[0].body ? 0 : this.offsetParent[0].scrollTop); 4913 } 4914 this.reverting = true; 4915 $(this.helper).animate( animation, parseInt(this.options.revert, 10) || 500, function() { 4916 that._clear(event); 4917 }); 4918 } else { 4919 this._clear(event, noPropagation); 4920 } 4921 4922 return false; 4923 4924 }, 4925 4926 cancel: function() { 4927 4928 if(this.dragging) { 4929 4930 this._mouseUp({ target: null }); 4931 4932 if(this.options.helper === "original") { 4933 this.currentItem.css(this._storedCSS).removeClass("ui-sortable-helper"); 4934 } else { 4935 this.currentItem.show(); 4936 } 4937 4938 //Post deactivating events to containers 4939 for (var i = this.containers.length - 1; i >= 0; i--){ 4940 this.containers[i]._trigger("deactivate", null, this._uiHash(this)); 4941 if(this.containers[i].containerCache.over) { 4942 this.containers[i]._trigger("out", null, this._uiHash(this)); 4943 this.containers[i].containerCache.over = 0; 4944 } 4945 } 4946 4947 } 4948 4949 if (this.placeholder) { 4950 //$(this.placeholder[0]).remove(); would have been the jQuery way - unfortunately, it unbinds ALL events from the original node! 4951 if(this.placeholder[0].parentNode) { 4952 this.placeholder[0].parentNode.removeChild(this.placeholder[0]); 4953 } 4954 if(this.options.helper !== "original" && this.helper && this.helper[0].parentNode) { 4955 this.helper.remove(); 4956 } 4957 4958 $.extend(this, { 4959 helper: null, 4960 dragging: false, 4961 reverting: false, 4962 _noFinalSort: null 4963 }); 4964 4965 if(this.domPosition.prev) { 4966 $(this.domPosition.prev).after(this.currentItem); 4967 } else { 4968 $(this.domPosition.parent).prepend(this.currentItem); 4969 } 4970 } 4971 4972 return this; 4973 4974 }, 4975 4976 serialize: function(o) { 4977 4978 var items = this._getItemsAsjQuery(o && o.connected), 4979 str = []; 4980 o = o || {}; 4981 4982 $(items).each(function() { 4983 var res = ($(o.item || this).attr(o.attribute || "id") || "").match(o.expression || (/(.+)[\-=_](.+)/)); 4984 if (res) { 4985 str.push((o.key || res[1]+"[]")+"="+(o.key && o.expression ? res[1] : res[2])); 4986 } 4987 }); 4988 4989 if(!str.length && o.key) { 4990 str.push(o.key + "="); 4991 } 4992 4993 return str.join("&"); 4994 4995 }, 4996 4997 toArray: function(o) { 4998 4999 var items = this._getItemsAsjQuery(o && o.connected), 5000 ret = []; 5001 5002 o = o || {}; 5003 5004 items.each(function() { ret.push($(o.item || this).attr(o.attribute || "id") || ""); }); 5005 return ret; 5006 5007 }, 5008 5009 /* Be careful with the following core functions */ 5010 _intersectsWith: function(item) { 5011 5012 var x1 = this.positionAbs.left, 5013 x2 = x1 + this.helperProportions.width, 5014 y1 = this.positionAbs.top, 5015 y2 = y1 + this.helperProportions.height, 5016 l = item.left, 5017 r = l + item.width, 5018 t = item.top, 5019 b = t + item.height, 5020 dyClick = this.offset.click.top, 5021 dxClick = this.offset.click.left, 5022 isOverElementHeight = ( this.options.axis === "x" ) || ( ( y1 + dyClick ) > t && ( y1 + dyClick ) < b ), 5023 isOverElementWidth = ( this.options.axis === "y" ) || ( ( x1 + dxClick ) > l && ( x1 + dxClick ) < r ), 5024 isOverElement = isOverElementHeight && isOverElementWidth; 5025 5026 if ( this.options.tolerance === "pointer" || 5027 this.options.forcePointerForContainers || 5028 (this.options.tolerance !== "pointer" && this.helperProportions[this.floating ? "width" : "height"] > item[this.floating ? "width" : "height"]) 5029 ) { 5030 return isOverElement; 5031 } else { 5032 5033 return (l < x1 + (this.helperProportions.width / 2) && // Right Half 5034 x2 - (this.helperProportions.width / 2) < r && // Left Half 5035 t < y1 + (this.helperProportions.height / 2) && // Bottom Half 5036 y2 - (this.helperProportions.height / 2) < b ); // Top Half 5037 5038 } 5039 }, 5040 5041 _intersectsWithPointer: function(item) { 5042 5043 var isOverElementHeight = (this.options.axis === "x") || this._isOverAxis(this.positionAbs.top + this.offset.click.top, item.top, item.height), 5044 isOverElementWidth = (this.options.axis === "y") || this._isOverAxis(this.positionAbs.left + this.offset.click.left, item.left, item.width), 5045 isOverElement = isOverElementHeight && isOverElementWidth, 5046 verticalDirection = this._getDragVerticalDirection(), 5047 horizontalDirection = this._getDragHorizontalDirection(); 5048 5049 if (!isOverElement) { 5050 return false; 5051 } 5052 5053 return this.floating ? 5054 ( ((horizontalDirection && horizontalDirection === "right") || verticalDirection === "down") ? 2 : 1 ) 5055 : ( verticalDirection && (verticalDirection === "down" ? 2 : 1) ); 5056 5057 }, 5058 5059 _intersectsWithSides: function(item) { 5060 5061 var isOverBottomHalf = this._isOverAxis(this.positionAbs.top + this.offset.click.top, item.top + (item.height/2), item.height), 5062 isOverRightHalf = this._isOverAxis(this.positionAbs.left + this.offset.click.left, item.left + (item.width/2), item.width), 5063 verticalDirection = this._getDragVerticalDirection(), 5064 horizontalDirection = this._getDragHorizontalDirection(); 5065 5066 if (this.floating && horizontalDirection) { 5067 return ((horizontalDirection === "right" && isOverRightHalf) || (horizontalDirection === "left" && !isOverRightHalf)); 5068 } else { 5069 return verticalDirection && ((verticalDirection === "down" && isOverBottomHalf) || (verticalDirection === "up" && !isOverBottomHalf)); 5070 } 5071 5072 }, 5073 5074 _getDragVerticalDirection: function() { 5075 var delta = this.positionAbs.top - this.lastPositionAbs.top; 5076 return delta !== 0 && (delta > 0 ? "down" : "up"); 5077 }, 5078 5079 _getDragHorizontalDirection: function() { 5080 var delta = this.positionAbs.left - this.lastPositionAbs.left; 5081 return delta !== 0 && (delta > 0 ? "right" : "left"); 5082 }, 5083 5084 refresh: function(event) { 5085 this._refreshItems(event); 5086 this._setHandleClassName(); 5087 this.refreshPositions(); 5088 return this; 5089 }, 5090 5091 _connectWith: function() { 5092 var options = this.options; 5093 return options.connectWith.constructor === String ? [options.connectWith] : options.connectWith; 5094 }, 5095 5096 _getItemsAsjQuery: function(connected) { 5097 5098 var i, j, cur, inst, 5099 items = [], 5100 queries = [], 5101 connectWith = this._connectWith(); 5102 5103 if(connectWith && connected) { 5104 for (i = connectWith.length - 1; i >= 0; i--){ 5105 cur = $(connectWith[i], this.document[0]); 5106 for ( j = cur.length - 1; j >= 0; j--){ 5107 inst = $.data(cur[j], this.widgetFullName); 5108 if(inst && inst !== this && !inst.options.disabled) { 5109 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]); 5110 } 5111 } 5112 } 5113 } 5114 5115 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]); 5116 5117 function addItems() { 5118 items.push( this ); 5119 } 5120 for (i = queries.length - 1; i >= 0; i--){ 5121 queries[i][0].each( addItems ); 5122 } 5123 5124 return $(items); 5125 5126 }, 5127 5128 _removeCurrentsFromItems: function() { 5129 5130 var list = this.currentItem.find(":data(" + this.widgetName + "-item)"); 5131 5132 this.items = $.grep(this.items, function (item) { 5133 for (var j=0; j < list.length; j++) { 5134 if(list[j] === item.item[0]) { 5135 return false; 5136 } 5137 } 5138 return true; 5139 }); 5140 5141 }, 5142 5143 _refreshItems: function(event) { 5144 5145 this.items = []; 5146 this.containers = [this]; 5147 5148 var i, j, cur, inst, targetData, _queries, item, queriesLength, 5149 items = this.items, 5150 queries = [[$.isFunction(this.options.items) ? this.options.items.call(this.element[0], event, { item: this.currentItem }) : $(this.options.items, this.element), this]], 5151 connectWith = this._connectWith(); 5152 5153 if(connectWith && this.ready) { //Shouldn't be run the first time through due to massive slow-down 5154 for (i = connectWith.length - 1; i >= 0; i--){ 5155 cur = $(connectWith[i], this.document[0]); 5156 for (j = cur.length - 1; j >= 0; j--){ 5157 inst = $.data(cur[j], this.widgetFullName); 5158 if(inst && inst !== this && !inst.options.disabled) { 5159 queries.push([$.isFunction(inst.options.items) ? inst.options.items.call(inst.element[0], event, { item: this.currentItem }) : $(inst.options.items, inst.element), inst]); 5160 this.containers.push(inst); 5161 } 5162 } 5163 } 5164 } 5165 5166 for (i = queries.length - 1; i >= 0; i--) { 5167 targetData = queries[i][1]; 5168 _queries = queries[i][0]; 5169 5170 for (j=0, queriesLength = _queries.length; j < queriesLength; j++) { 5171 item = $(_queries[j]); 5172 5173 item.data(this.widgetName + "-item", targetData); // Data for target checking (mouse manager) 5174 5175 items.push({ 5176 item: item, 5177 instance: targetData, 5178 width: 0, height: 0, 5179 left: 0, top: 0 5180 }); 5181 } 5182 } 5183 5184 }, 5185 5186 refreshPositions: function(fast) { 5187 5188 // Determine whether items are being displayed horizontally 5189 this.floating = this.items.length ? 5190 this.options.axis === "x" || this._isFloating( this.items[ 0 ].item ) : 5191 false; 5192 5193 //This has to be redone because due to the item being moved out/into the offsetParent, the offsetParent's position will change 5194 if(this.offsetParent && this.helper) { 5195 this.offset.parent = this._getParentOffset(); 5196 } 5197 5198 var i, item, t, p; 5199 5200 for (i = this.items.length - 1; i >= 0; i--){ 5201 item = this.items[i]; 5202 5203 //We ignore calculating positions of all connected containers when we're not over them 5204 if(item.instance !== this.currentContainer && this.currentContainer && item.item[0] !== this.currentItem[0]) { 5205 continue; 5206 } 5207 5208 t = this.options.toleranceElement ? $(this.options.toleranceElement, item.item) : item.item; 5209 5210 if (!fast) { 5211 item.width = t.outerWidth(); 5212 item.height = t.outerHeight(); 5213 } 5214 5215 p = t.offset(); 5216 item.left = p.left; 5217 item.top = p.top; 5218 } 5219 5220 if(this.options.custom && this.options.custom.refreshContainers) { 5221 this.options.custom.refreshContainers.call(this); 5222 } else { 5223 for (i = this.containers.length - 1; i >= 0; i--){ 5224 p = this.containers[i].element.offset(); 5225 this.containers[i].containerCache.left = p.left; 5226 this.containers[i].containerCache.top = p.top; 5227 this.containers[i].containerCache.width = this.containers[i].element.outerWidth(); 5228 this.containers[i].containerCache.height = this.containers[i].element.outerHeight(); 5229 } 5230 } 5231 5232 return this; 5233 }, 5234 5235 _createPlaceholder: function(that) { 5236 that = that || this; 5237 var className, 5238 o = that.options; 5239 5240 if(!o.placeholder || o.placeholder.constructor === String) { 5241 className = o.placeholder; 5242 o.placeholder = { 5243 element: function() { 5244 5245 var nodeName = that.currentItem[0].nodeName.toLowerCase(), 5246 element = $( "<" + nodeName + ">", that.document[0] ) 5247 .addClass(className || that.currentItem[0].className+" ui-sortable-placeholder") 5248 .removeClass("ui-sortable-helper"); 5249 5250 if ( nodeName === "tbody" ) { 5251 that._createTrPlaceholder( 5252 that.currentItem.find( "tr" ).eq( 0 ), 5253 $( "<tr>", that.document[ 0 ] ).appendTo( element ) 5254 ); 5255 } else if ( nodeName === "tr" ) { 5256 that._createTrPlaceholder( that.currentItem, element ); 5257 } else if ( nodeName === "img" ) { 5258 element.attr( "src", that.currentItem.attr( "src" ) ); 5259 } 5260 5261 if ( !className ) { 5262 element.css( "visibility", "hidden" ); 5263 } 5264 5265 return element; 5266 }, 5267 update: function(container, p) { 5268 5269 // 1. If a className is set as 'placeholder option, we don't force sizes - the class is responsible for that 5270 // 2. The option 'forcePlaceholderSize can be enabled to force it even if a class name is specified 5271 if(className && !o.forcePlaceholderSize) { 5272 return; 5273 } 5274 5275 //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 5276 if(!p.height()) { p.height(that.currentItem.innerHeight() - parseInt(that.currentItem.css("paddingTop")||0, 10) - parseInt(that.currentItem.css("paddingBottom")||0, 10)); } 5277 if(!p.width()) { p.width(that.currentItem.innerWidth() - parseInt(that.currentItem.css("paddingLeft")||0, 10) - parseInt(that.currentItem.css("paddingRight")||0, 10)); } 5278 } 5279 }; 5280 } 5281 5282 //Create the placeholder 5283 that.placeholder = $(o.placeholder.element.call(that.element, that.currentItem)); 5284 5285 //Append it after the actual current item 5286 that.currentItem.after(that.placeholder); 5287 5288 //Update the size of the placeholder (TODO: Logic to fuzzy, see line 316/317) 5289 o.placeholder.update(that, that.placeholder); 5290 5291 }, 5292 5293 _createTrPlaceholder: function( sourceTr, targetTr ) { 5294 var that = this; 5295 5296 sourceTr.children().each(function() { 5297 $( "<td> </td>", that.document[ 0 ] ) 5298 .attr( "colspan", $( this ).attr( "colspan" ) || 1 ) 5299 .appendTo( targetTr ); 5300 }); 5301 }, 5302 5303 _contactContainers: function(event) { 5304 var i, j, dist, itemWithLeastDistance, posProperty, sizeProperty, cur, nearBottom, floating, axis, 5305 innermostContainer = null, 5306 innermostIndex = null; 5307 5308 // get innermost container that intersects with item 5309 for (i = this.containers.length - 1; i >= 0; i--) { 5310 5311 // never consider a container that's located within the item itself 5312 if($.contains(this.currentItem[0], this.containers[i].element[0])) { 5313 continue; 5314 } 5315 5316 if(this._intersectsWith(this.containers[i].containerCache)) { 5317 5318 // if we've already found a container and it's more "inner" than this, then continue 5319 if(innermostContainer && $.contains(this.containers[i].element[0], innermostContainer.element[0])) { 5320 continue; 5321 } 5322 5323 innermostContainer = this.containers[i]; 5324 innermostIndex = i; 5325 5326 } else { 5327 // container doesn't intersect. trigger "out" event if necessary 5328 if(this.containers[i].containerCache.over) { 5329 this.containers[i]._trigger("out", event, this._uiHash(this)); 5330 this.containers[i].containerCache.over = 0; 5331 } 5332 } 5333 5334 } 5335 5336 // if no intersecting containers found, return 5337 if(!innermostContainer) { 5338 return; 5339 } 5340 5341 // move the item into the container if it's not there already 5342 if(this.containers.length === 1) { 5343 if (!this.containers[innermostIndex].containerCache.over) { 5344 this.containers[innermostIndex]._trigger("over", event, this._uiHash(this)); 5345 this.containers[innermostIndex].containerCache.over = 1; 5346 } 5347 } else { 5348 5349 //When entering a new container, we will find the item with the least distance and append our item near it 5350 dist = 10000; 5351 itemWithLeastDistance = null; 5352 floating = innermostContainer.floating || this._isFloating(this.currentItem); 5353 posProperty = floating ? "left" : "top"; 5354 sizeProperty = floating ? "width" : "height"; 5355 axis = floating ? "clientX" : "clientY"; 5356 5357 for (j = this.items.length - 1; j >= 0; j--) { 5358 if(!$.contains(this.containers[innermostIndex].element[0], this.items[j].item[0])) { 5359 continue; 5360 } 5361 if(this.items[j].item[0] === this.currentItem[0]) { 5362 continue; 5363 } 5364 5365 cur = this.items[j].item.offset()[posProperty]; 5366 nearBottom = false; 5367 if ( event[ axis ] - cur > this.items[ j ][ sizeProperty ] / 2 ) { 5368 nearBottom = true; 5369 } 5370 5371 if ( Math.abs( event[ axis ] - cur ) < dist ) { 5372 dist = Math.abs( event[ axis ] - cur ); 5373 itemWithLeastDistance = this.items[ j ]; 5374 this.direction = nearBottom ? "up": "down"; 5375 } 5376 } 5377 5378 //Check if dropOnEmpty is enabled 5379 if(!itemWithLeastDistance && !this.options.dropOnEmpty) { 5380 return; 5381 } 5382 5383 if(this.currentContainer === this.containers[innermostIndex]) { 5384 if ( !this.currentContainer.containerCache.over ) { 5385 this.containers[ innermostIndex ]._trigger( "over", event, this._uiHash() ); 5386 this.currentContainer.containerCache.over = 1; 5387 } 5388 return; 5389 } 5390 5391 itemWithLeastDistance ? this._rearrange(event, itemWithLeastDistance, null, true) : this._rearrange(event, null, this.containers[innermostIndex].element, true); 5392 this._trigger("change", event, this._uiHash()); 5393 this.containers[innermostIndex]._trigger("change", event, this._uiHash(this)); 5394 this.currentContainer = this.containers[innermostIndex]; 5395 5396 //Update the placeholder 5397 this.options.placeholder.update(this.currentContainer, this.placeholder); 5398 5399 this.containers[innermostIndex]._trigger("over", event, this._uiHash(this)); 5400 this.containers[innermostIndex].containerCache.over = 1; 5401 } 5402 5403 5404 }, 5405 5406 _createHelper: function(event) { 5407 5408 var o = this.options, 5409 helper = $.isFunction(o.helper) ? $(o.helper.apply(this.element[0], [event, this.currentItem])) : (o.helper === "clone" ? this.currentItem.clone() : this.currentItem); 5410 5411 //Add the helper to the DOM if that didn't happen already 5412 if(!helper.parents("body").length) { 5413 $(o.appendTo !== "parent" ? o.appendTo : this.currentItem[0].parentNode)[0].appendChild(helper[0]); 5414 } 5415 5416 if(helper[0] === this.currentItem[0]) { 5417 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") }; 5418 } 5419 5420 if(!helper[0].style.width || o.forceHelperSize) { 5421 helper.width(this.currentItem.width()); 5422 } 5423 if(!helper[0].style.height || o.forceHelperSize) { 5424 helper.height(this.currentItem.height()); 5425 } 5426 5427 return helper; 5428 5429 }, 5430 5431 _adjustOffsetFromHelper: function(obj) { 5432 if (typeof obj === "string") { 5433 obj = obj.split(" "); 5434 } 5435 if ($.isArray(obj)) { 5436 obj = {left: +obj[0], top: +obj[1] || 0}; 5437 } 5438 if ("left" in obj) { 5439 this.offset.click.left = obj.left + this.margins.left; 5440 } 5441 if ("right" in obj) { 5442 this.offset.click.left = this.helperProportions.width - obj.right + this.margins.left; 5443 } 5444 if ("top" in obj) { 5445 this.offset.click.top = obj.top + this.margins.top; 5446 } 5447 if ("bottom" in obj) { 5448 this.offset.click.top = this.helperProportions.height - obj.bottom + this.margins.top; 5449 } 5450 }, 5451 5452 _getParentOffset: function() { 5453 5454 5455 //Get the offsetParent and cache its position 5456 this.offsetParent = this.helper.offsetParent(); 5457 var po = this.offsetParent.offset(); 5458 5459 // This is a special case where we need to modify a offset calculated on start, since the following happened: 5460 // 1. The position of the helper is absolute, so it's position is calculated based on the next positioned parent 5461 // 2. The actual offset parent is a child of the scroll parent, and the scroll parent isn't the document, which means that 5462 // the scroll is included in the initial calculation of the offset of the parent, and never recalculated upon drag 5463 if(this.cssPosition === "absolute" && this.scrollParent[0] !== this.document[0] && $.contains(this.scrollParent[0], this.offsetParent[0])) { 5464 po.left += this.scrollParent.scrollLeft(); 5465 po.top += this.scrollParent.scrollTop(); 5466 } 5467 5468 // This needs to be actually done for all browsers, since pageX/pageY includes this information 5469 // with an ugly IE fix 5470 if( this.offsetParent[0] === this.document[0].body || (this.offsetParent[0].tagName && this.offsetParent[0].tagName.toLowerCase() === "html" && $.ui.ie)) { 5471 po = { top: 0, left: 0 }; 5472 } 5473 5474 return { 5475 top: po.top + (parseInt(this.offsetParent.css("borderTopWidth"),10) || 0), 5476 left: po.left + (parseInt(this.offsetParent.css("borderLeftWidth"),10) || 0) 5477 }; 5478 5479 }, 5480 5481 _getRelativeOffset: function() { 5482 5483 if(this.cssPosition === "relative") { 5484 var p = this.currentItem.position(); 5485 return { 5486 top: p.top - (parseInt(this.helper.css("top"),10) || 0) + this.scrollParent.scrollTop(), 5487 left: p.left - (parseInt(this.helper.css("left"),10) || 0) + this.scrollParent.scrollLeft() 5488 }; 5489 } else { 5490 return { top: 0, left: 0 }; 5491 } 5492 5493 }, 5494 5495 _cacheMargins: function() { 5496 this.margins = { 5497 left: (parseInt(this.currentItem.css("marginLeft"),10) || 0), 5498 top: (parseInt(this.currentItem.css("marginTop"),10) || 0) 5499 }; 5500 }, 5501 5502 _cacheHelperProportions: function() { 5503 this.helperProportions = { 5504 width: this.helper.outerWidth(), 5505 height: this.helper.outerHeight() 5506 }; 5507 }, 5508 5509 _setContainment: function() { 5510 5511 var ce, co, over, 5512 o = this.options; 5513 if(o.containment === "parent") { 5514 o.containment = this.helper[0].parentNode; 5515 } 5516 if(o.containment === "document" || o.containment === "window") { 5517 this.containment = [ 5518 0 - this.offset.relative.left - this.offset.parent.left, 5519 0 - this.offset.relative.top - this.offset.parent.top, 5520 o.containment === "document" ? this.document.width() : this.window.width() - this.helperProportions.width - this.margins.left, 5521 (o.containment === "document" ? this.document.width() : this.window.height() || this.document[0].body.parentNode.scrollHeight) - this.helperProportions.height - this.margins.top 5522 ]; 5523 } 5524 5525 if(!(/^(document|window|parent)$/).test(o.containment)) { 5526 ce = $(o.containment)[0]; 5527 co = $(o.containment).offset(); 5528 over = ($(ce).css("overflow") !== "hidden"); 5529 5530 this.containment = [ 5531 co.left + (parseInt($(ce).css("borderLeftWidth"),10) || 0) + (parseInt($(ce).css("paddingLeft"),10) || 0) - this.margins.left, 5532 co.top + (parseInt($(ce).css("borderTopWidth"),10) || 0) + (parseInt($(ce).css("paddingTop"),10) || 0) - this.margins.top, 5533 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, 5534 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 5535 ]; 5536 } 5537 5538 }, 5539 5540 _convertPositionTo: function(d, pos) { 5541 5542 if(!pos) { 5543 pos = this.position; 5544 } 5545 var mod = d === "absolute" ? 1 : -1, 5546 scroll = this.cssPosition === "absolute" && !(this.scrollParent[0] !== this.document[0] && $.contains(this.scrollParent[0], this.offsetParent[0])) ? this.offsetParent : this.scrollParent, 5547 scrollIsRootNode = (/(html|body)/i).test(scroll[0].tagName); 5548 5549 return { 5550 top: ( 5551 pos.top + // The absolute mouse position 5552 this.offset.relative.top * mod + // Only for relative positioned nodes: Relative offset from element to offset parent 5553 this.offset.parent.top * mod - // The offsetParent's offset without borders (offset + border) 5554 ( ( this.cssPosition === "fixed" ? -this.scrollParent.scrollTop() : ( scrollIsRootNode ? 0 : scroll.scrollTop() ) ) * mod) 5555 ), 5556 left: ( 5557 pos.left + // The absolute mouse position 5558 this.offset.relative.left * mod + // Only for relative positioned nodes: Relative offset from element to offset parent 5559 this.offset.parent.left * mod - // The offsetParent's offset without borders (offset + border) 5560 ( ( this.cssPosition === "fixed" ? -this.scrollParent.scrollLeft() : scrollIsRootNode ? 0 : scroll.scrollLeft() ) * mod) 5561 ) 5562 }; 5563 5564 }, 5565 5566 _generatePosition: function(event) { 5567 5568 var top, left, 5569 o = this.options, 5570 pageX = event.pageX, 5571 pageY = event.pageY, 5572 scroll = this.cssPosition === "absolute" && !(this.scrollParent[0] !== this.document[0] && $.contains(this.scrollParent[0], this.offsetParent[0])) ? this.offsetParent : this.scrollParent, scrollIsRootNode = (/(html|body)/i).test(scroll[0].tagName); 5573 5574 // This is another very weird special case that only happens for relative elements: 5575 // 1. If the css position is relative 5576 // 2. and the scroll parent is the document or similar to the offset parent 5577 // we have to refresh the relative offset during the scroll so there are no jumps 5578 if(this.cssPosition === "relative" && !(this.scrollParent[0] !== this.document[0] && this.scrollParent[0] !== this.offsetParent[0])) { 5579 this.offset.relative = this._getRelativeOffset(); 5580 } 5581 5582 /* 5583 * - Position constraining - 5584 * Constrain the position to a mix of grid, containment. 5585 */ 5586 5587 if(this.originalPosition) { //If we are not dragging yet, we won't check for options 5588 5589 if(this.containment) { 5590 if(event.pageX - this.offset.click.left < this.containment[0]) { 5591 pageX = this.containment[0] + this.offset.click.left; 5592 } 5593 if(event.pageY - this.offset.click.top < this.containment[1]) { 5594 pageY = this.containment[1] + this.offset.click.top; 5595 } 5596 if(event.pageX - this.offset.click.left > this.containment[2]) { 5597 pageX = this.containment[2] + this.offset.click.left; 5598 } 5599 if(event.pageY - this.offset.click.top > this.containment[3]) { 5600 pageY = this.containment[3] + this.offset.click.top; 5601 } 5602 } 5603 5604 if(o.grid) { 5605 top = this.originalPageY + Math.round((pageY - this.originalPageY) / o.grid[1]) * o.grid[1]; 5606 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; 5607 5608 left = this.originalPageX + Math.round((pageX - this.originalPageX) / o.grid[0]) * o.grid[0]; 5609 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; 5610 } 5611 5612 } 5613 5614 return { 5615 top: ( 5616 pageY - // The absolute mouse position 5617 this.offset.click.top - // Click offset (relative to the element) 5618 this.offset.relative.top - // Only for relative positioned nodes: Relative offset from element to offset parent 5619 this.offset.parent.top + // The offsetParent's offset without borders (offset + border) 5620 ( ( this.cssPosition === "fixed" ? -this.scrollParent.scrollTop() : ( scrollIsRootNode ? 0 : scroll.scrollTop() ) )) 5621 ), 5622 left: ( 5623 pageX - // The absolute mouse position 5624 this.offset.click.left - // Click offset (relative to the element) 5625 this.offset.relative.left - // Only for relative positioned nodes: Relative offset from element to offset parent 5626 this.offset.parent.left + // The offsetParent's offset without borders (offset + border) 5627 ( ( this.cssPosition === "fixed" ? -this.scrollParent.scrollLeft() : scrollIsRootNode ? 0 : scroll.scrollLeft() )) 5628 ) 5629 }; 5630 5631 }, 5632 5633 _rearrange: function(event, i, a, hardRefresh) { 5634 5635 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)); 5636 5637 //Various things done here to improve the performance: 5638 // 1. we create a setTimeout, that calls refreshPositions 5639 // 2. on the instance, we have a counter variable, that get's higher after every append 5640 // 3. on the local scope, we copy the counter variable, and check in the timeout, if it's still the same 5641 // 4. this lets only the last addition to the timeout stack through 5642 this.counter = this.counter ? ++this.counter : 1; 5643 var counter = this.counter; 5644 5645 this._delay(function() { 5646 if(counter === this.counter) { 5647 this.refreshPositions(!hardRefresh); //Precompute after each DOM insertion, NOT on mousemove 5648 } 5649 }); 5650 5651 }, 5652 5653 _clear: function(event, noPropagation) { 5654 5655 this.reverting = false; 5656 // We delay all events that have to be triggered to after the point where the placeholder has been removed and 5657 // everything else normalized again 5658 var i, 5659 delayedTriggers = []; 5660 5661 // We first have to update the dom position of the actual currentItem 5662 // Note: don't do it if the current item is already removed (by a user), or it gets reappended (see #4088) 5663 if(!this._noFinalSort && this.currentItem.parent().length) { 5664 this.placeholder.before(this.currentItem); 5665 } 5666 this._noFinalSort = null; 5667 5668 if(this.helper[0] === this.currentItem[0]) { 5669 for(i in this._storedCSS) { 5670 if(this._storedCSS[i] === "auto" || this._storedCSS[i] === "static") { 5671 this._storedCSS[i] = ""; 5672 } 5673 } 5674 this.currentItem.css(this._storedCSS).removeClass("ui-sortable-helper"); 5675 } else { 5676 this.currentItem.show(); 5677 } 5678 5679 if(this.fromOutside && !noPropagation) { 5680 delayedTriggers.push(function(event) { this._trigger("receive", event, this._uiHash(this.fromOutside)); }); 5681 } 5682 if((this.fromOutside || this.domPosition.prev !== this.currentItem.prev().not(".ui-sortable-helper")[0] || this.domPosition.parent !== this.currentItem.parent()[0]) && !noPropagation) { 5683 delayedTriggers.push(function(event) { this._trigger("update", event, this._uiHash()); }); //Trigger update callback if the DOM position has changed 5684 } 5685 5686 // Check if the items Container has Changed and trigger appropriate 5687 // events. 5688 if (this !== this.currentContainer) { 5689 if(!noPropagation) { 5690 delayedTriggers.push(function(event) { this._trigger("remove", event, this._uiHash()); }); 5691 delayedTriggers.push((function(c) { return function(event) { c._trigger("receive", event, this._uiHash(this)); }; }).call(this, this.currentContainer)); 5692 delayedTriggers.push((function(c) { return function(event) { c._trigger("update", event, this._uiHash(this)); }; }).call(this, this.currentContainer)); 5693 } 5694 } 5695 5696 5697 //Post events to containers 5698 function delayEvent( type, instance, container ) { 5699 return function( event ) { 5700 container._trigger( type, event, instance._uiHash( instance ) ); 5701 }; 5702 } 5703 for (i = this.containers.length - 1; i >= 0; i--){ 5704 if (!noPropagation) { 5705 delayedTriggers.push( delayEvent( "deactivate", this, this.containers[ i ] ) ); 5706 } 5707 if(this.containers[i].containerCache.over) { 5708 delayedTriggers.push( delayEvent( "out", this, this.containers[ i ] ) ); 5709 this.containers[i].containerCache.over = 0; 5710 } 5711 } 5712 5713 //Do what was originally in plugins 5714 if ( this.storedCursor ) { 5715 this.document.find( "body" ).css( "cursor", this.storedCursor ); 5716 this.storedStylesheet.remove(); 5717 } 5718 if(this._storedOpacity) { 5719 this.helper.css("opacity", this._storedOpacity); 5720 } 5721 if(this._storedZIndex) { 5722 this.helper.css("zIndex", this._storedZIndex === "auto" ? "" : this._storedZIndex); 5723 } 5724 5725 this.dragging = false; 5726 5727 if(!noPropagation) { 5728 this._trigger("beforeStop", event, this._uiHash()); 5729 } 5730 5731 //$(this.placeholder[0]).remove(); would have been the jQuery way - unfortunately, it unbinds ALL events from the original node! 5732 this.placeholder[0].parentNode.removeChild(this.placeholder[0]); 5733 5734 if ( !this.cancelHelperRemoval ) { 5735 if ( this.helper[ 0 ] !== this.currentItem[ 0 ] ) { 5736 this.helper.remove(); 5737 } 5738 this.helper = null; 5739 } 5740 5741 if(!noPropagation) { 5742 for (i=0; i < delayedTriggers.length; i++) { 5743 delayedTriggers[i].call(this, event); 5744 } //Trigger all delayed events 5745 this._trigger("stop", event, this._uiHash()); 5746 } 5747 5748 this.fromOutside = false; 5749 return !this.cancelHelperRemoval; 5750 5751 }, 5752 5753 _trigger: function() { 5754 if ($.Widget.prototype._trigger.apply(this, arguments) === false) { 5755 this.cancel(); 5756 } 5757 }, 5758 5759 _uiHash: function(_inst) { 5760 var inst = _inst || this; 5761 return { 5762 helper: inst.helper, 5763 placeholder: inst.placeholder || $([]), 5764 position: inst.position, 5765 originalPosition: inst.originalPosition, 5766 offset: inst.positionAbs, 5767 item: inst.currentItem, 5768 sender: _inst ? _inst.element : null 5769 }; 5770 } 5771 5772}); 5773 5774 5775/*! 5776 * jQuery UI Accordion 1.11.4 5777 * http://jqueryui.com 5778 * 5779 * Copyright jQuery Foundation and other contributors 5780 * Released under the MIT license. 5781 * http://jquery.org/license 5782 * 5783 * http://api.jqueryui.com/accordion/ 5784 */ 5785 5786 5787var accordion = $.widget( "ui.accordion", { 5788 version: "1.11.4", 5789 options: { 5790 active: 0, 5791 animate: {}, 5792 collapsible: false, 5793 event: "click", 5794 header: "> li > :first-child,> :not(li):even", 5795 heightStyle: "auto", 5796 icons: { 5797 activeHeader: "ui-icon-triangle-1-s", 5798 header: "ui-icon-triangle-1-e" 5799 }, 5800 5801 // callbacks 5802 activate: null, 5803 beforeActivate: null 5804 }, 5805 5806 hideProps: { 5807 borderTopWidth: "hide", 5808 borderBottomWidth: "hide", 5809 paddingTop: "hide", 5810 paddingBottom: "hide", 5811 height: "hide" 5812 }, 5813 5814 showProps: { 5815 borderTopWidth: "show", 5816 borderBottomWidth: "show", 5817 paddingTop: "show", 5818 paddingBottom: "show", 5819 height: "show" 5820 }, 5821 5822 _create: function() { 5823 var options = this.options; 5824 this.prevShow = this.prevHide = $(); 5825 this.element.addClass( "ui-accordion ui-widget ui-helper-reset" ) 5826 // ARIA 5827 .attr( "role", "tablist" ); 5828 5829 // don't allow collapsible: false and active: false / null 5830 if ( !options.collapsible && (options.active === false || options.active == null) ) { 5831 options.active = 0; 5832 } 5833 5834 this._processPanels(); 5835 // handle negative values 5836 if ( options.active < 0 ) { 5837 options.active += this.headers.length; 5838 } 5839 this._refresh(); 5840 }, 5841 5842 _getCreateEventData: function() { 5843 return { 5844 header: this.active, 5845 panel: !this.active.length ? $() : this.active.next() 5846 }; 5847 }, 5848 5849 _createIcons: function() { 5850 var icons = this.options.icons; 5851 if ( icons ) { 5852 $( "<span>" ) 5853 .addClass( "ui-accordion-header-icon ui-icon " + icons.header ) 5854 .prependTo( this.headers ); 5855 this.active.children( ".ui-accordion-header-icon" ) 5856 .removeClass( icons.header ) 5857 .addClass( icons.activeHeader ); 5858 this.headers.addClass( "ui-accordion-icons" ); 5859 } 5860 }, 5861 5862 _destroyIcons: function() { 5863 this.headers 5864 .removeClass( "ui-accordion-icons" ) 5865 .children( ".ui-accordion-header-icon" ) 5866 .remove(); 5867 }, 5868 5869 _destroy: function() { 5870 var contents; 5871 5872 // clean up main element 5873 this.element 5874 .removeClass( "ui-accordion ui-widget ui-helper-reset" ) 5875 .removeAttr( "role" ); 5876 5877 // clean up headers 5878 this.headers 5879 .removeClass( "ui-accordion-header ui-accordion-header-active ui-state-default " + 5880 "ui-corner-all ui-state-active ui-state-disabled ui-corner-top" ) 5881 .removeAttr( "role" ) 5882 .removeAttr( "aria-expanded" ) 5883 .removeAttr( "aria-selected" ) 5884 .removeAttr( "aria-controls" ) 5885 .removeAttr( "tabIndex" ) 5886 .removeUniqueId(); 5887 5888 this._destroyIcons(); 5889 5890 // clean up content panels 5891 contents = this.headers.next() 5892 .removeClass( "ui-helper-reset ui-widget-content ui-corner-bottom " + 5893 "ui-accordion-content ui-accordion-content-active ui-state-disabled" ) 5894 .css( "display", "" ) 5895 .removeAttr( "role" ) 5896 .removeAttr( "aria-hidden" ) 5897 .removeAttr( "aria-labelledby" ) 5898 .removeUniqueId(); 5899 5900 if ( this.options.heightStyle !== "content" ) { 5901 contents.css( "height", "" ); 5902 } 5903 }, 5904 5905 _setOption: function( key, value ) { 5906 if ( key === "active" ) { 5907 // _activate() will handle invalid values and update this.options 5908 this._activate( value ); 5909 return; 5910 } 5911 5912 if ( key === "event" ) { 5913 if ( this.options.event ) { 5914 this._off( this.headers, this.options.event ); 5915 } 5916 this._setupEvents( value ); 5917 } 5918 5919 this._super( key, value ); 5920 5921 // setting collapsible: false while collapsed; open first panel 5922 if ( key === "collapsible" && !value && this.options.active === false ) { 5923 this._activate( 0 ); 5924 } 5925 5926 if ( key === "icons" ) { 5927 this._destroyIcons(); 5928 if ( value ) { 5929 this._createIcons(); 5930 } 5931 } 5932 5933 // #5332 - opacity doesn't cascade to positioned elements in IE 5934 // so we need to add the disabled class to the headers and panels 5935 if ( key === "disabled" ) { 5936 this.element 5937 .toggleClass( "ui-state-disabled", !!value ) 5938 .attr( "aria-disabled", value ); 5939 this.headers.add( this.headers.next() ) 5940 .toggleClass( "ui-state-disabled", !!value ); 5941 } 5942 }, 5943 5944 _keydown: function( event ) { 5945 if ( event.altKey || event.ctrlKey ) { 5946 return; 5947 } 5948 5949 var keyCode = $.ui.keyCode, 5950 length = this.headers.length, 5951 currentIndex = this.headers.index( event.target ), 5952 toFocus = false; 5953 5954 switch ( event.keyCode ) { 5955 case keyCode.RIGHT: 5956 case keyCode.DOWN: 5957 toFocus = this.headers[ ( currentIndex + 1 ) % length ]; 5958 break; 5959 case keyCode.LEFT: 5960 case keyCode.UP: 5961 toFocus = this.headers[ ( currentIndex - 1 + length ) % length ]; 5962 break; 5963 case keyCode.SPACE: 5964 case keyCode.ENTER: 5965 this._eventHandler( event ); 5966 break; 5967 case keyCode.HOME: 5968 toFocus = this.headers[ 0 ]; 5969 break; 5970 case keyCode.END: 5971 toFocus = this.headers[ length - 1 ]; 5972 break; 5973 } 5974 5975 if ( toFocus ) { 5976 $( event.target ).attr( "tabIndex", -1 ); 5977 $( toFocus ).attr( "tabIndex", 0 ); 5978 toFocus.focus(); 5979 event.preventDefault(); 5980 } 5981 }, 5982 5983 _panelKeyDown: function( event ) { 5984 if ( event.keyCode === $.ui.keyCode.UP && event.ctrlKey ) { 5985 $( event.currentTarget ).prev().focus(); 5986 } 5987 }, 5988 5989 refresh: function() { 5990 var options = this.options; 5991 this._processPanels(); 5992 5993 // was collapsed or no panel 5994 if ( ( options.active === false && options.collapsible === true ) || !this.headers.length ) { 5995 options.active = false; 5996 this.active = $(); 5997 // active false only when collapsible is true 5998 } else if ( options.active === false ) { 5999 this._activate( 0 ); 6000 // was active, but active panel is gone 6001 } else if ( this.active.length && !$.contains( this.element[ 0 ], this.active[ 0 ] ) ) { 6002 // all remaining panel are disabled 6003 if ( this.headers.length === this.headers.find(".ui-state-disabled").length ) { 6004 options.active = false; 6005 this.active = $(); 6006 // activate previous panel 6007 } else { 6008 this._activate( Math.max( 0, options.active - 1 ) ); 6009 } 6010 // was active, active panel still exists 6011 } else { 6012 // make sure active index is correct 6013 options.active = this.headers.index( this.active ); 6014 } 6015 6016 this._destroyIcons(); 6017 6018 this._refresh(); 6019 }, 6020 6021 _processPanels: function() { 6022 var prevHeaders = this.headers, 6023 prevPanels = this.panels; 6024 6025 this.headers = this.element.find( this.options.header ) 6026 .addClass( "ui-accordion-header ui-state-default ui-corner-all" ); 6027 6028 this.panels = this.headers.next() 6029 .addClass( "ui-accordion-content ui-helper-reset ui-widget-content ui-corner-bottom" ) 6030 .filter( ":not(.ui-accordion-content-active)" ) 6031 .hide(); 6032 6033 // Avoid memory leaks (#10056) 6034 if ( prevPanels ) { 6035 this._off( prevHeaders.not( this.headers ) ); 6036 this._off( prevPanels.not( this.panels ) ); 6037 } 6038 }, 6039 6040 _refresh: function() { 6041 var maxHeight, 6042 options = this.options, 6043 heightStyle = options.heightStyle, 6044 parent = this.element.parent(); 6045 6046 this.active = this._findActive( options.active ) 6047 .addClass( "ui-accordion-header-active ui-state-active ui-corner-top" ) 6048 .removeClass( "ui-corner-all" ); 6049 this.active.next() 6050 .addClass( "ui-accordion-content-active" ) 6051 .show(); 6052 6053 this.headers 6054 .attr( "role", "tab" ) 6055 .each(function() { 6056 var header = $( this ), 6057 headerId = header.uniqueId().attr( "id" ), 6058 panel = header.next(), 6059 panelId = panel.uniqueId().attr( "id" ); 6060 header.attr( "aria-controls", panelId ); 6061 panel.attr( "aria-labelledby", headerId ); 6062 }) 6063 .next() 6064 .attr( "role", "tabpanel" ); 6065 6066 this.headers 6067 .not( this.active ) 6068 .attr({ 6069 "aria-selected": "false", 6070 "aria-expanded": "false", 6071 tabIndex: -1 6072 }) 6073 .next() 6074 .attr({ 6075 "aria-hidden": "true" 6076 }) 6077 .hide(); 6078 6079 // make sure at least one header is in the tab order 6080 if ( !this.active.length ) { 6081 this.headers.eq( 0 ).attr( "tabIndex", 0 ); 6082 } else { 6083 this.active.attr({ 6084 "aria-selected": "true", 6085 "aria-expanded": "true", 6086 tabIndex: 0 6087 }) 6088 .next() 6089 .attr({ 6090 "aria-hidden": "false" 6091 }); 6092 } 6093 6094 this._createIcons(); 6095 6096 this._setupEvents( options.event ); 6097 6098 if ( heightStyle === "fill" ) { 6099 maxHeight = parent.height(); 6100 this.element.siblings( ":visible" ).each(function() { 6101 var elem = $( this ), 6102 position = elem.css( "position" ); 6103 6104 if ( position === "absolute" || position === "fixed" ) { 6105 return; 6106 } 6107 maxHeight -= elem.outerHeight( true ); 6108 }); 6109 6110 this.headers.each(function() { 6111 maxHeight -= $( this ).outerHeight( true ); 6112 }); 6113 6114 this.headers.next() 6115 .each(function() { 6116 $( this ).height( Math.max( 0, maxHeight - 6117 $( this ).innerHeight() + $( this ).height() ) ); 6118 }) 6119 .css( "overflow", "auto" ); 6120 } else if ( heightStyle === "auto" ) { 6121 maxHeight = 0; 6122 this.headers.next() 6123 .each(function() { 6124 maxHeight = Math.max( maxHeight, $( this ).css( "height", "" ).height() ); 6125 }) 6126 .height( maxHeight ); 6127 } 6128 }, 6129 6130 _activate: function( index ) { 6131 var active = this._findActive( index )[ 0 ]; 6132 6133 // trying to activate the already active panel 6134 if ( active === this.active[ 0 ] ) { 6135 return; 6136 } 6137 6138 // trying to collapse, simulate a click on the currently active header 6139 active = active || this.active[ 0 ]; 6140 6141 this._eventHandler({ 6142 target: active, 6143 currentTarget: active, 6144 preventDefault: $.noop 6145 }); 6146 }, 6147 6148 _findActive: function( selector ) { 6149 return typeof selector === "number" ? this.headers.eq( selector ) : $(); 6150 }, 6151 6152 _setupEvents: function( event ) { 6153 var events = { 6154 keydown: "_keydown" 6155 }; 6156 if ( event ) { 6157 $.each( event.split( " " ), function( index, eventName ) { 6158 events[ eventName ] = "_eventHandler"; 6159 }); 6160 } 6161 6162 this._off( this.headers.add( this.headers.next() ) ); 6163 this._on( this.headers, events ); 6164 this._on( this.headers.next(), { keydown: "_panelKeyDown" }); 6165 this._hoverable( this.headers ); 6166 this._focusable( this.headers ); 6167 }, 6168 6169 _eventHandler: function( event ) { 6170 var options = this.options, 6171 active = this.active, 6172 clicked = $( event.currentTarget ), 6173 clickedIsActive = clicked[ 0 ] === active[ 0 ], 6174 collapsing = clickedIsActive && options.collapsible, 6175 toShow = collapsing ? $() : clicked.next(), 6176 toHide = active.next(), 6177 eventData = { 6178 oldHeader: active, 6179 oldPanel: toHide, 6180 newHeader: collapsing ? $() : clicked, 6181 newPanel: toShow 6182 }; 6183 6184 event.preventDefault(); 6185 6186 if ( 6187 // click on active header, but not collapsible 6188 ( clickedIsActive && !options.collapsible ) || 6189 // allow canceling activation 6190 ( this._trigger( "beforeActivate", event, eventData ) === false ) ) { 6191 return; 6192 } 6193 6194 options.active = collapsing ? false : this.headers.index( clicked ); 6195 6196 // when the call to ._toggle() comes after the class changes 6197 // it causes a very odd bug in IE 8 (see #6720) 6198 this.active = clickedIsActive ? $() : clicked; 6199 this._toggle( eventData ); 6200 6201 // switch classes 6202 // corner classes on the previously active header stay after the animation 6203 active.removeClass( "ui-accordion-header-active ui-state-active" ); 6204 if ( options.icons ) { 6205 active.children( ".ui-accordion-header-icon" ) 6206 .removeClass( options.icons.activeHeader ) 6207 .addClass( options.icons.header ); 6208 } 6209 6210 if ( !clickedIsActive ) { 6211 clicked 6212 .removeClass( "ui-corner-all" ) 6213 .addClass( "ui-accordion-header-active ui-state-active ui-corner-top" ); 6214 if ( options.icons ) { 6215 clicked.children( ".ui-accordion-header-icon" ) 6216 .removeClass( options.icons.header ) 6217 .addClass( options.icons.activeHeader ); 6218 } 6219 6220 clicked 6221 .next() 6222 .addClass( "ui-accordion-content-active" ); 6223 } 6224 }, 6225 6226 _toggle: function( data ) { 6227 var toShow = data.newPanel, 6228 toHide = this.prevShow.length ? this.prevShow : data.oldPanel; 6229 6230 // handle activating a panel during the animation for another activation 6231 this.prevShow.add( this.prevHide ).stop( true, true ); 6232 this.prevShow = toShow; 6233 this.prevHide = toHide; 6234 6235 if ( this.options.animate ) { 6236 this._animate( toShow, toHide, data ); 6237 } else { 6238 toHide.hide(); 6239 toShow.show(); 6240 this._toggleComplete( data ); 6241 } 6242 6243 toHide.attr({ 6244 "aria-hidden": "true" 6245 }); 6246 toHide.prev().attr({ 6247 "aria-selected": "false", 6248 "aria-expanded": "false" 6249 }); 6250 // if we're switching panels, remove the old header from the tab order 6251 // if we're opening from collapsed state, remove the previous header from the tab order 6252 // if we're collapsing, then keep the collapsing header in the tab order 6253 if ( toShow.length && toHide.length ) { 6254 toHide.prev().attr({ 6255 "tabIndex": -1, 6256 "aria-expanded": "false" 6257 }); 6258 } else if ( toShow.length ) { 6259 this.headers.filter(function() { 6260 return parseInt( $( this ).attr( "tabIndex" ), 10 ) === 0; 6261 }) 6262 .attr( "tabIndex", -1 ); 6263 } 6264 6265 toShow 6266 .attr( "aria-hidden", "false" ) 6267 .prev() 6268 .attr({ 6269 "aria-selected": "true", 6270 "aria-expanded": "true", 6271 tabIndex: 0 6272 }); 6273 }, 6274 6275 _animate: function( toShow, toHide, data ) { 6276 var total, easing, duration, 6277 that = this, 6278 adjust = 0, 6279 boxSizing = toShow.css( "box-sizing" ), 6280 down = toShow.length && 6281 ( !toHide.length || ( toShow.index() < toHide.index() ) ), 6282 animate = this.options.animate || {}, 6283 options = down && animate.down || animate, 6284 complete = function() { 6285 that._toggleComplete( data ); 6286 }; 6287 6288 if ( typeof options === "number" ) { 6289 duration = options; 6290 } 6291 if ( typeof options === "string" ) { 6292 easing = options; 6293 } 6294 // fall back from options to animation in case of partial down settings 6295 easing = easing || options.easing || animate.easing; 6296 duration = duration || options.duration || animate.duration; 6297 6298 if ( !toHide.length ) { 6299 return toShow.animate( this.showProps, duration, easing, complete ); 6300 } 6301 if ( !toShow.length ) { 6302 return toHide.animate( this.hideProps, duration, easing, complete ); 6303 } 6304 6305 total = toShow.show().outerHeight(); 6306 toHide.animate( this.hideProps, { 6307 duration: duration, 6308 easing: easing, 6309 step: function( now, fx ) { 6310 fx.now = Math.round( now ); 6311 } 6312 }); 6313 toShow 6314 .hide() 6315 .animate( this.showProps, { 6316 duration: duration, 6317 easing: easing, 6318 complete: complete, 6319 step: function( now, fx ) { 6320 fx.now = Math.round( now ); 6321 if ( fx.prop !== "height" ) { 6322 if ( boxSizing === "content-box" ) { 6323 adjust += fx.now; 6324 } 6325 } else if ( that.options.heightStyle !== "content" ) { 6326 fx.now = Math.round( total - toHide.outerHeight() - adjust ); 6327 adjust = 0; 6328 } 6329 } 6330 }); 6331 }, 6332 6333 _toggleComplete: function( data ) { 6334 var toHide = data.oldPanel; 6335 6336 toHide 6337 .removeClass( "ui-accordion-content-active" ) 6338 .prev() 6339 .removeClass( "ui-corner-top" ) 6340 .addClass( "ui-corner-all" ); 6341 6342 // Work around for rendering bug in IE (#5421) 6343 if ( toHide.length ) { 6344 toHide.parent()[ 0 ].className = toHide.parent()[ 0 ].className; 6345 } 6346 this._trigger( "activate", null, data ); 6347 } 6348}); 6349 6350 6351/*! 6352 * jQuery UI Menu 1.11.4 6353 * http://jqueryui.com 6354 * 6355 * Copyright jQuery Foundation and other contributors 6356 * Released under the MIT license. 6357 * http://jquery.org/license 6358 * 6359 * http://api.jqueryui.com/menu/ 6360 */ 6361 6362 6363var menu = $.widget( "ui.menu", { 6364 version: "1.11.4", 6365 defaultElement: "<ul>", 6366 delay: 300, 6367 options: { 6368 icons: { 6369 submenu: "ui-icon-carat-1-e" 6370 }, 6371 items: "> *", 6372 menus: "ul", 6373 position: { 6374 my: "left-1 top", 6375 at: "right top" 6376 }, 6377 role: "menu", 6378 6379 // callbacks 6380 blur: null, 6381 focus: null, 6382 select: null 6383 }, 6384 6385 _create: function() { 6386 this.activeMenu = this.element; 6387 6388 // Flag used to prevent firing of the click handler 6389 // as the event bubbles up through nested menus 6390 this.mouseHandled = false; 6391 this.element 6392 .uniqueId() 6393 .addClass( "ui-menu ui-widget ui-widget-content" ) 6394 .toggleClass( "ui-menu-icons", !!this.element.find( ".ui-icon" ).length ) 6395 .attr({ 6396 role: this.options.role, 6397 tabIndex: 0 6398 }); 6399 6400 if ( this.options.disabled ) { 6401 this.element 6402 .addClass( "ui-state-disabled" ) 6403 .attr( "aria-disabled", "true" ); 6404 } 6405 6406 this._on({ 6407 // Prevent focus from sticking to links inside menu after clicking 6408 // them (focus should always stay on UL during navigation). 6409 "mousedown .ui-menu-item": function( event ) { 6410 event.preventDefault(); 6411 }, 6412 "click .ui-menu-item": function( event ) { 6413 var target = $( event.target ); 6414 if ( !this.mouseHandled && target.not( ".ui-state-disabled" ).length ) { 6415 this.select( event ); 6416 6417 // Only set the mouseHandled flag if the event will bubble, see #9469. 6418 if ( !event.isPropagationStopped() ) { 6419 this.mouseHandled = true; 6420 } 6421 6422 // Open submenu on click 6423 if ( target.has( ".ui-menu" ).length ) { 6424 this.expand( event ); 6425 } else if ( !this.element.is( ":focus" ) && $( this.document[ 0 ].activeElement ).closest( ".ui-menu" ).length ) { 6426 6427 // Redirect focus to the menu 6428 this.element.trigger( "focus", [ true ] ); 6429 6430 // If the active item is on the top level, let it stay active. 6431 // Otherwise, blur the active item since it is no longer visible. 6432 if ( this.active && this.active.parents( ".ui-menu" ).length === 1 ) { 6433 clearTimeout( this.timer ); 6434 } 6435 } 6436 } 6437 }, 6438 "mouseenter .ui-menu-item": function( event ) { 6439 // Ignore mouse events while typeahead is active, see #10458. 6440 // Prevents focusing the wrong item when typeahead causes a scroll while the mouse 6441 // is over an item in the menu 6442 if ( this.previousFilter ) { 6443 return; 6444 } 6445 var target = $( event.currentTarget ); 6446 // Remove ui-state-active class from siblings of the newly focused menu item 6447 // to avoid a jump caused by adjacent elements both having a class with a border 6448 target.siblings( ".ui-state-active" ).removeClass( "ui-state-active" ); 6449 this.focus( event, target ); 6450 }, 6451 mouseleave: "collapseAll", 6452 "mouseleave .ui-menu": "collapseAll", 6453 focus: function( event, keepActiveItem ) { 6454 // If there's already an active item, keep it active 6455 // If not, activate the first item 6456 var item = this.active || this.element.find( this.options.items ).eq( 0 ); 6457 6458 if ( !keepActiveItem ) { 6459 this.focus( event, item ); 6460 } 6461 }, 6462 blur: function( event ) { 6463 this._delay(function() { 6464 if ( !$.contains( this.element[0], this.document[0].activeElement ) ) { 6465 this.collapseAll( event ); 6466 } 6467 }); 6468 }, 6469 keydown: "_keydown" 6470 }); 6471 6472 this.refresh(); 6473 6474 // Clicks outside of a menu collapse any open menus 6475 this._on( this.document, { 6476 click: function( event ) { 6477 if ( this._closeOnDocumentClick( event ) ) { 6478 this.collapseAll( event ); 6479 } 6480 6481 // Reset the mouseHandled flag 6482 this.mouseHandled = false; 6483 } 6484 }); 6485 }, 6486 6487 _destroy: function() { 6488 // Destroy (sub)menus 6489 this.element 6490 .removeAttr( "aria-activedescendant" ) 6491 .find( ".ui-menu" ).addBack() 6492 .removeClass( "ui-menu ui-widget ui-widget-content ui-menu-icons ui-front" ) 6493 .removeAttr( "role" ) 6494 .removeAttr( "tabIndex" ) 6495 .removeAttr( "aria-labelledby" ) 6496 .removeAttr( "aria-expanded" ) 6497 .removeAttr( "aria-hidden" ) 6498 .removeAttr( "aria-disabled" ) 6499 .removeUniqueId() 6500 .show(); 6501 6502 // Destroy menu items 6503 this.element.find( ".ui-menu-item" ) 6504 .removeClass( "ui-menu-item" ) 6505 .removeAttr( "role" ) 6506 .removeAttr( "aria-disabled" ) 6507 .removeUniqueId() 6508 .removeClass( "ui-state-hover" ) 6509 .removeAttr( "tabIndex" ) 6510 .removeAttr( "role" ) 6511 .removeAttr( "aria-haspopup" ) 6512 .children().each( function() { 6513 var elem = $( this ); 6514 if ( elem.data( "ui-menu-submenu-carat" ) ) { 6515 elem.remove(); 6516 } 6517 }); 6518 6519 // Destroy menu dividers 6520 this.element.find( ".ui-menu-divider" ).removeClass( "ui-menu-divider ui-widget-content" ); 6521 }, 6522 6523 _keydown: function( event ) { 6524 var match, prev, character, skip, 6525 preventDefault = true; 6526 6527 switch ( event.keyCode ) { 6528 case $.ui.keyCode.PAGE_UP: 6529 this.previousPage( event ); 6530 break; 6531 case $.ui.keyCode.PAGE_DOWN: 6532 this.nextPage( event ); 6533 break; 6534 case $.ui.keyCode.HOME: 6535 this._move( "first", "first", event ); 6536 break; 6537 case $.ui.keyCode.END: 6538 this._move( "last", "last", event ); 6539 break; 6540 case $.ui.keyCode.UP: 6541 this.previous( event ); 6542 break; 6543 case $.ui.keyCode.DOWN: 6544 this.next( event ); 6545 break; 6546 case $.ui.keyCode.LEFT: 6547 this.collapse( event ); 6548 break; 6549 case $.ui.keyCode.RIGHT: 6550 if ( this.active && !this.active.is( ".ui-state-disabled" ) ) { 6551 this.expand( event ); 6552 } 6553 break; 6554 case $.ui.keyCode.ENTER: 6555 case $.ui.keyCode.SPACE: 6556 this._activate( event ); 6557 break; 6558 case $.ui.keyCode.ESCAPE: 6559 this.collapse( event ); 6560 break; 6561 default: 6562 preventDefault = false; 6563 prev = this.previousFilter || ""; 6564 character = String.fromCharCode( event.keyCode ); 6565 skip = false; 6566 6567 clearTimeout( this.filterTimer ); 6568 6569 if ( character === prev ) { 6570 skip = true; 6571 } else { 6572 character = prev + character; 6573 } 6574 6575 match = this._filterMenuItems( character ); 6576 match = skip && match.index( this.active.next() ) !== -1 ? 6577 this.active.nextAll( ".ui-menu-item" ) : 6578 match; 6579 6580 // If no matches on the current filter, reset to the last character pressed 6581 // to move down the menu to the first item that starts with that character 6582 if ( !match.length ) { 6583 character = String.fromCharCode( event.keyCode ); 6584 match = this._filterMenuItems( character ); 6585 } 6586 6587 if ( match.length ) { 6588 this.focus( event, match ); 6589 this.previousFilter = character; 6590 this.filterTimer = this._delay(function() { 6591 delete this.previousFilter; 6592 }, 1000 ); 6593 } else { 6594 delete this.previousFilter; 6595 } 6596 } 6597 6598 if ( preventDefault ) { 6599 event.preventDefault(); 6600 } 6601 }, 6602 6603 _activate: function( event ) { 6604 if ( !this.active.is( ".ui-state-disabled" ) ) { 6605 if ( this.active.is( "[aria-haspopup='true']" ) ) { 6606 this.expand( event ); 6607 } else { 6608 this.select( event ); 6609 } 6610 } 6611 }, 6612 6613 refresh: function() { 6614 var menus, items, 6615 that = this, 6616 icon = this.options.icons.submenu, 6617 submenus = this.element.find( this.options.menus ); 6618 6619 this.element.toggleClass( "ui-menu-icons", !!this.element.find( ".ui-icon" ).length ); 6620 6621 // Initialize nested menus 6622 submenus.filter( ":not(.ui-menu)" ) 6623 .addClass( "ui-menu ui-widget ui-widget-content ui-front" ) 6624 .hide() 6625 .attr({ 6626 role: this.options.role, 6627 "aria-hidden": "true", 6628 "aria-expanded": "false" 6629 }) 6630 .each(function() { 6631 var menu = $( this ), 6632 item = menu.parent(), 6633 submenuCarat = $( "<span>" ) 6634 .addClass( "ui-menu-icon ui-icon " + icon ) 6635 .data( "ui-menu-submenu-carat", true ); 6636 6637 item 6638 .attr( "aria-haspopup", "true" ) 6639 .prepend( submenuCarat ); 6640 menu.attr( "aria-labelledby", item.attr( "id" ) ); 6641 }); 6642 6643 menus = submenus.add( this.element ); 6644 items = menus.find( this.options.items ); 6645
vendor: 4,109 bytes, lines 6646-6797
6646 // Initialize menu-items containing spaces and/or dashes only as dividers 6647 items.not( ".ui-menu-item" ).each(function() { 6648 var item = $( this ); 6649 if ( that._isDivider( item ) ) { 6650 item.addClass( "ui-widget-content ui-menu-divider" ); 6651 } 6652 }); 6653 6654 // Don't refresh list items that are already adapted 6655 items.not( ".ui-menu-item, .ui-menu-divider" ) 6656 .addClass( "ui-menu-item" ) 6657 .uniqueId() 6658 .attr({ 6659 tabIndex: -1, 6660 role: this._itemRole() 6661 }); 6662 6663 // Add aria-disabled attribute to any disabled menu item 6664 items.filter( ".ui-state-disabled" ).attr( "aria-disabled", "true" ); 6665 6666 // If the active item has been removed, blur the menu 6667 if ( this.active && !$.contains( this.element[ 0 ], this.active[ 0 ] ) ) { 6668 this.blur(); 6669 } 6670 }, 6671 6672 _itemRole: function() { 6673 return { 6674 menu: "menuitem", 6675 listbox: "option" 6676 }[ this.options.role ]; 6677 }, 6678 6679 _setOption: function( key, value ) { 6680 if ( key === "icons" ) { 6681 this.element.find( ".ui-menu-icon" ) 6682 .removeClass( this.options.icons.submenu ) 6683 .addClass( value.submenu ); 6684 } 6685 if ( key === "disabled" ) { 6686 this.element 6687 .toggleClass( "ui-state-disabled", !!value ) 6688 .attr( "aria-disabled", value ); 6689 } 6690 this._super( key, value ); 6691 }, 6692 6693 focus: function( event, item ) { 6694 var nested, focused; 6695 this.blur( event, event && event.type === "focus" ); 6696 6697 this._scrollIntoView( item ); 6698 6699 this.active = item.first(); 6700 focused = this.active.addClass( "ui-state-focus" ).removeClass( "ui-state-active" ); 6701 // Only update aria-activedescendant if there's a role 6702 // otherwise we assume focus is managed elsewhere 6703 if ( this.options.role ) { 6704 this.element.attr( "aria-activedescendant", focused.attr( "id" ) ); 6705 } 6706 6707 // Highlight active parent menu item, if any 6708 this.active 6709 .parent() 6710 .closest( ".ui-menu-item" ) 6711 .addClass( "ui-state-active" ); 6712 6713 if ( event && event.type === "keydown" ) { 6714 this._close(); 6715 } else { 6716 this.timer = this._delay(function() { 6717 this._close(); 6718 }, this.delay ); 6719 } 6720 6721 nested = item.children( ".ui-menu" ); 6722 if ( nested.length && event && ( /^mouse/.test( event.type ) ) ) { 6723 this._startOpening(nested); 6724 } 6725 this.activeMenu = item.parent(); 6726 6727 this._trigger( "focus", event, { item: item } ); 6728 }, 6729 6730 _scrollIntoView: function( item ) { 6731 var borderTop, paddingTop, offset, scroll, elementHeight, itemHeight; 6732 if ( this._hasScroll() ) { 6733 borderTop = parseFloat( $.css( this.activeMenu[0], "borderTopWidth" ) ) || 0; 6734 paddingTop = parseFloat( $.css( this.activeMenu[0], "paddingTop" ) ) || 0; 6735 offset = item.offset().top - this.activeMenu.offset().top - borderTop - paddingTop; 6736 scroll = this.activeMenu.scrollTop(); 6737 elementHeight = this.activeMenu.height(); 6738 itemHeight = item.outerHeight(); 6739 6740 if ( offset < 0 ) { 6741 this.activeMenu.scrollTop( scroll + offset ); 6742 } else if ( offset + itemHeight > elementHeight ) { 6743 this.activeMenu.scrollTop( scroll + offset - elementHeight + itemHeight ); 6744 } 6745 } 6746 }, 6747 6748 blur: function( event, fromFocus ) { 6749 if ( !fromFocus ) { 6750 clearTimeout( this.timer ); 6751 } 6752 6753 if ( !this.active ) { 6754 return; 6755 } 6756 6757 this.active.removeClass( "ui-state-focus" ); 6758 this.active = null; 6759 6760 this._trigger( "blur", event, { item: this.active } ); 6761 }, 6762 6763 _startOpening: function( submenu ) { 6764 clearTimeout( this.timer ); 6765 6766 // Don't open if already open fixes a Firefox bug that caused a .5 pixel 6767 // shift in the submenu position when mousing over the carat icon 6768 if ( submenu.attr( "aria-hidden" ) !== "true" ) { 6769 return; 6770 } 6771 6772 this.timer = this._delay(function() { 6773 this._close(); 6774 this._open( submenu ); 6775 }, this.delay ); 6776 }, 6777 6778 _open: function( submenu ) { 6779 var position = $.extend({ 6780 of: this.active 6781 }, this.options.position ); 6782 6783 clearTimeout( this.timer ); 6784 this.element.find( ".ui-menu" ).not( submenu.parents( ".ui-menu" ) ) 6785 .hide() 6786 .attr( "aria-hidden", "true" ); 6787 6788 submenu 6789 .show() 6790 .removeAttr( "aria-hidden" ) 6791 .attr( "aria-expanded", "true" ) 6792 .position( position ); 6793 }, 6794 6795 collapseAll: function( event, all ) { 6796 clearTimeout( this.timer ); 6797 this.timer = this._delay(function() {
vendor: 11,138 bytes, lines 6798-7214
6798 // If we were passed an event, look for the submenu that contains the event 6799 var currentMenu = all ? this.element : 6800 $( event && event.target ).closest( this.element.find( ".ui-menu" ) ); 6801 6802 // If we found no valid submenu ancestor, use the main menu to close all sub menus anyway 6803 if ( !currentMenu.length ) { 6804 currentMenu = this.element; 6805 } 6806 6807 this._close( currentMenu ); 6808 6809 this.blur( event ); 6810 this.activeMenu = currentMenu; 6811 }, this.delay ); 6812 }, 6813 6814 // With no arguments, closes the currently active menu - if nothing is active 6815 // it closes all menus. If passed an argument, it will search for menus BELOW 6816 _close: function( startMenu ) { 6817 if ( !startMenu ) { 6818 startMenu = this.active ? this.active.parent() : this.element; 6819 } 6820 6821 startMenu 6822 .find( ".ui-menu" ) 6823 .hide() 6824 .attr( "aria-hidden", "true" ) 6825 .attr( "aria-expanded", "false" ) 6826 .end() 6827 .find( ".ui-state-active" ).not( ".ui-state-focus" ) 6828 .removeClass( "ui-state-active" ); 6829 }, 6830 6831 _closeOnDocumentClick: function( event ) { 6832 return !$( event.target ).closest( ".ui-menu" ).length; 6833 }, 6834 6835 _isDivider: function( item ) { 6836 6837 // Match hyphen, em dash, en dash 6838 return !/[^\-\u2014\u2013\s]/.test( item.text() ); 6839 }, 6840 6841 collapse: function( event ) { 6842 var newItem = this.active && 6843 this.active.parent().closest( ".ui-menu-item", this.element ); 6844 if ( newItem && newItem.length ) { 6845 this._close(); 6846 this.focus( event, newItem ); 6847 } 6848 }, 6849 6850 expand: function( event ) { 6851 var newItem = this.active && 6852 this.active 6853 .children( ".ui-menu " ) 6854 .find( this.options.items ) 6855 .first(); 6856 6857 if ( newItem && newItem.length ) { 6858 this._open( newItem.parent() ); 6859 6860 // Delay so Firefox will not hide activedescendant change in expanding submenu from AT 6861 this._delay(function() { 6862 this.focus( event, newItem ); 6863 }); 6864 } 6865 }, 6866 6867 next: function( event ) { 6868 this._move( "next", "first", event ); 6869 }, 6870 6871 previous: function( event ) { 6872 this._move( "prev", "last", event ); 6873 }, 6874 6875 isFirstItem: function() { 6876 return this.active && !this.active.prevAll( ".ui-menu-item" ).length; 6877 }, 6878 6879 isLastItem: function() { 6880 return this.active && !this.active.nextAll( ".ui-menu-item" ).length; 6881 }, 6882 6883 _move: function( direction, filter, event ) { 6884 var next; 6885 if ( this.active ) { 6886 if ( direction === "first" || direction === "last" ) { 6887 next = this.active 6888 [ direction === "first" ? "prevAll" : "nextAll" ]( ".ui-menu-item" ) 6889 .eq( -1 ); 6890 } else { 6891 next = this.active 6892 [ direction + "All" ]( ".ui-menu-item" ) 6893 .eq( 0 ); 6894 } 6895 } 6896 if ( !next || !next.length || !this.active ) { 6897 next = this.activeMenu.find( this.options.items )[ filter ](); 6898 } 6899 6900 this.focus( event, next ); 6901 }, 6902 6903 nextPage: function( event ) { 6904 var item, base, height; 6905 6906 if ( !this.active ) { 6907 this.next( event ); 6908 return; 6909 } 6910 if ( this.isLastItem() ) { 6911 return; 6912 } 6913 if ( this._hasScroll() ) { 6914 base = this.active.offset().top; 6915 height = this.element.height(); 6916 this.active.nextAll( ".ui-menu-item" ).each(function() { 6917 item = $( this ); 6918 return item.offset().top - base - height < 0; 6919 }); 6920 6921 this.focus( event, item ); 6922 } else { 6923 this.focus( event, this.activeMenu.find( this.options.items ) 6924 [ !this.active ? "first" : "last" ]() ); 6925 } 6926 }, 6927 6928 previousPage: function( event ) { 6929 var item, base, height; 6930 if ( !this.active ) { 6931 this.next( event ); 6932 return; 6933 } 6934 if ( this.isFirstItem() ) { 6935 return; 6936 } 6937 if ( this._hasScroll() ) { 6938 base = this.active.offset().top; 6939 height = this.element.height(); 6940 this.active.prevAll( ".ui-menu-item" ).each(function() { 6941 item = $( this ); 6942 return item.offset().top - base + height > 0; 6943 }); 6944 6945 this.focus( event, item ); 6946 } else { 6947 this.focus( event, this.activeMenu.find( this.options.items ).first() ); 6948 } 6949 }, 6950 6951 _hasScroll: function() { 6952 return this.element.outerHeight() < this.element.prop( "scrollHeight" ); 6953 }, 6954 6955 select: function( event ) { 6956 // TODO: It should never be possible to not have an active item at this 6957 // point, but the tests don't trigger mouseenter before click. 6958 this.active = this.active || $( event.target ).closest( ".ui-menu-item" ); 6959 var ui = { item: this.active }; 6960 if ( !this.active.has( ".ui-menu" ).length ) { 6961 this.collapseAll( event, true ); 6962 } 6963 this._trigger( "select", event, ui ); 6964 }, 6965 6966 _filterMenuItems: function(character) { 6967 var escapedCharacter = character.replace( /[\-\[\]{}()*+?.,\\\^$|#\s]/g, "\\$&" ), 6968 regex = new RegExp( "^" + escapedCharacter, "i" ); 6969 6970 return this.activeMenu 6971 .find( this.options.items ) 6972 6973 // Only match on items, not dividers or other content (#10571) 6974 .filter( ".ui-menu-item" ) 6975 .filter(function() { 6976 return regex.test( $.trim( $( this ).text() ) ); 6977 }); 6978 } 6979}); 6980 6981 6982/*! 6983 * jQuery UI Autocomplete 1.11.4 6984 * http://jqueryui.com 6985 * 6986 * Copyright jQuery Foundation and other contributors 6987 * Released under the MIT license. 6988 * http://jquery.org/license 6989 * 6990 * http://api.jqueryui.com/autocomplete/ 6991 */ 6992 6993 6994$.widget( "ui.autocomplete", { 6995 version: "1.11.4", 6996 defaultElement: "<input>", 6997 options: { 6998 appendTo: null, 6999 autoFocus: false, 7000 delay: 300, 7001 minLength: 1, 7002 position: { 7003 my: "left top", 7004 at: "left bottom", 7005 collision: "none" 7006 }, 7007 source: null, 7008 7009 // callbacks 7010 change: null, 7011 close: null, 7012 focus: null, 7013 open: null, 7014 response: null, 7015 search: null, 7016 select: null 7017 }, 7018 7019 requestIndex: 0, 7020 pending: 0, 7021 7022 _create: function() { 7023 // Some browsers only repeat keydown events, not keypress events, 7024 // so we use the suppressKeyPress flag to determine if we've already 7025 // handled the keydown event. #7269 7026 // Unfortunately the code for & in keypress is the same as the up arrow, 7027 // so we use the suppressKeyPressRepeat flag to avoid handling keypress 7028 // events when we know the keydown event was used to modify the 7029 // search term. #7799 7030 var suppressKeyPress, suppressKeyPressRepeat, suppressInput, 7031 nodeName = this.element[ 0 ].nodeName.toLowerCase(), 7032 isTextarea = nodeName === "textarea", 7033 isInput = nodeName === "input"; 7034 7035 this.isMultiLine = 7036 // Textareas are always multi-line 7037 isTextarea ? true : 7038 // Inputs are always single-line, even if inside a contentEditable element 7039 // IE also treats inputs as contentEditable 7040 isInput ? false : 7041 // All other element types are determined by whether or not they're contentEditable 7042 this.element.prop( "isContentEditable" ); 7043 7044 this.valueMethod = this.element[ isTextarea || isInput ? "val" : "text" ]; 7045 this.isNewMenu = true; 7046 7047 this.element 7048 .addClass( "ui-autocomplete-input" ) 7049 .attr( "autocomplete", "off" ); 7050 7051 this._on( this.element, { 7052 keydown: function( event ) { 7053 if ( this.element.prop( "readOnly" ) ) { 7054 suppressKeyPress = true; 7055 suppressInput = true; 7056 suppressKeyPressRepeat = true; 7057 return; 7058 } 7059 7060 suppressKeyPress = false; 7061 suppressInput = false; 7062 suppressKeyPressRepeat = false; 7063 var keyCode = $.ui.keyCode; 7064 switch ( event.keyCode ) { 7065 case keyCode.PAGE_UP: 7066 suppressKeyPress = true; 7067 this._move( "previousPage", event ); 7068 break; 7069 case keyCode.PAGE_DOWN: 7070 suppressKeyPress = true; 7071 this._move( "nextPage", event ); 7072 break; 7073 case keyCode.UP: 7074 suppressKeyPress = true; 7075 this._keyEvent( "previous", event ); 7076 break; 7077 case keyCode.DOWN: 7078 suppressKeyPress = true; 7079 this._keyEvent( "next", event ); 7080 break; 7081 case keyCode.ENTER: 7082 // when menu is open and has focus 7083 if ( this.menu.active ) { 7084 // #6055 - Opera still allows the keypress to occur 7085 // which causes forms to submit 7086 suppressKeyPress = true; 7087 event.preventDefault(); 7088 this.menu.select( event ); 7089 } 7090 break; 7091 case keyCode.TAB: 7092 if ( this.menu.active ) { 7093 this.menu.select( event ); 7094 } 7095 break; 7096 case keyCode.ESCAPE: 7097 if ( this.menu.element.is( ":visible" ) ) { 7098 if ( !this.isMultiLine ) { 7099 this._value( this.term ); 7100 } 7101 this.close( event ); 7102 // Different browsers have different default behavior for escape 7103 // Single press can mean undo or clear 7104 // Double press in IE means clear the whole form 7105 event.preventDefault(); 7106 } 7107 break; 7108 default: 7109 suppressKeyPressRepeat = true; 7110 // search timeout should be triggered before the input value is changed 7111 this._searchTimeout( event ); 7112 break; 7113 } 7114 }, 7115 keypress: function( event ) { 7116 if ( suppressKeyPress ) { 7117 suppressKeyPress = false; 7118 if ( !this.isMultiLine || this.menu.element.is( ":visible" ) ) { 7119 event.preventDefault(); 7120 } 7121 return; 7122 } 7123 if ( suppressKeyPressRepeat ) { 7124 return; 7125 } 7126 7127 // replicate some key handlers to allow them to repeat in Firefox and Opera 7128 var keyCode = $.ui.keyCode; 7129 switch ( event.keyCode ) { 7130 case keyCode.PAGE_UP: 7131 this._move( "previousPage", event ); 7132 break; 7133 case keyCode.PAGE_DOWN: 7134 this._move( "nextPage", event ); 7135 break; 7136 case keyCode.UP: 7137 this._keyEvent( "previous", event ); 7138 break; 7139 case keyCode.DOWN: 7140 this._keyEvent( "next", event ); 7141 break; 7142 } 7143 }, 7144 input: function( event ) { 7145 if ( suppressInput ) { 7146 suppressInput = false; 7147 event.preventDefault(); 7148 return; 7149 } 7150 this._searchTimeout( event ); 7151 }, 7152 focus: function() { 7153 this.selectedItem = null; 7154 this.previous = this._value(); 7155 }, 7156 blur: function( event ) { 7157 if ( this.cancelBlur ) { 7158 delete this.cancelBlur; 7159 return; 7160 } 7161 7162 clearTimeout( this.searching ); 7163 this.close( event ); 7164 this._change( event ); 7165 } 7166 }); 7167 7168 this._initSource(); 7169 this.menu = $( "<ul>" ) 7170 .addClass( "ui-autocomplete ui-front" ) 7171 .appendTo( this._appendTo() ) 7172 .menu({ 7173 // disable ARIA support, the live region takes care of that 7174 role: null 7175 }) 7176 .hide() 7177 .menu( "instance" ); 7178 7179 this._on( this.menu.element, { 7180 mousedown: function( event ) { 7181 // prevent moving focus out of the text field 7182 event.preventDefault(); 7183 7184 // IE doesn't prevent moving focus even with event.preventDefault() 7185 // so we set a flag to know when we should ignore the blur event 7186 this.cancelBlur = true; 7187 this._delay(function() { 7188 delete this.cancelBlur; 7189 }); 7190 7191 // clicking on the scrollbar causes focus to shift to the body 7192 // but we can't detect a mouseup or a click immediately afterward 7193 // so we have to track the next mousedown and close the menu if 7194 // the user clicks somewhere outside of the autocomplete 7195 var menuElement = this.menu.element[ 0 ]; 7196 if ( !$( event.target ).closest( ".ui-menu-item" ).length ) { 7197 this._delay(function() { 7198 var that = this; 7199 this.document.one( "mousedown", function( event ) { 7200 if ( event.target !== that.element[ 0 ] && 7201 event.target !== menuElement && 7202 !$.contains( menuElement, event.target ) ) { 7203 that.close(); 7204 } 7205 }); 7206 }); 7207 } 7208 }, 7209 menufocus: function( event, ui ) { 7210 var label, item; 7211 // support: Firefox 7212 // Prevent accidental activation of menu items in Firefox (#7024 #9118) 7213 if ( this.isNewMenu ) { 7214 this.isNewMenu = false;
vendor: 4,086 bytes, lines 7215-7365
7215 if ( event.originalEvent && /^mouse/.test( event.originalEvent.type ) ) { 7216 this.menu.blur(); 7217 7218 this.document.one( "mousemove", function() { 7219 $( event.target ).trigger( event.originalEvent ); 7220 }); 7221 7222 return; 7223 } 7224 } 7225 7226 item = ui.item.data( "ui-autocomplete-item" ); 7227 if ( false !== this._trigger( "focus", event, { item: item } ) ) { 7228 // use value to match what will end up in the input, if it was a key event 7229 if ( event.originalEvent && /^key/.test( event.originalEvent.type ) ) { 7230 this._value( item.value ); 7231 } 7232 } 7233 7234 // Announce the value in the liveRegion 7235 label = ui.item.attr( "aria-label" ) || item.value; 7236 if ( label && $.trim( label ).length ) { 7237 this.liveRegion.children().hide(); 7238 $( "<div>" ).text( label ).appendTo( this.liveRegion ); 7239 } 7240 }, 7241 menuselect: function( event, ui ) { 7242 var item = ui.item.data( "ui-autocomplete-item" ), 7243 previous = this.previous; 7244 7245 // only trigger when focus was lost (click on menu) 7246 if ( this.element[ 0 ] !== this.document[ 0 ].activeElement ) { 7247 this.element.focus(); 7248 this.previous = previous; 7249 // #6109 - IE triggers two focus events and the second 7250 // is asynchronous, so we need to reset the previous 7251 // term synchronously and asynchronously :-( 7252 this._delay(function() { 7253 this.previous = previous; 7254 this.selectedItem = item; 7255 }); 7256 } 7257 7258 if ( false !== this._trigger( "select", event, { item: item } ) ) { 7259 this._value( item.value ); 7260 } 7261 // reset the term after the select event 7262 // this allows custom select handling to work properly 7263 this.term = this._value(); 7264 7265 this.close( event ); 7266 this.selectedItem = item; 7267 } 7268 }); 7269 7270 this.liveRegion = $( "<span>", { 7271 role: "status", 7272 "aria-live": "assertive", 7273 "aria-relevant": "additions" 7274 }) 7275 .addClass( "ui-helper-hidden-accessible" ) 7276 .appendTo( this.document[ 0 ].body ); 7277 7278 // turning off autocomplete prevents the browser from remembering the 7279 // value when navigating through history, so we re-enable autocomplete 7280 // if the page is unloaded before the widget is destroyed. #7790 7281 this._on( this.window, { 7282 beforeunload: function() { 7283 this.element.removeAttr( "autocomplete" ); 7284 } 7285 }); 7286 }, 7287 7288 _destroy: function() { 7289 clearTimeout( this.searching ); 7290 this.element 7291 .removeClass( "ui-autocomplete-input" ) 7292 .removeAttr( "autocomplete" ); 7293 this.menu.element.remove(); 7294 this.liveRegion.remove(); 7295 }, 7296 7297 _setOption: function( key, value ) { 7298 this._super( key, value ); 7299 if ( key === "source" ) { 7300 this._initSource(); 7301 } 7302 if ( key === "appendTo" ) { 7303 this.menu.element.appendTo( this._appendTo() ); 7304 } 7305 if ( key === "disabled" && value && this.xhr ) { 7306 this.xhr.abort(); 7307 } 7308 }, 7309 7310 _appendTo: function() { 7311 var element = this.options.appendTo; 7312 7313 if ( element ) { 7314 element = element.jquery || element.nodeType ? 7315 $( element ) : 7316 this.document.find( element ).eq( 0 ); 7317 } 7318 7319 if ( !element || !element[ 0 ] ) { 7320 element = this.element.closest( ".ui-front" ); 7321 } 7322 7323 if ( !element.length ) { 7324 element = this.document[ 0 ].body; 7325 } 7326 7327 return element; 7328 }, 7329 7330 _initSource: function() { 7331 var array, url, 7332 that = this; 7333 if ( $.isArray( this.options.source ) ) { 7334 array = this.options.source; 7335 this.source = function( request, response ) { 7336 response( $.ui.autocomplete.filter( array, request.term ) ); 7337 }; 7338 } else if ( typeof this.options.source === "string" ) { 7339 url = this.options.source; 7340 this.source = function( request, response ) { 7341 if ( that.xhr ) { 7342 that.xhr.abort(); 7343 } 7344 that.xhr = $.ajax({ 7345 url: url, 7346 data: request, 7347 dataType: "json", 7348 success: function( data ) { 7349 response( data ); 7350 }, 7351 error: function() { 7352 response([]); 7353 } 7354 }); 7355 }; 7356 } else { 7357 this.source = this.options.source; 7358 } 7359 }, 7360 7361 _searchTimeout: function( event ) { 7362 clearTimeout( this.searching ); 7363 this.searching = this._delay(function() { 7364 7365 // Search if the value has changed, or if the user retypes the same value (see #7434)
vendor: 8,850 bytes, lines 7366-7714
7366 var equalValues = this.term === this._value(), 7367 menuVisible = this.menu.element.is( ":visible" ), 7368 modifierKey = event.altKey || event.ctrlKey || event.metaKey || event.shiftKey; 7369 7370 if ( !equalValues || ( equalValues && !menuVisible && !modifierKey ) ) { 7371 this.selectedItem = null; 7372 this.search( null, event ); 7373 } 7374 }, this.options.delay ); 7375 }, 7376 7377 search: function( value, event ) { 7378 value = value != null ? value : this._value(); 7379 7380 // always save the actual value, not the one passed as an argument 7381 this.term = this._value(); 7382 7383 if ( value.length < this.options.minLength ) { 7384 return this.close( event ); 7385 } 7386 7387 if ( this._trigger( "search", event ) === false ) { 7388 return; 7389 } 7390 7391 return this._search( value ); 7392 }, 7393 7394 _search: function( value ) { 7395 this.pending++; 7396 this.element.addClass( "ui-autocomplete-loading" ); 7397 this.cancelSearch = false; 7398 7399 this.source( { term: value }, this._response() ); 7400 }, 7401 7402 _response: function() { 7403 var index = ++this.requestIndex; 7404 7405 return $.proxy(function( content ) { 7406 if ( index === this.requestIndex ) { 7407 this.__response( content ); 7408 } 7409 7410 this.pending--; 7411 if ( !this.pending ) { 7412 this.element.removeClass( "ui-autocomplete-loading" ); 7413 } 7414 }, this ); 7415 }, 7416 7417 __response: function( content ) { 7418 if ( content ) { 7419 content = this._normalize( content ); 7420 } 7421 this._trigger( "response", null, { content: content } ); 7422 if ( !this.options.disabled && content && content.length && !this.cancelSearch ) { 7423 this._suggest( content ); 7424 this._trigger( "open" ); 7425 } else { 7426 // use ._close() instead of .close() so we don't cancel future searches 7427 this._close(); 7428 } 7429 }, 7430 7431 close: function( event ) { 7432 this.cancelSearch = true; 7433 this._close( event ); 7434 }, 7435 7436 _close: function( event ) { 7437 if ( this.menu.element.is( ":visible" ) ) { 7438 this.menu.element.hide(); 7439 this.menu.blur(); 7440 this.isNewMenu = true; 7441 this._trigger( "close", event ); 7442 } 7443 }, 7444 7445 _change: function( event ) { 7446 if ( this.previous !== this._value() ) { 7447 this._trigger( "change", event, { item: this.selectedItem } ); 7448 } 7449 }, 7450 7451 _normalize: function( items ) { 7452 // assume all items have the right format when the first item is complete 7453 if ( items.length && items[ 0 ].label && items[ 0 ].value ) { 7454 return items; 7455 } 7456 return $.map( items, function( item ) { 7457 if ( typeof item === "string" ) { 7458 return { 7459 label: item, 7460 value: item 7461 }; 7462 } 7463 return $.extend( {}, item, { 7464 label: item.label || item.value, 7465 value: item.value || item.label 7466 }); 7467 }); 7468 }, 7469 7470 _suggest: function( items ) { 7471 var ul = this.menu.element.empty(); 7472 this._renderMenu( ul, items ); 7473 this.isNewMenu = true; 7474 this.menu.refresh(); 7475 7476 // size and position menu 7477 ul.show(); 7478 this._resizeMenu(); 7479 ul.position( $.extend({ 7480 of: this.element 7481 }, this.options.position ) ); 7482 7483 if ( this.options.autoFocus ) { 7484 this.menu.next(); 7485 } 7486 }, 7487 7488 _resizeMenu: function() { 7489 var ul = this.menu.element; 7490 ul.outerWidth( Math.max( 7491 // Firefox wraps long text (possibly a rounding bug) 7492 // so we add 1px to avoid the wrapping (#7513) 7493 ul.width( "" ).outerWidth() + 1, 7494 this.element.outerWidth() 7495 ) ); 7496 }, 7497 7498 _renderMenu: function( ul, items ) { 7499 var that = this; 7500 $.each( items, function( index, item ) { 7501 that._renderItemData( ul, item ); 7502 }); 7503 }, 7504 7505 _renderItemData: function( ul, item ) { 7506 return this._renderItem( ul, item ).data( "ui-autocomplete-item", item ); 7507 }, 7508 7509 _renderItem: function( ul, item ) { 7510 return $( "<li>" ).text( item.label ).appendTo( ul ); 7511 }, 7512 7513 _move: function( direction, event ) { 7514 if ( !this.menu.element.is( ":visible" ) ) { 7515 this.search( null, event ); 7516 return; 7517 } 7518 if ( this.menu.isFirstItem() && /^previous/.test( direction ) || 7519 this.menu.isLastItem() && /^next/.test( direction ) ) { 7520 7521 if ( !this.isMultiLine ) { 7522 this._value( this.term ); 7523 } 7524 7525 this.menu.blur(); 7526 return; 7527 } 7528 this.menu[ direction ]( event ); 7529 }, 7530 7531 widget: function() { 7532 return this.menu.element; 7533 }, 7534 7535 _value: function() { 7536 return this.valueMethod.apply( this.element, arguments ); 7537 }, 7538 7539 _keyEvent: function( keyEvent, event ) { 7540 if ( !this.isMultiLine || this.menu.element.is( ":visible" ) ) { 7541 this._move( keyEvent, event ); 7542 7543 // prevents moving cursor to beginning/end of the text field in some browsers 7544 event.preventDefault(); 7545 } 7546 } 7547}); 7548 7549$.extend( $.ui.autocomplete, { 7550 escapeRegex: function( value ) { 7551 return value.replace( /[\-\[\]{}()*+?.,\\\^$|#\s]/g, "\\$&" ); 7552 }, 7553 filter: function( array, term ) { 7554 var matcher = new RegExp( $.ui.autocomplete.escapeRegex( term ), "i" ); 7555 return $.grep( array, function( value ) { 7556 return matcher.test( value.label || value.value || value ); 7557 }); 7558 } 7559}); 7560 7561// live region extension, adding a `messages` option 7562// NOTE: This is an experimental API. We are still investigating 7563// a full solution for string manipulation and internationalization. 7564$.widget( "ui.autocomplete", $.ui.autocomplete, { 7565 options: { 7566 messages: { 7567 noResults: "No search results.", 7568 results: function( amount ) { 7569 return amount + ( amount > 1 ? " results are" : " result is" ) + 7570 " available, use up and down arrow keys to navigate."; 7571 } 7572 } 7573 }, 7574 7575 __response: function( content ) { 7576 var message; 7577 this._superApply( arguments ); 7578 if ( this.options.disabled || this.cancelSearch ) { 7579 return; 7580 } 7581 if ( content && content.length ) { 7582 message = this.options.messages.results( content.length ); 7583 } else { 7584 message = this.options.messages.noResults; 7585 } 7586 this.liveRegion.children().hide(); 7587 $( "<div>" ).text( message ).appendTo( this.liveRegion ); 7588 } 7589}); 7590 7591var autocomplete = $.ui.autocomplete; 7592 7593 7594/*! 7595 * jQuery UI Button 1.11.4 7596 * http://jqueryui.com 7597 * 7598 * Copyright jQuery Foundation and other contributors 7599 * Released under the MIT license. 7600 * http://jquery.org/license 7601 * 7602 * http://api.jqueryui.com/button/ 7603 */ 7604 7605 7606var lastActive, 7607 baseClasses = "ui-button ui-widget ui-state-default ui-corner-all", 7608 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", 7609 formResetHandler = function() { 7610 var form = $( this ); 7611 setTimeout(function() { 7612 form.find( ":ui-button" ).button( "refresh" ); 7613 }, 1 ); 7614 }, 7615 radioGroup = function( radio ) { 7616 var name = radio.name, 7617 form = radio.form, 7618 radios = $( [] ); 7619 if ( name ) { 7620 name = name.replace( /'/g, "\\'" ); 7621 if ( form ) { 7622 radios = $( form ).find( "[name='" + name + "'][type=radio]" ); 7623 } else { 7624 radios = $( "[name='" + name + "'][type=radio]", radio.ownerDocument ) 7625 .filter(function() { 7626 return !this.form; 7627 }); 7628 } 7629 } 7630 return radios; 7631 }; 7632 7633$.widget( "ui.button", { 7634 version: "1.11.4", 7635 defaultElement: "<button>", 7636 options: { 7637 disabled: null, 7638 text: true, 7639 label: null, 7640 icons: { 7641 primary: null, 7642 secondary: null 7643 } 7644 }, 7645 _create: function() { 7646 this.element.closest( "form" ) 7647 .unbind( "reset" + this.eventNamespace ) 7648 .bind( "reset" + this.eventNamespace, formResetHandler ); 7649 7650 if ( typeof this.options.disabled !== "boolean" ) { 7651 this.options.disabled = !!this.element.prop( "disabled" ); 7652 } else { 7653 this.element.prop( "disabled", this.options.disabled ); 7654 } 7655 7656 this._determineButtonType(); 7657 this.hasTitle = !!this.buttonElement.attr( "title" ); 7658 7659 var that = this, 7660 options = this.options, 7661 toggleButton = this.type === "checkbox" || this.type === "radio", 7662 activeClass = !toggleButton ? "ui-state-active" : ""; 7663 7664 if ( options.label === null ) { 7665 options.label = (this.type === "input" ? this.buttonElement.val() : this.buttonElement.html()); 7666 } 7667 7668 this._hoverable( this.buttonElement ); 7669 7670 this.buttonElement 7671 .addClass( baseClasses ) 7672 .attr( "role", "button" ) 7673 .bind( "mouseenter" + this.eventNamespace, function() { 7674 if ( options.disabled ) { 7675 return; 7676 } 7677 if ( this === lastActive ) { 7678 $( this ).addClass( "ui-state-active" ); 7679 } 7680 }) 7681 .bind( "mouseleave" + this.eventNamespace, function() { 7682 if ( options.disabled ) { 7683 return; 7684 } 7685 $( this ).removeClass( activeClass ); 7686 }) 7687 .bind( "click" + this.eventNamespace, function( event ) { 7688 if ( options.disabled ) { 7689 event.preventDefault(); 7690 event.stopImmediatePropagation(); 7691 } 7692 }); 7693 7694 // Can't use _focusable() because the element that receives focus 7695 // and the element that gets the ui-state-focus class are different 7696 this._on({ 7697 focus: function() { 7698 this.buttonElement.addClass( "ui-state-focus" ); 7699 }, 7700 blur: function() { 7701 this.buttonElement.removeClass( "ui-state-focus" ); 7702 } 7703 }); 7704 7705 if ( toggleButton ) { 7706 this.element.bind( "change" + this.eventNamespace, function() { 7707 that.refresh(); 7708 }); 7709 } 7710 7711 if ( this.type === "checkbox" ) { 7712 this.buttonElement.bind( "click" + this.eventNamespace, function() { 7713 if ( options.disabled ) { 7714 return false;
vendor: 5,528 bytes, lines 7715-7899
7715 } 7716 }); 7717 } else if ( this.type === "radio" ) { 7718 this.buttonElement.bind( "click" + this.eventNamespace, function() { 7719 if ( options.disabled ) { 7720 return false; 7721 } 7722 $( this ).addClass( "ui-state-active" ); 7723 that.buttonElement.attr( "aria-pressed", "true" ); 7724 7725 var radio = that.element[ 0 ]; 7726 radioGroup( radio ) 7727 .not( radio ) 7728 .map(function() { 7729 return $( this ).button( "widget" )[ 0 ]; 7730 }) 7731 .removeClass( "ui-state-active" ) 7732 .attr( "aria-pressed", "false" ); 7733 }); 7734 } else { 7735 this.buttonElement 7736 .bind( "mousedown" + this.eventNamespace, function() { 7737 if ( options.disabled ) { 7738 return false; 7739 } 7740 $( this ).addClass( "ui-state-active" ); 7741 lastActive = this; 7742 that.document.one( "mouseup", function() { 7743 lastActive = null; 7744 }); 7745 }) 7746 .bind( "mouseup" + this.eventNamespace, function() { 7747 if ( options.disabled ) { 7748 return false; 7749 } 7750 $( this ).removeClass( "ui-state-active" ); 7751 }) 7752 .bind( "keydown" + this.eventNamespace, function(event) { 7753 if ( options.disabled ) { 7754 return false; 7755 } 7756 if ( event.keyCode === $.ui.keyCode.SPACE || event.keyCode === $.ui.keyCode.ENTER ) { 7757 $( this ).addClass( "ui-state-active" ); 7758 } 7759 }) 7760 // see #8559, we bind to blur here in case the button element loses 7761 // focus between keydown and keyup, it would be left in an "active" state 7762 .bind( "keyup" + this.eventNamespace + " blur" + this.eventNamespace, function() { 7763 $( this ).removeClass( "ui-state-active" ); 7764 }); 7765 7766 if ( this.buttonElement.is("a") ) { 7767 this.buttonElement.keyup(function(event) { 7768 if ( event.keyCode === $.ui.keyCode.SPACE ) { 7769 // TODO pass through original event correctly (just as 2nd argument doesn't work) 7770 $( this ).click(); 7771 } 7772 }); 7773 } 7774 } 7775 7776 this._setOption( "disabled", options.disabled ); 7777 this._resetButton(); 7778 }, 7779 7780 _determineButtonType: function() { 7781 var ancestor, labelSelector, checked; 7782 7783 if ( this.element.is("[type=checkbox]") ) { 7784 this.type = "checkbox"; 7785 } else if ( this.element.is("[type=radio]") ) { 7786 this.type = "radio"; 7787 } else if ( this.element.is("input") ) { 7788 this.type = "input"; 7789 } else { 7790 this.type = "button"; 7791 } 7792 7793 if ( this.type === "checkbox" || this.type === "radio" ) { 7794 // we don't search against the document in case the element 7795 // is disconnected from the DOM 7796 ancestor = this.element.parents().last(); 7797 labelSelector = "label[for='" + this.element.attr("id") + "']"; 7798 this.buttonElement = ancestor.find( labelSelector ); 7799 if ( !this.buttonElement.length ) { 7800 ancestor = ancestor.length ? ancestor.siblings() : this.element.siblings(); 7801 this.buttonElement = ancestor.filter( labelSelector ); 7802 if ( !this.buttonElement.length ) { 7803 this.buttonElement = ancestor.find( labelSelector ); 7804 } 7805 } 7806 this.element.addClass( "ui-helper-hidden-accessible" ); 7807 7808 checked = this.element.is( ":checked" ); 7809 if ( checked ) { 7810 this.buttonElement.addClass( "ui-state-active" ); 7811 } 7812 this.buttonElement.prop( "aria-pressed", checked ); 7813 } else { 7814 this.buttonElement = this.element; 7815 } 7816 }, 7817 7818 widget: function() { 7819 return this.buttonElement; 7820 }, 7821 7822 _destroy: function() { 7823 this.element 7824 .removeClass( "ui-helper-hidden-accessible" ); 7825 this.buttonElement 7826 .removeClass( baseClasses + " ui-state-active " + typeClasses ) 7827 .removeAttr( "role" ) 7828 .removeAttr( "aria-pressed" ) 7829 .html( this.buttonElement.find(".ui-button-text").html() ); 7830 7831 if ( !this.hasTitle ) { 7832 this.buttonElement.removeAttr( "title" ); 7833 } 7834 }, 7835 7836 _setOption: function( key, value ) { 7837 this._super( key, value ); 7838 if ( key === "disabled" ) { 7839 this.widget().toggleClass( "ui-state-disabled", !!value ); 7840 this.element.prop( "disabled", !!value ); 7841 if ( value ) { 7842 if ( this.type === "checkbox" || this.type === "radio" ) { 7843 this.buttonElement.removeClass( "ui-state-focus" ); 7844 } else { 7845 this.buttonElement.removeClass( "ui-state-focus ui-state-active" ); 7846 } 7847 } 7848 return; 7849 } 7850 this._resetButton(); 7851 }, 7852 7853 refresh: function() { 7854 //See #8237 & #8828 7855 var isDisabled = this.element.is( "input, button" ) ? this.element.is( ":disabled" ) : this.element.hasClass( "ui-button-disabled" ); 7856 7857 if ( isDisabled !== this.options.disabled ) { 7858 this._setOption( "disabled", isDisabled ); 7859 } 7860 if ( this.type === "radio" ) { 7861 radioGroup( this.element[0] ).each(function() { 7862 if ( $( this ).is( ":checked" ) ) { 7863 $( this ).button( "widget" ) 7864 .addClass( "ui-state-active" ) 7865 .attr( "aria-pressed", "true" ); 7866 } else { 7867 $( this ).button( "widget" ) 7868 .removeClass( "ui-state-active" ) 7869 .attr( "aria-pressed", "false" ); 7870 } 7871 }); 7872 } else if ( this.type === "checkbox" ) { 7873 if ( this.element.is( ":checked" ) ) { 7874 this.buttonElement 7875 .addClass( "ui-state-active" ) 7876 .attr( "aria-pressed", "true" ); 7877 } else { 7878 this.buttonElement 7879 .removeClass( "ui-state-active" ) 7880 .attr( "aria-pressed", "false" ); 7881 } 7882 } 7883 }, 7884 7885 _resetButton: function() { 7886 if ( this.type === "input" ) { 7887 if ( this.options.label ) { 7888 this.element.val( this.options.label ); 7889 } 7890 return; 7891 } 7892 var buttonElement = this.buttonElement.removeClass( typeClasses ), 7893 buttonText = $( "<span></span>", this.document[0] ) 7894 .addClass( "ui-button-text" ) 7895 .html( this.options.label ) 7896 .appendTo( buttonElement.empty() ) 7897 .text(), 7898 icons = this.options.icons, 7899 multipleIcons = icons.primary && icons.secondary,
vendor: 6,515 bytes, lines 7900-8070
7900 buttonClasses = []; 7901 7902 if ( icons.primary || icons.secondary ) { 7903 if ( this.options.text ) { 7904 buttonClasses.push( "ui-button-text-icon" + ( multipleIcons ? "s" : ( icons.primary ? "-primary" : "-secondary" ) ) ); 7905 } 7906 7907 if ( icons.primary ) { 7908 buttonElement.prepend( "<span class='ui-button-icon-primary ui-icon " + icons.primary + "'></span>" ); 7909 } 7910 7911 if ( icons.secondary ) { 7912 buttonElement.append( "<span class='ui-button-icon-secondary ui-icon " + icons.secondary + "'></span>" ); 7913 } 7914 7915 if ( !this.options.text ) { 7916 buttonClasses.push( multipleIcons ? "ui-button-icons-only" : "ui-button-icon-only" ); 7917 7918 if ( !this.hasTitle ) { 7919 buttonElement.attr( "title", $.trim( buttonText ) ); 7920 } 7921 } 7922 } else { 7923 buttonClasses.push( "ui-button-text-only" ); 7924 } 7925 buttonElement.addClass( buttonClasses.join( " " ) ); 7926 } 7927}); 7928 7929$.widget( "ui.buttonset", { 7930 version: "1.11.4", 7931 options: { 7932 items: "button, input[type=button], input[type=submit], input[type=reset], input[type=checkbox], input[type=radio], a, :data(ui-button)" 7933 }, 7934 7935 _create: function() { 7936 this.element.addClass( "ui-buttonset" ); 7937 }, 7938 7939 _init: function() { 7940 this.refresh(); 7941 }, 7942 7943 _setOption: function( key, value ) { 7944 if ( key === "disabled" ) { 7945 this.buttons.button( "option", key, value ); 7946 } 7947 7948 this._super( key, value ); 7949 }, 7950 7951 refresh: function() { 7952 var rtl = this.element.css( "direction" ) === "rtl", 7953 allButtons = this.element.find( this.options.items ), 7954 existingButtons = allButtons.filter( ":ui-button" ); 7955 7956 // Initialize new buttons 7957 allButtons.not( ":ui-button" ).button(); 7958 7959 // Refresh existing buttons 7960 existingButtons.button( "refresh" ); 7961 7962 this.buttons = allButtons 7963 .map(function() { 7964 return $( this ).button( "widget" )[ 0 ]; 7965 }) 7966 .removeClass( "ui-corner-all ui-corner-left ui-corner-right" ) 7967 .filter( ":first" ) 7968 .addClass( rtl ? "ui-corner-right" : "ui-corner-left" ) 7969 .end() 7970 .filter( ":last" ) 7971 .addClass( rtl ? "ui-corner-left" : "ui-corner-right" ) 7972 .end() 7973 .end(); 7974 }, 7975 7976 _destroy: function() { 7977 this.element.removeClass( "ui-buttonset" ); 7978 this.buttons 7979 .map(function() { 7980 return $( this ).button( "widget" )[ 0 ]; 7981 }) 7982 .removeClass( "ui-corner-left ui-corner-right" ) 7983 .end() 7984 .button( "destroy" ); 7985 } 7986}); 7987 7988var button = $.ui.button; 7989 7990 7991/*! 7992 * jQuery UI Datepicker 1.11.4 7993 * http://jqueryui.com 7994 * 7995 * Copyright jQuery Foundation and other contributors 7996 * Released under the MIT license. 7997 * http://jquery.org/license 7998 * 7999 * http://api.jqueryui.com/datepicker/ 8000 */ 8001 8002 8003$.extend($.ui, { datepicker: { version: "1.11.4" } }); 8004 8005var datepicker_instActive; 8006 8007function datepicker_getZindex( elem ) { 8008 var position, value; 8009 while ( elem.length && elem[ 0 ] !== document ) { 8010 // Ignore z-index if position is set to a value where z-index is ignored by the browser 8011 // This makes behavior of this function consistent across browsers 8012 // WebKit always returns auto if the element is positioned 8013 position = elem.css( "position" ); 8014 if ( position === "absolute" || position === "relative" || position === "fixed" ) { 8015 // IE returns 0 when zIndex is not specified 8016 // other browsers return a string 8017 // we ignore the case of nested elements with an explicit value of 0 8018 // <div style="z-index: -10;"><div style="z-index: 0;"></div></div> 8019 value = parseInt( elem.css( "zIndex" ), 10 ); 8020 if ( !isNaN( value ) && value !== 0 ) { 8021 return value; 8022 } 8023 } 8024 elem = elem.parent(); 8025 } 8026 8027 return 0; 8028} 8029/* Date picker manager. 8030 Use the singleton instance of this class, $.datepicker, to interact with the date picker. 8031 Settings for (groups of) date pickers are maintained in an instance object, 8032 allowing multiple different settings on the same page. */ 8033 8034function Datepicker() { 8035 this._curInst = null; // The current instance in use 8036 this._keyEvent = false; // If the last event was a key event 8037 this._disabledInputs = []; // List of date picker inputs that have been disabled 8038 this._datepickerShowing = false; // True if the popup picker is showing , false if not 8039 this._inDialog = false; // True if showing within a "dialog", false if not 8040 this._mainDivId = "ui-datepicker-div"; // The ID of the main datepicker division 8041 this._inlineClass = "ui-datepicker-inline"; // The name of the inline marker class 8042 this._appendClass = "ui-datepicker-append"; // The name of the append marker class 8043 this._triggerClass = "ui-datepicker-trigger"; // The name of the trigger marker class 8044 this._dialogClass = "ui-datepicker-dialog"; // The name of the dialog marker class 8045 this._disableClass = "ui-datepicker-disabled"; // The name of the disabled covering marker class 8046 this._unselectableClass = "ui-datepicker-unselectable"; // The name of the unselectable cell marker class 8047 this._currentClass = "ui-datepicker-current-day"; // The name of the current day marker class 8048 this._dayOverClass = "ui-datepicker-days-cell-over"; // The name of the day hover marker class 8049 this.regional = []; // Available regional settings, indexed by language code 8050 this.regional[""] = { // Default regional settings 8051 closeText: "Done", // Display text for close link 8052 prevText: "Prev", // Display text for previous month link 8053 nextText: "Next", // Display text for next month link 8054 currentText: "Today", // Display text for current month link 8055 monthNames: ["January","February","March","April","May","June", 8056 "July","August","September","October","November","December"], // Names of months for drop-down and formatting 8057 monthNamesShort: ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"], // For formatting 8058 dayNames: ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"], // For formatting 8059 dayNamesShort: ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"], // For formatting 8060 dayNamesMin: ["Su","Mo","Tu","We","Th","Fr","Sa"], // Column headings for days starting at Sunday 8061 weekHeader: "Wk", // Column header for week of the year 8062 dateFormat: "mm/dd/yy", // See format options on parseDate 8063 firstDay: 0, // The first day of the week, Sun = 0, Mon = 1, ... 8064 isRTL: false, // True if right-to-left language, false if left-to-right 8065 showMonthAfterYear: false, // True if the year select precedes month, false for month then year 8066 yearSuffix: "" // Additional text to append to the year in the month headers 8067 }; 8068 this._defaults = { // Global defaults for all the date picker instances 8069 showOn: "focus", // "focus" for popup on focus, 8070 // "button" for trigger button, or "both" for either
vendor: 19,263 bytes, lines 8071-8570
8071 showAnim: "fadeIn", // Name of jQuery animation for popup 8072 showOptions: {}, // Options for enhanced animations 8073 defaultDate: null, // Used when field is blank: actual date, 8074 // +/-number for offset from today, null for today 8075 appendText: "", // Display text following the input box, e.g. showing the format 8076 buttonText: "...", // Text for trigger button 8077 buttonImage: "", // URL for trigger button image 8078 buttonImageOnly: false, // True if the image appears alone, false if it appears on a button 8079 hideIfNoPrevNext: false, // True to hide next/previous month links 8080 // if not applicable, false to just disable them 8081 navigationAsDateFormat: false, // True if date formatting applied to prev/today/next links 8082 gotoCurrent: false, // True if today link goes back to current selection instead 8083 changeMonth: false, // True if month can be selected directly, false if only prev/next 8084 changeYear: false, // True if year can be selected directly, false if only prev/next 8085 yearRange: "c-10:c+10", // Range of years to display in drop-down, 8086 // either relative to today's year (-nn:+nn), relative to currently displayed year 8087 // (c-nn:c+nn), absolute (nnnn:nnnn), or a combination of the above (nnnn:-n) 8088 showOtherMonths: false, // True to show dates in other months, false to leave blank 8089 selectOtherMonths: false, // True to allow selection of dates in other months, false for unselectable 8090 showWeek: false, // True to show week of the year, false to not show it 8091 calculateWeek: this.iso8601Week, // How to calculate the week of the year, 8092 // takes a Date and returns the number of the week for it 8093 shortYearCutoff: "+10", // Short year values < this are in the current century, 8094 // > this are in the previous century, 8095 // string value starting with "+" for current year + value 8096 minDate: null, // The earliest selectable date, or null for no limit 8097 maxDate: null, // The latest selectable date, or null for no limit 8098 duration: "fast", // Duration of display/closure 8099 beforeShowDay: null, // Function that takes a date and returns an array with 8100 // [0] = true if selectable, false if not, [1] = custom CSS class name(s) or "", 8101 // [2] = cell title (optional), e.g. $.datepicker.noWeekends 8102 beforeShow: null, // Function that takes an input field and 8103 // returns a set of custom settings for the date picker 8104 onSelect: null, // Define a callback function when a date is selected 8105 onChangeMonthYear: null, // Define a callback function when the month or year is changed 8106 onClose: null, // Define a callback function when the datepicker is closed 8107 numberOfMonths: 1, // Number of months to show at a time 8108 showCurrentAtPos: 0, // The position in multipe months at which to show the current month (starting at 0) 8109 stepMonths: 1, // Number of months to step back/forward 8110 stepBigMonths: 12, // Number of months to step back/forward for the big links 8111 altField: "", // Selector for an alternate field to store selected dates into 8112 altFormat: "", // The date format to use for the alternate field 8113 constrainInput: true, // The input is constrained by the current date format 8114 showButtonPanel: false, // True to show button panel, false to not show it 8115 autoSize: false, // True to size the input for the date format, false to leave as is 8116 disabled: false // The initial disabled state 8117 }; 8118 $.extend(this._defaults, this.regional[""]); 8119 this.regional.en = $.extend( true, {}, this.regional[ "" ]); 8120 this.regional[ "en-US" ] = $.extend( true, {}, this.regional.en ); 8121 this.dpDiv = datepicker_bindHover($("<div id='" + this._mainDivId + "' class='ui-datepicker ui-widget ui-widget-content ui-helper-clearfix ui-corner-all'></div>")); 8122} 8123 8124$.extend(Datepicker.prototype, { 8125 /* Class name added to elements to indicate already configured with a date picker. */ 8126 markerClassName: "hasDatepicker", 8127 8128 //Keep track of the maximum number of rows displayed (see #7043) 8129 maxRows: 4, 8130 8131 // TODO rename to "widget" when switching to widget factory 8132 _widgetDatepicker: function() { 8133 return this.dpDiv; 8134 }, 8135 8136 /* Override the default settings for all instances of the date picker. 8137 * @param settings object - the new settings to use as defaults (anonymous object) 8138 * @return the manager object 8139 */ 8140 setDefaults: function(settings) { 8141 datepicker_extendRemove(this._defaults, settings || {}); 8142 return this; 8143 }, 8144 8145 /* Attach the date picker to a jQuery selection. 8146 * @param target element - the target input field or division or span 8147 * @param settings object - the new settings to use for this date picker instance (anonymous) 8148 */ 8149 _attachDatepicker: function(target, settings) { 8150 var nodeName, inline, inst; 8151 nodeName = target.nodeName.toLowerCase(); 8152 inline = (nodeName === "div" || nodeName === "span"); 8153 if (!target.id) { 8154 this.uuid += 1; 8155 target.id = "dp" + this.uuid; 8156 } 8157 inst = this._newInst($(target), inline); 8158 inst.settings = $.extend({}, settings || {}); 8159 if (nodeName === "input") { 8160 this._connectDatepicker(target, inst); 8161 } else if (inline) { 8162 this._inlineDatepicker(target, inst); 8163 } 8164 }, 8165 8166 /* Create a new instance object. */ 8167 _newInst: function(target, inline) { 8168 var id = target[0].id.replace(/([^A-Za-z0-9_\-])/g, "\\\\$1"); // escape jQuery meta chars 8169 return {id: id, input: target, // associated target 8170 selectedDay: 0, selectedMonth: 0, selectedYear: 0, // current selection 8171 drawMonth: 0, drawYear: 0, // month being drawn 8172 inline: inline, // is datepicker inline or not 8173 dpDiv: (!inline ? this.dpDiv : // presentation div 8174 datepicker_bindHover($("<div class='" + this._inlineClass + " ui-datepicker ui-widget ui-widget-content ui-helper-clearfix ui-corner-all'></div>")))}; 8175 }, 8176 8177 /* Attach the date picker to an input field. */ 8178 _connectDatepicker: function(target, inst) { 8179 var input = $(target); 8180 inst.append = $([]); 8181 inst.trigger = $([]); 8182 if (input.hasClass(this.markerClassName)) { 8183 return; 8184 } 8185 this._attachments(input, inst); 8186 input.addClass(this.markerClassName).keydown(this._doKeyDown). 8187 keypress(this._doKeyPress).keyup(this._doKeyUp); 8188 this._autoSize(inst); 8189 $.data(target, "datepicker", inst); 8190 //If disabled option is true, disable the datepicker once it has been attached to the input (see ticket #5665) 8191 if( inst.settings.disabled ) { 8192 this._disableDatepicker( target ); 8193 } 8194 }, 8195 8196 /* Make attachments based on settings. */ 8197 _attachments: function(input, inst) { 8198 var showOn, buttonText, buttonImage, 8199 appendText = this._get(inst, "appendText"), 8200 isRTL = this._get(inst, "isRTL"); 8201 8202 if (inst.append) { 8203 inst.append.remove(); 8204 } 8205 if (appendText) { 8206 inst.append = $("<span class='" + this._appendClass + "'>" + appendText + "</span>"); 8207 input[isRTL ? "before" : "after"](inst.append); 8208 } 8209 8210 input.unbind("focus", this._showDatepicker); 8211 8212 if (inst.trigger) { 8213 inst.trigger.remove(); 8214 } 8215 8216 showOn = this._get(inst, "showOn"); 8217 if (showOn === "focus" || showOn === "both") { // pop-up date picker when in the marked field 8218 input.focus(this._showDatepicker); 8219 } 8220 if (showOn === "button" || showOn === "both") { // pop-up date picker when button clicked 8221 buttonText = this._get(inst, "buttonText"); 8222 buttonImage = this._get(inst, "buttonImage"); 8223 inst.trigger = $(this._get(inst, "buttonImageOnly") ? 8224 $("<img/>").addClass(this._triggerClass). 8225 attr({ src: buttonImage, alt: buttonText, title: buttonText }) : 8226 $("<button type='button'></button>").addClass(this._triggerClass). 8227 html(!buttonImage ? buttonText : $("<img/>").attr( 8228 { src:buttonImage, alt:buttonText, title:buttonText }))); 8229 input[isRTL ? "before" : "after"](inst.trigger); 8230 inst.trigger.click(function() { 8231 if ($.datepicker._datepickerShowing && $.datepicker._lastInput === input[0]) { 8232 $.datepicker._hideDatepicker(); 8233 } else if ($.datepicker._datepickerShowing && $.datepicker._lastInput !== input[0]) { 8234 $.datepicker._hideDatepicker(); 8235 $.datepicker._showDatepicker(input[0]); 8236 } else { 8237 $.datepicker._showDatepicker(input[0]); 8238 } 8239 return false; 8240 }); 8241 } 8242 }, 8243 8244 /* Apply the maximum length for the date format. */ 8245 _autoSize: function(inst) { 8246 if (this._get(inst, "autoSize") && !inst.inline) { 8247 var findMax, max, maxI, i, 8248 date = new Date(2009, 12 - 1, 20), // Ensure double digits 8249 dateFormat = this._get(inst, "dateFormat"); 8250 8251 if (dateFormat.match(/[DM]/)) { 8252 findMax = function(names) { 8253 max = 0; 8254 maxI = 0; 8255 for (i = 0; i < names.length; i++) { 8256 if (names[i].length > max) { 8257 max = names[i].length; 8258 maxI = i; 8259 } 8260 } 8261 return maxI; 8262 }; 8263 date.setMonth(findMax(this._get(inst, (dateFormat.match(/MM/) ? 8264 "monthNames" : "monthNamesShort")))); 8265 date.setDate(findMax(this._get(inst, (dateFormat.match(/DD/) ? 8266 "dayNames" : "dayNamesShort"))) + 20 - date.getDay()); 8267 } 8268 inst.input.attr("size", this._formatDate(inst, date).length); 8269 } 8270 }, 8271 8272 /* Attach an inline date picker to a div. */ 8273 _inlineDatepicker: function(target, inst) { 8274 var divSpan = $(target); 8275 if (divSpan.hasClass(this.markerClassName)) { 8276 return; 8277 } 8278 divSpan.addClass(this.markerClassName).append(inst.dpDiv); 8279 $.data(target, "datepicker", inst); 8280 this._setDate(inst, this._getDefaultDate(inst), true); 8281 this._updateDatepicker(inst); 8282 this._updateAlternate(inst); 8283 //If disabled option is true, disable the datepicker before showing it (see ticket #5665) 8284 if( inst.settings.disabled ) { 8285 this._disableDatepicker( target ); 8286 } 8287 // Set display:block in place of inst.dpDiv.show() which won't work on disconnected elements 8288 // http://bugs.jqueryui.com/ticket/7552 - A Datepicker created on a detached div has zero height 8289 inst.dpDiv.css( "display", "block" ); 8290 }, 8291 8292 /* Pop-up the date picker in a "dialog" box. 8293 * @param input element - ignored 8294 * @param date string or Date - the initial date to display 8295 * @param onSelect function - the function to call when a date is selected 8296 * @param settings object - update the dialog date picker instance's settings (anonymous object) 8297 * @param pos int[2] - coordinates for the dialog's position within the screen or 8298 * event - with x/y coordinates or 8299 * leave empty for default (screen centre) 8300 * @return the manager object 8301 */ 8302 _dialogDatepicker: function(input, date, onSelect, settings, pos) { 8303 var id, browserWidth, browserHeight, scrollX, scrollY, 8304 inst = this._dialogInst; // internal instance 8305 8306 if (!inst) { 8307 this.uuid += 1; 8308 id = "dp" + this.uuid; 8309 this._dialogInput = $("<input type='text' id='" + id + 8310 "' style='position: absolute; top: -100px; width: 0px;'/>"); 8311 this._dialogInput.keydown(this._doKeyDown); 8312 $("body").append(this._dialogInput); 8313 inst = this._dialogInst = this._newInst(this._dialogInput, false); 8314 inst.settings = {}; 8315 $.data(this._dialogInput[0], "datepicker", inst); 8316 } 8317 datepicker_extendRemove(inst.settings, settings || {}); 8318 date = (date && date.constructor === Date ? this._formatDate(inst, date) : date); 8319 this._dialogInput.val(date); 8320 8321 this._pos = (pos ? (pos.length ? pos : [pos.pageX, pos.pageY]) : null); 8322 if (!this._pos) { 8323 browserWidth = document.documentElement.clientWidth; 8324 browserHeight = document.documentElement.clientHeight; 8325 scrollX = document.documentElement.scrollLeft || document.body.scrollLeft; 8326 scrollY = document.documentElement.scrollTop || document.body.scrollTop; 8327 this._pos = // should use actual width/height below 8328 [(browserWidth / 2) - 100 + scrollX, (browserHeight / 2) - 150 + scrollY]; 8329 } 8330 8331 // move input on screen for focus, but hidden behind dialog 8332 this._dialogInput.css("left", (this._pos[0] + 20) + "px").css("top", this._pos[1] + "px"); 8333 inst.settings.onSelect = onSelect; 8334 this._inDialog = true; 8335 this.dpDiv.addClass(this._dialogClass); 8336 this._showDatepicker(this._dialogInput[0]); 8337 if ($.blockUI) { 8338 $.blockUI(this.dpDiv); 8339 } 8340 $.data(this._dialogInput[0], "datepicker", inst); 8341 return this; 8342 }, 8343 8344 /* Detach a datepicker from its control. 8345 * @param target element - the target input field or division or span 8346 */ 8347 _destroyDatepicker: function(target) { 8348 var nodeName, 8349 $target = $(target), 8350 inst = $.data(target, "datepicker"); 8351 8352 if (!$target.hasClass(this.markerClassName)) { 8353 return; 8354 } 8355 8356 nodeName = target.nodeName.toLowerCase(); 8357 $.removeData(target, "datepicker"); 8358 if (nodeName === "input") { 8359 inst.append.remove(); 8360 inst.trigger.remove(); 8361 $target.removeClass(this.markerClassName). 8362 unbind("focus", this._showDatepicker). 8363 unbind("keydown", this._doKeyDown). 8364 unbind("keypress", this._doKeyPress). 8365 unbind("keyup", this._doKeyUp); 8366 } else if (nodeName === "div" || nodeName === "span") { 8367 $target.removeClass(this.markerClassName).empty(); 8368 } 8369 8370 if ( datepicker_instActive === inst ) { 8371 datepicker_instActive = null; 8372 } 8373 }, 8374 8375 /* Enable the date picker to a jQuery selection. 8376 * @param target element - the target input field or division or span 8377 */ 8378 _enableDatepicker: function(target) { 8379 var nodeName, inline, 8380 $target = $(target), 8381 inst = $.data(target, "datepicker"); 8382 8383 if (!$target.hasClass(this.markerClassName)) { 8384 return; 8385 } 8386 8387 nodeName = target.nodeName.toLowerCase(); 8388 if (nodeName === "input") { 8389 target.disabled = false; 8390 inst.trigger.filter("button"). 8391 each(function() { this.disabled = false; }).end(). 8392 filter("img").css({opacity: "1.0", cursor: ""}); 8393 } else if (nodeName === "div" || nodeName === "span") { 8394 inline = $target.children("." + this._inlineClass); 8395 inline.children().removeClass("ui-state-disabled"); 8396 inline.find("select.ui-datepicker-month, select.ui-datepicker-year"). 8397 prop("disabled", false); 8398 } 8399 this._disabledInputs = $.map(this._disabledInputs, 8400 function(value) { return (value === target ? null : value); }); // delete entry 8401 }, 8402 8403 /* Disable the date picker to a jQuery selection. 8404 * @param target element - the target input field or division or span 8405 */ 8406 _disableDatepicker: function(target) { 8407 var nodeName, inline, 8408 $target = $(target), 8409 inst = $.data(target, "datepicker"); 8410 8411 if (!$target.hasClass(this.markerClassName)) { 8412 return; 8413 } 8414 8415 nodeName = target.nodeName.toLowerCase(); 8416 if (nodeName === "input") { 8417 target.disabled = true; 8418 inst.trigger.filter("button"). 8419 each(function() { this.disabled = true; }).end(). 8420 filter("img").css({opacity: "0.5", cursor: "default"}); 8421 } else if (nodeName === "div" || nodeName === "span") { 8422 inline = $target.children("." + this._inlineClass); 8423 inline.children().addClass("ui-state-disabled"); 8424 inline.find("select.ui-datepicker-month, select.ui-datepicker-year"). 8425 prop("disabled", true); 8426 } 8427 this._disabledInputs = $.map(this._disabledInputs, 8428 function(value) { return (value === target ? null : value); }); // delete entry 8429 this._disabledInputs[this._disabledInputs.length] = target; 8430 }, 8431 8432 /* Is the first field in a jQuery collection disabled as a datepicker? 8433 * @param target element - the target input field or division or span 8434 * @return boolean - true if disabled, false if enabled 8435 */ 8436 _isDisabledDatepicker: function(target) { 8437 if (!target) { 8438 return false; 8439 } 8440 for (var i = 0; i < this._disabledInputs.length; i++) { 8441 if (this._disabledInputs[i] === target) { 8442 return true; 8443 } 8444 } 8445 return false; 8446 }, 8447 8448 /* Retrieve the instance data for the target control. 8449 * @param target element - the target input field or division or span 8450 * @return object - the associated instance data 8451 * @throws error if a jQuery problem getting data 8452 */ 8453 _getInst: function(target) { 8454 try { 8455 return $.data(target, "datepicker"); 8456 } 8457 catch (err) { 8458 throw "Missing instance data for this datepicker"; 8459 } 8460 }, 8461 8462 /* Update or retrieve the settings for a date picker attached to an input field or division. 8463 * @param target element - the target input field or division or span 8464 * @param name object - the new settings to update or 8465 * string - the name of the setting to change or retrieve, 8466 * when retrieving also "all" for all instance settings or 8467 * "defaults" for all global defaults 8468 * @param value any - the new value for the setting 8469 * (omit if above is an object or to retrieve a value) 8470 */ 8471 _optionDatepicker: function(target, name, value) { 8472 var settings, date, minDate, maxDate, 8473 inst = this._getInst(target); 8474 8475 if (arguments.length === 2 && typeof name === "string") { 8476 return (name === "defaults" ? $.extend({}, $.datepicker._defaults) : 8477 (inst ? (name === "all" ? $.extend({}, inst.settings) : 8478 this._get(inst, name)) : null)); 8479 } 8480 8481 settings = name || {}; 8482 if (typeof name === "string") { 8483 settings = {}; 8484 settings[name] = value; 8485 } 8486 8487 if (inst) { 8488 if (this._curInst === inst) { 8489 this._hideDatepicker(); 8490 } 8491 8492 date = this._getDateDatepicker(target, true); 8493 minDate = this._getMinMaxDate(inst, "min"); 8494 maxDate = this._getMinMaxDate(inst, "max"); 8495 datepicker_extendRemove(inst.settings, settings); 8496 // reformat the old minDate/maxDate values if dateFormat changes and a new minDate/maxDate isn't provided 8497 if (minDate !== null && settings.dateFormat !== undefined && settings.minDate === undefined) { 8498 inst.settings.minDate = this._formatDate(inst, minDate); 8499 } 8500 if (maxDate !== null && settings.dateFormat !== undefined && settings.maxDate === undefined) { 8501 inst.settings.maxDate = this._formatDate(inst, maxDate); 8502 } 8503 if ( "disabled" in settings ) { 8504 if ( settings.disabled ) { 8505 this._disableDatepicker(target); 8506 } else { 8507 this._enableDatepicker(target); 8508 } 8509 } 8510 this._attachments($(target), inst); 8511 this._autoSize(inst); 8512 this._setDate(inst, date); 8513 this._updateAlternate(inst); 8514 this._updateDatepicker(inst); 8515 } 8516 }, 8517 8518 // change method deprecated 8519 _changeDatepicker: function(target, name, value) { 8520 this._optionDatepicker(target, name, value); 8521 }, 8522 8523 /* Redraw the date picker attached to an input field or division. 8524 * @param target element - the target input field or division or span 8525 */ 8526 _refreshDatepicker: function(target) { 8527 var inst = this._getInst(target); 8528 if (inst) { 8529 this._updateDatepicker(inst); 8530 } 8531 }, 8532 8533 /* Set the dates for a jQuery selection. 8534 * @param target element - the target input field or division or span 8535 * @param date Date - the new date 8536 */ 8537 _setDateDatepicker: function(target, date) { 8538 var inst = this._getInst(target); 8539 if (inst) { 8540 this._setDate(inst, date); 8541 this._updateDatepicker(inst); 8542 this._updateAlternate(inst); 8543 } 8544 }, 8545 8546 /* Get the date(s) for the first entry in a jQuery selection. 8547 * @param target element - the target input field or division or span 8548 * @param noDefault boolean - true if no default date is to be used 8549 * @return Date - the current date 8550 */ 8551 _getDateDatepicker: function(target, noDefault) { 8552 var inst = this._getInst(target); 8553 if (inst && !inst.inline) { 8554 this._setDateFromField(inst, noDefault); 8555 } 8556 return (inst ? this._getDate(inst) : null); 8557 }, 8558 8559 /* Handle keystrokes. */ 8560 _doKeyDown: function(event) { 8561 var onSelect, dateStr, sel, 8562 inst = $.datepicker._getInst(event.target), 8563 handled = true, 8564 isRTL = inst.dpDiv.is(".ui-datepicker-rtl"); 8565 8566 inst._keyEvent = true; 8567 if ($.datepicker._datepickerShowing) { 8568 switch (event.keyCode) { 8569 case 9: $.datepicker._hideDatepicker(); 8570 handled = false;
vendor: 4,495 bytes, lines 8571-8694
8571 break; // hide on tab out 8572 case 13: sel = $("td." + $.datepicker._dayOverClass + ":not(." + 8573 $.datepicker._currentClass + ")", inst.dpDiv); 8574 if (sel[0]) { 8575 $.datepicker._selectDay(event.target, inst.selectedMonth, inst.selectedYear, sel[0]); 8576 } 8577 8578 onSelect = $.datepicker._get(inst, "onSelect"); 8579 if (onSelect) { 8580 dateStr = $.datepicker._formatDate(inst); 8581 8582 // trigger custom callback 8583 onSelect.apply((inst.input ? inst.input[0] : null), [dateStr, inst]); 8584 } else { 8585 $.datepicker._hideDatepicker(); 8586 } 8587 8588 return false; // don't submit the form 8589 case 27: $.datepicker._hideDatepicker(); 8590 break; // hide on escape 8591 case 33: $.datepicker._adjustDate(event.target, (event.ctrlKey ? 8592 -$.datepicker._get(inst, "stepBigMonths") : 8593 -$.datepicker._get(inst, "stepMonths")), "M"); 8594 break; // previous month/year on page up/+ ctrl 8595 case 34: $.datepicker._adjustDate(event.target, (event.ctrlKey ? 8596 +$.datepicker._get(inst, "stepBigMonths") : 8597 +$.datepicker._get(inst, "stepMonths")), "M"); 8598 break; // next month/year on page down/+ ctrl 8599 case 35: if (event.ctrlKey || event.metaKey) { 8600 $.datepicker._clearDate(event.target); 8601 } 8602 handled = event.ctrlKey || event.metaKey; 8603 break; // clear on ctrl or command +end 8604 case 36: if (event.ctrlKey || event.metaKey) { 8605 $.datepicker._gotoToday(event.target); 8606 } 8607 handled = event.ctrlKey || event.metaKey; 8608 break; // current on ctrl or command +home 8609 case 37: if (event.ctrlKey || event.metaKey) { 8610 $.datepicker._adjustDate(event.target, (isRTL ? +1 : -1), "D"); 8611 } 8612 handled = event.ctrlKey || event.metaKey; 8613 // -1 day on ctrl or command +left 8614 if (event.originalEvent.altKey) { 8615 $.datepicker._adjustDate(event.target, (event.ctrlKey ? 8616 -$.datepicker._get(inst, "stepBigMonths") : 8617 -$.datepicker._get(inst, "stepMonths")), "M"); 8618 } 8619 // next month/year on alt +left on Mac 8620 break; 8621 case 38: if (event.ctrlKey || event.metaKey) { 8622 $.datepicker._adjustDate(event.target, -7, "D"); 8623 } 8624 handled = event.ctrlKey || event.metaKey; 8625 break; // -1 week on ctrl or command +up 8626 case 39: if (event.ctrlKey || event.metaKey) { 8627 $.datepicker._adjustDate(event.target, (isRTL ? -1 : +1), "D"); 8628 } 8629 handled = event.ctrlKey || event.metaKey; 8630 // +1 day on ctrl or command +right 8631 if (event.originalEvent.altKey) { 8632 $.datepicker._adjustDate(event.target, (event.ctrlKey ? 8633 +$.datepicker._get(inst, "stepBigMonths") : 8634 +$.datepicker._get(inst, "stepMonths")), "M"); 8635 } 8636 // next month/year on alt +right 8637 break; 8638 case 40: if (event.ctrlKey || event.metaKey) { 8639 $.datepicker._adjustDate(event.target, +7, "D"); 8640 } 8641 handled = event.ctrlKey || event.metaKey; 8642 break; // +1 week on ctrl or command +down 8643 default: handled = false; 8644 } 8645 } else if (event.keyCode === 36 && event.ctrlKey) { // display the date picker on ctrl+home 8646 $.datepicker._showDatepicker(this); 8647 } else { 8648 handled = false; 8649 } 8650 8651 if (handled) { 8652 event.preventDefault(); 8653 event.stopPropagation(); 8654 } 8655 }, 8656 8657 /* Filter entered characters - based on date format. */ 8658 _doKeyPress: function(event) { 8659 var chars, chr, 8660 inst = $.datepicker._getInst(event.target); 8661 8662 if ($.datepicker._get(inst, "constrainInput")) { 8663 chars = $.datepicker._possibleChars($.datepicker._get(inst, "dateFormat")); 8664 chr = String.fromCharCode(event.charCode == null ? event.keyCode : event.charCode); 8665 return event.ctrlKey || event.metaKey || (chr < " " || !chars || chars.indexOf(chr) > -1); 8666 } 8667 }, 8668 8669 /* Synchronise manual entry and field/alternate field. */ 8670 _doKeyUp: function(event) { 8671 var date, 8672 inst = $.datepicker._getInst(event.target); 8673 8674 if (inst.input.val() !== inst.lastVal) { 8675 try { 8676 date = $.datepicker.parseDate($.datepicker._get(inst, "dateFormat"), 8677 (inst.input ? inst.input.val() : null), 8678 $.datepicker._getFormatConfig(inst)); 8679 8680 if (date) { // only if valid 8681 $.datepicker._setDateFromField(inst); 8682 $.datepicker._updateAlternate(inst); 8683 $.datepicker._updateDatepicker(inst); 8684 } 8685 } 8686 catch (err) { 8687 } 8688 } 8689 return true; 8690 }, 8691 8692 /* Pop-up the date picker for a given input field. 8693 * If false returned from beforeShow event handler do not show. 8694 * @param input element - the input field attached to the date picker or
vendor: 9,398 bytes, lines 8695-8969
8695 * event - if triggered by focus 8696 */ 8697 _showDatepicker: function(input) { 8698 input = input.target || input; 8699 if (input.nodeName.toLowerCase() !== "input") { // find from button/image trigger 8700 input = $("input", input.parentNode)[0]; 8701 } 8702 8703 if ($.datepicker._isDisabledDatepicker(input) || $.datepicker._lastInput === input) { // already here 8704 return; 8705 } 8706 8707 var inst, beforeShow, beforeShowSettings, isFixed, 8708 offset, showAnim, duration; 8709 8710 inst = $.datepicker._getInst(input); 8711 if ($.datepicker._curInst && $.datepicker._curInst !== inst) { 8712 $.datepicker._curInst.dpDiv.stop(true, true); 8713 if ( inst && $.datepicker._datepickerShowing ) { 8714 $.datepicker._hideDatepicker( $.datepicker._curInst.input[0] ); 8715 } 8716 } 8717 8718 beforeShow = $.datepicker._get(inst, "beforeShow"); 8719 beforeShowSettings = beforeShow ? beforeShow.apply(input, [input, inst]) : {}; 8720 if(beforeShowSettings === false){ 8721 return; 8722 } 8723 datepicker_extendRemove(inst.settings, beforeShowSettings); 8724 8725 inst.lastVal = null; 8726 $.datepicker._lastInput = input; 8727 $.datepicker._setDateFromField(inst); 8728 8729 if ($.datepicker._inDialog) { // hide cursor 8730 input.value = ""; 8731 } 8732 if (!$.datepicker._pos) { // position below input 8733 $.datepicker._pos = $.datepicker._findPos(input); 8734 $.datepicker._pos[1] += input.offsetHeight; // add the height 8735 } 8736 8737 isFixed = false; 8738 $(input).parents().each(function() { 8739 isFixed |= $(this).css("position") === "fixed"; 8740 return !isFixed; 8741 }); 8742 8743 offset = {left: $.datepicker._pos[0], top: $.datepicker._pos[1]}; 8744 $.datepicker._pos = null; 8745 //to avoid flashes on Firefox 8746 inst.dpDiv.empty(); 8747 // determine sizing offscreen 8748 inst.dpDiv.css({position: "absolute", display: "block", top: "-1000px"}); 8749 $.datepicker._updateDatepicker(inst); 8750 // fix width for dynamic number of date pickers 8751 // and adjust position before showing 8752 offset = $.datepicker._checkOffset(inst, offset, isFixed); 8753 inst.dpDiv.css({position: ($.datepicker._inDialog && $.blockUI ? 8754 "static" : (isFixed ? "fixed" : "absolute")), display: "none", 8755 left: offset.left + "px", top: offset.top + "px"}); 8756 8757 if (!inst.inline) { 8758 showAnim = $.datepicker._get(inst, "showAnim"); 8759 duration = $.datepicker._get(inst, "duration"); 8760 inst.dpDiv.css( "z-index", datepicker_getZindex( $( input ) ) + 1 ); 8761 $.datepicker._datepickerShowing = true; 8762 8763 if ( $.effects && $.effects.effect[ showAnim ] ) { 8764 inst.dpDiv.show(showAnim, $.datepicker._get(inst, "showOptions"), duration); 8765 } else { 8766 inst.dpDiv[showAnim || "show"](showAnim ? duration : null); 8767 } 8768 8769 if ( $.datepicker._shouldFocusInput( inst ) ) { 8770 inst.input.focus(); 8771 } 8772 8773 $.datepicker._curInst = inst; 8774 } 8775 }, 8776 8777 /* Generate the date picker content. */ 8778 _updateDatepicker: function(inst) { 8779 this.maxRows = 4; //Reset the max number of rows being displayed (see #7043) 8780 datepicker_instActive = inst; // for delegate hover events 8781 inst.dpDiv.empty().append(this._generateHTML(inst)); 8782 this._attachHandlers(inst); 8783 8784 var origyearshtml, 8785 numMonths = this._getNumberOfMonths(inst), 8786 cols = numMonths[1], 8787 width = 17, 8788 activeCell = inst.dpDiv.find( "." + this._dayOverClass + " a" ); 8789 8790 if ( activeCell.length > 0 ) { 8791 datepicker_handleMouseover.apply( activeCell.get( 0 ) ); 8792 } 8793 8794 inst.dpDiv.removeClass("ui-datepicker-multi-2 ui-datepicker-multi-3 ui-datepicker-multi-4").width(""); 8795 if (cols > 1) { 8796 inst.dpDiv.addClass("ui-datepicker-multi-" + cols).css("width", (width * cols) + "em"); 8797 } 8798 inst.dpDiv[(numMonths[0] !== 1 || numMonths[1] !== 1 ? "add" : "remove") + 8799 "Class"]("ui-datepicker-multi"); 8800 inst.dpDiv[(this._get(inst, "isRTL") ? "add" : "remove") + 8801 "Class"]("ui-datepicker-rtl"); 8802 8803 if (inst === $.datepicker._curInst && $.datepicker._datepickerShowing && $.datepicker._shouldFocusInput( inst ) ) { 8804 inst.input.focus(); 8805 } 8806 8807 // deffered render of the years select (to avoid flashes on Firefox) 8808 if( inst.yearshtml ){ 8809 origyearshtml = inst.yearshtml; 8810 setTimeout(function(){ 8811 //assure that inst.yearshtml didn't change. 8812 if( origyearshtml === inst.yearshtml && inst.yearshtml ){ 8813 inst.dpDiv.find("select.ui-datepicker-year:first").replaceWith(inst.yearshtml); 8814 } 8815 origyearshtml = inst.yearshtml = null; 8816 }, 0); 8817 } 8818 }, 8819 8820 // #6694 - don't focus the input if it's already focused 8821 // this breaks the change event in IE 8822 // Support: IE and jQuery <1.9 8823 _shouldFocusInput: function( inst ) { 8824 return inst.input && inst.input.is( ":visible" ) && !inst.input.is( ":disabled" ) && !inst.input.is( ":focus" ); 8825 }, 8826 8827 /* Check positioning to remain on screen. */ 8828 _checkOffset: function(inst, offset, isFixed) { 8829 var dpWidth = inst.dpDiv.outerWidth(), 8830 dpHeight = inst.dpDiv.outerHeight(), 8831 inputWidth = inst.input ? inst.input.outerWidth() : 0, 8832 inputHeight = inst.input ? inst.input.outerHeight() : 0, 8833 viewWidth = document.documentElement.clientWidth + (isFixed ? 0 : $(document).scrollLeft()), 8834 viewHeight = document.documentElement.clientHeight + (isFixed ? 0 : $(document).scrollTop()); 8835 8836 offset.left -= (this._get(inst, "isRTL") ? (dpWidth - inputWidth) : 0); 8837 offset.left -= (isFixed && offset.left === inst.input.offset().left) ? $(document).scrollLeft() : 0; 8838 offset.top -= (isFixed && offset.top === (inst.input.offset().top + inputHeight)) ? $(document).scrollTop() : 0; 8839 8840 // now check if datepicker is showing outside window viewport - move to a better place if so. 8841 offset.left -= Math.min(offset.left, (offset.left + dpWidth > viewWidth && viewWidth > dpWidth) ? 8842 Math.abs(offset.left + dpWidth - viewWidth) : 0); 8843 offset.top -= Math.min(offset.top, (offset.top + dpHeight > viewHeight && viewHeight > dpHeight) ? 8844 Math.abs(dpHeight + inputHeight) : 0); 8845 8846 return offset; 8847 }, 8848 8849 /* Find an object's position on the screen. */ 8850 _findPos: function(obj) { 8851 var position, 8852 inst = this._getInst(obj), 8853 isRTL = this._get(inst, "isRTL"); 8854 8855 while (obj && (obj.type === "hidden" || obj.nodeType !== 1 || $.expr.filters.hidden(obj))) { 8856 obj = obj[isRTL ? "previousSibling" : "nextSibling"]; 8857 } 8858 8859 position = $(obj).offset(); 8860 return [position.left, position.top]; 8861 }, 8862 8863 /* Hide the date picker from view. 8864 * @param input element - the input field attached to the date picker 8865 */ 8866 _hideDatepicker: function(input) { 8867 var showAnim, duration, postProcess, onClose, 8868 inst = this._curInst; 8869 8870 if (!inst || (input && inst !== $.data(input, "datepicker"))) { 8871 return; 8872 } 8873 8874 if (this._datepickerShowing) { 8875 showAnim = this._get(inst, "showAnim"); 8876 duration = this._get(inst, "duration"); 8877 postProcess = function() { 8878 $.datepicker._tidyDialog(inst); 8879 }; 8880 8881 // DEPRECATED: after BC for 1.8.x $.effects[ showAnim ] is not needed 8882 if ( $.effects && ( $.effects.effect[ showAnim ] || $.effects[ showAnim ] ) ) { 8883 inst.dpDiv.hide(showAnim, $.datepicker._get(inst, "showOptions"), duration, postProcess); 8884 } else { 8885 inst.dpDiv[(showAnim === "slideDown" ? "slideUp" : 8886 (showAnim === "fadeIn" ? "fadeOut" : "hide"))]((showAnim ? duration : null), postProcess); 8887 } 8888 8889 if (!showAnim) { 8890 postProcess(); 8891 } 8892 this._datepickerShowing = false; 8893 8894 onClose = this._get(inst, "onClose"); 8895 if (onClose) { 8896 onClose.apply((inst.input ? inst.input[0] : null), [(inst.input ? inst.input.val() : ""), inst]); 8897 } 8898 8899 this._lastInput = null; 8900 if (this._inDialog) { 8901 this._dialogInput.css({ position: "absolute", left: "0", top: "-100px" }); 8902 if ($.blockUI) { 8903 $.unblockUI(); 8904 $("body").append(this.dpDiv); 8905 } 8906 } 8907 this._inDialog = false; 8908 } 8909 }, 8910 8911 /* Tidy up after a dialog display. */ 8912 _tidyDialog: function(inst) { 8913 inst.dpDiv.removeClass(this._dialogClass).unbind(".ui-datepicker-calendar"); 8914 }, 8915 8916 /* Close date picker if clicked elsewhere. */ 8917 _checkExternalClick: function(event) { 8918 if (!$.datepicker._curInst) { 8919 return; 8920 } 8921 8922 var $target = $(event.target), 8923 inst = $.datepicker._getInst($target[0]); 8924 8925 if ( ( ( $target[0].id !== $.datepicker._mainDivId && 8926 $target.parents("#" + $.datepicker._mainDivId).length === 0 && 8927 !$target.hasClass($.datepicker.markerClassName) && 8928 !$target.closest("." + $.datepicker._triggerClass).length && 8929 $.datepicker._datepickerShowing && !($.datepicker._inDialog && $.blockUI) ) ) || 8930 ( $target.hasClass($.datepicker.markerClassName) && $.datepicker._curInst !== inst ) ) { 8931 $.datepicker._hideDatepicker(); 8932 } 8933 }, 8934 8935 /* Adjust one of the date sub-fields. */ 8936 _adjustDate: function(id, offset, period) { 8937 var target = $(id), 8938 inst = this._getInst(target[0]); 8939 8940 if (this._isDisabledDatepicker(target[0])) { 8941 return; 8942 } 8943 this._adjustInstDate(inst, offset + 8944 (period === "M" ? this._get(inst, "showCurrentAtPos") : 0), // undo positioning 8945 period); 8946 this._updateDatepicker(inst); 8947 }, 8948 8949 /* Action for current link. */ 8950 _gotoToday: function(id) { 8951 var date, 8952 target = $(id), 8953 inst = this._getInst(target[0]); 8954 8955 if (this._get(inst, "gotoCurrent") && inst.currentDay) { 8956 inst.selectedDay = inst.currentDay; 8957 inst.drawMonth = inst.selectedMonth = inst.currentMonth; 8958 inst.drawYear = inst.selectedYear = inst.currentYear; 8959 } else { 8960 date = new Date(); 8961 inst.selectedDay = date.getDate(); 8962 inst.drawMonth = inst.selectedMonth = date.getMonth(); 8963 inst.drawYear = inst.selectedYear = date.getFullYear(); 8964 } 8965 this._notifyChange(inst); 8966 this._adjustDate(target); 8967 }, 8968 8969 /* Action for selecting a new month/year. */
vendor: 4,436 bytes, lines 8970-9101
8970 _selectMonthYear: function(id, select, period) { 8971 var target = $(id), 8972 inst = this._getInst(target[0]); 8973 8974 inst["selected" + (period === "M" ? "Month" : "Year")] = 8975 inst["draw" + (period === "M" ? "Month" : "Year")] = 8976 parseInt(select.options[select.selectedIndex].value,10); 8977 8978 this._notifyChange(inst); 8979 this._adjustDate(target); 8980 }, 8981 8982 /* Action for selecting a day. */ 8983 _selectDay: function(id, month, year, td) { 8984 var inst, 8985 target = $(id); 8986 8987 if ($(td).hasClass(this._unselectableClass) || this._isDisabledDatepicker(target[0])) { 8988 return; 8989 } 8990 8991 inst = this._getInst(target[0]); 8992 inst.selectedDay = inst.currentDay = $("a", td).html(); 8993 inst.selectedMonth = inst.currentMonth = month; 8994 inst.selectedYear = inst.currentYear = year; 8995 this._selectDate(id, this._formatDate(inst, 8996 inst.currentDay, inst.currentMonth, inst.currentYear)); 8997 }, 8998 8999 /* Erase the input field and hide the date picker. */ 9000 _clearDate: function(id) { 9001 var target = $(id); 9002 this._selectDate(target, ""); 9003 }, 9004 9005 /* Update the input field with the selected date. */ 9006 _selectDate: function(id, dateStr) { 9007 var onSelect, 9008 target = $(id), 9009 inst = this._getInst(target[0]); 9010 9011 dateStr = (dateStr != null ? dateStr : this._formatDate(inst)); 9012 if (inst.input) { 9013 inst.input.val(dateStr); 9014 } 9015 this._updateAlternate(inst); 9016 9017 onSelect = this._get(inst, "onSelect"); 9018 if (onSelect) { 9019 onSelect.apply((inst.input ? inst.input[0] : null), [dateStr, inst]); // trigger custom callback 9020 } else if (inst.input) { 9021 inst.input.trigger("change"); // fire the change event 9022 } 9023 9024 if (inst.inline){ 9025 this._updateDatepicker(inst); 9026 } else { 9027 this._hideDatepicker(); 9028 this._lastInput = inst.input[0]; 9029 if (typeof(inst.input[0]) !== "object") { 9030 inst.input.focus(); // restore focus 9031 } 9032 this._lastInput = null; 9033 } 9034 }, 9035 9036 /* Update any alternate field to synchronise with the main field. */ 9037 _updateAlternate: function(inst) { 9038 var altFormat, date, dateStr, 9039 altField = this._get(inst, "altField"); 9040 9041 if (altField) { // update alternate field too 9042 altFormat = this._get(inst, "altFormat") || this._get(inst, "dateFormat"); 9043 date = this._getDate(inst); 9044 dateStr = this.formatDate(altFormat, date, this._getFormatConfig(inst)); 9045 $(altField).each(function() { $(this).val(dateStr); }); 9046 } 9047 }, 9048 9049 /* Set as beforeShowDay function to prevent selection of weekends. 9050 * @param date Date - the date to customise 9051 * @return [boolean, string] - is this date selectable?, what is its CSS class? 9052 */ 9053 noWeekends: function(date) { 9054 var day = date.getDay(); 9055 return [(day > 0 && day < 6), ""]; 9056 }, 9057 9058 /* Set as calculateWeek to determine the week of the year based on the ISO 8601 definition. 9059 * @param date Date - the date to get the week for 9060 * @return number - the number of the week within the year that contains this date 9061 */ 9062 iso8601Week: function(date) { 9063 var time, 9064 checkDate = new Date(date.getTime()); 9065 9066 // Find Thursday of this week starting on Monday 9067 checkDate.setDate(checkDate.getDate() + 4 - (checkDate.getDay() || 7)); 9068 9069 time = checkDate.getTime(); 9070 checkDate.setMonth(0); // Compare with Jan 1 9071 checkDate.setDate(1); 9072 return Math.floor(Math.round((time - checkDate) / 86400000) / 7) + 1; 9073 }, 9074 9075 /* Parse a string value into a date object. 9076 * See formatDate below for the possible formats. 9077 * 9078 * @param format string - the expected format of the date 9079 * @param value string - the date in the above format 9080 * @param settings Object - attributes include: 9081 * shortYearCutoff number - the cutoff year for determining the century (optional) 9082 * dayNamesShort string[7] - abbreviated names of the days from Sunday (optional) 9083 * dayNames string[7] - names of the days from Sunday (optional) 9084 * monthNamesShort string[12] - abbreviated names of the months (optional) 9085 * monthNames string[12] - names of the months (optional) 9086 * @return Date - the extracted date value or null if value is blank 9087 */ 9088 parseDate: function (format, value, settings) { 9089 if (format == null || value == null) { 9090 throw "Invalid arguments"; 9091 } 9092 9093 value = (typeof value === "object" ? value.toString() : value + ""); 9094 if (value === "") { 9095 return null; 9096 } 9097 9098 var iFormat, dim, extra, 9099 iValue = 0, 9100 shortYearCutoffTemp = (settings ? settings.shortYearCutoff : null) || this._defaults.shortYearCutoff, 9101 shortYearCutoff = (typeof shortYearCutoffTemp !== "string" ? shortYearCutoffTemp
vendor: 5,261 bytes, lines 9101-9287
9101: 9102 new Date().getFullYear() % 100 + parseInt(shortYearCutoffTemp, 10)), 9103 dayNamesShort = (settings ? settings.dayNamesShort : null) || this._defaults.dayNamesShort, 9104 dayNames = (settings ? settings.dayNames : null) || this._defaults.dayNames, 9105 monthNamesShort = (settings ? settings.monthNamesShort : null) || this._defaults.monthNamesShort, 9106 monthNames = (settings ? settings.monthNames : null) || this._defaults.monthNames, 9107 year = -1, 9108 month = -1, 9109 day = -1, 9110 doy = -1, 9111 literal = false, 9112 date, 9113 // Check whether a format character is doubled 9114 lookAhead = function(match) { 9115 var matches = (iFormat + 1 < format.length && format.charAt(iFormat + 1) === match); 9116 if (matches) { 9117 iFormat++; 9118 } 9119 return matches; 9120 }, 9121 // Extract a number from the string value 9122 getNumber = function(match) { 9123 var isDoubled = lookAhead(match), 9124 size = (match === "@" ? 14 : (match === "!" ? 20 : 9125 (match === "y" && isDoubled ? 4 : (match === "o" ? 3 : 2)))), 9126 minSize = (match === "y" ? size : 1), 9127 digits = new RegExp("^\\d{" + minSize + "," + size + "}"), 9128 num = value.substring(iValue).match(digits); 9129 if (!num) { 9130 throw "Missing number at position " + iValue; 9131 } 9132 iValue += num[0].length; 9133 return parseInt(num[0], 10); 9134 }, 9135 // Extract a name from the string value and convert to an index 9136 getName = function(match, shortNames, longNames) { 9137 var index = -1, 9138 names = $.map(lookAhead(match) ? longNames : shortNames, function (v, k) { 9139 return [ [k, v] ]; 9140 }).sort(function (a, b) { 9141 return -(a[1].length - b[1].length); 9142 }); 9143 9144 $.each(names, function (i, pair) { 9145 var name = pair[1]; 9146 if (value.substr(iValue, name.length).toLowerCase() === name.toLowerCase()) { 9147 index = pair[0]; 9148 iValue += name.length; 9149 return false; 9150 } 9151 }); 9152 if (index !== -1) { 9153 return index + 1; 9154 } else { 9155 throw "Unknown name at position " + iValue; 9156 } 9157 }, 9158 // Confirm that a literal character matches the string value 9159 checkLiteral = function() { 9160 if (value.charAt(iValue) !== format.charAt(iFormat)) { 9161 throw "Unexpected literal at position " + iValue; 9162 } 9163 iValue++; 9164 }; 9165 9166 for (iFormat = 0; iFormat < format.length; iFormat++) { 9167 if (literal) { 9168 if (format.charAt(iFormat) === "'" && !lookAhead("'")) { 9169 literal = false; 9170 } else { 9171 checkLiteral(); 9172 } 9173 } else { 9174 switch (format.charAt(iFormat)) { 9175 case "d": 9176 day = getNumber("d"); 9177 break; 9178 case "D": 9179 getName("D", dayNamesShort, dayNames); 9180 break; 9181 case "o": 9182 doy = getNumber("o"); 9183 break; 9184 case "m": 9185 month = getNumber("m"); 9186 break; 9187 case "M": 9188 month = getName("M", monthNamesShort, monthNames); 9189 break; 9190 case "y": 9191 year = getNumber("y"); 9192 break; 9193 case "@": 9194 date = new Date(getNumber("@")); 9195 year = date.getFullYear(); 9196 month = date.getMonth() + 1; 9197 day = date.getDate(); 9198 break; 9199 case "!": 9200 date = new Date((getNumber("!") - this._ticksTo1970) / 10000); 9201 year = date.getFullYear(); 9202 month = date.getMonth() + 1; 9203 day = date.getDate(); 9204 break; 9205 case "'": 9206 if (lookAhead("'")){ 9207 checkLiteral(); 9208 } else { 9209 literal = true; 9210 } 9211 break; 9212 default: 9213 checkLiteral(); 9214 } 9215 } 9216 } 9217 9218 if (iValue < value.length){ 9219 extra = value.substr(iValue); 9220 if (!/^\s+/.test(extra)) { 9221 throw "Extra/unparsed characters found in date: " + extra; 9222 } 9223 } 9224 9225 if (year === -1) { 9226 year = new Date().getFullYear(); 9227 } else if (year < 100) { 9228 year += new Date().getFullYear() - new Date().getFullYear() % 100 + 9229 (year <= shortYearCutoff ? 0 : -100); 9230 } 9231 9232 if (doy > -1) { 9233 month = 1; 9234 day = doy; 9235 do { 9236 dim = this._getDaysInMonth(year, month - 1); 9237 if (day <= dim) { 9238 break; 9239 } 9240 month++; 9241 day -= dim; 9242 } while (true); 9243 } 9244 9245 date = this._daylightSavingAdjust(new Date(year, month - 1, day)); 9246 if (date.getFullYear() !== year || date.getMonth() + 1 !== month || date.getDate() !== day) { 9247 throw "Invalid date"; // E.g. 31/02/00 9248 } 9249 return date; 9250 }, 9251 9252 /* Standard date formats. */ 9253 ATOM: "yy-mm-dd", // RFC 3339 (ISO 8601) 9254 COOKIE: "D, dd M yy", 9255 ISO_8601: "yy-mm-dd", 9256 RFC_822: "D, d M y", 9257 RFC_850: "DD, dd-M-y", 9258 RFC_1036: "D, d M y", 9259 RFC_1123: "D, d M yy", 9260 RFC_2822: "D, d M yy", 9261 RSS: "D, d M y", // RFC 822 9262 TICKS: "!", 9263 TIMESTAMP: "@", 9264 W3C: "yy-mm-dd", // ISO 8601 9265 9266 _ticksTo1970: (((1970 - 1) * 365 + Math.floor(1970 / 4) - Math.floor(1970 / 100) + 9267 Math.floor(1970 / 400)) * 24 * 60 * 60 * 10000000), 9268 9269 /* Format a date object into a string value. 9270 * The format can be combinations of the following: 9271 * d - day of month (no leading zero) 9272 * dd - day of month (two digit) 9273 * o - day of year (no leading zeros) 9274 * oo - day of year (three digit) 9275 * D - day name short 9276 * DD - day name long 9277 * m - month of year (no leading zero) 9278 * mm - month of year (two digit) 9279 * M - month name short 9280 * MM - month name long 9281 * y - year (two digit) 9282 * yy - year (four digit) 9283 * @ - Unix timestamp (ms since 01/01/1970) 9284 * ! - Windows ticks (100ns since 01/01/0001) 9285 * "..." - literal text 9286 * '' - single quote 9287 *
vendor: 11,157 bytes, lines 9288-9621
9288 * @param format string - the desired format of the date 9289 * @param date Date - the date value to format 9290 * @param settings Object - attributes include: 9291 * dayNamesShort string[7] - abbreviated names of the days from Sunday (optional) 9292 * dayNames string[7] - names of the days from Sunday (optional) 9293 * monthNamesShort string[12] - abbreviated names of the months (optional) 9294 * monthNames string[12] - names of the months (optional) 9295 * @return string - the date in the above format 9296 */ 9297 formatDate: function (format, date, settings) { 9298 if (!date) { 9299 return ""; 9300 } 9301 9302 var iFormat, 9303 dayNamesShort = (settings ? settings.dayNamesShort : null) || this._defaults.dayNamesShort, 9304 dayNames = (settings ? settings.dayNames : null) || this._defaults.dayNames, 9305 monthNamesShort = (settings ? settings.monthNamesShort : null) || this._defaults.monthNamesShort, 9306 monthNames = (settings ? settings.monthNames : null) || this._defaults.monthNames, 9307 // Check whether a format character is doubled 9308 lookAhead = function(match) { 9309 var matches = (iFormat + 1 < format.length && format.charAt(iFormat + 1) === match); 9310 if (matches) { 9311 iFormat++; 9312 } 9313 return matches; 9314 }, 9315 // Format a number, with leading zero if necessary 9316 formatNumber = function(match, value, len) { 9317 var num = "" + value; 9318 if (lookAhead(match)) { 9319 while (num.length < len) { 9320 num = "0" + num; 9321 } 9322 } 9323 return num; 9324 }, 9325 // Format a name, short or long as requested 9326 formatName = function(match, value, shortNames, longNames) { 9327 return (lookAhead(match) ? longNames[value] : shortNames[value]); 9328 }, 9329 output = "", 9330 literal = false; 9331 9332 if (date) { 9333 for (iFormat = 0; iFormat < format.length; iFormat++) { 9334 if (literal) { 9335 if (format.charAt(iFormat) === "'" && !lookAhead("'")) { 9336 literal = false; 9337 } else { 9338 output += format.charAt(iFormat); 9339 } 9340 } else { 9341 switch (format.charAt(iFormat)) { 9342 case "d": 9343 output += formatNumber("d", date.getDate(), 2); 9344 break; 9345 case "D": 9346 output += formatName("D", date.getDay(), dayNamesShort, dayNames); 9347 break; 9348 case "o": 9349 output += formatNumber("o", 9350 Math.round((new Date(date.getFullYear(), date.getMonth(), date.getDate()).getTime() - new Date(date.getFullYear(), 0, 0).getTime()) / 86400000), 3); 9351 break; 9352 case "m": 9353 output += formatNumber("m", date.getMonth() + 1, 2); 9354 break; 9355 case "M": 9356 output += formatName("M", date.getMonth(), monthNamesShort, monthNames); 9357 break; 9358 case "y": 9359 output += (lookAhead("y") ? date.getFullYear() : 9360 (date.getYear() % 100 < 10 ? "0" : "") + date.getYear() % 100); 9361 break; 9362 case "@": 9363 output += date.getTime(); 9364 break; 9365 case "!": 9366 output += date.getTime() * 10000 + this._ticksTo1970; 9367 break; 9368 case "'": 9369 if (lookAhead("'")) { 9370 output += "'"; 9371 } else { 9372 literal = true; 9373 } 9374 break; 9375 default: 9376 output += format.charAt(iFormat); 9377 } 9378 } 9379 } 9380 } 9381 return output; 9382 }, 9383 9384 /* Extract all possible characters from the date format. */ 9385 _possibleChars: function (format) { 9386 var iFormat, 9387 chars = "", 9388 literal = false, 9389 // Check whether a format character is doubled 9390 lookAhead = function(match) { 9391 var matches = (iFormat + 1 < format.length && format.charAt(iFormat + 1) === match); 9392 if (matches) { 9393 iFormat++; 9394 } 9395 return matches; 9396 }; 9397 9398 for (iFormat = 0; iFormat < format.length; iFormat++) { 9399 if (literal) { 9400 if (format.charAt(iFormat) === "'" && !lookAhead("'")) { 9401 literal = false; 9402 } else { 9403 chars += format.charAt(iFormat); 9404 } 9405 } else { 9406 switch (format.charAt(iFormat)) { 9407 case "d": case "m": case "y": case "@": 9408 chars += "0123456789"; 9409 break; 9410 case "D": case "M": 9411 return null; // Accept anything 9412 case "'": 9413 if (lookAhead("'")) { 9414 chars += "'"; 9415 } else { 9416 literal = true; 9417 } 9418 break; 9419 default: 9420 chars += format.charAt(iFormat); 9421 } 9422 } 9423 } 9424 return chars; 9425 }, 9426 9427 /* Get a setting value, defaulting if necessary. */ 9428 _get: function(inst, name) { 9429 return inst.settings[name] !== undefined ? 9430 inst.settings[name] : this._defaults[name]; 9431 }, 9432 9433 /* Parse existing date and initialise date picker. */ 9434 _setDateFromField: function(inst, noDefault) { 9435 if (inst.input.val() === inst.lastVal) { 9436 return; 9437 } 9438 9439 var dateFormat = this._get(inst, "dateFormat"), 9440 dates = inst.lastVal = inst.input ? inst.input.val() : null, 9441 defaultDate = this._getDefaultDate(inst), 9442 date = defaultDate, 9443 settings = this._getFormatConfig(inst); 9444 9445 try { 9446 date = this.parseDate(dateFormat, dates, settings) || defaultDate; 9447 } catch (event) { 9448 dates = (noDefault ? "" : dates); 9449 } 9450 inst.selectedDay = date.getDate(); 9451 inst.drawMonth = inst.selectedMonth = date.getMonth(); 9452 inst.drawYear = inst.selectedYear = date.getFullYear(); 9453 inst.currentDay = (dates ? date.getDate() : 0); 9454 inst.currentMonth = (dates ? date.getMonth() : 0); 9455 inst.currentYear = (dates ? date.getFullYear() : 0); 9456 this._adjustInstDate(inst); 9457 }, 9458 9459 /* Retrieve the default date shown on opening. */ 9460 _getDefaultDate: function(inst) { 9461 return this._restrictMinMax(inst, 9462 this._determineDate(inst, this._get(inst, "defaultDate"), new Date())); 9463 }, 9464 9465 /* A date may be specified as an exact value or a relative one. */ 9466 _determineDate: function(inst, date, defaultDate) { 9467 var offsetNumeric = function(offset) { 9468 var date = new Date(); 9469 date.setDate(date.getDate() + offset); 9470 return date; 9471 }, 9472 offsetString = function(offset) { 9473 try { 9474 return $.datepicker.parseDate($.datepicker._get(inst, "dateFormat"), 9475 offset, $.datepicker._getFormatConfig(inst)); 9476 } 9477 catch (e) { 9478 // Ignore 9479 } 9480 9481 var date = (offset.toLowerCase().match(/^c/) ? 9482 $.datepicker._getDate(inst) : null) || new Date(), 9483 year = date.getFullYear(), 9484 month = date.getMonth(), 9485 day = date.getDate(), 9486 pattern = /([+\-]?[0-9]+)\s*(d|D|w|W|m|M|y|Y)?/g, 9487 matches = pattern.exec(offset); 9488 9489 while (matches) { 9490 switch (matches[2] || "d") { 9491 case "d" : case "D" : 9492 day += parseInt(matches[1],10); break; 9493 case "w" : case "W" : 9494 day += parseInt(matches[1],10) * 7; break; 9495 case "m" : case "M" : 9496 month += parseInt(matches[1],10); 9497 day = Math.min(day, $.datepicker._getDaysInMonth(year, month)); 9498 break; 9499 case "y": case "Y" : 9500 year += parseInt(matches[1],10); 9501 day = Math.min(day, $.datepicker._getDaysInMonth(year, month)); 9502 break; 9503 } 9504 matches = pattern.exec(offset); 9505 } 9506 return new Date(year, month, day); 9507 }, 9508 newDate = (date == null || date === "" ? defaultDate : (typeof date === "string" ? offsetString(date) : 9509 (typeof date === "number" ? (isNaN(date) ? defaultDate : offsetNumeric(date)) : new Date(date.getTime())))); 9510 9511 newDate = (newDate && newDate.toString() === "Invalid Date" ? defaultDate : newDate); 9512 if (newDate) { 9513 newDate.setHours(0); 9514 newDate.setMinutes(0); 9515 newDate.setSeconds(0); 9516 newDate.setMilliseconds(0); 9517 } 9518 return this._daylightSavingAdjust(newDate); 9519 }, 9520 9521 /* Handle switch to/from daylight saving. 9522 * Hours may be non-zero on daylight saving cut-over: 9523 * > 12 when midnight changeover, but then cannot generate 9524 * midnight datetime, so jump to 1AM, otherwise reset. 9525 * @param date (Date) the date to check 9526 * @return (Date) the corrected date 9527 */ 9528 _daylightSavingAdjust: function(date) { 9529 if (!date) { 9530 return null; 9531 } 9532 date.setHours(date.getHours() > 12 ? date.getHours() + 2 : 0); 9533 return date; 9534 }, 9535 9536 /* Set the date(s) directly. */ 9537 _setDate: function(inst, date, noChange) { 9538 var clear = !date, 9539 origMonth = inst.selectedMonth, 9540 origYear = inst.selectedYear, 9541 newDate = this._restrictMinMax(inst, this._determineDate(inst, date, new Date())); 9542 9543 inst.selectedDay = inst.currentDay = newDate.getDate(); 9544 inst.drawMonth = inst.selectedMonth = inst.currentMonth = newDate.getMonth(); 9545 inst.drawYear = inst.selectedYear = inst.currentYear = newDate.getFullYear(); 9546 if ((origMonth !== inst.selectedMonth || origYear !== inst.selectedYear) && !noChange) { 9547 this._notifyChange(inst); 9548 } 9549 this._adjustInstDate(inst); 9550 if (inst.input) { 9551 inst.input.val(clear ? "" : this._formatDate(inst)); 9552 } 9553 }, 9554 9555 /* Retrieve the date(s) directly. */ 9556 _getDate: function(inst) { 9557 var startDate = (!inst.currentYear || (inst.input && inst.input.val() === "") ? null : 9558 this._daylightSavingAdjust(new Date( 9559 inst.currentYear, inst.currentMonth, inst.currentDay))); 9560 return startDate; 9561 }, 9562 9563 /* Attach the onxxx handlers. These are declared statically so 9564 * they work with static code transformers like Caja. 9565 */ 9566 _attachHandlers: function(inst) { 9567 var stepMonths = this._get(inst, "stepMonths"), 9568 id = "#" + inst.id.replace( /\\\\/g, "\\" ); 9569 inst.dpDiv.find("[data-handler]").map(function () { 9570 var handler = { 9571 prev: function () { 9572 $.datepicker._adjustDate(id, -stepMonths, "M"); 9573 }, 9574 next: function () { 9575 $.datepicker._adjustDate(id, +stepMonths, "M"); 9576 }, 9577 hide: function () { 9578 $.datepicker._hideDatepicker(); 9579 }, 9580 today: function () { 9581 $.datepicker._gotoToday(id); 9582 }, 9583 selectDay: function () { 9584 $.datepicker._selectDay(id, +this.getAttribute("data-month"), +this.getAttribute("data-year"), this); 9585 return false; 9586 }, 9587 selectMonth: function () { 9588 $.datepicker._selectMonthYear(id, this, "M"); 9589 return false; 9590 }, 9591 selectYear: function () { 9592 $.datepicker._selectMonthYear(id, this, "Y"); 9593 return false; 9594 } 9595 }; 9596 $(this).bind(this.getAttribute("data-event"), handler[this.getAttribute("data-handler")]); 9597 }); 9598 }, 9599 9600 /* Generate the HTML for the current state of the date picker. */ 9601 _generateHTML: function(inst) { 9602 var maxDraw, prevText, prev, nextText, next, currentText, gotoDate, 9603 controls, buttonPanel, firstDay, showWeek, dayNames, dayNamesMin, 9604 monthNames, monthNamesShort, beforeShowDay, showOtherMonths, 9605 selectOtherMonths, defaultDate, html, dow, row, group, col, selectedDate, 9606 cornerClass, calender, thead, day, daysInMonth, leadDays, curRows, numRows, 9607 printDate, dRow, tbody, daySettings, otherMonth, unselectable, 9608 tempDate = new Date(), 9609 today = this._daylightSavingAdjust( 9610 new Date(tempDate.getFullYear(), tempDate.getMonth(), tempDate.getDate())), // clear time 9611 isRTL = this._get(inst, "isRTL"), 9612 showButtonPanel = this._get(inst, "showButtonPanel"), 9613 hideIfNoPrevNext = this._get(inst, "hideIfNoPrevNext"), 9614 navigationAsDateFormat = this._get(inst, "navigationAsDateFormat"), 9615 numMonths = this._getNumberOfMonths(inst), 9616 showCurrentAtPos = this._get(inst, "showCurrentAtPos"), 9617 stepMonths = this._get(inst, "stepMonths"), 9618 isMultiMonth = (numMonths[0] !== 1 || numMonths[1] !== 1), 9619 currentDate = this._daylightSavingAdjust((!inst.currentDay ? new Date(9999, 9, 9) : 9620 new Date(inst.currentYear, inst.currentMonth, inst.currentDay))), 9621 minDate = this._getMinMaxDate(inst, "min"),
vendor: 9,139 bytes, lines 9622-9780
9622 maxDate = this._getMinMaxDate(inst, "max"), 9623 drawMonth = inst.drawMonth - showCurrentAtPos, 9624 drawYear = inst.drawYear; 9625 9626 if (drawMonth < 0) { 9627 drawMonth += 12; 9628 drawYear--; 9629 } 9630 if (maxDate) { 9631 maxDraw = this._daylightSavingAdjust(new Date(maxDate.getFullYear(), 9632 maxDate.getMonth() - (numMonths[0] * numMonths[1]) + 1, maxDate.getDate())); 9633 maxDraw = (minDate && maxDraw < minDate ? minDate : maxDraw); 9634 while (this._daylightSavingAdjust(new Date(drawYear, drawMonth, 1)) > maxDraw) { 9635 drawMonth--; 9636 if (drawMonth < 0) { 9637 drawMonth = 11; 9638 drawYear--; 9639 } 9640 } 9641 } 9642 inst.drawMonth = drawMonth; 9643 inst.drawYear = drawYear; 9644 9645 prevText = this._get(inst, "prevText"); 9646 prevText = (!navigationAsDateFormat ? prevText : this.formatDate(prevText, 9647 this._daylightSavingAdjust(new Date(drawYear, drawMonth - stepMonths, 1)), 9648 this._getFormatConfig(inst))); 9649 9650 prev = (this._canAdjustMonth(inst, -1, drawYear, drawMonth) ? 9651 "<a class='ui-datepicker-prev ui-corner-all' data-handler='prev' data-event='click'" + 9652 " title='" + prevText + "'><span class='ui-icon ui-icon-circle-triangle-" + ( isRTL ? "e" : "w") + "'>" + prevText + "</span></a>" : 9653 (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>")); 9654 9655 nextText = this._get(inst, "nextText"); 9656 nextText = (!navigationAsDateFormat ? nextText : this.formatDate(nextText, 9657 this._daylightSavingAdjust(new Date(drawYear, drawMonth + stepMonths, 1)), 9658 this._getFormatConfig(inst))); 9659 9660 next = (this._canAdjustMonth(inst, +1, drawYear, drawMonth) ? 9661 "<a class='ui-datepicker-next ui-corner-all' data-handler='next' data-event='click'" + 9662 " title='" + nextText + "'><span class='ui-icon ui-icon-circle-triangle-" + ( isRTL ? "w" : "e") + "'>" + nextText + "</span></a>" : 9663 (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>")); 9664 9665 currentText = this._get(inst, "currentText"); 9666 gotoDate = (this._get(inst, "gotoCurrent") && inst.currentDay ? currentDate : today); 9667 currentText = (!navigationAsDateFormat ? currentText : 9668 this.formatDate(currentText, gotoDate, this._getFormatConfig(inst))); 9669 9670 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'>" + 9671 this._get(inst, "closeText") + "</button>" : ""); 9672 9673 buttonPanel = (showButtonPanel) ? "<div class='ui-datepicker-buttonpane ui-widget-content'>" + (isRTL ? controls : "") + 9674 (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'" + 9675 ">" + currentText + "</button>" : "") + (isRTL ? "" : controls) + "</div>" : ""; 9676 9677 firstDay = parseInt(this._get(inst, "firstDay"),10); 9678 firstDay = (isNaN(firstDay) ? 0 : firstDay); 9679 9680 showWeek = this._get(inst, "showWeek"); 9681 dayNames = this._get(inst, "dayNames"); 9682 dayNamesMin = this._get(inst, "dayNamesMin"); 9683 monthNames = this._get(inst, "monthNames"); 9684 monthNamesShort = this._get(inst, "monthNamesShort"); 9685 beforeShowDay = this._get(inst, "beforeShowDay"); 9686 showOtherMonths = this._get(inst, "showOtherMonths"); 9687 selectOtherMonths = this._get(inst, "selectOtherMonths"); 9688 defaultDate = this._getDefaultDate(inst); 9689 html = ""; 9690 dow; 9691 for (row = 0; row < numMonths[0]; row++) { 9692 group = ""; 9693 this.maxRows = 4; 9694 for (col = 0; col < numMonths[1]; col++) { 9695 selectedDate = this._daylightSavingAdjust(new Date(drawYear, drawMonth, inst.selectedDay)); 9696 cornerClass = " ui-corner-all"; 9697 calender = ""; 9698 if (isMultiMonth) { 9699 calender += "<div class='ui-datepicker-group"; 9700 if (numMonths[1] > 1) { 9701 switch (col) { 9702 case 0: calender += " ui-datepicker-group-first"; 9703 cornerClass = " ui-corner-" + (isRTL ? "right" : "left"); break; 9704 case numMonths[1]-1: calender += " ui-datepicker-group-last"; 9705 cornerClass = " ui-corner-" + (isRTL ? "left" : "right"); break; 9706 default: calender += " ui-datepicker-group-middle"; cornerClass = ""; break; 9707 } 9708 } 9709 calender += "'>"; 9710 } 9711 calender += "<div class='ui-datepicker-header ui-widget-header ui-helper-clearfix" + cornerClass + "'>" + 9712 (/all|left/.test(cornerClass) && row === 0 ? (isRTL ? next : prev) : "") + 9713 (/all|right/.test(cornerClass) && row === 0 ? (isRTL ? prev : next) : "") + 9714 this._generateMonthYearHeader(inst, drawMonth, drawYear, minDate, maxDate, 9715 row > 0 || col > 0, monthNames, monthNamesShort) + // draw month headers 9716 "</div><table class='ui-datepicker-calendar'><thead>" + 9717 "<tr>"; 9718 thead = (showWeek ? "<th class='ui-datepicker-week-col'>" + this._get(inst, "weekHeader") + "</th>" : ""); 9719 for (dow = 0; dow < 7; dow++) { // days of the week 9720 day = (dow + firstDay) % 7; 9721 thead += "<th scope='col'" + ((dow + firstDay + 6) % 7 >= 5 ? " class='ui-datepicker-week-end'" : "") + ">" + 9722 "<span title='" + dayNames[day] + "'>" + dayNamesMin[day] + "</span></th>"; 9723 } 9724 calender += thead + "</tr></thead><tbody>"; 9725 daysInMonth = this._getDaysInMonth(drawYear, drawMonth); 9726 if (drawYear === inst.selectedYear && drawMonth === inst.selectedMonth) { 9727 inst.selectedDay = Math.min(inst.selectedDay, daysInMonth); 9728 } 9729 leadDays = (this._getFirstDayOfMonth(drawYear, drawMonth) - firstDay + 7) % 7; 9730 curRows = Math.ceil((leadDays + daysInMonth) / 7); // calculate the number of rows to generate 9731 numRows = (isMultiMonth ? this.maxRows > curRows ? this.maxRows : curRows : curRows); //If multiple months, use the higher number of rows (see #7043) 9732 this.maxRows = numRows; 9733 printDate = this._daylightSavingAdjust(new Date(drawYear, drawMonth, 1 - leadDays)); 9734 for (dRow = 0; dRow < numRows; dRow++) { // create date picker rows 9735 calender += "<tr>"; 9736 tbody = (!showWeek ? "" : "<td class='ui-datepicker-week-col'>" + 9737 this._get(inst, "calculateWeek")(printDate) + "</td>"); 9738 for (dow = 0; dow < 7; dow++) { // create date picker days 9739 daySettings = (beforeShowDay ? 9740 beforeShowDay.apply((inst.input ? inst.input[0] : null), [printDate]) : [true, ""]); 9741 otherMonth = (printDate.getMonth() !== drawMonth); 9742 unselectable = (otherMonth && !selectOtherMonths) || !daySettings[0] || 9743 (minDate && printDate < minDate) || (maxDate && printDate > maxDate); 9744 tbody += "<td class='" + 9745 ((dow + firstDay + 6) % 7 >= 5 ? " ui-datepicker-week-end" : "") + // highlight weekends 9746 (otherMonth ? " ui-datepicker-other-month" : "") + // highlight days from other months 9747 ((printDate.getTime() === selectedDate.getTime() && drawMonth === inst.selectedMonth && inst._keyEvent) || // user pressed key 9748 (defaultDate.getTime() === printDate.getTime() && defaultDate.getTime() === selectedDate.getTime()) ? 9749 // or defaultDate is current printedDate and defaultDate is selectedDate 9750 " " + this._dayOverClass : "") + // highlight selected day 9751 (unselectable ? " " + this._unselectableClass + " ui-state-disabled": "") + // highlight unselectable days 9752 (otherMonth && !showOtherMonths ? "" : " " + daySettings[1] + // highlight custom dates 9753 (printDate.getTime() === currentDate.getTime() ? " " + this._currentClass : "") + // highlight selected day 9754 (printDate.getTime() === today.getTime() ? " ui-datepicker-today" : "")) + "'" + // highlight today (if different) 9755 ((!otherMonth || showOtherMonths) && daySettings[2] ? " title='" + daySettings[2].replace(/'/g, "'") + "'" : "") + // cell title 9756 (unselectable ? "" : " data-handler='selectDay' data-event='click' data-month='" + printDate.getMonth() + "' data-year='" + printDate.getFullYear() + "'") + ">" + // actions 9757 (otherMonth && !showOtherMonths ? " " : // display for other months 9758 (unselectable ? "<span class='ui-state-default'>" + printDate.getDate() + "</span>" : "<a class='ui-state-default" + 9759 (printDate.getTime() === today.getTime() ? " ui-state-highlight" : "") + 9760 (printDate.getTime() === currentDate.getTime() ? " ui-state-active" : "") + // highlight selected day 9761 (otherMonth ? " ui-priority-secondary" : "") + // distinguish dates from other months 9762 "' href='#'>" + printDate.getDate() + "</a>")) + "</td>"; // display selectable date 9763 printDate.setDate(printDate.getDate() + 1); 9764 printDate = this._daylightSavingAdjust(printDate); 9765 } 9766 calender += tbody + "</tr>"; 9767 } 9768 drawMonth++; 9769 if (drawMonth > 11) { 9770 drawMonth = 0; 9771 drawYear++; 9772 } 9773 calender += "</tbody></table>" + (isMultiMonth ? "</div>" + 9774 ((numMonths[0] > 0 && col === numMonths[1]-1) ? "<div class='ui-datepicker-row-break'></div>" : "") : ""); 9775 group += calender; 9776 } 9777 html += group; 9778 } 9779 html += buttonPanel; 9780 inst._keyEvent = false;
vendor: 5,431 bytes, lines 9781-9924
9781 return html; 9782 }, 9783 9784 /* Generate the month and year header. */ 9785 _generateMonthYearHeader: function(inst, drawMonth, drawYear, minDate, maxDate, 9786 secondary, monthNames, monthNamesShort) { 9787 9788 var inMinYear, inMaxYear, month, years, thisYear, determineYear, year, endYear, 9789 changeMonth = this._get(inst, "changeMonth"), 9790 changeYear = this._get(inst, "changeYear"), 9791 showMonthAfterYear = this._get(inst, "showMonthAfterYear"), 9792 html = "<div class='ui-datepicker-title'>", 9793 monthHtml = ""; 9794 9795 // month selection 9796 if (secondary || !changeMonth) { 9797 monthHtml += "<span class='ui-datepicker-month'>" + monthNames[drawMonth] + "</span>"; 9798 } else { 9799 inMinYear = (minDate && minDate.getFullYear() === drawYear); 9800 inMaxYear = (maxDate && maxDate.getFullYear() === drawYear); 9801 monthHtml += "<select class='ui-datepicker-month' data-handler='selectMonth' data-event='change'>"; 9802 for ( month = 0; month < 12; month++) { 9803 if ((!inMinYear || month >= minDate.getMonth()) && (!inMaxYear || month <= maxDate.getMonth())) { 9804 monthHtml += "<option value='" + month + "'" + 9805 (month === drawMonth ? " selected='selected'" : "") + 9806 ">" + monthNamesShort[month] + "</option>"; 9807 } 9808 } 9809 monthHtml += "</select>"; 9810 } 9811 9812 if (!showMonthAfterYear) { 9813 html += monthHtml + (secondary || !(changeMonth && changeYear) ? " " : ""); 9814 } 9815 9816 // year selection 9817 if ( !inst.yearshtml ) { 9818 inst.yearshtml = ""; 9819 if (secondary || !changeYear) { 9820 html += "<span class='ui-datepicker-year'>" + drawYear + "</span>"; 9821 } else { 9822 // determine range of years to display 9823 years = this._get(inst, "yearRange").split(":"); 9824 thisYear = new Date().getFullYear(); 9825 determineYear = function(value) { 9826 var year = (value.match(/c[+\-].*/) ? drawYear + parseInt(value.substring(1), 10) : 9827 (value.match(/[+\-].*/) ? thisYear + parseInt(value, 10) : 9828 parseInt(value, 10))); 9829 return (isNaN(year) ? thisYear : year); 9830 }; 9831 year = determineYear(years[0]); 9832 endYear = Math.max(year, determineYear(years[1] || "")); 9833 year = (minDate ? Math.max(year, minDate.getFullYear()) : year); 9834 endYear = (maxDate ? Math.min(endYear, maxDate.getFullYear()) : endYear); 9835 inst.yearshtml += "<select class='ui-datepicker-year' data-handler='selectYear' data-event='change'>"; 9836 for (; year <= endYear; year++) { 9837 inst.yearshtml += "<option value='" + year + "'" + 9838 (year === drawYear ? " selected='selected'" : "") + 9839 ">" + year + "</option>"; 9840 } 9841 inst.yearshtml += "</select>"; 9842 9843 html += inst.yearshtml; 9844 inst.yearshtml = null; 9845 } 9846 } 9847 9848 html += this._get(inst, "yearSuffix"); 9849 if (showMonthAfterYear) { 9850 html += (secondary || !(changeMonth && changeYear) ? " " : "") + monthHtml; 9851 } 9852 html += "</div>"; // Close datepicker_header 9853 return html; 9854 }, 9855 9856 /* Adjust one of the date sub-fields. */ 9857 _adjustInstDate: function(inst, offset, period) { 9858 var year = inst.drawYear + (period === "Y" ? offset : 0), 9859 month = inst.drawMonth + (period === "M" ? offset : 0), 9860 day = Math.min(inst.selectedDay, this._getDaysInMonth(year, month)) + (period === "D" ? offset : 0), 9861 date = this._restrictMinMax(inst, this._daylightSavingAdjust(new Date(year, month, day))); 9862 9863 inst.selectedDay = date.getDate(); 9864 inst.drawMonth = inst.selectedMonth = date.getMonth(); 9865 inst.drawYear = inst.selectedYear = date.getFullYear(); 9866 if (period === "M" || period === "Y") { 9867 this._notifyChange(inst); 9868 } 9869 }, 9870 9871 /* Ensure a date is within any min/max bounds. */ 9872 _restrictMinMax: function(inst, date) { 9873 var minDate = this._getMinMaxDate(inst, "min"), 9874 maxDate = this._getMinMaxDate(inst, "max"), 9875 newDate = (minDate && date < minDate ? minDate : date); 9876 return (maxDate && newDate > maxDate ? maxDate : newDate); 9877 }, 9878 9879 /* Notify change of month/year. */ 9880 _notifyChange: function(inst) { 9881 var onChange = this._get(inst, "onChangeMonthYear"); 9882 if (onChange) { 9883 onChange.apply((inst.input ? inst.input[0] : null), 9884 [inst.selectedYear, inst.selectedMonth + 1, inst]); 9885 } 9886 }, 9887 9888 /* Determine the number of months to show. */ 9889 _getNumberOfMonths: function(inst) { 9890 var numMonths = this._get(inst, "numberOfMonths"); 9891 return (numMonths == null ? [1, 1] : (typeof numMonths === "number" ? [1, numMonths] : numMonths)); 9892 }, 9893 9894 /* Determine the current maximum date - ensure no time components are set. */ 9895 _getMinMaxDate: function(inst, minMax) { 9896 return this._determineDate(inst, this._get(inst, minMax + "Date"), null); 9897 }, 9898 9899 /* Find the number of days in a given month. */ 9900 _getDaysInMonth: function(year, month) { 9901 return 32 - this._daylightSavingAdjust(new Date(year, month, 32)).getDate(); 9902 }, 9903 9904 /* Find the day of the week of the first of a month. */ 9905 _getFirstDayOfMonth: function(year, month) { 9906 return new Date(year, month, 1).getDay(); 9907 }, 9908 9909 /* Determines if we should allow a "next/prev" month display change. */ 9910 _canAdjustMonth: function(inst, offset, curYear, curMonth) { 9911 var numMonths = this._getNumberOfMonths(inst), 9912 date = this._daylightSavingAdjust(new Date(curYear, 9913 curMonth + (offset < 0 ? offset : numMonths[0] * numMonths[1]), 1)); 9914 9915 if (offset < 0) { 9916 date.setDate(this._getDaysInMonth(date.getFullYear(), date.getMonth())); 9917 } 9918 return this._isInRange(inst, date); 9919 }, 9920 9921 /* Is the given date in the accepted range? */ 9922 _isInRange: function(inst, date) { 9923 var yearSplit, currentYear, 9924 minDate = this._getMinMaxDate(inst, "min"),
vendor: 4,958 bytes, lines 9925-10060
9925 maxDate = this._getMinMaxDate(inst, "max"), 9926 minYear = null, 9927 maxYear = null, 9928 years = this._get(inst, "yearRange"); 9929 if (years){ 9930 yearSplit = years.split(":"); 9931 currentYear = new Date().getFullYear(); 9932 minYear = parseInt(yearSplit[0], 10); 9933 maxYear = parseInt(yearSplit[1], 10); 9934 if ( yearSplit[0].match(/[+\-].*/) ) { 9935 minYear += currentYear; 9936 } 9937 if ( yearSplit[1].match(/[+\-].*/) ) { 9938 maxYear += currentYear; 9939 } 9940 } 9941 9942 return ((!minDate || date.getTime() >= minDate.getTime()) && 9943 (!maxDate || date.getTime() <= maxDate.getTime()) && 9944 (!minYear || date.getFullYear() >= minYear) && 9945 (!maxYear || date.getFullYear() <= maxYear)); 9946 }, 9947 9948 /* Provide the configuration settings for formatting/parsing. */ 9949 _getFormatConfig: function(inst) { 9950 var shortYearCutoff = this._get(inst, "shortYearCutoff"); 9951 shortYearCutoff = (typeof shortYearCutoff !== "string" ? shortYearCutoff : 9952 new Date().getFullYear() % 100 + parseInt(shortYearCutoff, 10)); 9953 return {shortYearCutoff: shortYearCutoff, 9954 dayNamesShort: this._get(inst, "dayNamesShort"), dayNames: this._get(inst, "dayNames"), 9955 monthNamesShort: this._get(inst, "monthNamesShort"), monthNames: this._get(inst, "monthNames")}; 9956 }, 9957 9958 /* Format the given date for display. */ 9959 _formatDate: function(inst, day, month, year) { 9960 if (!day) { 9961 inst.currentDay = inst.selectedDay; 9962 inst.currentMonth = inst.selectedMonth; 9963 inst.currentYear = inst.selectedYear; 9964 } 9965 var date = (day ? (typeof day === "object" ? day : 9966 this._daylightSavingAdjust(new Date(year, month, day))) : 9967 this._daylightSavingAdjust(new Date(inst.currentYear, inst.currentMonth, inst.currentDay))); 9968 return this.formatDate(this._get(inst, "dateFormat"), date, this._getFormatConfig(inst)); 9969 } 9970}); 9971 9972/* 9973 * Bind hover events for datepicker elements. 9974 * Done via delegate so the binding only occurs once in the lifetime of the parent div. 9975 * Global datepicker_instActive, set by _updateDatepicker allows the handlers to find their way back to the active picker. 9976 */ 9977function datepicker_bindHover(dpDiv) { 9978 var selector = "button, .ui-datepicker-prev, .ui-datepicker-next, .ui-datepicker-calendar td a"; 9979 return dpDiv.delegate(selector, "mouseout", function() { 9980 $(this).removeClass("ui-state-hover"); 9981 if (this.className.indexOf("ui-datepicker-prev") !== -1) { 9982 $(this).removeClass("ui-datepicker-prev-hover"); 9983 } 9984 if (this.className.indexOf("ui-datepicker-next") !== -1) { 9985 $(this).removeClass("ui-datepicker-next-hover"); 9986 } 9987 }) 9988 .delegate( selector, "mouseover", datepicker_handleMouseover ); 9989} 9990 9991function datepicker_handleMouseover() { 9992 if (!$.datepicker._isDisabledDatepicker( datepicker_instActive.inline? datepicker_instActive.dpDiv.parent()[0] : datepicker_instActive.input[0])) { 9993 $(this).parents(".ui-datepicker-calendar").find("a").removeClass("ui-state-hover"); 9994 $(this).addClass("ui-state-hover"); 9995 if (this.className.indexOf("ui-datepicker-prev") !== -1) { 9996 $(this).addClass("ui-datepicker-prev-hover"); 9997 } 9998 if (this.className.indexOf("ui-datepicker-next") !== -1) { 9999 $(this).addClass("ui-datepicker-next-hover"); 10000 } 10001 } 10002} 10003 10004/* jQuery extend now ignores nulls! */ 10005function datepicker_extendRemove(target, props) { 10006 $.extend(target, props); 10007 for (var name in props) { 10008 if (props[name] == null) { 10009 target[name] = props[name]; 10010 } 10011 } 10012 return target; 10013} 10014 10015/* Invoke the datepicker functionality. 10016 @param options string - a command, optionally followed by additional parameters or 10017 Object - settings for attaching new datepicker functionality 10018 @return jQuery object */ 10019$.fn.datepicker = function(options){ 10020 10021 /* Verify an empty collection wasn't passed - Fixes #6976 */ 10022 if ( !this.length ) { 10023 return this; 10024 } 10025 10026 /* Initialise the date picker. */ 10027 if (!$.datepicker.initialized) { 10028 $(document).mousedown($.datepicker._checkExternalClick); 10029 $.datepicker.initialized = true; 10030 } 10031 10032 /* Append datepicker main container to body if not exist. */ 10033 if ($("#"+$.datepicker._mainDivId).length === 0) { 10034 $("body").append($.datepicker.dpDiv); 10035 } 10036 10037 var otherArgs = Array.prototype.slice.call(arguments, 1); 10038 if (typeof options === "string" && (options === "isDisabled" || options === "getDate" || options === "widget")) { 10039 return $.datepicker["_" + options + "Datepicker"]. 10040 apply($.datepicker, [this[0]].concat(otherArgs)); 10041 } 10042 if (options === "option" && arguments.length === 2 && typeof arguments[1] === "string") { 10043 return $.datepicker["_" + options + "Datepicker"]. 10044 apply($.datepicker, [this[0]].concat(otherArgs)); 10045 } 10046 return this.each(function() { 10047 typeof options === "string" ? 10048 $.datepicker["_" + options + "Datepicker"]. 10049 apply($.datepicker, [this].concat(otherArgs)) : 10050 $.datepicker._attachDatepicker(this, options); 10051 }); 10052}; 10053 10054$.datepicker = new Datepicker(); // singleton instance 10055$.datepicker.initialized = false; 10056$.datepicker.uuid = new Date().getTime(); 10057$.datepicker.version = "1.11.4"; 10058 10059var datepicker = $.datepicker; 10060
vendor: 24,872 bytes, lines 10061-11060
10061 10062/*! 10063 * jQuery UI Dialog 1.11.4 10064 * http://jqueryui.com 10065 * 10066 * Copyright jQuery Foundation and other contributors 10067 * Released under the MIT license. 10068 * http://jquery.org/license 10069 * 10070 * http://api.jqueryui.com/dialog/ 10071 */ 10072 10073 10074var dialog = $.widget( "ui.dialog", { 10075 version: "1.11.4", 10076 options: { 10077 appendTo: "body", 10078 autoOpen: true, 10079 buttons: [], 10080 closeOnEscape: true, 10081 closeText: "Close", 10082 dialogClass: "", 10083 draggable: true, 10084 hide: null, 10085 height: "auto", 10086 maxHeight: null, 10087 maxWidth: null, 10088 minHeight: 150, 10089 minWidth: 150, 10090 modal: false, 10091 position: { 10092 my: "center", 10093 at: "center", 10094 of: window, 10095 collision: "fit", 10096 // Ensure the titlebar is always visible 10097 using: function( pos ) { 10098 var topOffset = $( this ).css( pos ).offset().top; 10099 if ( topOffset < 0 ) { 10100 $( this ).css( "top", pos.top - topOffset ); 10101 } 10102 } 10103 }, 10104 resizable: true, 10105 show: null, 10106 title: null, 10107 width: 300, 10108 10109 // callbacks 10110 beforeClose: null, 10111 close: null, 10112 drag: null, 10113 dragStart: null, 10114 dragStop: null, 10115 focus: null, 10116 open: null, 10117 resize: null, 10118 resizeStart: null, 10119 resizeStop: null 10120 }, 10121 10122 sizeRelatedOptions: { 10123 buttons: true, 10124 height: true, 10125 maxHeight: true, 10126 maxWidth: true, 10127 minHeight: true, 10128 minWidth: true, 10129 width: true 10130 }, 10131 10132 resizableRelatedOptions: { 10133 maxHeight: true, 10134 maxWidth: true, 10135 minHeight: true, 10136 minWidth: true 10137 }, 10138 10139 _create: function() { 10140 this.originalCss = { 10141 display: this.element[ 0 ].style.display, 10142 width: this.element[ 0 ].style.width, 10143 minHeight: this.element[ 0 ].style.minHeight, 10144 maxHeight: this.element[ 0 ].style.maxHeight, 10145 height: this.element[ 0 ].style.height 10146 }; 10147 this.originalPosition = { 10148 parent: this.element.parent(), 10149 index: this.element.parent().children().index( this.element ) 10150 }; 10151 this.originalTitle = this.element.attr( "title" ); 10152 this.options.title = this.options.title || this.originalTitle; 10153 10154 this._createWrapper(); 10155 10156 this.element 10157 .show() 10158 .removeAttr( "title" ) 10159 .addClass( "ui-dialog-content ui-widget-content" ) 10160 .appendTo( this.uiDialog ); 10161 10162 this._createTitlebar(); 10163 this._createButtonPane(); 10164 10165 if ( this.options.draggable && $.fn.draggable ) { 10166 this._makeDraggable(); 10167 } 10168 if ( this.options.resizable && $.fn.resizable ) { 10169 this._makeResizable(); 10170 } 10171 10172 this._isOpen = false; 10173 10174 this._trackFocus(); 10175 }, 10176 10177 _init: function() { 10178 if ( this.options.autoOpen ) { 10179 this.open(); 10180 } 10181 }, 10182 10183 _appendTo: function() { 10184 var element = this.options.appendTo; 10185 if ( element && (element.jquery || element.nodeType) ) { 10186 return $( element ); 10187 } 10188 return this.document.find( element || "body" ).eq( 0 ); 10189 }, 10190 10191 _destroy: function() { 10192 var next, 10193 originalPosition = this.originalPosition; 10194 10195 this._untrackInstance(); 10196 this._destroyOverlay(); 10197 10198 this.element 10199 .removeUniqueId() 10200 .removeClass( "ui-dialog-content ui-widget-content" ) 10201 .css( this.originalCss ) 10202 // Without detaching first, the following becomes really slow 10203 .detach(); 10204 10205 this.uiDialog.stop( true, true ).remove(); 10206 10207 if ( this.originalTitle ) { 10208 this.element.attr( "title", this.originalTitle ); 10209 } 10210 10211 next = originalPosition.parent.children().eq( originalPosition.index ); 10212 // Don't try to place the dialog next to itself (#8613) 10213 if ( next.length && next[ 0 ] !== this.element[ 0 ] ) { 10214 next.before( this.element ); 10215 } else { 10216 originalPosition.parent.append( this.element ); 10217 } 10218 }, 10219 10220 widget: function() { 10221 return this.uiDialog; 10222 }, 10223 10224 disable: $.noop, 10225 enable: $.noop, 10226 10227 close: function( event ) { 10228 var activeElement, 10229 that = this; 10230 10231 if ( !this._isOpen || this._trigger( "beforeClose", event ) === false ) { 10232 return; 10233 } 10234 10235 this._isOpen = false; 10236 this._focusedElement = null; 10237 this._destroyOverlay(); 10238 this._untrackInstance(); 10239 10240 if ( !this.opener.filter( ":focusable" ).focus().length ) { 10241 10242 // support: IE9 10243 // IE9 throws an "Unspecified error" accessing document.activeElement from an <iframe> 10244 try { 10245 activeElement = this.document[ 0 ].activeElement; 10246 10247 // Support: IE9, IE10 10248 // If the <body> is blurred, IE will switch windows, see #4520 10249 if ( activeElement && activeElement.nodeName.toLowerCase() !== "body" ) { 10250 10251 // Hiding a focused element doesn't trigger blur in WebKit 10252 // so in case we have nothing to focus on, explicitly blur the active element 10253 // https://bugs.webkit.org/show_bug.cgi?id=47182 10254 $( activeElement ).blur(); 10255 } 10256 } catch ( error ) {} 10257 } 10258 10259 this._hide( this.uiDialog, this.options.hide, function() { 10260 that._trigger( "close", event ); 10261 }); 10262 }, 10263 10264 isOpen: function() { 10265 return this._isOpen; 10266 }, 10267 10268 moveToTop: function() { 10269 this._moveToTop(); 10270 }, 10271 10272 _moveToTop: function( event, silent ) { 10273 var moved = false, 10274 zIndices = this.uiDialog.siblings( ".ui-front:visible" ).map(function() { 10275 return +$( this ).css( "z-index" ); 10276 }).get(), 10277 zIndexMax = Math.max.apply( null, zIndices ); 10278 10279 if ( zIndexMax >= +this.uiDialog.css( "z-index" ) ) { 10280 this.uiDialog.css( "z-index", zIndexMax + 1 ); 10281 moved = true; 10282 } 10283 10284 if ( moved && !silent ) { 10285 this._trigger( "focus", event ); 10286 } 10287 return moved; 10288 }, 10289 10290 open: function() { 10291 var that = this; 10292 if ( this._isOpen ) { 10293 if ( this._moveToTop() ) { 10294 this._focusTabbable(); 10295 } 10296 return; 10297 } 10298 10299 this._isOpen = true; 10300 this.opener = $( this.document[ 0 ].activeElement ); 10301 10302 this._size(); 10303 this._position(); 10304 this._createOverlay(); 10305 this._moveToTop( null, true ); 10306 10307 // Ensure the overlay is moved to the top with the dialog, but only when 10308 // opening. The overlay shouldn't move after the dialog is open so that 10309 // modeless dialogs opened after the modal dialog stack properly. 10310 if ( this.overlay ) { 10311 this.overlay.css( "z-index", this.uiDialog.css( "z-index" ) - 1 ); 10312 } 10313 10314 this._show( this.uiDialog, this.options.show, function() { 10315 that._focusTabbable(); 10316 that._trigger( "focus" ); 10317 }); 10318 10319 // Track the dialog immediately upon openening in case a focus event 10320 // somehow occurs outside of the dialog before an element inside the 10321 // dialog is focused (#10152) 10322 this._makeFocusTarget(); 10323 10324 this._trigger( "open" ); 10325 }, 10326 10327 _focusTabbable: function() { 10328 // Set focus to the first match: 10329 // 1. An element that was focused previously 10330 // 2. First element inside the dialog matching [autofocus] 10331 // 3. Tabbable element inside the content element 10332 // 4. Tabbable element inside the buttonpane 10333 // 5. The close button 10334 // 6. The dialog itself 10335 var hasFocus = this._focusedElement; 10336 if ( !hasFocus ) { 10337 hasFocus = this.element.find( "[autofocus]" ); 10338 } 10339 if ( !hasFocus.length ) { 10340 hasFocus = this.element.find( ":tabbable" ); 10341 } 10342 if ( !hasFocus.length ) { 10343 hasFocus = this.uiDialogButtonPane.find( ":tabbable" ); 10344 } 10345 if ( !hasFocus.length ) { 10346 hasFocus = this.uiDialogTitlebarClose.filter( ":tabbable" ); 10347 } 10348 if ( !hasFocus.length ) { 10349 hasFocus = this.uiDialog; 10350 } 10351 hasFocus.eq( 0 ).focus(); 10352 }, 10353 10354 _keepFocus: function( event ) { 10355 function checkFocus() { 10356 var activeElement = this.document[0].activeElement, 10357 isActive = this.uiDialog[0] === activeElement || 10358 $.contains( this.uiDialog[0], activeElement ); 10359 if ( !isActive ) { 10360 this._focusTabbable(); 10361 } 10362 } 10363 event.preventDefault(); 10364 checkFocus.call( this ); 10365 // support: IE 10366 // IE <= 8 doesn't prevent moving focus even with event.preventDefault() 10367 // so we check again later 10368 this._delay( checkFocus ); 10369 }, 10370 10371 _createWrapper: function() { 10372 this.uiDialog = $("<div>") 10373 .addClass( "ui-dialog ui-widget ui-widget-content ui-corner-all ui-front " + 10374 this.options.dialogClass ) 10375 .hide() 10376 .attr({ 10377 // Setting tabIndex makes the div focusable 10378 tabIndex: -1, 10379 role: "dialog" 10380 }) 10381 .appendTo( this._appendTo() ); 10382 10383 this._on( this.uiDialog, { 10384 keydown: function( event ) { 10385 if ( this.options.closeOnEscape && !event.isDefaultPrevented() && event.keyCode && 10386 event.keyCode === $.ui.keyCode.ESCAPE ) { 10387 event.preventDefault(); 10388 this.close( event ); 10389 return; 10390 } 10391 10392 // prevent tabbing out of dialogs 10393 if ( event.keyCode !== $.ui.keyCode.TAB || event.isDefaultPrevented() ) { 10394 return; 10395 } 10396 var tabbables = this.uiDialog.find( ":tabbable" ), 10397 first = tabbables.filter( ":first" ), 10398 last = tabbables.filter( ":last" ); 10399 10400 if ( ( event.target === last[0] || event.target === this.uiDialog[0] ) && !event.shiftKey ) { 10401 this._delay(function() { 10402 first.focus(); 10403 }); 10404 event.preventDefault(); 10405 } else if ( ( event.target === first[0] || event.target === this.uiDialog[0] ) && event.shiftKey ) { 10406 this._delay(function() { 10407 last.focus(); 10408 }); 10409 event.preventDefault(); 10410 } 10411 }, 10412 mousedown: function( event ) { 10413 if ( this._moveToTop( event ) ) { 10414 this._focusTabbable(); 10415 } 10416 } 10417 }); 10418 10419 // We assume that any existing aria-describedby attribute means 10420 // that the dialog content is marked up properly 10421 // otherwise we brute force the content as the description 10422 if ( !this.element.find( "[aria-describedby]" ).length ) { 10423 this.uiDialog.attr({ 10424 "aria-describedby": this.element.uniqueId().attr( "id" ) 10425 }); 10426 } 10427 }, 10428 10429 _createTitlebar: function() { 10430 var uiDialogTitle; 10431 10432 this.uiDialogTitlebar = $( "<div>" ) 10433 .addClass( "ui-dialog-titlebar ui-widget-header ui-corner-all ui-helper-clearfix" ) 10434 .prependTo( this.uiDialog ); 10435 this._on( this.uiDialogTitlebar, { 10436 mousedown: function( event ) { 10437 // Don't prevent click on close button (#8838) 10438 // Focusing a dialog that is partially scrolled out of view 10439 // causes the browser to scroll it into view, preventing the click event 10440 if ( !$( event.target ).closest( ".ui-dialog-titlebar-close" ) ) { 10441 // Dialog isn't getting focus when dragging (#8063) 10442 this.uiDialog.focus(); 10443 } 10444 } 10445 }); 10446 10447 // support: IE 10448 // Use type="button" to prevent enter keypresses in textboxes from closing the 10449 // dialog in IE (#9312) 10450 this.uiDialogTitlebarClose = $( "<button type='button'></button>" ) 10451 .button({ 10452 label: this.options.closeText, 10453 icons: { 10454 primary: "ui-icon-closethick" 10455 }, 10456 text: false 10457 }) 10458 .addClass( "ui-dialog-titlebar-close" ) 10459 .appendTo( this.uiDialogTitlebar ); 10460 this._on( this.uiDialogTitlebarClose, { 10461 click: function( event ) { 10462 event.preventDefault(); 10463 this.close( event ); 10464 } 10465 }); 10466 10467 uiDialogTitle = $( "<span>" ) 10468 .uniqueId() 10469 .addClass( "ui-dialog-title" ) 10470 .prependTo( this.uiDialogTitlebar ); 10471 this._title( uiDialogTitle ); 10472 10473 this.uiDialog.attr({ 10474 "aria-labelledby": uiDialogTitle.attr( "id" ) 10475 }); 10476 }, 10477 10478 _title: function( title ) { 10479 if ( !this.options.title ) { 10480 title.html( " " ); 10481 } 10482 title.text( this.options.title ); 10483 }, 10484 10485 _createButtonPane: function() { 10486 this.uiDialogButtonPane = $( "<div>" ) 10487 .addClass( "ui-dialog-buttonpane ui-widget-content ui-helper-clearfix" ); 10488 10489 this.uiButtonSet = $( "<div>" ) 10490 .addClass( "ui-dialog-buttonset" ) 10491 .appendTo( this.uiDialogButtonPane ); 10492 10493 this._createButtons(); 10494 }, 10495 10496 _createButtons: function() { 10497 var that = this, 10498 buttons = this.options.buttons; 10499 10500 // if we already have a button pane, remove it 10501 this.uiDialogButtonPane.remove(); 10502 this.uiButtonSet.empty(); 10503 10504 if ( $.isEmptyObject( buttons ) || ($.isArray( buttons ) && !buttons.length) ) { 10505 this.uiDialog.removeClass( "ui-dialog-buttons" ); 10506 return; 10507 } 10508 10509 $.each( buttons, function( name, props ) { 10510 var click, buttonOptions; 10511 props = $.isFunction( props ) ? 10512 { click: props, text: name } : 10513 props; 10514 // Default to a non-submitting button 10515 props = $.extend( { type: "button" }, props ); 10516 // Change the context for the click callback to be the main element 10517 click = props.click; 10518 props.click = function() { 10519 click.apply( that.element[ 0 ], arguments ); 10520 }; 10521 buttonOptions = { 10522 icons: props.icons, 10523 text: props.showText 10524 }; 10525 delete props.icons; 10526 delete props.showText; 10527 $( "<button></button>", props ) 10528 .button( buttonOptions ) 10529 .appendTo( that.uiButtonSet ); 10530 }); 10531 this.uiDialog.addClass( "ui-dialog-buttons" ); 10532 this.uiDialogButtonPane.appendTo( this.uiDialog ); 10533 }, 10534 10535 _makeDraggable: function() { 10536 var that = this, 10537 options = this.options; 10538 10539 function filteredUi( ui ) { 10540 return { 10541 position: ui.position, 10542 offset: ui.offset 10543 }; 10544 } 10545 10546 this.uiDialog.draggable({ 10547 cancel: ".ui-dialog-content, .ui-dialog-titlebar-close", 10548 handle: ".ui-dialog-titlebar", 10549 containment: "document", 10550 start: function( event, ui ) { 10551 $( this ).addClass( "ui-dialog-dragging" ); 10552 that._blockFrames(); 10553 that._trigger( "dragStart", event, filteredUi( ui ) ); 10554 }, 10555 drag: function( event, ui ) { 10556 that._trigger( "drag", event, filteredUi( ui ) ); 10557 }, 10558 stop: function( event, ui ) { 10559 var left = ui.offset.left - that.document.scrollLeft(), 10560 top = ui.offset.top - that.document.scrollTop(); 10561 10562 options.position = { 10563 my: "left top", 10564 at: "left" + (left >= 0 ? "+" : "") + left + " " + 10565 "top" + (top >= 0 ? "+" : "") + top, 10566 of: that.window 10567 }; 10568 $( this ).removeClass( "ui-dialog-dragging" ); 10569 that._unblockFrames(); 10570 that._trigger( "dragStop", event, filteredUi( ui ) ); 10571 } 10572 }); 10573 }, 10574 10575 _makeResizable: function() { 10576 var that = this, 10577 options = this.options, 10578 handles = options.resizable, 10579 // .ui-resizable has position: relative defined in the stylesheet 10580 // but dialogs have to use absolute or fixed positioning 10581 position = this.uiDialog.css("position"), 10582 resizeHandles = typeof handles === "string" ? 10583 handles : 10584 "n,e,s,w,se,sw,ne,nw"; 10585 10586 function filteredUi( ui ) { 10587 return { 10588 originalPosition: ui.originalPosition, 10589 originalSize: ui.originalSize, 10590 position: ui.position, 10591 size: ui.size 10592 }; 10593 } 10594 10595 this.uiDialog.resizable({ 10596 cancel: ".ui-dialog-content", 10597 containment: "document", 10598 alsoResize: this.element, 10599 maxWidth: options.maxWidth, 10600 maxHeight: options.maxHeight, 10601 minWidth: options.minWidth, 10602 minHeight: this._minHeight(), 10603 handles: resizeHandles, 10604 start: function( event, ui ) { 10605 $( this ).addClass( "ui-dialog-resizing" ); 10606 that._blockFrames(); 10607 that._trigger( "resizeStart", event, filteredUi( ui ) ); 10608 }, 10609 resize: function( event, ui ) { 10610 that._trigger( "resize", event, filteredUi( ui ) ); 10611 }, 10612 stop: function( event, ui ) { 10613 var offset = that.uiDialog.offset(), 10614 left = offset.left - that.document.scrollLeft(), 10615 top = offset.top - that.document.scrollTop(); 10616 10617 options.height = that.uiDialog.height(); 10618 options.width = that.uiDialog.width(); 10619 options.position = { 10620 my: "left top", 10621 at: "left" + (left >= 0 ? "+" : "") + left + " " + 10622 "top" + (top >= 0 ? "+" : "") + top, 10623 of: that.window 10624 }; 10625 $( this ).removeClass( "ui-dialog-resizing" ); 10626 that._unblockFrames(); 10627 that._trigger( "resizeStop", event, filteredUi( ui ) ); 10628 } 10629 }) 10630 .css( "position", position ); 10631 }, 10632 10633 _trackFocus: function() { 10634 this._on( this.widget(), { 10635 focusin: function( event ) { 10636 this._makeFocusTarget(); 10637 this._focusedElement = $( event.target ); 10638 } 10639 }); 10640 }, 10641 10642 _makeFocusTarget: function() { 10643 this._untrackInstance(); 10644 this._trackingInstances().unshift( this ); 10645 }, 10646 10647 _untrackInstance: function() { 10648 var instances = this._trackingInstances(), 10649 exists = $.inArray( this, instances ); 10650 if ( exists !== -1 ) { 10651 instances.splice( exists, 1 ); 10652 } 10653 }, 10654 10655 _trackingInstances: function() { 10656 var instances = this.document.data( "ui-dialog-instances" ); 10657 if ( !instances ) { 10658 instances = []; 10659 this.document.data( "ui-dialog-instances", instances ); 10660 } 10661 return instances; 10662 }, 10663 10664 _minHeight: function() { 10665 var options = this.options; 10666 10667 return options.height === "auto" ? 10668 options.minHeight : 10669 Math.min( options.minHeight, options.height ); 10670 }, 10671 10672 _position: function() { 10673 // Need to show the dialog to get the actual offset in the position plugin 10674 var isVisible = this.uiDialog.is( ":visible" ); 10675 if ( !isVisible ) { 10676 this.uiDialog.show(); 10677 } 10678 this.uiDialog.position( this.options.position ); 10679 if ( !isVisible ) { 10680 this.uiDialog.hide(); 10681 } 10682 }, 10683 10684 _setOptions: function( options ) { 10685 var that = this, 10686 resize = false, 10687 resizableOptions = {}; 10688 10689 $.each( options, function( key, value ) { 10690 that._setOption( key, value ); 10691 10692 if ( key in that.sizeRelatedOptions ) { 10693 resize = true; 10694 } 10695 if ( key in that.resizableRelatedOptions ) { 10696 resizableOptions[ key ] = value; 10697 } 10698 }); 10699 10700 if ( resize ) { 10701 this._size(); 10702 this._position(); 10703 } 10704 if ( this.uiDialog.is( ":data(ui-resizable)" ) ) { 10705 this.uiDialog.resizable( "option", resizableOptions ); 10706 } 10707 }, 10708 10709 _setOption: function( key, value ) { 10710 var isDraggable, isResizable, 10711 uiDialog = this.uiDialog; 10712 10713 if ( key === "dialogClass" ) { 10714 uiDialog 10715 .removeClass( this.options.dialogClass ) 10716 .addClass( value ); 10717 } 10718 10719 if ( key === "disabled" ) { 10720 return; 10721 } 10722 10723 this._super( key, value ); 10724 10725 if ( key === "appendTo" ) { 10726 this.uiDialog.appendTo( this._appendTo() ); 10727 } 10728 10729 if ( key === "buttons" ) { 10730 this._createButtons(); 10731 } 10732 10733 if ( key === "closeText" ) { 10734 this.uiDialogTitlebarClose.button({ 10735 // Ensure that we always pass a string 10736 label: "" + value 10737 }); 10738 } 10739 10740 if ( key === "draggable" ) { 10741 isDraggable = uiDialog.is( ":data(ui-draggable)" ); 10742 if ( isDraggable && !value ) { 10743 uiDialog.draggable( "destroy" ); 10744 } 10745 10746 if ( !isDraggable && value ) { 10747 this._makeDraggable(); 10748 } 10749 } 10750 10751 if ( key === "position" ) { 10752 this._position(); 10753 } 10754 10755 if ( key === "resizable" ) { 10756 // currently resizable, becoming non-resizable 10757 isResizable = uiDialog.is( ":data(ui-resizable)" ); 10758 if ( isResizable && !value ) { 10759 uiDialog.resizable( "destroy" ); 10760 } 10761 10762 // currently resizable, changing handles 10763 if ( isResizable && typeof value === "string" ) { 10764 uiDialog.resizable( "option", "handles", value ); 10765 } 10766 10767 // currently non-resizable, becoming resizable 10768 if ( !isResizable && value !== false ) { 10769 this._makeResizable(); 10770 } 10771 } 10772 10773 if ( key === "title" ) { 10774 this._title( this.uiDialogTitlebar.find( ".ui-dialog-title" ) ); 10775 } 10776 }, 10777 10778 _size: function() { 10779 // If the user has resized the dialog, the .ui-dialog and .ui-dialog-content 10780 // divs will both have width and height set, so we need to reset them 10781 var nonContentHeight, minContentHeight, maxContentHeight, 10782 options = this.options; 10783 10784 // Reset content sizing 10785 this.element.show().css({ 10786 width: "auto", 10787 minHeight: 0, 10788 maxHeight: "none", 10789 height: 0 10790 }); 10791 10792 if ( options.minWidth > options.width ) { 10793 options.width = options.minWidth; 10794 } 10795 10796 // reset wrapper sizing 10797 // determine the height of all the non-content elements 10798 nonContentHeight = this.uiDialog.css({ 10799 height: "auto", 10800 width: options.width 10801 }) 10802 .outerHeight(); 10803 minContentHeight = Math.max( 0, options.minHeight - nonContentHeight ); 10804 maxContentHeight = typeof options.maxHeight === "number" ? 10805 Math.max( 0, options.maxHeight - nonContentHeight ) : 10806 "none"; 10807 10808 if ( options.height === "auto" ) { 10809 this.element.css({ 10810 minHeight: minContentHeight, 10811 maxHeight: maxContentHeight, 10812 height: "auto" 10813 }); 10814 } else { 10815 this.element.height( Math.max( 0, options.height - nonContentHeight ) ); 10816 } 10817 10818 if ( this.uiDialog.is( ":data(ui-resizable)" ) ) { 10819 this.uiDialog.resizable( "option", "minHeight", this._minHeight() ); 10820 } 10821 }, 10822 10823 _blockFrames: function() { 10824 this.iframeBlocks = this.document.find( "iframe" ).map(function() { 10825 var iframe = $( this ); 10826 10827 return $( "<div>" ) 10828 .css({ 10829 position: "absolute", 10830 width: iframe.outerWidth(), 10831 height: iframe.outerHeight() 10832 }) 10833 .appendTo( iframe.parent() ) 10834 .offset( iframe.offset() )[0]; 10835 }); 10836 }, 10837 10838 _unblockFrames: function() { 10839 if ( this.iframeBlocks ) { 10840 this.iframeBlocks.remove(); 10841 delete this.iframeBlocks; 10842 } 10843 }, 10844 10845 _allowInteraction: function( event ) { 10846 if ( $( event.target ).closest( ".ui-dialog" ).length ) { 10847 return true; 10848 } 10849 10850 // TODO: Remove hack when datepicker implements 10851 // the .ui-front logic (#8989) 10852 return !!$( event.target ).closest( ".ui-datepicker" ).length; 10853 }, 10854 10855 _createOverlay: function() { 10856 if ( !this.options.modal ) { 10857 return; 10858 } 10859 10860 // We use a delay in case the overlay is created from an 10861 // event that we're going to be cancelling (#2804) 10862 var isOpening = true; 10863 this._delay(function() { 10864 isOpening = false; 10865 }); 10866 10867 if ( !this.document.data( "ui-dialog-overlays" ) ) { 10868 10869 // Prevent use of anchors and inputs 10870 // Using _on() for an event handler shared across many instances is 10871 // safe because the dialogs stack and must be closed in reverse order 10872 this._on( this.document, { 10873 focusin: function( event ) { 10874 if ( isOpening ) { 10875 return; 10876 } 10877 10878 if ( !this._allowInteraction( event ) ) { 10879 event.preventDefault(); 10880 this._trackingInstances()[ 0 ]._focusTabbable(); 10881 } 10882 } 10883 }); 10884 } 10885 10886 this.overlay = $( "<div>" ) 10887 .addClass( "ui-widget-overlay ui-front" ) 10888 .appendTo( this._appendTo() ); 10889 this._on( this.overlay, { 10890 mousedown: "_keepFocus" 10891 }); 10892 this.document.data( "ui-dialog-overlays", 10893 (this.document.data( "ui-dialog-overlays" ) || 0) + 1 ); 10894 }, 10895 10896 _destroyOverlay: function() { 10897 if ( !this.options.modal ) { 10898 return; 10899 } 10900 10901 if ( this.overlay ) { 10902 var overlays = this.document.data( "ui-dialog-overlays" ) - 1; 10903 10904 if ( !overlays ) { 10905 this.document 10906 .unbind( "focusin" ) 10907 .removeData( "ui-dialog-overlays" ); 10908 } else { 10909 this.document.data( "ui-dialog-overlays", overlays ); 10910 } 10911 10912 this.overlay.remove(); 10913 this.overlay = null; 10914 } 10915 } 10916}); 10917 10918 10919/*! 10920 * jQuery UI Progressbar 1.11.4 10921 * http://jqueryui.com 10922 * 10923 * Copyright jQuery Foundation and other contributors 10924 * Released under the MIT license. 10925 * http://jquery.org/license 10926 * 10927 * http://api.jqueryui.com/progressbar/ 10928 */ 10929 10930 10931var progressbar = $.widget( "ui.progressbar", { 10932 version: "1.11.4", 10933 options: { 10934 max: 100, 10935 value: 0, 10936 10937 change: null, 10938 complete: null 10939 }, 10940 10941 min: 0, 10942 10943 _create: function() { 10944 // Constrain initial value 10945 this.oldValue = this.options.value = this._constrainedValue(); 10946 10947 this.element 10948 .addClass( "ui-progressbar ui-widget ui-widget-content ui-corner-all" ) 10949 .attr({ 10950 // Only set static values, aria-valuenow and aria-valuemax are 10951 // set inside _refreshValue() 10952 role: "progressbar", 10953 "aria-valuemin": this.min 10954 }); 10955 10956 this.valueDiv = $( "<div class='ui-progressbar-value ui-widget-header ui-corner-left'></div>" ) 10957 .appendTo( this.element ); 10958 10959 this._refreshValue(); 10960 }, 10961 10962 _destroy: function() { 10963 this.element 10964 .removeClass( "ui-progressbar ui-widget ui-widget-content ui-corner-all" ) 10965 .removeAttr( "role" ) 10966 .removeAttr( "aria-valuemin" ) 10967 .removeAttr( "aria-valuemax" ) 10968 .removeAttr( "aria-valuenow" ); 10969 10970 this.valueDiv.remove(); 10971 }, 10972 10973 value: function( newValue ) { 10974 if ( newValue === undefined ) { 10975 return this.options.value; 10976 } 10977 10978 this.options.value = this._constrainedValue( newValue ); 10979 this._refreshValue(); 10980 }, 10981 10982 _constrainedValue: function( newValue ) { 10983 if ( newValue === undefined ) { 10984 newValue = this.options.value; 10985 } 10986 10987 this.indeterminate = newValue === false; 10988 10989 // sanitize value 10990 if ( typeof newValue !== "number" ) { 10991 newValue = 0; 10992 } 10993 10994 return this.indeterminate ? false : 10995 Math.min( this.options.max, Math.max( this.min, newValue ) ); 10996 }, 10997 10998 _setOptions: function( options ) { 10999 // Ensure "value" option is set after other values (like max) 11000 var value = options.value; 11001 delete options.value; 11002 11003 this._super( options ); 11004 11005 this.options.value = this._constrainedValue( value ); 11006 this._refreshValue(); 11007 }, 11008 11009 _setOption: function( key, value ) { 11010 if ( key === "max" ) { 11011 // Don't allow a max less than min 11012 value = Math.max( this.min, value ); 11013 } 11014 if ( key === "disabled" ) { 11015 this.element 11016 .toggleClass( "ui-state-disabled", !!value ) 11017 .attr( "aria-disabled", value ); 11018 } 11019 this._super( key, value ); 11020 }, 11021 11022 _percentage: function() { 11023 return this.indeterminate ? 100 : 100 * ( this.options.value - this.min ) / ( this.options.max - this.min ); 11024 }, 11025 11026 _refreshValue: function() { 11027 var value = this.options.value, 11028 percentage = this._percentage(); 11029 11030 this.valueDiv 11031 .toggle( this.indeterminate || value > this.min ) 11032 .toggleClass( "ui-corner-right", value === this.options.max ) 11033 .width( percentage.toFixed(0) + "%" ); 11034 11035 this.element.toggleClass( "ui-progressbar-indeterminate", this.indeterminate ); 11036 11037 if ( this.indeterminate ) { 11038 this.element.removeAttr( "aria-valuenow" ); 11039 if ( !this.overlayDiv ) { 11040 this.overlayDiv = $( "<div class='ui-progressbar-overlay'></div>" ).appendTo( this.valueDiv ); 11041 } 11042 } else { 11043 this.element.attr({ 11044 "aria-valuemax": this.options.max, 11045 "aria-valuenow": value 11046 }); 11047 if ( this.overlayDiv ) { 11048 this.overlayDiv.remove(); 11049 this.overlayDiv = null; 11050 } 11051 } 11052 11053 if ( this.oldValue !== value ) { 11054 this.oldValue = value; 11055 this._trigger( "change" ); 11056 } 11057 if ( value === this.options.max ) { 11058 this._trigger( "complete" ); 11059 } 11060 }
vendor: 18,427 bytes, lines 11060-11864
11060 11061}); 11062 11063 11064/*! 11065 * jQuery UI Selectmenu 1.11.4 11066 * http://jqueryui.com 11067 * 11068 * Copyright jQuery Foundation and other contributors 11069 * Released under the MIT license. 11070 * http://jquery.org/license 11071 * 11072 * http://api.jqueryui.com/selectmenu 11073 */ 11074 11075 11076var selectmenu = $.widget( "ui.selectmenu", { 11077 version: "1.11.4", 11078 defaultElement: "<select>", 11079 options: { 11080 appendTo: null, 11081 disabled: null, 11082 icons: { 11083 button: "ui-icon-triangle-1-s" 11084 }, 11085 position: { 11086 my: "left top", 11087 at: "left bottom", 11088 collision: "none" 11089 }, 11090 width: null, 11091 11092 // callbacks 11093 change: null, 11094 close: null, 11095 focus: null, 11096 open: null, 11097 select: null 11098 }, 11099 11100 _create: function() { 11101 var selectmenuId = this.element.uniqueId().attr( "id" ); 11102 this.ids = { 11103 element: selectmenuId, 11104 button: selectmenuId + "-button", 11105 menu: selectmenuId + "-menu" 11106 }; 11107 11108 this._drawButton(); 11109 this._drawMenu(); 11110 11111 if ( this.options.disabled ) { 11112 this.disable(); 11113 } 11114 }, 11115 11116 _drawButton: function() { 11117 var that = this; 11118 11119 // Associate existing label with the new button 11120 this.label = $( "label[for='" + this.ids.element + "']" ).attr( "for", this.ids.button ); 11121 this._on( this.label, { 11122 click: function( event ) { 11123 this.button.focus(); 11124 event.preventDefault(); 11125 } 11126 }); 11127 11128 // Hide original select element 11129 this.element.hide(); 11130 11131 // Create button 11132 this.button = $( "<span>", { 11133 "class": "ui-selectmenu-button ui-widget ui-state-default ui-corner-all", 11134 tabindex: this.options.disabled ? -1 : 0, 11135 id: this.ids.button, 11136 role: "combobox", 11137 "aria-expanded": "false", 11138 "aria-autocomplete": "list", 11139 "aria-owns": this.ids.menu, 11140 "aria-haspopup": "true" 11141 }) 11142 .insertAfter( this.element ); 11143 11144 $( "<span>", { 11145 "class": "ui-icon " + this.options.icons.button 11146 }) 11147 .prependTo( this.button ); 11148 11149 this.buttonText = $( "<span>", { 11150 "class": "ui-selectmenu-text" 11151 }) 11152 .appendTo( this.button ); 11153 11154 this._setText( this.buttonText, this.element.find( "option:selected" ).text() ); 11155 this._resizeButton(); 11156 11157 this._on( this.button, this._buttonEvents ); 11158 this.button.one( "focusin", function() { 11159 11160 // Delay rendering the menu items until the button receives focus. 11161 // The menu may have already been rendered via a programmatic open. 11162 if ( !that.menuItems ) { 11163 that._refreshMenu(); 11164 } 11165 }); 11166 this._hoverable( this.button ); 11167 this._focusable( this.button ); 11168 }, 11169 11170 _drawMenu: function() { 11171 var that = this; 11172 11173 // Create menu 11174 this.menu = $( "<ul>", { 11175 "aria-hidden": "true", 11176 "aria-labelledby": this.ids.button, 11177 id: this.ids.menu 11178 }); 11179 11180 // Wrap menu 11181 this.menuWrap = $( "<div>", { 11182 "class": "ui-selectmenu-menu ui-front" 11183 }) 11184 .append( this.menu ) 11185 .appendTo( this._appendTo() ); 11186 11187 // Initialize menu widget 11188 this.menuInstance = this.menu 11189 .menu({ 11190 role: "listbox", 11191 select: function( event, ui ) { 11192 event.preventDefault(); 11193 11194 // support: IE8 11195 // If the item was selected via a click, the text selection 11196 // will be destroyed in IE 11197 that._setSelection(); 11198 11199 that._select( ui.item.data( "ui-selectmenu-item" ), event ); 11200 }, 11201 focus: function( event, ui ) { 11202 var item = ui.item.data( "ui-selectmenu-item" ); 11203 11204 // Prevent inital focus from firing and check if its a newly focused item 11205 if ( that.focusIndex != null && item.index !== that.focusIndex ) { 11206 that._trigger( "focus", event, { item: item } ); 11207 if ( !that.isOpen ) { 11208 that._select( item, event ); 11209 } 11210 } 11211 that.focusIndex = item.index; 11212 11213 that.button.attr( "aria-activedescendant", 11214 that.menuItems.eq( item.index ).attr( "id" ) ); 11215 } 11216 }) 11217 .menu( "instance" ); 11218 11219 // Adjust menu styles to dropdown 11220 this.menu 11221 .addClass( "ui-corner-bottom" ) 11222 .removeClass( "ui-corner-all" ); 11223 11224 // Don't close the menu on mouseleave 11225 this.menuInstance._off( this.menu, "mouseleave" ); 11226 11227 // Cancel the menu's collapseAll on document click 11228 this.menuInstance._closeOnDocumentClick = function() { 11229 return false; 11230 }; 11231 11232 // Selects often contain empty items, but never contain dividers 11233 this.menuInstance._isDivider = function() { 11234 return false; 11235 }; 11236 }, 11237 11238 refresh: function() { 11239 this._refreshMenu(); 11240 this._setText( this.buttonText, this._getSelectedItem().text() ); 11241 if ( !this.options.width ) { 11242 this._resizeButton(); 11243 } 11244 }, 11245 11246 _refreshMenu: function() { 11247 this.menu.empty(); 11248 11249 var item, 11250 options = this.element.find( "option" ); 11251 11252 if ( !options.length ) { 11253 return; 11254 } 11255 11256 this._parseOptions( options ); 11257 this._renderMenu( this.menu, this.items ); 11258 11259 this.menuInstance.refresh(); 11260 this.menuItems = this.menu.find( "li" ).not( ".ui-selectmenu-optgroup" ); 11261 11262 item = this._getSelectedItem(); 11263 11264 // Update the menu to have the correct item focused 11265 this.menuInstance.focus( null, item ); 11266 this._setAria( item.data( "ui-selectmenu-item" ) ); 11267 11268 // Set disabled state 11269 this._setOption( "disabled", this.element.prop( "disabled" ) ); 11270 }, 11271 11272 open: function( event ) { 11273 if ( this.options.disabled ) { 11274 return; 11275 } 11276 11277 // If this is the first time the menu is being opened, render the items 11278 if ( !this.menuItems ) { 11279 this._refreshMenu(); 11280 } else { 11281 11282 // Menu clears focus on close, reset focus to selected item 11283 this.menu.find( ".ui-state-focus" ).removeClass( "ui-state-focus" ); 11284 this.menuInstance.focus( null, this._getSelectedItem() ); 11285 } 11286 11287 this.isOpen = true; 11288 this._toggleAttr(); 11289 this._resizeMenu(); 11290 this._position(); 11291 11292 this._on( this.document, this._documentClick ); 11293 11294 this._trigger( "open", event ); 11295 }, 11296 11297 _position: function() { 11298 this.menuWrap.position( $.extend( { of: this.button }, this.options.position ) ); 11299 }, 11300 11301 close: function( event ) { 11302 if ( !this.isOpen ) { 11303 return; 11304 } 11305 11306 this.isOpen = false; 11307 this._toggleAttr(); 11308 11309 this.range = null; 11310 this._off( this.document ); 11311 11312 this._trigger( "close", event ); 11313 }, 11314 11315 widget: function() { 11316 return this.button; 11317 }, 11318 11319 menuWidget: function() { 11320 return this.menu; 11321 }, 11322 11323 _renderMenu: function( ul, items ) { 11324 var that = this, 11325 currentOptgroup = ""; 11326 11327 $.each( items, function( index, item ) { 11328 if ( item.optgroup !== currentOptgroup ) { 11329 $( "<li>", { 11330 "class": "ui-selectmenu-optgroup ui-menu-divider" + 11331 ( item.element.parent( "optgroup" ).prop( "disabled" ) ? 11332 " ui-state-disabled" : 11333 "" ), 11334 text: item.optgroup 11335 }) 11336 .appendTo( ul ); 11337 11338 currentOptgroup = item.optgroup; 11339 } 11340 11341 that._renderItemData( ul, item ); 11342 }); 11343 }, 11344 11345 _renderItemData: function( ul, item ) { 11346 return this._renderItem( ul, item ).data( "ui-selectmenu-item", item ); 11347 }, 11348 11349 _renderItem: function( ul, item ) { 11350 var li = $( "<li>" ); 11351 11352 if ( item.disabled ) { 11353 li.addClass( "ui-state-disabled" ); 11354 } 11355 this._setText( li, item.label ); 11356 11357 return li.appendTo( ul ); 11358 }, 11359 11360 _setText: function( element, value ) { 11361 if ( value ) { 11362 element.text( value ); 11363 } else { 11364 element.html( " " ); 11365 } 11366 }, 11367 11368 _move: function( direction, event ) { 11369 var item, next, 11370 filter = ".ui-menu-item"; 11371 11372 if ( this.isOpen ) { 11373 item = this.menuItems.eq( this.focusIndex ); 11374 } else { 11375 item = this.menuItems.eq( this.element[ 0 ].selectedIndex ); 11376 filter += ":not(.ui-state-disabled)"; 11377 } 11378 11379 if ( direction === "first" || direction === "last" ) { 11380 next = item[ direction === "first" ? "prevAll" : "nextAll" ]( filter ).eq( -1 ); 11381 } else { 11382 next = item[ direction + "All" ]( filter ).eq( 0 ); 11383 } 11384 11385 if ( next.length ) { 11386 this.menuInstance.focus( event, next ); 11387 } 11388 }, 11389 11390 _getSelectedItem: function() { 11391 return this.menuItems.eq( this.element[ 0 ].selectedIndex ); 11392 }, 11393 11394 _toggle: function( event ) { 11395 this[ this.isOpen ? "close" : "open" ]( event ); 11396 }, 11397 11398 _setSelection: function() { 11399 var selection; 11400 11401 if ( !this.range ) { 11402 return; 11403 } 11404 11405 if ( window.getSelection ) { 11406 selection = window.getSelection(); 11407 selection.removeAllRanges(); 11408 selection.addRange( this.range ); 11409 11410 // support: IE8 11411 } else { 11412 this.range.select(); 11413 } 11414 11415 // support: IE 11416 // Setting the text selection kills the button focus in IE, but 11417 // restoring the focus doesn't kill the selection. 11418 this.button.focus(); 11419 }, 11420 11421 _documentClick: { 11422 mousedown: function( event ) { 11423 if ( !this.isOpen ) { 11424 return; 11425 } 11426 11427 if ( !$( event.target ).closest( ".ui-selectmenu-menu, #" + this.ids.button ).length ) { 11428 this.close( event ); 11429 } 11430 } 11431 }, 11432 11433 _buttonEvents: { 11434 11435 // Prevent text selection from being reset when interacting with the selectmenu (#10144) 11436 mousedown: function() { 11437 var selection; 11438 11439 if ( window.getSelection ) { 11440 selection = window.getSelection(); 11441 if ( selection.rangeCount ) { 11442 this.range = selection.getRangeAt( 0 ); 11443 } 11444 11445 // support: IE8 11446 } else { 11447 this.range = document.selection.createRange(); 11448 } 11449 }, 11450 11451 click: function( event ) { 11452 this._setSelection(); 11453 this._toggle( event ); 11454 }, 11455 11456 keydown: function( event ) { 11457 var preventDefault = true; 11458 switch ( event.keyCode ) { 11459 case $.ui.keyCode.TAB: 11460 case $.ui.keyCode.ESCAPE: 11461 this.close( event ); 11462 preventDefault = false; 11463 break; 11464 case $.ui.keyCode.ENTER: 11465 if ( this.isOpen ) { 11466 this._selectFocusedItem( event ); 11467 } 11468 break; 11469 case $.ui.keyCode.UP: 11470 if ( event.altKey ) { 11471 this._toggle( event ); 11472 } else { 11473 this._move( "prev", event ); 11474 } 11475 break; 11476 case $.ui.keyCode.DOWN: 11477 if ( event.altKey ) { 11478 this._toggle( event ); 11479 } else { 11480 this._move( "next", event ); 11481 } 11482 break; 11483 case $.ui.keyCode.SPACE: 11484 if ( this.isOpen ) { 11485 this._selectFocusedItem( event ); 11486 } else { 11487 this._toggle( event ); 11488 } 11489 break; 11490 case $.ui.keyCode.LEFT: 11491 this._move( "prev", event ); 11492 break; 11493 case $.ui.keyCode.RIGHT: 11494 this._move( "next", event ); 11495 break; 11496 case $.ui.keyCode.HOME: 11497 case $.ui.keyCode.PAGE_UP: 11498 this._move( "first", event ); 11499 break; 11500 case $.ui.keyCode.END: 11501 case $.ui.keyCode.PAGE_DOWN: 11502 this._move( "last", event ); 11503 break; 11504 default: 11505 this.menu.trigger( event ); 11506 preventDefault = false; 11507 } 11508 11509 if ( preventDefault ) { 11510 event.preventDefault(); 11511 } 11512 } 11513 }, 11514 11515 _selectFocusedItem: function( event ) { 11516 var item = this.menuItems.eq( this.focusIndex ); 11517 if ( !item.hasClass( "ui-state-disabled" ) ) { 11518 this._select( item.data( "ui-selectmenu-item" ), event ); 11519 } 11520 }, 11521 11522 _select: function( item, event ) { 11523 var oldIndex = this.element[ 0 ].selectedIndex; 11524 11525 // Change native select element 11526 this.element[ 0 ].selectedIndex = item.index; 11527 this._setText( this.buttonText, item.label ); 11528 this._setAria( item ); 11529 this._trigger( "select", event, { item: item } ); 11530 11531 if ( item.index !== oldIndex ) { 11532 this._trigger( "change", event, { item: item } ); 11533 } 11534 11535 this.close( event ); 11536 }, 11537 11538 _setAria: function( item ) { 11539 var id = this.menuItems.eq( item.index ).attr( "id" ); 11540 11541 this.button.attr({ 11542 "aria-labelledby": id, 11543 "aria-activedescendant": id 11544 }); 11545 this.menu.attr( "aria-activedescendant", id ); 11546 }, 11547 11548 _setOption: function( key, value ) { 11549 if ( key === "icons" ) { 11550 this.button.find( "span.ui-icon" ) 11551 .removeClass( this.options.icons.button ) 11552 .addClass( value.button ); 11553 } 11554 11555 this._super( key, value ); 11556 11557 if ( key === "appendTo" ) { 11558 this.menuWrap.appendTo( this._appendTo() ); 11559 } 11560 11561 if ( key === "disabled" ) { 11562 this.menuInstance.option( "disabled", value ); 11563 this.button 11564 .toggleClass( "ui-state-disabled", value ) 11565 .attr( "aria-disabled", value ); 11566 11567 this.element.prop( "disabled", value ); 11568 if ( value ) { 11569 this.button.attr( "tabindex", -1 ); 11570 this.close(); 11571 } else { 11572 this.button.attr( "tabindex", 0 ); 11573 } 11574 } 11575 11576 if ( key === "width" ) { 11577 this._resizeButton(); 11578 } 11579 }, 11580 11581 _appendTo: function() { 11582 var element = this.options.appendTo; 11583 11584 if ( element ) { 11585 element = element.jquery || element.nodeType ? 11586 $( element ) : 11587 this.document.find( element ).eq( 0 ); 11588 } 11589 11590 if ( !element || !element[ 0 ] ) { 11591 element = this.element.closest( ".ui-front" ); 11592 } 11593 11594 if ( !element.length ) { 11595 element = this.document[ 0 ].body; 11596 } 11597 11598 return element; 11599 }, 11600 11601 _toggleAttr: function() { 11602 this.button 11603 .toggleClass( "ui-corner-top", this.isOpen ) 11604 .toggleClass( "ui-corner-all", !this.isOpen ) 11605 .attr( "aria-expanded", this.isOpen ); 11606 this.menuWrap.toggleClass( "ui-selectmenu-open", this.isOpen ); 11607 this.menu.attr( "aria-hidden", !this.isOpen ); 11608 }, 11609 11610 _resizeButton: function() { 11611 var width = this.options.width; 11612 11613 if ( !width ) { 11614 width = this.element.show().outerWidth(); 11615 this.element.hide(); 11616 } 11617 11618 this.button.outerWidth( width ); 11619 }, 11620 11621 _resizeMenu: function() { 11622 this.menu.outerWidth( Math.max( 11623 this.button.outerWidth(), 11624 11625 // support: IE10 11626 // IE10 wraps long text (possibly a rounding bug) 11627 // so we add 1px to avoid the wrapping 11628 this.menu.width( "" ).outerWidth() + 1 11629 ) ); 11630 }, 11631 11632 _getCreateOptions: function() { 11633 return { disabled: this.element.prop( "disabled" ) }; 11634 }, 11635 11636 _parseOptions: function( options ) { 11637 var data = []; 11638 options.each(function( index, item ) { 11639 var option = $( item ), 11640 optgroup = option.parent( "optgroup" ); 11641 data.push({ 11642 element: option, 11643 index: index, 11644 value: option.val(), 11645 label: option.text(), 11646 optgroup: optgroup.attr( "label" ) || "", 11647 disabled: optgroup.prop( "disabled" ) || option.prop( "disabled" ) 11648 }); 11649 }); 11650 this.items = data; 11651 }, 11652 11653 _destroy: function() { 11654 this.menuWrap.remove(); 11655 this.button.remove(); 11656 this.element.show(); 11657 this.element.removeUniqueId(); 11658 this.label.attr( "for", this.ids.element ); 11659 } 11660}); 11661 11662 11663/*! 11664 * jQuery UI Slider 1.11.4 11665 * http://jqueryui.com 11666 * 11667 * Copyright jQuery Foundation and other contributors 11668 * Released under the MIT license. 11669 * http://jquery.org/license 11670 * 11671 * http://api.jqueryui.com/slider/ 11672 */ 11673 11674 11675var slider = $.widget( "ui.slider", $.ui.mouse, { 11676 version: "1.11.4", 11677 widgetEventPrefix: "slide", 11678 11679 options: { 11680 animate: false, 11681 distance: 0, 11682 max: 100, 11683 min: 0, 11684 orientation: "horizontal", 11685 range: false, 11686 step: 1, 11687 value: 0, 11688 values: null, 11689 11690 // callbacks 11691 change: null, 11692 slide: null, 11693 start: null, 11694 stop: null 11695 }, 11696 11697 // number of pages in a slider 11698 // (how many times can you page up/down to go through the whole range) 11699 numPages: 5, 11700 11701 _create: function() { 11702 this._keySliding = false; 11703 this._mouseSliding = false; 11704 this._animateOff = true; 11705 this._handleIndex = null; 11706 this._detectOrientation(); 11707 this._mouseInit(); 11708 this._calculateNewMax(); 11709 11710 this.element 11711 .addClass( "ui-slider" + 11712 " ui-slider-" + this.orientation + 11713 " ui-widget" + 11714 " ui-widget-content" + 11715 " ui-corner-all"); 11716 11717 this._refresh(); 11718 this._setOption( "disabled", this.options.disabled ); 11719 11720 this._animateOff = false; 11721 }, 11722 11723 _refresh: function() { 11724 this._createRange(); 11725 this._createHandles(); 11726 this._setupEvents(); 11727 this._refreshValue(); 11728 }, 11729 11730 _createHandles: function() { 11731 var i, handleCount, 11732 options = this.options, 11733 existingHandles = this.element.find( ".ui-slider-handle" ).addClass( "ui-state-default ui-corner-all" ), 11734 handle = "<span class='ui-slider-handle ui-state-default ui-corner-all' tabindex='0'></span>", 11735 handles = []; 11736 11737 handleCount = ( options.values && options.values.length ) || 1; 11738 11739 if ( existingHandles.length > handleCount ) { 11740 existingHandles.slice( handleCount ).remove(); 11741 existingHandles = existingHandles.slice( 0, handleCount ); 11742 } 11743 11744 for ( i = existingHandles.length; i < handleCount; i++ ) { 11745 handles.push( handle ); 11746 } 11747 11748 this.handles = existingHandles.add( $( handles.join( "" ) ).appendTo( this.element ) ); 11749 11750 this.handle = this.handles.eq( 0 ); 11751 11752 this.handles.each(function( i ) { 11753 $( this ).data( "ui-slider-handle-index", i ); 11754 }); 11755 }, 11756 11757 _createRange: function() { 11758 var options = this.options, 11759 classes = ""; 11760 11761 if ( options.range ) { 11762 if ( options.range === true ) { 11763 if ( !options.values ) { 11764 options.values = [ this._valueMin(), this._valueMin() ]; 11765 } else if ( options.values.length && options.values.length !== 2 ) { 11766 options.values = [ options.values[0], options.values[0] ]; 11767 } else if ( $.isArray( options.values ) ) { 11768 options.values = options.values.slice(0); 11769 } 11770 } 11771 11772 if ( !this.range || !this.range.length ) { 11773 this.range = $( "<div></div>" ) 11774 .appendTo( this.element ); 11775 11776 classes = "ui-slider-range" + 11777 // note: this isn't the most fittingly semantic framework class for this element, 11778 // but worked best visually with a variety of themes 11779 " ui-widget-header ui-corner-all"; 11780 } else { 11781 this.range.removeClass( "ui-slider-range-min ui-slider-range-max" ) 11782 // Handle range switching from true to min/max 11783 .css({ 11784 "left": "", 11785 "bottom": "" 11786 }); 11787 } 11788 11789 this.range.addClass( classes + 11790 ( ( options.range === "min" || options.range === "max" ) ? " ui-slider-range-" + options.range : "" ) ); 11791 } else { 11792 if ( this.range ) { 11793 this.range.remove(); 11794 } 11795 this.range = null; 11796 } 11797 }, 11798 11799 _setupEvents: function() { 11800 this._off( this.handles ); 11801 this._on( this.handles, this._handleEvents ); 11802 this._hoverable( this.handles ); 11803 this._focusable( this.handles ); 11804 }, 11805 11806 _destroy: function() { 11807 this.handles.remove(); 11808 if ( this.range ) { 11809 this.range.remove(); 11810 } 11811 11812 this.element 11813 .removeClass( "ui-slider" + 11814 " ui-slider-horizontal" + 11815 " ui-slider-vertical" + 11816 " ui-widget" + 11817 " ui-widget-content" + 11818 " ui-corner-all" ); 11819 11820 this._mouseDestroy(); 11821 }, 11822 11823 _mouseCapture: function( event ) { 11824 var position, normValue, distance, closestHandle, index, allowed, offset, mouseOverHandle, 11825 that = this, 11826 o = this.options; 11827 11828 if ( o.disabled ) { 11829 return false; 11830 } 11831 11832 this.elementSize = { 11833 width: this.element.outerWidth(), 11834 height: this.element.outerHeight() 11835 }; 11836 this.elementOffset = this.element.offset(); 11837 11838 position = { x: event.pageX, y: event.pageY }; 11839 normValue = this._normValueFromMouse( position ); 11840 distance = this._valueMax() - this._valueMin() + 1; 11841 this.handles.each(function( i ) { 11842 var thisDistance = Math.abs( normValue - that.values(i) ); 11843 if (( distance > thisDistance ) || 11844 ( distance === thisDistance && 11845 (i === that._lastChangedValue || that.values(i) === o.min ))) { 11846 distance = thisDistance; 11847 closestHandle = $( this ); 11848 index = i; 11849 } 11850 }); 11851 11852 allowed = this._start( event, index ); 11853 if ( allowed === false ) { 11854 return false; 11855 } 11856 this._mouseSliding = true; 11857 11858 this._handleIndex = index; 11859 11860 closestHandle 11861 .addClass( "ui-state-active" ) 11862 .focus(); 11863 11864 offset = closestHandle.offset();
vendor: 4,641 bytes, lines 11865-12037
11865 mouseOverHandle = !$( event.target ).parents().addBack().is( ".ui-slider-handle" ); 11866 this._clickOffset = mouseOverHandle ? { left: 0, top: 0 } : { 11867 left: event.pageX - offset.left - ( closestHandle.width() / 2 ), 11868 top: event.pageY - offset.top - 11869 ( closestHandle.height() / 2 ) - 11870 ( parseInt( closestHandle.css("borderTopWidth"), 10 ) || 0 ) - 11871 ( parseInt( closestHandle.css("borderBottomWidth"), 10 ) || 0) + 11872 ( parseInt( closestHandle.css("marginTop"), 10 ) || 0) 11873 }; 11874 11875 if ( !this.handles.hasClass( "ui-state-hover" ) ) { 11876 this._slide( event, index, normValue ); 11877 } 11878 this._animateOff = true; 11879 return true; 11880 }, 11881 11882 _mouseStart: function() { 11883 return true; 11884 }, 11885 11886 _mouseDrag: function( event ) { 11887 var position = { x: event.pageX, y: event.pageY }, 11888 normValue = this._normValueFromMouse( position ); 11889 11890 this._slide( event, this._handleIndex, normValue ); 11891 11892 return false; 11893 }, 11894 11895 _mouseStop: function( event ) { 11896 this.handles.removeClass( "ui-state-active" ); 11897 this._mouseSliding = false; 11898 11899 this._stop( event, this._handleIndex ); 11900 this._change( event, this._handleIndex ); 11901 11902 this._handleIndex = null; 11903 this._clickOffset = null; 11904 this._animateOff = false; 11905 11906 return false; 11907 }, 11908 11909 _detectOrientation: function() { 11910 this.orientation = ( this.options.orientation === "vertical" ) ? "vertical" : "horizontal"; 11911 }, 11912 11913 _normValueFromMouse: function( position ) { 11914 var pixelTotal, 11915 pixelMouse, 11916 percentMouse, 11917 valueTotal, 11918 valueMouse; 11919 11920 if ( this.orientation === "horizontal" ) { 11921 pixelTotal = this.elementSize.width; 11922 pixelMouse = position.x - this.elementOffset.left - ( this._clickOffset ? this._clickOffset.left : 0 ); 11923 } else { 11924 pixelTotal = this.elementSize.height; 11925 pixelMouse = position.y - this.elementOffset.top - ( this._clickOffset ? this._clickOffset.top : 0 ); 11926 } 11927 11928 percentMouse = ( pixelMouse / pixelTotal ); 11929 if ( percentMouse > 1 ) { 11930 percentMouse = 1; 11931 } 11932 if ( percentMouse < 0 ) { 11933 percentMouse = 0; 11934 } 11935 if ( this.orientation === "vertical" ) { 11936 percentMouse = 1 - percentMouse; 11937 } 11938 11939 valueTotal = this._valueMax() - this._valueMin(); 11940 valueMouse = this._valueMin() + percentMouse * valueTotal; 11941 11942 return this._trimAlignValue( valueMouse ); 11943 }, 11944 11945 _start: function( event, index ) { 11946 var uiHash = { 11947 handle: this.handles[ index ], 11948 value: this.value() 11949 }; 11950 if ( this.options.values && this.options.values.length ) { 11951 uiHash.value = this.values( index ); 11952 uiHash.values = this.values(); 11953 } 11954 return this._trigger( "start", event, uiHash ); 11955 }, 11956 11957 _slide: function( event, index, newVal ) { 11958 var otherVal, 11959 newValues, 11960 allowed; 11961 11962 if ( this.options.values && this.options.values.length ) { 11963 otherVal = this.values( index ? 0 : 1 ); 11964 11965 if ( ( this.options.values.length === 2 && this.options.range === true ) && 11966 ( ( index === 0 && newVal > otherVal) || ( index === 1 && newVal < otherVal ) ) 11967 ) { 11968 newVal = otherVal; 11969 } 11970 11971 if ( newVal !== this.values( index ) ) { 11972 newValues = this.values(); 11973 newValues[ index ] = newVal; 11974 // A slide can be canceled by returning false from the slide callback 11975 allowed = this._trigger( "slide", event, { 11976 handle: this.handles[ index ], 11977 value: newVal, 11978 values: newValues 11979 } ); 11980 otherVal = this.values( index ? 0 : 1 ); 11981 if ( allowed !== false ) { 11982 this.values( index, newVal ); 11983 } 11984 } 11985 } else { 11986 if ( newVal !== this.value() ) { 11987 // A slide can be canceled by returning false from the slide callback 11988 allowed = this._trigger( "slide", event, { 11989 handle: this.handles[ index ], 11990 value: newVal 11991 } ); 11992 if ( allowed !== false ) { 11993 this.value( newVal ); 11994 } 11995 } 11996 } 11997 }, 11998 11999 _stop: function( event, index ) { 12000 var uiHash = { 12001 handle: this.handles[ index ], 12002 value: this.value() 12003 }; 12004 if ( this.options.values && this.options.values.length ) { 12005 uiHash.value = this.values( index ); 12006 uiHash.values = this.values(); 12007 } 12008 12009 this._trigger( "stop", event, uiHash ); 12010 }, 12011 12012 _change: function( event, index ) { 12013 if ( !this._keySliding && !this._mouseSliding ) { 12014 var uiHash = { 12015 handle: this.handles[ index ], 12016 value: this.value() 12017 }; 12018 if ( this.options.values && this.options.values.length ) { 12019 uiHash.value = this.values( index ); 12020 uiHash.values = this.values(); 12021 } 12022 12023 //store the last changed value index for reference when handles overlap 12024 this._lastChangedValue = index; 12025 12026 this._trigger( "change", event, uiHash ); 12027 } 12028 }, 12029 12030 value: function( newValue ) { 12031 if ( arguments.length ) { 12032 this.options.value = this._trimAlignValue( newValue ); 12033 this._refreshValue(); 12034 this._change( null, 0 ); 12035 return; 12036 } 12037
vendor: 34,569 bytes, lines 12038-13336
12038 return this._value(); 12039 }, 12040 12041 values: function( index, newValue ) { 12042 var vals, 12043 newValues, 12044 i; 12045 12046 if ( arguments.length > 1 ) { 12047 this.options.values[ index ] = this._trimAlignValue( newValue ); 12048 this._refreshValue(); 12049 this._change( null, index ); 12050 return; 12051 } 12052 12053 if ( arguments.length ) { 12054 if ( $.isArray( arguments[ 0 ] ) ) { 12055 vals = this.options.values; 12056 newValues = arguments[ 0 ]; 12057 for ( i = 0; i < vals.length; i += 1 ) { 12058 vals[ i ] = this._trimAlignValue( newValues[ i ] ); 12059 this._change( null, i ); 12060 } 12061 this._refreshValue(); 12062 } else { 12063 if ( this.options.values && this.options.values.length ) { 12064 return this._values( index ); 12065 } else { 12066 return this.value(); 12067 } 12068 } 12069 } else { 12070 return this._values(); 12071 } 12072 }, 12073 12074 _setOption: function( key, value ) { 12075 var i, 12076 valsLength = 0; 12077 12078 if ( key === "range" && this.options.range === true ) { 12079 if ( value === "min" ) { 12080 this.options.value = this._values( 0 ); 12081 this.options.values = null; 12082 } else if ( value === "max" ) { 12083 this.options.value = this._values( this.options.values.length - 1 ); 12084 this.options.values = null; 12085 } 12086 } 12087 12088 if ( $.isArray( this.options.values ) ) { 12089 valsLength = this.options.values.length; 12090 } 12091 12092 if ( key === "disabled" ) { 12093 this.element.toggleClass( "ui-state-disabled", !!value ); 12094 } 12095 12096 this._super( key, value ); 12097 12098 switch ( key ) { 12099 case "orientation": 12100 this._detectOrientation(); 12101 this.element 12102 .removeClass( "ui-slider-horizontal ui-slider-vertical" ) 12103 .addClass( "ui-slider-" + this.orientation ); 12104 this._refreshValue(); 12105 12106 // Reset positioning from previous orientation 12107 this.handles.css( value === "horizontal" ? "bottom" : "left", "" ); 12108 break; 12109 case "value": 12110 this._animateOff = true; 12111 this._refreshValue(); 12112 this._change( null, 0 ); 12113 this._animateOff = false; 12114 break; 12115 case "values": 12116 this._animateOff = true; 12117 this._refreshValue(); 12118 for ( i = 0; i < valsLength; i += 1 ) { 12119 this._change( null, i ); 12120 } 12121 this._animateOff = false; 12122 break; 12123 case "step": 12124 case "min": 12125 case "max": 12126 this._animateOff = true; 12127 this._calculateNewMax(); 12128 this._refreshValue(); 12129 this._animateOff = false; 12130 break; 12131 case "range": 12132 this._animateOff = true; 12133 this._refresh(); 12134 this._animateOff = false; 12135 break; 12136 } 12137 }, 12138 12139 //internal value getter 12140 // _value() returns value trimmed by min and max, aligned by step 12141 _value: function() { 12142 var val = this.options.value; 12143 val = this._trimAlignValue( val ); 12144 12145 return val; 12146 }, 12147 12148 //internal values getter 12149 // _values() returns array of values trimmed by min and max, aligned by step 12150 // _values( index ) returns single value trimmed by min and max, aligned by step 12151 _values: function( index ) { 12152 var val, 12153 vals, 12154 i; 12155 12156 if ( arguments.length ) { 12157 val = this.options.values[ index ]; 12158 val = this._trimAlignValue( val ); 12159 12160 return val; 12161 } else if ( this.options.values && this.options.values.length ) { 12162 // .slice() creates a copy of the array 12163 // this copy gets trimmed by min and max and then returned 12164 vals = this.options.values.slice(); 12165 for ( i = 0; i < vals.length; i += 1) { 12166 vals[ i ] = this._trimAlignValue( vals[ i ] ); 12167 } 12168 12169 return vals; 12170 } else { 12171 return []; 12172 } 12173 }, 12174 12175 // returns the step-aligned value that val is closest to, between (inclusive) min and max 12176 _trimAlignValue: function( val ) { 12177 if ( val <= this._valueMin() ) { 12178 return this._valueMin(); 12179 } 12180 if ( val >= this._valueMax() ) { 12181 return this._valueMax(); 12182 } 12183 var step = ( this.options.step > 0 ) ? this.options.step : 1, 12184 valModStep = (val - this._valueMin()) % step, 12185 alignValue = val - valModStep; 12186 12187 if ( Math.abs(valModStep) * 2 >= step ) { 12188 alignValue += ( valModStep > 0 ) ? step : ( -step ); 12189 } 12190 12191 // Since JavaScript has problems with large floats, round 12192 // the final value to 5 digits after the decimal point (see #4124) 12193 return parseFloat( alignValue.toFixed(5) ); 12194 }, 12195 12196 _calculateNewMax: function() { 12197 var max = this.options.max, 12198 min = this._valueMin(), 12199 step = this.options.step, 12200 aboveMin = Math.floor( ( +( max - min ).toFixed( this._precision() ) ) / step ) * step; 12201 max = aboveMin + min; 12202 this.max = parseFloat( max.toFixed( this._precision() ) ); 12203 }, 12204 12205 _precision: function() { 12206 var precision = this._precisionOf( this.options.step ); 12207 if ( this.options.min !== null ) { 12208 precision = Math.max( precision, this._precisionOf( this.options.min ) ); 12209 } 12210 return precision; 12211 }, 12212 12213 _precisionOf: function( num ) { 12214 var str = num.toString(), 12215 decimal = str.indexOf( "." ); 12216 return decimal === -1 ? 0 : str.length - decimal - 1; 12217 }, 12218 12219 _valueMin: function() { 12220 return this.options.min; 12221 }, 12222 12223 _valueMax: function() { 12224 return this.max; 12225 }, 12226 12227 _refreshValue: function() { 12228 var lastValPercent, valPercent, value, valueMin, valueMax, 12229 oRange = this.options.range, 12230 o = this.options, 12231 that = this, 12232 animate = ( !this._animateOff ) ? o.animate : false, 12233 _set = {}; 12234 12235 if ( this.options.values && this.options.values.length ) { 12236 this.handles.each(function( i ) { 12237 valPercent = ( that.values(i) - that._valueMin() ) / ( that._valueMax() - that._valueMin() ) * 100; 12238 _set[ that.orientation === "horizontal" ? "left" : "bottom" ] = valPercent + "%"; 12239 $( this ).stop( 1, 1 )[ animate ? "animate" : "css" ]( _set, o.animate ); 12240 if ( that.options.range === true ) { 12241 if ( that.orientation === "horizontal" ) { 12242 if ( i === 0 ) { 12243 that.range.stop( 1, 1 )[ animate ? "animate" : "css" ]( { left: valPercent + "%" }, o.animate ); 12244 } 12245 if ( i === 1 ) { 12246 that.range[ animate ? "animate" : "css" ]( { width: ( valPercent - lastValPercent ) + "%" }, { queue: false, duration: o.animate } ); 12247 } 12248 } else { 12249 if ( i === 0 ) { 12250 that.range.stop( 1, 1 )[ animate ? "animate" : "css" ]( { bottom: ( valPercent ) + "%" }, o.animate ); 12251 } 12252 if ( i === 1 ) { 12253 that.range[ animate ? "animate" : "css" ]( { height: ( valPercent - lastValPercent ) + "%" }, { queue: false, duration: o.animate } ); 12254 } 12255 } 12256 } 12257 lastValPercent = valPercent; 12258 }); 12259 } else { 12260 value = this.value(); 12261 valueMin = this._valueMin(); 12262 valueMax = this._valueMax(); 12263 valPercent = ( valueMax !== valueMin ) ? 12264 ( value - valueMin ) / ( valueMax - valueMin ) * 100 : 12265 0; 12266 _set[ this.orientation === "horizontal" ? "left" : "bottom" ] = valPercent + "%"; 12267 this.handle.stop( 1, 1 )[ animate ? "animate" : "css" ]( _set, o.animate ); 12268 12269 if ( oRange === "min" && this.orientation === "horizontal" ) { 12270 this.range.stop( 1, 1 )[ animate ? "animate" : "css" ]( { width: valPercent + "%" }, o.animate ); 12271 } 12272 if ( oRange === "max" && this.orientation === "horizontal" ) { 12273 this.range[ animate ? "animate" : "css" ]( { width: ( 100 - valPercent ) + "%" }, { queue: false, duration: o.animate } ); 12274 } 12275 if ( oRange === "min" && this.orientation === "vertical" ) { 12276 this.range.stop( 1, 1 )[ animate ? "animate" : "css" ]( { height: valPercent + "%" }, o.animate ); 12277 } 12278 if ( oRange === "max" && this.orientation === "vertical" ) { 12279 this.range[ animate ? "animate" : "css" ]( { height: ( 100 - valPercent ) + "%" }, { queue: false, duration: o.animate } ); 12280 } 12281 } 12282 }, 12283 12284 _handleEvents: { 12285 keydown: function( event ) { 12286 var allowed, curVal, newVal, step, 12287 index = $( event.target ).data( "ui-slider-handle-index" ); 12288 12289 switch ( event.keyCode ) { 12290 case $.ui.keyCode.HOME: 12291 case $.ui.keyCode.END: 12292 case $.ui.keyCode.PAGE_UP: 12293 case $.ui.keyCode.PAGE_DOWN: 12294 case $.ui.keyCode.UP: 12295 case $.ui.keyCode.RIGHT: 12296 case $.ui.keyCode.DOWN: 12297 case $.ui.keyCode.LEFT: 12298 event.preventDefault(); 12299 if ( !this._keySliding ) { 12300 this._keySliding = true; 12301 $( event.target ).addClass( "ui-state-active" ); 12302 allowed = this._start( event, index ); 12303 if ( allowed === false ) { 12304 return; 12305 } 12306 } 12307 break; 12308 } 12309 12310 step = this.options.step; 12311 if ( this.options.values && this.options.values.length ) { 12312 curVal = newVal = this.values( index ); 12313 } else { 12314 curVal = newVal = this.value(); 12315 } 12316 12317 switch ( event.keyCode ) { 12318 case $.ui.keyCode.HOME: 12319 newVal = this._valueMin(); 12320 break; 12321 case $.ui.keyCode.END: 12322 newVal = this._valueMax(); 12323 break; 12324 case $.ui.keyCode.PAGE_UP: 12325 newVal = this._trimAlignValue( 12326 curVal + ( ( this._valueMax() - this._valueMin() ) / this.numPages ) 12327 ); 12328 break; 12329 case $.ui.keyCode.PAGE_DOWN: 12330 newVal = this._trimAlignValue( 12331 curVal - ( (this._valueMax() - this._valueMin()) / this.numPages ) ); 12332 break; 12333 case $.ui.keyCode.UP: 12334 case $.ui.keyCode.RIGHT: 12335 if ( curVal === this._valueMax() ) { 12336 return; 12337 } 12338 newVal = this._trimAlignValue( curVal + step ); 12339 break; 12340 case $.ui.keyCode.DOWN: 12341 case $.ui.keyCode.LEFT: 12342 if ( curVal === this._valueMin() ) { 12343 return; 12344 } 12345 newVal = this._trimAlignValue( curVal - step ); 12346 break; 12347 } 12348 12349 this._slide( event, index, newVal ); 12350 }, 12351 keyup: function( event ) { 12352 var index = $( event.target ).data( "ui-slider-handle-index" ); 12353 12354 if ( this._keySliding ) { 12355 this._keySliding = false; 12356 this._stop( event, index ); 12357 this._change( event, index ); 12358 $( event.target ).removeClass( "ui-state-active" ); 12359 } 12360 } 12361 } 12362}); 12363 12364 12365/*! 12366 * jQuery UI Spinner 1.11.4 12367 * http://jqueryui.com 12368 * 12369 * Copyright jQuery Foundation and other contributors 12370 * Released under the MIT license. 12371 * http://jquery.org/license 12372 * 12373 * http://api.jqueryui.com/spinner/ 12374 */ 12375 12376 12377function spinner_modifier( fn ) { 12378 return function() { 12379 var previous = this.element.val(); 12380 fn.apply( this, arguments ); 12381 this._refresh(); 12382 if ( previous !== this.element.val() ) { 12383 this._trigger( "change" ); 12384 } 12385 }; 12386} 12387 12388var spinner = $.widget( "ui.spinner", { 12389 version: "1.11.4", 12390 defaultElement: "<input>", 12391 widgetEventPrefix: "spin", 12392 options: { 12393 culture: null, 12394 icons: { 12395 down: "ui-icon-triangle-1-s", 12396 up: "ui-icon-triangle-1-n" 12397 }, 12398 incremental: true, 12399 max: null, 12400 min: null, 12401 numberFormat: null, 12402 page: 10, 12403 step: 1, 12404 12405 change: null, 12406 spin: null, 12407 start: null, 12408 stop: null 12409 }, 12410 12411 _create: function() { 12412 // handle string values that need to be parsed 12413 this._setOption( "max", this.options.max ); 12414 this._setOption( "min", this.options.min ); 12415 this._setOption( "step", this.options.step ); 12416 12417 // Only format if there is a value, prevents the field from being marked 12418 // as invalid in Firefox, see #9573. 12419 if ( this.value() !== "" ) { 12420 // Format the value, but don't constrain. 12421 this._value( this.element.val(), true ); 12422 } 12423 12424 this._draw(); 12425 this._on( this._events ); 12426 this._refresh(); 12427 12428 // turning off autocomplete prevents the browser from remembering the 12429 // value when navigating through history, so we re-enable autocomplete 12430 // if the page is unloaded before the widget is destroyed. #7790 12431 this._on( this.window, { 12432 beforeunload: function() { 12433 this.element.removeAttr( "autocomplete" ); 12434 } 12435 }); 12436 }, 12437 12438 _getCreateOptions: function() { 12439 var options = {}, 12440 element = this.element; 12441 12442 $.each( [ "min", "max", "step" ], function( i, option ) { 12443 var value = element.attr( option ); 12444 if ( value !== undefined && value.length ) { 12445 options[ option ] = value; 12446 } 12447 }); 12448 12449 return options; 12450 }, 12451 12452 _events: { 12453 keydown: function( event ) { 12454 if ( this._start( event ) && this._keydown( event ) ) { 12455 event.preventDefault(); 12456 } 12457 }, 12458 keyup: "_stop", 12459 focus: function() { 12460 this.previous = this.element.val(); 12461 }, 12462 blur: function( event ) { 12463 if ( this.cancelBlur ) { 12464 delete this.cancelBlur; 12465 return; 12466 } 12467 12468 this._stop(); 12469 this._refresh(); 12470 if ( this.previous !== this.element.val() ) { 12471 this._trigger( "change", event ); 12472 } 12473 }, 12474 mousewheel: function( event, delta ) { 12475 if ( !delta ) { 12476 return; 12477 } 12478 if ( !this.spinning && !this._start( event ) ) { 12479 return false; 12480 } 12481 12482 this._spin( (delta > 0 ? 1 : -1) * this.options.step, event ); 12483 clearTimeout( this.mousewheelTimer ); 12484 this.mousewheelTimer = this._delay(function() { 12485 if ( this.spinning ) { 12486 this._stop( event ); 12487 } 12488 }, 100 ); 12489 event.preventDefault(); 12490 }, 12491 "mousedown .ui-spinner-button": function( event ) { 12492 var previous; 12493 12494 // We never want the buttons to have focus; whenever the user is 12495 // interacting with the spinner, the focus should be on the input. 12496 // If the input is focused then this.previous is properly set from 12497 // when the input first received focus. If the input is not focused 12498 // then we need to set this.previous based on the value before spinning. 12499 previous = this.element[0] === this.document[0].activeElement ? 12500 this.previous : this.element.val(); 12501 function checkFocus() { 12502 var isActive = this.element[0] === this.document[0].activeElement; 12503 if ( !isActive ) { 12504 this.element.focus(); 12505 this.previous = previous; 12506 // support: IE 12507 // IE sets focus asynchronously, so we need to check if focus 12508 // moved off of the input because the user clicked on the button. 12509 this._delay(function() { 12510 this.previous = previous; 12511 }); 12512 } 12513 } 12514 12515 // ensure focus is on (or stays on) the text field 12516 event.preventDefault(); 12517 checkFocus.call( this ); 12518 12519 // support: IE 12520 // IE doesn't prevent moving focus even with event.preventDefault() 12521 // so we set a flag to know when we should ignore the blur event 12522 // and check (again) if focus moved off of the input. 12523 this.cancelBlur = true; 12524 this._delay(function() { 12525 delete this.cancelBlur; 12526 checkFocus.call( this ); 12527 }); 12528 12529 if ( this._start( event ) === false ) { 12530 return; 12531 } 12532 12533 this._repeat( null, $( event.currentTarget ).hasClass( "ui-spinner-up" ) ? 1 : -1, event ); 12534 }, 12535 "mouseup .ui-spinner-button": "_stop", 12536 "mouseenter .ui-spinner-button": function( event ) { 12537 // button will add ui-state-active if mouse was down while mouseleave and kept down 12538 if ( !$( event.currentTarget ).hasClass( "ui-state-active" ) ) { 12539 return; 12540 } 12541 12542 if ( this._start( event ) === false ) { 12543 return false; 12544 } 12545 this._repeat( null, $( event.currentTarget ).hasClass( "ui-spinner-up" ) ? 1 : -1, event ); 12546 }, 12547 // TODO: do we really want to consider this a stop? 12548 // shouldn't we just stop the repeater and wait until mouseup before 12549 // we trigger the stop event? 12550 "mouseleave .ui-spinner-button": "_stop" 12551 }, 12552 12553 _draw: function() { 12554 var uiSpinner = this.uiSpinner = this.element 12555 .addClass( "ui-spinner-input" ) 12556 .attr( "autocomplete", "off" ) 12557 .wrap( this._uiSpinnerHtml() ) 12558 .parent() 12559 // add buttons 12560 .append( this._buttonHtml() ); 12561 12562 this.element.attr( "role", "spinbutton" ); 12563 12564 // button bindings 12565 this.buttons = uiSpinner.find( ".ui-spinner-button" ) 12566 .attr( "tabIndex", -1 ) 12567 .button() 12568 .removeClass( "ui-corner-all" ); 12569 12570 // IE 6 doesn't understand height: 50% for the buttons 12571 // unless the wrapper has an explicit height 12572 if ( this.buttons.height() > Math.ceil( uiSpinner.height() * 0.5 ) && 12573 uiSpinner.height() > 0 ) { 12574 uiSpinner.height( uiSpinner.height() ); 12575 } 12576 12577 // disable spinner if element was already disabled 12578 if ( this.options.disabled ) { 12579 this.disable(); 12580 } 12581 }, 12582 12583 _keydown: function( event ) { 12584 var options = this.options, 12585 keyCode = $.ui.keyCode; 12586 12587 switch ( event.keyCode ) { 12588 case keyCode.UP: 12589 this._repeat( null, 1, event ); 12590 return true; 12591 case keyCode.DOWN: 12592 this._repeat( null, -1, event ); 12593 return true; 12594 case keyCode.PAGE_UP: 12595 this._repeat( null, options.page, event ); 12596 return true; 12597 case keyCode.PAGE_DOWN: 12598 this._repeat( null, -options.page, event ); 12599 return true; 12600 } 12601 12602 return false; 12603 }, 12604 12605 _uiSpinnerHtml: function() { 12606 return "<span class='ui-spinner ui-widget ui-widget-content ui-corner-all'></span>"; 12607 }, 12608 12609 _buttonHtml: function() { 12610 return "" + 12611 "<a class='ui-spinner-button ui-spinner-up ui-corner-tr'>" + 12612 "<span class='ui-icon " + this.options.icons.up + "'>▲</span>" + 12613 "</a>" + 12614 "<a class='ui-spinner-button ui-spinner-down ui-corner-br'>" + 12615 "<span class='ui-icon " + this.options.icons.down + "'>▼</span>" + 12616 "</a>"; 12617 }, 12618 12619 _start: function( event ) { 12620 if ( !this.spinning && this._trigger( "start", event ) === false ) { 12621 return false; 12622 } 12623 12624 if ( !this.counter ) { 12625 this.counter = 1; 12626 } 12627 this.spinning = true; 12628 return true; 12629 }, 12630 12631 _repeat: function( i, steps, event ) { 12632 i = i || 500; 12633 12634 clearTimeout( this.timer ); 12635 this.timer = this._delay(function() { 12636 this._repeat( 40, steps, event ); 12637 }, i ); 12638 12639 this._spin( steps * this.options.step, event ); 12640 }, 12641 12642 _spin: function( step, event ) { 12643 var value = this.value() || 0; 12644 12645 if ( !this.counter ) { 12646 this.counter = 1; 12647 } 12648 12649 value = this._adjustValue( value + step * this._increment( this.counter ) ); 12650 12651 if ( !this.spinning || this._trigger( "spin", event, { value: value } ) !== false) { 12652 this._value( value ); 12653 this.counter++; 12654 } 12655 }, 12656 12657 _increment: function( i ) { 12658 var incremental = this.options.incremental; 12659 12660 if ( incremental ) { 12661 return $.isFunction( incremental ) ? 12662 incremental( i ) : 12663 Math.floor( i * i * i / 50000 - i * i / 500 + 17 * i / 200 + 1 ); 12664 } 12665 12666 return 1; 12667 }, 12668 12669 _precision: function() { 12670 var precision = this._precisionOf( this.options.step ); 12671 if ( this.options.min !== null ) { 12672 precision = Math.max( precision, this._precisionOf( this.options.min ) ); 12673 } 12674 return precision; 12675 }, 12676 12677 _precisionOf: function( num ) { 12678 var str = num.toString(), 12679 decimal = str.indexOf( "." ); 12680 return decimal === -1 ? 0 : str.length - decimal - 1; 12681 }, 12682 12683 _adjustValue: function( value ) { 12684 var base, aboveMin, 12685 options = this.options; 12686 12687 // make sure we're at a valid step 12688 // - find out where we are relative to the base (min or 0) 12689 base = options.min !== null ? options.min : 0; 12690 aboveMin = value - base; 12691 // - round to the nearest step 12692 aboveMin = Math.round(aboveMin / options.step) * options.step; 12693 // - rounding is based on 0, so adjust back to our base 12694 value = base + aboveMin; 12695 12696 // fix precision from bad JS floating point math 12697 value = parseFloat( value.toFixed( this._precision() ) ); 12698 12699 // clamp the value 12700 if ( options.max !== null && value > options.max) { 12701 return options.max; 12702 } 12703 if ( options.min !== null && value < options.min ) { 12704 return options.min; 12705 } 12706 12707 return value; 12708 }, 12709 12710 _stop: function( event ) { 12711 if ( !this.spinning ) { 12712 return; 12713 } 12714 12715 clearTimeout( this.timer ); 12716 clearTimeout( this.mousewheelTimer ); 12717 this.counter = 0; 12718 this.spinning = false; 12719 this._trigger( "stop", event ); 12720 }, 12721 12722 _setOption: function( key, value ) { 12723 if ( key === "culture" || key === "numberFormat" ) { 12724 var prevValue = this._parse( this.element.val() ); 12725 this.options[ key ] = value; 12726 this.element.val( this._format( prevValue ) ); 12727 return; 12728 } 12729 12730 if ( key === "max" || key === "min" || key === "step" ) { 12731 if ( typeof value === "string" ) { 12732 value = this._parse( value ); 12733 } 12734 } 12735 if ( key === "icons" ) { 12736 this.buttons.first().find( ".ui-icon" ) 12737 .removeClass( this.options.icons.up ) 12738 .addClass( value.up ); 12739 this.buttons.last().find( ".ui-icon" ) 12740 .removeClass( this.options.icons.down ) 12741 .addClass( value.down ); 12742 } 12743 12744 this._super( key, value ); 12745 12746 if ( key === "disabled" ) { 12747 this.widget().toggleClass( "ui-state-disabled", !!value ); 12748 this.element.prop( "disabled", !!value ); 12749 this.buttons.button( value ? "disable" : "enable" ); 12750 } 12751 }, 12752 12753 _setOptions: spinner_modifier(function( options ) { 12754 this._super( options ); 12755 }), 12756 12757 _parse: function( val ) { 12758 if ( typeof val === "string" && val !== "" ) { 12759 val = window.Globalize && this.options.numberFormat ? 12760 Globalize.parseFloat( val, 10, this.options.culture ) : +val; 12761 } 12762 return val === "" || isNaN( val ) ? null : val; 12763 }, 12764 12765 _format: function( value ) { 12766 if ( value === "" ) { 12767 return ""; 12768 } 12769 return window.Globalize && this.options.numberFormat ? 12770 Globalize.format( value, this.options.numberFormat, this.options.culture ) : 12771 value; 12772 }, 12773 12774 _refresh: function() { 12775 this.element.attr({ 12776 "aria-valuemin": this.options.min, 12777 "aria-valuemax": this.options.max, 12778 // TODO: what should we do with values that can't be parsed? 12779 "aria-valuenow": this._parse( this.element.val() ) 12780 }); 12781 }, 12782 12783 isValid: function() { 12784 var value = this.value(); 12785 12786 // null is invalid 12787 if ( value === null ) { 12788 return false; 12789 } 12790 12791 // if value gets adjusted, it's invalid 12792 return value === this._adjustValue( value ); 12793 }, 12794 12795 // update the value without triggering change 12796 _value: function( value, allowAny ) { 12797 var parsed; 12798 if ( value !== "" ) { 12799 parsed = this._parse( value ); 12800 if ( parsed !== null ) { 12801 if ( !allowAny ) { 12802 parsed = this._adjustValue( parsed ); 12803 } 12804 value = this._format( parsed ); 12805 } 12806 } 12807 this.element.val( value ); 12808 this._refresh(); 12809 }, 12810 12811 _destroy: function() { 12812 this.element 12813 .removeClass( "ui-spinner-input" ) 12814 .prop( "disabled", false ) 12815 .removeAttr( "autocomplete" ) 12816 .removeAttr( "role" ) 12817 .removeAttr( "aria-valuemin" ) 12818 .removeAttr( "aria-valuemax" ) 12819 .removeAttr( "aria-valuenow" ); 12820 this.uiSpinner.replaceWith( this.element ); 12821 }, 12822 12823 stepUp: spinner_modifier(function( steps ) { 12824 this._stepUp( steps ); 12825 }), 12826 _stepUp: function( steps ) { 12827 if ( this._start() ) { 12828 this._spin( (steps || 1) * this.options.step ); 12829 this._stop(); 12830 } 12831 }, 12832 12833 stepDown: spinner_modifier(function( steps ) { 12834 this._stepDown( steps ); 12835 }), 12836 _stepDown: function( steps ) { 12837 if ( this._start() ) { 12838 this._spin( (steps || 1) * -this.options.step ); 12839 this._stop(); 12840 } 12841 }, 12842 12843 pageUp: spinner_modifier(function( pages ) { 12844 this._stepUp( (pages || 1) * this.options.page ); 12845 }), 12846 12847 pageDown: spinner_modifier(function( pages ) { 12848 this._stepDown( (pages || 1) * this.options.page ); 12849 }), 12850 12851 value: function( newVal ) { 12852 if ( !arguments.length ) { 12853 return this._parse( this.element.val() ); 12854 } 12855 spinner_modifier( this._value ).call( this, newVal ); 12856 }, 12857 12858 widget: function() { 12859 return this.uiSpinner; 12860 } 12861}); 12862 12863 12864/*! 12865 * jQuery UI Tabs 1.11.4 12866 * http://jqueryui.com 12867 * 12868 * Copyright jQuery Foundation and other contributors 12869 * Released under the MIT license. 12870 * http://jquery.org/license 12871 * 12872 * http://api.jqueryui.com/tabs/ 12873 */ 12874 12875 12876var tabs = $.widget( "ui.tabs", { 12877 version: "1.11.4", 12878 delay: 300, 12879 options: { 12880 active: null, 12881 collapsible: false, 12882 event: "click", 12883 heightStyle: "content", 12884 hide: null, 12885 show: null, 12886 12887 // callbacks 12888 activate: null, 12889 beforeActivate: null, 12890 beforeLoad: null, 12891 load: null 12892 }, 12893 12894 _isLocal: (function() { 12895 var rhash = /#.*$/; 12896 12897 return function( anchor ) { 12898 var anchorUrl, locationUrl; 12899 12900 // support: IE7 12901 // IE7 doesn't normalize the href property when set via script (#9317) 12902 anchor = anchor.cloneNode( false ); 12903 12904 anchorUrl = anchor.href.replace( rhash, "" ); 12905 locationUrl = location.href.replace( rhash, "" ); 12906 12907 // decoding may throw an error if the URL isn't UTF-8 (#9518) 12908 try { 12909 anchorUrl = decodeURIComponent( anchorUrl ); 12910 } catch ( error ) {} 12911 try { 12912 locationUrl = decodeURIComponent( locationUrl ); 12913 } catch ( error ) {} 12914 12915 return anchor.hash.length > 1 && anchorUrl === locationUrl; 12916 }; 12917 })(), 12918 12919 _create: function() { 12920 var that = this, 12921 options = this.options; 12922 12923 this.running = false; 12924 12925 this.element 12926 .addClass( "ui-tabs ui-widget ui-widget-content ui-corner-all" ) 12927 .toggleClass( "ui-tabs-collapsible", options.collapsible ); 12928 12929 this._processTabs(); 12930 options.active = this._initialActive(); 12931 12932 // Take disabling tabs via class attribute from HTML 12933 // into account and update option properly. 12934 if ( $.isArray( options.disabled ) ) { 12935 options.disabled = $.unique( options.disabled.concat( 12936 $.map( this.tabs.filter( ".ui-state-disabled" ), function( li ) { 12937 return that.tabs.index( li ); 12938 }) 12939 ) ).sort(); 12940 } 12941 12942 // check for length avoids error when initializing empty list 12943 if ( this.options.active !== false && this.anchors.length ) { 12944 this.active = this._findActive( options.active ); 12945 } else { 12946 this.active = $(); 12947 } 12948 12949 this._refresh(); 12950 12951 if ( this.active.length ) { 12952 this.load( options.active ); 12953 } 12954 }, 12955 12956 _initialActive: function() { 12957 var active = this.options.active, 12958 collapsible = this.options.collapsible, 12959 locationHash = location.hash.substring( 1 ); 12960 12961 if ( active === null ) { 12962 // check the fragment identifier in the URL 12963 if ( locationHash ) { 12964 this.tabs.each(function( i, tab ) { 12965 if ( $( tab ).attr( "aria-controls" ) === locationHash ) { 12966 active = i; 12967 return false; 12968 } 12969 }); 12970 } 12971 12972 // check for a tab marked active via a class 12973 if ( active === null ) { 12974 active = this.tabs.index( this.tabs.filter( ".ui-tabs-active" ) ); 12975 } 12976 12977 // no active tab, set to false 12978 if ( active === null || active === -1 ) { 12979 active = this.tabs.length ? 0 : false; 12980 } 12981 } 12982 12983 // handle numbers: negative, out of range 12984 if ( active !== false ) { 12985 active = this.tabs.index( this.tabs.eq( active ) ); 12986 if ( active === -1 ) { 12987 active = collapsible ? false : 0; 12988 } 12989 } 12990 12991 // don't allow collapsible: false and active: false 12992 if ( !collapsible && active === false && this.anchors.length ) { 12993 active = 0; 12994 } 12995 12996 return active; 12997 }, 12998 12999 _getCreateEventData: function() { 13000 return { 13001 tab: this.active, 13002 panel: !this.active.length ? $() : this._getPanelForTab( this.active ) 13003 }; 13004 }, 13005 13006 _tabKeydown: function( event ) { 13007 var focusedTab = $( this.document[0].activeElement ).closest( "li" ), 13008 selectedIndex = this.tabs.index( focusedTab ), 13009 goingForward = true; 13010 13011 if ( this._handlePageNav( event ) ) { 13012 return; 13013 } 13014 13015 switch ( event.keyCode ) { 13016 case $.ui.keyCode.RIGHT: 13017 case $.ui.keyCode.DOWN: 13018 selectedIndex++; 13019 break; 13020 case $.ui.keyCode.UP: 13021 case $.ui.keyCode.LEFT: 13022 goingForward = false; 13023 selectedIndex--; 13024 break; 13025 case $.ui.keyCode.END: 13026 selectedIndex = this.anchors.length - 1; 13027 break; 13028 case $.ui.keyCode.HOME: 13029 selectedIndex = 0; 13030 break; 13031 case $.ui.keyCode.SPACE: 13032 // Activate only, no collapsing 13033 event.preventDefault(); 13034 clearTimeout( this.activating ); 13035 this._activate( selectedIndex ); 13036 return; 13037 case $.ui.keyCode.ENTER: 13038 // Toggle (cancel delayed activation, allow collapsing) 13039 event.preventDefault(); 13040 clearTimeout( this.activating ); 13041 // Determine if we should collapse or activate 13042 this._activate( selectedIndex === this.options.active ? false : selectedIndex ); 13043 return; 13044 default: 13045 return; 13046 } 13047 13048 // Focus the appropriate tab, based on which key was pressed 13049 event.preventDefault(); 13050 clearTimeout( this.activating ); 13051 selectedIndex = this._focusNextTab( selectedIndex, goingForward ); 13052 13053 // Navigating with control/command key will prevent automatic activation 13054 if ( !event.ctrlKey && !event.metaKey ) { 13055 13056 // Update aria-selected immediately so that AT think the tab is already selected. 13057 // Otherwise AT may confuse the user by stating that they need to activate the tab, 13058 // but the tab will already be activated by the time the announcement finishes. 13059 focusedTab.attr( "aria-selected", "false" ); 13060 this.tabs.eq( selectedIndex ).attr( "aria-selected", "true" ); 13061 13062 this.activating = this._delay(function() { 13063 this.option( "active", selectedIndex ); 13064 }, this.delay ); 13065 } 13066 }, 13067 13068 _panelKeydown: function( event ) { 13069 if ( this._handlePageNav( event ) ) { 13070 return; 13071 } 13072 13073 // Ctrl+up moves focus to the current tab 13074 if ( event.ctrlKey && event.keyCode === $.ui.keyCode.UP ) { 13075 event.preventDefault(); 13076 this.active.focus(); 13077 } 13078 }, 13079 13080 // Alt+page up/down moves focus to the previous/next tab (and activates) 13081 _handlePageNav: function( event ) { 13082 if ( event.altKey && event.keyCode === $.ui.keyCode.PAGE_UP ) { 13083 this._activate( this._focusNextTab( this.options.active - 1, false ) ); 13084 return true; 13085 } 13086 if ( event.altKey && event.keyCode === $.ui.keyCode.PAGE_DOWN ) { 13087 this._activate( this._focusNextTab( this.options.active + 1, true ) ); 13088 return true; 13089 } 13090 }, 13091 13092 _findNextTab: function( index, goingForward ) { 13093 var lastTabIndex = this.tabs.length - 1; 13094 13095 function constrain() { 13096 if ( index > lastTabIndex ) { 13097 index = 0; 13098 } 13099 if ( index < 0 ) { 13100 index = lastTabIndex; 13101 } 13102 return index; 13103 } 13104 13105 while ( $.inArray( constrain(), this.options.disabled ) !== -1 ) { 13106 index = goingForward ? index + 1 : index - 1; 13107 } 13108 13109 return index; 13110 }, 13111 13112 _focusNextTab: function( index, goingForward ) { 13113 index = this._findNextTab( index, goingForward ); 13114 this.tabs.eq( index ).focus(); 13115 return index; 13116 }, 13117 13118 _setOption: function( key, value ) { 13119 if ( key === "active" ) { 13120 // _activate() will handle invalid values and update this.options 13121 this._activate( value ); 13122 return; 13123 } 13124 13125 if ( key === "disabled" ) { 13126 // don't use the widget factory's disabled handling 13127 this._setupDisabled( value ); 13128 return; 13129 } 13130 13131 this._super( key, value); 13132 13133 if ( key === "collapsible" ) { 13134 this.element.toggleClass( "ui-tabs-collapsible", value ); 13135 // Setting collapsible: false while collapsed; open first panel 13136 if ( !value && this.options.active === false ) { 13137 this._activate( 0 ); 13138 } 13139 } 13140 13141 if ( key === "event" ) { 13142 this._setupEvents( value ); 13143 } 13144 13145 if ( key === "heightStyle" ) { 13146 this._setupHeightStyle( value ); 13147 } 13148 }, 13149 13150 _sanitizeSelector: function( hash ) { 13151 return hash ? hash.replace( /[!"$%&'()*+,.\/:;<=>?@\[\]\^`{|}~]/g, "\\$&" ) : ""; 13152 }, 13153 13154 refresh: function() { 13155 var options = this.options, 13156 lis = this.tablist.children( ":has(a[href])" ); 13157 13158 // get disabled tabs from class attribute from HTML 13159 // this will get converted to a boolean if needed in _refresh() 13160 options.disabled = $.map( lis.filter( ".ui-state-disabled" ), function( tab ) { 13161 return lis.index( tab ); 13162 }); 13163 13164 this._processTabs(); 13165 13166 // was collapsed or no tabs 13167 if ( options.active === false || !this.anchors.length ) { 13168 options.active = false; 13169 this.active = $(); 13170 // was active, but active tab is gone 13171 } else if ( this.active.length && !$.contains( this.tablist[ 0 ], this.active[ 0 ] ) ) { 13172 // all remaining tabs are disabled 13173 if ( this.tabs.length === options.disabled.length ) { 13174 options.active = false; 13175 this.active = $(); 13176 // activate previous tab 13177 } else { 13178 this._activate( this._findNextTab( Math.max( 0, options.active - 1 ), false ) ); 13179 } 13180 // was active, active tab still exists 13181 } else { 13182 // make sure active index is correct 13183 options.active = this.tabs.index( this.active ); 13184 } 13185 13186 this._refresh(); 13187 }, 13188 13189 _refresh: function() { 13190 this._setupDisabled( this.options.disabled ); 13191 this._setupEvents( this.options.event ); 13192 this._setupHeightStyle( this.options.heightStyle ); 13193 13194 this.tabs.not( this.active ).attr({ 13195 "aria-selected": "false", 13196 "aria-expanded": "false", 13197 tabIndex: -1 13198 }); 13199 this.panels.not( this._getPanelForTab( this.active ) ) 13200 .hide() 13201 .attr({ 13202 "aria-hidden": "true" 13203 }); 13204 13205 // Make sure one tab is in the tab order 13206 if ( !this.active.length ) { 13207 this.tabs.eq( 0 ).attr( "tabIndex", 0 ); 13208 } else { 13209 this.active 13210 .addClass( "ui-tabs-active ui-state-active" ) 13211 .attr({ 13212 "aria-selected": "true", 13213 "aria-expanded": "true", 13214 tabIndex: 0 13215 }); 13216 this._getPanelForTab( this.active ) 13217 .show() 13218 .attr({ 13219 "aria-hidden": "false" 13220 }); 13221 } 13222 }, 13223 13224 _processTabs: function() { 13225 var that = this, 13226 prevTabs = this.tabs, 13227 prevAnchors = this.anchors, 13228 prevPanels = this.panels; 13229 13230 this.tablist = this._getList() 13231 .addClass( "ui-tabs-nav ui-helper-reset ui-helper-clearfix ui-widget-header ui-corner-all" ) 13232 .attr( "role", "tablist" ) 13233 13234 // Prevent users from focusing disabled tabs via click 13235 .delegate( "> li", "mousedown" + this.eventNamespace, function( event ) { 13236 if ( $( this ).is( ".ui-state-disabled" ) ) { 13237 event.preventDefault(); 13238 } 13239 }) 13240 13241 // support: IE <9 13242 // Preventing the default action in mousedown doesn't prevent IE 13243 // from focusing the element, so if the anchor gets focused, blur. 13244 // We don't have to worry about focusing the previously focused 13245 // element since clicking on a non-focusable element should focus 13246 // the body anyway. 13247 .delegate( ".ui-tabs-anchor", "focus" + this.eventNamespace, function() { 13248 if ( $( this ).closest( "li" ).is( ".ui-state-disabled" ) ) { 13249 this.blur(); 13250 } 13251 }); 13252 13253 this.tabs = this.tablist.find( "> li:has(a[href])" ) 13254 .addClass( "ui-state-default ui-corner-top" ) 13255 .attr({ 13256 role: "tab", 13257 tabIndex: -1 13258 }); 13259 13260 this.anchors = this.tabs.map(function() { 13261 return $( "a", this )[ 0 ]; 13262 }) 13263 .addClass( "ui-tabs-anchor" ) 13264 .attr({ 13265 role: "presentation", 13266 tabIndex: -1 13267 }); 13268 13269 this.panels = $(); 13270 13271 this.anchors.each(function( i, anchor ) { 13272 var selector, panel, panelId, 13273 anchorId = $( anchor ).uniqueId().attr( "id" ), 13274 tab = $( anchor ).closest( "li" ), 13275 originalAriaControls = tab.attr( "aria-controls" ); 13276 13277 // inline tab 13278 if ( that._isLocal( anchor ) ) { 13279 selector = anchor.hash; 13280 panelId = selector.substring( 1 ); 13281 panel = that.element.find( that._sanitizeSelector( selector ) ); 13282 // remote tab 13283 } else { 13284 // If the tab doesn't already have aria-controls, 13285 // generate an id by using a throw-away element 13286 panelId = tab.attr( "aria-controls" ) || $( {} ).uniqueId()[ 0 ].id; 13287 selector = "#" + panelId; 13288 panel = that.element.find( selector ); 13289 if ( !panel.length ) { 13290 panel = that._createPanel( panelId ); 13291 panel.insertAfter( that.panels[ i - 1 ] || that.tablist ); 13292 } 13293 panel.attr( "aria-live", "polite" ); 13294 } 13295 13296 if ( panel.length) { 13297 that.panels = that.panels.add( panel ); 13298 } 13299 if ( originalAriaControls ) { 13300 tab.data( "ui-tabs-aria-controls", originalAriaControls ); 13301 } 13302 tab.attr({ 13303 "aria-controls": panelId, 13304 "aria-labelledby": anchorId 13305 }); 13306 panel.attr( "aria-labelledby", anchorId ); 13307 }); 13308 13309 this.panels 13310 .addClass( "ui-tabs-panel ui-widget-content ui-corner-bottom" ) 13311 .attr( "role", "tabpanel" ); 13312 13313 // Avoid memory leaks (#10056) 13314 if ( prevTabs ) { 13315 this._off( prevTabs.not( this.tabs ) ); 13316 this._off( prevAnchors.not( this.anchors ) ); 13317 this._off( prevPanels.not( this.panels ) ); 13318 } 13319 }, 13320 13321 // allow overriding how to find the list for rare usage scenarios (#7715) 13322 _getList: function() { 13323 return this.tablist || this.element.find( "ol,ul" ).eq( 0 ); 13324 }, 13325 13326 _createPanel: function( id ) { 13327 return $( "<div>" ) 13328 .attr( "id", id ) 13329 .addClass( "ui-tabs-panel ui-widget-content ui-corner-bottom" ) 13330 .data( "ui-tabs-destroy", true ); 13331 }, 13332 13333 _setupDisabled: function( disabled ) { 13334 if ( $.isArray( disabled ) ) { 13335 if ( !disabled.length ) { 13336 disabled = false;
vendor: 8,633 bytes, lines 13337-13669
13337 } else if ( disabled.length === this.anchors.length ) { 13338 disabled = true; 13339 } 13340 } 13341 13342 // disable tabs 13343 for ( var i = 0, li; ( li = this.tabs[ i ] ); i++ ) { 13344 if ( disabled === true || $.inArray( i, disabled ) !== -1 ) { 13345 $( li ) 13346 .addClass( "ui-state-disabled" ) 13347 .attr( "aria-disabled", "true" ); 13348 } else { 13349 $( li ) 13350 .removeClass( "ui-state-disabled" ) 13351 .removeAttr( "aria-disabled" ); 13352 } 13353 } 13354 13355 this.options.disabled = disabled; 13356 }, 13357 13358 _setupEvents: function( event ) { 13359 var events = {}; 13360 if ( event ) { 13361 $.each( event.split(" "), function( index, eventName ) { 13362 events[ eventName ] = "_eventHandler"; 13363 }); 13364 } 13365 13366 this._off( this.anchors.add( this.tabs ).add( this.panels ) ); 13367 // Always prevent the default action, even when disabled 13368 this._on( true, this.anchors, { 13369 click: function( event ) { 13370 event.preventDefault(); 13371 } 13372 }); 13373 this._on( this.anchors, events ); 13374 this._on( this.tabs, { keydown: "_tabKeydown" } ); 13375 this._on( this.panels, { keydown: "_panelKeydown" } ); 13376 13377 this._focusable( this.tabs ); 13378 this._hoverable( this.tabs ); 13379 }, 13380 13381 _setupHeightStyle: function( heightStyle ) { 13382 var maxHeight, 13383 parent = this.element.parent(); 13384 13385 if ( heightStyle === "fill" ) { 13386 maxHeight = parent.height(); 13387 maxHeight -= this.element.outerHeight() - this.element.height(); 13388 13389 this.element.siblings( ":visible" ).each(function() { 13390 var elem = $( this ), 13391 position = elem.css( "position" ); 13392 13393 if ( position === "absolute" || position === "fixed" ) { 13394 return; 13395 } 13396 maxHeight -= elem.outerHeight( true ); 13397 }); 13398 13399 this.element.children().not( this.panels ).each(function() { 13400 maxHeight -= $( this ).outerHeight( true ); 13401 }); 13402 13403 this.panels.each(function() { 13404 $( this ).height( Math.max( 0, maxHeight - 13405 $( this ).innerHeight() + $( this ).height() ) ); 13406 }) 13407 .css( "overflow", "auto" ); 13408 } else if ( heightStyle === "auto" ) { 13409 maxHeight = 0; 13410 this.panels.each(function() { 13411 maxHeight = Math.max( maxHeight, $( this ).height( "" ).height() ); 13412 }).height( maxHeight ); 13413 } 13414 }, 13415 13416 _eventHandler: function( event ) { 13417 var options = this.options, 13418 active = this.active, 13419 anchor = $( event.currentTarget ), 13420 tab = anchor.closest( "li" ), 13421 clickedIsActive = tab[ 0 ] === active[ 0 ], 13422 collapsing = clickedIsActive && options.collapsible, 13423 toShow = collapsing ? $() : this._getPanelForTab( tab ), 13424 toHide = !active.length ? $() : this._getPanelForTab( active ), 13425 eventData = { 13426 oldTab: active, 13427 oldPanel: toHide, 13428 newTab: collapsing ? $() : tab, 13429 newPanel: toShow 13430 }; 13431 13432 event.preventDefault(); 13433 13434 if ( tab.hasClass( "ui-state-disabled" ) || 13435 // tab is already loading 13436 tab.hasClass( "ui-tabs-loading" ) || 13437 // can't switch durning an animation 13438 this.running || 13439 // click on active header, but not collapsible 13440 ( clickedIsActive && !options.collapsible ) || 13441 // allow canceling activation 13442 ( this._trigger( "beforeActivate", event, eventData ) === false ) ) { 13443 return; 13444 } 13445 13446 options.active = collapsing ? false : this.tabs.index( tab ); 13447 13448 this.active = clickedIsActive ? $() : tab; 13449 if ( this.xhr ) { 13450 this.xhr.abort(); 13451 } 13452 13453 if ( !toHide.length && !toShow.length ) { 13454 $.error( "jQuery UI Tabs: Mismatching fragment identifier." ); 13455 } 13456 13457 if ( toShow.length ) { 13458 this.load( this.tabs.index( tab ), event ); 13459 } 13460 this._toggle( event, eventData ); 13461 }, 13462 13463 // handles show/hide for selecting tabs 13464 _toggle: function( event, eventData ) { 13465 var that = this, 13466 toShow = eventData.newPanel, 13467 toHide = eventData.oldPanel; 13468 13469 this.running = true; 13470 13471 function complete() { 13472 that.running = false; 13473 that._trigger( "activate", event, eventData ); 13474 } 13475 13476 function show() { 13477 eventData.newTab.closest( "li" ).addClass( "ui-tabs-active ui-state-active" ); 13478 13479 if ( toShow.length && that.options.show ) { 13480 that._show( toShow, that.options.show, complete ); 13481 } else { 13482 toShow.show(); 13483 complete(); 13484 } 13485 } 13486 13487 // start out by hiding, then showing, then completing 13488 if ( toHide.length && this.options.hide ) { 13489 this._hide( toHide, this.options.hide, function() { 13490 eventData.oldTab.closest( "li" ).removeClass( "ui-tabs-active ui-state-active" ); 13491 show(); 13492 }); 13493 } else { 13494 eventData.oldTab.closest( "li" ).removeClass( "ui-tabs-active ui-state-active" ); 13495 toHide.hide(); 13496 show(); 13497 } 13498 13499 toHide.attr( "aria-hidden", "true" ); 13500 eventData.oldTab.attr({ 13501 "aria-selected": "false", 13502 "aria-expanded": "false" 13503 }); 13504 // If we're switching tabs, remove the old tab from the tab order. 13505 // If we're opening from collapsed state, remove the previous tab from the tab order. 13506 // If we're collapsing, then keep the collapsing tab in the tab order. 13507 if ( toShow.length && toHide.length ) { 13508 eventData.oldTab.attr( "tabIndex", -1 ); 13509 } else if ( toShow.length ) { 13510 this.tabs.filter(function() { 13511 return $( this ).attr( "tabIndex" ) === 0; 13512 }) 13513 .attr( "tabIndex", -1 ); 13514 } 13515 13516 toShow.attr( "aria-hidden", "false" ); 13517 eventData.newTab.attr({ 13518 "aria-selected": "true", 13519 "aria-expanded": "true", 13520 tabIndex: 0 13521 }); 13522 }, 13523 13524 _activate: function( index ) { 13525 var anchor, 13526 active = this._findActive( index ); 13527 13528 // trying to activate the already active panel 13529 if ( active[ 0 ] === this.active[ 0 ] ) { 13530 return; 13531 } 13532 13533 // trying to collapse, simulate a click on the current active header 13534 if ( !active.length ) { 13535 active = this.active; 13536 } 13537 13538 anchor = active.find( ".ui-tabs-anchor" )[ 0 ]; 13539 this._eventHandler({ 13540 target: anchor, 13541 currentTarget: anchor, 13542 preventDefault: $.noop 13543 }); 13544 }, 13545 13546 _findActive: function( index ) { 13547 return index === false ? $() : this.tabs.eq( index ); 13548 }, 13549 13550 _getIndex: function( index ) { 13551 // meta-function to give users option to provide a href string instead of a numerical index. 13552 if ( typeof index === "string" ) { 13553 index = this.anchors.index( this.anchors.filter( "[href$='" + index + "']" ) ); 13554 } 13555 13556 return index; 13557 }, 13558 13559 _destroy: function() { 13560 if ( this.xhr ) { 13561 this.xhr.abort(); 13562 } 13563 13564 this.element.removeClass( "ui-tabs ui-widget ui-widget-content ui-corner-all ui-tabs-collapsible" ); 13565 13566 this.tablist 13567 .removeClass( "ui-tabs-nav ui-helper-reset ui-helper-clearfix ui-widget-header ui-corner-all" ) 13568 .removeAttr( "role" ); 13569 13570 this.anchors 13571 .removeClass( "ui-tabs-anchor" ) 13572 .removeAttr( "role" ) 13573 .removeAttr( "tabIndex" ) 13574 .removeUniqueId(); 13575 13576 this.tablist.unbind( this.eventNamespace ); 13577 13578 this.tabs.add( this.panels ).each(function() { 13579 if ( $.data( this, "ui-tabs-destroy" ) ) { 13580 $( this ).remove(); 13581 } else { 13582 $( this ) 13583 .removeClass( "ui-state-default ui-state-active ui-state-disabled " + 13584 "ui-corner-top ui-corner-bottom ui-widget-content ui-tabs-active ui-tabs-panel" ) 13585 .removeAttr( "tabIndex" ) 13586 .removeAttr( "aria-live" ) 13587 .removeAttr( "aria-busy" ) 13588 .removeAttr( "aria-selected" ) 13589 .removeAttr( "aria-labelledby" ) 13590 .removeAttr( "aria-hidden" ) 13591 .removeAttr( "aria-expanded" ) 13592 .removeAttr( "role" ); 13593 } 13594 }); 13595 13596 this.tabs.each(function() { 13597 var li = $( this ), 13598 prev = li.data( "ui-tabs-aria-controls" ); 13599 if ( prev ) { 13600 li 13601 .attr( "aria-controls", prev ) 13602 .removeData( "ui-tabs-aria-controls" ); 13603 } else { 13604 li.removeAttr( "aria-controls" ); 13605 } 13606 }); 13607 13608 this.panels.show(); 13609 13610 if ( this.options.heightStyle !== "content" ) { 13611 this.panels.css( "height", "" ); 13612 } 13613 }, 13614 13615 enable: function( index ) { 13616 var disabled = this.options.disabled; 13617 if ( disabled === false ) { 13618 return; 13619 } 13620 13621 if ( index === undefined ) { 13622 disabled = false; 13623 } else { 13624 index = this._getIndex( index ); 13625 if ( $.isArray( disabled ) ) { 13626 disabled = $.map( disabled, function( num ) { 13627 return num !== index ? num : null; 13628 }); 13629 } else { 13630 disabled = $.map( this.tabs, function( li, num ) { 13631 return num !== index ? num : null; 13632 }); 13633 } 13634 } 13635 this._setupDisabled( disabled ); 13636 }, 13637 13638 disable: function( index ) { 13639 var disabled = this.options.disabled; 13640 if ( disabled === true ) { 13641 return; 13642 } 13643 13644 if ( index === undefined ) { 13645 disabled = true; 13646 } else { 13647 index = this._getIndex( index ); 13648 if ( $.inArray( index, disabled ) !== -1 ) { 13649 return; 13650 } 13651 if ( $.isArray( disabled ) ) { 13652 disabled = $.merge( [ index ], disabled ).sort(); 13653 } else { 13654 disabled = [ index ]; 13655 } 13656 } 13657 this._setupDisabled( disabled ); 13658 }, 13659 13660 load: function( index, event ) { 13661 index = this._getIndex( index ); 13662 var that = this, 13663 tab = this.tabs.eq( index ), 13664 anchor = tab.find( ".ui-tabs-anchor" ), 13665 panel = this._getPanelForTab( tab ), 13666 eventData = { 13667 tab: tab, 13668 panel: panel 13669 }
vendor: 1,725 bytes, lines 13669-13740
13669, 13670 complete = function( jqXHR, status ) { 13671 if ( status === "abort" ) { 13672 that.panels.stop( false, true ); 13673 } 13674 13675 tab.removeClass( "ui-tabs-loading" ); 13676 panel.removeAttr( "aria-busy" ); 13677 13678 if ( jqXHR === that.xhr ) { 13679 delete that.xhr; 13680 } 13681 }; 13682 13683 // not remote 13684 if ( this._isLocal( anchor[ 0 ] ) ) { 13685 return; 13686 } 13687 13688 this.xhr = $.ajax( this._ajaxSettings( anchor, event, eventData ) ); 13689 13690 // support: jQuery <1.8 13691 // jQuery <1.8 returns false if the request is canceled in beforeSend, 13692 // but as of 1.8, $.ajax() always returns a jqXHR object. 13693 if ( this.xhr && this.xhr.statusText !== "canceled" ) { 13694 tab.addClass( "ui-tabs-loading" ); 13695 panel.attr( "aria-busy", "true" ); 13696 13697 this.xhr 13698 .done(function( response, status, jqXHR ) { 13699 // support: jQuery <1.8 13700 // http://bugs.jquery.com/ticket/11778 13701 setTimeout(function() { 13702 panel.html( response ); 13703 that._trigger( "load", event, eventData ); 13704 13705 complete( jqXHR, status ); 13706 }, 1 ); 13707 }) 13708 .fail(function( jqXHR, status ) { 13709 // support: jQuery <1.8 13710 // http://bugs.jquery.com/ticket/11778 13711 setTimeout(function() { 13712 complete( jqXHR, status ); 13713 }, 1 ); 13714 }); 13715 } 13716 }, 13717 13718 _ajaxSettings: function( anchor, event, eventData ) { 13719 var that = this; 13720 return { 13721 url: anchor.attr( "href" ), 13722 beforeSend: function( jqXHR, settings ) { 13723 return that._trigger( "beforeLoad", event, 13724 $.extend( { jqXHR: jqXHR, ajaxSettings: settings }, eventData ) ); 13725 } 13726 }; 13727 }, 13728 13729 _getPanelForTab: function( tab ) { 13730 var id = $( tab ).attr( "aria-controls" ); 13731 return this.element.find( this._sanitizeSelector( "#" + id ) ); 13732 } 13733}); 13734 13735 13736/*! 13737 * jQuery UI Effects 1.11.4 13738 * http://jqueryui.com 13739 * 13740 * Copyright
vendor: 13,076 bytes, lines 13740-14274
13740 jQuery Foundation and other contributors 13741 * Released under the MIT license. 13742 * http://jquery.org/license 13743 * 13744 * http://api.jqueryui.com/category/effects-core/ 13745 */ 13746 13747 13748var dataSpace = "ui-effects-", 13749 13750 // Create a local jQuery because jQuery Color relies on it and the 13751 // global may not exist with AMD and a custom build (#10199) 13752 jQuery = $; 13753 13754$.effects = { 13755 effect: {} 13756}; 13757 13758/*! 13759 * jQuery Color Animations v2.1.2 13760 * https://github.com/jquery/jquery-color 13761 * 13762 * Copyright 2014 jQuery Foundation and other contributors 13763 * Released under the MIT license. 13764 * http://jquery.org/license 13765 * 13766 * Date: Wed Jan 16 08:47:09 2013 -0600 13767 */ 13768(function( jQuery, undefined ) { 13769 13770 var stepHooks = "backgroundColor borderBottomColor borderLeftColor borderRightColor borderTopColor color columnRuleColor outlineColor textDecorationColor textEmphasisColor", 13771 13772 // plusequals test for += 100 -= 100 13773 rplusequals = /^([\-+])=\s*(\d+\.?\d*)/, 13774 // a set of RE's that can match strings and generate color tuples. 13775 stringParsers = [ { 13776 re: /rgba?\(\s*(\d{1,3})\s*,\s*(\d{1,3})\s*,\s*(\d{1,3})\s*(?:,\s*(\d?(?:\.\d+)?)\s*)?\)/, 13777 parse: function( execResult ) { 13778 return [ 13779 execResult[ 1 ], 13780 execResult[ 2 ], 13781 execResult[ 3 ], 13782 execResult[ 4 ] 13783 ]; 13784 } 13785 }, { 13786 re: /rgba?\(\s*(\d+(?:\.\d+)?)\%\s*,\s*(\d+(?:\.\d+)?)\%\s*,\s*(\d+(?:\.\d+)?)\%\s*(?:,\s*(\d?(?:\.\d+)?)\s*)?\)/, 13787 parse: function( execResult ) { 13788 return [ 13789 execResult[ 1 ] * 2.55, 13790 execResult[ 2 ] * 2.55, 13791 execResult[ 3 ] * 2.55, 13792 execResult[ 4 ] 13793 ]; 13794 } 13795 }, { 13796 // this regex ignores A-F because it's compared against an already lowercased string 13797 re: /#([a-f0-9]{2})([a-f0-9]{2})([a-f0-9]{2})/, 13798 parse: function( execResult ) { 13799 return [ 13800 parseInt( execResult[ 1 ], 16 ), 13801 parseInt( execResult[ 2 ], 16 ), 13802 parseInt( execResult[ 3 ], 16 ) 13803 ]; 13804 } 13805 }, { 13806 // this regex ignores A-F because it's compared against an already lowercased string 13807 re: /#([a-f0-9])([a-f0-9])([a-f0-9])/, 13808 parse: function( execResult ) { 13809 return [ 13810 parseInt( execResult[ 1 ] + execResult[ 1 ], 16 ), 13811 parseInt( execResult[ 2 ] + execResult[ 2 ], 16 ), 13812 parseInt( execResult[ 3 ] + execResult[ 3 ], 16 ) 13813 ]; 13814 } 13815 }, { 13816 re: /hsla?\(\s*(\d+(?:\.\d+)?)\s*,\s*(\d+(?:\.\d+)?)\%\s*,\s*(\d+(?:\.\d+)?)\%\s*(?:,\s*(\d?(?:\.\d+)?)\s*)?\)/, 13817 space: "hsla", 13818 parse: function( execResult ) { 13819 return [ 13820 execResult[ 1 ], 13821 execResult[ 2 ] / 100, 13822 execResult[ 3 ] / 100, 13823 execResult[ 4 ] 13824 ]; 13825 } 13826 } ], 13827 13828 // jQuery.Color( ) 13829 color = jQuery.Color = function( color, green, blue, alpha ) { 13830 return new jQuery.Color.fn.parse( color, green, blue, alpha ); 13831 }, 13832 spaces = { 13833 rgba: { 13834 props: { 13835 red: { 13836 idx: 0, 13837 type: "byte" 13838 }, 13839 green: { 13840 idx: 1, 13841 type: "byte" 13842 }, 13843 blue: { 13844 idx: 2, 13845 type: "byte" 13846 } 13847 } 13848 }, 13849 13850 hsla: { 13851 props: { 13852 hue: { 13853 idx: 0, 13854 type: "degrees" 13855 }, 13856 saturation: { 13857 idx: 1, 13858 type: "percent" 13859 }, 13860 lightness: { 13861 idx: 2, 13862 type: "percent" 13863 } 13864 } 13865 } 13866 }, 13867 propTypes = { 13868 "byte": { 13869 floor: true, 13870 max: 255 13871 }, 13872 "percent": { 13873 max: 1 13874 }, 13875 "degrees": { 13876 mod: 360, 13877 floor: true 13878 } 13879 }, 13880 support = color.support = {}, 13881 13882 // element for support tests 13883 supportElem = jQuery( "<p>" )[ 0 ], 13884 13885 // colors = jQuery.Color.names 13886 colors, 13887 13888 // local aliases of functions called often 13889 each = jQuery.each; 13890 13891// determine rgba support immediately 13892supportElem.style.cssText = "background-color:rgba(1,1,1,.5)"; 13893support.rgba = supportElem.style.backgroundColor.indexOf( "rgba" ) > -1; 13894 13895// define cache name and alpha properties 13896// for rgba and hsla spaces 13897each( spaces, function( spaceName, space ) { 13898 space.cache = "_" + spaceName; 13899 space.props.alpha = { 13900 idx: 3, 13901 type: "percent", 13902 def: 1 13903 }; 13904}); 13905 13906function clamp( value, prop, allowEmpty ) { 13907 var type = propTypes[ prop.type ] || {}; 13908 13909 if ( value == null ) { 13910 return (allowEmpty || !prop.def) ? null : prop.def; 13911 } 13912 13913 // ~~ is an short way of doing floor for positive numbers 13914 value = type.floor ? ~~value : parseFloat( value ); 13915 13916 // IE will pass in empty strings as value for alpha, 13917 // which will hit this case 13918 if ( isNaN( value ) ) { 13919 return prop.def; 13920 } 13921 13922 if ( type.mod ) { 13923 // we add mod before modding to make sure that negatives values 13924 // get converted properly: -10 -> 350 13925 return (value + type.mod) % type.mod; 13926 } 13927 13928 // for now all property types without mod have min and max 13929 return 0 > value ? 0 : type.max < value ? type.max : value; 13930} 13931 13932function stringParse( string ) { 13933 var inst = color(), 13934 rgba = inst._rgba = []; 13935 13936 string = string.toLowerCase(); 13937 13938 each( stringParsers, function( i, parser ) { 13939 var parsed, 13940 match = parser.re.exec( string ), 13941 values = match && parser.parse( match ), 13942 spaceName = parser.space || "rgba"; 13943 13944 if ( values ) { 13945 parsed = inst[ spaceName ]( values ); 13946 13947 // if this was an rgba parse the assignment might happen twice 13948 // oh well.... 13949 inst[ spaces[ spaceName ].cache ] = parsed[ spaces[ spaceName ].cache ]; 13950 rgba = inst._rgba = parsed._rgba; 13951 13952 // exit each( stringParsers ) here because we matched 13953 return false; 13954 } 13955 }); 13956 13957 // Found a stringParser that handled it 13958 if ( rgba.length ) { 13959 13960 // if this came from a parsed string, force "transparent" when alpha is 0 13961 // chrome, (and maybe others) return "transparent" as rgba(0,0,0,0) 13962 if ( rgba.join() === "0,0,0,0" ) { 13963 jQuery.extend( rgba, colors.transparent ); 13964 } 13965 return inst; 13966 } 13967 13968 // named colors 13969 return colors[ string ]; 13970} 13971 13972color.fn = jQuery.extend( color.prototype, { 13973 parse: function( red, green, blue, alpha ) { 13974 if ( red === undefined ) { 13975 this._rgba = [ null, null, null, null ]; 13976 return this; 13977 } 13978 if ( red.jquery || red.nodeType ) { 13979 red = jQuery( red ).css( green ); 13980 green = undefined; 13981 } 13982 13983 var inst = this, 13984 type = jQuery.type( red ), 13985 rgba = this._rgba = []; 13986 13987 // more than 1 argument specified - assume ( red, green, blue, alpha ) 13988 if ( green !== undefined ) { 13989 red = [ red, green, blue, alpha ]; 13990 type = "array"; 13991 } 13992 13993 if ( type === "string" ) { 13994 return this.parse( stringParse( red ) || colors._default ); 13995 } 13996 13997 if ( type === "array" ) { 13998 each( spaces.rgba.props, function( key, prop ) { 13999 rgba[ prop.idx ] = clamp( red[ prop.idx ], prop ); 14000 }); 14001 return this; 14002 } 14003 14004 if ( type === "object" ) { 14005 if ( red instanceof color ) { 14006 each( spaces, function( spaceName, space ) { 14007 if ( red[ space.cache ] ) { 14008 inst[ space.cache ] = red[ space.cache ].slice(); 14009 } 14010 }); 14011 } else { 14012 each( spaces, function( spaceName, space ) { 14013 var cache = space.cache; 14014 each( space.props, function( key, prop ) { 14015 14016 // if the cache doesn't exist, and we know how to convert 14017 if ( !inst[ cache ] && space.to ) { 14018 14019 // if the value was null, we don't need to copy it 14020 // if the key was alpha, we don't need to copy it either 14021 if ( key === "alpha" || red[ key ] == null ) { 14022 return; 14023 } 14024 inst[ cache ] = space.to( inst._rgba ); 14025 } 14026 14027 // this is the only case where we allow nulls for ALL properties. 14028 // call clamp with alwaysAllowEmpty 14029 inst[ cache ][ prop.idx ] = clamp( red[ key ], prop, true ); 14030 }); 14031 14032 // everything defined but alpha? 14033 if ( inst[ cache ] && jQuery.inArray( null, inst[ cache ].slice( 0, 3 ) ) < 0 ) { 14034 // use the default of 1 14035 inst[ cache ][ 3 ] = 1; 14036 if ( space.from ) { 14037 inst._rgba = space.from( inst[ cache ] ); 14038 } 14039 } 14040 }); 14041 } 14042 return this; 14043 } 14044 }, 14045 is: function( compare ) { 14046 var is = color( compare ), 14047 same = true, 14048 inst = this; 14049 14050 each( spaces, function( _, space ) { 14051 var localCache, 14052 isCache = is[ space.cache ]; 14053 if (isCache) { 14054 localCache = inst[ space.cache ] || space.to && space.to( inst._rgba ) || []; 14055 each( space.props, function( _, prop ) { 14056 if ( isCache[ prop.idx ] != null ) { 14057 same = ( isCache[ prop.idx ] === localCache[ prop.idx ] ); 14058 return same; 14059 } 14060 }); 14061 } 14062 return same; 14063 }); 14064 return same; 14065 }, 14066 _space: function() { 14067 var used = [], 14068 inst = this; 14069 each( spaces, function( spaceName, space ) { 14070 if ( inst[ space.cache ] ) { 14071 used.push( spaceName ); 14072 } 14073 }); 14074 return used.pop(); 14075 }, 14076 transition: function( other, distance ) { 14077 var end = color( other ), 14078 spaceName = end._space(), 14079 space = spaces[ spaceName ], 14080 startColor = this.alpha() === 0 ? color( "transparent" ) : this, 14081 start = startColor[ space.cache ] || space.to( startColor._rgba ), 14082 result = start.slice(); 14083 14084 end = end[ space.cache ]; 14085 each( space.props, function( key, prop ) { 14086 var index = prop.idx, 14087 startValue = start[ index ], 14088 endValue = end[ index ], 14089 type = propTypes[ prop.type ] || {}; 14090 14091 // if null, don't override start value 14092 if ( endValue === null ) { 14093 return; 14094 } 14095 // if null - use end 14096 if ( startValue === null ) { 14097 result[ index ] = endValue; 14098 } else { 14099 if ( type.mod ) { 14100 if ( endValue - startValue > type.mod / 2 ) { 14101 startValue += type.mod; 14102 } else if ( startValue - endValue > type.mod / 2 ) { 14103 startValue -= type.mod; 14104 } 14105 } 14106 result[ index ] = clamp( ( endValue - startValue ) * distance + startValue, prop ); 14107 } 14108 }); 14109 return this[ spaceName ]( result ); 14110 }, 14111 blend: function( opaque ) { 14112 // if we are already opaque - return ourself 14113 if ( this._rgba[ 3 ] === 1 ) { 14114 return this; 14115 } 14116 14117 var rgb = this._rgba.slice(), 14118 a = rgb.pop(), 14119 blend = color( opaque )._rgba; 14120 14121 return color( jQuery.map( rgb, function( v, i ) { 14122 return ( 1 - a ) * blend[ i ] + a * v; 14123 })); 14124 }, 14125 toRgbaString: function() { 14126 var prefix = "rgba(", 14127 rgba = jQuery.map( this._rgba, function( v, i ) { 14128 return v == null ? ( i > 2 ? 1 : 0 ) : v; 14129 }); 14130 14131 if ( rgba[ 3 ] === 1 ) { 14132 rgba.pop(); 14133 prefix = "rgb("; 14134 } 14135 14136 return prefix + rgba.join() + ")"; 14137 }, 14138 toHslaString: function() { 14139 var prefix = "hsla(", 14140 hsla = jQuery.map( this.hsla(), function( v, i ) { 14141 if ( v == null ) { 14142 v = i > 2 ? 1 : 0; 14143 } 14144 14145 // catch 1 and 2 14146 if ( i && i < 3 ) { 14147 v = Math.round( v * 100 ) + "%"; 14148 } 14149 return v; 14150 }); 14151 14152 if ( hsla[ 3 ] === 1 ) { 14153 hsla.pop(); 14154 prefix = "hsl("; 14155 } 14156 return prefix + hsla.join() + ")"; 14157 }, 14158 toHexString: function( includeAlpha ) { 14159 var rgba = this._rgba.slice(), 14160 alpha = rgba.pop(); 14161 14162 if ( includeAlpha ) { 14163 rgba.push( ~~( alpha * 255 ) ); 14164 } 14165 14166 return "#" + jQuery.map( rgba, function( v ) { 14167 14168 // default to 0 when nulls exist 14169 v = ( v || 0 ).toString( 16 ); 14170 return v.length === 1 ? "0" + v : v; 14171 }).join(""); 14172 }, 14173 toString: function() { 14174 return this._rgba[ 3 ] === 0 ? "transparent" : this.toRgbaString(); 14175 } 14176}); 14177color.fn.parse.prototype = color.fn; 14178 14179// hsla conversions adapted from: 14180// https://code.google.com/p/maashaack/source/browse/packages/graphics/trunk/src/graphics/colors/HUE2RGB.as?r=5021 14181 14182function hue2rgb( p, q, h ) { 14183 h = ( h + 1 ) % 1; 14184 if ( h * 6 < 1 ) { 14185 return p + ( q - p ) * h * 6; 14186 } 14187 if ( h * 2 < 1) { 14188 return q; 14189 } 14190 if ( h * 3 < 2 ) { 14191 return p + ( q - p ) * ( ( 2 / 3 ) - h ) * 6; 14192 } 14193 return p; 14194} 14195 14196spaces.hsla.to = function( rgba ) { 14197 if ( rgba[ 0 ] == null || rgba[ 1 ] == null || rgba[ 2 ] == null ) { 14198 return [ null, null, null, rgba[ 3 ] ]; 14199 } 14200 var r = rgba[ 0 ] / 255, 14201 g = rgba[ 1 ] / 255, 14202 b = rgba[ 2 ] / 255, 14203 a = rgba[ 3 ], 14204 max = Math.max( r, g, b ), 14205 min = Math.min( r, g, b ), 14206 diff = max - min, 14207 add = max + min, 14208 l = add * 0.5, 14209 h, s; 14210 14211 if ( min === max ) { 14212 h = 0; 14213 } else if ( r === max ) { 14214 h = ( 60 * ( g - b ) / diff ) + 360; 14215 } else if ( g === max ) { 14216 h = ( 60 * ( b - r ) / diff ) + 120; 14217 } else { 14218 h = ( 60 * ( r - g ) / diff ) + 240; 14219 } 14220 14221 // chroma (diff) == 0 means greyscale which, by definition, saturation = 0% 14222 // otherwise, saturation is based on the ratio of chroma (diff) to lightness (add) 14223 if ( diff === 0 ) { 14224 s = 0; 14225 } else if ( l <= 0.5 ) { 14226 s = diff / add; 14227 } else { 14228 s = diff / ( 2 - add ); 14229 } 14230 return [ Math.round(h) % 360, s, l, a == null ? 1 : a ]; 14231}; 14232 14233spaces.hsla.from = function( hsla ) { 14234 if ( hsla[ 0 ] == null || hsla[ 1 ] == null || hsla[ 2 ] == null ) { 14235 return [ null, null, null, hsla[ 3 ] ]; 14236 } 14237 var h = hsla[ 0 ] / 360, 14238 s = hsla[ 1 ], 14239 l = hsla[ 2 ], 14240 a = hsla[ 3 ], 14241 q = l <= 0.5 ? l * ( 1 + s ) : l + s - l * s, 14242 p = 2 * l - q; 14243 14244 return [ 14245 Math.round( hue2rgb( p, q, h + ( 1 / 3 ) ) * 255 ), 14246 Math.round( hue2rgb( p, q, h ) * 255 ), 14247 Math.round( hue2rgb( p, q, h - ( 1 / 3 ) ) * 255 ), 14248 a 14249 ]; 14250}; 14251 14252each( spaces, function( spaceName, space ) { 14253 var props = space.props, 14254 cache = space.cache, 14255 to = space.to, 14256 from = space.from; 14257 14258 // makes rgba() and hsla() 14259 color.fn[ spaceName ] = function( value ) { 14260 14261 // generate a cache for this space if it doesn't exist 14262 if ( to && !this[ cache ] ) { 14263 this[ cache ] = to( this._rgba ); 14264 } 14265 if ( value === undefined ) { 14266 return this[ cache ].slice(); 14267 } 14268 14269 var ret, 14270 type = jQuery.type( value ), 14271 arr = ( type === "array" || type === "object" ) ? value : arguments, 14272 local = this[ cache ].slice(); 14273 14274 each( props, function( key, prop ) {
vendor: 46,221 bytes, lines 14275-16157
14275 var val = arr[ type === "object" ? key : prop.idx ]; 14276 if ( val == null ) { 14277 val = local[ prop.idx ]; 14278 } 14279 local[ prop.idx ] = clamp( val, prop ); 14280 }); 14281 14282 if ( from ) { 14283 ret = color( from( local ) ); 14284 ret[ cache ] = local; 14285 return ret; 14286 } else { 14287 return color( local ); 14288 } 14289 }; 14290 14291 // makes red() green() blue() alpha() hue() saturation() lightness() 14292 each( props, function( key, prop ) { 14293 // alpha is included in more than one space 14294 if ( color.fn[ key ] ) { 14295 return; 14296 } 14297 color.fn[ key ] = function( value ) { 14298 var vtype = jQuery.type( value ), 14299 fn = ( key === "alpha" ? ( this._hsla ? "hsla" : "rgba" ) : spaceName ), 14300 local = this[ fn ](), 14301 cur = local[ prop.idx ], 14302 match; 14303 14304 if ( vtype === "undefined" ) { 14305 return cur; 14306 } 14307 14308 if ( vtype === "function" ) { 14309 value = value.call( this, cur ); 14310 vtype = jQuery.type( value ); 14311 } 14312 if ( value == null && prop.empty ) { 14313 return this; 14314 } 14315 if ( vtype === "string" ) { 14316 match = rplusequals.exec( value ); 14317 if ( match ) { 14318 value = cur + parseFloat( match[ 2 ] ) * ( match[ 1 ] === "+" ? 1 : -1 ); 14319 } 14320 } 14321 local[ prop.idx ] = value; 14322 return this[ fn ]( local ); 14323 }; 14324 }); 14325}); 14326 14327// add cssHook and .fx.step function for each named hook. 14328// accept a space separated string of properties 14329color.hook = function( hook ) { 14330 var hooks = hook.split( " " ); 14331 each( hooks, function( i, hook ) { 14332 jQuery.cssHooks[ hook ] = { 14333 set: function( elem, value ) { 14334 var parsed, curElem, 14335 backgroundColor = ""; 14336 14337 if ( value !== "transparent" && ( jQuery.type( value ) !== "string" || ( parsed = stringParse( value ) ) ) ) { 14338 value = color( parsed || value ); 14339 if ( !support.rgba && value._rgba[ 3 ] !== 1 ) { 14340 curElem = hook === "backgroundColor" ? elem.parentNode : elem; 14341 while ( 14342 (backgroundColor === "" || backgroundColor === "transparent") && 14343 curElem && curElem.style 14344 ) { 14345 try { 14346 backgroundColor = jQuery.css( curElem, "backgroundColor" ); 14347 curElem = curElem.parentNode; 14348 } catch ( e ) { 14349 } 14350 } 14351 14352 value = value.blend( backgroundColor && backgroundColor !== "transparent" ? 14353 backgroundColor : 14354 "_default" ); 14355 } 14356 14357 value = value.toRgbaString(); 14358 } 14359 try { 14360 elem.style[ hook ] = value; 14361 } catch ( e ) { 14362 // wrapped to prevent IE from throwing errors on "invalid" values like 'auto' or 'inherit' 14363 } 14364 } 14365 }; 14366 jQuery.fx.step[ hook ] = function( fx ) { 14367 if ( !fx.colorInit ) { 14368 fx.start = color( fx.elem, hook ); 14369 fx.end = color( fx.end ); 14370 fx.colorInit = true; 14371 } 14372 jQuery.cssHooks[ hook ].set( fx.elem, fx.start.transition( fx.end, fx.pos ) ); 14373 }; 14374 }); 14375 14376}; 14377 14378color.hook( stepHooks ); 14379 14380jQuery.cssHooks.borderColor = { 14381 expand: function( value ) { 14382 var expanded = {}; 14383 14384 each( [ "Top", "Right", "Bottom", "Left" ], function( i, part ) { 14385 expanded[ "border" + part + "Color" ] = value; 14386 }); 14387 return expanded; 14388 } 14389}; 14390 14391// Basic color names only. 14392// Usage of any of the other color names requires adding yourself or including 14393// jquery.color.svg-names.js. 14394colors = jQuery.Color.names = { 14395 // 4.1. Basic color keywords 14396 aqua: "#00ffff", 14397 black: "#000000", 14398 blue: "#0000ff", 14399 fuchsia: "#ff00ff", 14400 gray: "#808080", 14401 green: "#008000", 14402 lime: "#00ff00", 14403 maroon: "#800000", 14404 navy: "#000080", 14405 olive: "#808000", 14406 purple: "#800080", 14407 red: "#ff0000", 14408 silver: "#c0c0c0", 14409 teal: "#008080", 14410 white: "#ffffff", 14411 yellow: "#ffff00", 14412 14413 // 4.2.3. "transparent" color keyword 14414 transparent: [ null, null, null, 0 ], 14415 14416 _default: "#ffffff" 14417}; 14418 14419})( jQuery ); 14420 14421/******************************************************************************/ 14422/****************************** CLASS ANIMATIONS ******************************/ 14423/******************************************************************************/ 14424(function() { 14425 14426var classAnimationActions = [ "add", "remove", "toggle" ], 14427 shorthandStyles = { 14428 border: 1, 14429 borderBottom: 1, 14430 borderColor: 1, 14431 borderLeft: 1, 14432 borderRight: 1, 14433 borderTop: 1, 14434 borderWidth: 1, 14435 margin: 1, 14436 padding: 1 14437 }; 14438 14439$.each([ "borderLeftStyle", "borderRightStyle", "borderBottomStyle", "borderTopStyle" ], function( _, prop ) { 14440 $.fx.step[ prop ] = function( fx ) { 14441 if ( fx.end !== "none" && !fx.setAttr || fx.pos === 1 && !fx.setAttr ) { 14442 jQuery.style( fx.elem, prop, fx.end ); 14443 fx.setAttr = true; 14444 } 14445 }; 14446}); 14447 14448function getElementStyles( elem ) { 14449 var key, len, 14450 style = elem.ownerDocument.defaultView ? 14451 elem.ownerDocument.defaultView.getComputedStyle( elem, null ) : 14452 elem.currentStyle, 14453 styles = {}; 14454 14455 if ( style && style.length && style[ 0 ] && style[ style[ 0 ] ] ) { 14456 len = style.length; 14457 while ( len-- ) { 14458 key = style[ len ]; 14459 if ( typeof style[ key ] === "string" ) { 14460 styles[ $.camelCase( key ) ] = style[ key ]; 14461 } 14462 } 14463 // support: Opera, IE <9 14464 } else { 14465 for ( key in style ) { 14466 if ( typeof style[ key ] === "string" ) { 14467 styles[ key ] = style[ key ]; 14468 } 14469 } 14470 } 14471 14472 return styles; 14473} 14474 14475function styleDifference( oldStyle, newStyle ) { 14476 var diff = {}, 14477 name, value; 14478 14479 for ( name in newStyle ) { 14480 value = newStyle[ name ]; 14481 if ( oldStyle[ name ] !== value ) { 14482 if ( !shorthandStyles[ name ] ) { 14483 if ( $.fx.step[ name ] || !isNaN( parseFloat( value ) ) ) { 14484 diff[ name ] = value; 14485 } 14486 } 14487 } 14488 } 14489 14490 return diff; 14491} 14492 14493// support: jQuery <1.8 14494if ( !$.fn.addBack ) { 14495 $.fn.addBack = function( selector ) { 14496 return this.add( selector == null ? 14497 this.prevObject : this.prevObject.filter( selector ) 14498 ); 14499 }; 14500} 14501 14502$.effects.animateClass = function( value, duration, easing, callback ) { 14503 var o = $.speed( duration, easing, callback ); 14504 14505 return this.queue( function() { 14506 var animated = $( this ), 14507 baseClass = animated.attr( "class" ) || "", 14508 applyClassChange, 14509 allAnimations = o.children ? animated.find( "*" ).addBack() : animated; 14510 14511 // map the animated objects to store the original styles. 14512 allAnimations = allAnimations.map(function() { 14513 var el = $( this ); 14514 return { 14515 el: el, 14516 start: getElementStyles( this ) 14517 }; 14518 }); 14519 14520 // apply class change 14521 applyClassChange = function() { 14522 $.each( classAnimationActions, function(i, action) { 14523 if ( value[ action ] ) { 14524 animated[ action + "Class" ]( value[ action ] ); 14525 } 14526 }); 14527 }; 14528 applyClassChange(); 14529 14530 // map all animated objects again - calculate new styles and diff 14531 allAnimations = allAnimations.map(function() { 14532 this.end = getElementStyles( this.el[ 0 ] ); 14533 this.diff = styleDifference( this.start, this.end ); 14534 return this; 14535 }); 14536 14537 // apply original class 14538 animated.attr( "class", baseClass ); 14539 14540 // map all animated objects again - this time collecting a promise 14541 allAnimations = allAnimations.map(function() { 14542 var styleInfo = this, 14543 dfd = $.Deferred(), 14544 opts = $.extend({}, o, { 14545 queue: false, 14546 complete: function() { 14547 dfd.resolve( styleInfo ); 14548 } 14549 }); 14550 14551 this.el.animate( this.diff, opts ); 14552 return dfd.promise(); 14553 }); 14554 14555 // once all animations have completed: 14556 $.when.apply( $, allAnimations.get() ).done(function() { 14557 14558 // set the final class 14559 applyClassChange(); 14560 14561 // for each animated element, 14562 // clear all css properties that were animated 14563 $.each( arguments, function() { 14564 var el = this.el; 14565 $.each( this.diff, function(key) { 14566 el.css( key, "" ); 14567 }); 14568 }); 14569 14570 // this is guarnteed to be there if you use jQuery.speed() 14571 // it also handles dequeuing the next anim... 14572 o.complete.call( animated[ 0 ] ); 14573 }); 14574 }); 14575}; 14576 14577$.fn.extend({ 14578 addClass: (function( orig ) { 14579 return function( classNames, speed, easing, callback ) { 14580 return speed ? 14581 $.effects.animateClass.call( this, 14582 { add: classNames }, speed, easing, callback ) : 14583 orig.apply( this, arguments ); 14584 }; 14585 })( $.fn.addClass ), 14586 14587 removeClass: (function( orig ) { 14588 return function( classNames, speed, easing, callback ) { 14589 return arguments.length > 1 ? 14590 $.effects.animateClass.call( this, 14591 { remove: classNames }, speed, easing, callback ) : 14592 orig.apply( this, arguments ); 14593 }; 14594 })( $.fn.removeClass ), 14595 14596 toggleClass: (function( orig ) { 14597 return function( classNames, force, speed, easing, callback ) { 14598 if ( typeof force === "boolean" || force === undefined ) { 14599 if ( !speed ) { 14600 // without speed parameter 14601 return orig.apply( this, arguments ); 14602 } else { 14603 return $.effects.animateClass.call( this, 14604 (force ? { add: classNames } : { remove: classNames }), 14605 speed, easing, callback ); 14606 } 14607 } else { 14608 // without force parameter 14609 return $.effects.animateClass.call( this, 14610 { toggle: classNames }, force, speed, easing ); 14611 } 14612 }; 14613 })( $.fn.toggleClass ), 14614 14615 switchClass: function( remove, add, speed, easing, callback) { 14616 return $.effects.animateClass.call( this, { 14617 add: add, 14618 remove: remove 14619 }, speed, easing, callback ); 14620 } 14621}); 14622 14623})(); 14624 14625/******************************************************************************/ 14626/*********************************** EFFECTS **********************************/ 14627/******************************************************************************/ 14628 14629(function() { 14630 14631$.extend( $.effects, { 14632 version: "1.11.4", 14633 14634 // Saves a set of properties in a data storage 14635 save: function( element, set ) { 14636 for ( var i = 0; i < set.length; i++ ) { 14637 if ( set[ i ] !== null ) { 14638 element.data( dataSpace + set[ i ], element[ 0 ].style[ set[ i ] ] ); 14639 } 14640 } 14641 }, 14642 14643 // Restores a set of previously saved properties from a data storage 14644 restore: function( element, set ) { 14645 var val, i; 14646 for ( i = 0; i < set.length; i++ ) { 14647 if ( set[ i ] !== null ) { 14648 val = element.data( dataSpace + set[ i ] ); 14649 // support: jQuery 1.6.2 14650 // http://bugs.jquery.com/ticket/9917 14651 // jQuery 1.6.2 incorrectly returns undefined for any falsy value. 14652 // We can't differentiate between "" and 0 here, so we just assume 14653 // empty string since it's likely to be a more common value... 14654 if ( val === undefined ) { 14655 val = ""; 14656 } 14657 element.css( set[ i ], val ); 14658 } 14659 } 14660 }, 14661 14662 setMode: function( el, mode ) { 14663 if (mode === "toggle") { 14664 mode = el.is( ":hidden" ) ? "show" : "hide"; 14665 } 14666 return mode; 14667 }, 14668 14669 // Translates a [top,left] array into a baseline value 14670 // this should be a little more flexible in the future to handle a string & hash 14671 getBaseline: function( origin, original ) { 14672 var y, x; 14673 switch ( origin[ 0 ] ) { 14674 case "top": y = 0; break; 14675 case "middle": y = 0.5; break; 14676 case "bottom": y = 1; break; 14677 default: y = origin[ 0 ] / original.height; 14678 } 14679 switch ( origin[ 1 ] ) { 14680 case "left": x = 0; break; 14681 case "center": x = 0.5; break; 14682 case "right": x = 1; break; 14683 default: x = origin[ 1 ] / original.width; 14684 } 14685 return { 14686 x: x, 14687 y: y 14688 }; 14689 }, 14690 14691 // Wraps the element around a wrapper that copies position properties 14692 createWrapper: function( element ) { 14693 14694 // if the element is already wrapped, return it 14695 if ( element.parent().is( ".ui-effects-wrapper" )) { 14696 return element.parent(); 14697 } 14698 14699 // wrap the element 14700 var props = { 14701 width: element.outerWidth(true), 14702 height: element.outerHeight(true), 14703 "float": element.css( "float" ) 14704 }, 14705 wrapper = $( "<div></div>" ) 14706 .addClass( "ui-effects-wrapper" ) 14707 .css({ 14708 fontSize: "100%", 14709 background: "transparent", 14710 border: "none", 14711 margin: 0, 14712 padding: 0 14713 }), 14714 // Store the size in case width/height are defined in % - Fixes #5245 14715 size = { 14716 width: element.width(), 14717 height: element.height() 14718 }, 14719 active = document.activeElement; 14720 14721 // support: Firefox 14722 // Firefox incorrectly exposes anonymous content 14723 // https://bugzilla.mozilla.org/show_bug.cgi?id=561664 14724 try { 14725 active.id; 14726 } catch ( e ) { 14727 active = document.body; 14728 } 14729 14730 element.wrap( wrapper ); 14731 14732 // Fixes #7595 - Elements lose focus when wrapped. 14733 if ( element[ 0 ] === active || $.contains( element[ 0 ], active ) ) { 14734 $( active ).focus(); 14735 } 14736 14737 wrapper = element.parent(); //Hotfix for jQuery 1.4 since some change in wrap() seems to actually lose the reference to the wrapped element 14738 14739 // transfer positioning properties to the wrapper 14740 if ( element.css( "position" ) === "static" ) { 14741 wrapper.css({ position: "relative" }); 14742 element.css({ position: "relative" }); 14743 } else { 14744 $.extend( props, { 14745 position: element.css( "position" ), 14746 zIndex: element.css( "z-index" ) 14747 }); 14748 $.each([ "top", "left", "bottom", "right" ], function(i, pos) { 14749 props[ pos ] = element.css( pos ); 14750 if ( isNaN( parseInt( props[ pos ], 10 ) ) ) { 14751 props[ pos ] = "auto"; 14752 } 14753 }); 14754 element.css({ 14755 position: "relative", 14756 top: 0, 14757 left: 0, 14758 right: "auto", 14759 bottom: "auto" 14760 }); 14761 } 14762 element.css(size); 14763 14764 return wrapper.css( props ).show(); 14765 }, 14766 14767 removeWrapper: function( element ) { 14768 var active = document.activeElement; 14769 14770 if ( element.parent().is( ".ui-effects-wrapper" ) ) { 14771 element.parent().replaceWith( element ); 14772 14773 // Fixes #7595 - Elements lose focus when wrapped. 14774 if ( element[ 0 ] === active || $.contains( element[ 0 ], active ) ) { 14775 $( active ).focus(); 14776 } 14777 } 14778 14779 return element; 14780 }, 14781 14782 setTransition: function( element, list, factor, value ) { 14783 value = value || {}; 14784 $.each( list, function( i, x ) { 14785 var unit = element.cssUnit( x ); 14786 if ( unit[ 0 ] > 0 ) { 14787 value[ x ] = unit[ 0 ] * factor + unit[ 1 ]; 14788 } 14789 }); 14790 return value; 14791 } 14792}); 14793 14794// return an effect options object for the given parameters: 14795function _normalizeArguments( effect, options, speed, callback ) { 14796 14797 // allow passing all options as the first parameter 14798 if ( $.isPlainObject( effect ) ) { 14799 options = effect; 14800 effect = effect.effect; 14801 } 14802 14803 // convert to an object 14804 effect = { effect: effect }; 14805 14806 // catch (effect, null, ...) 14807 if ( options == null ) { 14808 options = {}; 14809 } 14810 14811 // catch (effect, callback) 14812 if ( $.isFunction( options ) ) { 14813 callback = options; 14814 speed = null; 14815 options = {}; 14816 } 14817 14818 // catch (effect, speed, ?) 14819 if ( typeof options === "number" || $.fx.speeds[ options ] ) { 14820 callback = speed; 14821 speed = options; 14822 options = {}; 14823 } 14824 14825 // catch (effect, options, callback) 14826 if ( $.isFunction( speed ) ) { 14827 callback = speed; 14828 speed = null; 14829 } 14830 14831 // add options to effect 14832 if ( options ) { 14833 $.extend( effect, options ); 14834 } 14835 14836 speed = speed || options.duration; 14837 effect.duration = $.fx.off ? 0 : 14838 typeof speed === "number" ? speed : 14839 speed in $.fx.speeds ? $.fx.speeds[ speed ] : 14840 $.fx.speeds._default; 14841 14842 effect.complete = callback || options.complete; 14843 14844 return effect; 14845} 14846 14847function standardAnimationOption( option ) { 14848 // Valid standard speeds (nothing, number, named speed) 14849 if ( !option || typeof option === "number" || $.fx.speeds[ option ] ) { 14850 return true; 14851 } 14852 14853 // Invalid strings - treat as "normal" speed 14854 if ( typeof option === "string" && !$.effects.effect[ option ] ) { 14855 return true; 14856 } 14857 14858 // Complete callback 14859 if ( $.isFunction( option ) ) { 14860 return true; 14861 } 14862 14863 // Options hash (but not naming an effect) 14864 if ( typeof option === "object" && !option.effect ) { 14865 return true; 14866 } 14867 14868 // Didn't match any standard API 14869 return false; 14870} 14871 14872$.fn.extend({ 14873 effect: function( /* effect, options, speed, callback */ ) { 14874 var args = _normalizeArguments.apply( this, arguments ), 14875 mode = args.mode, 14876 queue = args.queue, 14877 effectMethod = $.effects.effect[ args.effect ]; 14878 14879 if ( $.fx.off || !effectMethod ) { 14880 // delegate to the original method (e.g., .show()) if possible 14881 if ( mode ) { 14882 return this[ mode ]( args.duration, args.complete ); 14883 } else { 14884 return this.each( function() { 14885 if ( args.complete ) { 14886 args.complete.call( this ); 14887 } 14888 }); 14889 } 14890 } 14891 14892 function run( next ) { 14893 var elem = $( this ), 14894 complete = args.complete, 14895 mode = args.mode; 14896 14897 function done() { 14898 if ( $.isFunction( complete ) ) { 14899 complete.call( elem[0] ); 14900 } 14901 if ( $.isFunction( next ) ) { 14902 next(); 14903 } 14904 } 14905 14906 // If the element already has the correct final state, delegate to 14907 // the core methods so the internal tracking of "olddisplay" works. 14908 if ( elem.is( ":hidden" ) ? mode === "hide" : mode === "show" ) { 14909 elem[ mode ](); 14910 done(); 14911 } else { 14912 effectMethod.call( elem[0], args, done ); 14913 } 14914 } 14915 14916 return queue === false ? this.each( run ) : this.queue( queue || "fx", run ); 14917 }, 14918 14919 show: (function( orig ) { 14920 return function( option ) { 14921 if ( standardAnimationOption( option ) ) { 14922 return orig.apply( this, arguments ); 14923 } else { 14924 var args = _normalizeArguments.apply( this, arguments ); 14925 args.mode = "show"; 14926 return this.effect.call( this, args ); 14927 } 14928 }; 14929 })( $.fn.show ), 14930 14931 hide: (function( orig ) { 14932 return function( option ) { 14933 if ( standardAnimationOption( option ) ) { 14934 return orig.apply( this, arguments ); 14935 } else { 14936 var args = _normalizeArguments.apply( this, arguments ); 14937 args.mode = "hide"; 14938 return this.effect.call( this, args ); 14939 } 14940 }; 14941 })( $.fn.hide ), 14942 14943 toggle: (function( orig ) { 14944 return function( option ) { 14945 if ( standardAnimationOption( option ) || typeof option === "boolean" ) { 14946 return orig.apply( this, arguments ); 14947 } else { 14948 var args = _normalizeArguments.apply( this, arguments ); 14949 args.mode = "toggle"; 14950 return this.effect.call( this, args ); 14951 } 14952 }; 14953 })( $.fn.toggle ), 14954 14955 // helper functions 14956 cssUnit: function(key) { 14957 var style = this.css( key ), 14958 val = []; 14959 14960 $.each( [ "em", "px", "%", "pt" ], function( i, unit ) { 14961 if ( style.indexOf( unit ) > 0 ) { 14962 val = [ parseFloat( style ), unit ]; 14963 } 14964 }); 14965 return val; 14966 } 14967}); 14968 14969})(); 14970 14971/******************************************************************************/ 14972/*********************************** EASING ***********************************/ 14973/******************************************************************************/ 14974 14975(function() { 14976 14977// based on easing equations from Robert Penner (http://www.robertpenner.com/easing) 14978 14979var baseEasings = {}; 14980 14981$.each( [ "Quad", "Cubic", "Quart", "Quint", "Expo" ], function( i, name ) { 14982 baseEasings[ name ] = function( p ) { 14983 return Math.pow( p, i + 2 ); 14984 }; 14985}); 14986 14987$.extend( baseEasings, { 14988 Sine: function( p ) { 14989 return 1 - Math.cos( p * Math.PI / 2 ); 14990 }, 14991 Circ: function( p ) { 14992 return 1 - Math.sqrt( 1 - p * p ); 14993 }, 14994 Elastic: function( p ) { 14995 return p === 0 || p === 1 ? p : 14996 -Math.pow( 2, 8 * (p - 1) ) * Math.sin( ( (p - 1) * 80 - 7.5 ) * Math.PI / 15 ); 14997 }, 14998 Back: function( p ) { 14999 return p * p * ( 3 * p - 2 ); 15000 }, 15001 Bounce: function( p ) { 15002 var pow2, 15003 bounce = 4; 15004 15005 while ( p < ( ( pow2 = Math.pow( 2, --bounce ) ) - 1 ) / 11 ) {} 15006 return 1 / Math.pow( 4, 3 - bounce ) - 7.5625 * Math.pow( ( pow2 * 3 - 2 ) / 22 - p, 2 ); 15007 } 15008}); 15009 15010$.each( baseEasings, function( name, easeIn ) { 15011 $.easing[ "easeIn" + name ] = easeIn; 15012 $.easing[ "easeOut" + name ] = function( p ) { 15013 return 1 - easeIn( 1 - p ); 15014 }; 15015 $.easing[ "easeInOut" + name ] = function( p ) { 15016 return p < 0.5 ? 15017 easeIn( p * 2 ) / 2 : 15018 1 - easeIn( p * -2 + 2 ) / 2; 15019 }; 15020}); 15021 15022})(); 15023 15024var effect = $.effects; 15025 15026 15027/*! 15028 * jQuery UI Effects Blind 1.11.4 15029 * http://jqueryui.com 15030 * 15031 * Copyright jQuery Foundation and other contributors 15032 * Released under the MIT license. 15033 * http://jquery.org/license 15034 * 15035 * http://api.jqueryui.com/blind-effect/ 15036 */ 15037 15038 15039var effectBlind = $.effects.effect.blind = function( o, done ) { 15040 // Create element 15041 var el = $( this ), 15042 rvertical = /up|down|vertical/, 15043 rpositivemotion = /up|left|vertical|horizontal/, 15044 props = [ "position", "top", "bottom", "left", "right", "height", "width" ], 15045 mode = $.effects.setMode( el, o.mode || "hide" ), 15046 direction = o.direction || "up", 15047 vertical = rvertical.test( direction ), 15048 ref = vertical ? "height" : "width", 15049 ref2 = vertical ? "top" : "left", 15050 motion = rpositivemotion.test( direction ), 15051 animation = {}, 15052 show = mode === "show", 15053 wrapper, distance, margin; 15054 15055 // if already wrapped, the wrapper's properties are my property. #6245 15056 if ( el.parent().is( ".ui-effects-wrapper" ) ) { 15057 $.effects.save( el.parent(), props ); 15058 } else { 15059 $.effects.save( el, props ); 15060 } 15061 el.show(); 15062 wrapper = $.effects.createWrapper( el ).css({ 15063 overflow: "hidden" 15064 }); 15065 15066 distance = wrapper[ ref ](); 15067 margin = parseFloat( wrapper.css( ref2 ) ) || 0; 15068 15069 animation[ ref ] = show ? distance : 0; 15070 if ( !motion ) { 15071 el 15072 .css( vertical ? "bottom" : "right", 0 ) 15073 .css( vertical ? "top" : "left", "auto" ) 15074 .css({ position: "absolute" }); 15075 15076 animation[ ref2 ] = show ? margin : distance + margin; 15077 } 15078 15079 // start at 0 if we are showing 15080 if ( show ) { 15081 wrapper.css( ref, 0 ); 15082 if ( !motion ) { 15083 wrapper.css( ref2, margin + distance ); 15084 } 15085 } 15086 15087 // Animate 15088 wrapper.animate( animation, { 15089 duration: o.duration, 15090 easing: o.easing, 15091 queue: false, 15092 complete: function() { 15093 if ( mode === "hide" ) { 15094 el.hide(); 15095 } 15096 $.effects.restore( el, props ); 15097 $.effects.removeWrapper( el ); 15098 done(); 15099 } 15100 }); 15101}; 15102 15103 15104/*! 15105 * jQuery UI Effects Bounce 1.11.4 15106 * http://jqueryui.com 15107 * 15108 * Copyright jQuery Foundation and other contributors 15109 * Released under the MIT license. 15110 * http://jquery.org/license 15111 * 15112 * http://api.jqueryui.com/bounce-effect/ 15113 */ 15114 15115 15116var effectBounce = $.effects.effect.bounce = function( o, done ) { 15117 var el = $( this ), 15118 props = [ "position", "top", "bottom", "left", "right", "height", "width" ], 15119 15120 // defaults: 15121 mode = $.effects.setMode( el, o.mode || "effect" ), 15122 hide = mode === "hide", 15123 show = mode === "show", 15124 direction = o.direction || "up", 15125 distance = o.distance, 15126 times = o.times || 5, 15127 15128 // number of internal animations 15129 anims = times * 2 + ( show || hide ? 1 : 0 ), 15130 speed = o.duration / anims, 15131 easing = o.easing, 15132 15133 // utility: 15134 ref = ( direction === "up" || direction === "down" ) ? "top" : "left", 15135 motion = ( direction === "up" || direction === "left" ), 15136 i, 15137 upAnim, 15138 downAnim, 15139 15140 // we will need to re-assemble the queue to stack our animations in place 15141 queue = el.queue(), 15142 queuelen = queue.length; 15143 15144 // Avoid touching opacity to prevent clearType and PNG issues in IE 15145 if ( show || hide ) { 15146 props.push( "opacity" ); 15147 } 15148 15149 $.effects.save( el, props ); 15150 el.show(); 15151 $.effects.createWrapper( el ); // Create Wrapper 15152 15153 // default distance for the BIGGEST bounce is the outer Distance / 3 15154 if ( !distance ) { 15155 distance = el[ ref === "top" ? "outerHeight" : "outerWidth" ]() / 3; 15156 } 15157 15158 if ( show ) { 15159 downAnim = { opacity: 1 }; 15160 downAnim[ ref ] = 0; 15161 15162 // if we are showing, force opacity 0 and set the initial position 15163 // then do the "first" animation 15164 el.css( "opacity", 0 ) 15165 .css( ref, motion ? -distance * 2 : distance * 2 ) 15166 .animate( downAnim, speed, easing ); 15167 } 15168 15169 // start at the smallest distance if we are hiding 15170 if ( hide ) { 15171 distance = distance / Math.pow( 2, times - 1 ); 15172 } 15173 15174 downAnim = {}; 15175 downAnim[ ref ] = 0; 15176 // Bounces up/down/left/right then back to 0 -- times * 2 animations happen here 15177 for ( i = 0; i < times; i++ ) { 15178 upAnim = {}; 15179 upAnim[ ref ] = ( motion ? "-=" : "+=" ) + distance; 15180 15181 el.animate( upAnim, speed, easing ) 15182 .animate( downAnim, speed, easing ); 15183 15184 distance = hide ? distance * 2 : distance / 2; 15185 } 15186 15187 // Last Bounce when Hiding 15188 if ( hide ) { 15189 upAnim = { opacity: 0 }; 15190 upAnim[ ref ] = ( motion ? "-=" : "+=" ) + distance; 15191 15192 el.animate( upAnim, speed, easing ); 15193 } 15194 15195 el.queue(function() { 15196 if ( hide ) { 15197 el.hide(); 15198 } 15199 $.effects.restore( el, props ); 15200 $.effects.removeWrapper( el ); 15201 done(); 15202 }); 15203 15204 // inject all the animations we just queued to be first in line (after "inprogress") 15205 if ( queuelen > 1) { 15206 queue.splice.apply( queue, 15207 [ 1, 0 ].concat( queue.splice( queuelen, anims + 1 ) ) ); 15208 } 15209 el.dequeue(); 15210 15211}; 15212 15213 15214/*! 15215 * jQuery UI Effects Clip 1.11.4 15216 * http://jqueryui.com 15217 * 15218 * Copyright jQuery Foundation and other contributors 15219 * Released under the MIT license. 15220 * http://jquery.org/license 15221 * 15222 * http://api.jqueryui.com/clip-effect/ 15223 */ 15224 15225 15226var effectClip = $.effects.effect.clip = function( o, done ) { 15227 // Create element 15228 var el = $( this ), 15229 props = [ "position", "top", "bottom", "left", "right", "height", "width" ], 15230 mode = $.effects.setMode( el, o.mode || "hide" ), 15231 show = mode === "show", 15232 direction = o.direction || "vertical", 15233 vert = direction === "vertical", 15234 size = vert ? "height" : "width", 15235 position = vert ? "top" : "left", 15236 animation = {}, 15237 wrapper, animate, distance; 15238 15239 // Save & Show 15240 $.effects.save( el, props ); 15241 el.show(); 15242 15243 // Create Wrapper 15244 wrapper = $.effects.createWrapper( el ).css({ 15245 overflow: "hidden" 15246 }); 15247 animate = ( el[0].tagName === "IMG" ) ? wrapper : el; 15248 distance = animate[ size ](); 15249 15250 // Shift 15251 if ( show ) { 15252 animate.css( size, 0 ); 15253 animate.css( position, distance / 2 ); 15254 } 15255 15256 // Create Animation Object: 15257 animation[ size ] = show ? distance : 0; 15258 animation[ position ] = show ? 0 : distance / 2; 15259 15260 // Animate 15261 animate.animate( animation, { 15262 queue: false, 15263 duration: o.duration, 15264 easing: o.easing, 15265 complete: function() { 15266 if ( !show ) { 15267 el.hide(); 15268 } 15269 $.effects.restore( el, props ); 15270 $.effects.removeWrapper( el ); 15271 done(); 15272 } 15273 }); 15274 15275}; 15276 15277 15278/*! 15279 * jQuery UI Effects Drop 1.11.4 15280 * http://jqueryui.com 15281 * 15282 * Copyright jQuery Foundation and other contributors 15283 * Released under the MIT license. 15284 * http://jquery.org/license 15285 * 15286 * http://api.jqueryui.com/drop-effect/ 15287 */ 15288 15289 15290var effectDrop = $.effects.effect.drop = function( o, done ) { 15291 15292 var el = $( this ), 15293 props = [ "position", "top", "bottom", "left", "right", "opacity", "height", "width" ], 15294 mode = $.effects.setMode( el, o.mode || "hide" ), 15295 show = mode === "show", 15296 direction = o.direction || "left", 15297 ref = ( direction === "up" || direction === "down" ) ? "top" : "left", 15298 motion = ( direction === "up" || direction === "left" ) ? "pos" : "neg", 15299 animation = { 15300 opacity: show ? 1 : 0 15301 }, 15302 distance; 15303 15304 // Adjust 15305 $.effects.save( el, props ); 15306 el.show(); 15307 $.effects.createWrapper( el ); 15308 15309 distance = o.distance || el[ ref === "top" ? "outerHeight" : "outerWidth" ]( true ) / 2; 15310 15311 if ( show ) { 15312 el 15313 .css( "opacity", 0 ) 15314 .css( ref, motion === "pos" ? -distance : distance ); 15315 } 15316 15317 // Animation 15318 animation[ ref ] = ( show ? 15319 ( motion === "pos" ? "+=" : "-=" ) : 15320 ( motion === "pos" ? "-=" : "+=" ) ) + 15321 distance; 15322 15323 // Animate 15324 el.animate( animation, { 15325 queue: false, 15326 duration: o.duration, 15327 easing: o.easing, 15328 complete: function() { 15329 if ( mode === "hide" ) { 15330 el.hide(); 15331 } 15332 $.effects.restore( el, props ); 15333 $.effects.removeWrapper( el ); 15334 done(); 15335 } 15336 }); 15337}; 15338 15339 15340/*! 15341 * jQuery UI Effects Explode 1.11.4 15342 * http://jqueryui.com 15343 * 15344 * Copyright jQuery Foundation and other contributors 15345 * Released under the MIT license. 15346 * http://jquery.org/license 15347 * 15348 * http://api.jqueryui.com/explode-effect/ 15349 */ 15350 15351 15352var effectExplode = $.effects.effect.explode = function( o, done ) { 15353 15354 var rows = o.pieces ? Math.round( Math.sqrt( o.pieces ) ) : 3, 15355 cells = rows, 15356 el = $( this ), 15357 mode = $.effects.setMode( el, o.mode || "hide" ), 15358 show = mode === "show", 15359 15360 // show and then visibility:hidden the element before calculating offset 15361 offset = el.show().css( "visibility", "hidden" ).offset(), 15362 15363 // width and height of a piece 15364 width = Math.ceil( el.outerWidth() / cells ), 15365 height = Math.ceil( el.outerHeight() / rows ), 15366 pieces = [], 15367 15368 // loop 15369 i, j, left, top, mx, my; 15370 15371 // children animate complete: 15372 function childComplete() { 15373 pieces.push( this ); 15374 if ( pieces.length === rows * cells ) { 15375 animComplete(); 15376 } 15377 } 15378 15379 // clone the element for each row and cell. 15380 for ( i = 0; i < rows ; i++ ) { // ===> 15381 top = offset.top + i * height; 15382 my = i - ( rows - 1 ) / 2 ; 15383 15384 for ( j = 0; j < cells ; j++ ) { // ||| 15385 left = offset.left + j * width; 15386 mx = j - ( cells - 1 ) / 2 ; 15387 15388 // Create a clone of the now hidden main element that will be absolute positioned 15389 // within a wrapper div off the -left and -top equal to size of our pieces 15390 el 15391 .clone() 15392 .appendTo( "body" ) 15393 .wrap( "<div></div>" ) 15394 .css({ 15395 position: "absolute", 15396 visibility: "visible", 15397 left: -j * width, 15398 top: -i * height 15399 }) 15400 15401 // select the wrapper - make it overflow: hidden and absolute positioned based on 15402 // where the original was located +left and +top equal to the size of pieces 15403 .parent() 15404 .addClass( "ui-effects-explode" ) 15405 .css({ 15406 position: "absolute", 15407 overflow: "hidden", 15408 width: width, 15409 height: height, 15410 left: left + ( show ? mx * width : 0 ), 15411 top: top + ( show ? my * height : 0 ), 15412 opacity: show ? 0 : 1 15413 }).animate({ 15414 left: left + ( show ? 0 : mx * width ), 15415 top: top + ( show ? 0 : my * height ), 15416 opacity: show ? 1 : 0 15417 }, o.duration || 500, o.easing, childComplete ); 15418 } 15419 } 15420 15421 function animComplete() { 15422 el.css({ 15423 visibility: "visible" 15424 }); 15425 $( pieces ).remove(); 15426 if ( !show ) { 15427 el.hide(); 15428 } 15429 done(); 15430 } 15431}; 15432 15433 15434/*! 15435 * jQuery UI Effects Fade 1.11.4 15436 * http://jqueryui.com 15437 * 15438 * Copyright jQuery Foundation and other contributors 15439 * Released under the MIT license. 15440 * http://jquery.org/license 15441 * 15442 * http://api.jqueryui.com/fade-effect/ 15443 */ 15444 15445 15446var effectFade = $.effects.effect.fade = function( o, done ) { 15447 var el = $( this ), 15448 mode = $.effects.setMode( el, o.mode || "toggle" ); 15449 15450 el.animate({ 15451 opacity: mode 15452 }, { 15453 queue: false, 15454 duration: o.duration, 15455 easing: o.easing, 15456 complete: done 15457 }); 15458}; 15459 15460 15461/*! 15462 * jQuery UI Effects Fold 1.11.4 15463 * http://jqueryui.com 15464 * 15465 * Copyright jQuery Foundation and other contributors 15466 * Released under the MIT license. 15467 * http://jquery.org/license 15468 * 15469 * http://api.jqueryui.com/fold-effect/ 15470 */ 15471 15472 15473var effectFold = $.effects.effect.fold = function( o, done ) { 15474 15475 // Create element 15476 var el = $( this ), 15477 props = [ "position", "top", "bottom", "left", "right", "height", "width" ], 15478 mode = $.effects.setMode( el, o.mode || "hide" ), 15479 show = mode === "show", 15480 hide = mode === "hide", 15481 size = o.size || 15, 15482 percent = /([0-9]+)%/.exec( size ), 15483 horizFirst = !!o.horizFirst, 15484 widthFirst = show !== horizFirst, 15485 ref = widthFirst ? [ "width", "height" ] : [ "height", "width" ], 15486 duration = o.duration / 2, 15487 wrapper, distance, 15488 animation1 = {}, 15489 animation2 = {}; 15490 15491 $.effects.save( el, props ); 15492 el.show(); 15493 15494 // Create Wrapper 15495 wrapper = $.effects.createWrapper( el ).css({ 15496 overflow: "hidden" 15497 }); 15498 distance = widthFirst ? 15499 [ wrapper.width(), wrapper.height() ] : 15500 [ wrapper.height(), wrapper.width() ]; 15501 15502 if ( percent ) { 15503 size = parseInt( percent[ 1 ], 10 ) / 100 * distance[ hide ? 0 : 1 ]; 15504 } 15505 if ( show ) { 15506 wrapper.css( horizFirst ? { 15507 height: 0, 15508 width: size 15509 } : { 15510 height: size, 15511 width: 0 15512 }); 15513 } 15514 15515 // Animation 15516 animation1[ ref[ 0 ] ] = show ? distance[ 0 ] : size; 15517 animation2[ ref[ 1 ] ] = show ? distance[ 1 ] : 0; 15518 15519 // Animate 15520 wrapper 15521 .animate( animation1, duration, o.easing ) 15522 .animate( animation2, duration, o.easing, function() { 15523 if ( hide ) { 15524 el.hide(); 15525 } 15526 $.effects.restore( el, props ); 15527 $.effects.removeWrapper( el ); 15528 done(); 15529 }); 15530 15531}; 15532 15533 15534/*! 15535 * jQuery UI Effects Highlight 1.11.4 15536 * http://jqueryui.com 15537 * 15538 * Copyright jQuery Foundation and other contributors 15539 * Released under the MIT license. 15540 * http://jquery.org/license 15541 * 15542 * http://api.jqueryui.com/highlight-effect/ 15543 */ 15544 15545 15546var effectHighlight = $.effects.effect.highlight = function( o, done ) { 15547 var elem = $( this ), 15548 props = [ "backgroundImage", "backgroundColor", "opacity" ], 15549 mode = $.effects.setMode( elem, o.mode || "show" ), 15550 animation = { 15551 backgroundColor: elem.css( "backgroundColor" ) 15552 }; 15553 15554 if (mode === "hide") { 15555 animation.opacity = 0; 15556 } 15557 15558 $.effects.save( elem, props ); 15559 15560 elem 15561 .show() 15562 .css({ 15563 backgroundImage: "none", 15564 backgroundColor: o.color || "#ffff99" 15565 }) 15566 .animate( animation, { 15567 queue: false, 15568 duration: o.duration, 15569 easing: o.easing, 15570 complete: function() { 15571 if ( mode === "hide" ) { 15572 elem.hide(); 15573 } 15574 $.effects.restore( elem, props ); 15575 done(); 15576 } 15577 }); 15578}; 15579 15580 15581/*! 15582 * jQuery UI Effects Size 1.11.4 15583 * http://jqueryui.com 15584 * 15585 * Copyright jQuery Foundation and other contributors 15586 * Released under the MIT license. 15587 * http://jquery.org/license 15588 * 15589 * http://api.jqueryui.com/size-effect/ 15590 */ 15591 15592 15593var effectSize = $.effects.effect.size = function( o, done ) { 15594 15595 // Create element 15596 var original, baseline, factor, 15597 el = $( this ), 15598 props0 = [ "position", "top", "bottom", "left", "right", "width", "height", "overflow", "opacity" ], 15599 15600 // Always restore 15601 props1 = [ "position", "top", "bottom", "left", "right", "overflow", "opacity" ], 15602 15603 // Copy for children 15604 props2 = [ "width", "height", "overflow" ], 15605 cProps = [ "fontSize" ], 15606 vProps = [ "borderTopWidth", "borderBottomWidth", "paddingTop", "paddingBottom" ], 15607 hProps = [ "borderLeftWidth", "borderRightWidth", "paddingLeft", "paddingRight" ], 15608 15609 // Set options 15610 mode = $.effects.setMode( el, o.mode || "effect" ), 15611 restore = o.restore || mode !== "effect", 15612 scale = o.scale || "both", 15613 origin = o.origin || [ "middle", "center" ], 15614 position = el.css( "position" ), 15615 props = restore ? props0 : props1, 15616 zero = { 15617 height: 0, 15618 width: 0, 15619 outerHeight: 0, 15620 outerWidth: 0 15621 }; 15622 15623 if ( mode === "show" ) { 15624 el.show(); 15625 } 15626 original = { 15627 height: el.height(), 15628 width: el.width(), 15629 outerHeight: el.outerHeight(), 15630 outerWidth: el.outerWidth() 15631 }; 15632 15633 if ( o.mode === "toggle" && mode === "show" ) { 15634 el.from = o.to || zero; 15635 el.to = o.from || original; 15636 } else { 15637 el.from = o.from || ( mode === "show" ? zero : original ); 15638 el.to = o.to || ( mode === "hide" ? zero : original ); 15639 } 15640 15641 // Set scaling factor 15642 factor = { 15643 from: { 15644 y: el.from.height / original.height, 15645 x: el.from.width / original.width 15646 }, 15647 to: { 15648 y: el.to.height / original.height, 15649 x: el.to.width / original.width 15650 } 15651 }; 15652 15653 // Scale the css box 15654 if ( scale === "box" || scale === "both" ) { 15655 15656 // Vertical props scaling 15657 if ( factor.from.y !== factor.to.y ) { 15658 props = props.concat( vProps ); 15659 el.from = $.effects.setTransition( el, vProps, factor.from.y, el.from ); 15660 el.to = $.effects.setTransition( el, vProps, factor.to.y, el.to ); 15661 } 15662 15663 // Horizontal props scaling 15664 if ( factor.from.x !== factor.to.x ) { 15665 props = props.concat( hProps ); 15666 el.from = $.effects.setTransition( el, hProps, factor.from.x, el.from ); 15667 el.to = $.effects.setTransition( el, hProps, factor.to.x, el.to ); 15668 } 15669 } 15670 15671 // Scale the content 15672 if ( scale === "content" || scale === "both" ) { 15673 15674 // Vertical props scaling 15675 if ( factor.from.y !== factor.to.y ) { 15676 props = props.concat( cProps ).concat( props2 ); 15677 el.from = $.effects.setTransition( el, cProps, factor.from.y, el.from ); 15678 el.to = $.effects.setTransition( el, cProps, factor.to.y, el.to ); 15679 } 15680 } 15681 15682 $.effects.save( el, props ); 15683 el.show(); 15684 $.effects.createWrapper( el ); 15685 el.css( "overflow", "hidden" ).css( el.from ); 15686 15687 // Adjust 15688 if (origin) { // Calculate baseline shifts 15689 baseline = $.effects.getBaseline( origin, original ); 15690 el.from.top = ( original.outerHeight - el.outerHeight() ) * baseline.y; 15691 el.from.left = ( original.outerWidth - el.outerWidth() ) * baseline.x; 15692 el.to.top = ( original.outerHeight - el.to.outerHeight ) * baseline.y; 15693 el.to.left = ( original.outerWidth - el.to.outerWidth ) * baseline.x; 15694 } 15695 el.css( el.from ); // set top & left 15696 15697 // Animate 15698 if ( scale === "content" || scale === "both" ) { // Scale the children 15699 15700 // Add margins/font-size 15701 vProps = vProps.concat([ "marginTop", "marginBottom" ]).concat(cProps); 15702 hProps = hProps.concat([ "marginLeft", "marginRight" ]); 15703 props2 = props0.concat(vProps).concat(hProps); 15704 15705 el.find( "*[width]" ).each( function() { 15706 var child = $( this ), 15707 c_original = { 15708 height: child.height(), 15709 width: child.width(), 15710 outerHeight: child.outerHeight(), 15711 outerWidth: child.outerWidth() 15712 }; 15713 if (restore) { 15714 $.effects.save(child, props2); 15715 } 15716 15717 child.from = { 15718 height: c_original.height * factor.from.y, 15719 width: c_original.width * factor.from.x, 15720 outerHeight: c_original.outerHeight * factor.from.y, 15721 outerWidth: c_original.outerWidth * factor.from.x 15722 }; 15723 child.to = { 15724 height: c_original.height * factor.to.y, 15725 width: c_original.width * factor.to.x, 15726 outerHeight: c_original.height * factor.to.y, 15727 outerWidth: c_original.width * factor.to.x 15728 }; 15729 15730 // Vertical props scaling 15731 if ( factor.from.y !== factor.to.y ) { 15732 child.from = $.effects.setTransition( child, vProps, factor.from.y, child.from ); 15733 child.to = $.effects.setTransition( child, vProps, factor.to.y, child.to ); 15734 } 15735 15736 // Horizontal props scaling 15737 if ( factor.from.x !== factor.to.x ) { 15738 child.from = $.effects.setTransition( child, hProps, factor.from.x, child.from ); 15739 child.to = $.effects.setTransition( child, hProps, factor.to.x, child.to ); 15740 } 15741 15742 // Animate children 15743 child.css( child.from ); 15744 child.animate( child.to, o.duration, o.easing, function() { 15745 15746 // Restore children 15747 if ( restore ) { 15748 $.effects.restore( child, props2 ); 15749 } 15750 }); 15751 }); 15752 } 15753 15754 // Animate 15755 el.animate( el.to, { 15756 queue: false, 15757 duration: o.duration, 15758 easing: o.easing, 15759 complete: function() { 15760 if ( el.to.opacity === 0 ) { 15761 el.css( "opacity", el.from.opacity ); 15762 } 15763 if ( mode === "hide" ) { 15764 el.hide(); 15765 } 15766 $.effects.restore( el, props ); 15767 if ( !restore ) { 15768 15769 // we need to calculate our new positioning based on the scaling 15770 if ( position === "static" ) { 15771 el.css({ 15772 position: "relative", 15773 top: el.to.top, 15774 left: el.to.left 15775 }); 15776 } else { 15777 $.each([ "top", "left" ], function( idx, pos ) { 15778 el.css( pos, function( _, str ) { 15779 var val = parseInt( str, 10 ), 15780 toRef = idx ? el.to.left : el.to.top; 15781 15782 // if original was "auto", recalculate the new value from wrapper 15783 if ( str === "auto" ) { 15784 return toRef + "px"; 15785 } 15786 15787 return val + toRef + "px"; 15788 }); 15789 }); 15790 } 15791 } 15792 15793 $.effects.removeWrapper( el ); 15794 done(); 15795 } 15796 }); 15797 15798}; 15799 15800 15801/*! 15802 * jQuery UI Effects Scale 1.11.4 15803 * http://jqueryui.com 15804 * 15805 * Copyright jQuery Foundation and other contributors 15806 * Released under the MIT license. 15807 * http://jquery.org/license 15808 * 15809 * http://api.jqueryui.com/scale-effect/ 15810 */ 15811 15812 15813var effectScale = $.effects.effect.scale = function( o, done ) { 15814 15815 // Create element 15816 var el = $( this ), 15817 options = $.extend( true, {}, o ), 15818 mode = $.effects.setMode( el, o.mode || "effect" ), 15819 percent = parseInt( o.percent, 10 ) || 15820 ( parseInt( o.percent, 10 ) === 0 ? 0 : ( mode === "hide" ? 0 : 100 ) ), 15821 direction = o.direction || "both", 15822 origin = o.origin, 15823 original = { 15824 height: el.height(), 15825 width: el.width(), 15826 outerHeight: el.outerHeight(), 15827 outerWidth: el.outerWidth() 15828 }, 15829 factor = { 15830 y: direction !== "horizontal" ? (percent / 100) : 1, 15831 x: direction !== "vertical" ? (percent / 100) : 1 15832 }; 15833 15834 // We are going to pass this effect to the size effect: 15835 options.effect = "size"; 15836 options.queue = false; 15837 options.complete = done; 15838 15839 // Set default origin and restore for show/hide 15840 if ( mode !== "effect" ) { 15841 options.origin = origin || [ "middle", "center" ]; 15842 options.restore = true; 15843 } 15844 15845 options.from = o.from || ( mode === "show" ? { 15846 height: 0, 15847 width: 0, 15848 outerHeight: 0, 15849 outerWidth: 0 15850 } : original ); 15851 options.to = { 15852 height: original.height * factor.y, 15853 width: original.width * factor.x, 15854 outerHeight: original.outerHeight * factor.y, 15855 outerWidth: original.outerWidth * factor.x 15856 }; 15857 15858 // Fade option to support puff 15859 if ( options.fade ) { 15860 if ( mode === "show" ) { 15861 options.from.opacity = 0; 15862 options.to.opacity = 1; 15863 } 15864 if ( mode === "hide" ) { 15865 options.from.opacity = 1; 15866 options.to.opacity = 0; 15867 } 15868 } 15869 15870 // Animate 15871 el.effect( options ); 15872 15873}; 15874 15875 15876/*! 15877 * jQuery UI Effects Puff 1.11.4 15878 * http://jqueryui.com 15879 * 15880 * Copyright jQuery Foundation and other contributors 15881 * Released under the MIT license. 15882 * http://jquery.org/license 15883 * 15884 * http://api.jqueryui.com/puff-effect/ 15885 */ 15886 15887 15888var effectPuff = $.effects.effect.puff = function( o, done ) { 15889 var elem = $( this ), 15890 mode = $.effects.setMode( elem, o.mode || "hide" ), 15891 hide = mode === "hide", 15892 percent = parseInt( o.percent, 10 ) || 150, 15893 factor = percent / 100, 15894 original = { 15895 height: elem.height(), 15896 width: elem.width(), 15897 outerHeight: elem.outerHeight(), 15898 outerWidth: elem.outerWidth() 15899 }; 15900 15901 $.extend( o, { 15902 effect: "scale", 15903 queue: false, 15904 fade: true, 15905 mode: mode, 15906 complete: done, 15907 percent: hide ? percent : 100, 15908 from: hide ? 15909 original : 15910 { 15911 height: original.height * factor, 15912 width: original.width * factor, 15913 outerHeight: original.outerHeight * factor, 15914 outerWidth: original.outerWidth * factor 15915 } 15916 }); 15917 15918 elem.effect( o ); 15919}; 15920 15921 15922/*! 15923 * jQuery UI Effects Pulsate 1.11.4 15924 * http://jqueryui.com 15925 * 15926 * Copyright jQuery Foundation and other contributors 15927 * Released under the MIT license. 15928 * http://jquery.org/license 15929 * 15930 * http://api.jqueryui.com/pulsate-effect/ 15931 */ 15932 15933 15934var effectPulsate = $.effects.effect.pulsate = function( o, done ) { 15935 var elem = $( this ), 15936 mode = $.effects.setMode( elem, o.mode || "show" ), 15937 show = mode === "show", 15938 hide = mode === "hide", 15939 showhide = ( show || mode === "hide" ), 15940 15941 // showing or hiding leaves of the "last" animation 15942 anims = ( ( o.times || 5 ) * 2 ) + ( showhide ? 1 : 0 ), 15943 duration = o.duration / anims, 15944 animateTo = 0, 15945 queue = elem.queue(), 15946 queuelen = queue.length, 15947 i; 15948 15949 if ( show || !elem.is(":visible")) { 15950 elem.css( "opacity", 0 ).show(); 15951 animateTo = 1; 15952 } 15953 15954 // anims - 1 opacity "toggles" 15955 for ( i = 1; i < anims; i++ ) { 15956 elem.animate({ 15957 opacity: animateTo 15958 }, duration, o.easing ); 15959 animateTo = 1 - animateTo; 15960 } 15961 15962 elem.animate({ 15963 opacity: animateTo 15964 }, duration, o.easing); 15965 15966 elem.queue(function() { 15967 if ( hide ) { 15968 elem.hide(); 15969 } 15970 done(); 15971 }); 15972 15973 // We just queued up "anims" animations, we need to put them next in the queue 15974 if ( queuelen > 1 ) { 15975 queue.splice.apply( queue, 15976 [ 1, 0 ].concat( queue.splice( queuelen, anims + 1 ) ) ); 15977 } 15978 elem.dequeue(); 15979}; 15980 15981 15982/*! 15983 * jQuery UI Effects Shake 1.11.4 15984 * http://jqueryui.com 15985 * 15986 * Copyright jQuery Foundation and other contributors 15987 * Released under the MIT license. 15988 * http://jquery.org/license 15989 * 15990 * http://api.jqueryui.com/shake-effect/ 15991 */ 15992 15993 15994var effectShake = $.effects.effect.shake = function( o, done ) { 15995 15996 var el = $( this ), 15997 props = [ "position", "top", "bottom", "left", "right", "height", "width" ], 15998 mode = $.effects.setMode( el, o.mode || "effect" ), 15999 direction = o.direction || "left", 16000 distance = o.distance || 20, 16001 times = o.times || 3, 16002 anims = times * 2 + 1, 16003 speed = Math.round( o.duration / anims ), 16004 ref = (direction === "up" || direction === "down") ? "top" : "left", 16005 positiveMotion = (direction === "up" || direction === "left"), 16006 animation = {}, 16007 animation1 = {}, 16008 animation2 = {}, 16009 i, 16010 16011 // we will need to re-assemble the queue to stack our animations in place 16012 queue = el.queue(), 16013 queuelen = queue.length; 16014 16015 $.effects.save( el, props ); 16016 el.show(); 16017 $.effects.createWrapper( el ); 16018 16019 // Animation 16020 animation[ ref ] = ( positiveMotion ? "-=" : "+=" ) + distance; 16021 animation1[ ref ] = ( positiveMotion ? "+=" : "-=" ) + distance * 2; 16022 animation2[ ref ] = ( positiveMotion ? "-=" : "+=" ) + distance * 2; 16023 16024 // Animate 16025 el.animate( animation, speed, o.easing ); 16026 16027 // Shakes 16028 for ( i = 1; i < times; i++ ) { 16029 el.animate( animation1, speed, o.easing ).animate( animation2, speed, o.easing ); 16030 } 16031 el 16032 .animate( animation1, speed, o.easing ) 16033 .animate( animation, speed / 2, o.easing ) 16034 .queue(function() { 16035 if ( mode === "hide" ) { 16036 el.hide(); 16037 } 16038 $.effects.restore( el, props ); 16039 $.effects.removeWrapper( el ); 16040 done(); 16041 }); 16042 16043 // inject all the animations we just queued to be first in line (after "inprogress") 16044 if ( queuelen > 1) { 16045 queue.splice.apply( queue, 16046 [ 1, 0 ].concat( queue.splice( queuelen, anims + 1 ) ) ); 16047 } 16048 el.dequeue(); 16049 16050}; 16051 16052 16053/*! 16054 * jQuery UI Effects Slide 1.11.4 16055 * http://jqueryui.com 16056 * 16057 * Copyright jQuery Foundation and other contributors 16058 * Released under the MIT license. 16059 * http://jquery.org/license 16060 * 16061 * http://api.jqueryui.com/slide-effect/ 16062 */ 16063 16064 16065var effectSlide = $.effects.effect.slide = function( o, done ) { 16066 16067 // Create element 16068 var el = $( this ), 16069 props = [ "position", "top", "bottom", "left", "right", "width", "height" ], 16070 mode = $.effects.setMode( el, o.mode || "show" ), 16071 show = mode === "show", 16072 direction = o.direction || "left", 16073 ref = (direction === "up" || direction === "down") ? "top" : "left", 16074 positiveMotion = (direction === "up" || direction === "left"), 16075 distance, 16076 animation = {}; 16077 16078 // Adjust 16079 $.effects.save( el, props ); 16080 el.show(); 16081 distance = o.distance || el[ ref === "top" ? "outerHeight" : "outerWidth" ]( true ); 16082 16083 $.effects.createWrapper( el ).css({ 16084 overflow: "hidden" 16085 }); 16086 16087 if ( show ) { 16088 el.css( ref, positiveMotion ? (isNaN(distance) ? "-" + distance : -distance) : distance ); 16089 } 16090 16091 // Animation 16092 animation[ ref ] = ( show ? 16093 ( positiveMotion ? "+=" : "-=") : 16094 ( positiveMotion ? "-=" : "+=")) + 16095 distance; 16096 16097 // Animate 16098 el.animate( animation, { 16099 queue: false, 16100 duration: o.duration, 16101 easing: o.easing, 16102 complete: function() { 16103 if ( mode === "hide" ) { 16104 el.hide(); 16105 } 16106 $.effects.restore( el, props ); 16107 $.effects.removeWrapper( el ); 16108 done(); 16109 } 16110 }); 16111}; 16112 16113 16114/*! 16115 * jQuery UI Effects Transfer 1.11.4 16116 * http://jqueryui.com 16117 * 16118 * Copyright jQuery Foundation and other contributors 16119 * Released under the MIT license. 16120 * http://jquery.org/license 16121 * 16122 * http://api.jqueryui.com/transfer-effect/ 16123 */ 16124 16125 16126var effectTransfer = $.effects.effect.transfer = function( o, done ) { 16127 var elem = $( this ), 16128 target = $( o.to ), 16129 targetFixed = target.css( "position" ) === "fixed", 16130 body = $("body"), 16131 fixTop = targetFixed ? body.scrollTop() : 0, 16132 fixLeft = targetFixed ? body.scrollLeft() : 0, 16133 endPosition = target.offset(), 16134 animation = { 16135 top: endPosition.top - fixTop, 16136 left: endPosition.left - fixLeft, 16137 height: target.innerHeight(), 16138 width: target.innerWidth() 16139 }, 16140 startPosition = elem.offset(), 16141 transfer = $( "<div class='ui-effects-transfer'></div>" ) 16142 .appendTo( document.body ) 16143 .addClass( o.className ) 16144 .css({ 16145 top: startPosition.top - fixTop, 16146 left: startPosition.left - fixLeft, 16147 height: elem.innerHeight(), 16148 width: elem.innerWidth(), 16149 position: targetFixed ? "fixed" : "absolute" 16150 }) 16151 .animate( animation, o.duration, o.easing, function() { 16152 transfer.remove(); 16153 done(); 16154 }); 16155}; 16156 16157
16158 16159}));
Line numbers count LF bytes from the start of the resource, as the search results do. Vendor segments are library code the classifier recognised; they are stored but not indexed. Bytes are shown as Latin1 characters, one per byte.