1. /*! jQuery UI - v1.11.4 - 2015-04-23
  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, tooltip.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 2015 jQuery Foundation and other contributors; Licensed MIT */
  6. (function( factory ) {
  7. if ( typeof define === "function" && define.amd ) {
  9. // AMD. Register as an anonymous module.
  10. define([ "jquery" ], factory );
  11. } else {
  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. */
  29. // $.ui might exist from components with no dependencies, e.g., $.ui.position
  30. $.ui = $.ui || {};
  32. $.extend( $.ui, {
  33. version: "1.11.4",
  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. });
  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 );
  69. return position === "fixed" || !scrollParent.length ? $( this[ 0 ].ownerDocument || document ) : scrollParent;
  70. },
  72. uniqueId: (function() {
  73. var uuid = 0;
  75. return function() {
  76. return this.each(function() {
  77. if ( !this.id ) {
  78. this.id = "ui-id-" + ( ++uuid );
  79. }
  80. });
  81. };
  82. })(),
  84. removeUniqueId: function() {
  85. return this.each(function() {
  86. if ( /^ui-id-\d+$/.test( this.id ) ) {
  87. $( this ).removeAttr( "id" );
  88. }
  89. });
  90. }
  91. });
  93. // selectors
  94. function 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. }
  115. function visible( element ) {
  116. return $.expr.filters.visible( element ) &&
  117. !$( element ).parents().addBack().filter(function() {
  118. return $.css( this, "visibility" ) === "hidden";
  119. }).length;
  120. }
  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. },
  134. focusable: function( element ) {
  135. return focusable( element, !isNaN( $.attr( element, "tabindex" ) ) );
  136. },
  138. tabbable: function( element ) {
  139. var tabIndex = $.attr( element, "tabindex" ),
  140. isTabIndexNaN = isNaN( tabIndex );
  141. return ( isTabIndexNaN || tabIndex >= 0 ) && focusable( element, !isTabIndexNaN );
  142. }
  143. });
  145. // support: jQuery <1.8
  146. if ( !$( "<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. };
  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. }
  170. $.fn[ "inner" + name ] = function( size ) {
  171. if ( size === undefined ) {
  172. return orig[ "inner" + name ].call( this );
  173. }
  175. return this.each(function() {
  176. $( this ).css( type, reduce( this, size ) + "px" );
  177. });
  178. };
  180. $.fn[ "outer" + name] = function( size, margin ) {
  181. if ( typeof size !== "number" ) {
  182. return orig[ "outer" + name ].call( this, size );
  183. }
  185. return this.each(function() {
  186. $( this).css( type, reduce( this, size, true, margin ) + "px" );
  187. });
  188. };
  189. });
  190. }
  192. // support: jQuery <1.8
  193. if ( !$.fn.addBack ) {
  194. $.fn.addBack = function( selector ) {
  195. return this.add( selector == null ?
  196. this.prevObject : this.prevObject.filter( selector )
  197. );
  198. };
  199. }
  201. // support: jQuery 1.6.1, 1.6.2 (http://bugs.jquery.com/ticket/9413)
  202. if ( $( "<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. }
  214. // deprecated
  215. $.ui.ie = !!/msie [\w.]+/.exec( navigator.userAgent.toLowerCase() );
  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 ),
  234. disableSelection: (function() {
  235. var eventType = "onselectstart" in document.createElement( "div" ) ?
  236. "selectstart" :
  237. "mousedown";
  239. return function() {
  240. return this.bind( eventType + ".ui-disableSelection", function( event ) {
  241. event.preventDefault();
  242. });
  243. };
  244. })(),
  246. enableSelection: function() {
  247. return this.unbind( ".ui-disableSelection" );
  248. },
  250. zIndex: function( zIndex ) {
  251. if ( zIndex !== undefined ) {
  252. return this.css( "zIndex", zIndex );
  253. }
  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. }
  276. return 0;
  277. }
  278. });
  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 ];
  294. if ( !set ) {
  295. return;
  296. }
  298. if ( !allowDisconnected && ( !instance.element[ 0 ].parentNode || instance.element[ 0 ].parentNode.nodeType === 11 ) ) {
  299. return;
  300. }
  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. };
  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. */
  323. var widget_uuid = 0,
  324. widget_slice = Array.prototype.slice;
  326. $.cleanData = (function( orig ) {
  327. return function( elems ) {
  328. var events, elem, i;
  329. for ( i = 0; (elem = elems[i]) != null; i++ ) {
  330. try {
  332. // Only trigger remove when necessary to save time
  333. events = $._data( elem, "events" );
  334. if ( events && events.remove ) {
  335. $( elem ).triggerHandler( "remove" );
  336. }
  338. // http://bugs.jquery.com/ticket/8235
  339. } catch ( e ) {}
  340. }
  341. orig( elems );
  342. };
  343. })( $.cleanData );
  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 ];
  352. name = name.split( "." )[ 1 ];
  353. fullName = namespace + "-" + name;
  355. if ( !prototype ) {
  356. prototype = base;
  357. base = $.Widget;
  358. }
  360. // create selector for plugin
  361. $.expr[ ":" ][ fullName.toLowerCase() ] = function( elem ) {
  362. return !!$.data( elem, fullName );
  363. };
  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. }
  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. });
  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;
  412. this._super = _super;
  413. this._superApply = _superApply;
  415. returnValue = value.apply( this, arguments );
  417. this._super = __super;
  418. this._superApply = __superApply;
  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. });
  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;
  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. }
  455. $.widget.bridge( name, constructor );
  457. return constructor;
  458. };
  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. };
  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;
  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 {
  518. // Allow multiple hashes to be passed on init
  519. if ( args.length ) {
  520. options = $.widget.extend.apply( null, [ options ].concat(args) );
  521. }
  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. }
  536. return returnValue;
  537. };
  538. };
  540. $.Widget = function( /* options, element */ ) {};
  541. $.Widget._childConstructors = [];
  543. $.Widget.prototype = {
  544. widgetName: "widget",
  545. widgetEventPrefix: "",
  546. defaultElement: "<div>",
  547. options: {
  548. disabled: false,
  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;
  559. this.bindings = $();
  560. this.hoverable = $();
  561. this.focusable = $();
  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. }
  580. this.options = $.widget.extend( {},
  581. this.options,
  582. this._getCreateOptions(),
  583. options );
  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,
  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" );
  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,
  618. widget: function() {
  619. return this.element;
  620. },
  622. option: function( key, value ) {
  623. var options = key,
  624. parts,
  625. curOption,
  626. i;
  628. if ( arguments.length === 0 ) {
  629. // don't return a reference to the internal hash
  630. return $.widget.extend( {}, this.options );
  631. }
  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. }
  657. this._setOptions( options );
  659. return this;
  660. },
  661. _setOptions: function( options ) {
  662. var key;
  664. for ( key in options ) {
  665. this._setOption( key, options[ key ] );
  666. }
  668. return this;
  669. },
  670. _setOption: function( key, value ) {
  671. this.options[ key ] = value;
  673. if ( key === "disabled" ) {
  674. this.widget()
  675. .toggleClass( this.widgetFullName + "-disabled", !!value );
  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. }
  684. return this;
  685. },
  687. enable: function() {
  688. return this._setOptions({ disabled: false });
  689. },
  690. disable: function() {
  691. return this._setOptions({ disabled: true });
  692. },
  694. _on: function( suppressDisabledCheck, element, handlers ) {
  695. var delegateElement,
  696. instance = this;
  698. // no suppressDisabledCheck flag, shuffle arguments
  699. if ( typeof suppressDisabledCheck !== "boolean" ) {
  700. handlers = element;
  701. element = suppressDisabledCheck;
  702. suppressDisabledCheck = false;
  703. }
  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. }
  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. }
  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. }
  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. },
  746. _off: function( element, eventName ) {
  747. eventName = (eventName || "").split( " " ).join( this.eventNamespace + " " ) +
  748. this.eventNamespace;
  749. element.unbind( eventName ).undelegate( eventName );
  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. },
  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. },
  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. },
  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. },
  790. _trigger: function( type, event, data ) {
  791. var prop, orig,
  792. callback = this.options[ type ];
  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 ];
  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. }
  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. };
  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. });
  856. var widget = $.widget;
  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. */
  871. var mouseHandled = false;
  872. $( document ).mouseup( function() {
  873. mouseHandled = false;
  874. });
  876. var 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;
  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. });
  898. this.started = false;
  899. },
  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. },
  912. _mouseDown: function(event) {
  913. // don't let more than one widget handle mouseStart
  914. if ( mouseHandled ) {
  915. return;
  916. }
  918. this._mouseMoved = false;
  920. // we may have missed mouseup (out of window)
  921. (this._mouseStarted && this._mouseUp(event));
  923. this._mouseDownEvent = event;
  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. }
  934. this.mouseDelayMet = !this.options.delay;
  935. if (!this.mouseDelayMet) {
  936. this._mouseDelayTimer = setTimeout(function() {
  937. that.mouseDelayMet = true;
  938. }, this.options.delay);
  939. }
  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. }
  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. }
  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. };
  962. this.document
  963. .bind( "mousemove." + this.widgetName, this._mouseMoveDelegate )
  964. .bind( "mouseup." + this.widgetName, this._mouseUpDelegate );
  966. event.preventDefault();
  968. mouseHandled = true;
  969. return true;
  970. },
  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);
  982. // Iframe mouseup check - mouseup occurred in another document
  983. } else if ( !event.which ) {
  984. return this._mouseUp( event );
  985. }
  986. }
  988. if ( event.which || event.button ) {
  989. this._mouseMoved = true;
  990. }
  992. if (this._mouseStarted) {
  993. this._mouseDrag(event);
  994. return event.preventDefault();
  995. }
  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. }
  1003. return !this._mouseStarted;
  1004. },
  1006. _mouseUp: function(event) {
  1007. this.document
  1008. .unbind( "mousemove." + this.widgetName, this._mouseMoveDelegate )
  1009. .unbind( "mouseup." + this.widgetName, this._mouseUpDelegate );
  1011. if (this._mouseStarted) {
  1012. this._mouseStarted = false;
  1014. if (event.target === this._mouseDownEvent.target) {
  1015. $.data(event.target, this.widgetName + ".preventClickEvent", true);
  1016. }
  1018. this._mouseStop(event);
  1019. }
  1021. mouseHandled = false;
  1022. return false;
  1023. },
  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. },
  1033. _mouseDelayMet: function(/* event */) {
  1034. return this.mouseDelayMet;
  1035. },
  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. });
  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. */
  1056. (function() {
  1058. $.ui = $.ui || {};
  1060. var 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;
  1071. function 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. }
  1078. function parseCss( element, property ) {
  1079. return parseInt( $.css( element, property ), 10 ) || 0;
  1080. }
  1082. function 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. }
  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];
  1121. $( "body" ).append( div );
  1122. w1 = innerDiv.offsetWidth;
  1123. div.css( "overflow", "scroll" );
  1125. w2 = innerDiv.offsetWidth;
  1127. if ( w1 === w2 ) {
  1128. w2 = div[0].clientWidth;
  1129. }
  1131. div.remove();
  1133. return (cachedScrollbarWidth = w1 - w2);
  1134. },
  1136. getWithinInfo: function( element ) {
  1137. var withinElement = $( element || window ),
  1138. isWindow = $.isWindow( withinElement[0] ),
  1139. isDocument = !!withinElement[ 0 ] && withinElement[ 0 ].nodeType === 9;
  1140. return {
  1141. element: withinElement,
  1142. isWindow: isWindow,
  1143. isDocument: isDocument,
  1144. offset: withinElement.offset() || { left: 0, top: 0 },
  1145. scrollLeft: withinElement.scrollLeft(),
  1146. scrollTop: withinElement.scrollTop(),
  1148. // support: jQuery 1.6.x
  1149. // jQuery 1.6 doesn't support .outerWidth/Height() on documents or windows
  1150. width: isWindow || isDocument ? withinElement.width() : withinElement.outerWidth(),
  1151. height: isWindow || isDocument ? withinElement.height() : withinElement.outerHeight()
  1152. };
  1153. }
  1154. };
  1156. $.fn.position = function( options ) {
  1157. if ( !options || !options.of ) {
  1158. return _position.apply( this, arguments );
  1159. }
  1161. // make a copy, we don't want to modify arguments
  1162. options = $.extend( {}, options );
  1164. var atOffset, targetWidth, targetHeight, targetOffset, basePosition, dimensions,
  1165. target = $( options.of ),
  1166. within = $.position.getWithinInfo( options.within ),
  1167. scrollInfo = $.position.getScrollInfo( within ),
  1168. collision = ( options.collision || "flip" ).split( " " ),
  1169. offsets = {};
  1171. dimensions = getDimensions( target );
  1172. if ( target[0].preventDefault ) {
  1173. // force left top to allow flipping
  1174. options.at = "left top";
  1175. }
  1176. targetWidth = dimensions.width;
  1177. targetHeight = dimensions.height;
  1178. targetOffset = dimensions.offset;
  1179. // clone to reuse original targetOffset later
  1180. basePosition = $.extend( {}, targetOffset );
  1182. // force my and at to have valid horizontal and vertical positions
  1183. // if a value is missing or invalid, it will be converted to center
  1184. $.each( [ "my", "at" ], function() {
  1185. var pos = ( options[ this ] || "" ).split( " " ),
  1186. horizontalOffset,
  1187. verticalOffset;
  1189. if ( pos.length === 1) {
  1190. pos = rhorizontal.test( pos[ 0 ] ) ?
  1191. pos.concat( [ "center" ] ) :
  1192. rvertical.test( pos[ 0 ] ) ?
  1193. [ "center" ].concat( pos ) :
  1194. [ "center", "center" ];
  1195. }
  1196. pos[ 0 ] = rhorizontal.test( pos[ 0 ] ) ? pos[ 0 ] : "center";
  1197. pos[ 1 ] = rvertical.test( pos[ 1 ] ) ? pos[ 1 ] : "center";
  1199. // calculate offsets
  1200. horizontalOffset = roffset.exec( pos[ 0 ] );
  1201. verticalOffset = roffset.exec( pos[ 1 ] );
  1202. offsets[ this ] = [
  1203. horizontalOffset ? horizontalOffset[ 0 ] : 0,
  1204. verticalOffset ? verticalOffset[ 0 ] : 0
  1205. ];
  1207. // reduce to just the positions without the offsets
  1208. options[ this ] = [
  1209. rposition.exec( pos[ 0 ] )[ 0 ],
  1210. rposition.exec( pos[ 1 ] )[ 0 ]
  1211. ];
  1212. });
  1214. // normalize collision option
  1215. if ( collision.length === 1 ) {
  1216. collision[ 1 ] = collision[ 0 ];
  1217. }
  1219. if ( options.at[ 0 ] === "right" ) {
  1220. basePosition.left += targetWidth;
  1221. } else if ( options.at[ 0 ] === "center" ) {
  1222. basePosition.left += targetWidth / 2;
  1223. }
  1225. if ( options.at[ 1 ] === "bottom" ) {
  1226. basePosition.top += targetHeight;
  1227. } else if ( options.at[ 1 ] === "center" ) {
  1228. basePosition.top += targetHeight / 2;
  1229. }
  1231. atOffset = getOffsets( offsets.at, targetWidth, targetHeight );
  1232. basePosition.left += atOffset[ 0 ];
  1233. basePosition.top += atOffset[ 1 ];
  1235. return this.each(function() {
  1236. var collisionPosition, using,
  1237. elem = $( this ),
  1238. elemWidth = elem.outerWidth(),
  1239. elemHeight = elem.outerHeight(),
  1240. marginLeft = parseCss( this, "marginLeft" ),
  1241. marginTop = parseCss( this, "marginTop" ),
  1242. collisionWidth = elemWidth + marginLeft + parseCss( this, "marginRight" ) + scrollInfo.width,
  1243. collisionHeight = elemHeight + marginTop + parseCss( this, "marginBottom" ) + scrollInfo.height,
  1244. position = $.extend( {}, basePosition ),
  1245. myOffset = getOffsets( offsets.my, elem.outerWidth(), elem.outerHeight() );
  1247. if ( options.my[ 0 ] === "right" ) {
  1248. position.left -= elemWidth;
  1249. } else if ( options.my[ 0 ] === "center" ) {
  1250. position.left -= elemWidth / 2;
  1251. }
  1253. if ( options.my[ 1 ] === "bottom" ) {
  1254. position.top -= elemHeight;
  1255. } else if ( options.my[ 1 ] === "center" ) {
  1256. position.top -= elemHeight / 2;
  1257. }
  1259. position.left += myOffset[ 0 ];
  1260. position.top += myOffset[ 1 ];
  1262. // if the browser doesn't support fractions, then round for consistent results
  1263. if ( !supportsOffsetFractions ) {
  1264. position.left = round( position.left );
  1265. position.top = round( position.top );
  1266. }
  1268. collisionPosition = {
  1269. marginLeft: marginLeft,
  1270. marginTop: marginTop
  1271. };
  1273. $.each( [ "left", "top" ], function( i, dir ) {
  1274. if ( $.ui.position[ collision[ i ] ] ) {
  1275. $.ui.position[ collision[ i ] ][ dir ]( position, {
  1276. targetWidth: targetWidth,
  1277. targetHeight: targetHeight,
  1278. elemWidth: elemWidth,
  1279. elemHeight: elemHeight,
  1280. collisionPosition: collisionPosition,
  1281. collisionWidth: collisionWidth,
  1282. collisionHeight: collisionHeight,
  1283. offset: [ atOffset[ 0 ] + myOffset[ 0 ], atOffset [ 1 ] + myOffset[ 1 ] ],
  1284. my: options.my,
  1285. at: options.at,
  1286. within: within,
  1287. elem: elem
  1288. });
  1289. }
  1290. });
  1292. if ( options.using ) {
  1293. // adds feedback as second argument to using callback, if present
  1294. using = function( props ) {
  1295. var left = targetOffset.left - position.left,
  1296. right = left + targetWidth - elemWidth,
  1297. top = targetOffset.top - position.top,
  1298. bottom = top + targetHeight - elemHeight,
  1299. feedback = {
  1300. target: {
  1301. element: target,
  1302. left: targetOffset.left,
  1303. top: targetOffset.top,
  1304. width: targetWidth,
  1305. height: targetHeight
  1306. },
  1307. element: {
  1308. element: elem,
  1309. left: position.left,
  1310. top: position.top,
  1311. width: elemWidth,
  1312. height: elemHeight
  1313. },
  1314. horizontal: right < 0 ? "left" : left > 0 ? "right" : "center",
  1315. vertical: bottom < 0 ? "top" : top > 0 ? "bottom" : "middle"
  1316. };
  1317. if ( targetWidth < elemWidth && abs( left + right ) < targetWidth ) {
  1318. feedback.horizontal = "center";
  1319. }
  1320. if ( targetHeight < elemHeight && abs( top + bottom ) < targetHeight ) {
  1321. feedback.vertical = "middle";
  1322. }
  1323. if ( max( abs( left ), abs( right ) ) > max( abs( top ), abs( bottom ) ) ) {
  1324. feedback.important = "horizontal";
  1325. } else {
  1326. feedback.important = "vertical";
  1327. }
  1328. options.using.call( this, props, feedback );
  1329. };
  1330. }
  1332. elem.offset( $.extend( position, { using: using } ) );
  1333. });
  1334. };
  1336. $.ui.position = {
  1337. fit: {
  1338. left: function( position, data ) {
  1339. var within = data.within,
  1340. withinOffset = within.isWindow ? within.scrollLeft : within.offset.left,
  1341. outerWidth = within.width,
  1342. collisionPosLeft = position.left - data.collisionPosition.marginLeft,
  1343. overLeft = withinOffset - collisionPosLeft,
  1344. overRight = collisionPosLeft + data.collisionWidth - outerWidth - withinOffset,
  1345. newOverRight;
  1347. // element is wider than within
  1348. if ( data.collisionWidth > outerWidth ) {
  1349. // element is initially over the left side of within
  1350. if ( overLeft > 0 && overRight <= 0 ) {
  1351. newOverRight = position.left + overLeft + data.collisionWidth - outerWidth - withinOffset;
  1352. position.left += overLeft - newOverRight;
  1353. // element is initially over right side of within
  1354. } else if ( overRight > 0 && overLeft <= 0 ) {
  1355. position.left = withinOffset;
  1356. // element is initially over both left and right sides of within
  1357. } else {
  1358. if ( overLeft > overRight ) {
  1359. position.left = withinOffset + outerWidth - data.collisionWidth;
  1360. } else {
  1361. position.left = withinOffset;
  1362. }
  1363. }
  1364. // too far left -> align with left edge
  1365. } else if ( overLeft > 0 ) {
  1366. position.left += overLeft;
  1367. // too far right -> align with right edge
  1368. } else if ( overRight > 0 ) {
  1369. position.left -= overRight;
  1370. // adjust based on position and margin
  1371. } else {
  1372. position.left = max( position.left - collisionPosLeft, position.left );
  1373. }
  1374. },
  1375. top: function( position, data ) {
  1376. var within = data.within,
  1377. withinOffset = within.isWindow ? within.scrollTop : within.offset.top,
  1378. outerHeight = data.within.height,
  1379. collisionPosTop = position.top - data.collisionPosition.marginTop,
  1380. overTop = withinOffset - collisionPosTop,
  1381. overBottom = collisionPosTop + data.collisionHeight - outerHeight - withinOffset,
  1382. newOverBottom;
  1384. // element is taller than within
  1385. if ( data.collisionHeight > outerHeight ) {
  1386. // element is initially over the top of within
  1387. if ( overTop > 0 && overBottom <= 0 ) {
  1388. newOverBottom = position.top + overTop + data.collisionHeight - outerHeight - withinOffset;
  1389. position.top += overTop - newOverBottom;
  1390. // element is initially over bottom of within
  1391. } else if ( overBottom > 0 && overTop <= 0 ) {
  1392. position.top = withinOffset;
  1393. // element is initially over both top and bottom of within
  1394. } else {
  1395. if ( overTop > overBottom ) {
  1396. position.top = withinOffset + outerHeight - data.collisionHeight;
  1397. } else {
  1398. position.top = withinOffset;
  1399. }
  1400. }
  1401. // too far up -> align with top
  1402. } else if ( overTop > 0 ) {
  1403. position.top += overTop;
  1404. // too far down -> align with bottom edge
  1405. } else if ( overBottom > 0 ) {
  1406. position.top -= overBottom;
  1407. // adjust based on position and margin
  1408. } else {
  1409. position.top = max( position.top - collisionPosTop, position.top );
  1410. }
  1411. }
  1412. },
  1413. flip: {
  1414. left: function( position, data ) {
  1415. var within = data.within,
  1416. withinOffset = within.offset.left + within.scrollLeft,
  1417. outerWidth = within.width,
  1418. offsetLeft = within.isWindow ? within.scrollLeft : within.offset.left,
  1419. collisionPosLeft = position.left - data.collisionPosition.marginLeft,
  1420. overLeft = collisionPosLeft - offsetLeft,
  1421. overRight = collisionPosLeft + data.collisionWidth - outerWidth - offsetLeft,
  1422. myOffset = data.my[ 0 ] === "left" ?
  1423. -data.elemWidth :
  1424. data.my[ 0 ] === "right" ?
  1425. data.elemWidth :
  1426. 0,
  1427. atOffset = data.at[ 0 ] === "left" ?
  1428. data.targetWidth :
  1429. data.at[ 0 ] === "right" ?
  1430. -data.targetWidth :
  1431. 0,
  1432. offset = -2 * data.offset[ 0 ],
  1433. newOverRight,
  1434. newOverLeft;
  1436. if ( overLeft < 0 ) {
  1437. newOverRight = position.left + myOffset + atOffset + offset + data.collisionWidth - outerWidth - withinOffset;
  1438. if ( newOverRight < 0 || newOverRight < abs( overLeft ) ) {
  1439. position.left += myOffset + atOffset + offset;
  1440. }
  1441. } else if ( overRight > 0 ) {
  1442. newOverLeft = position.left - data.collisionPosition.marginLeft + myOffset + atOffset + offset - offsetLeft;
  1443. if ( newOverLeft > 0 || abs( newOverLeft ) < overRight ) {
  1444. position.left += myOffset + atOffset + offset;
  1445. }
  1446. }
  1447. },
  1448. top: function( position, data ) {
  1449. var within = data.within,
  1450. withinOffset = within.offset.top + within.scrollTop,
  1451. outerHeight = within.height,
  1452. offsetTop = within.isWindow ? within.scrollTop : within.offset.top,
  1453. collisionPosTop = position.top - data.collisionPosition.marginTop,
  1454. overTop = collisionPosTop - offsetTop,
  1455. overBottom = collisionPosTop + data.collisionHeight - outerHeight - offsetTop,
  1456. top = data.my[ 1 ] === "top",
  1457. myOffset = top ?
  1458. -data.elemHeight :
  1459. data.my[ 1 ] === "bottom" ?
  1460. data.elemHeight :
  1461. 0,
  1462. atOffset = data.at[ 1 ] === "top" ?
  1463. data.targetHeight :
  1464. data.at[ 1 ] === "bottom" ?
  1465. -data.targetHeight :
  1466. 0,
  1467. offset = -2 * data.offset[ 1 ],
  1468. newOverTop,
  1469. newOverBottom;
  1470. if ( overTop < 0 ) {
  1471. newOverBottom = position.top + myOffset + atOffset + offset + data.collisionHeight - outerHeight - withinOffset;
  1472. if ( newOverBottom < 0 || newOverBottom < abs( overTop ) ) {
  1473. position.top += myOffset + atOffset + offset;
  1474. }
  1475. } else if ( overBottom > 0 ) {
  1476. newOverTop = position.top - data.collisionPosition.marginTop + myOffset + atOffset + offset - offsetTop;
  1477. if ( newOverTop > 0 || abs( newOverTop ) < overBottom ) {
  1478. position.top += myOffset + atOffset + offset;
  1479. }
  1480. }
  1481. }
  1482. },
  1483. flipfit: {
  1484. left: function() {
  1485. $.ui.position.flip.left.apply( this, arguments );
  1486. $.ui.position.fit.left.apply( this, arguments );
  1487. },
  1488. top: function() {
  1489. $.ui.position.flip.top.apply( this, arguments );
  1490. $.ui.position.fit.top.apply( this, arguments );
  1491. }
  1492. }
  1493. };
  1495. // fraction support test
  1496. (function() {
  1497. var testElement, testElementParent, testElementStyle, offsetLeft, i,
  1498. body = document.getElementsByTagName( "body" )[ 0 ],
  1499. div = document.createElement( "div" );
  1501. //Create a "fake body" for testing based on method used in jQuery.support
  1502. testElement = document.createElement( body ? "div" : "body" );
  1503. testElementStyle = {
  1504. visibility: "hidden",
  1505. width: 0,
  1506. height: 0,
  1507. border: 0,
  1508. margin: 0,
  1509. background: "none"
  1510. };
  1511. if ( body ) {
  1512. $.extend( testElementStyle, {
  1513. position: "absolute",
  1514. left: "-1000px",
  1515. top: "-1000px"
  1516. });
  1517. }
  1518. for ( i in testElementStyle ) {
  1519. testElement.style[ i ] = testElementStyle[ i ];
  1520. }
  1521. testElement.appendChild( div );
  1522. testElementParent = body || document.documentElement;
  1523. testElementParent.insertBefore( testElement, testElementParent.firstChild );
  1525. div.style.cssText = "position: absolute; left: 10.7432222px;";
  1527. offsetLeft = $( div ).offset().left;
  1528. supportsOffsetFractions = offsetLeft > 10 && offsetLeft < 11;
  1530. testElement.innerHTML = "";
  1531. testElementParent.removeChild( testElement );
  1532. })();
  1534. })();
  1536. var position = $.ui.position;
  1539. /*!
  1540. * jQuery UI Draggable 1.11.4
  1541. * http://jqueryui.com
  1542. *
  1543. * Copyright jQuery Foundation and other contributors
  1544. * Released under the MIT license.
  1545. * http://jquery.org/license
  1546. *
  1547. * http://api.jqueryui.com/draggable/
  1548. */
  1551. $.widget("ui.draggable", $.ui.mouse, {
  1552. version: "1.11.4",
  1553. widgetEventPrefix: "drag",
  1554. options: {
  1555. addClasses: true,
  1556. appendTo: "parent",
  1557. axis: false,
  1558. connectToSortable: false,
  1559. containment: false,
  1560. cursor: "auto",
  1561. cursorAt: false,
  1562. grid: false,
  1563. handle: false,
  1564. helper: "original",
  1565. iframeFix: false,
  1566. opacity: false,
  1567. refreshPositions: false,
  1568. revert: false,
  1569. revertDuration: 500,
  1570. scope: "default",
  1571. scroll: true,
  1572. scrollSensitivity: 20,
  1573. scrollSpeed: 20,
  1574. snap: false,
  1575. snapMode: "both",
  1576. snapTolerance: 20,
  1577. stack: false,
  1578. zIndex: false,
  1580. // callbacks
  1581. drag: null,
  1582. start: null,
  1583. stop: null
  1584. },
  1585. _create: function() {
  1587. if ( this.options.helper === "original" ) {
  1588. this._setPositionRelative();
  1589. }
  1590. if (this.options.addClasses){
  1591. this.element.addClass("ui-draggable");
  1592. }
  1593. if (this.options.disabled){
  1594. this.element.addClass("ui-draggable-disabled");
  1595. }
  1596. this._setHandleClassName();
  1598. this._mouseInit();
  1599. },
  1601. _setOption: function( key, value ) {
  1602. this._super( key, value );
  1603. if ( key === "handle" ) {
  1604. this._removeHandleClassName();
  1605. this._setHandleClassName();
  1606. }
  1607. },
  1609. _destroy: function() {
  1610. if ( ( this.helper || this.element ).is( ".ui-draggable-dragging" ) ) {
  1611. this.destroyOnClear = true;
  1612. return;
  1613. }
  1614. this.element.removeClass( "ui-draggable ui-draggable-dragging ui-draggable-disabled" );
  1615. this._removeHandleClassName();
  1616. this._mouseDestroy();
  1617. },
  1619. _mouseCapture: function(event) {
  1620. var o = this.options;
  1622. this._blurActiveElement( event );
  1624. // among others, prevent a drag on a resizable-handle
  1625. if (this.helper || o.disabled || $(event.target).closest(".ui-resizable-handle").length > 0) {
  1626. return false;
  1627. }
  1629. //Quit if we're not on a valid handle
  1630. this.handle = this._getHandle(event);
  1631. if (!this.handle) {
  1632. return false;
  1633. }
  1635. this._blockFrames( o.iframeFix === true ? "iframe" : o.iframeFix );
  1637. return true;
  1639. },
  1641. _blockFrames: function( selector ) {
  1642. this.iframeBlocks = this.document.find( selector ).map(function() {
  1643. var iframe = $( this );
  1645. return $( "<div>" )
  1646. .css( "position", "absolute" )
  1647. .appendTo( iframe.parent() )
  1648. .outerWidth( iframe.outerWidth() )
  1649. .outerHeight( iframe.outerHeight() )
  1650. .offset( iframe.offset() )[ 0 ];
  1651. });
  1652. },
  1654. _unblockFrames: function() {
  1655. if ( this.iframeBlocks ) {
  1656. this.iframeBlocks.remove();
  1657. delete this.iframeBlocks;
  1658. }
  1659. },
  1661. _blurActiveElement: function( event ) {
  1662. var document = this.document[ 0 ];
  1664. // Only need to blur if the event occurred on the draggable itself, see #10527
  1665. if ( !this.handleElement.is( event.target ) ) {
  1666. return;
  1667. }
  1669. // support: IE9
  1670. // IE9 throws an "Unspecified error" accessing document.activeElement from an <iframe>
  1671. try {
  1673. // Support: IE9, IE10
  1674. // If the <body> is blurred, IE will switch windows, see #9520
  1675. if ( document.activeElement && document.activeElement.nodeName.toLowerCase() !== "body" ) {
  1677. // Blur any element that currently has focus, see #4261
  1678. $( document.activeElement ).blur();
  1679. }
  1680. } catch ( error ) {}
  1681. },
  1683. _mouseStart: function(event) {
  1685. var o = this.options;
  1687. //Create and append the visible helper
  1688. this.helper = this._createHelper(event);
  1690. this.helper.addClass("ui-draggable-dragging");
  1692. //Cache the helper size
  1693. this._cacheHelperProportions();
  1695. //If ddmanager is used for droppables, set the global draggable
  1696. if ($.ui.ddmanager) {
  1697. $.ui.ddmanager.current = this;
  1698. }
  1700. /*
  1701. * - Position generation -
  1702. * This block generates everything position related - it's the core of draggables.
  1703. */
  1705. //Cache the margins of the original element
  1706. this._cacheMargins();
  1708. //Store the helper's css position
  1709. this.cssPosition = this.helper.css( "position" );
  1710. this.scrollParent = this.helper.scrollParent( true );
  1711. this.offsetParent = this.helper.offsetParent();
  1712. this.hasFixedAncestor = this.helper.parents().filter(function() {
  1713. return $( this ).css( "position" ) === "fixed";
  1714. }).length > 0;
  1716. //The element's absolute position on the page minus margins
  1717. this.positionAbs = this.element.offset();
  1718. this._refreshOffsets( event );
  1720. //Generate the original position
  1721. this.originalPosition = this.position = this._generatePosition( event, false );
  1722. this.originalPageX = event.pageX;
  1723. this.originalPageY = event.pageY;
  1725. //Adjust the mouse offset relative to the helper if "cursorAt" is supplied
  1726. (o.cursorAt && this._adjustOffsetFromHelper(o.cursorAt));
  1728. //Set a containment if given in the options
  1729. this._setContainment();
  1731. //Trigger event + callbacks
  1732. if (this._trigger("start", event) === false) {
  1733. this._clear();
  1734. return false;
  1735. }
  1737. //Recache the helper size
  1738. this._cacheHelperProportions();
  1740. //Prepare the droppable offsets
  1741. if ($.ui.ddmanager && !o.dropBehaviour) {
  1742. $.ui.ddmanager.prepareOffsets(this, event);
  1743. }
  1745. // Reset helper's right/bottom css if they're set and set explicit width/height instead
  1746. // as this prevents resizing of elements with right/bottom set (see #7772)
  1747. this._normalizeRightBottom();
  1749. this._mouseDrag(event, true); //Execute the drag once - this causes the helper not to be visible before getting its correct position
  1751. //If the ddmanager is used for droppables, inform the manager that dragging has started (see #5003)
  1752. if ( $.ui.ddmanager ) {
  1753. $.ui.ddmanager.dragStart(this, event);
  1754. }
  1756. return true;
  1757. },
  1759. _refreshOffsets: function( event ) {
  1760. this.offset = {
  1761. top: this.positionAbs.top - this.margins.top,
  1762. left: this.positionAbs.left - this.margins.left,
  1763. scroll: false,
  1764. parent: this._getParentOffset(),
  1765. relative: this._getRelativeOffset()
  1766. };
  1768. this.offset.click = {
  1769. left: event.pageX - this.offset.left,
  1770. top: event.pageY - this.offset.top
  1771. };
  1772. },
  1774. _mouseDrag: function(event, noPropagation) {
  1775. // reset any necessary cached properties (see #5009)
  1776. if ( this.hasFixedAncestor ) {
  1777. this.offset.parent = this._getParentOffset();
  1778. }
  1780. //Compute the helpers position
  1781. this.position = this._generatePosition( event, true );
  1782. this.positionAbs = this._convertPositionTo("absolute");
  1784. //Call plugins and callbacks and use the resulting position if something is returned
  1785. if (!noPropagation) {
  1786. var ui = this._uiHash();
  1787. if (this._trigger("drag", event, ui) === false) {
  1788. this._mouseUp({});
  1789. return false;
  1790. }
  1791. this.position = ui.position;
  1792. }
  1794. this.helper[ 0 ].style.left = this.position.left + "px";
  1795. this.helper[ 0 ].style.top = this.position.top + "px";
  1797. if ($.ui.ddmanager) {
  1798. $.ui.ddmanager.drag(this, event);
  1799. }
  1801. return false;
  1802. },
  1804. _mouseStop: function(event) {
  1806. //If we are using droppables, inform the manager about the drop
  1807. var that = this,
  1808. dropped = false;
  1809. if ($.ui.ddmanager && !this.options.dropBehaviour) {
  1810. dropped = $.ui.ddmanager.drop(this, event);
  1811. }
  1813. //if a drop comes from outside (a sortable)
  1814. if (this.dropped) {
  1815. dropped = this.dropped;
  1816. this.dropped = false;
  1817. }
  1819. 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))) {
  1820. $(this.helper).animate(this.originalPosition, parseInt(this.options.revertDuration, 10), function() {
  1821. if (that._trigger("stop", event) !== false) {
  1822. that._clear();
  1823. }
  1824. });
  1825. } else {
  1826. if (this._trigger("stop", event) !== false) {
  1827. this._clear();
  1828. }
  1829. }
  1831. return false;
  1832. },
  1834. _mouseUp: function( event ) {
  1835. this._unblockFrames();
  1837. //If the ddmanager is used for droppables, inform the manager that dragging has stopped (see #5003)
  1838. if ( $.ui.ddmanager ) {
  1839. $.ui.ddmanager.dragStop(this, event);
  1840. }
  1842. // Only need to focus if the event occurred on the draggable itself, see #10527
  1843. if ( this.handleElement.is( event.target ) ) {
  1844. // The interaction is over; whether or not the click resulted in a drag, focus the element
  1845. this.element.focus();
  1846. }
  1848. return $.ui.mouse.prototype._mouseUp.call(this, event);
  1849. },
  1851. cancel: function() {
  1853. if (this.helper.is(".ui-draggable-dragging")) {
  1854. this._mouseUp({});
  1855. } else {
  1856. this._clear();
  1857. }
  1859. return this;
  1861. },
  1863. _getHandle: function(event) {
  1864. return this.options.handle ?
  1865. !!$( event.target ).closest( this.element.find( this.options.handle ) ).length :
  1866. true;
  1867. },
  1869. _setHandleClassName: function() {
  1870. this.handleElement = this.options.handle ?
  1871. this.element.find( this.options.handle ) : this.element;
  1872. this.handleElement.addClass( "ui-draggable-handle" );
  1873. },
  1875. _removeHandleClassName: function() {
  1876. this.handleElement.removeClass( "ui-draggable-handle" );
  1877. },
  1879. _createHelper: function(event) {
  1881. var o = this.options,
  1882. helperIsFunction = $.isFunction( o.helper ),
  1883. helper = helperIsFunction ?
  1884. $( o.helper.apply( this.element[ 0 ], [ event ] ) ) :
  1885. ( o.helper === "clone" ?
  1886. this.element.clone().removeAttr( "id" ) :
  1887. this.element );
  1889. if (!helper.parents("body").length) {
  1890. helper.appendTo((o.appendTo === "parent" ? this.element[0].parentNode : o.appendTo));
  1891. }
  1893. // http://bugs.jqueryui.com/ticket/9446
  1894. // a helper function can return the original element
  1895. // which wouldn't have been set to relative in _create
  1896. if ( helperIsFunction && helper[ 0 ] === this.element[ 0 ] ) {
  1897. this._setPositionRelative();
  1898. }
  1900. if (helper[0] !== this.element[0] && !(/(fixed|absolute)/).test(helper.css("position"))) {
  1901. helper.css("position", "absolute");
  1902. }
  1904. return helper;
  1906. },
  1908. _setPositionRelative: function() {
  1909. if ( !( /^(?:r|a|f)/ ).test( this.element.css( "position" ) ) ) {
  1910. this.element[ 0 ].style.position = "relative";
  1911. }
  1912. },
  1914. _adjustOffsetFromHelper: function(obj) {
  1915. if (typeof obj === "string") {
  1916. obj = obj.split(" ");
  1917. }
  1918. if ($.isArray(obj)) {
  1919. obj = { left: +obj[0], top: +obj[1] || 0 };
  1920. }
  1921. if ("left" in obj) {
  1922. this.offset.click.left = obj.left + this.margins.left;
  1923. }
  1924. if ("right" in obj) {
  1925. this.offset.click.left = this.helperProportions.width - obj.right + this.margins.left;
  1926. }
  1927. if ("top" in obj) {
  1928. this.offset.click.top = obj.top + this.margins.top;
  1929. }
  1930. if ("bottom" in obj) {
  1931. this.offset.click.top = this.helperProportions.height - obj.bottom + this.margins.top;
  1932. }
  1933. },
  1935. _isRootNode: function( element ) {
  1936. return ( /(html|body)/i ).test( element.tagName ) || element === this.document[ 0 ];
  1937. },
  1939. _getParentOffset: function() {
  1941. //Get the offsetParent and cache its position
  1942. var po = this.offsetParent.offset(),
  1943. document = this.document[ 0 ];
  1945. // This is a special case where we need to modify a offset calculated on start, since the following happened:
  1946. // 1. The position of the helper is absolute, so it's position is calculated based on the next positioned parent
  1947. // 2. The actual offset parent is a child of the scroll parent, and the scroll parent isn't the document, which means that
  1948. // the scroll is included in the initial calculation of the offset of the parent, and never recalculated upon drag
  1949. if (this.cssPosition === "absolute" && this.scrollParent[0] !== document && $.contains(this.scrollParent[0], this.offsetParent[0])) {
  1950. po.left += this.scrollParent.scrollLeft();
  1951. po.top += this.scrollParent.scrollTop();
  1952. }
  1954. if ( this._isRootNode( this.offsetParent[ 0 ] ) ) {
  1955. po = { top: 0, left: 0 };
  1956. }
  1958. return {
  1959. top: po.top + (parseInt(this.offsetParent.css("borderTopWidth"), 10) || 0),
  1960. left: po.left + (parseInt(this.offsetParent.css("borderLeftWidth"), 10) || 0)
  1961. };
  1963. },
  1965. _getRelativeOffset: function() {
  1966. if ( this.cssPosition !== "relative" ) {
  1967. return { top: 0, left: 0 };
  1968. }
  1970. var p = this.element.position(),
  1971. scrollIsRootNode = this._isRootNode( this.scrollParent[ 0 ] );
  1973. return {
  1974. top: p.top - ( parseInt(this.helper.css( "top" ), 10) || 0 ) + ( !scrollIsRootNode ? this.scrollParent.scrollTop() : 0 ),
  1975. left: p.left - ( parseInt(this.helper.css( "left" ), 10) || 0 ) + ( !scrollIsRootNode ? this.scrollParent.scrollLeft() : 0 )
  1976. };
  1978. },
  1980. _cacheMargins: function() {
  1981. this.margins = {
  1982. left: (parseInt(this.element.css("marginLeft"), 10) || 0),
  1983. top: (parseInt(this.element.css("marginTop"), 10) || 0),
  1984. right: (parseInt(this.element.css("marginRight"), 10) || 0),
  1985. bottom: (parseInt(this.element.css("marginBottom"), 10) || 0)
  1986. };
  1987. },
  1989. _cacheHelperProportions: function() {
  1990. this.helperProportions = {
  1991. width: this.helper.outerWidth(),
  1992. height: this.helper.outerHeight()
  1993. };
  1994. },
  1996. _setContainment: function() {
  1998. var isUserScrollable, c, ce,
  1999. o = this.options,
  2000. document = this.document[ 0 ];
  2002. this.relativeContainer = null;
  2004. if ( !o.containment ) {
  2005. this.containment = null;
  2006. return;
  2007. }
  2009. if ( o.containment === "window" ) {
  2010. this.containment = [
  2011. $( window ).scrollLeft() - this.offset.relative.left - this.offset.parent.left,
  2012. $( window ).scrollTop() - this.offset.relative.top - this.offset.parent.top,
  2013. $( window ).scrollLeft() + $( window ).width() - this.helperProportions.width - this.margins.left,
  2014. $( window ).scrollTop() + ( $( window ).height() || document.body.parentNode.scrollHeight ) - this.helperProportions.height - this.margins.top
  2015. ];
  2016. return;
  2017. }
  2019. if ( o.containment === "document") {
  2020. this.containment = [
  2021. 0,
  2022. 0,
  2023. $( document ).width() - this.helperProportions.width - this.margins.left,
  2024. ( $( document ).height() || document.body.parentNode.scrollHeight ) - this.helperProportions.height - this.margins.top
  2025. ];
  2026. return;
  2027. }
  2029. if ( o.containment.constructor === Array ) {
  2030. this.containment = o.containment;
  2031. return;
  2032. }
  2034. if ( o.containment === "parent" ) {
  2035. o.containment = this.helper[ 0 ].parentNode;
  2036. }
  2038. c = $( o.containment );
  2039. ce = c[ 0 ];
  2041. if ( !ce ) {
  2042. return;
  2043. }
  2045. isUserScrollable = /(scroll|auto)/.test( c.css( "overflow" ) );
  2047. this.containment = [
  2048. ( parseInt( c.css( "borderLeftWidth" ), 10 ) || 0 ) + ( parseInt( c.css( "paddingLeft" ), 10 ) || 0 ),
  2049. ( parseInt( c.css( "borderTopWidth" ), 10 ) || 0 ) + ( parseInt( c.css( "paddingTop" ), 10 ) || 0 ),
  2050. ( isUserScrollable ? Math.max( ce.scrollWidth, ce.offsetWidth ) : ce.offsetWidth ) -
  2051. ( parseInt( c.css( "borderRightWidth" ), 10 ) || 0 ) -
  2052. ( parseInt( c.css( "paddingRight" ), 10 ) || 0 ) -
  2053. this.helperProportions.width -
  2054. this.margins.left -
  2055. this.margins.right,
  2056. ( isUserScrollable ? Math.max( ce.scrollHeight, ce.offsetHeight ) : ce.offsetHeight ) -
  2057. ( parseInt( c.css( "borderBottomWidth" ), 10 ) || 0 ) -
  2058. ( parseInt( c.css( "paddingBottom" ), 10 ) || 0 ) -
  2059. this.helperProportions.height -
  2060. this.margins.top -
  2061. this.margins.bottom
  2062. ];
  2063. this.relativeContainer = c;
  2064. },
  2066. _convertPositionTo: function(d, pos) {
  2068. if (!pos) {
  2069. pos = this.position;
  2070. }
  2072. var mod = d === "absolute" ? 1 : -1,
  2073. scrollIsRootNode = this._isRootNode( this.scrollParent[ 0 ] );
  2075. return {
  2076. top: (
  2077. pos.top + // The absolute mouse position
  2078. this.offset.relative.top * mod + // Only for relative positioned nodes: Relative offset from element to offset parent
  2079. this.offset.parent.top * mod - // The offsetParent's offset without borders (offset + border)
  2080. ( ( this.cssPosition === "fixed" ? -this.offset.scroll.top : ( scrollIsRootNode ? 0 : this.offset.scroll.top ) ) * mod)
  2081. ),
  2082. left: (
  2083. pos.left + // The absolute mouse position
  2084. this.offset.relative.left * mod + // Only for relative positioned nodes: Relative offset from element to offset parent
  2085. this.offset.parent.left * mod - // The offsetParent's offset without borders (offset + border)
  2086. ( ( this.cssPosition === "fixed" ? -this.offset.scroll.left : ( scrollIsRootNode ? 0 : this.offset.scroll.left ) ) * mod)
  2087. )
  2088. };
  2090. },
  2092. _generatePosition: function( event, constrainPosition ) {
  2094. var containment, co, top, left,
  2095. o = this.options,
  2096. scrollIsRootNode = this._isRootNode( this.scrollParent[ 0 ] ),
  2097. pageX = event.pageX,
  2098. pageY = event.pageY;
  2100. // Cache the scroll
  2101. if ( !scrollIsRootNode || !this.offset.scroll ) {
  2102. this.offset.scroll = {
  2103. top: this.scrollParent.scrollTop(),
  2104. left: this.scrollParent.scrollLeft()
  2105. };
  2106. }
  2108. /*
  2109. * - Position constraining -
  2110. * Constrain the position to a mix of grid, containment.
  2111. */
  2113. // If we are not dragging yet, we won't check for options
  2114. if ( constrainPosition ) {
  2115. if ( this.containment ) {
  2116. if ( this.relativeContainer ){
  2117. co = this.relativeContainer.offset();
  2118. containment = [
  2119. this.containment[ 0 ] + co.left,
  2120. this.containment[ 1 ] + co.top,
  2121. this.containment[ 2 ] + co.left,
  2122. this.containment[ 3 ] + co.top
  2123. ];
  2124. } else {
  2125. containment = this.containment;
  2126. }
  2128. if (event.pageX - this.offset.click.left < containment[0]) {
  2129. pageX = containment[0] + this.offset.click.left;
  2130. }
  2131. if (event.pageY - this.offset.click.top < containment[1]) {
  2132. pageY = containment[1] + this.offset.click.top;
  2133. }
  2134. if (event.pageX - this.offset.click.left > containment[2]) {
  2135. pageX = containment[2] + this.offset.click.left;
  2136. }
  2137. if (event.pageY - this.offset.click.top > containment[3]) {
  2138. pageY = containment[3] + this.offset.click.top;
  2139. }
  2140. }
  2142. if (o.grid) {
  2143. //Check for grid elements set to 0 to prevent divide by 0 error causing invalid argument errors in IE (see ticket #6950)
  2144. top = o.grid[1] ? this.originalPageY + Math.round((pageY - this.originalPageY) / o.grid[1]) * o.grid[1] : this.originalPageY;
  2145. 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;
  2147. left = o.grid[0] ? this.originalPageX + Math.round((pageX - this.originalPageX) / o.grid[0]) * o.grid[0] : this.originalPageX;
  2148. 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;
  2149. }
  2151. if ( o.axis === "y" ) {
  2152. pageX = this.originalPageX;
  2153. }
  2155. if ( o.axis === "x" ) {
  2156. pageY = this.originalPageY;
  2157. }
  2158. }
  2160. return {
  2161. top: (
  2162. pageY - // The absolute mouse position
  2163. this.offset.click.top - // Click offset (relative to the element)
  2164. this.offset.relative.top - // Only for relative positioned nodes: Relative offset from element to offset parent
  2165. this.offset.parent.top + // The offsetParent's offset without borders (offset + border)
  2166. ( this.cssPosition === "fixed" ? -this.offset.scroll.top : ( scrollIsRootNode ? 0 : this.offset.scroll.top ) )
  2167. ),
  2168. left: (
  2169. pageX - // The absolute mouse position
  2170. this.offset.click.left - // Click offset (relative to the element)
  2171. this.offset.relative.left - // Only for relative positioned nodes: Relative offset from element to offset parent
  2172. this.offset.parent.left + // The offsetParent's offset without borders (offset + border)
  2173. ( this.cssPosition === "fixed" ? -this.offset.scroll.left : ( scrollIsRootNode ? 0 : this.offset.scroll.left ) )
  2174. )
  2175. };
  2177. },
  2179. _clear: function() {
  2180. this.helper.removeClass("ui-draggable-dragging");
  2181. if (this.helper[0] !== this.element[0] && !this.cancelHelperRemoval) {
  2182. this.helper.remove();
  2183. }
  2184. this.helper = null;
  2185. this.cancelHelperRemoval = false;
  2186. if ( this.destroyOnClear ) {
  2187. this.destroy();
  2188. }
  2189. },
  2191. _normalizeRightBottom: function() {
  2192. if ( this.options.axis !== "y" && this.helper.css( "right" ) !== "auto" ) {
  2193. this.helper.width( this.helper.width() );
  2194. this.helper.css( "right", "auto" );
  2195. }
  2196. if ( this.options.axis !== "x" && this.helper.css( "bottom" ) !== "auto" ) {
  2197. this.helper.height( this.helper.height() );
  2198. this.helper.css( "bottom", "auto" );
  2199. }
  2200. },
  2202. // From now on bulk stuff - mainly helpers
  2204. _trigger: function( type, event, ui ) {
  2205. ui = ui || this._uiHash();
  2206. $.ui.plugin.call( this, type, [ event, ui, this ], true );
  2208. // Absolute position and offset (see #6884 ) have to be recalculated after plugins
  2209. if ( /^(drag|start|stop)/.test( type ) ) {
  2210. this.positionAbs = this._convertPositionTo( "absolute" );
  2211. ui.offset = this.positionAbs;
  2212. }
  2213. return $.Widget.prototype._trigger.call( this, type, event, ui );
  2214. },
  2216. plugins: {},
  2218. _uiHash: function() {
  2219. return {
  2220. helper: this.helper,
  2221. position: this.position,
  2222. originalPosition: this.originalPosition,
  2223. offset: this.positionAbs
  2224. };
  2225. }
  2227. });
  2229. $.ui.plugin.add( "draggable", "connectToSortable", {
  2230. start: function( event, ui, draggable ) {
  2231. var uiSortable = $.extend( {}, ui, {
  2232. item: draggable.element
  2233. });
  2235. draggable.sortables = [];
  2236. $( draggable.options.connectToSortable ).each(function() {
  2237. var sortable = $( this ).sortable( "instance" );
  2239. if ( sortable && !sortable.options.disabled ) {
  2240. draggable.sortables.push( sortable );
  2242. // refreshPositions is called at drag start to refresh the containerCache
  2243. // which is used in drag. This ensures it's initialized and synchronized
  2244. // with any changes that might have happened on the page since initialization.
  2245. sortable.refreshPositions();
  2246. sortable._trigger("activate", event, uiSortable);
  2247. }
  2248. });
  2249. },
  2250. stop: function( event, ui, draggable ) {
  2251. var uiSortable = $.extend( {}, ui, {
  2252. item: draggable.element
  2253. });
  2255. draggable.cancelHelperRemoval = false;
  2257. $.each( draggable.sortables, function() {
  2258. var sortable = this;
  2260. if ( sortable.isOver ) {
  2261. sortable.isOver = 0;
  2263. // Allow this sortable to handle removing the helper
  2264. draggable.cancelHelperRemoval = true;
  2265. sortable.cancelHelperRemoval = false;
  2267. // Use _storedCSS To restore properties in the sortable,
  2268. // as this also handles revert (#9675) since the draggable
  2269. // may have modified them in unexpected ways (#8809)
  2270. sortable._storedCSS = {
  2271. position: sortable.placeholder.css( "position" ),
  2272. top: sortable.placeholder.css( "top" ),
  2273. left: sortable.placeholder.css( "left" )
  2274. };
  2276. sortable._mouseStop(event);
  2278. // Once drag has ended, the sortable should return to using
  2279. // its original helper, not the shared helper from draggable
  2280. sortable.options.helper = sortable.options._helper;
  2281. } else {
  2282. // Prevent this Sortable from removing the helper.
  2283. // However, don't set the draggable to remove the helper
  2284. // either as another connected Sortable may yet handle the removal.
  2285. sortable.cancelHelperRemoval = true;
  2287. sortable._trigger( "deactivate", event, uiSortable );
  2288. }
  2289. });
  2290. },
  2291. drag: function( event, ui, draggable ) {
  2292. $.each( draggable.sortables, function() {
  2293. var innermostIntersecting = false,
  2294. sortable = this;
  2296. // Copy over variables that sortable's _intersectsWith uses
  2297. sortable.positionAbs = draggable.positionAbs;
  2298. sortable.helperProportions = draggable.helperProportions;
  2299. sortable.offset.click = draggable.offset.click;
  2301. if ( sortable._intersectsWith( sortable.containerCache ) ) {
  2302. innermostIntersecting = true;
  2304. $.each( draggable.sortables, function() {
  2305. // Copy over variables that sortable's _intersectsWith uses
  2306. this.positionAbs = draggable.positionAbs;
  2307. this.helperProportions = draggable.helperProportions;
  2308. this.offset.click = draggable.offset.click;
  2310. if ( this !== sortable &&
  2311. this._intersectsWith( this.containerCache ) &&
  2312. $.contains( sortable.element[ 0 ], this.element[ 0 ] ) ) {
  2313. innermostIntersecting = false;
  2314. }
  2316. return innermostIntersecting;
  2317. });
  2318. }
  2320. if ( innermostIntersecting ) {
  2321. // If it intersects, we use a little isOver variable and set it once,
  2322. // so that the move-in stuff gets fired only once.
  2323. if ( !sortable.isOver ) {
  2324. sortable.isOver = 1;
  2326. // Store draggable's parent in case we need to reappend to it later.
  2327. draggable._parent = ui.helper.parent();
  2329. sortable.currentItem = ui.helper
  2330. .appendTo( sortable.element )
  2331. .data( "ui-sortable-item", true );
  2333. // Store helper option to later restore it
  2334. sortable.options._helper = sortable.options.helper;
  2336. sortable.options.helper = function() {
  2337. return ui.helper[ 0 ];
  2338. };
  2340. // Fire the start events of the sortable with our passed browser event,
  2341. // and our own helper (so it doesn't create a new one)
  2342. event.target = sortable.currentItem[ 0 ];
  2343. sortable._mouseCapture( event, true );
  2344. sortable._mouseStart( event, true, true );
  2346. // Because the browser event is way off the new appended portlet,
  2347. // modify necessary variables to reflect the changes
  2348. sortable.offset.click.top = draggable.offset.click.top;
  2349. sortable.offset.click.left = draggable.offset.click.left;
  2350. sortable.offset.parent.left -= draggable.offset.parent.left -
  2351. sortable.offset.parent.left;
  2352. sortable.offset.parent.top -= draggable.offset.parent.top -
  2353. sortable.offset.parent.top;
  2355. draggable._trigger( "toSortable", event );
  2357. // Inform draggable that the helper is in a valid drop zone,
  2358. // used solely in the revert option to handle "valid/invalid".
  2359. draggable.dropped = sortable.element;
  2361. // Need to refreshPositions of all sortables in the case that
  2362. // adding to one sortable changes the location of the other sortables (#9675)
  2363. $.each( draggable.sortables, function() {
  2364. this.refreshPositions();
  2365. });
  2367. // hack so receive/update callbacks work (mostly)
  2368. draggable.currentItem = draggable.element;
  2369. sortable.fromOutside = draggable;
  2370. }
  2372. if ( sortable.currentItem ) {
  2373. sortable._mouseDrag( event );
  2374. // Copy the sortable's position because the draggable's can potentially reflect
  2375. // a relative position, while sortable is always absolute, which the dragged
  2376. // element has now become. (#8809)
  2377. ui.position = sortable.position;
  2378. }
  2379. } else {
  2380. // If it doesn't intersect with the sortable, and it intersected before,
  2381. // we fake the drag stop of the sortable, but make sure it doesn't remove
  2382. // the helper by using cancelHelperRemoval.
  2383. if ( sortable.isOver ) {
  2385. sortable.isOver = 0;
  2386. sortable.cancelHelperRemoval = true;
  2388. // Calling sortable's mouseStop would trigger a revert,
  2389. // so revert must be temporarily false until after mouseStop is called.
  2390. sortable.options._revert = sortable.options.revert;
  2391. sortable.options.revert = false;
  2393. sortable._trigger( "out", event, sortable._uiHash( sortable ) );
  2394. sortable._mouseStop( event, true );
  2396. // restore sortable behaviors that were modfied
  2397. // when the draggable entered the sortable area (#9481)
  2398. sortable.options.revert = sortable.options._revert;
  2399. sortable.options.helper = sortable.options._helper;
  2401. if ( sortable.placeholder ) {
  2402. sortable.placeholder.remove();
  2403. }
  2405. // Restore and recalculate the draggable's offset considering the sortable
  2406. // may have modified them in unexpected ways. (#8809, #10669)
  2407. ui.helper.appendTo( draggable._parent );
  2408. draggable._refreshOffsets( event );
  2409. ui.position = draggable._generatePosition( event, true );
  2411. draggable._trigger( "fromSortable", event );
  2413. // Inform draggable that the helper is no longer in a valid drop zone
  2414. draggable.dropped = false;
  2416. // Need to refreshPositions of all sortables just in case removing
  2417. // from one sortable changes the location of other sortables (#9675)
  2418. $.each( draggable.sortables, function() {
  2419. this.refreshPositions();
  2420. });
  2421. }
  2422. }
  2423. });
  2424. }
  2425. });
  2427. $.ui.plugin.add("draggable", "cursor", {
  2428. start: function( event, ui, instance ) {
  2429. var t = $( "body" ),
  2430. o = instance.options;
  2432. if (t.css("cursor")) {
  2433. o._cursor = t.css("cursor");
  2434. }
  2435. t.css("cursor", o.cursor);
  2436. },
  2437. stop: function( event, ui, instance ) {
  2438. var o = instance.options;
  2439. if (o._cursor) {
  2440. $("body").css("cursor", o._cursor);
  2441. }
  2442. }
  2443. });
  2445. $.ui.plugin.add("draggable", "opacity", {
  2446. start: function( event, ui, instance ) {
  2447. var t = $( ui.helper ),
  2448. o = instance.options;
  2449. if (t.css("opacity")) {
  2450. o._opacity = t.css("opacity");
  2451. }
  2452. t.css("opacity", o.opacity);
  2453. },
  2454. stop: function( event, ui, instance ) {
  2455. var o = instance.options;
  2456. if (o._opacity) {
  2457. $(ui.helper).css("opacity", o._opacity);
  2458. }
  2459. }
  2460. });
  2462. $.ui.plugin.add("draggable", "scroll", {
  2463. start: function( event, ui, i ) {
  2464. if ( !i.scrollParentNotHidden ) {
  2465. i.scrollParentNotHidden = i.helper.scrollParent( false );
  2466. }
  2468. if ( i.scrollParentNotHidden[ 0 ] !== i.document[ 0 ] && i.scrollParentNotHidden[ 0 ].tagName !== "HTML" ) {
  2469. i.overflowOffset = i.scrollParentNotHidden.offset();
  2470. }
  2471. },
  2472. drag: function( event, ui, i ) {
  2474. var o = i.options,
  2475. scrolled = false,
  2476. scrollParent = i.scrollParentNotHidden[ 0 ],
  2477. document = i.document[ 0 ];
  2479. if ( scrollParent !== document && scrollParent.tagName !== "HTML" ) {
  2480. if ( !o.axis || o.axis !== "x" ) {
  2481. if ( ( i.overflowOffset.top + scrollParent.offsetHeight ) - event.pageY < o.scrollSensitivity ) {
  2482. scrollParent.scrollTop = scrolled = scrollParent.scrollTop + o.scrollSpeed;
  2483. } else if ( event.pageY - i.overflowOffset.top < o.scrollSensitivity ) {
  2484. scrollParent.scrollTop = scrolled = scrollParent.scrollTop - o.scrollSpeed;
  2485. }
  2486. }
  2488. if ( !o.axis || o.axis !== "y" ) {
  2489. if ( ( i.overflowOffset.left + scrollParent.offsetWidth ) - event.pageX < o.scrollSensitivity ) {
  2490. scrollParent.scrollLeft = scrolled = scrollParent.scrollLeft + o.scrollSpeed;
  2491. } else if ( event.pageX - i.overflowOffset.left < o.scrollSensitivity ) {
  2492. scrollParent.scrollLeft = scrolled = scrollParent.scrollLeft - o.scrollSpeed;
  2493. }
  2494. }
  2496. } else {
  2498. if (!o.axis || o.axis !== "x") {
  2499. if (event.pageY - $(document).scrollTop() < o.scrollSensitivity) {
  2500. scrolled = $(document).scrollTop($(document).scrollTop() - o.scrollSpeed);
  2501. } else if ($(window).height() - (event.pageY - $(document).scrollTop()) < o.scrollSensitivity) {
  2502. scrolled = $(document).scrollTop($(document).scrollTop() + o.scrollSpeed);
  2503. }
  2504. }
  2506. if (!o.axis || o.axis !== "y") {
  2507. if (event.pageX - $(document).scrollLeft() < o.scrollSensitivity) {
  2508. scrolled = $(document).scrollLeft($(document).scrollLeft() - o.scrollSpeed);
  2509. } else if ($(window).width() - (event.pageX - $(document).scrollLeft()) < o.scrollSensitivity) {
  2510. scrolled = $(document).scrollLeft($(document).scrollLeft() + o.scrollSpeed);
  2511. }
  2512. }
  2514. }
  2516. if (scrolled !== false && $.ui.ddmanager && !o.dropBehaviour) {
  2517. $.ui.ddmanager.prepareOffsets(i, event);
  2518. }
  2520. }
  2521. });
  2523. $.ui.plugin.add("draggable", "snap", {
  2524. start: function( event, ui, i ) {
  2526. var o = i.options;
  2528. i.snapElements = [];
  2530. $(o.snap.constructor !== String ? ( o.snap.items || ":data(ui-draggable)" ) : o.snap).each(function() {
  2531. var $t = $(this),
  2532. $o = $t.offset();
  2533. if (this !== i.element[0]) {
  2534. i.snapElements.push({
  2535. item: this,
  2536. width: $t.outerWidth(), height: $t.outerHeight(),
  2537. top: $o.top, left: $o.left
  2538. });
  2539. }
  2540. });
  2542. },
  2543. drag: function( event, ui, inst ) {
  2545. var ts, bs, ls, rs, l, r, t, b, i, first,
  2546. o = inst.options,
  2547. d = o.snapTolerance,
  2548. x1 = ui.offset.left, x2 = x1 + inst.helperProportions.width,
  2549. y1 = ui.offset.top, y2 = y1 + inst.helperProportions.height;
  2551. for (i = inst.snapElements.length - 1; i >= 0; i--){
  2553. l = inst.snapElements[i].left - inst.margins.left;
  2554. r = l + inst.snapElements[i].width;
  2555. t = inst.snapElements[i].top - inst.margins.top;
  2556. b = t + inst.snapElements[i].height;
  2558. if ( x2 < l - d || x1 > r + d || y2 < t - d || y1 > b + d || !$.contains( inst.snapElements[ i ].item.ownerDocument, inst.snapElements[ i ].item ) ) {
  2559. if (inst.snapElements[i].snapping) {
  2560. (inst.options.snap.release && inst.options.snap.release.call(inst.element, event, $.extend(inst._uiHash(), { snapItem: inst.snapElements[i].item })));
  2561. }
  2562. inst.snapElements[i].snapping = false;
  2563. continue;
  2564. }
  2566. if (o.snapMode !== "inner") {
  2567. ts = Math.abs(t - y2) <= d;
  2568. bs = Math.abs(b - y1) <= d;
  2569. ls = Math.abs(l - x2) <= d;
  2570. rs = Math.abs(r - x1) <= d;
  2571. if (ts) {
  2572. ui.position.top = inst._convertPositionTo("relative", { top: t - inst.helperProportions.height, left: 0 }).top;
  2573. }
  2574. if (bs) {
  2575. ui.position.top = inst._convertPositionTo("relative", { top: b, left: 0 }).top;
  2576. }
  2577. if (ls) {
  2578. ui.position.left = inst._convertPositionTo("relative", { top: 0, left: l - inst.helperProportions.width }).left;
  2579. }
  2580. if (rs) {
  2581. ui.position.left = inst._convertPositionTo("relative", { top: 0, left: r }).left;
  2582. }
  2583. }
  2585. first = (ts || bs || ls || rs);
  2587. if (o.snapMode !== "outer") {
  2588. ts = Math.abs(t - y1) <= d;
  2589. bs = Math.abs(b - y2) <= d;
  2590. ls = Math.abs(l - x1) <= d;
  2591. rs = Math.abs(r - x2) <= d;
  2592. if (ts) {
  2593. ui.position.top = inst._convertPositionTo("relative", { top: t, left: 0 }).top;
  2594. }
  2595. if (bs) {
  2596. ui.position.top = inst._convertPositionTo("relative", { top: b - inst.helperProportions.height, left: 0 }).top;
  2597. }
  2598. if (ls) {
  2599. ui.position.left = inst._convertPositionTo("relative", { top: 0, left: l }).left;
  2600. }
  2601. if (rs) {
  2602. ui.position.left = inst._convertPositionTo("relative", { top: 0, left: r - inst.helperProportions.width }).left;
  2603. }
  2604. }
  2606. if (!inst.snapElements[i].snapping && (ts || bs || ls || rs || first)) {
  2607. (inst.options.snap.snap && inst.options.snap.snap.call(inst.element, event, $.extend(inst._uiHash(), { snapItem: inst.snapElements[i].item })));
  2608. }
  2609. inst.snapElements[i].snapping = (ts || bs || ls || rs || first);
  2611. }
  2613. }
  2614. });
  2616. $.ui.plugin.add("draggable", "stack", {
  2617. start: function( event, ui, instance ) {
  2618. var min,
  2619. o = instance.options,
  2620. group = $.makeArray($(o.stack)).sort(function(a, b) {
  2621. return (parseInt($(a).css("zIndex"), 10) || 0) - (parseInt($(b).css("zIndex"), 10) || 0);
  2622. });
  2624. if (!group.length) { return; }
  2626. min = parseInt($(group[0]).css("zIndex"), 10) || 0;
  2627. $(group).each(function(i) {
  2628. $(this).css("zIndex", min + i);
  2629. });
  2630. this.css("zIndex", (min + group.length));
  2631. }
  2632. });
  2634. $.ui.plugin.add("draggable", "zIndex", {
  2635. start: function( event, ui, instance ) {
  2636. var t = $( ui.helper ),
  2637. o = instance.options;
  2639. if (t.css("zIndex")) {
  2640. o._zIndex = t.css("zIndex");
  2641. }
  2642. t.css("zIndex", o.zIndex);
  2643. },
  2644. stop: function( event, ui, instance ) {
  2645. var o = instance.options;
  2647. if (o._zIndex) {
  2648. $(ui.helper).css("zIndex", o._zIndex);
  2649. }
  2650. }
  2651. });
  2653. var draggable = $.ui.draggable;
  2656. /*!
  2657. * jQuery UI Droppable 1.11.4
  2658. * http://jqueryui.com
  2659. *
  2660. * Copyright jQuery Foundation and other contributors
  2661. * Released under the MIT license.
  2662. * http://jquery.org/license
  2663. *
  2664. * http://api.jqueryui.com/droppable/
  2665. */
  2668. $.widget( "ui.droppable", {
  2669. version: "1.11.4",
  2670. widgetEventPrefix: "drop",
  2671. options: {
  2672. accept: "*",
  2673. activeClass: false,
  2674. addClasses: true,
  2675. greedy: false,
  2676. hoverClass: false,
  2677. scope: "default",
  2678. tolerance: "intersect",
  2680. // callbacks
  2681. activate: null,
  2682. deactivate: null,
  2683. drop: null,
  2684. out: null,
  2685. over: null
  2686. },
  2687. _create: function() {
  2689. var proportions,
  2690. o = this.options,
  2691. accept = o.accept;
  2693. this.isover = false;
  2694. this.isout = true;
  2696. this.accept = $.isFunction( accept ) ? accept : function( d ) {
  2697. return d.is( accept );
  2698. };
  2700. this.proportions = function( /* valueToWrite */ ) {
  2701. if ( arguments.length ) {
  2702. // Store the droppable's proportions
  2703. proportions = arguments[ 0 ];
  2704. } else {
  2705. // Retrieve or derive the droppable's proportions
  2706. return proportions ?
  2707. proportions :
  2708. proportions = {
  2709. width: this.element[ 0 ].offsetWidth,
  2710. height: this.element[ 0 ].offsetHeight
  2711. };
  2712. }
  2713. };
  2715. this._addToManager( o.scope );
  2717. o.addClasses && this.element.addClass( "ui-droppable" );
  2719. },
  2721. _addToManager: function( scope ) {
  2722. // Add the reference and positions to the manager
  2723. $.ui.ddmanager.droppables[ scope ] = $.ui.ddmanager.droppables[ scope ] || [];
  2724. $.ui.ddmanager.droppables[ scope ].push( this );
  2725. },
  2727. _splice: function( drop ) {
  2728. var i = 0;
  2729. for ( ; i < drop.length; i++ ) {
  2730. if ( drop[ i ] === this ) {
  2731. drop.splice( i, 1 );
  2732. }
  2733. }
  2734. },
  2736. _destroy: function() {
  2737. var drop = $.ui.ddmanager.droppables[ this.options.scope ];
  2739. this._splice( drop );
  2741. this.element.removeClass( "ui-droppable ui-droppable-disabled" );
  2742. },
  2744. _setOption: function( key, value ) {
  2746. if ( key === "accept" ) {
  2747. this.accept = $.isFunction( value ) ? value : function( d ) {
  2748. return d.is( value );
  2749. };
  2750. } else if ( key === "scope" ) {
  2751. var drop = $.ui.ddmanager.droppables[ this.options.scope ];
  2753. this._splice( drop );
  2754. this._addToManager( value );
  2755. }
  2757. this._super( key, value );
  2758. },
  2760. _activate: function( event ) {
  2761. var draggable = $.ui.ddmanager.current;
  2762. if ( this.options.activeClass ) {
  2763. this.element.addClass( this.options.activeClass );
  2764. }
  2765. if ( draggable ){
  2766. this._trigger( "activate", event, this.ui( draggable ) );
  2767. }
  2768. },
  2770. _deactivate: function( event ) {
  2771. var draggable = $.ui.ddmanager.current;
  2772. if ( this.options.activeClass ) {
  2773. this.element.removeClass( this.options.activeClass );
  2774. }
  2775. if ( draggable ){
  2776. this._trigger( "deactivate", event, this.ui( draggable ) );
  2777. }
  2778. },
  2780. _over: function( event ) {
  2782. var draggable = $.ui.ddmanager.current;
  2784. // Bail if draggable and droppable are same element
  2785. if ( !draggable || ( draggable.currentItem || draggable.element )[ 0 ] === this.element[ 0 ] ) {
  2786. return;
  2787. }
  2789. if ( this.accept.call( this.element[ 0 ], ( draggable.currentItem || draggable.element ) ) ) {
  2790. if ( this.options.hoverClass ) {
  2791. this.element.addClass( this.options.hoverClass );
  2792. }
  2793. this._trigger( "over", event, this.ui( draggable ) );
  2794. }
  2796. },
  2798. _out: function( event ) {
  2800. var draggable = $.ui.ddmanager.current;
  2802. // Bail if draggable and droppable are same element
  2803. if ( !draggable || ( draggable.currentItem || draggable.element )[ 0 ] === this.element[ 0 ] ) {
  2804. return;
  2805. }
  2807. if ( this.accept.call( this.element[ 0 ], ( draggable.currentItem || draggable.element ) ) ) {
  2808. if ( this.options.hoverClass ) {
  2809. this.element.removeClass( this.options.hoverClass );
  2810. }
  2811. this._trigger( "out", event, this.ui( draggable ) );
  2812. }
  2814. },
  2816. _drop: function( event, custom ) {
  2818. var draggable = custom || $.ui.ddmanager.current,
  2819. childrenIntersection = false;
  2821. // Bail if draggable and droppable are same element
  2822. if ( !draggable || ( draggable.currentItem || draggable.element )[ 0 ] === this.element[ 0 ] ) {
  2823. return false;
  2824. }
  2826. this.element.find( ":data(ui-droppable)" ).not( ".ui-draggable-dragging" ).each(function() {
  2827. var inst = $( this ).droppable( "instance" );
  2828. if (
  2829. inst.options.greedy &&
  2830. !inst.options.disabled &&
  2831. inst.options.scope === draggable.options.scope &&
  2832. inst.accept.call( inst.element[ 0 ], ( draggable.currentItem || draggable.element ) ) &&
  2833. $.ui.intersect( draggable, $.extend( inst, { offset: inst.element.offset() } ), inst.options.tolerance, event )
  2834. ) { childrenIntersection = true; return false; }
  2835. });
  2836. if ( childrenIntersection ) {
  2837. return false;
  2838. }
  2840. if ( this.accept.call( this.element[ 0 ], ( draggable.currentItem || draggable.element ) ) ) {
  2841. if ( this.options.activeClass ) {
  2842. this.element.removeClass( this.options.activeClass );
  2843. }
  2844. if ( this.options.hoverClass ) {
  2845. this.element.removeClass( this.options.hoverClass );
  2846. }
  2847. this._trigger( "drop", event, this.ui( draggable ) );
  2848. return this.element;
  2849. }
  2851. return false;
  2853. },
  2855. ui: function( c ) {
  2856. return {
  2857. draggable: ( c.currentItem || c.element ),
  2858. helper: c.helper,
  2859. position: c.position,
  2860. offset: c.positionAbs
  2861. };
  2862. }
  2864. });
  2866. $.ui.intersect = (function() {
  2867. function isOverAxis( x, reference, size ) {
  2868. return ( x >= reference ) && ( x < ( reference + size ) );
  2869. }
  2871. return function( draggable, droppable, toleranceMode, event ) {
  2873. if ( !droppable.offset ) {
  2874. return false;
  2875. }
  2877. var x1 = ( draggable.positionAbs || draggable.position.absolute ).left + draggable.margins.left,
  2878. y1 = ( draggable.positionAbs || draggable.position.absolute ).top + draggable.margins.top,
  2879. x2 = x1 + draggable.helperProportions.width,
  2880. y2 = y1 + draggable.helperProportions.height,
  2881. l = droppable.offset.left,
  2882. t = droppable.offset.top,
  2883. r = l + droppable.proportions().width,
  2884. b = t + droppable.proportions().height;
  2886. switch ( toleranceMode ) {
  2887. case "fit":
  2888. return ( l <= x1 && x2 <= r && t <= y1 && y2 <= b );
  2889. case "intersect":
  2890. return ( l < x1 + ( draggable.helperProportions.width / 2 ) && // Right Half
  2891. x2 - ( draggable.helperProportions.width / 2 ) < r && // Left Half
  2892. t < y1 + ( draggable.helperProportions.height / 2 ) && // Bottom Half
  2893. y2 - ( draggable.helperProportions.height / 2 ) < b ); // Top Half
  2894. case "pointer":
  2895. return isOverAxis( event.pageY, t, droppable.proportions().height ) && isOverAxis( event.pageX, l, droppable.proportions().width );
  2896. case "touch":
  2897. return (
  2898. ( y1 >= t && y1 <= b ) || // Top edge touching
  2899. ( y2 >= t && y2 <= b ) || // Bottom edge touching
  2900. ( y1 < t && y2 > b ) // Surrounded vertically
  2901. ) && (
  2902. ( x1 >= l && x1 <= r ) || // Left edge touching
  2903. ( x2 >= l && x2 <= r ) || // Right edge touching
  2904. ( x1 < l && x2 > r ) // Surrounded horizontally
  2905. );
  2906. default:
  2907. return false;
  2908. }
  2909. };
  2910. })();
  2912. /*
  2913. This manager tracks offsets of draggables and droppables
  2914. */
  2915. $.ui.ddmanager = {
  2916. current: null,
  2917. droppables: { "default": [] },
  2918. prepareOffsets: function( t, event ) {
  2920. var i, j,
  2921. m = $.ui.ddmanager.droppables[ t.options.scope ] || [],
  2922. type = event ? event.type : null, // workaround for #2317
  2923. list = ( t.currentItem || t.element ).find( ":data(ui-droppable)" ).addBack();
  2925. droppablesLoop: for ( i = 0; i < m.length; i++ ) {
  2927. // No disabled and non-accepted
  2928. if ( m[ i ].options.disabled || ( t && !m[ i ].accept.call( m[ i ].element[ 0 ], ( t.currentItem || t.element ) ) ) ) {
  2929. continue;
  2930. }
  2932. // Filter out elements in the current dragged item
  2933. for ( j = 0; j < list.length; j++ ) {
  2934. if ( list[ j ] === m[ i ].element[ 0 ] ) {
  2935. m[ i ].proportions().height = 0;
  2936. continue droppablesLoop;
  2937. }
  2938. }
  2940. m[ i ].visible = m[ i ].element.css( "display" ) !== "none";
  2941. if ( !m[ i ].visible ) {
  2942. continue;
  2943. }
  2945. // Activate the droppable if used directly from draggables
  2946. if ( type === "mousedown" ) {
  2947. m[ i ]._activate.call( m[ i ], event );
  2948. }
  2950. m[ i ].offset = m[ i ].element.offset();
  2951. m[ i ].proportions({ width: m[ i ].element[ 0 ].offsetWidth, height: m[ i ].element[ 0 ].offsetHeight });
  2953. }
  2955. },
  2956. drop: function( draggable, event ) {
  2958. var dropped = false;
  2959. // Create a copy of the droppables in case the list changes during the drop (#9116)
  2960. $.each( ( $.ui.ddmanager.droppables[ draggable.options.scope ] || [] ).slice(), function() {
  2962. if ( !this.options ) {
  2963. return;
  2964. }
  2965. if ( !this.options.disabled && this.visible && $.ui.intersect( draggable, this, this.options.tolerance, event ) ) {
  2966. dropped = this._drop.call( this, event ) || dropped;
  2967. }
  2969. if ( !this.options.disabled && this.visible && this.accept.call( this.element[ 0 ], ( draggable.currentItem || draggable.element ) ) ) {
  2970. this.isout = true;
  2971. this.isover = false;
  2972. this._deactivate.call( this, event );
  2973. }
  2975. });
  2976. return dropped;
  2978. },
  2979. dragStart: function( draggable, event ) {
  2980. // Listen for scrolling so that if the dragging causes scrolling the position of the droppables can be recalculated (see #5003)
  2981. draggable.element.parentsUntil( "body" ).bind( "scroll.droppable", function() {
  2982. if ( !draggable.options.refreshPositions ) {
  2983. $.ui.ddmanager.prepareOffsets( draggable, event );
  2984. }
  2985. });
  2986. },
  2987. drag: function( draggable, event ) {
  2989. // If you have a highly dynamic page, you might try this option. It renders positions every time you move the mouse.
  2990. if ( draggable.options.refreshPositions ) {
  2991. $.ui.ddmanager.prepareOffsets( draggable, event );
  2992. }
  2994. // Run through all droppables and check their positions based on specific tolerance options
  2995. $.each( $.ui.ddmanager.droppables[ draggable.options.scope ] || [], function() {
  2997. if ( this.options.disabled || this.greedyChild || !this.visible ) {
  2998. return;
  2999. }
  3001. var parentInstance, scope, parent,
  3002. intersects = $.ui.intersect( draggable, this, this.options.tolerance, event ),
  3003. c = !intersects && this.isover ? "isout" : ( intersects && !this.isover ? "isover" : null );
  3004. if ( !c ) {
  3005. return;
  3006. }
  3008. if ( this.options.greedy ) {
  3009. // find droppable parents with same scope
  3010. scope = this.options.scope;
  3011. parent = this.element.parents( ":data(ui-droppable)" ).filter(function() {
  3012. return $( this ).droppable( "instance" ).options.scope === scope;
  3013. });
  3015. if ( parent.length ) {
  3016. parentInstance = $( parent[ 0 ] ).droppable( "instance" );
  3017. parentInstance.greedyChild = ( c === "isover" );
  3018. }
  3019. }
  3021. // we just moved into a greedy child
  3022. if ( parentInstance && c === "isover" ) {
  3023. parentInstance.isover = false;
  3024. parentInstance.isout = true;
  3025. parentInstance._out.call( parentInstance, event );
  3026. }
  3028. this[ c ] = true;
  3029. this[c === "isout" ? "isover" : "isout"] = false;
  3030. this[c === "isover" ? "_over" : "_out"].call( this, event );
  3032. // we just moved out of a greedy child
  3033. if ( parentInstance && c === "isout" ) {
  3034. parentInstance.isout = false;
  3035. parentInstance.isover = true;
  3036. parentInstance._over.call( parentInstance, event );
  3037. }
  3038. });
  3040. },
  3041. dragStop: function( draggable, event ) {
  3042. draggable.element.parentsUntil( "body" ).unbind( "scroll.droppable" );
  3043. // Call prepareOffsets one final time since IE does not fire return scroll events when overflow was caused by drag (see #5003)
  3044. if ( !draggable.options.refreshPositions ) {
  3045. $.ui.ddmanager.prepareOffsets( draggable, event );
  3046. }
  3047. }
  3048. };
  3050. var droppable = $.ui.droppable;
  3053. /*!
  3054. * jQuery UI Resizable 1.11.4
  3055. * http://jqueryui.com
  3056. *
  3057. * Copyright jQuery Foundation and other contributors
  3058. * Released under the MIT license.
  3059. * http://jquery.org/license
  3060. *
  3061. * http://api.jqueryui.com/resizable/
  3062. */
  3065. $.widget("ui.resizable", $.ui.mouse, {
  3066. version: "1.11.4",
  3067. widgetEventPrefix: "resize",
  3068. options: {
  3069. alsoResize: false,
  3070. animate: false,
  3071. animateDuration: "slow",
  3072. animateEasing: "swing",
  3073. aspectRatio: false,
  3074. autoHide: false,
  3075. containment: false,
  3076. ghost: false,
  3077. grid: false,
  3078. handles: "e,s,se",
  3079. helper: false,
  3080. maxHeight: null,
  3081. maxWidth: null,
  3082. minHeight: 10,
  3083. minWidth: 10,
  3084. // See #7960
  3085. zIndex: 90,
  3087. // callbacks
  3088. resize: null,
  3089. start: null,
  3090. stop: null
  3091. },
  3093. _num: function( value ) {
  3094. return parseInt( value, 10 ) || 0;
  3095. },
  3097. _isNumber: function( value ) {
  3098. return !isNaN( parseInt( value, 10 ) );
  3099. },
  3101. _hasScroll: function( el, a ) {
  3103. if ( $( el ).css( "overflow" ) === "hidden") {
  3104. return false;
  3105. }
  3107. var scroll = ( a && a === "left" ) ? "scrollLeft" : "scrollTop",
  3108. has = false;
  3110. if ( el[ scroll ] > 0 ) {
  3111. return true;
  3112. }
  3114. // TODO: determine which cases actually cause this to happen
  3115. // if the element doesn't have the scroll set, see if it's possible to
  3116. // set the scroll
  3117. el[ scroll ] = 1;
  3118. has = ( el[ scroll ] > 0 );
  3119. el[ scroll ] = 0;
  3120. return has;
  3121. },
  3123. _create: function() {
  3125. var n, i, handle, axis, hname,
  3126. that = this,
  3127. o = this.options;
  3128. this.element.addClass("ui-resizable");
  3130. $.extend(this, {
  3131. _aspectRatio: !!(o.aspectRatio),
  3132. aspectRatio: o.aspectRatio,
  3133. originalElement: this.element,
  3134. _proportionallyResizeElements: [],
  3135. _helper: o.helper || o.ghost || o.animate ? o.helper || "ui-resizable-helper" : null
  3136. });
  3138. // Wrap the element if it cannot hold child nodes
  3139. if (this.element[0].nodeName.match(/^(canvas|textarea|input|select|button|img)$/i)) {
  3141. this.element.wrap(
  3142. $("<div class='ui-wrapper' style='overflow: hidden;'></div>").css({
  3143. position: this.element.css("position"),
  3144. width: this.element.outerWidth(),
  3145. height: this.element.outerHeight(),
  3146. top: this.element.css("top"),
  3147. left: this.element.css("left")
  3148. })
  3149. );
  3151. this.element = this.element.parent().data(
  3152. "ui-resizable", this.element.resizable( "instance" )
  3153. );
  3155. this.elementIsWrapper = true;
  3157. this.element.css({
  3158. marginLeft: this.originalElement.css("marginLeft"),
  3159. marginTop: this.originalElement.css("marginTop"),
  3160. marginRight: this.originalElement.css("marginRight"),
  3161. marginBottom: this.originalElement.css("marginBottom")
  3162. });
  3163. this.originalElement.css({
  3164. marginLeft: 0,
  3165. marginTop: 0,
  3166. marginRight: 0,
  3167. marginBottom: 0
  3168. });
  3169. // support: Safari
  3170. // Prevent Safari textarea resize
  3171. this.originalResizeStyle = this.originalElement.css("resize");
  3172. this.originalElement.css("resize", "none");
  3174. this._proportionallyResizeElements.push( this.originalElement.css({
  3175. position: "static",
  3176. zoom: 1,
  3177. display: "block"
  3178. }) );
  3180. // support: IE9
  3181. // avoid IE jump (hard set the margin)
  3182. this.originalElement.css({ margin: this.originalElement.css("margin") });
  3184. this._proportionallyResize();
  3185. }
  3187. this.handles = o.handles ||
  3188. ( !$(".ui-resizable-handle", this.element).length ?
  3189. "e,s,se" : {
  3190. n: ".ui-resizable-n",
  3191. e: ".ui-resizable-e",
  3192. s: ".ui-resizable-s",
  3193. w: ".ui-resizable-w",
  3194. se: ".ui-resizable-se",
  3195. sw: ".ui-resizable-sw",
  3196. ne: ".ui-resizable-ne",
  3197. nw: ".ui-resizable-nw"
  3198. } );
  3200. this._handles = $();
  3201. if ( this.handles.constructor === String ) {
  3203. if ( this.handles === "all") {
  3204. this.handles = "n,e,s,w,se,sw,ne,nw";
  3205. }
  3207. n = this.handles.split(",");
  3208. this.handles = {};
  3210. for (i = 0; i < n.length; i++) {
  3212. handle = $.trim(n[i]);
  3213. hname = "ui-resizable-" + handle;
  3214. axis = $("<div class='ui-resizable-handle " + hname + "'></div>");
  3216. axis.css({ zIndex: o.zIndex });
  3218. // TODO : What's going on here?
  3219. if ("se" === handle) {
  3220. axis.addClass("ui-icon ui-icon-gripsmall-diagonal-se");
  3221. }
  3223. this.handles[handle] = ".ui-resizable-" + handle;
  3224. this.element.append(axis);
  3225. }
  3227. }
  3229. this._renderAxis = function(target) {
  3231. var i, axis, padPos, padWrapper;
  3233. target = target || this.element;
  3235. for (i in this.handles) {
  3237. if (this.handles[i].constructor === String) {
  3238. this.handles[i] = this.element.children( this.handles[ i ] ).first().show();
  3239. } else if ( this.handles[ i ].jquery || this.handles[ i ].nodeType ) {
  3240. this.handles[ i ] = $( this.handles[ i ] );
  3241. this._on( this.handles[ i ], { "mousedown": that._mouseDown });
  3242. }
  3244. if (this.elementIsWrapper && this.originalElement[0].nodeName.match(/^(textarea|input|select|button)$/i)) {
  3246. axis = $(this.handles[i], this.element);
  3248. padWrapper = /sw|ne|nw|se|n|s/.test(i) ? axis.outerHeight() : axis.outerWidth();
  3250. padPos = [ "padding",
  3251. /ne|nw|n/.test(i) ? "Top" :
  3252. /se|sw|s/.test(i) ? "Bottom" :
  3253. /^e$/.test(i) ? "Right" : "Left" ].join("");
  3255. target.css(padPos, padWrapper);
  3257. this._proportionallyResize();
  3258. }
  3260. this._handles = this._handles.add( this.handles[ i ] );
  3261. }
  3262. };
  3264. // TODO: make renderAxis a prototype function
  3265. this._renderAxis(this.element);
  3267. this._handles = this._handles.add( this.element.find( ".ui-resizable-handle" ) );
  3268. this._handles.disableSelection();
  3270. this._handles.mouseover(function() {
  3271. if (!that.resizing) {
  3272. if (this.className) {
  3273. axis = this.className.match(/ui-resizable-(se|sw|ne|nw|n|e|s|w)/i);
  3274. }
  3275. that.axis = axis && axis[1] ? axis[1] : "se";
  3276. }
  3277. });
  3279. if (o.autoHide) {
  3280. this._handles.hide();
  3281. $(this.element)
  3282. .addClass("ui-resizable-autohide")
  3283. .mouseenter(function() {
  3284. if (o.disabled) {
  3285. return;
  3286. }
  3287. $(this).removeClass("ui-resizable-autohide");
  3288. that._handles.show();
  3289. })
  3290. .mouseleave(function() {
  3291. if (o.disabled) {
  3292. return;
  3293. }
  3294. if (!that.resizing) {
  3295. $(this).addClass("ui-resizable-autohide");
  3296. that._handles.hide();
  3297. }
  3298. });
  3299. }
  3301. this._mouseInit();
  3302. },
  3304. _destroy: function() {
  3306. this._mouseDestroy();
  3308. var wrapper,
  3309. _destroy = function(exp) {
  3310. $(exp)
  3311. .removeClass("ui-resizable ui-resizable-disabled ui-resizable-resizing")
  3312. .removeData("resizable")
  3313. .removeData("ui-resizable")
  3314. .unbind(".resizable")
  3315. .find(".ui-resizable-handle")
  3316. .remove();
  3317. };
  3319. // TODO: Unwrap at same DOM position
  3320. if (this.elementIsWrapper) {
  3321. _destroy(this.element);
  3322. wrapper = this.element;
  3323. this.originalElement.css({
  3324. position: wrapper.css("position"),
  3325. width: wrapper.outerWidth(),
  3326. height: wrapper.outerHeight(),
  3327. top: wrapper.css("top"),
  3328. left: wrapper.css("left")
  3329. }).insertAfter( wrapper );
  3330. wrapper.remove();
  3331. }
  3333. this.originalElement.css("resize", this.originalResizeStyle);
  3334. _destroy(this.originalElement);
  3336. return this;
  3337. },
  3339. _mouseCapture: function(event) {
  3340. var i, handle,
  3341. capture = false;
  3343. for (i in this.handles) {
  3344. handle = $(this.handles[i])[0];
  3345. if (handle === event.target || $.contains(handle, event.target)) {
  3346. capture = true;
  3347. }
  3348. }
  3350. return !this.options.disabled && capture;
  3351. },
  3353. _mouseStart: function(event) {
  3355. var curleft, curtop, cursor,
  3356. o = this.options,
  3357. el = this.element;
  3359. this.resizing = true;
  3361. this._renderProxy();
  3363. curleft = this._num(this.helper.css("left"));
  3364. curtop = this._num(this.helper.css("top"));
  3366. if (o.containment) {
  3367. curleft += $(o.containment).scrollLeft() || 0;
  3368. curtop += $(o.containment).scrollTop() || 0;
  3369. }
  3371. this.offset = this.helper.offset();
  3372. this.position = { left: curleft, top: curtop };
  3374. this.size = this._helper ? {
  3375. width: this.helper.width(),
  3376. height: this.helper.height()
  3377. } : {
  3378. width: el.width(),
  3379. height: el.height()
  3380. };
  3382. this.originalSize = this._helper ? {
  3383. width: el.outerWidth(),
  3384. height: el.outerHeight()
  3385. } : {
  3386. width: el.width(),
  3387. height: el.height()
  3388. };
  3390. this.sizeDiff = {
  3391. width: el.outerWidth() - el.width(),
  3392. height: el.outerHeight() - el.height()
  3393. };
  3395. this.originalPosition = { left: curleft, top: curtop };
  3396. this.originalMousePosition = { left: event.pageX, top: event.pageY };
  3398. this.aspectRatio = (typeof o.aspectRatio === "number") ?
  3399. o.aspectRatio :
  3400. ((this.originalSize.width / this.originalSize.height) || 1);
  3402. cursor = $(".ui-resizable-" + this.axis).css("cursor");
  3403. $("body").css("cursor", cursor === "auto" ? this.axis + "-resize" : cursor);
  3405. el.addClass("ui-resizable-resizing");
  3406. this._propagate("start", event);
  3407. return true;
  3408. },
  3410. _mouseDrag: function(event) {
  3412. var data, props,
  3413. smp = this.originalMousePosition,
  3414. a = this.axis,
  3415. dx = (event.pageX - smp.left) || 0,
  3416. dy = (event.pageY - smp.top) || 0,
  3417. trigger = this._change[a];
  3419. this._updatePrevProperties();
  3421. if (!trigger) {
  3422. return false;
  3423. }
  3425. data = trigger.apply(this, [ event, dx, dy ]);
  3427. this._updateVirtualBoundaries(event.shiftKey);
  3428. if (this._aspectRatio || event.shiftKey) {
  3429. data = this._updateRatio(data, event);
  3430. }
  3432. data = this._respectSize(data, event);
  3434. this._updateCache(data);
  3436. this._propagate("resize", event);
  3438. props = this._applyChanges();
  3440. if ( !this._helper && this._proportionallyResizeElements.length ) {
  3441. this._proportionallyResize();
  3442. }
  3444. if ( !$.isEmptyObject( props ) ) {
  3445. this._updatePrevProperties();
  3446. this._trigger( "resize", event, this.ui() );
  3447. this._applyChanges();
  3448. }
  3450. return false;
  3451. },
  3453. _mouseStop: function(event) {
  3455. this.resizing = false;
  3456. var pr, ista, soffseth, soffsetw, s, left, top,
  3457. o = this.options, that = this;
  3459. if (this._helper) {
  3461. pr = this._proportionallyResizeElements;
  3462. ista = pr.length && (/textarea/i).test(pr[0].nodeName);
  3463. soffseth = ista && this._hasScroll(pr[0], "left") ? 0 : that.sizeDiff.height;
  3464. soffsetw = ista ? 0 : that.sizeDiff.width;
  3466. s = {
  3467. width: (that.helper.width() - soffsetw),
  3468. height: (that.helper.height() - soffseth)
  3469. };
  3470. left = (parseInt(that.element.css("left"), 10) +
  3471. (that.position.left - that.originalPosition.left)) || null;
  3472. top = (parseInt(that.element.css("top"), 10) +
  3473. (that.position.top - that.originalPosition.top)) || null;
  3475. if (!o.animate) {
  3476. this.element.css($.extend(s, { top: top, left: left }));
  3477. }
  3479. that.helper.height(that.size.height);
  3480. that.helper.width(that.size.width);
  3482. if (this._helper && !o.animate) {
  3483. this._proportionallyResize();
  3484. }
  3485. }
  3487. $("body").css("cursor", "auto");
  3489. this.element.removeClass("ui-resizable-resizing");
  3491. this._propagate("stop", event);
  3493. if (this._helper) {
  3494. this.helper.remove();
  3495. }
  3497. return false;
  3499. },
  3501. _updatePrevProperties: function() {
  3502. this.prevPosition = {
  3503. top: this.position.top,
  3504. left: this.position.left
  3505. };
  3506. this.prevSize = {
  3507. width: this.size.width,
  3508. height: this.size.height
  3509. };
  3510. },
  3512. _applyChanges: function() {
  3513. var props = {};
  3515. if ( this.position.top !== this.prevPosition.top ) {
  3516. props.top = this.position.top + "px";
  3517. }
  3518. if ( this.position.left !== this.prevPosition.left ) {
  3519. props.left = this.position.left + "px";
  3520. }
  3521. if ( this.size.width !== this.prevSize.width ) {
  3522. props.width = this.size.width + "px";
  3523. }
  3524. if ( this.size.height !== this.prevSize.height ) {
  3525. props.height = this.size.height + "px";
  3526. }
  3528. this.helper.css( props );
  3530. return props;
  3531. },
  3533. _updateVirtualBoundaries: function(forceAspectRatio) {
  3534. var pMinWidth, pMaxWidth, pMinHeight, pMaxHeight, b,
  3535. o = this.options;
  3537. b = {
  3538. minWidth: this._isNumber(o.minWidth) ? o.minWidth : 0,
  3539. maxWidth: this._isNumber(o.maxWidth) ? o.maxWidth : Infinity,
  3540. minHeight: this._isNumber(o.minHeight) ? o.minHeight : 0,
  3541. maxHeight: this._isNumber(o.maxHeight) ? o.maxHeight : Infinity
  3542. };
  3544. if (this._aspectRatio || forceAspectRatio) {
  3545. pMinWidth = b.minHeight * this.aspectRatio;
  3546. pMinHeight = b.minWidth / this.aspectRatio;
  3547. pMaxWidth = b.maxHeight * this.aspectRatio;
  3548. pMaxHeight = b.maxWidth / this.aspectRatio;
  3550. if (pMinWidth > b.minWidth) {
  3551. b.minWidth = pMinWidth;
  3552. }
  3553. if (pMinHeight > b.minHeight) {
  3554. b.minHeight = pMinHeight;
  3555. }
  3556. if (pMaxWidth < b.maxWidth) {
  3557. b.maxWidth = pMaxWidth;
  3558. }
  3559. if (pMaxHeight < b.maxHeight) {
  3560. b.maxHeight = pMaxHeight;
  3561. }
  3562. }
  3563. this._vBoundaries = b;
  3564. },
  3566. _updateCache: function(data) {
  3567. this.offset = this.helper.offset();
  3568. if (this._isNumber(data.left)) {
  3569. this.position.left = data.left;
  3570. }
  3571. if (this._isNumber(data.top)) {
  3572. this.position.top = data.top;
  3573. }
  3574. if (this._isNumber(data.height)) {
  3575. this.size.height = data.height;
  3576. }
  3577. if (this._isNumber(data.width)) {
  3578. this.size.width = data.width;
  3579. }
  3580. },
  3582. _updateRatio: function( data ) {
  3584. var cpos = this.position,
  3585. csize = this.size,
  3586. a = this.axis;
  3588. if (this._isNumber(data.height)) {
  3589. data.width = (data.height * this.aspectRatio);
  3590. } else if (this._isNumber(data.width)) {
  3591. data.height = (data.width / this.aspectRatio);
  3592. }
  3594. if (a === "sw") {
  3595. data.left = cpos.left + (csize.width - data.width);
  3596. data.top = null;
  3597. }
  3598. if (a === "nw") {
  3599. data.top = cpos.top + (csize.height - data.height);
  3600. data.left = cpos.left + (csize.width - data.width);
  3601. }
  3603. return data;
  3604. },
  3606. _respectSize: function( data ) {
  3608. var o = this._vBoundaries,
  3609. a = this.axis,
  3610. ismaxw = this._isNumber(data.width) && o.maxWidth && (o.maxWidth < data.width),
  3611. ismaxh = this._isNumber(data.height) && o.maxHeight && (o.maxHeight < data.height),
  3612. isminw = this._isNumber(data.width) && o.minWidth && (o.minWidth > data.width),
  3613. isminh = this._isNumber(data.height) && o.minHeight && (o.minHeight > data.height),
  3614. dw = this.originalPosition.left + this.originalSize.width,
  3615. dh = this.position.top + this.size.height,
  3616. cw = /sw|nw|w/.test(a), ch = /nw|ne|n/.test(a);
  3617. if (isminw) {
  3618. data.width = o.minWidth;
  3619. }
  3620. if (isminh) {
  3621. data.height = o.minHeight;
  3622. }
  3623. if (ismaxw) {
  3624. data.width = o.maxWidth;
  3625. }
  3626. if (ismaxh) {
  3627. data.height = o.maxHeight;
  3628. }
  3630. if (isminw && cw) {
  3631. data.left = dw - o.minWidth;
  3632. }
  3633. if (ismaxw && cw) {
  3634. data.left = dw - o.maxWidth;
  3635. }
  3636. if (isminh && ch) {
  3637. data.top = dh - o.minHeight;
  3638. }
  3639. if (ismaxh && ch) {
  3640. data.top = dh - o.maxHeight;
  3641. }
  3643. // Fixing jump error on top/left - bug #2330
  3644. if (!data.width && !data.height && !data.left && data.top) {
  3645. data.top = null;
  3646. } else if (!data.width && !data.height && !data.top && data.left) {
  3647. data.left = null;
  3648. }
  3650. return data;
  3651. },
  3653. _getPaddingPlusBorderDimensions: function( element ) {
  3654. var i = 0,
  3655. widths = [],
  3656. borders = [
  3657. element.css( "borderTopWidth" ),
  3658. element.css( "borderRightWidth" ),
  3659. element.css( "borderBottomWidth" ),
  3660. element.css( "borderLeftWidth" )
  3661. ],
  3662. paddings = [
  3663. element.css( "paddingTop" ),
  3664. element.css( "paddingRight" ),
  3665. element.css( "paddingBottom" ),
  3666. element.css( "paddingLeft" )
  3667. ];
  3669. for ( ; i < 4; i++ ) {
  3670. widths[ i ] = ( parseInt( borders[ i ], 10 ) || 0 );
  3671. widths[ i ] += ( parseInt( paddings[ i ], 10 ) || 0 );
  3672. }
  3674. return {
  3675. height: widths[ 0 ] + widths[ 2 ],
  3676. width: widths[ 1 ] + widths[ 3 ]
  3677. };
  3678. },
  3680. _proportionallyResize: function() {
  3682. if (!this._proportionallyResizeElements.length) {
  3683. return;
  3684. }
  3686. var prel,
  3687. i = 0,
  3688. element = this.helper || this.element;
  3690. for ( ; i < this._proportionallyResizeElements.length; i++) {
  3692. prel = this._proportionallyResizeElements[i];
  3694. // TODO: Seems like a bug to cache this.outerDimensions
  3695. // considering that we are in a loop.
  3696. if (!this.outerDimensions) {
  3697. this.outerDimensions = this._getPaddingPlusBorderDimensions( prel );
  3698. }
  3700. prel.css({
  3701. height: (element.height() - this.outerDimensions.height) || 0,
  3702. width: (element.width() - this.outerDimensions.width) || 0
  3703. });
  3705. }
  3707. },
  3709. _renderProxy: function() {
  3711. var el = this.element, o = this.options;
  3712. this.elementOffset = el.offset();
  3714. if (this._helper) {
  3716. this.helper = this.helper || $("<div style='overflow:hidden;'></div>");
  3718. this.helper.addClass(this._helper).css({
  3719. width: this.element.outerWidth() - 1,
  3720. height: this.element.outerHeight() - 1,
  3721. position: "absolute",
  3722. left: this.elementOffset.left + "px",
  3723. top: this.elementOffset.top + "px",
  3724. zIndex: ++o.zIndex //TODO: Don't modify option
  3725. });
  3727. this.helper
  3728. .appendTo("body")
  3729. .disableSelection();
  3731. } else {
  3732. this.helper = this.element;
  3733. }
  3735. },
  3737. _change: {
  3738. e: function(event, dx) {
  3739. return { width: this.originalSize.width + dx };
  3740. },
  3741. w: function(event, dx) {
  3742. var cs = this.originalSize, sp = this.originalPosition;
  3743. return { left: sp.left + dx, width: cs.width - dx };
  3744. },
  3745. n: function(event, dx, dy) {
  3746. var cs = this.originalSize, sp = this.originalPosition;
  3747. return { top: sp.top + dy, height: cs.height - dy };
  3748. },
  3749. s: function(event, dx, dy) {
  3750. return { height: this.originalSize.height + dy };
  3751. },
  3752. se: function(event, dx, dy) {
  3753. return $.extend(this._change.s.apply(this, arguments),
  3754. this._change.e.apply(this, [ event, dx, dy ]));
  3755. },
  3756. sw: function(event, dx, dy) {
  3757. return $.extend(this._change.s.apply(this, arguments),
  3758. this._change.w.apply(this, [ event, dx, dy ]));
  3759. },
  3760. ne: function(event, dx, dy) {
  3761. return $.extend(this._change.n.apply(this, arguments),
  3762. this._change.e.apply(this, [ event, dx, dy ]));
  3763. },
  3764. nw: function(event, dx, dy) {
  3765. return $.extend(this._change.n.apply(this, arguments),
  3766. this._change.w.apply(this, [ event, dx, dy ]));
  3767. }
  3768. },
  3770. _propagate: function(n, event) {
  3771. $.ui.plugin.call(this, n, [ event, this.ui() ]);
  3772. (n !== "resize" && this._trigger(n, event, this.ui()));
  3773. },
  3775. plugins: {},
  3777. ui: function() {
  3778. return {
  3779. originalElement: this.originalElement,
  3780. element: this.element,
  3781. helper: this.helper,
  3782. position: this.position,
  3783. size: this.size,
  3784. originalSize: this.originalSize,
  3785. originalPosition: this.originalPosition
  3786. };
  3787. }
  3789. });
  3791. /*
  3792. * Resizable Extensions
  3793. */
  3795. $.ui.plugin.add("resizable", "animate", {
  3797. stop: function( event ) {
  3798. var that = $(this).resizable( "instance" ),
  3799. o = that.options,
  3800. pr = that._proportionallyResizeElements,
  3801. ista = pr.length && (/textarea/i).test(pr[0].nodeName),
  3802. soffseth = ista && that._hasScroll(pr[0], "left") ? 0 : that.sizeDiff.height,
  3803. soffsetw = ista ? 0 : that.sizeDiff.width,
  3804. style = { width: (that.size.width - soffsetw), height: (that.size.height - soffseth) },
  3805. left = (parseInt(that.element.css("left"), 10) +
  3806. (that.position.left - that.originalPosition.left)) || null,
  3807. top = (parseInt(that.element.css("top"), 10) +
  3808. (that.position.top - that.originalPosition.top)) || null;
  3810. that.element.animate(
  3811. $.extend(style, top && left ? { top: top, left: left } : {}), {
  3812. duration: o.animateDuration,
  3813. easing: o.animateEasing,
  3814. step: function() {
  3816. var data = {
  3817. width: parseInt(that.element.css("width"), 10),
  3818. height: parseInt(that.element.css("height"), 10),
  3819. top: parseInt(that.element.css("top"), 10),
  3820. left: parseInt(that.element.css("left"), 10)
  3821. };
  3823. if (pr && pr.length) {
  3824. $(pr[0]).css({ width: data.width, height: data.height });
  3825. }
  3827. // propagating resize, and updating values for each animation step
  3828. that._updateCache(data);
  3829. that._propagate("resize", event);
  3831. }
  3832. }
  3833. );
  3834. }
  3836. });
  3838. $.ui.plugin.add( "resizable", "containment", {
  3840. start: function() {
  3841. var element, p, co, ch, cw, width, height,
  3842. that = $( this ).resizable( "instance" ),
  3843. o = that.options,
  3844. el = that.element,
  3845. oc = o.containment,
  3846. ce = ( oc instanceof $ ) ? oc.get( 0 ) : ( /parent/.test( oc ) ) ? el.parent().get( 0 ) : oc;
  3848. if ( !ce ) {
  3849. return;
  3850. }
  3852. that.containerElement = $( ce );
  3854. if ( /document/.test( oc ) || oc === document ) {
  3855. that.containerOffset = {
  3856. left: 0,
  3857. top: 0
  3858. };
  3859. that.containerPosition = {
  3860. left: 0,
  3861. top: 0
  3862. };
  3864. that.parentData = {
  3865. element: $( document ),
  3866. left: 0,
  3867. top: 0,
  3868. width: $( document ).width(),
  3869. height: $( document ).height() || document.body.parentNode.scrollHeight
  3870. };
  3871. } else {
  3872. element = $( ce );
  3873. p = [];
  3874. $([ "Top", "Right", "Left", "Bottom" ]).each(function( i, name ) {
  3875. p[ i ] = that._num( element.css( "padding" + name ) );
  3876. });
  3878. that.containerOffset = element.offset();
  3879. that.containerPosition = element.position();
  3880. that.containerSize = {
  3881. height: ( element.innerHeight() - p[ 3 ] ),
  3882. width: ( element.innerWidth() - p[ 1 ] )
  3883. };
  3885. co = that.containerOffset;
  3886. ch = that.containerSize.height;
  3887. cw = that.containerSize.width;
  3888. width = ( that._hasScroll ( ce, "left" ) ? ce.scrollWidth : cw );
  3889. height = ( that._hasScroll ( ce ) ? ce.scrollHeight : ch ) ;
  3891. that.parentData = {
  3892. element: ce,
  3893. left: co.left,
  3894. top: co.top,
  3895. width: width,
  3896. height: height
  3897. };
  3898. }
  3899. },
  3901. resize: function( event ) {
  3902. var woset, hoset, isParent, isOffsetRelative,
  3903. that = $( this ).resizable( "instance" ),
  3904. o = that.options,
  3905. co = that.containerOffset,
  3906. cp = that.position,
  3907. pRatio = that._aspectRatio || event.shiftKey,
  3908. cop = {
  3909. top: 0,
  3910. left: 0
  3911. },
  3912. ce = that.containerElement,
  3913. continueResize = true;
  3915. if ( ce[ 0 ] !== document && ( /static/ ).test( ce.css( "position" ) ) ) {
  3916. cop = co;
  3917. }
  3919. if ( cp.left < ( that._helper ? co.left : 0 ) ) {
  3920. that.size.width = that.size.width +
  3921. ( that._helper ?
  3922. ( that.position.left - co.left ) :
  3923. ( that.position.left - cop.left ) );
  3925. if ( pRatio ) {
  3926. that.size.height = that.size.width / that.aspectRatio;
  3927. continueResize = false;
  3928. }
  3929. that.position.left = o.helper ? co.left : 0;
  3930. }
  3932. if ( cp.top < ( that._helper ? co.top : 0 ) ) {
  3933. that.size.height = that.size.height +
  3934. ( that._helper ?
  3935. ( that.position.top - co.top ) :
  3936. that.position.top );
  3938. if ( pRatio ) {
  3939. that.size.width = that.size.height * that.aspectRatio;
  3940. continueResize = false;
  3941. }
  3942. that.position.top = that._helper ? co.top : 0;
  3943. }
  3945. isParent = that.containerElement.get( 0 ) === that.element.parent().get( 0 );
  3946. isOffsetRelative = /relative|absolute/.test( that.containerElement.css( "position" ) );
  3948. if ( isParent && isOffsetRelative ) {
  3949. that.offset.left = that.parentData.left + that.position.left;
  3950. that.offset.top = that.parentData.top + that.position.top;
  3951. } else {
  3952. that.offset.left = that.element.offset().left;
  3953. that.offset.top = that.element.offset().top;
  3954. }
  3956. woset = Math.abs( that.sizeDiff.width +
  3957. (that._helper ?
  3958. that.offset.left - cop.left :
  3959. (that.offset.left - co.left)) );
  3961. hoset = Math.abs( that.sizeDiff.height +
  3962. (that._helper ?
  3963. that.offset.top - cop.top :
  3964. (that.offset.top - co.top)) );
  3966. if ( woset + that.size.width >= that.parentData.width ) {
  3967. that.size.width = that.parentData.width - woset;
  3968. if ( pRatio ) {
  3969. that.size.height = that.size.width / that.aspectRatio;
  3970. continueResize = false;
  3971. }
  3972. }
  3974. if ( hoset + that.size.height >= that.parentData.height ) {
  3975. that.size.height = that.parentData.height - hoset;
  3976. if ( pRatio ) {
  3977. that.size.width = that.size.height * that.aspectRatio;
  3978. continueResize = false;
  3979. }
  3980. }
  3982. if ( !continueResize ) {
  3983. that.position.left = that.prevPosition.left;
  3984. that.position.top = that.prevPosition.top;
  3985. that.size.width = that.prevSize.width;
  3986. that.size.height = that.prevSize.height;
  3987. }
  3988. },
  3990. stop: function() {
  3991. var that = $( this ).resizable( "instance" ),
  3992. o = that.options,
  3993. co = that.containerOffset,
  3994. cop = that.containerPosition,
  3995. ce = that.containerElement,
  3996. helper = $( that.helper ),
  3997. ho = helper.offset(),
  3998. w = helper.outerWidth() - that.sizeDiff.width,
  3999. h = helper.outerHeight() - that.sizeDiff.height;
  4001. if ( that._helper && !o.animate && ( /relative/ ).test( ce.css( "position" ) ) ) {
  4002. $( this ).css({
  4003. left: ho.left - cop.left - co.left,
  4004. width: w,
  4005. height: h
  4006. });
  4007. }
  4009. if ( that._helper && !o.animate && ( /static/ ).test( ce.css( "position" ) ) ) {
  4010. $( this ).css({
  4011. left: ho.left - cop.left - co.left,
  4012. width: w,
  4013. height: h
  4014. });
  4015. }
  4016. }
  4017. });
  4019. $.ui.plugin.add("resizable", "alsoResize", {
  4021. start: function() {
  4022. var that = $(this).resizable( "instance" ),
  4023. o = that.options;
  4025. $(o.alsoResize).each(function() {
  4026. var el = $(this);
  4027. el.data("ui-resizable-alsoresize", {
  4028. width: parseInt(el.width(), 10), height: parseInt(el.height(), 10),
  4029. left: parseInt(el.css("left"), 10), top: parseInt(el.css("top"), 10)
  4030. });
  4031. });
  4032. },
  4034. resize: function(event, ui) {
  4035. var that = $(this).resizable( "instance" ),
  4036. o = that.options,
  4037. os = that.originalSize,
  4038. op = that.originalPosition,
  4039. delta = {
  4040. height: (that.size.height - os.height) || 0,
  4041. width: (that.size.width - os.width) || 0,
  4042. top: (that.position.top - op.top) || 0,
  4043. left: (that.position.left - op.left) || 0
  4044. };
  4046. $(o.alsoResize).each(function() {
  4047. var el = $(this), start = $(this).data("ui-resizable-alsoresize"), style = {},
  4048. css = el.parents(ui.originalElement[0]).length ?
  4049. [ "width", "height" ] :
  4050. [ "width", "height", "top", "left" ];
  4052. $.each(css, function(i, prop) {
  4053. var sum = (start[prop] || 0) + (delta[prop] || 0);
  4054. if (sum && sum >= 0) {
  4055. style[prop] = sum || null;
  4056. }
  4057. });
  4059. el.css(style);
  4060. });
  4061. },
  4063. stop: function() {
  4064. $(this).removeData("resizable-alsoresize");
  4065. }
  4066. });
  4068. $.ui.plugin.add("resizable", "ghost", {
  4070. start: function() {
  4072. var that = $(this).resizable( "instance" ), o = that.options, cs = that.size;
  4074. that.ghost = that.originalElement.clone();
  4075. that.ghost
  4076. .css({
  4077. opacity: 0.25,
  4078. display: "block",
  4079. position: "relative",
  4080. height: cs.height,
  4081. width: cs.width,
  4082. margin: 0,
  4083. left: 0,
  4084. top: 0
  4085. })
  4086. .addClass("ui-resizable-ghost")
  4087. .addClass(typeof o.ghost === "string" ? o.ghost : "");
  4089. that.ghost.appendTo(that.helper);
  4091. },
  4093. resize: function() {
  4094. var that = $(this).resizable( "instance" );
  4095. if (that.ghost) {
  4096. that.ghost.css({
  4097. position: "relative",
  4098. height: that.size.height,
  4099. width: that.size.width
  4100. });
  4101. }
  4102. },
  4104. stop: function() {
  4105. var that = $(this).resizable( "instance" );
  4106. if (that.ghost && that.helper) {
  4107. that.helper.get(0).removeChild(that.ghost.get(0));
  4108. }
  4109. }
  4111. });
  4113. $.ui.plugin.add("resizable", "grid", {
  4115. resize: function() {
  4116. var outerDimensions,
  4117. that = $(this).resizable( "instance" ),
  4118. o = that.options,
  4119. cs = that.size,
  4120. os = that.originalSize,
  4121. op = that.originalPosition,
  4122. a = that.axis,
  4123. grid = typeof o.grid === "number" ? [ o.grid, o.grid ] : o.grid,
  4124. gridX = (grid[0] || 1),
  4125. gridY = (grid[1] || 1),
  4126. ox = Math.round((cs.width - os.width) / gridX) * gridX,
  4127. oy = Math.round((cs.height - os.height) / gridY) * gridY,
  4128. newWidth = os.width + ox,
  4129. newHeight = os.height + oy,
  4130. isMaxWidth = o.maxWidth && (o.maxWidth < newWidth),
  4131. isMaxHeight = o.maxHeight && (o.maxHeight < newHeight),
  4132. isMinWidth = o.minWidth && (o.minWidth > newWidth),
  4133. isMinHeight = o.minHeight && (o.minHeight > newHeight);
  4135. o.grid = grid;
  4137. if (isMinWidth) {
  4138. newWidth += gridX;
  4139. }
  4140. if (isMinHeight) {
  4141. newHeight += gridY;
  4142. }
  4143. if (isMaxWidth) {
  4144. newWidth -= gridX;
  4145. }
  4146. if (isMaxHeight) {
  4147. newHeight -= gridY;
  4148. }
  4150. if (/^(se|s|e)$/.test(a)) {
  4151. that.size.width = newWidth;
  4152. that.size.height = newHeight;
  4153. } else if (/^(ne)$/.test(a)) {
  4154. that.size.width = newWidth;
  4155. that.size.height = newHeight;
  4156. that.position.top = op.top - oy;
  4157. } else if (/^(sw)$/.test(a)) {
  4158. that.size.width = newWidth;
  4159. that.size.height = newHeight;
  4160. that.position.left = op.left - ox;
  4161. } else {
  4162. if ( newHeight - gridY <= 0 || newWidth - gridX <= 0) {
  4163. outerDimensions = that._getPaddingPlusBorderDimensions( this );
  4164. }
  4166. if ( newHeight - gridY > 0 ) {
  4167. that.size.height = newHeight;
  4168. that.position.top = op.top - oy;
  4169. } else {
  4170. newHeight = gridY - outerDimensions.height;
  4171. that.size.height = newHeight;
  4172. that.position.top = op.top + os.height - newHeight;
  4173. }
  4174. if ( newWidth - gridX > 0 ) {
  4175. that.size.width = newWidth;
  4176. that.position.left = op.left - ox;
  4177. } else {
  4178. newWidth = gridX - outerDimensions.width;
  4179. that.size.width = newWidth;
  4180. that.position.left = op.left + os.width - newWidth;
  4181. }
  4182. }
  4183. }
  4185. });
  4187. var resizable = $.ui.resizable;
  4190. /*!
  4191. * jQuery UI Selectable 1.11.4
  4192. * http://jqueryui.com
  4193. *
  4194. * Copyright jQuery Foundation and other contributors
  4195. * Released under the MIT license.
  4196. * http://jquery.org/license
  4197. *
  4198. * http://api.jqueryui.com/selectable/
  4199. */
  4202. var selectable = $.widget("ui.selectable", $.ui.mouse, {
  4203. version: "1.11.4",
  4204. options: {
  4205. appendTo: "body",
  4206. autoRefresh: true,
  4207. distance: 0,
  4208. filter: "*",
  4209. tolerance: "touch",
  4211. // callbacks
  4212. selected: null,
  4213. selecting: null,
  4214. start: null,
  4215. stop: null,
  4216. unselected: null,
  4217. unselecting: null
  4218. },
  4219. _create: function() {
  4220. var selectees,
  4221. that = this;
  4223. this.element.addClass("ui-selectable");
  4225. this.dragged = false;
  4227. // cache selectee children based on filter
  4228. this.refresh = function() {
  4229. selectees = $(that.options.filter, that.element[0]);
  4230. selectees.addClass("ui-selectee");
  4231. selectees.each(function() {
  4232. var $this = $(this),
  4233. pos = $this.offset();
  4234. $.data(this, "selectable-item", {
  4235. element: this,
  4236. $element: $this,
  4237. left: pos.left,
  4238. top: pos.top,
  4239. right: pos.left + $this.outerWidth(),
  4240. bottom: pos.top + $this.outerHeight(),
  4241. startselected: false,
  4242. selected: $this.hasClass("ui-selected"),
  4243. selecting: $this.hasClass("ui-selecting"),
  4244. unselecting: $this.hasClass("ui-unselecting")
  4245. });
  4246. });
  4247. };
  4248. this.refresh();
  4250. this.selectees = selectees.addClass("ui-selectee");
  4252. this._mouseInit();
  4254. this.helper = $("<div class='ui-selectable-helper'></div>");
  4255. },
  4257. _destroy: function() {
  4258. this.selectees
  4259. .removeClass("ui-selectee")
  4260. .removeData("selectable-item");
  4261. this.element
  4262. .removeClass("ui-selectable ui-selectable-disabled");
  4263. this._mouseDestroy();
  4264. },
  4266. _mouseStart: function(event) {
  4267. var that = this,
  4268. options = this.options;
  4270. this.opos = [ event.pageX, event.pageY ];
  4272. if (this.options.disabled) {
  4273. return;
  4274. }
  4276. this.selectees = $(options.filter, this.element[0]);
  4278. this._trigger("start", event);
  4280. $(options.appendTo).append(this.helper);
  4281. // position helper (lasso)
  4282. this.helper.css({
  4283. "left": event.pageX,
  4284. "top": event.pageY,
  4285. "width": 0,
  4286. "height": 0
  4287. });
  4289. if (options.autoRefresh) {
  4290. this.refresh();
  4291. }
  4293. this.selectees.filter(".ui-selected").each(function() {
  4294. var selectee = $.data(this, "selectable-item");
  4295. selectee.startselected = true;
  4296. if (!event.metaKey && !event.ctrlKey) {
  4297. selectee.$element.removeClass("ui-selected");
  4298. selectee.selected = false;
  4299. selectee.$element.addClass("ui-unselecting");
  4300. selectee.unselecting = true;
  4301. // selectable UNSELECTING callback
  4302. that._trigger("unselecting", event, {
  4303. unselecting: selectee.element
  4304. });
  4305. }
  4306. });
  4308. $(event.target).parents().addBack().each(function() {
  4309. var doSelect,
  4310. selectee = $.data(this, "selectable-item");
  4311. if (selectee) {
  4312. doSelect = (!event.metaKey && !event.ctrlKey) || !selectee.$element.hasClass("ui-selected");
  4313. selectee.$element
  4314. .removeClass(doSelect ? "ui-unselecting" : "ui-selected")
  4315. .addClass(doSelect ? "ui-selecting" : "ui-unselecting");
  4316. selectee.unselecting = !doSelect;
  4317. selectee.selecting = doSelect;
  4318. selectee.selected = doSelect;
  4319. // selectable (UN)SELECTING callback
  4320. if (doSelect) {
  4321. that._trigger("selecting", event, {
  4322. selecting: selectee.element
  4323. });
  4324. } else {
  4325. that._trigger("unselecting", event, {
  4326. unselecting: selectee.element
  4327. });
  4328. }
  4329. return false;
  4330. }
  4331. });
  4333. },
  4335. _mouseDrag: function(event) {
  4337. this.dragged = true;
  4339. if (this.options.disabled) {
  4340. return;
  4341. }
  4343. var tmp,
  4344. that = this,
  4345. options = this.options,
  4346. x1 = this.opos[0],
  4347. y1 = this.opos[1],
  4348. x2 = event.pageX,
  4349. y2 = event.pageY;
  4351. if (x1 > x2) { tmp = x2; x2 = x1; x1 = tmp; }
  4352. if (y1 > y2) { tmp = y2; y2 = y1; y1 = tmp; }
  4353. this.helper.css({ left: x1, top: y1, width: x2 - x1, height: y2 - y1 });
  4355. this.selectees.each(function() {
  4356. var selectee = $.data(this, "selectable-item"),
  4357. hit = false;
  4359. //prevent helper from being selected if appendTo: selectable
  4360. if (!selectee || selectee.element === that.element[0]) {
  4361. return;
  4362. }
  4364. if (options.tolerance === "touch") {
  4365. hit = ( !(selectee.left > x2 || selectee.right < x1 || selectee.top > y2 || selectee.bottom < y1) );
  4366. } else if (options.tolerance === "fit") {
  4367. hit = (selectee.left > x1 && selectee.right < x2 && selectee.top > y1 && selectee.bottom < y2);
  4368. }
  4370. if (hit) {
  4371. // SELECT
  4372. if (selectee.selected) {
  4373. selectee.$element.removeClass("ui-selected");
  4374. selectee.selected = false;
  4375. }
  4376. if (selectee.unselecting) {
  4377. selectee.$element.removeClass("ui-unselecting");
  4378. selectee.unselecting = false;
  4379. }
  4380. if (!selectee.selecting) {
  4381. selectee.$element.addClass("ui-selecting");
  4382. selectee.selecting = true;
  4383. // selectable SELECTING callback
  4384. that._trigger("selecting", event, {
  4385. selecting: selectee.element
  4386. });
  4387. }
  4388. } else {
  4389. // UNSELECT
  4390. if (selectee.selecting) {
  4391. if ((event.metaKey || event.ctrlKey) && selectee.startselected) {
  4392. selectee.$element.removeClass("ui-selecting");
  4393. selectee.selecting = false;
  4394. selectee.$element.addClass("ui-selected");
  4395. selectee.selected = true;
  4396. } else {
  4397. selectee.$element.removeClass("ui-selecting");
  4398. selectee.selecting = false;
  4399. if (selectee.startselected) {
  4400. selectee.$element.addClass("ui-unselecting");
  4401. selectee.unselecting = true;
  4402. }
  4403. // selectable UNSELECTING callback
  4404. that._trigger("unselecting", event, {
  4405. unselecting: selectee.element
  4406. });
  4407. }
  4408. }
  4409. if (selectee.selected) {
  4410. if (!event.metaKey && !event.ctrlKey && !selectee.startselected) {
  4411. selectee.$element.removeClass("ui-selected");
  4412. selectee.selected = false;
  4414. selectee.$element.addClass("ui-unselecting");
  4415. selectee.unselecting = true;
  4416. // selectable UNSELECTING callback
  4417. that._trigger("unselecting", event, {
  4418. unselecting: selectee.element
  4419. });
  4420. }
  4421. }
  4422. }
  4423. });
  4425. return false;
  4426. },
  4428. _mouseStop: function(event) {
  4429. var that = this;
  4431. this.dragged = false;
  4433. $(".ui-unselecting", this.element[0]).each(function() {
  4434. var selectee = $.data(this, "selectable-item");
  4435. selectee.$element.removeClass("ui-unselecting");
  4436. selectee.unselecting = false;
  4437. selectee.startselected = false;
  4438. that._trigger("unselected", event, {
  4439. unselected: selectee.element
  4440. });
  4441. });
  4442. $(".ui-selecting", this.element[0]).each(function() {
  4443. var selectee = $.data(this, "selectable-item");
  4444. selectee.$element.removeClass("ui-selecting").addClass("ui-selected");
  4445. selectee.selecting = false;
  4446. selectee.selected = true;
  4447. selectee.startselected = true;
  4448. that._trigger("selected", event, {
  4449. selected: selectee.element
  4450. });
  4451. });
  4452. this._trigger("stop", event);
  4454. this.helper.remove();
  4456. return false;
  4457. }
  4459. });
  4462. /*!
  4463. * jQuery UI Sortable 1.11.4
  4464. * http://jqueryui.com
  4465. *
  4466. * Copyright jQuery Foundation and other contributors
  4467. * Released under the MIT license.
  4468. * http://jquery.org/license
  4469. *
  4470. * http://api.jqueryui.com/sortable/
  4471. */
  4474. var sortable = $.widget("ui.sortable", $.ui.mouse, {
  4475. version: "1.11.4",
  4476. widgetEventPrefix: "sort",
  4477. ready: false,
  4478. options: {
  4479. appendTo: "parent",
  4480. axis: false,
  4481. connectWith: false,
  4482. containment: false,
  4483. cursor: "auto",
  4484. cursorAt: false,
  4485. dropOnEmpty: true,
  4486. forcePlaceholderSize: false,
  4487. forceHelperSize: false,
  4488. grid: false,
  4489. handle: false,
  4490. helper: "original",
  4491. items: "> *",
  4492. opacity: false,
  4493. placeholder: false,
  4494. revert: false,
  4495. scroll: true,
  4496. scrollSensitivity: 20,
  4497. scrollSpeed: 20,
  4498. scope: "default",
  4499. tolerance: "intersect",
  4500. zIndex: 1000,
  4502. // callbacks
  4503. activate: null,
  4504. beforeStop: null,
  4505. change: null,
  4506. deactivate: null,
  4507. out: null,
  4508. over: null,
  4509. receive: null,
  4510. remove: null,
  4511. sort: null,
  4512. start: null,
  4513. stop: null,
  4514. update: null
  4515. },
  4517. _isOverAxis: function( x, reference, size ) {
  4518. return ( x >= reference ) && ( x < ( reference + size ) );
  4519. },
  4521. _isFloating: function( item ) {
  4522. return (/left|right/).test(item.css("float")) || (/inline|table-cell/).test(item.css("display"));
  4523. },
  4525. _create: function() {
  4526. this.containerCache = {};
  4527. this.element.addClass("ui-sortable");
  4529. //Get the items
  4530. this.refresh();
  4532. //Let's determine the parent's offset
  4533. this.offset = this.element.offset();
  4535. //Initialize mouse events for interaction
  4536. this._mouseInit();
  4538. this._setHandleClassName();
  4540. //We're ready to go
  4541. this.ready = true;
  4543. },
  4545. _setOption: function( key, value ) {
  4546. this._super( key, value );
  4548. if ( key === "handle" ) {
  4549. this._setHandleClassName();
  4550. }
  4551. },
  4553. _setHandleClassName: function() {
  4554. this.element.find( ".ui-sortable-handle" ).removeClass( "ui-sortable-handle" );
  4555. $.each( this.items, function() {
  4556. ( this.instance.options.handle ?
  4557. this.item.find( this.instance.options.handle ) : this.item )
  4558. .addClass( "ui-sortable-handle" );
  4559. });
  4560. },
  4562. _destroy: function() {
  4563. this.element
  4564. .removeClass( "ui-sortable ui-sortable-disabled" )
  4565. .find( ".ui-sortable-handle" )
  4566. .removeClass( "ui-sortable-handle" );
  4567. this._mouseDestroy();
  4569. for ( var i = this.items.length - 1; i >= 0; i-- ) {
  4570. this.items[i].item.removeData(this.widgetName + "-item");
  4571. }
  4573. return this;
  4574. },
  4576. _mouseCapture: function(event, overrideHandle) {
  4577. var currentItem = null,
  4578. validHandle = false,
  4579. that = this;
  4581. if (this.reverting) {
  4582. return false;
  4583. }
  4585. if(this.options.disabled || this.options.type === "static") {
  4586. return false;
  4587. }
  4589. //We have to refresh the items data once first
  4590. this._refreshItems(event);
  4592. //Find out if the clicked node (or one of its parents) is a actual item in this.items
  4593. $(event.target).parents().each(function() {
  4594. if($.data(this, that.widgetName + "-item") === that) {
  4595. currentItem = $(this);
  4596. return false;
  4597. }
  4598. });
  4599. if($.data(event.target, that.widgetName + "-item") === that) {
  4600. currentItem = $(event.target);
  4601. }
  4603. if(!currentItem) {
  4604. return false;
  4605. }
  4606. if(this.options.handle && !overrideHandle) {
  4607. $(this.options.handle, currentItem).find("*").addBack().each(function() {
  4608. if(this === event.target) {
  4609. validHandle = true;
  4610. }
  4611. });
  4612. if(!validHandle) {
  4613. return false;
  4614. }
  4615. }
  4617. this.currentItem = currentItem;
  4618. this._removeCurrentsFromItems();
  4619. return true;
  4621. },
  4623. _mouseStart: function(event, overrideHandle, noActivation) {
  4625. var i, body,
  4626. o = this.options;
  4628. this.currentContainer = this;
  4630. //We only need to call refreshPositions, because the refreshItems call has been moved to mouseCapture
  4631. this.refreshPositions();
  4633. //Create and append the visible helper
  4634. this.helper = this._createHelper(event);
  4636. //Cache the helper size
  4637. this._cacheHelperProportions();
  4639. /*
  4640. * - Position generation -
  4641. * This block generates everything position related - it's the core of draggables.
  4642. */
  4644. //Cache the margins of the original element
  4645. this._cacheMargins();
  4647. //Get the next scrolling parent
  4648. this.scrollParent = this.helper.scrollParent();
  4650. //The element's absolute position on the page minus margins
  4651. this.offset = this.currentItem.offset();
  4652. this.offset = {
  4653. top: this.offset.top - this.margins.top,
  4654. left: this.offset.left - this.margins.left
  4655. };
  4657. $.extend(this.offset, {
  4658. click: { //Where the click happened, relative to the element
  4659. left: event.pageX - this.offset.left,
  4660. top: event.pageY - this.offset.top
  4661. },
  4662. parent: this._getParentOffset(),
  4663. relative: this._getRelativeOffset() //This is a relative to absolute position minus the actual position calculation - only used for relative positioned helper
  4664. });
  4666. // Only after we got the offset, we can change the helper's position to absolute
  4667. // TODO: Still need to figure out a way to make relative sorting possible
  4668. this.helper.css("position", "absolute");
  4669. this.cssPosition = this.helper.css("position");
  4671. //Generate the original position
  4672. this.originalPosition = this._generatePosition(event);
  4673. this.originalPageX = event.pageX;
  4674. this.originalPageY = event.pageY;
  4676. //Adjust the mouse offset relative to the helper if "cursorAt" is supplied
  4677. (o.cursorAt && this._adjustOffsetFromHelper(o.cursorAt));
  4679. //Cache the former DOM position
  4680. this.domPosition = { prev: this.currentItem.prev()[0], parent: this.currentItem.parent()[0] };
  4682. //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
  4683. if(this.helper[0] !== this.currentItem[0]) {
  4684. this.currentItem.hide();
  4685. }
  4687. //Create the placeholder
  4688. this._createPlaceholder();
  4690. //Set a containment if given in the options
  4691. if(o.containment) {
  4692. this._setContainment();
  4693. }
  4695. if( o.cursor && o.cursor !== "auto" ) { // cursor option
  4696. body = this.document.find( "body" );
  4698. // support: IE
  4699. this.storedCursor = body.css( "cursor" );
  4700. body.css( "cursor", o.cursor );
  4702. this.storedStylesheet = $( "<style>*{ cursor: "+o.cursor+" !important; }</style>" ).appendTo( body );
  4703. }
  4705. if(o.opacity) { // opacity option
  4706. if (this.helper.css("opacity")) {
  4707. this._storedOpacity = this.helper.css("opacity");
  4708. }
  4709. this.helper.css("opacity", o.opacity);
  4710. }
  4712. if(o.zIndex) { // zIndex option
  4713. if (this.helper.css("zIndex")) {
  4714. this._storedZIndex = this.helper.css("zIndex");
  4715. }
  4716. this.helper.css("zIndex", o.zIndex);
  4717. }
  4719. //Prepare scrolling
  4720. if(this.scrollParent[0] !== this.document[0] && this.scrollParent[0].tagName !== "HTML") {
  4721. this.overflowOffset = this.scrollParent.offset();
  4722. }
  4724. //Call callbacks
  4725. this._trigger("start", event, this._uiHash());
  4727. //Recache the helper size
  4728. if(!this._preserveHelperProportions) {
  4729. this._cacheHelperProportions();
  4730. }
  4733. //Post "activate" events to possible containers
  4734. if( !noActivation ) {
  4735. for ( i = this.containers.length - 1; i >= 0; i-- ) {
  4736. this.containers[ i ]._trigger( "activate", event, this._uiHash( this ) );
  4737. }
  4738. }
  4740. //Prepare possible droppables
  4741. if($.ui.ddmanager) {
  4742. $.ui.ddmanager.current = this;
  4743. }
  4745. if ($.ui.ddmanager && !o.dropBehaviour) {
  4746. $.ui.ddmanager.prepareOffsets(this, event);
  4747. }
  4749. this.dragging = true;
  4751. this.helper.addClass("ui-sortable-helper");
  4752. this._mouseDrag(event); //Execute the drag once - this causes the helper not to be visible before getting its correct position
  4753. return true;
  4755. },
  4757. _mouseDrag: function(event) {
  4758. var i, item, itemElement, intersection,
  4759. o = this.options,
  4760. scrolled = false;
  4762. //Compute the helpers position
  4763. this.position = this._generatePosition(event);
  4764. this.positionAbs = this._convertPositionTo("absolute");
  4766. if (!this.lastPositionAbs) {
  4767. this.lastPositionAbs = this.positionAbs;
  4768. }
  4770. //Do scrolling
  4771. if(this.options.scroll) {
  4772. if(this.scrollParent[0] !== this.document[0] && this.scrollParent[0].tagName !== "HTML") {
  4774. if((this.overflowOffset.top + this.scrollParent[0].offsetHeight) - event.pageY < o.scrollSensitivity) {
  4775. this.scrollParent[0].scrollTop = scrolled = this.scrollParent[0].scrollTop + o.scrollSpeed;
  4776. } else if(event.pageY - this.overflowOffset.top < o.scrollSensitivity) {
  4777. this.scrollParent[0].scrollTop = scrolled = this.scrollParent[0].scrollTop - o.scrollSpeed;
  4778. }
  4780. if((this.overflowOffset.left + this.scrollParent[0].offsetWidth) - event.pageX < o.scrollSensitivity) {
  4781. this.scrollParent[0].scrollLeft = scrolled = this.scrollParent[0].scrollLeft + o.scrollSpeed;
  4782. } else if(event.pageX - this.overflowOffset.left < o.scrollSensitivity) {
  4783. this.scrollParent[0].scrollLeft = scrolled = this.scrollParent[0].scrollLeft - o.scrollSpeed;
  4784. }
  4786. } else {
  4788. if(event.pageY - this.document.scrollTop() < o.scrollSensitivity) {
  4789. scrolled = this.document.scrollTop(this.document.scrollTop() - o.scrollSpeed);
  4790. } else if(this.window.height() - (event.pageY - this.document.scrollTop()) < o.scrollSensitivity) {
  4791. scrolled = this.document.scrollTop(this.document.scrollTop() + o.scrollSpeed);
  4792. }
  4794. if(event.pageX - this.document.scrollLeft() < o.scrollSensitivity) {
  4795. scrolled = this.document.scrollLeft(this.document.scrollLeft() - o.scrollSpeed);
  4796. } else if(this.window.width() - (event.pageX - this.document.scrollLeft()) < o.scrollSensitivity) {
  4797. scrolled = this.document.scrollLeft(this.document.scrollLeft() + o.scrollSpeed);
  4798. }
  4800. }
  4802. if(scrolled !== false && $.ui.ddmanager && !o.dropBehaviour) {
  4803. $.ui.ddmanager.prepareOffsets(this, event);
  4804. }
  4805. }
  4807. //Regenerate the absolute position used for position checks
  4808. this.positionAbs = this._convertPositionTo("absolute");
  4810. //Set the helper position
  4811. if(!this.options.axis || this.options.axis !== "y") {
  4812. this.helper[0].style.left = this.position.left+"px";
  4813. }
  4814. if(!this.options.axis || this.options.axis !== "x") {
  4815. this.helper[0].style.top = this.position.top+"px";
  4816. }
  4818. //Rearrange
  4819. for (i = this.items.length - 1; i >= 0; i--) {
  4821. //Cache variables and intersection, continue if no intersection
  4822. item = this.items[i];
  4823. itemElement = item.item[0];
  4824. intersection = this._intersectsWithPointer(item);
  4825. if (!intersection) {
  4826. continue;
  4827. }
  4829. // Only put the placeholder inside the current Container, skip all
  4830. // items from other containers. This works because when moving
  4831. // an item from one container to another the
  4832. // currentContainer is switched before the placeholder is moved.
  4833. //
  4834. // Without this, moving items in "sub-sortables" can cause
  4835. // the placeholder to jitter between the outer and inner container.
  4836. if (item.instance !== this.currentContainer) {
  4837. continue;
  4838. }
  4840. // cannot intersect with itself
  4841. // no useless actions that have been done before
  4842. // no action if the item moved is the parent of the item checked
  4843. if (itemElement !== this.currentItem[0] &&
  4844. this.placeholder[intersection === 1 ? "next" : "prev"]()[0] !== itemElement &&
  4845. !$.contains(this.placeholder[0], itemElement) &&
  4846. (this.options.type === "semi-dynamic" ? !$.contains(this.element[0], itemElement) : true)
  4847. ) {
  4849. this.direction = intersection === 1 ? "down" : "up";
  4851. if (this.options.tolerance === "pointer" || this._intersectsWithSides(item)) {
  4852. this._rearrange(event, item);
  4853. } else {
  4854. break;
  4855. }
  4857. this._trigger("change", event, this._uiHash());
  4858. break;
  4859. }
  4860. }
  4862. //Post events to containers
  4863. this._contactContainers(event);
  4865. //Interconnect with droppables
  4866. if($.ui.ddmanager) {
  4867. $.ui.ddmanager.drag(this, event);
  4868. }
  4870. //Call callbacks
  4871. this._trigger("sort", event, this._uiHash());
  4873. this.lastPositionAbs = this.positionAbs;
  4874. return false;
  4876. },
  4878. _mouseStop: function(event, noPropagation) {
  4880. if(!event) {
  4881. return;
  4882. }
  4884. //If we are using droppables, inform the manager about the drop
  4885. if ($.ui.ddmanager && !this.options.dropBehaviour) {
  4886. $.ui.ddmanager.drop(this, event);
  4887. }
  4889. if(this.options.revert) {
  4890. var that = this,
  4891. cur = this.placeholder.offset(),
  4892. axis = this.options.axis,
  4893. animation = {};
  4895. if ( !axis || axis === "x" ) {
  4896. animation.left = cur.left - this.offset.parent.left - this.margins.left + (this.offsetParent[0] === this.document[0].body ? 0 : this.offsetParent[0].scrollLeft);
  4897. }
  4898. if ( !axis || axis === "y" ) {
  4899. animation.top = cur.top - this.offset.parent.top - this.margins.top + (this.offsetParent[0] === this.document[0].body ? 0 : this.offsetParent[0].scrollTop);
  4900. }
  4901. this.reverting = true;
  4902. $(this.helper).animate( animation, parseInt(this.options.revert, 10) || 500, function() {
  4903. that._clear(event);
  4904. });
  4905. } else {
  4906. this._clear(event, noPropagation);
  4907. }
  4909. return false;
  4911. },
  4913. cancel: function() {
  4915. if(this.dragging) {
  4917. this._mouseUp({ target: null });
  4919. if(this.options.helper === "original") {
  4920. this.currentItem.css(this._storedCSS).removeClass("ui-sortable-helper");
  4921. } else {
  4922. this.currentItem.show();
  4923. }
  4925. //Post deactivating events to containers
  4926. for (var i = this.containers.length - 1; i >= 0; i--){
  4927. this.containers[i]._trigger("deactivate", null, this._uiHash(this));
  4928. if(this.containers[i].containerCache.over) {
  4929. this.containers[i]._trigger("out", null, this._uiHash(this));
  4930. this.containers[i].containerCache.over = 0;
  4931. }
  4932. }
  4934. }
  4936. if (this.placeholder) {
  4937. //$(this.placeholder[0]).remove(); would have been the jQuery way - unfortunately, it unbinds ALL events from the original node!
  4938. if(this.placeholder[0].parentNode) {
  4939. this.placeholder[0].parentNode.removeChild(this.placeholder[0]);
  4940. }
  4941. if(this.options.helper !== "original" && this.helper && this.helper[0].parentNode) {
  4942. this.helper.remove();
  4943. }
  4945. $.extend(this, {
  4946. helper: null,
  4947. dragging: false,
  4948. reverting: false,
  4949. _noFinalSort: null
  4950. });
  4952. if(this.domPosition.prev) {
  4953. $(this.domPosition.prev).after(this.currentItem);
  4954. } else {
  4955. $(this.domPosition.parent).prepend(this.currentItem);
  4956. }
  4957. }
  4959. return this;
  4961. },
  4963. serialize: function(o) {
  4965. var items = this._getItemsAsjQuery(o && o.connected),
  4966. str = [];
  4967. o = o || {};
  4969. $(items).each(function() {
  4970. var res = ($(o.item || this).attr(o.attribute || "id") || "").match(o.expression || (/(.+)[\-=_](.+)/));
  4971. if (res) {
  4972. str.push((o.key || res[1]+"[]")+"="+(o.key && o.expression ? res[1] : res[2]));
  4973. }
  4974. });
  4976. if(!str.length && o.key) {
  4977. str.push(o.key + "=");
  4978. }
  4980. return str.join("&");
  4982. },
  4984. toArray: function(o) {
  4986. var items = this._getItemsAsjQuery(o && o.connected),
  4987. ret = [];
  4989. o = o || {};
  4991. items.each(function() { ret.push($(o.item || this).attr(o.attribute || "id") || ""); });
  4992. return ret;
  4994. },
  4996. /* Be careful with the following core functions */
  4997. _intersectsWith: function(item) {
  4999. var x1 = this.positionAbs.left,
  5000. x2 = x1 + this.helperProportions.width,
  5001. y1 = this.positionAbs.top,
  5002. y2 = y1 + this.helperProportions.height,
  5003. l = item.left,
  5004. r = l + item.width,
  5005. t = item.top,
  5006. b = t + item.height,
  5007. dyClick = this.offset.click.top,
  5008. dxClick = this.offset.click.left,
  5009. isOverElementHeight = ( this.options.axis === "x" ) || ( ( y1 + dyClick ) > t && ( y1 + dyClick ) < b ),
  5010. isOverElementWidth = ( this.options.axis === "y" ) || ( ( x1 + dxClick ) > l && ( x1 + dxClick ) < r ),
  5011. isOverElement = isOverElementHeight && isOverElementWidth;
  5013. if ( this.options.tolerance === "pointer" ||
  5014. this.options.forcePointerForContainers ||
  5015. (this.options.tolerance !== "pointer" && this.helperProportions[this.floating ? "width" : "height"] > item[this.floating ? "width" : "height"])
  5016. ) {
  5017. return isOverElement;
  5018. } else {
  5020. return (l < x1 + (this.helperProportions.width / 2) && // Right Half
  5021. x2 - (this.helperProportions.width / 2) < r && // Left Half
  5022. t < y1 + (this.helperProportions.height / 2) && // Bottom Half
  5023. y2 - (this.helperProportions.height / 2) < b ); // Top Half
  5025. }
  5026. },
  5028. _intersectsWithPointer: function(item) {
  5030. var isOverElementHeight = (this.options.axis === "x") || this._isOverAxis(this.positionAbs.top + this.offset.click.top, item.top, item.height),
  5031. isOverElementWidth = (this.options.axis === "y") || this._isOverAxis(this.positionAbs.left + this.offset.click.left, item.left, item.width),
  5032. isOverElement = isOverElementHeight && isOverElementWidth,
  5033. verticalDirection = this._getDragVerticalDirection(),
  5034. horizontalDirection = this._getDragHorizontalDirection();
  5036. if (!isOverElement) {
  5037. return false;
  5038. }
  5040. return this.floating ?
  5041. ( ((horizontalDirection && horizontalDirection === "right") || verticalDirection === "down") ? 2 : 1 )
  5042. : ( verticalDirection && (verticalDirection === "down" ? 2 : 1) );
  5044. },
  5046. _intersectsWithSides: function(item) {
  5048. var isOverBottomHalf = this._isOverAxis(this.positionAbs.top + this.offset.click.top, item.top + (item.height/2), item.height),
  5049. isOverRightHalf = this._isOverAxis(this.positionAbs.left + this.offset.click.left, item.left + (item.width/2), item.width),
  5050. verticalDirection = this._getDragVerticalDirection(),
  5051. horizontalDirection = this._getDragHorizontalDirection();
  5053. if (this.floating && horizontalDirection) {
  5054. return ((horizontalDirection === "right" && isOverRightHalf) || (horizontalDirection === "left" && !isOverRightHalf));
  5055. } else {
  5056. return verticalDirection && ((verticalDirection === "down" && isOverBottomHalf) || (verticalDirection === "up" && !isOverBottomHalf));
  5057. }
  5059. },
  5061. _getDragVerticalDirection: function() {
  5062. var delta = this.positionAbs.top - this.lastPositionAbs.top;
  5063. return delta !== 0 && (delta > 0 ? "down" : "up");
  5064. },
  5066. _getDragHorizontalDirection: function() {
  5067. var delta = this.positionAbs.left - this.lastPositionAbs.left;
  5068. return delta !== 0 && (delta > 0 ? "right" : "left");
  5069. },
  5071. refresh: function(event) {
  5072. this._refreshItems(event);
  5073. this._setHandleClassName();
  5074. this.refreshPositions();
  5075. return this;
  5076. },
  5078. _connectWith: function() {
  5079. var options = this.options;
  5080. return options.connectWith.constructor === String ? [options.connectWith] : options.connectWith;
  5081. },
  5083. _getItemsAsjQuery: function(connected) {
  5085. var i, j, cur, inst,
  5086. items = [],
  5087. queries = [],
  5088. connectWith = this._connectWith();
  5090. if(connectWith && connected) {
  5091. for (i = connectWith.length - 1; i >= 0; i--){
  5092. cur = $(connectWith[i], this.document[0]);
  5093. for ( j = cur.length - 1; j >= 0; j--){
  5094. inst = $.data(cur[j], this.widgetFullName);
  5095. if(inst && inst !== this && !inst.options.disabled) {
  5096. 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]);
  5097. }
  5098. }
  5099. }
  5100. }
  5102. 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]);
  5104. function addItems() {
  5105. items.push( this );
  5106. }
  5107. for (i = queries.length - 1; i >= 0; i--){
  5108. queries[i][0].each( addItems );
  5109. }
  5111. return $(items);
  5113. },
  5115. _removeCurrentsFromItems: function() {
  5117. var list = this.currentItem.find(":data(" + this.widgetName + "-item)");
  5119. this.items = $.grep(this.items, function (item) {
  5120. for (var j=0; j < list.length; j++) {
  5121. if(list[j] === item.item[0]) {
  5122. return false;
  5123. }
  5124. }
  5125. return true;
  5126. });
  5128. },
  5130. _refreshItems: function(event) {
  5132. this.items = [];
  5133. this.containers = [this];
  5135. var i, j, cur, inst, targetData, _queries, item, queriesLength,
  5136. items = this.items,
  5137. queries = [[$.isFunction(this.options.items) ? this.options.items.call(this.element[0], event, { item: this.currentItem }) : $(this.options.items, this.element), this]],
  5138. connectWith = this._connectWith();
  5140. if(connectWith && this.ready) { //Shouldn't be run the first time through due to massive slow-down
  5141. for (i = connectWith.length - 1; i >= 0; i--){
  5142. cur = $(connectWith[i], this.document[0]);
  5143. for (j = cur.length - 1; j >= 0; j--){
  5144. inst = $.data(cur[j], this.widgetFullName);
  5145. if(inst && inst !== this && !inst.options.disabled) {
  5146. queries.push([$.isFunction(inst.options.items) ? inst.options.items.call(inst.element[0], event, { item: this.currentItem }) : $(inst.options.items, inst.element), inst]);
  5147. this.containers.push(inst);
  5148. }
  5149. }
  5150. }
  5151. }
  5153. for (i = queries.length - 1; i >= 0; i--) {
  5154. targetData = queries[i][1];
  5155. _queries = queries[i][0];
  5157. for (j=0, queriesLength = _queries.length; j < queriesLength; j++) {
  5158. item = $(_queries[j]);
  5160. item.data(this.widgetName + "-item", targetData); // Data for target checking (mouse manager)
  5162. items.push({
  5163. item: item,
  5164. instance: targetData,
  5165. width: 0, height: 0,
  5166. left: 0, top: 0
  5167. });
  5168. }
  5169. }
  5171. },
  5173. refreshPositions: function(fast) {
  5175. // Determine whether items are being displayed horizontally
  5176. this.floating = this.items.length ?
  5177. this.options.axis === "x" || this._isFloating( this.items[ 0 ].item ) :
  5178. false;
  5180. //This has to be redone because due to the item being moved out/into the offsetParent, the offsetParent's position will change
  5181. if(this.offsetParent && this.helper) {
  5182. this.offset.parent = this._getParentOffset();
  5183. }
  5185. var i, item, t, p;
  5187. for (i = this.items.length - 1; i >= 0; i--){
  5188. item = this.items[i];
  5190. //We ignore calculating positions of all connected containers when we're not over them
  5191. if(item.instance !== this.currentContainer && this.currentContainer && item.item[0] !== this.currentItem[0]) {
  5192. continue;
  5193. }
  5195. t = this.options.toleranceElement ? $(this.options.toleranceElement, item.item) : item.item;
  5197. if (!fast) {
  5198. item.width = t.outerWidth();
  5199. item.height = t.outerHeight();
  5200. }
  5202. p = t.offset();
  5203. item.left = p.left;
  5204. item.top = p.top;
  5205. }
  5207. if(this.options.custom && this.options.custom.refreshContainers) {
  5208. this.options.custom.refreshContainers.call(this);
  5209. } else {
  5210. for (i = this.containers.length - 1; i >= 0; i--){
  5211. p = this.containers[i].element.offset();
  5212. this.containers[i].containerCache.left = p.left;
  5213. this.containers[i].containerCache.top = p.top;
  5214. this.containers[i].containerCache.width = this.containers[i].element.outerWidth();
  5215. this.containers[i].containerCache.height = this.containers[i].element.outerHeight();
  5216. }
  5217. }
  5219. return this;
  5220. },
  5222. _createPlaceholder: function(that) {
  5223. that = that || this;
  5224. var className,
  5225. o = that.options;
  5227. if(!o.placeholder || o.placeholder.constructor === String) {
  5228. className = o.placeholder;
  5229. o.placeholder = {
  5230. element: function() {
  5232. var nodeName = that.currentItem[0].nodeName.toLowerCase(),
  5233. element = $( "<" + nodeName + ">", that.document[0] )
  5234. .addClass(className || that.currentItem[0].className+" ui-sortable-placeholder")
  5235. .removeClass("ui-sortable-helper");
  5237. if ( nodeName === "tbody" ) {
  5238. that._createTrPlaceholder(
  5239. that.currentItem.find( "tr" ).eq( 0 ),
  5240. $( "<tr>", that.document[ 0 ] ).appendTo( element )
  5241. );
  5242. } else if ( nodeName === "tr" ) {
  5243. that._createTrPlaceholder( that.currentItem, element );
  5244. } else if ( nodeName === "img" ) {
  5245. element.attr( "src", that.currentItem.attr( "src" ) );
  5246. }
  5248. if ( !className ) {
  5249. element.css( "visibility", "hidden" );
  5250. }
  5252. return element;
  5253. },
  5254. update: function(container, p) {
  5256. // 1. If a className is set as 'placeholder option, we don't force sizes - the class is responsible for that
  5257. // 2. The option 'forcePlaceholderSize can be enabled to force it even if a class name is specified
  5258. if(className && !o.forcePlaceholderSize) {
  5259. return;
  5260. }
  5262. //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
  5263. if(!p.height()) { p.height(that.currentItem.innerHeight() - parseInt(that.currentItem.css("paddingTop")||0, 10) - parseInt(that.currentItem.css("paddingBottom")||0, 10)); }
  5264. if(!p.width()) { p.width(that.currentItem.innerWidth() - parseInt(that.currentItem.css("paddingLeft")||0, 10) - parseInt(that.currentItem.css("paddingRight")||0, 10)); }
  5265. }
  5266. };
  5267. }
  5269. //Create the placeholder
  5270. that.placeholder = $(o.placeholder.element.call(that.element, that.currentItem));
  5272. //Append it after the actual current item
  5273. that.currentItem.after(that.placeholder);
  5275. //Update the size of the placeholder (TODO: Logic to fuzzy, see line 316/317)
  5276. o.placeholder.update(that, that.placeholder);
  5278. },
  5280. _createTrPlaceholder: function( sourceTr, targetTr ) {
  5281. var that = this;
  5283. sourceTr.children().each(function() {
  5284. $( "<td>&#160;</td>", that.document[ 0 ] )
  5285. .attr( "colspan", $( this ).attr( "colspan" ) || 1 )
  5286. .appendTo( targetTr );
  5287. });
  5288. },
  5290. _contactContainers: function(event) {
  5291. var i, j, dist, itemWithLeastDistance, posProperty, sizeProperty, cur, nearBottom, floating, axis,
  5292. innermostContainer = null,
  5293. innermostIndex = null;
  5295. // get innermost container that intersects with item
  5296. for (i = this.containers.length - 1; i >= 0; i--) {
  5298. // never consider a container that's located within the item itself
  5299. if($.contains(this.currentItem[0], this.containers[i].element[0])) {
  5300. continue;
  5301. }
  5303. if(this._intersectsWith(this.containers[i].containerCache)) {
  5305. // if we've already found a container and it's more "inner" than this, then continue
  5306. if(innermostContainer && $.contains(this.containers[i].element[0], innermostContainer.element[0])) {
  5307. continue;
  5308. }
  5310. innermostContainer = this.containers[i];
  5311. innermostIndex = i;
  5313. } else {
  5314. // container doesn't intersect. trigger "out" event if necessary
  5315. if(this.containers[i].containerCache.over) {
  5316. this.containers[i]._trigger("out", event, this._uiHash(this));
  5317. this.containers[i].containerCache.over = 0;
  5318. }
  5319. }
  5321. }
  5323. // if no intersecting containers found, return
  5324. if(!innermostContainer) {
  5325. return;
  5326. }
  5328. // move the item into the container if it's not there already
  5329. if(this.containers.length === 1) {
  5330. if (!this.containers[innermostIndex].containerCache.over) {
  5331. this.containers[innermostIndex]._trigger("over", event, this._uiHash(this));
  5332. this.containers[innermostIndex].containerCache.over = 1;
  5333. }
  5334. } else {
  5336. //When entering a new container, we will find the item with the least distance and append our item near it
  5337. dist = 10000;
  5338. itemWithLeastDistance = null;
  5339. floating = innermostContainer.floating || this._isFloating(this.currentItem);
  5340. posProperty = floating ? "left" : "top";
  5341. sizeProperty = floating ? "width" : "height";
  5342. axis = floating ? "clientX" : "clientY";
  5344. for (j = this.items.length - 1; j >= 0; j--) {
  5345. if(!$.contains(this.containers[innermostIndex].element[0], this.items[j].item[0])) {
  5346. continue;
  5347. }
  5348. if(this.items[j].item[0] === this.currentItem[0]) {
  5349. continue;
  5350. }
  5352. cur = this.items[j].item.offset()[posProperty];
  5353. nearBottom = false;
  5354. if ( event[ axis ] - cur > this.items[ j ][ sizeProperty ] / 2 ) {
  5355. nearBottom = true;
  5356. }
  5358. if ( Math.abs( event[ axis ] - cur ) < dist ) {
  5359. dist = Math.abs( event[ axis ] - cur );
  5360. itemWithLeastDistance = this.items[ j ];
  5361. this.direction = nearBottom ? "up": "down";
  5362. }
  5363. }
  5365. //Check if dropOnEmpty is enabled
  5366. if(!itemWithLeastDistance && !this.options.dropOnEmpty) {
  5367. return;
  5368. }
  5370. if(this.currentContainer === this.containers[innermostIndex]) {
  5371. if ( !this.currentContainer.containerCache.over ) {
  5372. this.containers[ innermostIndex ]._trigger( "over", event, this._uiHash() );
  5373. this.currentContainer.containerCache.over = 1;
  5374. }
  5375. return;
  5376. }
  5378. itemWithLeastDistance ? this._rearrange(event, itemWithLeastDistance, null, true) : this._rearrange(event, null, this.containers[innermostIndex].element, true);
  5379. this._trigger("change", event, this._uiHash());
  5380. this.containers[innermostIndex]._trigger("change", event, this._uiHash(this));
  5381. this.currentContainer = this.containers[innermostIndex];
  5383. //Update the placeholder
  5384. this.options.placeholder.update(this.currentContainer, this.placeholder);
  5386. this.containers[innermostIndex]._trigger("over", event, this._uiHash(this));
  5387. this.containers[innermostIndex].containerCache.over = 1;
  5388. }
  5391. },
  5393. _createHelper: function(event) {
  5395. var o = this.options,
  5396. helper = $.isFunction(o.helper) ? $(o.helper.apply(this.element[0], [event, this.currentItem])) : (o.helper === "clone" ? this.currentItem.clone() : this.currentItem);
  5398. //Add the helper to the DOM if that didn't happen already
  5399. if(!helper.parents("body").length) {
  5400. $(o.appendTo !== "parent" ? o.appendTo : this.currentItem[0].parentNode)[0].appendChild(helper[0]);
  5401. }
  5403. if(helper[0] === this.currentItem[0]) {
  5404. 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") };
  5405. }
  5407. if(!helper[0].style.width || o.forceHelperSize) {
  5408. helper.width(this.currentItem.width());
  5409. }
  5410. if(!helper[0].style.height || o.forceHelperSize) {
  5411. helper.height(this.currentItem.height());
  5412. }
  5414. return helper;
  5416. },
  5418. _adjustOffsetFromHelper: function(obj) {
  5419. if (typeof obj === "string") {
  5420. obj = obj.split(" ");
  5421. }
  5422. if ($.isArray(obj)) {
  5423. obj = {left: +obj[0], top: +obj[1] || 0};
  5424. }
  5425. if ("left" in obj) {
  5426. this.offset.click.left = obj.left + this.margins.left;
  5427. }
  5428. if ("right" in obj) {
  5429. this.offset.click.left = this.helperProportions.width - obj.right + this.margins.left;
  5430. }
  5431. if ("top" in obj) {
  5432. this.offset.click.top = obj.top + this.margins.top;
  5433. }
  5434. if ("bottom" in obj) {
  5435. this.offset.click.top = this.helperProportions.height - obj.bottom + this.margins.top;
  5436. }
  5437. },
  5439. _getParentOffset: function() {
  5442. //Get the offsetParent and cache its position
  5443. this.offsetParent = this.helper.offsetParent();
  5444. var po = this.offsetParent.offset();
  5446. // This is a special case where we need to modify a offset calculated on start, since the following happened:
  5447. // 1. The position of the helper is absolute, so it's position is calculated based on the next positioned parent
  5448. // 2. The actual offset parent is a child of the scroll parent, and the scroll parent isn't the document, which means that
  5449. // the scroll is included in the initial calculation of the offset of the parent, and never recalculated upon drag
  5450. if(this.cssPosition === "absolute" && this.scrollParent[0] !== this.document[0] && $.contains(this.scrollParent[0], this.offsetParent[0])) {
  5451. po.left += this.scrollParent.scrollLeft();
  5452. po.top += this.scrollParent.scrollTop();
  5453. }
  5455. // This needs to be actually done for all browsers, since pageX/pageY includes this information
  5456. // with an ugly IE fix
  5457. if( this.offsetParent[0] === this.document[0].body || (this.offsetParent[0].tagName && this.offsetParent[0].tagName.toLowerCase() === "html" && $.ui.ie)) {
  5458. po = { top: 0, left: 0 };
  5459. }
  5461. return {
  5462. top: po.top + (parseInt(this.offsetParent.css("borderTopWidth"),10) || 0),
  5463. left: po.left + (parseInt(this.offsetParent.css("borderLeftWidth"),10) || 0)
  5464. };
  5466. },
  5468. _getRelativeOffset: function() {
  5470. if(this.cssPosition === "relative") {
  5471. var p = this.currentItem.position();
  5472. return {
  5473. top: p.top - (parseInt(this.helper.css("top"),10) || 0) + this.scrollParent.scrollTop(),
  5474. left: p.left - (parseInt(this.helper.css("left"),10) || 0) + this.scrollParent.scrollLeft()
  5475. };
  5476. } else {
  5477. return { top: 0, left: 0 };
  5478. }
  5480. },
  5482. _cacheMargins: function() {
  5483. this.margins = {
  5484. left: (parseInt(this.currentItem.css("marginLeft"),10) || 0),
  5485. top: (parseInt(this.currentItem.css("marginTop"),10) || 0)
  5486. };
  5487. },
  5489. _cacheHelperProportions: function() {
  5490. this.helperProportions = {
  5491. width: this.helper.outerWidth(),
  5492. height: this.helper.outerHeight()
  5493. };
  5494. },
  5496. _setContainment: function() {
  5498. var ce, co, over,
  5499. o = this.options;
  5500. if(o.containment === "parent") {
  5501. o.containment = this.helper[0].parentNode;
  5502. }
  5503. if(o.containment === "document" || o.containment === "window") {
  5504. this.containment = [
  5505. 0 - this.offset.relative.left - this.offset.parent.left,
  5506. 0 - this.offset.relative.top - this.offset.parent.top,
  5507. o.containment === "document" ? this.document.width() : this.window.width() - this.helperProportions.width - this.margins.left,
  5508. (o.containment === "document" ? this.document.width() : this.window.height() || this.document[0].body.parentNode.scrollHeight) - this.helperProportions.height - this.margins.top
  5509. ];
  5510. }
  5512. if(!(/^(document|window|parent)$/).test(o.containment)) {
  5513. ce = $(o.containment)[0];
  5514. co = $(o.containment).offset();
  5515. over = ($(ce).css("overflow") !== "hidden");
  5517. this.containment = [
  5518. co.left + (parseInt($(ce).css("borderLeftWidth"),10) || 0) + (parseInt($(ce).css("paddingLeft"),10) || 0) - this.margins.left,
  5519. co.top + (parseInt($(ce).css("borderTopWidth"),10) || 0) + (parseInt($(ce).css("paddingTop"),10) || 0) - this.margins.top,
  5520. 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,
  5521. 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
  5522. ];
  5523. }
  5525. },
  5527. _convertPositionTo: function(d, pos) {
  5529. if(!pos) {
  5530. pos = this.position;
  5531. }
  5532. var mod = d === "absolute" ? 1 : -1,
  5533. scroll = this.cssPosition === "absolute" && !(this.scrollParent[0] !== this.document[0] && $.contains(this.scrollParent[0], this.offsetParent[0])) ? this.offsetParent : this.scrollParent,
  5534. scrollIsRootNode = (/(html|body)/i).test(scroll[0].tagName);
  5536. return {
  5537. top: (
  5538. pos.top + // The absolute mouse position
  5539. this.offset.relative.top * mod + // Only for relative positioned nodes: Relative offset from element to offset parent
  5540. this.offset.parent.top * mod - // The offsetParent's offset without borders (offset + border)
  5541. ( ( this.cssPosition === "fixed" ? -this.scrollParent.scrollTop() : ( scrollIsRootNode ? 0 : scroll.scrollTop() ) ) * mod)
  5542. ),
  5543. left: (
  5544. pos.left + // The absolute mouse position
  5545. this.offset.relative.left * mod + // Only for relative positioned nodes: Relative offset from element to offset parent
  5546. this.offset.parent.left * mod - // The offsetParent's offset without borders (offset + border)
  5547. ( ( this.cssPosition === "fixed" ? -this.scrollParent.scrollLeft() : scrollIsRootNode ? 0 : scroll.scrollLeft() ) * mod)
  5548. )
  5549. };
  5551. },
  5553. _generatePosition: function(event) {
  5555. var top, left,
  5556. o = this.options,
  5557. pageX = event.pageX,
  5558. pageY = event.pageY,
  5559. 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);
  5561. // This is another very weird special case that only happens for relative elements:
  5562. // 1. If the css position is relative
  5563. // 2. and the scroll parent is the document or similar to the offset parent
  5564. // we have to refresh the relative offset during the scroll so there are no jumps
  5565. if(this.cssPosition === "relative" && !(this.scrollParent[0] !== this.document[0] && this.scrollParent[0] !== this.offsetParent[0])) {
  5566. this.offset.relative = this._getRelativeOffset();
  5567. }
  5569. /*
  5570. * - Position constraining -
  5571. * Constrain the position to a mix of grid, containment.
  5572. */
  5574. if(this.originalPosition) { //If we are not dragging yet, we won't check for options
  5576. if(this.containment) {
  5577. if(event.pageX - this.offset.click.left < this.containment[0]) {
  5578. pageX = this.containment[0] + this.offset.click.left;
  5579. }
  5580. if(event.pageY - this.offset.click.top < this.containment[1]) {
  5581. pageY = this.containment[1] + this.offset.click.top;
  5582. }
  5583. if(event.pageX - this.offset.click.left > this.containment[2]) {
  5584. pageX = this.containment[2] + this.offset.click.left;
  5585. }
  5586. if(event.pageY - this.offset.click.top > this.containment[3]) {
  5587. pageY = this.containment[3] + this.offset.click.top;
  5588. }
  5589. }
  5591. if(o.grid) {
  5592. top = this.originalPageY + Math.round((pageY - this.originalPageY) / o.grid[1]) * o.grid[1];
  5593. 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;
  5595. left = this.originalPageX + Math.round((pageX - this.originalPageX) / o.grid[0]) * o.grid[0];
  5596. 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;
  5597. }
  5599. }
  5601. return {
  5602. top: (
  5603. pageY - // The absolute mouse position
  5604. this.offset.click.top - // Click offset (relative to the element)
  5605. this.offset.relative.top - // Only for relative positioned nodes: Relative offset from element to offset parent
  5606. this.offset.parent.top + // The offsetParent's offset without borders (offset + border)
  5607. ( ( this.cssPosition === "fixed" ? -this.scrollParent.scrollTop() : ( scrollIsRootNode ? 0 : scroll.scrollTop() ) ))
  5608. ),
  5609. left: (
  5610. pageX - // The absolute mouse position
  5611. this.offset.click.left - // Click offset (relative to the element)
  5612. this.offset.relative.left - // Only for relative positioned nodes: Relative offset from element to offset parent
  5613. this.offset.parent.left + // The offsetParent's offset without borders (offset + border)
  5614. ( ( this.cssPosition === "fixed" ? -this.scrollParent.scrollLeft() : scrollIsRootNode ? 0 : scroll.scrollLeft() ))
  5615. )
  5616. };
  5618. },
  5620. _rearrange: function(event, i, a, hardRefresh) {
  5622. 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));
  5624. //Various things done here to improve the performance:
  5625. // 1. we create a setTimeout, that calls refreshPositions
  5626. // 2. on the instance, we have a counter variable, that get's higher after every append
  5627. // 3. on the local scope, we copy the counter variable, and check in the timeout, if it's still the same
  5628. // 4. this lets only the last addition to the timeout stack through
  5629. this.counter = this.counter ? ++this.counter : 1;
  5630. var counter = this.counter;
  5632. this._delay(function() {
  5633. if(counter === this.counter) {
  5634. this.refreshPositions(!hardRefresh); //Precompute after each DOM insertion, NOT on mousemove
  5635. }
  5636. });
  5638. },
  5640. _clear: function(event, noPropagation) {
  5642. this.reverting = false;
  5643. // We delay all events that have to be triggered to after the point where the placeholder has been removed and
  5644. // everything else normalized again
  5645. var i,
  5646. delayedTriggers = [];
  5648. // We first have to update the dom position of the actual currentItem
  5649. // Note: don't do it if the current item is already removed (by a user), or it gets reappended (see #4088)
  5650. if(!this._noFinalSort && this.currentItem.parent().length) {
  5651. this.placeholder.before(this.currentItem);
  5652. }
  5653. this._noFinalSort = null;
  5655. if(this.helper[0] === this.currentItem[0]) {
  5656. for(i in this._storedCSS) {
  5657. if(this._storedCSS[i] === "auto" || this._storedCSS[i] === "static") {
  5658. this._storedCSS[i] = "";
  5659. }
  5660. }
  5661. this.currentItem.css(this._storedCSS).removeClass("ui-sortable-helper");
  5662. } else {
  5663. this.currentItem.show();
  5664. }
  5666. if(this.fromOutside && !noPropagation) {
  5667. delayedTriggers.push(function(event) { this._trigger("receive", event, this._uiHash(this.fromOutside)); });
  5668. }
  5669. if((this.fromOutside || this.domPosition.prev !== this.currentItem.prev().not(".ui-sortable-helper")[0] || this.domPosition.parent !== this.currentItem.parent()[0]) && !noPropagation) {
  5670. delayedTriggers.push(function(event) { this._trigger("update", event, this._uiHash()); }); //Trigger update callback if the DOM position has changed
  5671. }
  5673. // Check if the items Container has Changed and trigger appropriate
  5674. // events.
  5675. if (this !== this.currentContainer) {
  5676. if(!noPropagation) {
  5677. delayedTriggers.push(function(event) { this._trigger("remove", event, this._uiHash()); });
  5678. delayedTriggers.push((function(c) { return function(event) { c._trigger("receive", event, this._uiHash(this)); }; }).call(this, this.currentContainer));
  5679. delayedTriggers.push((function(c) { return function(event) { c._trigger("update", event, this._uiHash(this)); }; }).call(this, this.currentContainer));
  5680. }
  5681. }
  5684. //Post events to containers
  5685. function delayEvent( type, instance, container ) {
  5686. return function( event ) {
  5687. container._trigger( type, event, instance._uiHash( instance ) );
  5688. };
  5689. }
  5690. for (i = this.containers.length - 1; i >= 0; i--){
  5691. if (!noPropagation) {
  5692. delayedTriggers.push( delayEvent( "deactivate", this, this.containers[ i ] ) );
  5693. }
  5694. if(this.containers[i].containerCache.over) {
  5695. delayedTriggers.push( delayEvent( "out", this, this.containers[ i ] ) );
  5696. this.containers[i].containerCache.over = 0;
  5697. }
  5698. }
  5700. //Do what was originally in plugins
  5701. if ( this.storedCursor ) {
  5702. this.document.find( "body" ).css( "cursor", this.storedCursor );
  5703. this.storedStylesheet.remove();
  5704. }
  5705. if(this._storedOpacity) {
  5706. this.helper.css("opacity", this._storedOpacity);
  5707. }
  5708. if(this._storedZIndex) {
  5709. this.helper.css("zIndex", this._storedZIndex === "auto" ? "" : this._storedZIndex);
  5710. }
  5712. this.dragging = false;
  5714. if(!noPropagation) {
  5715. this._trigger("beforeStop", event, this._uiHash());
  5716. }
  5718. //$(this.placeholder[0]).remove(); would have been the jQuery way - unfortunately, it unbinds ALL events from the original node!
  5719. this.placeholder[0].parentNode.removeChild(this.placeholder[0]);
  5721. if ( !this.cancelHelperRemoval ) {
  5722. if ( this.helper[ 0 ] !== this.currentItem[ 0 ] ) {
  5723. this.helper.remove();
  5724. }
  5725. this.helper = null;
  5726. }
  5728. if(!noPropagation) {
  5729. for (i=0; i < delayedTriggers.length; i++) {
  5730. delayedTriggers[i].call(this, event);
  5731. } //Trigger all delayed events
  5732. this._trigger("stop", event, this._uiHash());
  5733. }
  5735. this.fromOutside = false;
  5736. return !this.cancelHelperRemoval;
  5738. },
  5740. _trigger: function() {
  5741. if ($.Widget.prototype._trigger.apply(this, arguments) === false) {
  5742. this.cancel();
  5743. }
  5744. },
  5746. _uiHash: function(_inst) {
  5747. var inst = _inst || this;
  5748. return {
  5749. helper: inst.helper,
  5750. placeholder: inst.placeholder || $([]),
  5751. position: inst.position,
  5752. originalPosition: inst.originalPosition,
  5753. offset: inst.positionAbs,
  5754. item: inst.currentItem,
  5755. sender: _inst ? _inst.element : null
  5756. };
  5757. }
  5759. });
  5762. /*!
  5763. * jQuery UI Accordion 1.11.4
  5764. * http://jqueryui.com
  5765. *
  5766. * Copyright jQuery Foundation and other contributors
  5767. * Released under the MIT license.
  5768. * http://jquery.org/license
  5769. *
  5770. * http://api.jqueryui.com/accordion/
  5771. */
  5774. var accordion = $.widget( "ui.accordion", {
  5775. version: "1.11.4",
  5776. options: {
  5777. active: 0,
  5778. animate: {},
  5779. collapsible: false,
  5780. event: "click",
  5781. header: "> li > :first-child,> :not(li):even",
  5782. heightStyle: "auto",
  5783. icons: {
  5784. activeHeader: "ui-icon-triangle-1-s",
  5785. header: "ui-icon-triangle-1-e"
  5786. },
  5788. // callbacks
  5789. activate: null,
  5790. beforeActivate: null
  5791. },
  5793. hideProps: {
  5794. borderTopWidth: "hide",
  5795. borderBottomWidth: "hide",
  5796. paddingTop: "hide",
  5797. paddingBottom: "hide",
  5798. height: "hide"
  5799. },
  5801. showProps: {
  5802. borderTopWidth: "show",
  5803. borderBottomWidth: "show",
  5804. paddingTop: "show",
  5805. paddingBottom: "show",
  5806. height: "show"
  5807. },
  5809. _create: function() {
  5810. var options = this.options;
  5811. this.prevShow = this.prevHide = $();
  5812. this.element.addClass( "ui-accordion ui-widget ui-helper-reset" )
  5813. // ARIA
  5814. .attr( "role", "tablist" );
  5816. // don't allow collapsible: false and active: false / null
  5817. if ( !options.collapsible && (options.active === false || options.active == null) ) {
  5818. options.active = 0;
  5819. }
  5821. this._processPanels();
  5822. // handle negative values
  5823. if ( options.active < 0 ) {
  5824. options.active += this.headers.length;
  5825. }
  5826. this._refresh();
  5827. },
  5829. _getCreateEventData: function() {
  5830. return {
  5831. header: this.active,
  5832. panel: !this.active.length ? $() : this.active.next()
  5833. };
  5834. },
  5836. _createIcons: function() {
  5837. var icons = this.options.icons;
  5838. if ( icons ) {
  5839. $( "<span>" )
  5840. .addClass( "ui-accordion-header-icon ui-icon " + icons.header )
  5841. .prependTo( this.headers );
  5842. this.active.children( ".ui-accordion-header-icon" )
  5843. .removeClass( icons.header )
  5844. .addClass( icons.activeHeader );
  5845. this.headers.addClass( "ui-accordion-icons" );
  5846. }
  5847. },
  5849. _destroyIcons: function() {
  5850. this.headers
  5851. .removeClass( "ui-accordion-icons" )
  5852. .children( ".ui-accordion-header-icon" )
  5853. .remove();
  5854. },
  5856. _destroy: function() {
  5857. var contents;
  5859. // clean up main element
  5860. this.element
  5861. .removeClass( "ui-accordion ui-widget ui-helper-reset" )
  5862. .removeAttr( "role" );
  5864. // clean up headers
  5865. this.headers
  5866. .removeClass( "ui-accordion-header ui-accordion-header-active ui-state-default " +
  5867. "ui-corner-all ui-state-active ui-state-disabled ui-corner-top" )
  5868. .removeAttr( "role" )
  5869. .removeAttr( "aria-expanded" )
  5870. .removeAttr( "aria-selected" )
  5871. .removeAttr( "aria-controls" )
  5872. .removeAttr( "tabIndex" )
  5873. .removeUniqueId();
  5875. this._destroyIcons();
  5877. // clean up content panels
  5878. contents = this.headers.next()
  5879. .removeClass( "ui-helper-reset ui-widget-content ui-corner-bottom " +
  5880. "ui-accordion-content ui-accordion-content-active ui-state-disabled" )
  5881. .css( "display", "" )
  5882. .removeAttr( "role" )
  5883. .removeAttr( "aria-hidden" )
  5884. .removeAttr( "aria-labelledby" )
  5885. .removeUniqueId();
  5887. if ( this.options.heightStyle !== "content" ) {
  5888. contents.css( "height", "" );
  5889. }
  5890. },
  5892. _setOption: function( key, value ) {
  5893. if ( key === "active" ) {
  5894. // _activate() will handle invalid values and update this.options
  5895. this._activate( value );
  5896. return;
  5897. }
  5899. if ( key === "event" ) {
  5900. if ( this.options.event ) {
  5901. this._off( this.headers, this.options.event );
  5902. }
  5903. this._setupEvents( value );
  5904. }
  5906. this._super( key, value );
  5908. // setting collapsible: false while collapsed; open first panel
  5909. if ( key === "collapsible" && !value && this.options.active === false ) {
  5910. this._activate( 0 );
  5911. }
  5913. if ( key === "icons" ) {
  5914. this._destroyIcons();
  5915. if ( value ) {
  5916. this._createIcons();
  5917. }
  5918. }
  5920. // #5332 - opacity doesn't cascade to positioned elements in IE
  5921. // so we need to add the disabled class to the headers and panels
  5922. if ( key === "disabled" ) {
  5923. this.element
  5924. .toggleClass( "ui-state-disabled", !!value )
  5925. .attr( "aria-disabled", value );
  5926. this.headers.add( this.headers.next() )
  5927. .toggleClass( "ui-state-disabled", !!value );
  5928. }
  5929. },
  5931. _keydown: function( event ) {
  5932. if ( event.altKey || event.ctrlKey ) {
  5933. return;
  5934. }
  5936. var keyCode = $.ui.keyCode,
  5937. length = this.headers.length,
  5938. currentIndex = this.headers.index( event.target ),
  5939. toFocus = false;
  5941. switch ( event.keyCode ) {
  5942. case keyCode.RIGHT:
  5943. case keyCode.DOWN:
  5944. toFocus = this.headers[ ( currentIndex + 1 ) % length ];
  5945. break;
  5946. case keyCode.LEFT:
  5947. case keyCode.UP:
  5948. toFocus = this.headers[ ( currentIndex - 1 + length ) % length ];
  5949. break;
  5950. case keyCode.SPACE:
  5951. case keyCode.ENTER:
  5952. this._eventHandler( event );
  5953. break;
  5954. case keyCode.HOME:
  5955. toFocus = this.headers[ 0 ];
  5956. break;
  5957. case keyCode.END:
  5958. toFocus = this.headers[ length - 1 ];
  5959. break;
  5960. }
  5962. if ( toFocus ) {
  5963. $( event.target ).attr( "tabIndex", -1 );
  5964. $( toFocus ).attr( "tabIndex", 0 );
  5965. toFocus.focus();
  5966. event.preventDefault();
  5967. }
  5968. },
  5970. _panelKeyDown: function( event ) {
  5971. if ( event.keyCode === $.ui.keyCode.UP && event.ctrlKey ) {
  5972. $( event.currentTarget ).prev().focus();
  5973. }
  5974. },
  5976. refresh: function() {
  5977. var options = this.options;
  5978. this._processPanels();
  5980. // was collapsed or no panel
  5981. if ( ( options.active === false && options.collapsible === true ) || !this.headers.length ) {
  5982. options.active = false;
  5983. this.active = $();
  5984. // active false only when collapsible is true
  5985. } else if ( options.active === false ) {
  5986. this._activate( 0 );
  5987. // was active, but active panel is gone
  5988. } else if ( this.active.length && !$.contains( this.element[ 0 ], this.active[ 0 ] ) ) {
  5989. // all remaining panel are disabled
  5990. if ( this.headers.length === this.headers.find(".ui-state-disabled").length ) {
  5991. options.active = false;
  5992. this.active = $();
  5993. // activate previous panel
  5994. } else {
  5995. this._activate( Math.max( 0, options.active - 1 ) );
  5996. }
  5997. // was active, active panel still exists
  5998. } else {
  5999. // make sure active index is correct
  6000. options.active = this.headers.index( this.active );
  6001. }
  6003. this._destroyIcons();
  6005. this._refresh();
  6006. },
  6008. _processPanels: function() {
  6009. var prevHeaders = this.headers,
  6010. prevPanels = this.panels;
  6012. this.headers = this.element.find( this.options.header )
  6013. .addClass( "ui-accordion-header ui-state-default ui-corner-all" );
  6015. this.panels = this.headers.next()
  6016. .addClass( "ui-accordion-content ui-helper-reset ui-widget-content ui-corner-bottom" )
  6017. .filter( ":not(.ui-accordion-content-active)" )
  6018. .hide();
  6020. // Avoid memory leaks (#10056)
  6021. if ( prevPanels ) {
  6022. this._off( prevHeaders.not( this.headers ) );
  6023. this._off( prevPanels.not( this.panels ) );
  6024. }
  6025. },
  6027. _refresh: function() {
  6028. var maxHeight,
  6029. options = this.options,
  6030. heightStyle = options.heightStyle,
  6031. parent = this.element.parent();
  6033. this.active = this._findActive( options.active )
  6034. .addClass( "ui-accordion-header-active ui-state-active ui-corner-top" )
  6035. .removeClass( "ui-corner-all" );
  6036. this.active.next()
  6037. .addClass( "ui-accordion-content-active" )
  6038. .show();
  6040. this.headers
  6041. .attr( "role", "tab" )
  6042. .each(function() {
  6043. var header = $( this ),
  6044. headerId = header.uniqueId().attr( "id" ),
  6045. panel = header.next(),
  6046. panelId = panel.uniqueId().attr( "id" );
  6047. header.attr( "aria-controls", panelId );
  6048. panel.attr( "aria-labelledby", headerId );
  6049. })
  6050. .next()
  6051. .attr( "role", "tabpanel" );
  6053. this.headers
  6054. .not( this.active )
  6055. .attr({
  6056. "aria-selected": "false",
  6057. "aria-expanded": "false",
  6058. tabIndex: -1
  6059. })
  6060. .next()
  6061. .attr({
  6062. "aria-hidden": "true"
  6063. })
  6064. .hide();
  6066. // make sure at least one header is in the tab order
  6067. if ( !this.active.length ) {
  6068. this.headers.eq( 0 ).attr( "tabIndex", 0 );
  6069. } else {
  6070. this.active.attr({
  6071. "aria-selected": "true",
  6072. "aria-expanded": "true",
  6073. tabIndex: 0
  6074. })
  6075. .next()
  6076. .attr({
  6077. "aria-hidden": "false"
  6078. });
  6079. }
  6081. this._createIcons();
  6083. this._setupEvents( options.event );
  6085. if ( heightStyle === "fill" ) {
  6086. maxHeight = parent.height();
  6087. this.element.siblings( ":visible" ).each(function() {
  6088. var elem = $( this ),
  6089. position = elem.css( "position" );
  6091. if ( position === "absolute" || position === "fixed" ) {
  6092. return;
  6093. }
  6094. maxHeight -= elem.outerHeight( true );
  6095. });
  6097. this.headers.each(function() {
  6098. maxHeight -= $( this ).outerHeight( true );
  6099. });
  6101. this.headers.next()
  6102. .each(function() {
  6103. $( this ).height( Math.max( 0, maxHeight -
  6104. $( this ).innerHeight() + $( this ).height() ) );
  6105. })
  6106. .css( "overflow", "auto" );
  6107. } else if ( heightStyle === "none" ) {
  6108. maxHeight = 0;
  6109. this.headers.next()
  6110. .each(function() {
  6111. maxHeight = Math.max( maxHeight, $( this ).css( "height", "" ).height() );
  6112. })
  6113. .height( maxHeight );
  6114. }
  6115. },
  6117. _activate: function( index ) {
  6118. var active = this._findActive( index )[ 0 ];
  6120. // trying to activate the already active panel
  6121. if ( active === this.active[ 0 ] ) {
  6122. return;
  6123. }
  6125. // trying to collapse, simulate a click on the currently active header
  6126. active = active || this.active[ 0 ];
  6128. this._eventHandler({
  6129. target: active,
  6130. currentTarget: active,
  6131. preventDefault: $.noop
  6132. });
  6133. },
  6135. _findActive: function( selector ) {
  6136. return typeof selector === "number" ? this.headers.eq( selector ) : $();
  6137. },
  6139. _setupEvents: function( event ) {
  6140. var events = {
  6141. keydown: "_keydown"
  6142. };
  6143. if ( event ) {
  6144. $.each( event.split( " " ), function( index, eventName ) {
  6145. events[ eventName ] = "_eventHandler";
  6146. });
  6147. }
  6149. this._off( this.headers.add( this.headers.next() ) );
  6150. this._on( this.headers, events );
  6151. this._on( this.headers.next(), { keydown: "_panelKeyDown" });
  6152. this._hoverable( this.headers );
  6153. this._focusable( this.headers );
  6154. },
  6156. _eventHandler: function( event ) {
  6157. var options = this.options,
  6158. active = this.active,
  6159. clicked = $( event.currentTarget ),
  6160. clickedIsActive = clicked[ 0 ] === active[ 0 ],
  6161. collapsing = clickedIsActive && options.collapsible,
  6162. toShow = collapsing ? $() : clicked.next(),
  6163. toHide = active.next(),
  6164. eventData = {
  6165. oldHeader: active,
  6166. oldPanel: toHide,
  6167. newHeader: collapsing ? $() : clicked,
  6168. newPanel: toShow
  6169. };
  6171. event.preventDefault();
  6173. if (
  6174. // click on active header, but not collapsible
  6175. ( clickedIsActive && !options.collapsible ) ||
  6176. // allow canceling activation
  6177. ( this._trigger( "beforeActivate", event, eventData ) === false ) ) {
  6178. return;
  6179. }
  6181. options.active = collapsing ? false : this.headers.index( clicked );
  6183. // when the call to ._toggle() comes after the class changes
  6184. // it causes a very odd bug in IE 8 (see #6720)
  6185. this.active = clickedIsActive ? $() : clicked;
  6186. this._toggle( eventData );
  6188. // switch classes
  6189. // corner classes on the previously active header stay after the animation
  6190. active.removeClass( "ui-accordion-header-active ui-state-active" );
  6191. if ( options.icons ) {
  6192. active.children( ".ui-accordion-header-icon" )
  6193. .removeClass( options.icons.activeHeader )
  6194. .addClass( options.icons.header );
  6195. }
  6197. if ( !clickedIsActive ) {
  6198. clicked
  6199. .removeClass( "ui-corner-all" )
  6200. .addClass( "ui-accordion-header-active ui-state-active ui-corner-top" );
  6201. if ( options.icons ) {
  6202. clicked.children( ".ui-accordion-header-icon" )
  6203. .removeClass( options.icons.header )
  6204. .addClass( options.icons.activeHeader );
  6205. }
  6207. clicked
  6208. .next()
  6209. .addClass( "ui-accordion-content-active" );
  6210. }
  6211. },
  6213. _toggle: function( data ) {
  6214. var toShow = data.newPanel,
  6215. toHide = this.prevShow.length ? this.prevShow : data.oldPanel;
  6217. // handle activating a panel during the animation for another activation
  6218. this.prevShow.add( this.prevHide ).stop( true, true );
  6219. this.prevShow = toShow;
  6220. this.prevHide = toHide;
  6222. if ( this.options.animate ) {
  6223. this._animate( toShow, toHide, data );
  6224. } else {
  6225. toHide.hide();
  6226. toShow.show();
  6227. this._toggleComplete( data );
  6228. }
  6230. toHide.attr({
  6231. "aria-hidden": "true"
  6232. });
  6233. toHide.prev().attr({
  6234. "aria-selected": "false",
  6235. "aria-expanded": "false"
  6236. });
  6237. // if we're switching panels, remove the old header from the tab order
  6238. // if we're opening from collapsed state, remove the previous header from the tab order
  6239. // if we're collapsing, then keep the collapsing header in the tab order
  6240. if ( toShow.length && toHide.length ) {
  6241. toHide.prev().attr({
  6242. "tabIndex": -1,
  6243. "aria-expanded": "false"
  6244. });
  6245. } else if ( toShow.length ) {
  6246. this.headers.filter(function() {
  6247. return parseInt( $( this ).attr( "tabIndex" ), 10 ) === 0;
  6248. })
  6249. .attr( "tabIndex", -1 );
  6250. }
  6252. toShow
  6253. .attr( "aria-hidden", "false" )
  6254. .prev()
  6255. .attr({
  6256. "aria-selected": "true",
  6257. "aria-expanded": "true",
  6258. tabIndex: 0
  6259. });
  6260. },
  6262. _animate: function( toShow, toHide, data ) {
  6263. var total, easing, duration,
  6264. that = this,
  6265. adjust = 0,
  6266. boxSizing = toShow.css( "box-sizing" ),
  6267. down = toShow.length &&
  6268. ( !toHide.length || ( toShow.index() < toHide.index() ) ),
  6269. animate = this.options.animate || {},
  6270. options = down && animate.down || animate,
  6271. complete = function() {
  6272. that._toggleComplete( data );
  6273. };
  6275. if ( typeof options === "number" ) {
  6276. duration = options;
  6277. }
  6278. if ( typeof options === "string" ) {
  6279. easing = options;
  6280. }
  6281. // fall back from options to animation in case of partial down settings
  6282. easing = easing || options.easing || animate.easing;
  6283. duration = duration || options.duration || animate.duration;
  6285. if ( !toHide.length ) {
  6286. return toShow.animate( this.showProps, duration, easing, complete );
  6287. }
  6288. if ( !toShow.length ) {
  6289. return toHide.animate( this.hideProps, duration, easing, complete );
  6290. }
  6292. total = toShow.show().outerHeight();
  6293. toHide.animate( this.hideProps, {
  6294. duration: duration,
  6295. easing: easing,
  6296. step: function( now, fx ) {
  6297. fx.now = Math.round( now );
  6298. }
  6299. });
  6300. toShow
  6301. .hide()
  6302. .animate( this.showProps, {
  6303. duration: duration,
  6304. easing: easing,
  6305. complete: complete,
  6306. step: function( now, fx ) {
  6307. fx.now = Math.round( now );
  6308. if ( fx.prop !== "height" ) {
  6309. if ( boxSizing === "content-box" ) {
  6310. adjust += fx.now;
  6311. }
  6312. } else if ( that.options.heightStyle !== "content" ) {
  6313. fx.now = Math.round( total - toHide.outerHeight() - adjust );
  6314. adjust = 0;
  6315. }
  6316. }
  6317. });
  6318. },
  6320. _toggleComplete: function( data ) {
  6321. var toHide = data.oldPanel;
  6323. toHide
  6324. .removeClass( "ui-accordion-content-active" )
  6325. .prev()
  6326. .removeClass( "ui-corner-top" )
  6327. .addClass( "ui-corner-all" );
  6329. // Work around for rendering bug in IE (#5421)
  6330. if ( toHide.length ) {
  6331. toHide.parent()[ 0 ].className = toHide.parent()[ 0 ].className;
  6332. }
  6333. this._trigger( "activate", null, data );
  6334. }
  6335. });
  6338. /*!
  6339. * jQuery UI Menu 1.11.4
  6340. * http://jqueryui.com
  6341. *
  6342. * Copyright jQuery Foundation and other contributors
  6343. * Released under the MIT license.
  6344. * http://jquery.org/license
  6345. *
  6346. * http://api.jqueryui.com/menu/
  6347. */
  6350. var menu = $.widget( "ui.menu", {
  6351. version: "1.11.4",
  6352. defaultElement: "<ul>",
  6353. delay: 300,
  6354. options: {
  6355. icons: {
  6356. submenu: "ui-icon-carat-1-e"
  6357. },
  6358. items: "> *",
  6359. menus: "ul",
  6360. position: {
  6361. my: "left-1 top",
  6362. at: "right top"
  6363. },
  6364. role: "menu",
  6366. // callbacks
  6367. blur: null,
  6368. focus: null,
  6369. select: null
  6370. },
  6372. _create: function() {
  6373. this.activeMenu = this.element;
  6375. // Flag used to prevent firing of the click handler
  6376. // as the event bubbles up through nested menus
  6377. this.mouseHandled = false;
  6378. this.element
  6379. .uniqueId()
  6380. .addClass( "ui-menu ui-widget ui-widget-content" )
  6381. .toggleClass( "ui-menu-icons", !!this.element.find( ".ui-icon" ).length )
  6382. .attr({
  6383. role: this.options.role,
  6384. tabIndex: 0
  6385. });
  6387. if ( this.options.disabled ) {
  6388. this.element
  6389. .addClass( "ui-state-disabled" )
  6390. .attr( "aria-disabled", "true" );
  6391. }
  6393. this._on({
  6394. // Prevent focus from sticking to links inside menu after clicking
  6395. // them (focus should always stay on UL during navigation).
  6396. "mousedown .ui-menu-item": function( event ) {
  6397. event.preventDefault();
  6398. },
  6399. "click .ui-menu-item": function( event ) {
  6400. var target = $( event.target );
  6401. if ( !this.mouseHandled && target.not( ".ui-state-disabled" ).length ) {
  6402. this.select( event );
  6404. // Only set the mouseHandled flag if the event will bubble, see #9469.
  6405. if ( !event.isPropagationStopped() ) {
  6406. this.mouseHandled = true;
  6407. }
  6409. // Open submenu on click
  6410. if ( target.has( ".ui-menu" ).length ) {
  6411. this.expand( event );
  6412. } else if ( !this.element.is( ":focus" ) && $( this.document[ 0 ].activeElement ).closest( ".ui-menu" ).length ) {
  6414. // Redirect focus to the menu
  6415. this.element.trigger( "focus", [ true ] );
  6417. // If the active item is on the top level, let it stay active.
  6418. // Otherwise, blur the active item since it is no longer visible.
  6419. if ( this.active && this.active.parents( ".ui-menu" ).length === 1 ) {
  6420. clearTimeout( this.timer );
  6421. }
  6422. }
  6423. }
  6424. },
  6425. "mouseenter .ui-menu-item": function( event ) {
  6426. // Ignore mouse events while typeahead is active, see #10458.
  6427. // Prevents focusing the wrong item when typeahead causes a scroll while the mouse
  6428. // is over an item in the menu
  6429. if ( this.previousFilter ) {
  6430. return;
  6431. }
  6432. var target = $( event.currentTarget );
  6433. // Remove ui-state-active class from siblings of the newly focused menu item
  6434. // to avoid a jump caused by adjacent elements both having a class with a border
  6435. target.siblings( ".ui-state-active" ).removeClass( "ui-state-active" );
  6436. this.focus( event, target );
  6437. },
  6438. mouseleave: "collapseAll",
  6439. "mouseleave .ui-menu": "collapseAll",
  6440. focus: function( event, keepActiveItem ) {
  6441. // If there's already an active item, keep it active
  6442. // If not, activate the first item
  6443. var item = this.active || this.element.find( this.options.items ).eq( 0 );
  6445. if ( !keepActiveItem ) {
  6446. this.focus( event, item );
  6447. }
  6448. },
  6449. blur: function( event ) {
  6450. this._delay(function() {
  6451. if ( !$.contains( this.element[0], this.document[0].activeElement ) ) {
  6452. this.collapseAll( event );
  6453. }
  6454. });
  6455. },
  6456. keydown: "_keydown"
  6457. });
  6459. this.refresh();
  6461. // Clicks outside of a menu collapse any open menus
  6462. this._on( this.document, {
  6463. click: function( event ) {
  6464. if ( this._closeOnDocumentClick( event ) ) {
  6465. this.collapseAll( event );
  6466. }
  6468. // Reset the mouseHandled flag
  6469. this.mouseHandled = false;
  6470. }
  6471. });
  6472. },
  6474. _destroy: function() {
  6475. // Destroy (sub)menus
  6476. this.element
  6477. .removeAttr( "aria-activedescendant" )
  6478. .find( ".ui-menu" ).addBack()
  6479. .removeClass( "ui-menu ui-widget ui-widget-content ui-menu-icons ui-front" )
  6480. .removeAttr( "role" )
  6481. .removeAttr( "tabIndex" )
  6482. .removeAttr( "aria-labelledby" )
  6483. .removeAttr( "aria-expanded" )
  6484. .removeAttr( "aria-hidden" )
  6485. .removeAttr( "aria-disabled" )
  6486. .removeUniqueId()
  6487. .show();
  6489. // Destroy menu items
  6490. this.element.find( ".ui-menu-item" )
  6491. .removeClass( "ui-menu-item" )
  6492. .removeAttr( "role" )
  6493. .removeAttr( "aria-disabled" )
  6494. .removeUniqueId()
  6495. .removeClass( "ui-state-hover" )
  6496. .removeAttr( "tabIndex" )
  6497. .removeAttr( "role" )
  6498. .removeAttr( "aria-haspopup" )
  6499. .children().each( function() {
  6500. var elem = $( this );
  6501. if ( elem.data( "ui-menu-submenu-carat" ) ) {
  6502. elem.remove();
  6503. }
  6504. });
  6506. // Destroy menu dividers
  6507. this.element.find( ".ui-menu-divider" ).removeClass( "ui-menu-divider ui-widget-content" );
  6508. },
  6510. _keydown: function( event ) {
  6511. var match, prev, character, skip,
  6512. preventDefault = true;
  6514. switch ( event.keyCode ) {
  6515. case $.ui.keyCode.PAGE_UP:
  6516. this.previousPage( event );
  6517. break;
  6518. case $.ui.keyCode.PAGE_DOWN:
  6519. this.nextPage( event );
  6520. break;
  6521. case $.ui.keyCode.HOME:
  6522. this._move( "first", "first", event );
  6523. break;
  6524. case $.ui.keyCode.END:
  6525. this._move( "last", "last", event );
  6526. break;
  6527. case $.ui.keyCode.UP:
  6528. this.previous( event );
  6529. break;
  6530. case $.ui.keyCode.DOWN:
  6531. this.next( event );
  6532. break;
  6533. case $.ui.keyCode.LEFT:
  6534. this.collapse( event );
  6535. break;
  6536. case $.ui.keyCode.RIGHT:
  6537. if ( this.active && !this.active.is( ".ui-state-disabled" ) ) {
  6538. this.expand( event );
  6539. }
  6540. break;
  6541. case $.ui.keyCode.ENTER:
  6542. case $.ui.keyCode.SPACE:
  6543. this._activate( event );
  6544. break;
  6545. case $.ui.keyCode.ESCAPE:
  6546. this.collapse( event );
  6547. break;
  6548. default:
  6549. preventDefault = false;
  6550. prev = this.previousFilter || "";
  6551. character = String.fromCharCode( event.keyCode );
  6552. skip = false;
  6554. clearTimeout( this.filterTimer );
  6556. if ( character === prev ) {
  6557. skip = true;
  6558. } else {
  6559. character = prev + character;
  6560. }
  6562. match = this._filterMenuItems( character );
  6563. match = skip && match.index( this.active.next() ) !== -1 ?
  6564. this.active.nextAll( ".ui-menu-item" ) :
  6565. match;
  6567. // If no matches on the current filter, reset to the last character pressed
  6568. // to move down the menu to the first item that starts with that character
  6569. if ( !match.length ) {
  6570. character = String.fromCharCode( event.keyCode );
  6571. match = this._filterMenuItems( character );
  6572. }
  6574. if ( match.length ) {
  6575. this.focus( event, match );
  6576. this.previousFilter = character;
  6577. this.filterTimer = this._delay(function() {
  6578. delete this.previousFilter;
  6579. }, 1000 );
  6580. } else {
  6581. delete this.previousFilter;
  6582. }
  6583. }
  6585. if ( preventDefault ) {
  6586. event.preventDefault();
  6587. }
  6588. },
  6590. _activate: function( event ) {
  6591. if ( !this.active.is( ".ui-state-disabled" ) ) {
  6592. if ( this.active.is( "[aria-haspopup='true']" ) ) {
  6593. this.expand( event );
  6594. } else {
  6595. this.select( event );
  6596. }
  6597. }
  6598. },
  6600. refresh: function() {
  6601. var menus, items,
  6602. that = this,
  6603. icon = this.options.icons.submenu,
  6604. submenus = this.element.find( this.options.menus );
  6606. this.element.toggleClass( "ui-menu-icons", !!this.element.find( ".ui-icon" ).length );
  6608. // Initialize nested menus
  6609. submenus.filter( ":not(.ui-menu)" )
  6610. .addClass( "ui-menu ui-widget ui-widget-content ui-front" )
  6611. .hide()
  6612. .attr({
  6613. role: this.options.role,
  6614. "aria-hidden": "true",
  6615. "aria-expanded": "false"
  6616. })
  6617. .each(function() {
  6618. var menu = $( this ),
  6619. item = menu.parent(),
  6620. submenuCarat = $( "<span>" )
  6621. .addClass( "ui-menu-icon ui-icon " + icon )
  6622. .data( "ui-menu-submenu-carat", true );
  6624. item
  6625. .attr( "aria-haspopup", "true" )
  6626. .prepend( submenuCarat );
  6627. menu.attr( "aria-labelledby", item.attr( "id" ) );
  6628. });
  6630. menus = submenus.add( this.element );
  6631. items = menus.find( this.options.items );
  6633. // Initialize menu-items containing spaces and/or dashes only as dividers
  6634. items.not( ".ui-menu-item" ).each(function() {
  6635. var item = $( this );
  6636. if ( that._isDivider( item ) ) {
  6637. item.addClass( "ui-widget-content ui-menu-divider" );
  6638. }
  6639. });
  6641. // Don't refresh list items that are already adapted
  6642. items.not( ".ui-menu-item, .ui-menu-divider" )
  6643. .addClass( "ui-menu-item" )
  6644. .uniqueId()
  6645. .attr({
  6646. tabIndex: -1,
  6647. role: this._itemRole()
  6648. });
  6650. // Add aria-disabled attribute to any disabled menu item
  6651. items.filter( ".ui-state-disabled" ).attr( "aria-disabled", "true" );
  6653. // If the active item has been removed, blur the menu
  6654. if ( this.active && !$.contains( this.element[ 0 ], this.active[ 0 ] ) ) {
  6655. this.blur();
  6656. }
  6657. },
  6659. _itemRole: function() {
  6660. return {
  6661. menu: "menuitem",
  6662. listbox: "option"
  6663. }[ this.options.role ];
  6664. },
  6666. _setOption: function( key, value ) {
  6667. if ( key === "icons" ) {
  6668. this.element.find( ".ui-menu-icon" )
  6669. .removeClass( this.options.icons.submenu )
  6670. .addClass( value.submenu );
  6671. }
  6672. if ( key === "disabled" ) {
  6673. this.element
  6674. .toggleClass( "ui-state-disabled", !!value )
  6675. .attr( "aria-disabled", value );
  6676. }
  6677. this._super( key, value );
  6678. },
  6680. focus: function( event, item ) {
  6681. var nested, focused;
  6682. this.blur( event, event && event.type === "focus" );
  6684. this._scrollIntoView( item );
  6686. this.active = item.first();
  6687. focused = this.active.addClass( "ui-state-focus" ).removeClass( "ui-state-active" );
  6688. // Only update aria-activedescendant if there's a role
  6689. // otherwise we assume focus is managed elsewhere
  6690. if ( this.options.role ) {
  6691. this.element.attr( "aria-activedescendant", focused.attr( "id" ) );
  6692. }
  6694. // Highlight active parent menu item, if any
  6695. this.active
  6696. .parent()
  6697. .closest( ".ui-menu-item" )
  6698. .addClass( "ui-state-active" );
  6700. if ( event && event.type === "keydown" ) {
  6701. this._close();
  6702. } else {
  6703. this.timer = this._delay(function() {
  6704. this._close();
  6705. }, this.delay );
  6706. }
  6708. nested = item.children( ".ui-menu" );
  6709. if ( nested.length && event && ( /^mouse/.test( event.type ) ) ) {
  6710. this._startOpening(nested);
  6711. }
  6712. this.activeMenu = item.parent();
  6714. this._trigger( "focus", event, { item: item } );
  6715. },
  6717. _scrollIntoView: function( item ) {
  6718. var borderTop, paddingTop, offset, scroll, elementHeight, itemHeight;
  6719. if ( this._hasScroll() ) {
  6720. borderTop = parseFloat( $.css( this.activeMenu[0], "borderTopWidth" ) ) || 0;
  6721. paddingTop = parseFloat( $.css( this.activeMenu[0], "paddingTop" ) ) || 0;
  6722. offset = item.offset().top - this.activeMenu.offset().top - borderTop - paddingTop;
  6723. scroll = this.activeMenu.scrollTop();
  6724. elementHeight = this.activeMenu.height();
  6725. itemHeight = item.outerHeight();
  6727. if ( offset < 0 ) {
  6728. this.activeMenu.scrollTop( scroll + offset );
  6729. } else if ( offset + itemHeight > elementHeight ) {
  6730. this.activeMenu.scrollTop( scroll + offset - elementHeight + itemHeight );
  6731. }
  6732. }
  6733. },
  6735. blur: function( event, fromFocus ) {
  6736. if ( !fromFocus ) {
  6737. clearTimeout( this.timer );
  6738. }
  6740. if ( !this.active ) {
  6741. return;
  6742. }
  6744. this.active.removeClass( "ui-state-focus" );
  6745. this.active = null;
  6747. this._trigger( "blur", event, { item: this.active } );
  6748. },
  6750. _startOpening: function( submenu ) {
  6751. clearTimeout( this.timer );
  6753. // Don't open if already open fixes a Firefox bug that caused a .5 pixel
  6754. // shift in the submenu position when mousing over the carat icon
  6755. if ( submenu.attr( "aria-hidden" ) !== "true" ) {
  6756. return;
  6757. }
  6759. this.timer = this._delay(function() {
  6760. this._close();
  6761. this._open( submenu );
  6762. }, this.delay );
  6763. },
  6765. _open: function( submenu ) {
  6766. var position = $.extend({
  6767. of: this.active
  6768. }, this.options.position );
  6770. clearTimeout( this.timer );
  6771. this.element.find( ".ui-menu" ).not( submenu.parents( ".ui-menu" ) )
  6772. .hide()
  6773. .attr( "aria-hidden", "true" );
  6775. submenu
  6776. .show()
  6777. .removeAttr( "aria-hidden" )
  6778. .attr( "aria-expanded", "true" )
  6779. .position( position );
  6780. },
  6782. collapseAll: function( event, all ) {
  6783. clearTimeout( this.timer );
  6784. this.timer = this._delay(function() {
  6785. // If we were passed an event, look for the submenu that contains the event
  6786. var currentMenu = all ? this.element :
  6787. $( event && event.target ).closest( this.element.find( ".ui-menu" ) );
  6789. // If we found no valid submenu ancestor, use the main menu to close all sub menus anyway
  6790. if ( !currentMenu.length ) {
  6791. currentMenu = this.element;
  6792. }
  6794. this._close( currentMenu );
  6796. this.blur( event );
  6797. this.activeMenu = currentMenu;
  6798. }, this.delay );
  6799. },
  6801. // With no arguments, closes the currently active menu - if nothing is active
  6802. // it closes all menus. If passed an argument, it will search for menus BELOW
  6803. _close: function( startMenu ) {
  6804. if ( !startMenu ) {
  6805. startMenu = this.active ? this.active.parent() : this.element;
  6806. }
  6808. startMenu
  6809. .find( ".ui-menu" )
  6810. .hide()
  6811. .attr( "aria-hidden", "true" )
  6812. .attr( "aria-expanded", "false" )
  6813. .end()
  6814. .find( ".ui-state-active" ).not( ".ui-state-focus" )
  6815. .removeClass( "ui-state-active" );
  6816. },
  6818. _closeOnDocumentClick: function( event ) {
  6819. return !$( event.target ).closest( ".ui-menu" ).length;
  6820. },
  6822. _isDivider: function( item ) {
  6824. // Match hyphen, em dash, en dash
  6825. return !/[^\-\u2014\u2013\s]/.test( item.text() );
  6826. },
  6828. collapse: function( event ) {
  6829. var newItem = this.active &&
  6830. this.active.parent().closest( ".ui-menu-item", this.element );
  6831. if ( newItem && newItem.length ) {
  6832. this._close();
  6833. this.focus( event, newItem );
  6834. }
  6835. },
  6837. expand: function( event ) {
  6838. var newItem = this.active &&
  6839. this.active
  6840. .children( ".ui-menu " )
  6841. .find( this.options.items )
  6842. .first();
  6844. if ( newItem && newItem.length ) {
  6845. this._open( newItem.parent() );
  6847. // Delay so Firefox will not hide activedescendant change in expanding submenu from AT
  6848. this._delay(function() {
  6849. this.focus( event, newItem );
  6850. });
  6851. }
  6852. },
  6854. next: function( event ) {
  6855. this._move( "next", "first", event );
  6856. },
  6858. previous: function( event ) {
  6859. this._move( "prev", "last", event );
  6860. },
  6862. isFirstItem: function() {
  6863. return this.active && !this.active.prevAll( ".ui-menu-item" ).length;
  6864. },
  6866. isLastItem: function() {
  6867. return this.active && !this.active.nextAll( ".ui-menu-item" ).length;
  6868. },
  6870. _move: function( direction, filter, event ) {
  6871. var next;
  6872. if ( this.active ) {
  6873. if ( direction === "first" || direction === "last" ) {
  6874. next = this.active
  6875. [ direction === "first" ? "prevAll" : "nextAll" ]( ".ui-menu-item" )
  6876. .eq( -1 );
  6877. } else {
  6878. next = this.active
  6879. [ direction + "All" ]( ".ui-menu-item" )
  6880. .eq( 0 );
  6881. }
  6882. }
  6883. if ( !next || !next.length || !this.active ) {
  6884. next = this.activeMenu.find( this.options.items )[ filter ]();
  6885. }
  6887. this.focus( event, next );
  6888. },
  6890. nextPage: function( event ) {
  6891. var item, base, height;
  6893. if ( !this.active ) {
  6894. this.next( event );
  6895. return;
  6896. }
  6897. if ( this.isLastItem() ) {
  6898. return;
  6899. }
  6900. if ( this._hasScroll() ) {
  6901. base = this.active.offset().top;
  6902. height = this.element.height();
  6903. this.active.nextAll( ".ui-menu-item" ).each(function() {
  6904. item = $( this );
  6905. return item.offset().top - base - height < 0;
  6906. });
  6908. this.focus( event, item );
  6909. } else {
  6910. this.focus( event, this.activeMenu.find( this.options.items )
  6911. [ !this.active ? "first" : "last" ]() );
  6912. }
  6913. },
  6915. previousPage: function( event ) {
  6916. var item, base, height;
  6917. if ( !this.active ) {
  6918. this.next( event );
  6919. return;
  6920. }
  6921. if ( this.isFirstItem() ) {
  6922. return;
  6923. }
  6924. if ( this._hasScroll() ) {
  6925. base = this.active.offset().top;
  6926. height = this.element.height();
  6927. this.active.prevAll( ".ui-menu-item" ).each(function() {
  6928. item = $( this );
  6929. return item.offset().top - base + height > 0;
  6930. });
  6932. this.focus( event, item );
  6933. } else {
  6934. this.focus( event, this.activeMenu.find( this.options.items ).first() );
  6935. }
  6936. },
  6938. _hasScroll: function() {
  6939. return this.element.outerHeight() < this.element.prop( "scrollHeight" );
  6940. },
  6942. select: function( event ) {
  6943. // TODO: It should never be possible to not have an active item at this
  6944. // point, but the tests don't trigger mouseenter before click.
  6945. this.active = this.active || $( event.target ).closest( ".ui-menu-item" );
  6946. var ui = { item: this.active };
  6947. if ( !this.active.has( ".ui-menu" ).length ) {
  6948. this.collapseAll( event, true );
  6949. }
  6950. this._trigger( "select", event, ui );
  6951. },
  6953. _filterMenuItems: function(character) {
  6954. var escapedCharacter = character.replace( /[\-\[\]{}()*+?.,\\\^$|#\s]/g, "\\$&" ),
  6955. regex = new RegExp( "^" + escapedCharacter, "i" );
  6957. return this.activeMenu
  6958. .find( this.options.items )
  6960. // Only match on items, not dividers or other content (#10571)
  6961. .filter( ".ui-menu-item" )
  6962. .filter(function() {
  6963. return regex.test( $.trim( $( this ).text() ) );
  6964. });
  6965. }
  6966. });
  6969. /*!
  6970. * jQuery UI Autocomplete 1.11.4
  6971. * http://jqueryui.com
  6972. *
  6973. * Copyright jQuery Foundation and other contributors
  6974. * Released under the MIT license.
  6975. * http://jquery.org/license
  6976. *
  6977. * http://api.jqueryui.com/autocomplete/
  6978. */
  6981. $.widget( "ui.autocomplete", {
  6982. version: "1.11.4",
  6983. defaultElement: "<input>",
  6984. options: {
  6985. appendTo: null,
  6986. autoFocus: false,
  6987. delay: 300,
  6988. minLength: 1,
  6989. position: {
  6990. my: "left top",
  6991. at: "left bottom",
  6992. collision: "none"
  6993. },
  6994. source: null,
  6996. // callbacks
  6997. change: null,
  6998. close: null,
  6999. focus: null,
  7000. open: null,
  7001. response: null,
  7002. search: null,
  7003. select: null
  7004. },
  7006. requestIndex: 0,
  7007. pending: 0,
  7009. _create: function() {
  7010. // Some browsers only repeat keydown events, not keypress events,
  7011. // so we use the suppressKeyPress flag to determine if we've already
  7012. // handled the keydown event. #7269
  7013. // Unfortunately the code for & in keypress is the same as the up arrow,
  7014. // so we use the suppressKeyPressRepeat flag to avoid handling keypress
  7015. // events when we know the keydown event was used to modify the
  7016. // search term. #7799
  7017. var suppressKeyPress, suppressKeyPressRepeat, suppressInput,
  7018. nodeName = this.element[ 0 ].nodeName.toLowerCase(),
  7019. isTextarea = nodeName === "textarea",
  7020. isInput = nodeName === "input";
  7022. this.isMultiLine =
  7023. // Textareas are always multi-line
  7024. isTextarea ? true :
  7025. // Inputs are always single-line, even if inside a contentEditable element
  7026. // IE also treats inputs as contentEditable
  7027. isInput ? false :
  7028. // All other element types are determined by whether or not they're contentEditable
  7029. this.element.prop( "isContentEditable" );
  7031. this.valueMethod = this.element[ isTextarea || isInput ? "val" : "text" ];
  7032. this.isNewMenu = true;
  7034. this.element
  7035. .addClass( "ui-autocomplete-input" )
  7036. .attr( "autocomplete", "off" );
  7038. this._on( this.element, {
  7039. keydown: function( event ) {
  7040. if ( this.element.prop( "readOnly" ) ) {
  7041. suppressKeyPress = true;
  7042. suppressInput = true;
  7043. suppressKeyPressRepeat = true;
  7044. return;
  7045. }
  7047. suppressKeyPress = false;
  7048. suppressInput = false;
  7049. suppressKeyPressRepeat = false;
  7050. var keyCode = $.ui.keyCode;
  7051. switch ( event.keyCode ) {
  7052. case keyCode.PAGE_UP:
  7053. suppressKeyPress = true;
  7054. this._move( "previousPage", event );
  7055. break;
  7056. case keyCode.PAGE_DOWN:
  7057. suppressKeyPress = true;
  7058. this._move( "nextPage", event );
  7059. break;
  7060. case keyCode.UP:
  7061. suppressKeyPress = true;
  7062. this._keyEvent( "previous", event );
  7063. break;
  7064. case keyCode.DOWN:
  7065. suppressKeyPress = true;
  7066. this._keyEvent( "next", event );
  7067. break;
  7068. case keyCode.ENTER:
  7069. // when menu is open and has focus
  7070. if ( this.menu.active ) {
  7071. // #6055 - Opera still allows the keypress to occur
  7072. // which causes forms to submit
  7073. suppressKeyPress = true;
  7074. event.preventDefault();
  7075. this.menu.select( event );
  7076. }
  7077. break;
  7078. case keyCode.TAB:
  7079. if ( this.menu.active ) {
  7080. this.menu.select( event );
  7081. }
  7082. break;
  7083. case keyCode.ESCAPE:
  7084. if ( this.menu.element.is( ":visible" ) ) {
  7085. if ( !this.isMultiLine ) {
  7086. this._value( this.term );
  7087. }
  7088. this.close( event );
  7089. // Different browsers have different default behavior for escape
  7090. // Single press can mean undo or clear
  7091. // Double press in IE means clear the whole form
  7092. event.preventDefault();
  7093. }
  7094. break;
  7095. default:
  7096. suppressKeyPressRepeat = true;
  7097. // search timeout should be triggered before the input value is changed
  7098. this._searchTimeout( event );
  7099. break;
  7100. }
  7101. },
  7102. keypress: function( event ) {
  7103. if ( suppressKeyPress ) {
  7104. suppressKeyPress = false;
  7105. if ( !this.isMultiLine || this.menu.element.is( ":visible" ) ) {
  7106. event.preventDefault();
  7107. }
  7108. return;
  7109. }
  7110. if ( suppressKeyPressRepeat ) {
  7111. return;
  7112. }
  7114. // replicate some key handlers to allow them to repeat in Firefox and Opera
  7115. var keyCode = $.ui.keyCode;
  7116. switch ( event.keyCode ) {
  7117. case keyCode.PAGE_UP:
  7118. this._move( "previousPage", event );
  7119. break;
  7120. case keyCode.PAGE_DOWN:
  7121. this._move( "nextPage", event );
  7122. break;
  7123. case keyCode.UP:
  7124. this._keyEvent( "previous", event );
  7125. break;
  7126. case keyCode.DOWN:
  7127. this._keyEvent( "next", event );
  7128. break;
  7129. }
  7130. },
  7131. input: function( event ) {
  7132. if ( suppressInput ) {
  7133. suppressInput = false;
  7134. event.preventDefault();
  7135. return;
  7136. }
  7137. this._searchTimeout( event );
  7138. },
  7139. focus: function() {
  7140. this.selectedItem = null;
  7141. this.previous = this._value();
  7142. },
  7143. blur: function( event ) {
  7144. if ( this.cancelBlur ) {
  7145. delete this.cancelBlur;
  7146. return;
  7147. }
  7149. clearTimeout( this.searching );
  7150. this.close( event );
  7151. this._change( event );
  7152. }
  7153. });
  7155. this._initSource();
  7156. this.menu = $( "<ul>" )
  7157. .addClass( "ui-autocomplete ui-front" )
  7158. .appendTo( this._appendTo() )
  7159. .menu({
  7160. // disable ARIA support, the live region takes care of that
  7161. role: null
  7162. })
  7163. .hide()
  7164. .menu( "instance" );
  7166. this._on( this.menu.element, {
  7167. mousedown: function( event ) {
  7168. // prevent moving focus out of the text field
  7169. event.preventDefault();
  7171. // IE doesn't prevent moving focus even with event.preventDefault()
  7172. // so we set a flag to know when we should ignore the blur event
  7173. this.cancelBlur = true;
  7174. this._delay(function() {
  7175. delete this.cancelBlur;
  7176. });
  7178. // clicking on the scrollbar causes focus to shift to the body
  7179. // but we can't detect a mouseup or a click immediately afterward
  7180. // so we have to track the next mousedown and close the menu if
  7181. // the user clicks somewhere outside of the autocomplete
  7182. var menuElement = this.menu.element[ 0 ];
  7183. if ( !$( event.target ).closest( ".ui-menu-item" ).length ) {
  7184. this._delay(function() {
  7185. var that = this;
  7186. this.document.one( "mousedown", function( event ) {
  7187. if ( event.target !== that.element[ 0 ] &&
  7188. event.target !== menuElement &&
  7189. !$.contains( menuElement, event.target ) ) {
  7190. that.close();
  7191. }
  7192. });
  7193. });
  7194. }
  7195. },
  7196. menufocus: function( event, ui ) {
  7197. var label, item;
  7198. // support: Firefox
  7199. // Prevent accidental activation of menu items in Firefox (#7024 #9118)
  7200. if ( this.isNewMenu ) {
  7201. this.isNewMenu = false;
  7202. if ( event.originalEvent && /^mouse/.test( event.originalEvent.type ) ) {
  7203. this.menu.blur();
  7205. this.document.one( "mousemove", function() {
  7206. $( event.target ).trigger( event.originalEvent );
  7207. });
  7209. return;
  7210. }
  7211. }
  7213. item = ui.item.data( "ui-autocomplete-item" );
  7214. if ( false !== this._trigger( "focus", event, { item: item } ) ) {
  7215. // use value to match what will end up in the input, if it was a key event
  7216. if ( event.originalEvent && /^key/.test( event.originalEvent.type ) ) {
  7217. this._value( item.value );
  7218. }
  7219. }
  7221. // Announce the value in the liveRegion
  7222. label = ui.item.attr( "aria-label" ) || item.value;
  7223. if ( label && $.trim( label ).length ) {
  7224. this.liveRegion.children().hide();
  7225. $( "<div>" ).text( label ).appendTo( this.liveRegion );
  7226. }
  7227. },
  7228. menuselect: function( event, ui ) {
  7229. var item = ui.item.data( "ui-autocomplete-item" ),
  7230. previous = this.previous;
  7232. // only trigger when focus was lost (click on menu)
  7233. if ( this.element[ 0 ] !== this.document[ 0 ].activeElement ) {
  7234. this.element.focus();
  7235. this.previous = previous;
  7236. // #6109 - IE triggers two focus events and the second
  7237. // is asynchronous, so we need to reset the previous
  7238. // term synchronously and asynchronously :-(
  7239. this._delay(function() {
  7240. this.previous = previous;
  7241. this.selectedItem = item;
  7242. });
  7243. }
  7245. if ( false !== this._trigger( "select", event, { item: item } ) ) {
  7246. this._value( item.value );
  7247. }
  7248. // reset the term after the select event
  7249. // this allows custom select handling to work properly
  7250. this.term = this._value();
  7252. this.close( event );
  7253. this.selectedItem = item;
  7254. }
  7255. });
  7257. this.liveRegion = $( "<span>", {
  7258. role: "status",
  7259. "aria-live": "assertive",
  7260. "aria-relevant": "additions"
  7261. })
  7262. .addClass( "ui-helper-hidden-accessible" )
  7263. .appendTo( this.document[ 0 ].body );
  7265. // turning off autocomplete prevents the browser from remembering the
  7266. // value when navigating through history, so we re-enable autocomplete
  7267. // if the page is unloaded before the widget is destroyed. #7790
  7268. this._on( this.window, {
  7269. beforeunload: function() {
  7270. this.element.removeAttr( "autocomplete" );
  7271. }
  7272. });
  7273. },
  7275. _destroy: function() {
  7276. clearTimeout( this.searching );
  7277. this.element
  7278. .removeClass( "ui-autocomplete-input" )
  7279. .removeAttr( "autocomplete" );
  7280. this.menu.element.remove();
  7281. this.liveRegion.remove();
  7282. },
  7284. _setOption: function( key, value ) {
  7285. this._super( key, value );
  7286. if ( key === "source" ) {
  7287. this._initSource();
  7288. }
  7289. if ( key === "appendTo" ) {
  7290. this.menu.element.appendTo( this._appendTo() );
  7291. }
  7292. if ( key === "disabled" && value && this.xhr ) {
  7293. this.xhr.abort();
  7294. }
  7295. },
  7297. _appendTo: function() {
  7298. var element = this.options.appendTo;
  7300. if ( element ) {
  7301. element = element.jquery || element.nodeType ?
  7302. $( element ) :
  7303. this.document.find( element ).eq( 0 );
  7304. }
  7306. if ( !element || !element[ 0 ] ) {
  7307. element = this.element.closest( ".ui-front" );
  7308. }
  7310. if ( !element.length ) {
  7311. element = this.document[ 0 ].body;
  7312. }
  7314. return element;
  7315. },
  7317. _initSource: function() {
  7318. var array, url,
  7319. that = this;
  7320. if ( $.isArray( this.options.source ) ) {
  7321. array = this.options.source;
  7322. this.source = function( request, response ) {
  7323. response( $.ui.autocomplete.filter( array, request.term ) );
  7324. };
  7325. } else if ( typeof this.options.source === "string" ) {
  7326. url = this.options.source;
  7327. this.source = function( request, response ) {
  7328. if ( that.xhr ) {
  7329. that.xhr.abort();
  7330. }
  7331. that.xhr = $.ajax({
  7332. url: url,
  7333. data: request,
  7334. dataType: "json",
  7335. success: function( data ) {
  7336. response( data );
  7337. },
  7338. error: function() {
  7339. response([]);
  7340. }
  7341. });
  7342. };
  7343. } else {
  7344. this.source = this.options.source;
  7345. }
  7346. },
  7348. _searchTimeout: function( event ) {
  7349. clearTimeout( this.searching );
  7350. this.searching = this._delay(function() {
  7352. // Search if the value has changed, or if the user retypes the same value (see #7434)
  7353. var equalValues = this.term === this._value(),
  7354. menuVisible = this.menu.element.is( ":visible" ),
  7355. modifierKey = event.altKey || event.ctrlKey || event.metaKey || event.shiftKey;
  7357. if ( !equalValues || ( equalValues && !menuVisible && !modifierKey ) ) {
  7358. this.selectedItem = null;
  7359. this.search( null, event );
  7360. }
  7361. }, this.options.delay );
  7362. },
  7364. search: function( value, event ) {
  7365. value = value != null ? value : this._value();
  7367. // always save the actual value, not the one passed as an argument
  7368. this.term = this._value();
  7370. if ( value.length < this.options.minLength ) {
  7371. return this.close( event );
  7372. }
  7374. if ( this._trigger( "search", event ) === false ) {
  7375. return;
  7376. }
  7378. return this._search( value );
  7379. },
  7381. _search: function( value ) {
  7382. this.pending++;
  7383. this.element.addClass( "ui-autocomplete-loading" );
  7384. this.cancelSearch = false;
  7386. this.source( { term: value }, this._response() );
  7387. },
  7389. _response: function() {
  7390. var index = ++this.requestIndex;
  7392. return $.proxy(function( content ) {
  7393. if ( index === this.requestIndex ) {
  7394. this.__response( content );
  7395. }
  7397. this.pending--;
  7398. if ( !this.pending ) {
  7399. this.element.removeClass( "ui-autocomplete-loading" );
  7400. }
  7401. }, this );
  7402. },
  7404. __response: function( content ) {
  7405. if ( content ) {
  7406. content = this._normalize( content );
  7407. }
  7408. this._trigger( "response", null, { content: content } );
  7409. if ( !this.options.disabled && content && content.length && !this.cancelSearch ) {
  7410. this._suggest( content );
  7411. this._trigger( "open" );
  7412. } else {
  7413. // use ._close() instead of .close() so we don't cancel future searches
  7414. this._close();
  7415. }
  7416. },
  7418. close: function( event ) {
  7419. this.cancelSearch = true;
  7420. this._close( event );
  7421. },
  7423. _close: function( event ) {
  7424. if ( this.menu.element.is( ":visible" ) ) {
  7425. this.menu.element.hide();
  7426. this.menu.blur();
  7427. this.isNewMenu = true;
  7428. this._trigger( "close", event );
  7429. }
  7430. },
  7432. _change: function( event ) {
  7433. if ( this.previous !== this._value() ) {
  7434. this._trigger( "change", event, { item: this.selectedItem } );
  7435. }
  7436. },
  7438. _normalize: function( items ) {
  7439. // assume all items have the right format when the first item is complete
  7440. if ( items.length && items[ 0 ].label && items[ 0 ].value ) {
  7441. return items;
  7442. }
  7443. return $.map( items, function( item ) {
  7444. if ( typeof item === "string" ) {
  7445. return {
  7446. label: item,
  7447. value: item
  7448. };
  7449. }
  7450. return $.extend( {}, item, {
  7451. label: item.label || item.value,
  7452. value: item.value || item.label
  7453. });
  7454. });
  7455. },
  7457. _suggest: function( items ) {
  7458. var ul = this.menu.element.empty();
  7459. this._renderMenu( ul, items );
  7460. this.isNewMenu = true;
  7461. this.menu.refresh();
  7463. // size and position menu
  7464. ul.show();
  7465. this._resizeMenu();
  7466. ul.position( $.extend({
  7467. of: this.element
  7468. }, this.options.position ) );
  7470. if ( this.options.autoFocus ) {
  7471. this.menu.next();
  7472. }
  7473. },
  7475. _resizeMenu: function() {
  7476. var ul = this.menu.element;
  7477. ul.outerWidth( Math.max(
  7478. // Firefox wraps long text (possibly a rounding bug)
  7479. // so we add 1px to avoid the wrapping (#7513)
  7480. ul.width( "" ).outerWidth() + 1,
  7481. this.element.outerWidth()
  7482. ) );
  7483. },
  7485. _renderMenu: function( ul, items ) {
  7486. var that = this;
  7487. $.each( items, function( index, item ) {
  7488. that._renderItemData( ul, item );
  7489. });
  7490. },
  7492. _renderItemData: function( ul, item ) {
  7493. return this._renderItem( ul, item ).data( "ui-autocomplete-item", item );
  7494. },
  7496. _renderItem: function( ul, item ) {
  7497. return $( "<li>" ).text( item.label ).appendTo( ul );
  7498. },
  7500. _move: function( direction, event ) {
  7501. if ( !this.menu.element.is( ":visible" ) ) {
  7502. this.search( null, event );
  7503. return;
  7504. }
  7505. if ( this.menu.isFirstItem() && /^previous/.test( direction ) ||
  7506. this.menu.isLastItem() && /^next/.test( direction ) ) {
  7508. if ( !this.isMultiLine ) {
  7509. this._value( this.term );
  7510. }
  7512. this.menu.blur();
  7513. return;
  7514. }
  7515. this.menu[ direction ]( event );
  7516. },
  7518. widget: function() {
  7519. return this.menu.element;
  7520. },
  7522. _value: function() {
  7523. return this.valueMethod.apply( this.element, arguments );
  7524. },
  7526. _keyEvent: function( keyEvent, event ) {
  7527. if ( !this.isMultiLine || this.menu.element.is( ":visible" ) ) {
  7528. this._move( keyEvent, event );
  7530. // prevents moving cursor to beginning/end of the text field in some browsers
  7531. event.preventDefault();
  7532. }
  7533. }
  7534. });
  7536. $.extend( $.ui.autocomplete, {
  7537. escapeRegex: function( value ) {
  7538. return value.replace( /[\-\[\]{}()*+?.,\\\^$|#\s]/g, "\\$&" );
  7539. },
  7540. filter: function( array, term ) {
  7541. var matcher = new RegExp( $.ui.autocomplete.escapeRegex( term ), "i" );
  7542. return $.grep( array, function( value ) {
  7543. return matcher.test( value.label || value.value || value );
  7544. });
  7545. }
  7546. });
  7548. // live region extension, adding a `messages` option
  7549. // NOTE: This is an experimental API. We are still investigating
  7550. // a full solution for string manipulation and internationalization.
  7551. $.widget( "ui.autocomplete", $.ui.autocomplete, {
  7552. options: {
  7553. messages: {
  7554. noResults: "No search results.",
  7555. results: function( amount ) {
  7556. return amount + ( amount > 1 ? " results are" : " result is" ) +
  7557. " available, use up and down arrow keys to navigate.";
  7558. }
  7559. }
  7560. },
  7562. __response: function( content ) {
  7563. var message;
  7564. this._superApply( arguments );
  7565. if ( this.options.disabled || this.cancelSearch ) {
  7566. return;
  7567. }
  7568. if ( content && content.length ) {
  7569. message = this.options.messages.results( content.length );
  7570. } else {
  7571. message = this.options.messages.noResults;
  7572. }
  7573. this.liveRegion.children().hide();
  7574. $( "<div>" ).text( message ).appendTo( this.liveRegion );
  7575. }
  7576. });
  7578. var autocomplete = $.ui.autocomplete;
  7581. /*!
  7582. * jQuery UI Button 1.11.4
  7583. * http://jqueryui.com
  7584. *
  7585. * Copyright jQuery Foundation and other contributors
  7586. * Released under the MIT license.
  7587. * http://jquery.org/license
  7588. *
  7589. * http://api.jqueryui.com/button/
  7590. */
  7593. var lastActive,
  7594. baseClasses = "ui-button ui-widget ui-state-default ui-corner-all",
  7595. 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",
  7596. formResetHandler = function() {
  7597. var form = $( this );
  7598. setTimeout(function() {
  7599. form.find( ":ui-button" ).button( "refresh" );
  7600. }, 1 );
  7601. },
  7602. radioGroup = function( radio ) {
  7603. var name = radio.name,
  7604. form = radio.form,
  7605. radios = $( [] );
  7606. if ( name ) {
  7607. name = name.replace( /'/g, "\\'" );
  7608. if ( form ) {
  7609. radios = $( form ).find( "[name='" + name + "'][type=radio]" );
  7610. } else {
  7611. radios = $( "[name='" + name + "'][type=radio]", radio.ownerDocument )
  7612. .filter(function() {
  7613. return !this.form;
  7614. });
  7615. }
  7616. }
  7617. return radios;
  7618. };
  7620. $.widget( "ui.button", {
  7621. version: "1.11.4",
  7622. defaultElement: "<button>",
  7623. options: {
  7624. disabled: null,
  7625. text: true,
  7626. label: null,
  7627. icons: {
  7628. primary: null,
  7629. secondary: null
  7630. }
  7631. },
  7632. _create: function() {
  7633. this.element.closest( "form" )
  7634. .unbind( "reset" + this.eventNamespace )
  7635. .bind( "reset" + this.eventNamespace, formResetHandler );
  7637. if ( typeof this.options.disabled !== "boolean" ) {
  7638. this.options.disabled = !!this.element.prop( "disabled" );
  7639. } else {
  7640. this.element.prop( "disabled", this.options.disabled );
  7641. }
  7643. this._determineButtonType();
  7644. this.hasTitle = !!this.buttonElement.attr( "title" );
  7646. var that = this,
  7647. options = this.options,
  7648. toggleButton = this.type === "checkbox" || this.type === "radio",
  7649. activeClass = !toggleButton ? "ui-state-active" : "";
  7651. if ( options.label === null ) {
  7652. options.label = (this.type === "input" ? this.buttonElement.val() : this.buttonElement.html());
  7653. }
  7655. this._hoverable( this.buttonElement );
  7657. this.buttonElement
  7658. .addClass( baseClasses )
  7659. .attr( "role", "button" )
  7660. .bind( "mouseenter" + this.eventNamespace, function() {
  7661. if ( options.disabled ) {
  7662. return;
  7663. }
  7664. if ( this === lastActive ) {
  7665. $( this ).addClass( "ui-state-active" );
  7666. }
  7667. })
  7668. .bind( "mouseleave" + this.eventNamespace, function() {
  7669. if ( options.disabled ) {
  7670. return;
  7671. }
  7672. $( this ).removeClass( activeClass );
  7673. })
  7674. .bind( "click" + this.eventNamespace, function( event ) {
  7675. if ( options.disabled ) {
  7676. event.preventDefault();
  7677. event.stopImmediatePropagation();
  7678. }
  7679. });
  7681. // Can't use _focusable() because the element that receives focus
  7682. // and the element that gets the ui-state-focus class are different
  7683. this._on({
  7684. focus: function() {
  7685. this.buttonElement.addClass( "ui-state-focus" );
  7686. },
  7687. blur: function() {
  7688. this.buttonElement.removeClass( "ui-state-focus" );
  7689. }
  7690. });
  7692. if ( toggleButton ) {
  7693. this.element.bind( "change" + this.eventNamespace, function() {
  7694. that.refresh();
  7695. });
  7696. }
  7698. if ( this.type === "checkbox" ) {
  7699. this.buttonElement.bind( "click" + this.eventNamespace, function() {
  7700. if ( options.disabled ) {
  7701. return false;
  7702. }
  7703. });
  7704. } else if ( this.type === "radio" ) {
  7705. this.buttonElement.bind( "click" + this.eventNamespace, function() {
  7706. if ( options.disabled ) {
  7707. return false;
  7708. }
  7709. $( this ).addClass( "ui-state-active" );
  7710. that.buttonElement.attr( "aria-pressed", "true" );
  7712. var radio = that.element[ 0 ];
  7713. radioGroup( radio )
  7714. .not( radio )
  7715. .map(function() {
  7716. return $( this ).button( "widget" )[ 0 ];
  7717. })
  7718. .removeClass( "ui-state-active" )
  7719. .attr( "aria-pressed", "false" );
  7720. });
  7721. } else {
  7722. this.buttonElement
  7723. .bind( "mousedown" + this.eventNamespace, function() {
  7724. if ( options.disabled ) {
  7725. return false;
  7726. }
  7727. $( this ).addClass( "ui-state-active" );
  7728. lastActive = this;
  7729. that.document.one( "mouseup", function() {
  7730. lastActive = null;
  7731. });
  7732. })
  7733. .bind( "mouseup" + this.eventNamespace, function() {
  7734. if ( options.disabled ) {
  7735. return false;
  7736. }
  7737. $( this ).removeClass( "ui-state-active" );
  7738. })
  7739. .bind( "keydown" + this.eventNamespace, function(event) {
  7740. if ( options.disabled ) {
  7741. return false;
  7742. }
  7743. if ( event.keyCode === $.ui.keyCode.SPACE || event.keyCode === $.ui.keyCode.ENTER ) {
  7744. $( this ).addClass( "ui-state-active" );
  7745. }
  7746. })
  7747. // see #8559, we bind to blur here in case the button element loses
  7748. // focus between keydown and keyup, it would be left in an "active" state
  7749. .bind( "keyup" + this.eventNamespace + " blur" + this.eventNamespace, function() {
  7750. $( this ).removeClass( "ui-state-active" );
  7751. });
  7753. if ( this.buttonElement.is("a") ) {
  7754. this.buttonElement.keyup(function(event) {
  7755. if ( event.keyCode === $.ui.keyCode.SPACE ) {
  7756. // TODO pass through original event correctly (just as 2nd argument doesn't work)
  7757. $( this ).click();
  7758. }
  7759. });
  7760. }
  7761. }
  7763. this._setOption( "disabled", options.disabled );
  7764. this._resetButton();
  7765. },
  7767. _determineButtonType: function() {
  7768. var ancestor, labelSelector, checked;
  7770. if ( this.element.is("[type=checkbox]") ) {
  7771. this.type = "checkbox";
  7772. } else if ( this.element.is("[type=radio]") ) {
  7773. this.type = "radio";
  7774. } else if ( this.element.is("input") ) {
  7775. this.type = "input";
  7776. } else {
  7777. this.type = "button";
  7778. }
  7780. if ( this.type === "checkbox" || this.type === "radio" ) {
  7781. // we don't search against the document in case the element
  7782. // is disconnected from the DOM
  7783. ancestor = this.element.parents().last();
  7784. labelSelector = "label[for='" + this.element.attr("id") + "']";
  7785. this.buttonElement = ancestor.find( labelSelector );
  7786. if ( !this.buttonElement.length ) {
  7787. ancestor = ancestor.length ? ancestor.siblings() : this.element.siblings();
  7788. this.buttonElement = ancestor.filter( labelSelector );
  7789. if ( !this.buttonElement.length ) {
  7790. this.buttonElement = ancestor.find( labelSelector );
  7791. }
  7792. }
  7793. this.element.addClass( "ui-helper-hidden-accessible" );
  7795. checked = this.element.is( ":checked" );
  7796. if ( checked ) {
  7797. this.buttonElement.addClass( "ui-state-active" );
  7798. }
  7799. this.buttonElement.prop( "aria-pressed", checked );
  7800. } else {
  7801. this.buttonElement = this.element;
  7802. }
  7803. },
  7805. widget: function() {
  7806. return this.buttonElement;
  7807. },
  7809. _destroy: function() {
  7810. this.element
  7811. .removeClass( "ui-helper-hidden-accessible" );
  7812. this.buttonElement
  7813. .removeClass( baseClasses + " ui-state-active " + typeClasses )
  7814. .removeAttr( "role" )
  7815. .removeAttr( "aria-pressed" )
  7816. .html( this.buttonElement.find(".ui-button-text").html() );
  7818. if ( !this.hasTitle ) {
  7819. this.buttonElement.removeAttr( "title" );
  7820. }
  7821. },
  7823. _setOption: function( key, value ) {
  7824. this._super( key, value );
  7825. if ( key === "disabled" ) {
  7826. this.widget().toggleClass( "ui-state-disabled", !!value );
  7827. this.element.prop( "disabled", !!value );
  7828. if ( value ) {
  7829. if ( this.type === "checkbox" || this.type === "radio" ) {
  7830. this.buttonElement.removeClass( "ui-state-focus" );
  7831. } else {
  7832. this.buttonElement.removeClass( "ui-state-focus ui-state-active" );
  7833. }
  7834. }
  7835. return;
  7836. }
  7837. this._resetButton();
  7838. },
  7840. refresh: function() {
  7841. //See #8237 & #8828
  7842. var isDisabled = this.element.is( "input, button" ) ? this.element.is( ":disabled" ) : this.element.hasClass( "ui-button-disabled" );
  7844. if ( isDisabled !== this.options.disabled ) {
  7845. this._setOption( "disabled", isDisabled );
  7846. }
  7847. if ( this.type === "radio" ) {
  7848. radioGroup( this.element[0] ).each(function() {
  7849. if ( $( this ).is( ":checked" ) ) {
  7850. $( this ).button( "widget" )
  7851. .addClass( "ui-state-active" )
  7852. .attr( "aria-pressed", "true" );
  7853. } else {
  7854. $( this ).button( "widget" )
  7855. .removeClass( "ui-state-active" )
  7856. .attr( "aria-pressed", "false" );
  7857. }
  7858. });
  7859. } else if ( this.type === "checkbox" ) {
  7860. if ( this.element.is( ":checked" ) ) {
  7861. this.buttonElement
  7862. .addClass( "ui-state-active" )
  7863. .attr( "aria-pressed", "true" );
  7864. } else {
  7865. this.buttonElement
  7866. .removeClass( "ui-state-active" )
  7867. .attr( "aria-pressed", "false" );
  7868. }
  7869. }
  7870. },
  7872. _resetButton: function() {
  7873. if ( this.type === "input" ) {
  7874. if ( this.options.label ) {
  7875. this.element.val( this.options.label );
  7876. }
  7877. return;
  7878. }
  7879. var buttonElement = this.buttonElement.removeClass( typeClasses ),
  7880. buttonText = $( "<span></span>", this.document[0] )
  7881. .addClass( "ui-button-text" )
  7882. .html( this.options.label )
  7883. .appendTo( buttonElement.empty() )
  7884. .text(),
  7885. icons = this.options.icons,
  7886. multipleIcons = icons.primary && icons.secondary,
  7887. buttonClasses = [];
  7889. if ( icons.primary || icons.secondary ) {
  7890. if ( this.options.text ) {
  7891. buttonClasses.push( "ui-button-text-icon" + ( multipleIcons ? "s" : ( icons.primary ? "-primary" : "-secondary" ) ) );
  7892. }
  7894. if ( icons.primary ) {
  7895. buttonElement.prepend( "<span class='ui-button-icon-primary ui-icon " + icons.primary + "'></span>" );
  7896. }
  7898. if ( icons.secondary ) {
  7899. buttonElement.append( "<span class='ui-button-icon-secondary ui-icon " + icons.secondary + "'></span>" );
  7900. }
  7902. if ( !this.options.text ) {
  7903. buttonClasses.push( multipleIcons ? "ui-button-icons-only" : "ui-button-icon-only" );
  7905. if ( !this.hasTitle ) {
  7906. buttonElement.attr( "title", $.trim( buttonText ) );
  7907. }
  7908. }
  7909. } else {
  7910. buttonClasses.push( "ui-button-text-only" );
  7911. }
  7912. buttonElement.addClass( buttonClasses.join( " " ) );
  7913. }
  7914. });
  7916. $.widget( "ui.buttonset", {
  7917. version: "1.11.4",
  7918. options: {
  7919. items: "button, input[type=button], input[type=submit], input[type=reset], input[type=checkbox], input[type=radio], a, :data(ui-button)"
  7920. },
  7922. _create: function() {
  7923. this.element.addClass( "ui-buttonset" );
  7924. },
  7926. _init: function() {
  7927. this.refresh();
  7928. },
  7930. _setOption: function( key, value ) {
  7931. if ( key === "disabled" ) {
  7932. this.buttons.button( "option", key, value );
  7933. }
  7935. this._super( key, value );
  7936. },
  7938. refresh: function() {
  7939. var rtl = this.element.css( "direction" ) === "rtl",
  7940. allButtons = this.element.find( this.options.items ),
  7941. existingButtons = allButtons.filter( ":ui-button" );
  7943. // Initialize new buttons
  7944. allButtons.not( ":ui-button" ).button();
  7946. // Refresh existing buttons
  7947. existingButtons.button( "refresh" );
  7949. this.buttons = allButtons
  7950. .map(function() {
  7951. return $( this ).button( "widget" )[ 0 ];
  7952. })
  7953. .removeClass( "ui-corner-all ui-corner-left ui-corner-right" )
  7954. .filter( ":first" )
  7955. .addClass( rtl ? "ui-corner-right" : "ui-corner-left" )
  7956. .end()
  7957. .filter( ":last" )
  7958. .addClass( rtl ? "ui-corner-left" : "ui-corner-right" )
  7959. .end()
  7960. .end();
  7961. },
  7963. _destroy: function() {
  7964. this.element.removeClass( "ui-buttonset" );
  7965. this.buttons
  7966. .map(function() {
  7967. return $( this ).button( "widget" )[ 0 ];
  7968. })
  7969. .removeClass( "ui-corner-left ui-corner-right" )
  7970. .end()
  7971. .button( "destroy" );
  7972. }
  7973. });
  7975. var button = $.ui.button;
  7978. /*!
  7979. * jQuery UI Datepicker 1.11.4
  7980. * http://jqueryui.com
  7981. *
  7982. * Copyright jQuery Foundation and other contributors
  7983. * Released under the MIT license.
  7984. * http://jquery.org/license
  7985. *
  7986. * http://api.jqueryui.com/datepicker/
  7987. */
  7990. $.extend($.ui, { datepicker: { version: "1.11.4" } });
  7992. var datepicker_instActive;
  7994. function datepicker_getZindex( elem ) {
  7995. var position, value;
  7996. while ( elem.length && elem[ 0 ] !== document ) {
  7997. // Ignore z-index if position is set to a value where z-index is ignored by the browser
  7998. // This makes behavior of this function consistent across browsers
  7999. // WebKit always returns auto if the element is positioned
  8000. position = elem.css( "position" );
  8001. if ( position === "absolute" || position === "relative" || position === "fixed" ) {
  8002. // IE returns 0 when zIndex is not specified
  8003. // other browsers return a string
  8004. // we ignore the case of nested elements with an explicit value of 0
  8005. // <div style="z-index: -10;"><div style="z-index: 0;"></div></div>
  8006. value = parseInt( elem.css( "zIndex" ), 10 );
  8007. if ( !isNaN( value ) && value !== 0 ) {
  8008. return value;
  8009. }
  8010. }
  8011. elem = elem.parent();
  8012. }
  8014. return 0;
  8015. }
  8016. /* Date picker manager.
  8017. Use the singleton instance of this class, $.datepicker, to interact with the date picker.
  8018. Settings for (groups of) date pickers are maintained in an instance object,
  8019. allowing multiple different settings on the same page. */
  8021. function Datepicker() {
  8022. this._curInst = null; // The current instance in use
  8023. this._keyEvent = false; // If the last event was a key event
  8024. this._disabledInputs = []; // List of date picker inputs that have been disabled
  8025. this._datepickerShowing = false; // True if the popup picker is showing , false if not
  8026. this._inDialog = false; // True if showing within a "dialog", false if not
  8027. this._mainDivId = "ui-datepicker-div"; // The ID of the main datepicker division
  8028. this._inlineClass = "ui-datepicker-inline"; // The name of the inline marker class
  8029. this._appendClass = "ui-datepicker-append"; // The name of the append marker class
  8030. this._triggerClass = "ui-datepicker-trigger"; // The name of the trigger marker class
  8031. this._dialogClass = "ui-datepicker-dialog"; // The name of the dialog marker class
  8032. this._disableClass = "ui-datepicker-disabled"; // The name of the disabled covering marker class
  8033. this._unselectableClass = "ui-datepicker-unselectable"; // The name of the unselectable cell marker class
  8034. this._currentClass = "ui-datepicker-current-day"; // The name of the current day marker class
  8035. this._dayOverClass = "ui-datepicker-days-cell-over"; // The name of the day hover marker class
  8036. this.regional = []; // Available regional settings, indexed by language code
  8037. this.regional[""] = { // Default regional settings
  8038. closeText: "Done", // Display text for close link
  8039. prevText: "Prev", // Display text for previous month link
  8040. nextText: "Next", // Display text for next month link
  8041. currentText: "Today", // Display text for current month link
  8042. monthNames: ["January","February","March","April","May","June",
  8043. "July","August","September","October","November","December"], // Names of months for drop-down and formatting
  8044. monthNamesShort: ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"], // For formatting
  8045. dayNames: ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"], // For formatting
  8046. dayNamesShort: ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"], // For formatting
  8047. dayNamesMin: ["Su","Mo","Tu","We","Th","Fr","Sa"], // Column headings for days starting at Sunday
  8048. weekHeader: "Wk", // Column header for week of the year
  8049. dateFormat: "mm/dd/yy", // See format options on parseDate
  8050. firstDay: 0, // The first day of the week, Sun = 0, Mon = 1, ...
  8051. isRTL: false, // True if right-to-left language, false if left-to-right
  8052. showMonthAfterYear: false, // True if the year select precedes month, false for month then year
  8053. yearSuffix: "" // Additional text to append to the year in the month headers
  8054. };
  8055. this._defaults = { // Global defaults for all the date picker instances
  8056. showOn: "focus", // "focus" for popup on focus,
  8057. // "button" for trigger button, or "both" for either
  8058. showAnim: "fadeIn", // Name of jQuery animation for popup
  8059. showOptions: {}, // Options for enhanced animations
  8060. defaultDate: null, // Used when field is blank: actual date,
  8061. // +/-number for offset from today, null for today
  8062. appendText: "", // Display text following the input box, e.g. showing the format
  8063. buttonText: "...", // Text for trigger button
  8064. buttonImage: "", // URL for trigger button image
  8065. buttonImageOnly: false, // True if the image appears alone, false if it appears on a button
  8066. hideIfNoPrevNext: false, // True to hide next/previous month links
  8067. // if not applicable, false to just disable them
  8068. navigationAsDateFormat: false, // True if date formatting applied to prev/today/next links
  8069. gotoCurrent: false, // True if today link goes back to current selection instead
  8070. changeMonth: false, // True if month can be selected directly, false if only prev/next
  8071. changeYear: false, // True if year can be selected directly, false if only prev/next
  8072. yearRange: "c-10:c+10", // Range of years to display in drop-down,
  8073. // either relative to today's year (-nn:+nn), relative to currently displayed year
  8074. // (c-nn:c+nn), absolute (nnnn:nnnn), or a combination of the above (nnnn:-n)
  8075. showOtherMonths: false, // True to show dates in other months, false to leave blank
  8076. selectOtherMonths: false, // True to allow selection of dates in other months, false for unselectable
  8077. showWeek: false, // True to show week of the year, false to not show it
  8078. calculateWeek: this.iso8601Week, // How to calculate the week of the year,
  8079. // takes a Date and returns the number of the week for it
  8080. shortYearCutoff: "+10", // Short year values < this are in the current century,
  8081. // > this are in the previous century,
  8082. // string value starting with "+" for current year + value
  8083. minDate: null, // The earliest selectable date, or null for no limit
  8084. maxDate: null, // The latest selectable date, or null for no limit
  8085. duration: "fast", // Duration of display/closure
  8086. beforeShowDay: null, // Function that takes a date and returns an array with
  8087. // [0] = true if selectable, false if not, [1] = custom CSS class name(s) or "",
  8088. // [2] = cell title (optional), e.g. $.datepicker.noWeekends
  8089. beforeShow: null, // Function that takes an input field and
  8090. // returns a set of custom settings for the date picker
  8091. onSelect: null, // Define a callback function when a date is selected
  8092. onChangeMonthYear: null, // Define a callback function when the month or year is changed
  8093. onClose: null, // Define a callback function when the datepicker is closed
  8094. numberOfMonths: 1, // Number of months to show at a time
  8095. showCurrentAtPos: 0, // The position in multipe months at which to show the current month (starting at 0)
  8096. stepMonths: 1, // Number of months to step back/forward
  8097. stepBigMonths: 12, // Number of months to step back/forward for the big links
  8098. altField: "", // Selector for an alternate field to store selected dates into
  8099. altFormat: "", // The date format to use for the alternate field
  8100. constrainInput: true, // The input is constrained by the current date format
  8101. showButtonPanel: false, // True to show button panel, false to not show it
  8102. autoSize: false, // True to size the input for the date format, false to leave as is
  8103. disabled: false // The initial disabled state
  8104. };
  8105. $.extend(this._defaults, this.regional[""]);
  8106. this.regional.en = $.extend( true, {}, this.regional[ "" ]);
  8107. this.regional[ "en-US" ] = $.extend( true, {}, this.regional.en );
  8108. this.dpDiv = datepicker_bindHover($("<div id='" + this._mainDivId + "' class='ui-datepicker ui-widget ui-widget-content ui-helper-clearfix ui-corner-all'></div>"));
  8109. }
  8111. $.extend(Datepicker.prototype, {
  8112. /* Class name added to elements to indicate already configured with a date picker. */
  8113. markerClassName: "hasDatepicker",
  8115. //Keep track of the maximum number of rows displayed (see #7043)
  8116. maxRows: 4,
  8118. // TODO rename to "widget" when switching to widget factory
  8119. _widgetDatepicker: function() {
  8120. return this.dpDiv;
  8121. },
  8123. /* Override the default settings for all instances of the date picker.
  8124. * @param settings object - the new settings to use as defaults (anonymous object)
  8125. * @return the manager object
  8126. */
  8127. setDefaults: function(settings) {
  8128. datepicker_extendRemove(this._defaults, settings || {});
  8129. return this;
  8130. },
  8132. /* Attach the date picker to a jQuery selection.
  8133. * @param target element - the target input field or division or span
  8134. * @param settings object - the new settings to use for this date picker instance (anonymous)
  8135. */
  8136. _attachDatepicker: function(target, settings) {
  8137. var nodeName, inline, inst;
  8138. nodeName = target.nodeName.toLowerCase();
  8139. inline = (nodeName === "div" || nodeName === "span");
  8140. if (!target.id) {
  8141. this.uuid += 1;
  8142. target.id = "dp" + this.uuid;
  8143. }
  8144. inst = this._newInst($(target), inline);
  8145. inst.settings = $.extend({}, settings || {});
  8146. if (nodeName === "input") {
  8147. this._connectDatepicker(target, inst);
  8148. } else if (inline) {
  8149. this._inlineDatepicker(target, inst);
  8150. }
  8151. },
  8153. /* Create a new instance object. */
  8154. _newInst: function(target, inline) {
  8155. var id = target[0].id.replace(/([^A-Za-z0-9_\-])/g, "\\\\$1"); // escape jQuery meta chars
  8156. return {id: id, input: target, // associated target
  8157. selectedDay: 0, selectedMonth: 0, selectedYear: 0, // current selection
  8158. drawMonth: 0, drawYear: 0, // month being drawn
  8159. inline: inline, // is datepicker inline or not
  8160. dpDiv: (!inline ? this.dpDiv : // presentation div
  8161. datepicker_bindHover($("<div class='" + this._inlineClass + " ui-datepicker ui-widget ui-widget-content ui-helper-clearfix ui-corner-all'></div>")))};
  8162. },
  8164. /* Attach the date picker to an input field. */
  8165. _connectDatepicker: function(target, inst) {
  8166. var input = $(target);
  8167. inst.append = $([]);
  8168. inst.trigger = $([]);
  8169. if (input.hasClass(this.markerClassName)) {
  8170. return;
  8171. }
  8172. this._attachments(input, inst);
  8173. input.addClass(this.markerClassName).keydown(this._doKeyDown).
  8174. keypress(this._doKeyPress).keyup(this._doKeyUp);
  8175. this._autoSize(inst);
  8176. $.data(target, "datepicker", inst);
  8177. //If disabled option is true, disable the datepicker once it has been attached to the input (see ticket #5665)
  8178. if( inst.settings.disabled ) {
  8179. this._disableDatepicker( target );
  8180. }
  8181. },
  8183. /* Make attachments based on settings. */
  8184. _attachments: function(input, inst) {
  8185. var showOn, buttonText, buttonImage,
  8186. appendText = this._get(inst, "appendText"),
  8187. isRTL = this._get(inst, "isRTL");
  8189. if (inst.append) {
  8190. inst.append.remove();
  8191. }
  8192. if (appendText) {
  8193. inst.append = $("<span class='" + this._appendClass + "'>" + appendText + "</span>");
  8194. input[isRTL ? "before" : "after"](inst.append);
  8195. }
  8197. input.unbind("focus", this._showDatepicker);
  8199. if (inst.trigger) {
  8200. inst.trigger.remove();
  8201. }
  8203. showOn = this._get(inst, "showOn");
  8204. if (showOn === "focus" || showOn === "both") { // pop-up date picker when in the marked field
  8205. input.focus(this._showDatepicker);
  8206. }
  8207. if (showOn === "button" || showOn === "both") { // pop-up date picker when button clicked
  8208. buttonText = this._get(inst, "buttonText");
  8209. buttonImage = this._get(inst, "buttonImage");
  8210. inst.trigger = $(this._get(inst, "buttonImageOnly") ?
  8211. $("<img/>").addClass(this._triggerClass).
  8212. attr({ src: buttonImage, alt: buttonText, title: buttonText }) :
  8213. $("<button type='button'></button>").addClass(this._triggerClass).
  8214. html(!buttonImage ? buttonText : $("<img/>").attr(
  8215. { src:buttonImage, alt:buttonText, title:buttonText })));
  8216. input[isRTL ? "before" : "after"](inst.trigger);
  8217. inst.trigger.click(function() {
  8218. if ($.datepicker._datepickerShowing && $.datepicker._lastInput === input[0]) {
  8219. $.datepicker._hideDatepicker();
  8220. } else if ($.datepicker._datepickerShowing && $.datepicker._lastInput !== input[0]) {
  8221. $.datepicker._hideDatepicker();
  8222. $.datepicker._showDatepicker(input[0]);
  8223. } else {
  8224. $.datepicker._showDatepicker(input[0]);
  8225. }
  8226. return false;
  8227. });
  8228. }
  8229. },
  8231. /* Apply the maximum length for the date format. */
  8232. _autoSize: function(inst) {
  8233. if (this._get(inst, "autoSize") && !inst.inline) {
  8234. var findMax, max, maxI, i,
  8235. date = new Date(2009, 12 - 1, 20), // Ensure double digits
  8236. dateFormat = this._get(inst, "dateFormat");
  8238. if (dateFormat.match(/[DM]/)) {
  8239. findMax = function(names) {
  8240. max = 0;
  8241. maxI = 0;
  8242. for (i = 0; i < names.length; i++) {
  8243. if (names[i].length > max) {
  8244. max = names[i].length;
  8245. maxI = i;
  8246. }
  8247. }
  8248. return maxI;
  8249. };
  8250. date.setMonth(findMax(this._get(inst, (dateFormat.match(/MM/) ?
  8251. "monthNames" : "monthNamesShort"))));
  8252. date.setDate(findMax(this._get(inst, (dateFormat.match(/DD/) ?
  8253. "dayNames" : "dayNamesShort"))) + 20 - date.getDay());
  8254. }
  8255. inst.input.attr("size", this._formatDate(inst, date).length);
  8256. }
  8257. },
  8259. /* Attach an inline date picker to a div. */
  8260. _inlineDatepicker: function(target, inst) {
  8261. var divSpan = $(target);
  8262. if (divSpan.hasClass(this.markerClassName)) {
  8263. return;
  8264. }
  8265. divSpan.addClass(this.markerClassName).append(inst.dpDiv);
  8266. $.data(target, "datepicker", inst);
  8267. this._setDate(inst, this._getDefaultDate(inst), true);
  8268. this._updateDatepicker(inst);
  8269. this._updateAlternate(inst);
  8270. //If disabled option is true, disable the datepicker before showing it (see ticket #5665)
  8271. if( inst.settings.disabled ) {
  8272. this._disableDatepicker( target );
  8273. }
  8274. // Set display:block in place of inst.dpDiv.show() which won't work on disconnected elements
  8275. // http://bugs.jqueryui.com/ticket/7552 - A Datepicker created on a detached div has zero height
  8276. inst.dpDiv.css( "display", "block" );
  8277. },
  8279. /* Pop-up the date picker in a "dialog" box.
  8280. * @param input element - ignored
  8281. * @param date string or Date - the initial date to display
  8282. * @param onSelect function - the function to call when a date is selected
  8283. * @param settings object - update the dialog date picker instance's settings (anonymous object)
  8284. * @param pos int[2] - coordinates for the dialog's position within the screen or
  8285. * event - with x/y coordinates or
  8286. * leave empty for default (screen centre)
  8287. * @return the manager object
  8288. */
  8289. _dialogDatepicker: function(input, date, onSelect, settings, pos) {
  8290. var id, browserWidth, browserHeight, scrollX, scrollY,
  8291. inst = this._dialogInst; // internal instance
  8293. if (!inst) {
  8294. this.uuid += 1;
  8295. id = "dp" + this.uuid;
  8296. this._dialogInput = $("<input type='text' id='" + id +
  8297. "' style='position: absolute; top: -100px; width: 0px;'/>");
  8298. this._dialogInput.keydown(this._doKeyDown);
  8299. $("body").append(this._dialogInput);
  8300. inst = this._dialogInst = this._newInst(this._dialogInput, false);
  8301. inst.settings = {};
  8302. $.data(this._dialogInput[0], "datepicker", inst);
  8303. }
  8304. datepicker_extendRemove(inst.settings, settings || {});
  8305. date = (date && date.constructor === Date ? this._formatDate(inst, date) : date);
  8306. this._dialogInput.val(date);
  8308. this._pos = (pos ? (pos.length ? pos : [pos.pageX, pos.pageY]) : null);
  8309. if (!this._pos) {
  8310. browserWidth = document.documentElement.clientWidth;
  8311. browserHeight = document.documentElement.clientHeight;
  8312. scrollX = document.documentElement.scrollLeft || document.body.scrollLeft;
  8313. scrollY = document.documentElement.scrollTop || document.body.scrollTop;
  8314. this._pos = // should use actual width/height below
  8315. [(browserWidth / 2) - 100 + scrollX, (browserHeight / 2) - 150 + scrollY];
  8316. }
  8318. // move input on screen for focus, but hidden behind dialog
  8319. this._dialogInput.css("left", (this._pos[0] + 20) + "px").css("top", this._pos[1] + "px");
  8320. inst.settings.onSelect = onSelect;
  8321. this._inDialog = true;
  8322. this.dpDiv.addClass(this._dialogClass);
  8323. this._showDatepicker(this._dialogInput[0]);
  8324. if ($.blockUI) {
  8325. $.blockUI(this.dpDiv);
  8326. }
  8327. $.data(this._dialogInput[0], "datepicker", inst);
  8328. return this;
  8329. },
  8331. /* Detach a datepicker from its control.
  8332. * @param target element - the target input field or division or span
  8333. */
  8334. _destroyDatepicker: function(target) {
  8335. var nodeName,
  8336. $target = $(target),
  8337. inst = $.data(target, "datepicker");
  8339. if (!$target.hasClass(this.markerClassName)) {
  8340. return;
  8341. }
  8343. nodeName = target.nodeName.toLowerCase();
  8344. $.removeData(target, "datepicker");
  8345. if (nodeName === "input") {
  8346. inst.append.remove();
  8347. inst.trigger.remove();
  8348. $target.removeClass(this.markerClassName).
  8349. unbind("focus", this._showDatepicker).
  8350. unbind("keydown", this._doKeyDown).
  8351. unbind("keypress", this._doKeyPress).
  8352. unbind("keyup", this._doKeyUp);
  8353. } else if (nodeName === "div" || nodeName === "span") {
  8354. $target.removeClass(this.markerClassName).empty();
  8355. }
  8357. if ( datepicker_instActive === inst ) {
  8358. datepicker_instActive = null;
  8359. }
  8360. },
  8362. /* Enable the date picker to a jQuery selection.
  8363. * @param target element - the target input field or division or span
  8364. */
  8365. _enableDatepicker: function(target) {
  8366. var nodeName, inline,
  8367. $target = $(target),
  8368. inst = $.data(target, "datepicker");
  8370. if (!$target.hasClass(this.markerClassName)) {
  8371. return;
  8372. }
  8374. nodeName = target.nodeName.toLowerCase();
  8375. if (nodeName === "input") {
  8376. target.disabled = false;
  8377. inst.trigger.filter("button").
  8378. each(function() { this.disabled = false; }).end().
  8379. filter("img").css({opacity: "1.0", cursor: ""});
  8380. } else if (nodeName === "div" || nodeName === "span") {
  8381. inline = $target.children("." + this._inlineClass);
  8382. inline.children().removeClass("ui-state-disabled");
  8383. inline.find("select.ui-datepicker-month, select.ui-datepicker-year").
  8384. prop("disabled", false);
  8385. }
  8386. this._disabledInputs = $.map(this._disabledInputs,
  8387. function(value) { return (value === target ? null : value); }); // delete entry
  8388. },
  8390. /* Disable the date picker to a jQuery selection.
  8391. * @param target element - the target input field or division or span
  8392. */
  8393. _disableDatepicker: function(target) {
  8394. var nodeName, inline,
  8395. $target = $(target),
  8396. inst = $.data(target, "datepicker");
  8398. if (!$target.hasClass(this.markerClassName)) {
  8399. return;
  8400. }
  8402. nodeName = target.nodeName.toLowerCase();
  8403. if (nodeName === "input") {
  8404. target.disabled = true;
  8405. inst.trigger.filter("button").
  8406. each(function() { this.disabled = true; }).end().
  8407. filter("img").css({opacity: "0.5", cursor: "default"});
  8408. } else if (nodeName === "div" || nodeName === "span") {
  8409. inline = $target.children("." + this._inlineClass);
  8410. inline.children().addClass("ui-state-disabled");
  8411. inline.find("select.ui-datepicker-month, select.ui-datepicker-year").
  8412. prop("disabled", true);
  8413. }
  8414. this._disabledInputs = $.map(this._disabledInputs,
  8415. function(value) { return (value === target ? null : value); }); // delete entry
  8416. this._disabledInputs[this._disabledInputs.length] = target;
  8417. },
  8419. /* Is the first field in a jQuery collection disabled as a datepicker?
  8420. * @param target element - the target input field or division or span
  8421. * @return boolean - true if disabled, false if enabled
  8422. */
  8423. _isDisabledDatepicker: function(target) {
  8424. if (!target) {
  8425. return false;
  8426. }
  8427. for (var i = 0; i < this._disabledInputs.length; i++) {
  8428. if (this._disabledInputs[i] === target) {
  8429. return true;
  8430. }
  8431. }
  8432. return false;
  8433. },
  8435. /* Retrieve the instance data for the target control.
  8436. * @param target element - the target input field or division or span
  8437. * @return object - the associated instance data
  8438. * @throws error if a jQuery problem getting data
  8439. */
  8440. _getInst: function(target) {
  8441. try {
  8442. return $.data(target, "datepicker");
  8443. }
  8444. catch (err) {
  8445. throw "Missing instance data for this datepicker";
  8446. }
  8447. },
  8449. /* Update or retrieve the settings for a date picker attached to an input field or division.
  8450. * @param target element - the target input field or division or span
  8451. * @param name object - the new settings to update or
  8452. * string - the name of the setting to change or retrieve,
  8453. * when retrieving also "all" for all instance settings or
  8454. * "defaults" for all global defaults
  8455. * @param value any - the new value for the setting
  8456. * (omit if above is an object or to retrieve a value)
  8457. */
  8458. _optionDatepicker: function(target, name, value) {
  8459. var settings, date, minDate, maxDate,
  8460. inst = this._getInst(target);
  8462. if (arguments.length === 2 && typeof name === "string") {
  8463. return (name === "defaults" ? $.extend({}, $.datepicker._defaults) :
  8464. (inst ? (name === "all" ? $.extend({}, inst.settings) :
  8465. this._get(inst, name)) : null));
  8466. }
  8468. settings = name || {};
  8469. if (typeof name === "string") {
  8470. settings = {};
  8471. settings[name] = value;
  8472. }
  8474. if (inst) {
  8475. if (this._curInst === inst) {
  8476. this._hideDatepicker();
  8477. }
  8479. date = this._getDateDatepicker(target, true);
  8480. minDate = this._getMinMaxDate(inst, "min");
  8481. maxDate = this._getMinMaxDate(inst, "max");
  8482. datepicker_extendRemove(inst.settings, settings);
  8483. // reformat the old minDate/maxDate values if dateFormat changes and a new minDate/maxDate isn't provided
  8484. if (minDate !== null && settings.dateFormat !== undefined && settings.minDate === undefined) {
  8485. inst.settings.minDate = this._formatDate(inst, minDate);
  8486. }
  8487. if (maxDate !== null && settings.dateFormat !== undefined && settings.maxDate === undefined) {
  8488. inst.settings.maxDate = this._formatDate(inst, maxDate);
  8489. }
  8490. if ( "disabled" in settings ) {
  8491. if ( settings.disabled ) {
  8492. this._disableDatepicker(target);
  8493. } else {
  8494. this._enableDatepicker(target);
  8495. }
  8496. }
  8497. this._attachments($(target), inst);
  8498. this._autoSize(inst);
  8499. this._setDate(inst, date);
  8500. this._updateAlternate(inst);
  8501. this._updateDatepicker(inst);
  8502. }
  8503. },
  8505. // change method deprecated
  8506. _changeDatepicker: function(target, name, value) {
  8507. this._optionDatepicker(target, name, value);
  8508. },
  8510. /* Redraw the date picker attached to an input field or division.
  8511. * @param target element - the target input field or division or span
  8512. */
  8513. _refreshDatepicker: function(target) {
  8514. var inst = this._getInst(target);
  8515. if (inst) {
  8516. this._updateDatepicker(inst);
  8517. }
  8518. },
  8520. /* Set the dates for a jQuery selection.
  8521. * @param target element - the target input field or division or span
  8522. * @param date Date - the new date
  8523. */
  8524. _setDateDatepicker: function(target, date) {
  8525. var inst = this._getInst(target);
  8526. if (inst) {
  8527. this._setDate(inst, date);
  8528. this._updateDatepicker(inst);
  8529. this._updateAlternate(inst);
  8530. }
  8531. },
  8533. /* Get the date(s) for the first entry in a jQuery selection.
  8534. * @param target element - the target input field or division or span
  8535. * @param noDefault boolean - true if no default date is to be used
  8536. * @return Date - the current date
  8537. */
  8538. _getDateDatepicker: function(target, noDefault) {
  8539. var inst = this._getInst(target);
  8540. if (inst && !inst.inline) {
  8541. this._setDateFromField(inst, noDefault);
  8542. }
  8543. return (inst ? this._getDate(inst) : null);
  8544. },
  8546. /* Handle keystrokes. */
  8547. _doKeyDown: function(event) {
  8548. var onSelect, dateStr, sel,
  8549. inst = $.datepicker._getInst(event.target),
  8550. handled = true,
  8551. isRTL = inst.dpDiv.is(".ui-datepicker-rtl");
  8553. inst._keyEvent = true;
  8554. if ($.datepicker._datepickerShowing) {
  8555. switch (event.keyCode) {
  8556. case 9: $.datepicker._hideDatepicker();
  8557. handled = false;
  8558. break; // hide on tab out
  8559. case 13: sel = $("td." + $.datepicker._dayOverClass + ":not(." +
  8560. $.datepicker._currentClass + ")", inst.dpDiv);
  8561. if (sel[0]) {
  8562. $.datepicker._selectDay(event.target, inst.selectedMonth, inst.selectedYear, sel[0]);
  8563. }
  8565. onSelect = $.datepicker._get(inst, "onSelect");
  8566. if (onSelect) {
  8567. dateStr = $.datepicker._formatDate(inst);
  8569. // trigger custom callback
  8570. onSelect.apply((inst.input ? inst.input[0] : null), [dateStr, inst]);
  8571. } else {
  8572. $.datepicker._hideDatepicker();
  8573. }
  8575. return false; // don't submit the form
  8576. case 27: $.datepicker._hideDatepicker();
  8577. break; // hide on escape
  8578. case 33: $.datepicker._adjustDate(event.target, (event.ctrlKey ?
  8579. -$.datepicker._get(inst, "stepBigMonths") :
  8580. -$.datepicker._get(inst, "stepMonths")), "M");
  8581. break; // previous month/year on page up/+ ctrl
  8582. case 34: $.datepicker._adjustDate(event.target, (event.ctrlKey ?
  8583. +$.datepicker._get(inst, "stepBigMonths") :
  8584. +$.datepicker._get(inst, "stepMonths")), "M");
  8585. break; // next month/year on page down/+ ctrl
  8586. case 35: if (event.ctrlKey || event.metaKey) {
  8587. $.datepicker._clearDate(event.target);
  8588. }
  8589. handled = event.ctrlKey || event.metaKey;
  8590. break; // clear on ctrl or command +end
  8591. case 36: if (event.ctrlKey || event.metaKey) {
  8592. $.datepicker._gotoToday(event.target);
  8593. }
  8594. handled = event.ctrlKey || event.metaKey;
  8595. break; // current on ctrl or command +home
  8596. case 37: if (event.ctrlKey || event.metaKey) {
  8597. $.datepicker._adjustDate(event.target, (isRTL ? +1 : -1), "D");
  8598. }
  8599. handled = event.ctrlKey || event.metaKey;
  8600. // -1 day on ctrl or command +left
  8601. if (event.originalEvent.altKey) {
  8602. $.datepicker._adjustDate(event.target, (event.ctrlKey ?
  8603. -$.datepicker._get(inst, "stepBigMonths") :
  8604. -$.datepicker._get(inst, "stepMonths")), "M");
  8605. }
  8606. // next month/year on alt +left on Mac
  8607. break;
  8608. case 38: if (event.ctrlKey || event.metaKey) {
  8609. $.datepicker._adjustDate(event.target, -7, "D");
  8610. }
  8611. handled = event.ctrlKey || event.metaKey;
  8612. break; // -1 week on ctrl or command +up
  8613. case 39: if (event.ctrlKey || event.metaKey) {
  8614. $.datepicker._adjustDate(event.target, (isRTL ? -1 : +1), "D");
  8615. }
  8616. handled = event.ctrlKey || event.metaKey;
  8617. // +1 day on ctrl or command +right
  8618. if (event.originalEvent.altKey) {
  8619. $.datepicker._adjustDate(event.target, (event.ctrlKey ?
  8620. +$.datepicker._get(inst, "stepBigMonths") :
  8621. +$.datepicker._get(inst, "stepMonths")), "M");
  8622. }
  8623. // next month/year on alt +right
  8624. break;
  8625. case 40: if (event.ctrlKey || event.metaKey) {
  8626. $.datepicker._adjustDate(event.target, +7, "D");
  8627. }
  8628. handled = event.ctrlKey || event.metaKey;
  8629. break; // +1 week on ctrl or command +down
  8630. default: handled = false;
  8631. }
  8632. } else if (event.keyCode === 36 && event.ctrlKey) { // display the date picker on ctrl+home
  8633. $.datepicker._showDatepicker(this);
  8634. } else {
  8635. handled = false;
  8636. }
  8638. if (handled) {
  8639. event.preventDefault();
  8640. event.stopPropagation();
  8641. }
  8642. },
  8644. /* Filter entered characters - based on date format. */
  8645. _doKeyPress: function(event) {
  8646. var chars, chr,
  8647. inst = $.datepicker._getInst(event.target);
  8649. if ($.datepicker._get(inst, "constrainInput")) {
  8650. chars = $.datepicker._possibleChars($.datepicker._get(inst, "dateFormat"));
  8651. chr = String.fromCharCode(event.charCode == null ? event.keyCode : event.charCode);
  8652. return event.ctrlKey || event.metaKey || (chr < " " || !chars || chars.indexOf(chr) > -1);
  8653. }
  8654. },
  8656. /* Synchronise manual entry and field/alternate field. */
  8657. _doKeyUp: function(event) {
  8658. var date,
  8659. inst = $.datepicker._getInst(event.target);
  8661. if (inst.input.val() !== inst.lastVal) {
  8662. try {
  8663. date = $.datepicker.parseDate($.datepicker._get(inst, "dateFormat"),
  8664. (inst.input ? inst.input.val() : null),
  8665. $.datepicker._getFormatConfig(inst));
  8667. if (date) { // only if valid
  8668. $.datepicker._setDateFromField(inst);
  8669. $.datepicker._updateAlternate(inst);
  8670. $.datepicker._updateDatepicker(inst);
  8671. }
  8672. }
  8673. catch (err) {
  8674. }
  8675. }
  8676. return true;
  8677. },
  8679. /* Pop-up the date picker for a given input field.
  8680. * If false returned from beforeShow event handler do not show.
  8681. * @param input element - the input field attached to the date picker or
  8682. * event - if triggered by focus
  8683. */
  8684. _showDatepicker: function(input) {
  8685. input = input.target || input;
  8686. if (input.nodeName.toLowerCase() !== "input") { // find from button/image trigger
  8687. input = $("input", input.parentNode)[0];
  8688. }
  8690. if ($.datepicker._isDisabledDatepicker(input) || $.datepicker._lastInput === input) { // already here
  8691. return;
  8692. }
  8694. var inst, beforeShow, beforeShowSettings, isFixed,
  8695. offset, showAnim, duration;
  8697. inst = $.datepicker._getInst(input);
  8698. if ($.datepicker._curInst && $.datepicker._curInst !== inst) {
  8699. $.datepicker._curInst.dpDiv.stop(true, true);
  8700. if ( inst && $.datepicker._datepickerShowing ) {
  8701. $.datepicker._hideDatepicker( $.datepicker._curInst.input[0] );
  8702. }
  8703. }
  8705. beforeShow = $.datepicker._get(inst, "beforeShow");
  8706. beforeShowSettings = beforeShow ? beforeShow.apply(input, [input, inst]) : {};
  8707. if(beforeShowSettings === false){
  8708. return;
  8709. }
  8710. datepicker_extendRemove(inst.settings, beforeShowSettings);
  8712. inst.lastVal = null;
  8713. $.datepicker._lastInput = input;
  8714. $.datepicker._setDateFromField(inst);
  8716. if ($.datepicker._inDialog) { // hide cursor
  8717. input.value = "";
  8718. }
  8719. if (!$.datepicker._pos) { // position below input
  8720. $.datepicker._pos = $.datepicker._findPos(input);
  8721. $.datepicker._pos[1] += input.offsetHeight; // add the height
  8722. }
  8724. isFixed = false;
  8725. $(input).parents().each(function() {
  8726. isFixed |= $(this).css("position") === "fixed";
  8727. return !isFixed;
  8728. });
  8730. offset = {left: $.datepicker._pos[0], top: $.datepicker._pos[1]};
  8731. $.datepicker._pos = null;
  8732. //to avoid flashes on Firefox
  8733. inst.dpDiv.empty();
  8734. // determine sizing offscreen
  8735. inst.dpDiv.css({position: "absolute", display: "block", top: "-1000px"});
  8736. $.datepicker._updateDatepicker(inst);
  8737. // fix width for dynamic number of date pickers
  8738. // and adjust position before showing
  8739. offset = $.datepicker._checkOffset(inst, offset, isFixed);
  8740. inst.dpDiv.css({position: ($.datepicker._inDialog && $.blockUI ?
  8741. "static" : (isFixed ? "fixed" : "absolute")), display: "none",
  8742. left: offset.left + "px", top: offset.top + "px"});
  8744. if (!inst.inline) {
  8745. showAnim = $.datepicker._get(inst, "showAnim");
  8746. duration = $.datepicker._get(inst, "duration");
  8747. inst.dpDiv.css( "z-index", datepicker_getZindex( $( input ) ) + 1 );
  8748. $.datepicker._datepickerShowing = true;
  8750. if ( $.effects && $.effects.effect[ showAnim ] ) {
  8751. inst.dpDiv.show(showAnim, $.datepicker._get(inst, "showOptions"), duration);
  8752. } else {
  8753. inst.dpDiv[showAnim || "show"](showAnim ? duration : null);
  8754. }
  8756. if ( $.datepicker._shouldFocusInput( inst ) ) {
  8757. inst.input.focus();
  8758. }
  8760. $.datepicker._curInst = inst;
  8761. }
  8762. },
  8764. /* Generate the date picker content. */
  8765. _updateDatepicker: function(inst) {
  8766. this.maxRows = 4; //Reset the max number of rows being displayed (see #7043)
  8767. datepicker_instActive = inst; // for delegate hover events
  8768. inst.dpDiv.empty().append(this._generateHTML(inst));
  8769. this._attachHandlers(inst);
  8771. var origyearshtml,
  8772. numMonths = this._getNumberOfMonths(inst),
  8773. cols = numMonths[1],
  8774. width = 17,
  8775. activeCell = inst.dpDiv.find( "." + this._dayOverClass + " a" );
  8777. if ( activeCell.length > 0 ) {
  8778. datepicker_handleMouseover.apply( activeCell.get( 0 ) );
  8779. }
  8781. inst.dpDiv.removeClass("ui-datepicker-multi-2 ui-datepicker-multi-3 ui-datepicker-multi-4").width("");
  8782. if (cols > 1) {
  8783. inst.dpDiv.addClass("ui-datepicker-multi-" + cols).css("width", (width * cols) + "em");
  8784. }
  8785. inst.dpDiv[(numMonths[0] !== 1 || numMonths[1] !== 1 ? "add" : "remove") +
  8786. "Class"]("ui-datepicker-multi");
  8787. inst.dpDiv[(this._get(inst, "isRTL") ? "add" : "remove") +
  8788. "Class"]("ui-datepicker-rtl");
  8790. if (inst === $.datepicker._curInst && $.datepicker._datepickerShowing && $.datepicker._shouldFocusInput( inst ) ) {
  8791. inst.input.focus();
  8792. }
  8794. // deffered render of the years select (to avoid flashes on Firefox)
  8795. if( inst.yearshtml ){
  8796. origyearshtml = inst.yearshtml;
  8797. setTimeout(function(){
  8798. //assure that inst.yearshtml didn't change.
  8799. if( origyearshtml === inst.yearshtml && inst.yearshtml ){
  8800. inst.dpDiv.find("select.ui-datepicker-year:first").replaceWith(inst.yearshtml);
  8801. }
  8802. origyearshtml = inst.yearshtml = null;
  8803. }, 0);
  8804. }
  8805. },
  8807. // #6694 - don't focus the input if it's already focused
  8808. // this breaks the change event in IE
  8809. // Support: IE and jQuery <1.9
  8810. _shouldFocusInput: function( inst ) {
  8811. return inst.input && inst.input.is( ":visible" ) && !inst.input.is( ":disabled" ) && !inst.input.is( ":focus" );
  8812. },
  8814. /* Check positioning to remain on screen. */
  8815. _checkOffset: function(inst, offset, isFixed) {
  8816. var dpWidth = inst.dpDiv.outerWidth(),
  8817. dpHeight = inst.dpDiv.outerHeight(),
  8818. inputWidth = inst.input ? inst.input.outerWidth() : 0,
  8819. inputHeight = inst.input ? inst.input.outerHeight() : 0,
  8820. viewWidth = document.documentElement.clientWidth + (isFixed ? 0 : $(document).scrollLeft()),
  8821. viewHeight = document.documentElement.clientHeight + (isFixed ? 0 : $(document).scrollTop());
  8823. offset.left -= (this._get(inst, "isRTL") ? (dpWidth - inputWidth) : 0);
  8824. offset.left -= (isFixed && offset.left === inst.input.offset().left) ? $(document).scrollLeft() : 0;
  8825. offset.top -= (isFixed && offset.top === (inst.input.offset().top + inputHeight)) ? $(document).scrollTop() : 0;
  8827. // now check if datepicker is showing outside window viewport - move to a better place if so.
  8828. offset.left -= Math.min(offset.left, (offset.left + dpWidth > viewWidth && viewWidth > dpWidth) ?
  8829. Math.abs(offset.left + dpWidth - viewWidth) : 0);
  8830. offset.top -= Math.min(offset.top, (offset.top + dpHeight > viewHeight && viewHeight > dpHeight) ?
  8831. Math.abs(dpHeight + inputHeight) : 0);
  8833. return offset;
  8834. },
  8836. /* Find an object's position on the screen. */
  8837. _findPos: function(obj) {
  8838. var position,
  8839. inst = this._getInst(obj),
  8840. isRTL = this._get(inst, "isRTL");
  8842. while (obj && (obj.type === "hidden" || obj.nodeType !== 1 || $.expr.filters.hidden(obj))) {
  8843. obj = obj[isRTL ? "previousSibling" : "nextSibling"];
  8844. }
  8846. position = $(obj).offset();
  8847. return [position.left, position.top];
  8848. },
  8850. /* Hide the date picker from view.
  8851. * @param input element - the input field attached to the date picker
  8852. */
  8853. _hideDatepicker: function(input) {
  8854. var showAnim, duration, postProcess, onClose,
  8855. inst = this._curInst;
  8857. if (!inst || (input && inst !== $.data(input, "datepicker"))) {
  8858. return;
  8859. }
  8861. if (this._datepickerShowing) {
  8862. showAnim = this._get(inst, "showAnim");
  8863. duration = this._get(inst, "duration");
  8864. postProcess = function() {
  8865. $.datepicker._tidyDialog(inst);
  8866. };
  8868. // DEPRECATED: after BC for 1.8.x $.effects[ showAnim ] is not needed
  8869. if ( $.effects && ( $.effects.effect[ showAnim ] || $.effects[ showAnim ] ) ) {
  8870. inst.dpDiv.hide(showAnim, $.datepicker._get(inst, "showOptions"), duration, postProcess);
  8871. } else {
  8872. inst.dpDiv[(showAnim === "slideDown" ? "slideUp" :
  8873. (showAnim === "fadeIn" ? "fadeOut" : "hide"))]((showAnim ? duration : null), postProcess);
  8874. }
  8876. if (!showAnim) {
  8877. postProcess();
  8878. }
  8879. this._datepickerShowing = false;
  8881. onClose = this._get(inst, "onClose");
  8882. if (onClose) {
  8883. onClose.apply((inst.input ? inst.input[0] : null), [(inst.input ? inst.input.val() : ""), inst]);
  8884. }
  8886. this._lastInput = null;
  8887. if (this._inDialog) {
  8888. this._dialogInput.css({ position: "absolute", left: "0", top: "-100px" });
  8889. if ($.blockUI) {
  8890. $.unblockUI();
  8891. $("body").append(this.dpDiv);
  8892. }
  8893. }
  8894. this._inDialog = false;
  8895. }
  8896. },
  8898. /* Tidy up after a dialog display. */
  8899. _tidyDialog: function(inst) {
  8900. inst.dpDiv.removeClass(this._dialogClass).unbind(".ui-datepicker-calendar");
  8901. },
  8903. /* Close date picker if clicked elsewhere. */
  8904. _checkExternalClick: function(event) {
  8905. if (!$.datepicker._curInst) {
  8906. return;
  8907. }
  8909. var $target = $(event.target),
  8910. inst = $.datepicker._getInst($target[0]);
  8912. if ( ( ( $target[0].id !== $.datepicker._mainDivId &&
  8913. $target.parents("#" + $.datepicker._mainDivId).length === 0 &&
  8914. !$target.hasClass($.datepicker.markerClassName) &&
  8915. !$target.closest("." + $.datepicker._triggerClass).length &&
  8916. $.datepicker._datepickerShowing && !($.datepicker._inDialog && $.blockUI) ) ) ||
  8917. ( $target.hasClass($.datepicker.markerClassName) && $.datepicker._curInst !== inst ) ) {
  8918. $.datepicker._hideDatepicker();
  8919. }
  8920. },
  8922. /* Adjust one of the date sub-fields. */
  8923. _adjustDate: function(id, offset, period) {
  8924. var target = $(id),
  8925. inst = this._getInst(target[0]);
  8927. if (this._isDisabledDatepicker(target[0])) {
  8928. return;
  8929. }
  8930. this._adjustInstDate(inst, offset +
  8931. (period === "M" ? this._get(inst, "showCurrentAtPos") : 0), // undo positioning
  8932. period);
  8933. this._updateDatepicker(inst);
  8934. },
  8936. /* Action for current link. */
  8937. _gotoToday: function(id) {
  8938. var date,
  8939. target = $(id),
  8940. inst = this._getInst(target[0]);
  8942. if (this._get(inst, "gotoCurrent") && inst.currentDay) {
  8943. inst.selectedDay = inst.currentDay;
  8944. inst.drawMonth = inst.selectedMonth = inst.currentMonth;
  8945. inst.drawYear = inst.selectedYear = inst.currentYear;
  8946. } else {
  8947. date = new Date();
  8948. inst.selectedDay = date.getDate();
  8949. inst.drawMonth = inst.selectedMonth = date.getMonth();
  8950. inst.drawYear = inst.selectedYear = date.getFullYear();
  8951. }
  8952. this._notifyChange(inst);
  8953. this._adjustDate(target);
  8954. },
  8956. /* Action for selecting a new month/year. */
  8957. _selectMonthYear: function(id, select, period) {
  8958. var target = $(id),
  8959. inst = this._getInst(target[0]);
  8961. inst["selected" + (period === "M" ? "Month" : "Year")] =
  8962. inst["draw" + (period === "M" ? "Month" : "Year")] =
  8963. parseInt(select.options[select.selectedIndex].value,10);
  8965. this._notifyChange(inst);
  8966. this._adjustDate(target);
  8967. },
  8969. /* Action for selecting a day. */
  8970. _selectDay: function(id, month, year, td) {
  8971. var inst,
  8972. target = $(id);
  8974. if ($(td).hasClass(this._unselectableClass) || this._isDisabledDatepicker(target[0])) {
  8975. return;
  8976. }
  8978. inst = this._getInst(target[0]);
  8979. inst.selectedDay = inst.currentDay = $("a", td).html();
  8980. inst.selectedMonth = inst.currentMonth = month;
  8981. inst.selectedYear = inst.currentYear = year;
  8982. this._selectDate(id, this._formatDate(inst,
  8983. inst.currentDay, inst.currentMonth, inst.currentYear));
  8984. },
  8986. /* Erase the input field and hide the date picker. */
  8987. _clearDate: function(id) {
  8988. var target = $(id);
  8989. this._selectDate(target, "");
  8990. },
  8992. /* Update the input field with the selected date. */
  8993. _selectDate: function(id, dateStr) {
  8994. var onSelect,
  8995. target = $(id),
  8996. inst = this._getInst(target[0]);
  8998. dateStr = (dateStr != null ? dateStr : this._formatDate(inst));
  8999. if (inst.input) {
  9000. inst.input.val(dateStr);
  9001. }
  9002. this._updateAlternate(inst);
  9004. onSelect = this._get(inst, "onSelect");
  9005. if (onSelect) {
  9006. onSelect.apply((inst.input ? inst.input[0] : null), [dateStr, inst]); // trigger custom callback
  9007. } else if (inst.input) {
  9008. inst.input.trigger("change"); // fire the change event
  9009. }
  9011. if (inst.inline){
  9012. this._updateDatepicker(inst);
  9013. } else {
  9014. this._hideDatepicker();
  9015. this._lastInput = inst.input[0];
  9016. if (typeof(inst.input[0]) !== "object") {
  9017. inst.input.focus(); // restore focus
  9018. }
  9019. this._lastInput = null;
  9020. }
  9021. },
  9023. /* Update any alternate field to synchronise with the main field. */
  9024. _updateAlternate: function(inst) {
  9025. var altFormat, date, dateStr,
  9026. altField = this._get(inst, "altField");
  9028. if (altField) { // update alternate field too
  9029. altFormat = this._get(inst, "altFormat") || this._get(inst, "dateFormat");
  9030. date = this._getDate(inst);
  9031. dateStr = this.formatDate(altFormat, date, this._getFormatConfig(inst));
  9032. $(altField).each(function() { $(this).val(dateStr); });
  9033. }
  9034. },
  9036. /* Set as beforeShowDay function to prevent selection of weekends.
  9037. * @param date Date - the date to customise
  9038. * @return [boolean, string] - is this date selectable?, what is its CSS class?
  9039. */
  9040. noWeekends: function(date) {
  9041. var day = date.getDay();
  9042. return [(day > 0 && day < 6), ""];
  9043. },
  9045. /* Set as calculateWeek to determine the week of the year based on the ISO 8601 definition.
  9046. * @param date Date - the date to get the week for
  9047. * @return number - the number of the week within the year that contains this date
  9048. */
  9049. iso8601Week: function(date) {
  9050. var time,
  9051. checkDate = new Date(date.getTime());
  9053. // Find Thursday of this week starting on Monday
  9054. checkDate.setDate(checkDate.getDate() + 4 - (checkDate.getDay() || 7));
  9056. time = checkDate.getTime();
  9057. checkDate.setMonth(0); // Compare with Jan 1
  9058. checkDate.setDate(1);
  9059. return Math.floor(Math.round((time - checkDate) / 86400000) / 7) + 1;
  9060. },
  9062. /* Parse a string value into a date object.
  9063. * See formatDate below for the possible formats.
  9064. *
  9065. * @param format string - the expected format of the date
  9066. * @param value string - the date in the above format
  9067. * @param settings Object - attributes include:
  9068. * shortYearCutoff number - the cutoff year for determining the century (optional)
  9069. * dayNamesShort string[7] - abbreviated names of the days from Sunday (optional)
  9070. * dayNames string[7] - names of the days from Sunday (optional)
  9071. * monthNamesShort string[12] - abbreviated names of the months (optional)
  9072. * monthNames string[12] - names of the months (optional)
  9073. * @return Date - the extracted date value or null if value is blank
  9074. */
  9075. parseDate: function (format, value, settings) {
  9076. if (format == null || value == null) {
  9077. throw "Invalid arguments";
  9078. }
  9080. value = (typeof value === "object" ? value.toString() : value + "");
  9081. if (value === "") {
  9082. return null;
  9083. }
  9085. var iFormat, dim, extra,
  9086. iValue = 0,
  9087. shortYearCutoffTemp = (settings ? settings.shortYearCutoff : null) || this._defaults.shortYearCutoff,
  9088. shortYearCutoff = (typeof shortYearCutoffTemp !== "string" ? shortYearCutoffTemp :
  9089. new Date().getFullYear() % 100 + parseInt(shortYearCutoffTemp, 10)),
  9090. dayNamesShort = (settings ? settings.dayNamesShort : null) || this._defaults.dayNamesShort,
  9091. dayNames = (settings ? settings.dayNames : null) || this._defaults.dayNames,
  9092. monthNamesShort = (settings ? settings.monthNamesShort : null) || this._defaults.monthNamesShort,
  9093. monthNames = (settings ? settings.monthNames : null) || this._defaults.monthNames,
  9094. year = -1,
  9095. month = -1,
  9096. day = -1,
  9097. doy = -1,
  9098. literal = false,
  9099. date,
  9100. // Check whether a format character is doubled
  9101. lookAhead = function(match) {
  9102. var matches = (iFormat + 1 < format.length && format.charAt(iFormat + 1) === match);
  9103. if (matches) {
  9104. iFormat++;
  9105. }
  9106. return matches;
  9107. },
  9108. // Extract a number from the string value
  9109. getNumber = function(match) {
  9110. var isDoubled = lookAhead(match),
  9111. size = (match === "@" ? 14 : (match === "!" ? 20 :
  9112. (match === "y" && isDoubled ? 4 : (match === "o" ? 3 : 2)))),
  9113. minSize = (match === "y" ? size : 1),
  9114. digits = new RegExp("^\\d{" + minSize + "," + size + "}"),
  9115. num = value.substring(iValue).match(digits);
  9116. if (!num) {
  9117. throw "Missing number at position " + iValue;
  9118. }
  9119. iValue += num[0].length;
  9120. return parseInt(num[0], 10);
  9121. },
  9122. // Extract a name from the string value and convert to an index
  9123. getName = function(match, shortNames, longNames) {
  9124. var index = -1,
  9125. names = $.map(lookAhead(match) ? longNames : shortNames, function (v, k) {
  9126. return [ [k, v] ];
  9127. }).sort(function (a, b) {
  9128. return -(a[1].length - b[1].length);
  9129. });
  9131. $.each(names, function (i, pair) {
  9132. var name = pair[1];
  9133. if (value.substr(iValue, name.length).toLowerCase() === name.toLowerCase()) {
  9134. index = pair[0];
  9135. iValue += name.length;
  9136. return false;
  9137. }
  9138. });
  9139. if (index !== -1) {
  9140. return index + 1;
  9141. } else {
  9142. throw "Unknown name at position " + iValue;
  9143. }
  9144. },
  9145. // Confirm that a literal character matches the string value
  9146. checkLiteral = function() {
  9147. if (value.charAt(iValue) !== format.charAt(iFormat)) {
  9148. throw "Unexpected literal at position " + iValue;
  9149. }
  9150. iValue++;
  9151. };
  9153. for (iFormat = 0; iFormat < format.length; iFormat++) {
  9154. if (literal) {
  9155. if (format.charAt(iFormat) === "'" && !lookAhead("'")) {
  9156. literal = false;
  9157. } else {
  9158. checkLiteral();
  9159. }
  9160. } else {
  9161. switch (format.charAt(iFormat)) {
  9162. case "d":
  9163. day = getNumber("d");
  9164. break;
  9165. case "D":
  9166. getName("D", dayNamesShort, dayNames);
  9167. break;
  9168. case "o":
  9169. doy = getNumber("o");
  9170. break;
  9171. case "m":
  9172. month = getNumber("m");
  9173. break;
  9174. case "M":
  9175. month = getName("M", monthNamesShort, monthNames);
  9176. break;
  9177. case "y":
  9178. year = getNumber("y");
  9179. break;
  9180. case "@":
  9181. date = new Date(getNumber("@"));
  9182. year = date.getFullYear();
  9183. month = date.getMonth() + 1;
  9184. day = date.getDate();
  9185. break;
  9186. case "!":
  9187. date = new Date((getNumber("!") - this._ticksTo1970) / 10000);
  9188. year = date.getFullYear();
  9189. month = date.getMonth() + 1;
  9190. day = date.getDate();
  9191. break;
  9192. case "'":
  9193. if (lookAhead("'")){
  9194. checkLiteral();
  9195. } else {
  9196. literal = true;
  9197. }
  9198. break;
  9199. default:
  9200. checkLiteral();
  9201. }
  9202. }
  9203. }
  9205. if (iValue < value.length){
  9206. extra = value.substr(iValue);
  9207. if (!/^\s+/.test(extra)) {
  9208. throw "Extra/unparsed characters found in date: " + extra;
  9209. }
  9210. }
  9212. if (year === -1) {
  9213. year = new Date().getFullYear();
  9214. } else if (year < 100) {
  9215. year += new Date().getFullYear() - new Date().getFullYear() % 100 +
  9216. (year <= shortYearCutoff ? 0 : -100);
  9217. }
  9219. if (doy > -1) {
  9220. month = 1;
  9221. day = doy;
  9222. do {
  9223. dim = this._getDaysInMonth(year, month - 1);
  9224. if (day <= dim) {
  9225. break;
  9226. }
  9227. month++;
  9228. day -= dim;
  9229. } while (true);
  9230. }
  9232. date = this._daylightSavingAdjust(new Date(year, month - 1, day));
  9233. if (date.getFullYear() !== year || date.getMonth() + 1 !== month || date.getDate() !== day) {
  9234. throw "Invalid date"; // E.g. 31/02/00
  9235. }
  9236. return date;
  9237. },
  9239. /* Standard date formats. */
  9240. ATOM: "yy-mm-dd", // RFC 3339 (ISO 8601)
  9241. COOKIE: "D, dd M yy",
  9242. ISO_8601: "yy-mm-dd",
  9243. RFC_822: "D, d M y",
  9244. RFC_850: "DD, dd-M-y",
  9245. RFC_1036: "D, d M y",
  9246. RFC_1123: "D, d M yy",
  9247. RFC_2822: "D, d M yy",
  9248. RSS: "D, d M y", // RFC 822
  9249. TICKS: "!",
  9250. TIMESTAMP: "@",
  9251. W3C: "yy-mm-dd", // ISO 8601
  9253. _ticksTo1970: (((1970 - 1) * 365 + Math.floor(1970 / 4) - Math.floor(1970 / 100) +
  9254. Math.floor(1970 / 400)) * 24 * 60 * 60 * 10000000),
  9256. /* Format a date object into a string value.
  9257. * The format can be combinations of the following:
  9258. * d - day of month (no leading zero)
  9259. * dd - day of month (two digit)
  9260. * o - day of year (no leading zeros)
  9261. * oo - day of year (three digit)
  9262. * D - day name short
  9263. * DD - day name long
  9264. * m - month of year (no leading zero)
  9265. * mm - month of year (two digit)
  9266. * M - month name short
  9267. * MM - month name long
  9268. * y - year (two digit)
  9269. * yy - year (four digit)
  9270. * @ - Unix timestamp (ms since 01/01/1970)
  9271. * ! - Windows ticks (100ns since 01/01/0001)
  9272. * "..." - literal text
  9273. * '' - single quote
  9274. *
  9275. * @param format string - the desired format of the date
  9276. * @param date Date - the date value to format
  9277. * @param settings Object - attributes include:
  9278. * dayNamesShort string[7] - abbreviated names of the days from Sunday (optional)
  9279. * dayNames string[7] - names of the days from Sunday (optional)
  9280. * monthNamesShort string[12] - abbreviated names of the months (optional)
  9281. * monthNames string[12] - names of the months (optional)
  9282. * @return string - the date in the above format
  9283. */
  9284. formatDate: function (format, date, settings) {
  9285. if (!date) {
  9286. return "";
  9287. }
  9289. var iFormat,
  9290. dayNamesShort = (settings ? settings.dayNamesShort : null) || this._defaults.dayNamesShort,
  9291. dayNames = (settings ? settings.dayNames : null) || this._defaults.dayNames,
  9292. monthNamesShort = (settings ? settings.monthNamesShort : null) || this._defaults.monthNamesShort,
  9293. monthNames = (settings ? settings.monthNames : null) || this._defaults.monthNames,
  9294. // Check whether a format character is doubled
  9295. lookAhead = function(match) {
  9296. var matches = (iFormat + 1 < format.length && format.charAt(iFormat + 1) === match);
  9297. if (matches) {
  9298. iFormat++;
  9299. }
  9300. return matches;
  9301. },
  9302. // Format a number, with leading zero if necessary
  9303. formatNumber = function(match, value, len) {
  9304. var num = "" + value;
  9305. if (lookAhead(match)) {
  9306. while (num.length < len) {
  9307. num = "0" + num;
  9308. }
  9309. }
  9310. return num;
  9311. },
  9312. // Format a name, short or long as requested
  9313. formatName = function(match, value, shortNames, longNames) {
  9314. return (lookAhead(match) ? longNames[value] : shortNames[value]);
  9315. },
  9316. output = "",
  9317. literal = false;
  9319. if (date) {
  9320. for (iFormat = 0; iFormat < format.length; iFormat++) {
  9321. if (literal) {
  9322. if (format.charAt(iFormat) === "'" && !lookAhead("'")) {
  9323. literal = false;
  9324. } else {
  9325. output += format.charAt(iFormat);
  9326. }
  9327. } else {
  9328. switch (format.charAt(iFormat)) {
  9329. case "d":
  9330. output += formatNumber("d", date.getDate(), 2);
  9331. break;
  9332. case "D":
  9333. output += formatName("D", date.getDay(), dayNamesShort, dayNames);
  9334. break;
  9335. case "o":
  9336. output += formatNumber("o",
  9337. Math.round((new Date(date.getFullYear(), date.getMonth(), date.getDate()).getTime() - new Date(date.getFullYear(), 0, 0).getTime()) / 86400000), 3);
  9338. break;
  9339. case "m":
  9340. output += formatNumber("m", date.getMonth() + 1, 2);
  9341. break;
  9342. case "M":
  9343. output += formatName("M", date.getMonth(), monthNamesShort, monthNames);
  9344. break;
  9345. case "y":
  9346. output += (lookAhead("y") ? date.getFullYear() :
  9347. (date.getYear() % 100 < 10 ? "0" : "") + date.getYear() % 100);
  9348. break;
  9349. case "@":
  9350. output += date.getTime();
  9351. break;
  9352. case "!":
  9353. output += date.getTime() * 10000 + this._ticksTo1970;
  9354. break;
  9355. case "'":
  9356. if (lookAhead("'")) {
  9357. output += "'";
  9358. } else {
  9359. literal = true;
  9360. }
  9361. break;
  9362. default:
  9363. output += format.charAt(iFormat);
  9364. }
  9365. }
  9366. }
  9367. }
  9368. return output;
  9369. },
  9371. /* Extract all possible characters from the date format. */
  9372. _possibleChars: function (format) {
  9373. var iFormat,
  9374. chars = "",
  9375. literal = false,
  9376. // Check whether a format character is doubled
  9377. lookAhead = function(match) {
  9378. var matches = (iFormat + 1 < format.length && format.charAt(iFormat + 1) === match);
  9379. if (matches) {
  9380. iFormat++;
  9381. }
  9382. return matches;
  9383. };
  9385. for (iFormat = 0; iFormat < format.length; iFormat++) {
  9386. if (literal) {
  9387. if (format.charAt(iFormat) === "'" && !lookAhead("'")) {
  9388. literal = false;
  9389. } else {
  9390. chars += format.charAt(iFormat);
  9391. }
  9392. } else {
  9393. switch (format.charAt(iFormat)) {
  9394. case "d": case "m": case "y": case "@":
  9395. chars += "0123456789";
  9396. break;
  9397. case "D": case "M":
  9398. return null; // Accept anything
  9399. case "'":
  9400. if (lookAhead("'")) {
  9401. chars += "'";
  9402. } else {
  9403. literal = true;
  9404. }
  9405. break;
  9406. default:
  9407. chars += format.charAt(iFormat);
  9408. }
  9409. }
  9410. }
  9411. return chars;
  9412. },
  9414. /* Get a setting value, defaulting if necessary. */
  9415. _get: function(inst, name) {
  9416. return inst.settings[name] !== undefined ?
  9417. inst.settings[name] : this._defaults[name];
  9418. },
  9420. /* Parse existing date and initialise date picker. */
  9421. _setDateFromField: function(inst, noDefault) {
  9422. if (inst.input.val() === inst.lastVal) {
  9423. return;
  9424. }
  9426. var dateFormat = this._get(inst, "dateFormat"),
  9427. dates = inst.lastVal = inst.input ? inst.input.val() : null,
  9428. defaultDate = this._getDefaultDate(inst),
  9429. date = defaultDate,
  9430. settings = this._getFormatConfig(inst);
  9432. try {
  9433. date = this.parseDate(dateFormat, dates, settings) || defaultDate;
  9434. } catch (event) {
  9435. dates = (noDefault ? "" : dates);
  9436. }
  9437. inst.selectedDay = date.getDate();
  9438. inst.drawMonth = inst.selectedMonth = date.getMonth();
  9439. inst.drawYear = inst.selectedYear = date.getFullYear();
  9440. inst.currentDay = (dates ? date.getDate() : 0);
  9441. inst.currentMonth = (dates ? date.getMonth() : 0);
  9442. inst.currentYear = (dates ? date.getFullYear() : 0);
  9443. this._adjustInstDate(inst);
  9444. },
  9446. /* Retrieve the default date shown on opening. */
  9447. _getDefaultDate: function(inst) {
  9448. return this._restrictMinMax(inst,
  9449. this._determineDate(inst, this._get(inst, "defaultDate"), new Date()));
  9450. },
  9452. /* A date may be specified as an exact value or a relative one. */
  9453. _determineDate: function(inst, date, defaultDate) {
  9454. var offsetNumeric = function(offset) {
  9455. var date = new Date();
  9456. date.setDate(date.getDate() + offset);
  9457. return date;
  9458. },
  9459. offsetString = function(offset) {
  9460. try {
  9461. return $.datepicker.parseDate($.datepicker._get(inst, "dateFormat"),
  9462. offset, $.datepicker._getFormatConfig(inst));
  9463. }
  9464. catch (e) {
  9465. // Ignore
  9466. }
  9468. var date = (offset.toLowerCase().match(/^c/) ?
  9469. $.datepicker._getDate(inst) : null) || new Date(),
  9470. year = date.getFullYear(),
  9471. month = date.getMonth(),
  9472. day = date.getDate(),
  9473. pattern = /([+\-]?[0-9]+)\s*(d|D|w|W|m|M|y|Y)?/g,
  9474. matches = pattern.exec(offset);
  9476. while (matches) {
  9477. switch (matches[2] || "d") {
  9478. case "d" : case "D" :
  9479. day += parseInt(matches[1],10); break;
  9480. case "w" : case "W" :
  9481. day += parseInt(matches[1],10) * 7; break;
  9482. case "m" : case "M" :
  9483. month += parseInt(matches[1],10);
  9484. day = Math.min(day, $.datepicker._getDaysInMonth(year, month));
  9485. break;
  9486. case "y": case "Y" :
  9487. year += parseInt(matches[1],10);
  9488. day = Math.min(day, $.datepicker._getDaysInMonth(year, month));
  9489. break;
  9490. }
  9491. matches = pattern.exec(offset);
  9492. }
  9493. return new Date(year, month, day);
  9494. },
  9495. newDate = (date == null || date === "" ? defaultDate : (typeof date === "string" ? offsetString(date) :
  9496. (typeof date === "number" ? (isNaN(date) ? defaultDate : offsetNumeric(date)) : new Date(date.getTime()))));
  9498. newDate = (newDate && newDate.toString() === "Invalid Date" ? defaultDate : newDate);
  9499. if (newDate) {
  9500. newDate.setHours(0);
  9501. newDate.setMinutes(0);
  9502. newDate.setSeconds(0);
  9503. newDate.setMilliseconds(0);
  9504. }
  9505. return this._daylightSavingAdjust(newDate);
  9506. },
  9508. /* Handle switch to/from daylight saving.
  9509. * Hours may be non-zero on daylight saving cut-over:
  9510. * > 12 when midnight changeover, but then cannot generate
  9511. * midnight datetime, so jump to 1AM, otherwise reset.
  9512. * @param date (Date) the date to check
  9513. * @return (Date) the corrected date
  9514. */
  9515. _daylightSavingAdjust: function(date) {
  9516. if (!date) {
  9517. return null;
  9518. }
  9519. date.setHours(date.getHours() > 12 ? date.getHours() + 2 : 0);
  9520. return date;
  9521. },
  9523. /* Set the date(s) directly. */
  9524. _setDate: function(inst, date, noChange) {
  9525. var clear = !date,
  9526. origMonth = inst.selectedMonth,
  9527. origYear = inst.selectedYear,
  9528. newDate = this._restrictMinMax(inst, this._determineDate(inst, date, new Date()));
  9530. inst.selectedDay = inst.currentDay = newDate.getDate();
  9531. inst.drawMonth = inst.selectedMonth = inst.currentMonth = newDate.getMonth();
  9532. inst.drawYear = inst.selectedYear = inst.currentYear = newDate.getFullYear();
  9533. if ((origMonth !== inst.selectedMonth || origYear !== inst.selectedYear) && !noChange) {
  9534. this._notifyChange(inst);
  9535. }
  9536. this._adjustInstDate(inst);
  9537. if (inst.input) {
  9538. inst.input.val(clear ? "" : this._formatDate(inst));
  9539. }
  9540. },
  9542. /* Retrieve the date(s) directly. */
  9543. _getDate: function(inst) {
  9544. var startDate = (!inst.currentYear || (inst.input && inst.input.val() === "") ? null :
  9545. this._daylightSavingAdjust(new Date(
  9546. inst.currentYear, inst.currentMonth, inst.currentDay)));
  9547. return startDate;
  9548. },
  9550. /* Attach the onxxx handlers. These are declared statically so
  9551. * they work with static code transformers like Caja.
  9552. */
  9553. _attachHandlers: function(inst) {
  9554. var stepMonths = this._get(inst, "stepMonths"),
  9555. id = "#" + inst.id.replace( /\\\\/g, "\\" );
  9556. inst.dpDiv.find("[data-handler]").map(function () {
  9557. var handler = {
  9558. prev: function () {
  9559. $.datepicker._adjustDate(id, -stepMonths, "M");
  9560. },
  9561. next: function () {
  9562. $.datepicker._adjustDate(id, +stepMonths, "M");
  9563. },
  9564. hide: function () {
  9565. $.datepicker._hideDatepicker();
  9566. },
  9567. today: function () {
  9568. $.datepicker._gotoToday(id);
  9569. },
  9570. selectDay: function () {
  9571. $.datepicker._selectDay(id, +this.getAttribute("data-month"), +this.getAttribute("data-year"), this);
  9572. return false;
  9573. },
  9574. selectMonth: function () {
  9575. $.datepicker._selectMonthYear(id, this, "M");
  9576. return false;
  9577. },
  9578. selectYear: function () {
  9579. $.datepicker._selectMonthYear(id, this, "Y");
  9580. return false;
  9581. }
  9582. };
  9583. $(this).bind(this.getAttribute("data-event"), handler[this.getAttribute("data-handler")]);
  9584. });
  9585. },
  9587. /* Generate the HTML for the current state of the date picker. */
  9588. _generateHTML: function(inst) {
  9589. var maxDraw, prevText, prev, nextText, next, currentText, gotoDate,
  9590. controls, buttonPanel, firstDay, showWeek, dayNames, dayNamesMin,
  9591. monthNames, monthNamesShort, beforeShowDay, showOtherMonths,
  9592. selectOtherMonths, defaultDate, html, dow, row, group, col, selectedDate,
  9593. cornerClass, calender, thead, day, daysInMonth, leadDays, curRows, numRows,
  9594. printDate, dRow, tbody, daySettings, otherMonth, unselectable,
  9595. tempDate = new Date(),
  9596. today = this._daylightSavingAdjust(
  9597. new Date(tempDate.getFullYear(), tempDate.getMonth(), tempDate.getDate())), // clear time
  9598. isRTL = this._get(inst, "isRTL"),
  9599. showButtonPanel = this._get(inst, "showButtonPanel"),
  9600. hideIfNoPrevNext = this._get(inst, "hideIfNoPrevNext"),
  9601. navigationAsDateFormat = this._get(inst, "navigationAsDateFormat"),
  9602. numMonths = this._getNumberOfMonths(inst),
  9603. showCurrentAtPos = this._get(inst, "showCurrentAtPos"),
  9604. stepMonths = this._get(inst, "stepMonths"),
  9605. isMultiMonth = (numMonths[0] !== 1 || numMonths[1] !== 1),
  9606. currentDate = this._daylightSavingAdjust((!inst.currentDay ? new Date(9999, 9, 9) :
  9607. new Date(inst.currentYear, inst.currentMonth, inst.currentDay))),
  9608. minDate = this._getMinMaxDate(inst, "min"),
  9609. maxDate = this._getMinMaxDate(inst, "max"),
  9610. drawMonth = inst.drawMonth - showCurrentAtPos,
  9611. drawYear = inst.drawYear;
  9613. if (drawMonth < 0) {
  9614. drawMonth += 12;
  9615. drawYear--;
  9616. }
  9617. if (maxDate) {
  9618. maxDraw = this._daylightSavingAdjust(new Date(maxDate.getFullYear(),
  9619. maxDate.getMonth() - (numMonths[0] * numMonths[1]) + 1, maxDate.getDate()));
  9620. maxDraw = (minDate && maxDraw < minDate ? minDate : maxDraw);
  9621. while (this._daylightSavingAdjust(new Date(drawYear, drawMonth, 1)) > maxDraw) {
  9622. drawMonth--;
  9623. if (drawMonth < 0) {
  9624. drawMonth = 11;
  9625. drawYear--;
  9626. }
  9627. }
  9628. }
  9629. inst.drawMonth = drawMonth;
  9630. inst.drawYear = drawYear;
  9632. prevText = this._get(inst, "prevText");
  9633. prevText = (!navigationAsDateFormat ? prevText : this.formatDate(prevText,
  9634. this._daylightSavingAdjust(new Date(drawYear, drawMonth - stepMonths, 1)),
  9635. this._getFormatConfig(inst)));
  9637. prev = (this._canAdjustMonth(inst, -1, drawYear, drawMonth) ?
  9638. "<a class='ui-datepicker-prev ui-corner-all' data-handler='prev' data-event='click'" +
  9639. " title='" + prevText + "'><span class='ui-icon ui-icon-circle-triangle-" + ( isRTL ? "e" : "w") + "'>" + prevText + "</span></a>" :
  9640. (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>"));
  9642. nextText = this._get(inst, "nextText");
  9643. nextText = (!navigationAsDateFormat ? nextText : this.formatDate(nextText,
  9644. this._daylightSavingAdjust(new Date(drawYear, drawMonth + stepMonths, 1)),
  9645. this._getFormatConfig(inst)));
  9647. next = (this._canAdjustMonth(inst, +1, drawYear, drawMonth) ?
  9648. "<a class='ui-datepicker-next ui-corner-all' data-handler='next' data-event='click'" +
  9649. " title='" + nextText + "'><span class='ui-icon ui-icon-circle-triangle-" + ( isRTL ? "w" : "e") + "'>" + nextText + "</span></a>" :
  9650. (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>"));
  9652. currentText = this._get(inst, "currentText");
  9653. gotoDate = (this._get(inst, "gotoCurrent") && inst.currentDay ? currentDate : today);
  9654. currentText = (!navigationAsDateFormat ? currentText :
  9655. this.formatDate(currentText, gotoDate, this._getFormatConfig(inst)));
  9657. 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'>" +
  9658. this._get(inst, "closeText") + "</button>" : "");
  9660. buttonPanel = (showButtonPanel) ? "<div class='ui-datepicker-buttonpane ui-widget-content'>" + (isRTL ? controls : "") +
  9661. (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'" +
  9662. ">" + currentText + "</button>" : "") + (isRTL ? "" : controls) + "</div>" : "";
  9664. firstDay = parseInt(this._get(inst, "firstDay"),10);
  9665. firstDay = (isNaN(firstDay) ? 0 : firstDay);
  9667. showWeek = this._get(inst, "showWeek");
  9668. dayNames = this._get(inst, "dayNames");
  9669. dayNamesMin = this._get(inst, "dayNamesMin");
  9670. monthNames = this._get(inst, "monthNames");
  9671. monthNamesShort = this._get(inst, "monthNamesShort");
  9672. beforeShowDay = this._get(inst, "beforeShowDay");
  9673. showOtherMonths = this._get(inst, "showOtherMonths");
  9674. selectOtherMonths = this._get(inst, "selectOtherMonths");
  9675. defaultDate = this._getDefaultDate(inst);
  9676. html = "";
  9677. dow;
  9678. for (row = 0; row < numMonths[0]; row++) {
  9679. group = "";
  9680. this.maxRows = 4;
  9681. for (col = 0; col < numMonths[1]; col++) {
  9682. selectedDate = this._daylightSavingAdjust(new Date(drawYear, drawMonth, inst.selectedDay));
  9683. cornerClass = " ui-corner-all";
  9684. calender = "";
  9685. if (isMultiMonth) {
  9686. calender += "<div class='ui-datepicker-group";
  9687. if (numMonths[1] > 1) {
  9688. switch (col) {
  9689. case 0: calender += " ui-datepicker-group-first";
  9690. cornerClass = " ui-corner-" + (isRTL ? "right" : "left"); break;
  9691. case numMonths[1]-1: calender += " ui-datepicker-group-last";
  9692. cornerClass = " ui-corner-" + (isRTL ? "left" : "right"); break;
  9693. default: calender += " ui-datepicker-group-middle"; cornerClass = ""; break;
  9694. }
  9695. }
  9696. calender += "'>";
  9697. }
  9698. calender += "<div class='ui-datepicker-header ui-widget-header ui-helper-clearfix" + cornerClass + "'>" +
  9699. (/all|left/.test(cornerClass) && row === 0 ? (isRTL ? next : prev) : "") +
  9700. (/all|right/.test(cornerClass) && row === 0 ? (isRTL ? prev : next) : "") +
  9701. this._generateMonthYearHeader(inst, drawMonth, drawYear, minDate, maxDate,
  9702. row > 0 || col > 0, monthNames, monthNamesShort) + // draw month headers
  9703. "</div><table class='ui-datepicker-calendar'><thead>" +
  9704. "<tr>";
  9705. thead = (showWeek ? "<th class='ui-datepicker-week-col'>" + this._get(inst, "weekHeader") + "</th>" : "");
  9706. for (dow = 0; dow < 7; dow++) { // days of the week
  9707. day = (dow + firstDay) % 7;
  9708. thead += "<th scope='col'" + ((dow + firstDay + 6) % 7 >= 5 ? " class='ui-datepicker-week-end'" : "") + ">" +
  9709. "<span title='" + dayNames[day] + "'>" + dayNamesMin[day] + "</span></th>";
  9710. }
  9711. calender += thead + "</tr></thead><tbody>";
  9712. daysInMonth = this._getDaysInMonth(drawYear, drawMonth);
  9713. if (drawYear === inst.selectedYear && drawMonth === inst.selectedMonth) {
  9714. inst.selectedDay = Math.min(inst.selectedDay, daysInMonth);
  9715. }
  9716. leadDays = (this._getFirstDayOfMonth(drawYear, drawMonth) - firstDay + 7) % 7;
  9717. curRows = Math.ceil((leadDays + daysInMonth) / 7); // calculate the number of rows to generate
  9718. numRows = (isMultiMonth ? this.maxRows > curRows ? this.maxRows : curRows : curRows); //If multiple months, use the higher number of rows (see #7043)
  9719. this.maxRows = numRows;
  9720. printDate = this._daylightSavingAdjust(new Date(drawYear, drawMonth, 1 - leadDays));
  9721. for (dRow = 0; dRow < numRows; dRow++) { // create date picker rows
  9722. calender += "<tr>";
  9723. tbody = (!showWeek ? "" : "<td class='ui-datepicker-week-col'>" +
  9724. this._get(inst, "calculateWeek")(printDate) + "</td>");
  9725. for (dow = 0; dow < 7; dow++) { // create date picker days
  9726. daySettings = (beforeShowDay ?
  9727. beforeShowDay.apply((inst.input ? inst.input[0] : null), [printDate]) : [true, ""]);
  9728. otherMonth = (printDate.getMonth() !== drawMonth);
  9729. unselectable = (otherMonth && !selectOtherMonths) || !daySettings[0] ||
  9730. (minDate && printDate < minDate) || (maxDate && printDate > maxDate);
  9731. tbody += "<td class='" +
  9732. ((dow + firstDay + 6) % 7 >= 5 ? " ui-datepicker-week-end" : "") + // highlight weekends
  9733. (otherMonth ? " ui-datepicker-other-month" : "") + // highlight days from other months
  9734. ((printDate.getTime() === selectedDate.getTime() && drawMonth === inst.selectedMonth && inst._keyEvent) || // user pressed key
  9735. (defaultDate.getTime() === printDate.getTime() && defaultDate.getTime() === selectedDate.getTime()) ?
  9736. // or defaultDate is current printedDate and defaultDate is selectedDate
  9737. " " + this._dayOverClass : "") + // highlight selected day
  9738. (unselectable ? " " + this._unselectableClass + " ui-state-disabled": "") + // highlight unselectable days
  9739. (otherMonth && !showOtherMonths ? "" : " " + daySettings[1] + // highlight custom dates
  9740. (printDate.getTime() === currentDate.getTime() ? " " + this._currentClass : "") + // highlight selected day
  9741. (printDate.getTime() === today.getTime() ? " ui-datepicker-today" : "")) + "'" + // highlight today (if different)
  9742. ((!otherMonth || showOtherMonths) && daySettings[2] ? " title='" + daySettings[2].replace(/'/g, "&#39;") + "'" : "") + // cell title
  9743. (unselectable ? "" : " data-handler='selectDay' data-event='click' data-month='" + printDate.getMonth() + "' data-year='" + printDate.getFullYear() + "'") + ">" + // actions
  9744. (otherMonth && !showOtherMonths ? "&#xa0;" : // display for other months
  9745. (unselectable ? "<span class='ui-state-default'>" + printDate.getDate() + "</span>" : "<a class='ui-state-default" +
  9746. (printDate.getTime() === today.getTime() ? " ui-state-highlight" : "") +
  9747. (printDate.getTime() === currentDate.getTime() ? " ui-state-active" : "") + // highlight selected day
  9748. (otherMonth ? " ui-priority-secondary" : "") + // distinguish dates from other months
  9749. "' href='#'>" + printDate.getDate() + "</a>")) + "</td>"; // display selectable date
  9750. printDate.setDate(printDate.getDate() + 1);
  9751. printDate = this._daylightSavingAdjust(printDate);
  9752. }
  9753. calender += tbody + "</tr>";
  9754. }
  9755. drawMonth++;
  9756. if (drawMonth > 11) {
  9757. drawMonth = 0;
  9758. drawYear++;
  9759. }
  9760. calender += "</tbody></table>" + (isMultiMonth ? "</div>" +
  9761. ((numMonths[0] > 0 && col === numMonths[1]-1) ? "<div class='ui-datepicker-row-break'></div>" : "") : "");
  9762. group += calender;
  9763. }
  9764. html += group;
  9765. }
  9766. html += buttonPanel;
  9767. inst._keyEvent = false;
  9768. return html;
  9769. },
  9771. /* Generate the month and year header. */
  9772. _generateMonthYearHeader: function(inst, drawMonth, drawYear, minDate, maxDate,
  9773. secondary, monthNames, monthNamesShort) {
  9775. var inMinYear, inMaxYear, month, years, thisYear, determineYear, year, endYear,
  9776. changeMonth = this._get(inst, "changeMonth"),
  9777. changeYear = this._get(inst, "changeYear"),
  9778. showMonthAfterYear = this._get(inst, "showMonthAfterYear"),
  9779. html = "<div class='ui-datepicker-title'>",
  9780. monthHtml = "";
  9782. // month selection
  9783. if (secondary || !changeMonth) {
  9784. monthHtml += "<span class='ui-datepicker-month'>" + monthNames[drawMonth] + "</span>";
  9785. } else {
  9786. inMinYear = (minDate && minDate.getFullYear() === drawYear);
  9787. inMaxYear = (maxDate && maxDate.getFullYear() === drawYear);
  9788. monthHtml += "<select class='ui-datepicker-month' data-handler='selectMonth' data-event='change'>";
  9789. for ( month = 0; month < 12; month++) {
  9790. if ((!inMinYear || month >= minDate.getMonth()) && (!inMaxYear || month <= maxDate.getMonth())) {
  9791. monthHtml += "<option value='" + month + "'" +
  9792. (month === drawMonth ? " selected='selected'" : "") +
  9793. ">" + monthNamesShort[month] + "</option>";
  9794. }
  9795. }
  9796. monthHtml += "</select>";
  9797. }
  9799. if (!showMonthAfterYear) {
  9800. html += monthHtml + (secondary || !(changeMonth && changeYear) ? "&#xa0;" : "");
  9801. }
  9803. // year selection
  9804. if ( !inst.yearshtml ) {
  9805. inst.yearshtml = "";
  9806. if (secondary || !changeYear) {
  9807. html += "<span class='ui-datepicker-year'>" + drawYear + "</span>";
  9808. } else {
  9809. // determine range of years to display
  9810. years = this._get(inst, "yearRange").split(":");
  9811. thisYear = new Date().getFullYear();
  9812. determineYear = function(value) {
  9813. var year = (value.match(/c[+\-].*/) ? drawYear + parseInt(value.substring(1), 10) :
  9814. (value.match(/[+\-].*/) ? thisYear + parseInt(value, 10) :
  9815. parseInt(value, 10)));
  9816. return (isNaN(year) ? thisYear : year);
  9817. };
  9818. year = determineYear(years[0]);
  9819. endYear = Math.max(year, determineYear(years[1] || ""));
  9820. year = (minDate ? Math.max(year, minDate.getFullYear()) : year);
  9821. endYear = (maxDate ? Math.min(endYear, maxDate.getFullYear()) : endYear);
  9822. inst.yearshtml += "<select class='ui-datepicker-year' data-handler='selectYear' data-event='change'>";
  9823. for (; year <= endYear; year++) {
  9824. inst.yearshtml += "<option value='" + year + "'" +
  9825. (year === drawYear ? " selected='selected'" : "") +
  9826. ">" + year + "</option>";
  9827. }
  9828. inst.yearshtml += "</select>";
  9830. html += inst.yearshtml;
  9831. inst.yearshtml = null;
  9832. }
  9833. }
  9835. html += this._get(inst, "yearSuffix");
  9836. if (showMonthAfterYear) {
  9837. html += (secondary || !(changeMonth && changeYear) ? "&#xa0;" : "") + monthHtml;
  9838. }
  9839. html += "</div>"; // Close datepicker_header
  9840. return html;
  9841. },
  9843. /* Adjust one of the date sub-fields. */
  9844. _adjustInstDate: function(inst, offset, period) {
  9845. var year = inst.drawYear + (period === "Y" ? offset : 0),
  9846. month = inst.drawMonth + (period === "M" ? offset : 0),
  9847. day = Math.min(inst.selectedDay, this._getDaysInMonth(year, month)) + (period === "D" ? offset : 0),
  9848. date = this._restrictMinMax(inst, this._daylightSavingAdjust(new Date(year, month, day)));
  9850. inst.selectedDay = date.getDate();
  9851. inst.drawMonth = inst.selectedMonth = date.getMonth();
  9852. inst.drawYear = inst.selectedYear = date.getFullYear();
  9853. if (period === "M" || period === "Y") {
  9854. this._notifyChange(inst);
  9855. }
  9856. },
  9858. /* Ensure a date is within any min/max bounds. */
  9859. _restrictMinMax: function(inst, date) {
  9860. var minDate = this._getMinMaxDate(inst, "min"),
  9861. maxDate = this._getMinMaxDate(inst, "max"),
  9862. newDate = (minDate && date < minDate ? minDate : date);
  9863. return (maxDate && newDate > maxDate ? maxDate : newDate);
  9864. },
  9866. /* Notify change of month/year. */
  9867. _notifyChange: function(inst) {
  9868. var onChange = this._get(inst, "onChangeMonthYear");
  9869. if (onChange) {
  9870. onChange.apply((inst.input ? inst.input[0] : null),
  9871. [inst.selectedYear, inst.selectedMonth + 1, inst]);
  9872. }
  9873. },
  9875. /* Determine the number of months to show. */
  9876. _getNumberOfMonths: function(inst) {
  9877. var numMonths = this._get(inst, "numberOfMonths");
  9878. return (numMonths == null ? [1, 1] : (typeof numMonths === "number" ? [1, numMonths] : numMonths));
  9879. },
  9881. /* Determine the current maximum date - ensure no time components are set. */
  9882. _getMinMaxDate: function(inst, minMax) {
  9883. return this._determineDate(inst, this._get(inst, minMax + "Date"), null);
  9884. },
  9886. /* Find the number of days in a given month. */
  9887. _getDaysInMonth: function(year, month) {
  9888. return 32 - this._daylightSavingAdjust(new Date(year, month, 32)).getDate();
  9889. },
  9891. /* Find the day of the week of the first of a month. */
  9892. _getFirstDayOfMonth: function(year, month) {
  9893. return new Date(year, month, 1).getDay();
  9894. },
  9896. /* Determines if we should allow a "next/prev" month display change. */
  9897. _canAdjustMonth: function(inst, offset, curYear, curMonth) {
  9898. var numMonths = this._getNumberOfMonths(inst),
  9899. date = this._daylightSavingAdjust(new Date(curYear,
  9900. curMonth + (offset < 0 ? offset : numMonths[0] * numMonths[1]), 1));
  9902. if (offset < 0) {
  9903. date.setDate(this._getDaysInMonth(date.getFullYear(), date.getMonth()));
  9904. }
  9905. return this._isInRange(inst, date);
  9906. },
  9908. /* Is the given date in the accepted range? */
  9909. _isInRange: function(inst, date) {
  9910. var yearSplit, currentYear,
  9911. minDate = this._getMinMaxDate(inst, "min"),
  9912. maxDate = this._getMinMaxDate(inst, "max"),
  9913. minYear = null,
  9914. maxYear = null,
  9915. years = this._get(inst, "yearRange");
  9916. if (years){
  9917. yearSplit = years.split(":");
  9918. currentYear = new Date().getFullYear();
  9919. minYear = parseInt(yearSplit[0], 10);
  9920. maxYear = parseInt(yearSplit[1], 10);
  9921. if ( yearSplit[0].match(/[+\-].*/) ) {
  9922. minYear += currentYear;
  9923. }
  9924. if ( yearSplit[1].match(/[+\-].*/) ) {
  9925. maxYear += currentYear;
  9926. }
  9927. }
  9929. return ((!minDate || date.getTime() >= minDate.getTime()) &&
  9930. (!maxDate || date.getTime() <= maxDate.getTime()) &&
  9931. (!minYear || date.getFullYear() >= minYear) &&
  9932. (!maxYear || date.getFullYear() <= maxYear));
  9933. },
  9935. /* Provide the configuration settings for formatting/parsing. */
  9936. _getFormatConfig: function(inst) {
  9937. var shortYearCutoff = this._get(inst, "shortYearCutoff");
  9938. shortYearCutoff = (typeof shortYearCutoff !== "string" ? shortYearCutoff :
  9939. new Date().getFullYear() % 100 + parseInt(shortYearCutoff, 10));
  9940. return {shortYearCutoff: shortYearCutoff,
  9941. dayNamesShort: this._get(inst, "dayNamesShort"), dayNames: this._get(inst, "dayNames"),
  9942. monthNamesShort: this._get(inst, "monthNamesShort"), monthNames: this._get(inst, "monthNames")};
  9943. },
  9945. /* Format the given date for display. */
  9946. _formatDate: function(inst, day, month, year) {
  9947. if (!day) {
  9948. inst.currentDay = inst.selectedDay;
  9949. inst.currentMonth = inst.selectedMonth;
  9950. inst.currentYear = inst.selectedYear;
  9951. }
  9952. var date = (day ? (typeof day === "object" ? day :
  9953. this._daylightSavingAdjust(new Date(year, month, day))) :
  9954. this._daylightSavingAdjust(new Date(inst.currentYear, inst.currentMonth, inst.currentDay)));
  9955. return this.formatDate(this._get(inst, "dateFormat"), date, this._getFormatConfig(inst));
  9956. }
  9957. });
  9959. /*
  9960. * Bind hover events for datepicker elements.
  9961. * Done via delegate so the binding only occurs once in the lifetime of the parent div.
  9962. * Global datepicker_instActive, set by _updateDatepicker allows the handlers to find their way back to the active picker.
  9963. */
  9964. function datepicker_bindHover(dpDiv) {
  9965. var selector = "button, .ui-datepicker-prev, .ui-datepicker-next, .ui-datepicker-calendar td a";
  9966. return dpDiv.delegate(selector, "mouseout", function() {
  9967. $(this).removeClass("ui-state-hover");
  9968. if (this.className.indexOf("ui-datepicker-prev") !== -1) {
  9969. $(this).removeClass("ui-datepicker-prev-hover");
  9970. }
  9971. if (this.className.indexOf("ui-datepicker-next") !== -1) {
  9972. $(this).removeClass("ui-datepicker-next-hover");
  9973. }
  9974. })
  9975. .delegate( selector, "mouseover", datepicker_handleMouseover );
  9976. }
  9978. function datepicker_handleMouseover() {
  9979. if (!$.datepicker._isDisabledDatepicker( datepicker_instActive.inline? datepicker_instActive.dpDiv.parent()[0] : datepicker_instActive.input[0])) {
  9980. $(this).parents(".ui-datepicker-calendar").find("a").removeClass("ui-state-hover");
  9981. $(this).addClass("ui-state-hover");
  9982. if (this.className.indexOf("ui-datepicker-prev") !== -1) {
  9983. $(this).addClass("ui-datepicker-prev-hover");
  9984. }
  9985. if (this.className.indexOf("ui-datepicker-next") !== -1) {
  9986. $(this).addClass("ui-datepicker-next-hover");
  9987. }
  9988. }
  9989. }
  9991. /* jQuery extend now ignores nulls! */
  9992. function datepicker_extendRemove(target, props) {
  9993. $.extend(target, props);
  9994. for (var name in props) {
  9995. if (props[name] == null) {
  9996. target[name] = props[name];
  9997. }
  9998. }
  9999. return target;
  10000. }
  10002. /* Invoke the datepicker functionality.
  10003. @param options string - a command, optionally followed by additional parameters or
  10004. Object - settings for attaching new datepicker functionality
  10005. @return jQuery object */
  10006. $.fn.datepicker = function(options){
  10008. /* Verify an empty collection wasn't passed - Fixes #6976 */
  10009. if ( !this.length ) {
  10010. return this;
  10011. }
  10013. /* Initialise the date picker. */
  10014. if (!$.datepicker.initialized) {
  10015. $(document).mousedown($.datepicker._checkExternalClick);
  10016. $.datepicker.initialized = true;
  10017. }
  10019. /* Append datepicker main container to body if not exist. */
  10020. if ($("#"+$.datepicker._mainDivId).length === 0) {
  10021. $("body").append($.datepicker.dpDiv);
  10022. }
  10024. var otherArgs = Array.prototype.slice.call(arguments, 1);
  10025. if (typeof options === "string" && (options === "isDisabled" || options === "getDate" || options === "widget")) {
  10026. return $.datepicker["_" + options + "Datepicker"].
  10027. apply($.datepicker, [this[0]].concat(otherArgs));
  10028. }
  10029. if (options === "option" && arguments.length === 2 && typeof arguments[1] === "string") {
  10030. return $.datepicker["_" + options + "Datepicker"].
  10031. apply($.datepicker, [this[0]].concat(otherArgs));
  10032. }
  10033. return this.each(function() {
  10034. typeof options === "string" ?
  10035. $.datepicker["_" + options + "Datepicker"].
  10036. apply($.datepicker, [this].concat(otherArgs)) :
  10037. $.datepicker._attachDatepicker(this, options);
  10038. });
  10039. };
  10041. $.datepicker = new Datepicker(); // singleton instance
  10042. $.datepicker.initialized = false;
  10043. $.datepicker.uuid = new Date().getTime();
  10044. $.datepicker.version = "1.11.4";
  10046. var datepicker = $.datepicker;
  10049. /*!
  10050. * jQuery UI Dialog 1.11.4
  10051. * http://jqueryui.com
  10052. *
  10053. * Copyright jQuery Foundation and other contributors
  10054. * Released under the MIT license.
  10055. * http://jquery.org/license
  10056. *
  10057. * http://api.jqueryui.com/dialog/
  10058. */
  10061. var dialog = $.widget( "ui.dialog", {
  10062. version: "1.11.4",
  10063. options: {
  10064. appendTo: "body",
  10065. autoOpen: true,
  10066. buttons: [],
  10067. closeOnEscape: true,
  10068. closeText: "Close",
  10069. dialogClass: "",
  10070. draggable: true,
  10071. hide: null,
  10072. height: "auto",
  10073. maxHeight: null,
  10074. maxWidth: null,
  10075. minHeight: 150,
  10076. minWidth: 150,
  10077. modal: false,
  10078. position: {
  10079. my: "center",
  10080. at: "center",
  10081. of: window,
  10082. collision: "fit",
  10083. // Ensure the titlebar is always visible
  10084. using: function( pos ) {
  10085. var topOffset = $( this ).css( pos ).offset().top;
  10086. if ( topOffset < 0 ) {
  10087. $( this ).css( "top", pos.top - topOffset );
  10088. }
  10089. }
  10090. },
  10091. resizable: true,
  10092. show: null,
  10093. title: null,
  10094. width: 300,
  10096. // callbacks
  10097. beforeClose: null,
  10098. close: null,
  10099. drag: null,
  10100. dragStart: null,
  10101. dragStop: null,
  10102. focus: null,
  10103. open: null,
  10104. resize: null,
  10105. resizeStart: null,
  10106. resizeStop: null
  10107. },
  10109. sizeRelatedOptions: {
  10110. buttons: true,
  10111. height: true,
  10112. maxHeight: true,
  10113. maxWidth: true,
  10114. minHeight: true,
  10115. minWidth: true,
  10116. width: true
  10117. },
  10119. resizableRelatedOptions: {
  10120. maxHeight: true,
  10121. maxWidth: true,
  10122. minHeight: true,
  10123. minWidth: true
  10124. },
  10126. _create: function() {
  10127. this.originalCss = {
  10128. display: this.element[ 0 ].style.display,
  10129. width: this.element[ 0 ].style.width,
  10130. minHeight: this.element[ 0 ].style.minHeight,
  10131. maxHeight: this.element[ 0 ].style.maxHeight,
  10132. height: this.element[ 0 ].style.height
  10133. };
  10134. this.originalPosition = {
  10135. parent: this.element.parent(),
  10136. index: this.element.parent().children().index( this.element )
  10137. };
  10138. this.originalTitle = this.element.attr( "title" );
  10139. this.options.title = this.options.title || this.originalTitle;
  10141. this._createWrapper();
  10143. this.element
  10144. .show()
  10145. .removeAttr( "title" )
  10146. .addClass( "ui-dialog-content ui-widget-content" )
  10147. .appendTo( this.uiDialog );
  10149. this._createTitlebar();
  10150. this._createButtonPane();
  10152. if ( this.options.draggable && $.fn.draggable ) {
  10153. this._makeDraggable();
  10154. }
  10155. if ( this.options.resizable && $.fn.resizable ) {
  10156. this._makeResizable();
  10157. }
  10159. this._isOpen = false;
  10161. this._trackFocus();
  10162. },
  10164. _init: function() {
  10165. if ( this.options.autoOpen ) {
  10166. this.open();
  10167. }
  10168. },
  10170. _appendTo: function() {
  10171. var element = this.options.appendTo;
  10172. if ( element && (element.jquery || element.nodeType) ) {
  10173. return $( element );
  10174. }
  10175. return this.document.find( element || "body" ).eq( 0 );
  10176. },
  10178. _destroy: function() {
  10179. var next,
  10180. originalPosition = this.originalPosition;
  10182. this._untrackInstance();
  10183. this._destroyOverlay();
  10185. this.element
  10186. .removeUniqueId()
  10187. .removeClass( "ui-dialog-content ui-widget-content" )
  10188. .css( this.originalCss )
  10189. // Without detaching first, the following becomes really slow
  10190. .detach();
  10192. this.uiDialog.stop( true, true ).remove();
  10194. if ( this.originalTitle ) {
  10195. this.element.attr( "title", this.originalTitle );
  10196. }
  10198. next = originalPosition.parent.children().eq( originalPosition.index );
  10199. // Don't try to place the dialog next to itself (#8613)
  10200. if ( next.length && next[ 0 ] !== this.element[ 0 ] ) {
  10201. next.before( this.element );
  10202. } else {
  10203. originalPosition.parent.append( this.element );
  10204. }
  10205. },
  10207. widget: function() {
  10208. return this.uiDialog;
  10209. },
  10211. disable: $.noop,
  10212. enable: $.noop,
  10214. close: function( event ) {
  10215. var activeElement,
  10216. that = this;
  10218. if ( !this._isOpen || this._trigger( "beforeClose", event ) === false ) {
  10219. return;
  10220. }
  10222. this._isOpen = false;
  10223. this._focusedElement = null;
  10224. this._destroyOverlay();
  10225. this._untrackInstance();
  10227. if ( !this.opener.filter( ":focusable" ).focus().length ) {
  10229. // support: IE9
  10230. // IE9 throws an "Unspecified error" accessing document.activeElement from an <iframe>
  10231. try {
  10232. activeElement = this.document[ 0 ].activeElement;
  10234. // Support: IE9, IE10
  10235. // If the <body> is blurred, IE will switch windows, see #4520
  10236. if ( activeElement && activeElement.nodeName.toLowerCase() !== "body" ) {
  10238. // Hiding a focused element doesn't trigger blur in WebKit
  10239. // so in case we have nothing to focus on, explicitly blur the active element
  10240. // https://bugs.webkit.org/show_bug.cgi?id=47182
  10241. $( activeElement ).blur();
  10242. }
  10243. } catch ( error ) {}
  10244. }
  10246. this._hide( this.uiDialog, this.options.hide, function() {
  10247. that._trigger( "close", event );
  10248. });
  10249. },
  10251. isOpen: function() {
  10252. return this._isOpen;
  10253. },
  10255. moveToTop: function() {
  10256. this._moveToTop();
  10257. },
  10259. _moveToTop: function( event, silent ) {
  10260. var moved = false,
  10261. zIndices = this.uiDialog.siblings( ".ui-front:visible" ).map(function() {
  10262. return +$( this ).css( "z-index" );
  10263. }).get(),
  10264. zIndexMax = Math.max.apply( null, zIndices );
  10266. if ( zIndexMax >= +this.uiDialog.css( "z-index" ) ) {
  10267. this.uiDialog.css( "z-index", zIndexMax + 1 );
  10268. moved = true;
  10269. }
  10271. if ( moved && !silent ) {
  10272. this._trigger( "focus", event );
  10273. }
  10274. return moved;
  10275. },
  10277. open: function() {
  10278. var that = this;
  10279. if ( this._isOpen ) {
  10280. if ( this._moveToTop() ) {
  10281. this._focusTabbable();
  10282. }
  10283. return;
  10284. }
  10286. this._isOpen = true;
  10287. this.opener = $( this.document[ 0 ].activeElement );
  10289. this._size();
  10290. this._position();
  10291. this._createOverlay();
  10292. this._moveToTop( null, true );
  10294. // Ensure the overlay is moved to the top with the dialog, but only when
  10295. // opening. The overlay shouldn't move after the dialog is open so that
  10296. // modeless dialogs opened after the modal dialog stack properly.
  10297. if ( this.overlay ) {
  10298. this.overlay.css( "z-index", this.uiDialog.css( "z-index" ) - 1 );
  10299. }
  10301. this._show( this.uiDialog, this.options.show, function() {
  10302. that._focusTabbable();
  10303. that._trigger( "focus" );
  10304. });
  10306. // Track the dialog immediately upon openening in case a focus event
  10307. // somehow occurs outside of the dialog before an element inside the
  10308. // dialog is focused (#10152)
  10309. this._makeFocusTarget();
  10311. this._trigger( "open" );
  10312. },
  10314. _focusTabbable: function() {
  10315. // Set focus to the first match:
  10316. // 1. An element that was focused previously
  10317. // 2. First element inside the dialog matching [autofocus]
  10318. // 3. Tabbable element inside the content element
  10319. // 4. Tabbable element inside the buttonpane
  10320. // 5. The close button
  10321. // 6. The dialog itself
  10322. var hasFocus = this._focusedElement;
  10323. if ( !hasFocus ) {
  10324. hasFocus = this.element.find( "[autofocus]" );
  10325. }
  10326. if ( !hasFocus.length ) {
  10327. hasFocus = this.element.find( ":tabbable" );
  10328. }
  10329. if ( !hasFocus.length ) {
  10330. hasFocus = this.uiDialogButtonPane.find( ":tabbable" );
  10331. }
  10332. if ( !hasFocus.length ) {
  10333. hasFocus = this.uiDialogTitlebarClose.filter( ":tabbable" );
  10334. }
  10335. if ( !hasFocus.length ) {
  10336. hasFocus = this.uiDialog;
  10337. }
  10338. hasFocus.eq( 0 ).focus();
  10339. },
  10341. _keepFocus: function( event ) {
  10342. function checkFocus() {
  10343. var activeElement = this.document[0].activeElement,
  10344. isActive = this.uiDialog[0] === activeElement ||
  10345. $.contains( this.uiDialog[0], activeElement );
  10346. if ( !isActive ) {
  10347. this._focusTabbable();
  10348. }
  10349. }
  10350. event.preventDefault();
  10351. checkFocus.call( this );
  10352. // support: IE
  10353. // IE <= 8 doesn't prevent moving focus even with event.preventDefault()
  10354. // so we check again later
  10355. this._delay( checkFocus );
  10356. },
  10358. _createWrapper: function() {
  10359. this.uiDialog = $("<div>")
  10360. .addClass( "ui-dialog ui-widget ui-widget-content ui-corner-all ui-front " +
  10361. this.options.dialogClass )
  10362. .hide()
  10363. .attr({
  10364. // Setting tabIndex makes the div focusable
  10365. tabIndex: -1,
  10366. role: "dialog"
  10367. })
  10368. .appendTo( this._appendTo() );
  10370. this._on( this.uiDialog, {
  10371. keydown: function( event ) {
  10372. if ( this.options.closeOnEscape && !event.isDefaultPrevented() && event.keyCode &&
  10373. event.keyCode === $.ui.keyCode.ESCAPE ) {
  10374. event.preventDefault();
  10375. this.close( event );
  10376. return;
  10377. }
  10379. // prevent tabbing out of dialogs
  10380. if ( event.keyCode !== $.ui.keyCode.TAB || event.isDefaultPrevented() ) {
  10381. return;
  10382. }
  10383. var tabbables = this.uiDialog.find( ":tabbable" ),
  10384. first = tabbables.filter( ":first" ),
  10385. last = tabbables.filter( ":last" );
  10387. if ( ( event.target === last[0] || event.target === this.uiDialog[0] ) && !event.shiftKey ) {
  10388. this._delay(function() {
  10389. first.focus();
  10390. });
  10391. event.preventDefault();
  10392. } else if ( ( event.target === first[0] || event.target === this.uiDialog[0] ) && event.shiftKey ) {
  10393. this._delay(function() {
  10394. last.focus();
  10395. });
  10396. event.preventDefault();
  10397. }
  10398. },
  10399. mousedown: function( event ) {
  10400. if ( this._moveToTop( event ) ) {
  10401. this._focusTabbable();
  10402. }
  10403. }
  10404. });
  10406. // We assume that any existing aria-describedby attribute means
  10407. // that the dialog content is marked up properly
  10408. // otherwise we brute force the content as the description
  10409. if ( !this.element.find( "[aria-describedby]" ).length ) {
  10410. this.uiDialog.attr({
  10411. "aria-describedby": this.element.uniqueId().attr( "id" )
  10412. });
  10413. }
  10414. },
  10416. _createTitlebar: function() {
  10417. var uiDialogTitle;
  10419. this.uiDialogTitlebar = $( "<div>" )
  10420. .addClass( "ui-dialog-titlebar ui-widget-header ui-corner-all ui-helper-clearfix" )
  10421. .prependTo( this.uiDialog );
  10422. this._on( this.uiDialogTitlebar, {
  10423. mousedown: function( event ) {
  10424. // Don't prevent click on close button (#8838)
  10425. // Focusing a dialog that is partially scrolled out of view
  10426. // causes the browser to scroll it into view, preventing the click event
  10427. if ( !$( event.target ).closest( ".ui-dialog-titlebar-close" ) ) {
  10428. // Dialog isn't getting focus when dragging (#8063)
  10429. this.uiDialog.focus();
  10430. }
  10431. }
  10432. });
  10434. // support: IE
  10435. // Use type="button" to prevent enter keypresses in textboxes from closing the
  10436. // dialog in IE (#9312)
  10437. this.uiDialogTitlebarClose = $( "<button type='button'></button>" )
  10438. .button({
  10439. label: this.options.closeText,
  10440. icons: {
  10441. primary: "ui-icon-closethick"
  10442. },
  10443. text: false
  10444. })
  10445. .addClass( "ui-dialog-titlebar-close" )
  10446. .appendTo( this.uiDialogTitlebar );
  10447. this._on( this.uiDialogTitlebarClose, {
  10448. click: function( event ) {
  10449. event.preventDefault();
  10450. this.close( event );
  10451. }
  10452. });
  10454. uiDialogTitle = $( "<span>" )
  10455. .uniqueId()
  10456. .addClass( "ui-dialog-title" )
  10457. .prependTo( this.uiDialogTitlebar );
  10458. this._title( uiDialogTitle );
  10460. this.uiDialog.attr({
  10461. "aria-labelledby": uiDialogTitle.attr( "id" )
  10462. });
  10463. },
  10465. _title: function( title ) {
  10466. if ( !this.options.title ) {
  10467. title.html( "&#160;" );
  10468. }
  10469. title.text( this.options.title );
  10470. },
  10472. _createButtonPane: function() {
  10473. this.uiDialogButtonPane = $( "<div>" )
  10474. .addClass( "ui-dialog-buttonpane ui-widget-content ui-helper-clearfix" );
  10476. this.uiButtonSet = $( "<div>" )
  10477. .addClass( "ui-dialog-buttonset" )
  10478. .appendTo( this.uiDialogButtonPane );
  10480. this._createButtons();
  10481. },
  10483. _createButtons: function() {
  10484. var that = this,
  10485. buttons = this.options.buttons;
  10487. // if we already have a button pane, remove it
  10488. this.uiDialogButtonPane.remove();
  10489. this.uiButtonSet.empty();
  10491. if ( $.isEmptyObject( buttons ) || ($.isArray( buttons ) && !buttons.length) ) {
  10492. this.uiDialog.removeClass( "ui-dialog-buttons" );
  10493. return;
  10494. }
  10496. $.each( buttons, function( name, props ) {
  10497. var click, buttonOptions;
  10498. props = $.isFunction( props ) ?
  10499. { click: props, text: name } :
  10500. props;
  10501. // Default to a non-submitting button
  10502. props = $.extend( { type: "button" }, props );
  10503. // Change the context for the click callback to be the main element
  10504. click = props.click;
  10505. props.click = function() {
  10506. click.apply( that.element[ 0 ], arguments );
  10507. };
  10508. buttonOptions = {
  10509. icons: props.icons,
  10510. text: props.showText
  10511. };
  10512. delete props.icons;
  10513. delete props.showText;
  10514. $( "<button></button>", props )
  10515. .button( buttonOptions )
  10516. .appendTo( that.uiButtonSet );
  10517. });
  10518. this.uiDialog.addClass( "ui-dialog-buttons" );
  10519. this.uiDialogButtonPane.appendTo( this.uiDialog );
  10520. },
  10522. _makeDraggable: function() {
  10523. var that = this,
  10524. options = this.options;
  10526. function filteredUi( ui ) {
  10527. return {
  10528. position: ui.position,
  10529. offset: ui.offset
  10530. };
  10531. }
  10533. this.uiDialog.draggable({
  10534. cancel: ".ui-dialog-content, .ui-dialog-titlebar-close",
  10535. handle: ".ui-dialog-titlebar",
  10536. containment: "document",
  10537. start: function( event, ui ) {
  10538. $( this ).addClass( "ui-dialog-dragging" );
  10539. that._blockFrames();
  10540. that._trigger( "dragStart", event, filteredUi( ui ) );
  10541. },
  10542. drag: function( event, ui ) {
  10543. that._trigger( "drag", event, filteredUi( ui ) );
  10544. },
  10545. stop: function( event, ui ) {
  10546. var left = ui.offset.left - that.document.scrollLeft(),
  10547. top = ui.offset.top - that.document.scrollTop();
  10549. options.position = {
  10550. my: "left top",
  10551. at: "left" + (left >= 0 ? "+" : "") + left + " " +
  10552. "top" + (top >= 0 ? "+" : "") + top,
  10553. of: that.window
  10554. };
  10555. $( this ).removeClass( "ui-dialog-dragging" );
  10556. that._unblockFrames();
  10557. that._trigger( "dragStop", event, filteredUi( ui ) );
  10558. }
  10559. });
  10560. },
  10562. _makeResizable: function() {
  10563. var that = this,
  10564. options = this.options,
  10565. handles = options.resizable,
  10566. // .ui-resizable has position: relative defined in the stylesheet
  10567. // but dialogs have to use absolute or fixed positioning
  10568. position = this.uiDialog.css("position"),
  10569. resizeHandles = typeof handles === "string" ?
  10570. handles :
  10571. "n,e,s,w,se,sw,ne,nw";
  10573. function filteredUi( ui ) {
  10574. return {
  10575. originalPosition: ui.originalPosition,
  10576. originalSize: ui.originalSize,
  10577. position: ui.position,
  10578. size: ui.size
  10579. };
  10580. }
  10582. this.uiDialog.resizable({
  10583. cancel: ".ui-dialog-content",
  10584. containment: "document",
  10585. alsoResize: this.element,
  10586. maxWidth: options.maxWidth,
  10587. maxHeight: options.maxHeight,
  10588. minWidth: options.minWidth,
  10589. minHeight: this._minHeight(),
  10590. handles: resizeHandles,
  10591. start: function( event, ui ) {
  10592. $( this ).addClass( "ui-dialog-resizing" );
  10593. that._blockFrames();
  10594. that._trigger( "resizeStart", event, filteredUi( ui ) );
  10595. },
  10596. resize: function( event, ui ) {
  10597. that._trigger( "resize", event, filteredUi( ui ) );
  10598. },
  10599. stop: function( event, ui ) {
  10600. var offset = that.uiDialog.offset(),
  10601. left = offset.left - that.document.scrollLeft(),
  10602. top = offset.top - that.document.scrollTop();
  10604. options.height = that.uiDialog.height();
  10605. options.width = that.uiDialog.width();
  10606. options.position = {
  10607. my: "left top",
  10608. at: "left" + (left >= 0 ? "+" : "") + left + " " +
  10609. "top" + (top >= 0 ? "+" : "") + top,
  10610. of: that.window
  10611. };
  10612. $( this ).removeClass( "ui-dialog-resizing" );
  10613. that._unblockFrames();
  10614. that._trigger( "resizeStop", event, filteredUi( ui ) );
  10615. }
  10616. })
  10617. .css( "position", position );
  10618. },
  10620. _trackFocus: function() {
  10621. this._on( this.widget(), {
  10622. focusin: function( event ) {
  10623. this._makeFocusTarget();
  10624. this._focusedElement = $( event.target );
  10625. }
  10626. });
  10627. },
  10629. _makeFocusTarget: function() {
  10630. this._untrackInstance();
  10631. this._trackingInstances().unshift( this );
  10632. },
  10634. _untrackInstance: function() {
  10635. var instances = this._trackingInstances(),
  10636. exists = $.inArray( this, instances );
  10637. if ( exists !== -1 ) {
  10638. instances.splice( exists, 1 );
  10639. }
  10640. },
  10642. _trackingInstances: function() {
  10643. var instances = this.document.data( "ui-dialog-instances" );
  10644. if ( !instances ) {
  10645. instances = [];
  10646. this.document.data( "ui-dialog-instances", instances );
  10647. }
  10648. return instances;
  10649. },
  10651. _minHeight: function() {
  10652. var options = this.options;
  10654. return options.height === "auto" ?
  10655. options.minHeight :
  10656. Math.min( options.minHeight, options.height );
  10657. },
  10659. _position: function() {
  10660. // Need to show the dialog to get the actual offset in the position plugin
  10661. var isVisible = this.uiDialog.is( ":visible" );
  10662. if ( !isVisible ) {
  10663. this.uiDialog.show();
  10664. }
  10665. this.uiDialog.position( this.options.position );
  10666. if ( !isVisible ) {
  10667. this.uiDialog.hide();
  10668. }
  10669. },
  10671. _setOptions: function( options ) {
  10672. var that = this,
  10673. resize = false,
  10674. resizableOptions = {};
  10676. $.each( options, function( key, value ) {
  10677. that._setOption( key, value );
  10679. if ( key in that.sizeRelatedOptions ) {
  10680. resize = true;
  10681. }
  10682. if ( key in that.resizableRelatedOptions ) {
  10683. resizableOptions[ key ] = value;
  10684. }
  10685. });
  10687. if ( resize ) {
  10688. this._size();
  10689. this._position();
  10690. }
  10691. if ( this.uiDialog.is( ":data(ui-resizable)" ) ) {
  10692. this.uiDialog.resizable( "option", resizableOptions );
  10693. }
  10694. },
  10696. _setOption: function( key, value ) {
  10697. var isDraggable, isResizable,
  10698. uiDialog = this.uiDialog;
  10700. if ( key === "dialogClass" ) {
  10701. uiDialog
  10702. .removeClass( this.options.dialogClass )
  10703. .addClass( value );
  10704. }
  10706. if ( key === "disabled" ) {
  10707. return;
  10708. }
  10710. this._super( key, value );
  10712. if ( key === "appendTo" ) {
  10713. this.uiDialog.appendTo( this._appendTo() );
  10714. }
  10716. if ( key === "buttons" ) {
  10717. this._createButtons();
  10718. }
  10720. if ( key === "closeText" ) {
  10721. this.uiDialogTitlebarClose.button({
  10722. // Ensure that we always pass a string
  10723. label: "" + value
  10724. });
  10725. }
  10727. if ( key === "draggable" ) {
  10728. isDraggable = uiDialog.is( ":data(ui-draggable)" );
  10729. if ( isDraggable && !value ) {
  10730. uiDialog.draggable( "destroy" );
  10731. }
  10733. if ( !isDraggable && value ) {
  10734. this._makeDraggable();
  10735. }
  10736. }
  10738. if ( key === "position" ) {
  10739. this._position();
  10740. }
  10742. if ( key === "resizable" ) {
  10743. // currently resizable, becoming non-resizable
  10744. isResizable = uiDialog.is( ":data(ui-resizable)" );
  10745. if ( isResizable && !value ) {
  10746. uiDialog.resizable( "destroy" );
  10747. }
  10749. // currently resizable, changing handles
  10750. if ( isResizable && typeof value === "string" ) {
  10751. uiDialog.resizable( "option", "handles", value );
  10752. }
  10754. // currently non-resizable, becoming resizable
  10755. if ( !isResizable && value !== false ) {
  10756. this._makeResizable();
  10757. }
  10758. }
  10760. if ( key === "title" ) {
  10761. this._title( this.uiDialogTitlebar.find( ".ui-dialog-title" ) );
  10762. }
  10763. },
  10765. _size: function() {
  10766. // If the user has resized the dialog, the .ui-dialog and .ui-dialog-content
  10767. // divs will both have width and height set, so we need to reset them
  10768. var nonContentHeight, minContentHeight, maxContentHeight,
  10769. options = this.options;
  10771. // Reset content sizing
  10772. this.element.show().css({
  10773. width: "auto",
  10774. minHeight: 0,
  10775. maxHeight: "none",
  10776. height: 0
  10777. });
  10779. if ( options.minWidth > options.width ) {
  10780. options.width = options.minWidth;
  10781. }
  10783. // reset wrapper sizing
  10784. // determine the height of all the non-content elements
  10785. nonContentHeight = this.uiDialog.css({
  10786. height: "auto",
  10787. width: options.width
  10788. })
  10789. .outerHeight();
  10790. minContentHeight = Math.max( 0, options.minHeight - nonContentHeight );
  10791. maxContentHeight = typeof options.maxHeight === "number" ?
  10792. Math.max( 0, options.maxHeight - nonContentHeight ) :
  10793. "none";
  10795. if ( options.height === "auto" ) {
  10796. this.element.css({
  10797. minHeight: minContentHeight,
  10798. maxHeight: maxContentHeight,
  10799. height: "auto"
  10800. });
  10801. } else {
  10802. this.element.height( Math.max( 0, options.height - nonContentHeight ) );
  10803. }
  10805. if ( this.uiDialog.is( ":data(ui-resizable)" ) ) {
  10806. this.uiDialog.resizable( "option", "minHeight", this._minHeight() );
  10807. }
  10808. },
  10810. _blockFrames: function() {
  10811. this.iframeBlocks = this.document.find( "iframe" ).map(function() {
  10812. var iframe = $( this );
  10814. return $( "<div>" )
  10815. .css({
  10816. position: "absolute",
  10817. width: iframe.outerWidth(),
  10818. height: iframe.outerHeight()
  10819. })
  10820. .appendTo( iframe.parent() )
  10821. .offset( iframe.offset() )[0];
  10822. });
  10823. },
  10825. _unblockFrames: function() {
  10826. if ( this.iframeBlocks ) {
  10827. this.iframeBlocks.remove();
  10828. delete this.iframeBlocks;
  10829. }
  10830. },
  10832. _allowInteraction: function( event ) {
  10833. if ( $( event.target ).closest( ".ui-dialog" ).length ) {
  10834. return true;
  10835. }
  10837. // TODO: Remove hack when datepicker implements
  10838. // the .ui-front logic (#8989)
  10839. return !!$( event.target ).closest( ".ui-datepicker" ).length;
  10840. },
  10842. _createOverlay: function() {
  10843. if ( !this.options.modal ) {
  10844. return;
  10845. }
  10847. // We use a delay in case the overlay is created from an
  10848. // event that we're going to be cancelling (#2804)
  10849. var isOpening = true;
  10850. this._delay(function() {
  10851. isOpening = false;
  10852. });
  10854. if ( !this.document.data( "ui-dialog-overlays" ) ) {
  10856. // Prevent use of anchors and inputs
  10857. // Using _on() for an event handler shared across many instances is
  10858. // safe because the dialogs stack and must be closed in reverse order
  10859. this._on( this.document, {
  10860. focusin: function( event ) {
  10861. if ( isOpening ) {
  10862. return;
  10863. }
  10865. if ( !this._allowInteraction( event ) ) {
  10866. event.preventDefault();
  10867. this._trackingInstances()[ 0 ]._focusTabbable();
  10868. }
  10869. }
  10870. });
  10871. }
  10873. this.overlay = $( "<div>" )
  10874. .addClass( "ui-widget-overlay ui-front" )
  10875. .appendTo( this._appendTo() );
  10876. this._on( this.overlay, {
  10877. mousedown: "_keepFocus"
  10878. });
  10879. this.document.data( "ui-dialog-overlays",
  10880. (this.document.data( "ui-dialog-overlays" ) || 0) + 1 );
  10881. },
  10883. _destroyOverlay: function() {
  10884. if ( !this.options.modal ) {
  10885. return;
  10886. }
  10888. if ( this.overlay ) {
  10889. var overlays = this.document.data( "ui-dialog-overlays" ) - 1;
  10891. if ( !overlays ) {
  10892. this.document
  10893. .unbind( "focusin" )
  10894. .removeData( "ui-dialog-overlays" );
  10895. } else {
  10896. this.document.data( "ui-dialog-overlays", overlays );
  10897. }
  10899. this.overlay.remove();
  10900. this.overlay = null;
  10901. }
  10902. }
  10903. });
  10906. /*!
  10907. * jQuery UI Progressbar 1.11.4
  10908. * http://jqueryui.com
  10909. *
  10910. * Copyright jQuery Foundation and other contributors
  10911. * Released under the MIT license.
  10912. * http://jquery.org/license
  10913. *
  10914. * http://api.jqueryui.com/progressbar/
  10915. */
  10918. var progressbar = $.widget( "ui.progressbar", {
  10919. version: "1.11.4",
  10920. options: {
  10921. max: 100,
  10922. value: 0,
  10924. change: null,
  10925. complete: null
  10926. },
  10928. min: 0,
  10930. _create: function() {
  10931. // Constrain initial value
  10932. this.oldValue = this.options.value = this._constrainedValue();
  10934. this.element
  10935. .addClass( "ui-progressbar ui-widget ui-widget-content ui-corner-all" )
  10936. .attr({
  10937. // Only set static values, aria-valuenow and aria-valuemax are
  10938. // set inside _refreshValue()
  10939. role: "progressbar",
  10940. "aria-valuemin": this.min
  10941. });
  10943. this.valueDiv = $( "<div class='ui-progressbar-value ui-widget-header ui-corner-left'></div>" )
  10944. .appendTo( this.element );
  10946. this._refreshValue();
  10947. },
  10949. _destroy: function() {
  10950. this.element
  10951. .removeClass( "ui-progressbar ui-widget ui-widget-content ui-corner-all" )
  10952. .removeAttr( "role" )
  10953. .removeAttr( "aria-valuemin" )
  10954. .removeAttr( "aria-valuemax" )
  10955. .removeAttr( "aria-valuenow" );
  10957. this.valueDiv.remove();
  10958. },
  10960. value: function( newValue ) {
  10961. if ( newValue === undefined ) {
  10962. return this.options.value;
  10963. }
  10965. this.options.value = this._constrainedValue( newValue );
  10966. this._refreshValue();
  10967. },
  10969. _constrainedValue: function( newValue ) {
  10970. if ( newValue === undefined ) {
  10971. newValue = this.options.value;
  10972. }
  10974. this.indeterminate = newValue === false;
  10976. // sanitize value
  10977. if ( typeof newValue !== "number" ) {
  10978. newValue = 0;
  10979. }
  10981. return this.indeterminate ? false :
  10982. Math.min( this.options.max, Math.max( this.min, newValue ) );
  10983. },
  10985. _setOptions: function( options ) {
  10986. // Ensure "value" option is set after other values (like max)
  10987. var value = options.value;
  10988. delete options.value;
  10990. this._super( options );
  10992. this.options.value = this._constrainedValue( value );
  10993. this._refreshValue();
  10994. },
  10996. _setOption: function( key, value ) {
  10997. if ( key === "max" ) {
  10998. // Don't allow a max less than min
  10999. value = Math.max( this.min, value );
  11000. }
  11001. if ( key === "disabled" ) {
  11002. this.element
  11003. .toggleClass( "ui-state-disabled", !!value )
  11004. .attr( "aria-disabled", value );
  11005. }
  11006. this._super( key, value );
  11007. },
  11009. _percentage: function() {
  11010. return this.indeterminate ? 100 : 100 * ( this.options.value - this.min ) / ( this.options.max - this.min );
  11011. },
  11013. _refreshValue: function() {
  11014. var value = this.options.value,
  11015. percentage = this._percentage();
  11017. this.valueDiv
  11018. .toggle( this.indeterminate || value > this.min )
  11019. .toggleClass( "ui-corner-right", value === this.options.max )
  11020. .width( percentage.toFixed(0) + "%" );
  11022. this.element.toggleClass( "ui-progressbar-indeterminate", this.indeterminate );
  11024. if ( this.indeterminate ) {
  11025. this.element.removeAttr( "aria-valuenow" );
  11026. if ( !this.overlayDiv ) {
  11027. this.overlayDiv = $( "<div class='ui-progressbar-overlay'></div>" ).appendTo( this.valueDiv );
  11028. }
  11029. } else {
  11030. this.element.attr({
  11031. "aria-valuemax": this.options.max,
  11032. "aria-valuenow": value
  11033. });
  11034. if ( this.overlayDiv ) {
  11035. this.overlayDiv.remove();
  11036. this.overlayDiv = null;
  11037. }
  11038. }
  11040. if ( this.oldValue !== value ) {
  11041. this.oldValue = value;
  11042. this._trigger( "change" );
  11043. }
  11044. if ( value === this.options.max ) {
  11045. this._trigger( "complete" );
  11046. }
  11047. }
  11048. });
  11051. /*!
  11052. * jQuery UI Selectmenu 1.11.4
  11053. * http://jqueryui.com
  11054. *
  11055. * Copyright jQuery Foundation and other contributors
  11056. * Released under the MIT license.
  11057. * http://jquery.org/license
  11058. *
  11059. * http://api.jqueryui.com/selectmenu
  11060. */
  11063. var selectmenu = $.widget( "ui.selectmenu", {
  11064. version: "1.11.4",
  11065. defaultElement: "<select>",
  11066. options: {
  11067. appendTo: null,
  11068. disabled: null,
  11069. icons: {
  11070. button: "ui-icon-triangle-1-s"
  11071. },
  11072. position: {
  11073. my: "left top",
  11074. at: "left bottom",
  11075. collision: "none"
  11076. },
  11077. width: null,
  11079. // callbacks
  11080. change: null,
  11081. close: null,
  11082. focus: null,
  11083. open: null,
  11084. select: null
  11085. },
  11087. _create: function() {
  11088. var selectmenuId = this.element.uniqueId().attr( "id" );
  11089. this.ids = {
  11090. element: selectmenuId,
  11091. button: selectmenuId + "-button",
  11092. menu: selectmenuId + "-menu"
  11093. };
  11095. this._drawButton();
  11096. this._drawMenu();
  11098. if ( this.options.disabled ) {
  11099. this.disable();
  11100. }
  11101. },
  11103. _drawButton: function() {
  11104. var that = this;
  11106. // Associate existing label with the new button
  11107. this.label = $( "label[for='" + this.ids.element + "']" ).attr( "for", this.ids.button );
  11108. this._on( this.label, {
  11109. click: function( event ) {
  11110. this.button.focus();
  11111. event.preventDefault();
  11112. }
  11113. });
  11115. // Hide original select element
  11116. this.element.hide();
  11118. // Create button
  11119. this.button = $( "<span>", {
  11120. "class": "ui-selectmenu-button ui-widget ui-state-default ui-corner-all",
  11121. tabindex: this.options.disabled ? -1 : 0,
  11122. id: this.ids.button,
  11123. role: "combobox",
  11124. "aria-expanded": "false",
  11125. "aria-autocomplete": "list",
  11126. "aria-owns": this.ids.menu,
  11127. "aria-haspopup": "true"
  11128. })
  11129. .insertAfter( this.element );
  11131. $( "<span>", {
  11132. "class": "ui-icon " + this.options.icons.button
  11133. })
  11134. .prependTo( this.button );
  11136. this.buttonText = $( "<span>", {
  11137. "class": "ui-selectmenu-text"
  11138. })
  11139. .appendTo( this.button );
  11141. this._setText( this.buttonText, this.element.find( "option:selected" ).text() );
  11142. this._resizeButton();
  11144. this._on( this.button, this._buttonEvents );
  11145. this.button.one( "focusin", function() {
  11147. // Delay rendering the menu items until the button receives focus.
  11148. // The menu may have already been rendered via a programmatic open.
  11149. if ( !that.menuItems ) {
  11150. that._refreshMenu();
  11151. }
  11152. });
  11153. this._hoverable( this.button );
  11154. this._focusable( this.button );
  11155. },
  11157. _drawMenu: function() {
  11158. var that = this;
  11160. // Create menu
  11161. this.menu = $( "<ul>", {
  11162. "aria-hidden": "true",
  11163. "aria-labelledby": this.ids.button,
  11164. id: this.ids.menu
  11165. });
  11167. // Wrap menu
  11168. this.menuWrap = $( "<div>", {
  11169. "class": "ui-selectmenu-menu ui-front"
  11170. })
  11171. .append( this.menu )
  11172. .appendTo( this._appendTo() );
  11174. // Initialize menu widget
  11175. this.menuInstance = this.menu
  11176. .menu({
  11177. role: "listbox",
  11178. select: function( event, ui ) {
  11179. event.preventDefault();
  11181. // support: IE8
  11182. // If the item was selected via a click, the text selection
  11183. // will be destroyed in IE
  11184. that._setSelection();
  11186. that._select( ui.item.data( "ui-selectmenu-item" ), event );
  11187. },
  11188. focus: function( event, ui ) {
  11189. var item = ui.item.data( "ui-selectmenu-item" );
  11191. // Prevent inital focus from firing and check if its a newly focused item
  11192. if ( that.focusIndex != null && item.index !== that.focusIndex ) {
  11193. that._trigger( "focus", event, { item: item } );
  11194. if ( !that.isOpen ) {
  11195. that._select( item, event );
  11196. }
  11197. }
  11198. that.focusIndex = item.index;
  11200. that.button.attr( "aria-activedescendant",
  11201. that.menuItems.eq( item.index ).attr( "id" ) );
  11202. }
  11203. })
  11204. .menu( "instance" );
  11206. // Adjust menu styles to dropdown
  11207. this.menu
  11208. .addClass( "ui-corner-bottom" )
  11209. .removeClass( "ui-corner-all" );
  11211. // Don't close the menu on mouseleave
  11212. this.menuInstance._off( this.menu, "mouseleave" );
  11214. // Cancel the menu's collapseAll on document click
  11215. this.menuInstance._closeOnDocumentClick = function() {
  11216. return false;
  11217. };
  11219. // Selects often contain empty items, but never contain dividers
  11220. this.menuInstance._isDivider = function() {
  11221. return false;
  11222. };
  11223. },
  11225. refresh: function() {
  11226. this._refreshMenu();
  11227. this._setText( this.buttonText, this._getSelectedItem().text() );
  11228. if ( !this.options.width ) {
  11229. this._resizeButton();
  11230. }
  11231. },
  11233. _refreshMenu: function() {
  11234. this.menu.empty();
  11236. var item,
  11237. options = this.element.find( "option" );
  11239. if ( !options.length ) {
  11240. return;
  11241. }
  11243. this._parseOptions( options );
  11244. this._renderMenu( this.menu, this.items );
  11246. this.menuInstance.refresh();
  11247. this.menuItems = this.menu.find( "li" ).not( ".ui-selectmenu-optgroup" );
  11249. item = this._getSelectedItem();
  11251. // Update the menu to have the correct item focused
  11252. this.menuInstance.focus( null, item );
  11253. this._setAria( item.data( "ui-selectmenu-item" ) );
  11255. // Set disabled state
  11256. this._setOption( "disabled", this.element.prop( "disabled" ) );
  11257. },
  11259. open: function( event ) {
  11260. if ( this.options.disabled ) {
  11261. return;
  11262. }
  11264. // If this is the first time the menu is being opened, render the items
  11265. if ( !this.menuItems ) {
  11266. this._refreshMenu();
  11267. } else {
  11269. // Menu clears focus on close, reset focus to selected item
  11270. this.menu.find( ".ui-state-focus" ).removeClass( "ui-state-focus" );
  11271. this.menuInstance.focus( null, this._getSelectedItem() );
  11272. }
  11274. this.isOpen = true;
  11275. this._toggleAttr();
  11276. this._resizeMenu();
  11277. this._position();
  11279. this._on( this.document, this._documentClick );
  11281. this._trigger( "open", event );
  11282. },
  11284. _position: function() {
  11285. this.menuWrap.position( $.extend( { of: this.button }, this.options.position ) );
  11286. },
  11288. close: function( event ) {
  11289. if ( !this.isOpen ) {
  11290. return;
  11291. }
  11293. this.isOpen = false;
  11294. this._toggleAttr();
  11296. this.range = null;
  11297. this._off( this.document );
  11299. this._trigger( "close", event );
  11300. },
  11302. widget: function() {
  11303. return this.button;
  11304. },
  11306. menuWidget: function() {
  11307. return this.menu;
  11308. },
  11310. _renderMenu: function( ul, items ) {
  11311. var that = this,
  11312. currentOptgroup = "";
  11314. $.each( items, function( index, item ) {
  11315. if ( item.optgroup !== currentOptgroup ) {
  11316. $( "<li>", {
  11317. "class": "ui-selectmenu-optgroup ui-menu-divider" +
  11318. ( item.element.parent( "optgroup" ).prop( "disabled" ) ?
  11319. " ui-state-disabled" :
  11320. "" ),
  11321. text: item.optgroup
  11322. })
  11323. .appendTo( ul );
  11325. currentOptgroup = item.optgroup;
  11326. }
  11328. that._renderItemData( ul, item );
  11329. });
  11330. },
  11332. _renderItemData: function( ul, item ) {
  11333. return this._renderItem( ul, item ).data( "ui-selectmenu-item", item );
  11334. },
  11336. _renderItem: function( ul, item ) {
  11337. var li = $( "<li>" );
  11339. if ( item.disabled ) {
  11340. li.addClass( "ui-state-disabled" );
  11341. }
  11342. this._setText( li, item.label );
  11344. return li.appendTo( ul );
  11345. },
  11347. _setText: function( element, value ) {
  11348. if ( value ) {
  11349. element.text( value );
  11350. } else {
  11351. element.html( "&#160;" );
  11352. }
  11353. },
  11355. _move: function( direction, event ) {
  11356. var item, next,
  11357. filter = ".ui-menu-item";
  11359. if ( this.isOpen ) {
  11360. item = this.menuItems.eq( this.focusIndex );
  11361. } else {
  11362. item = this.menuItems.eq( this.element[ 0 ].selectedIndex );
  11363. filter += ":not(.ui-state-disabled)";
  11364. }
  11366. if ( direction === "first" || direction === "last" ) {
  11367. next = item[ direction === "first" ? "prevAll" : "nextAll" ]( filter ).eq( -1 );
  11368. } else {
  11369. next = item[ direction + "All" ]( filter ).eq( 0 );
  11370. }
  11372. if ( next.length ) {
  11373. this.menuInstance.focus( event, next );
  11374. }
  11375. },
  11377. _getSelectedItem: function() {
  11378. return this.menuItems.eq( this.element[ 0 ].selectedIndex );
  11379. },
  11381. _toggle: function( event ) {
  11382. this[ this.isOpen ? "close" : "open" ]( event );
  11383. },
  11385. _setSelection: function() {
  11386. var selection;
  11388. if ( !this.range ) {
  11389. return;
  11390. }
  11392. if ( window.getSelection ) {
  11393. selection = window.getSelection();
  11394. selection.removeAllRanges();
  11395. selection.addRange( this.range );
  11397. // support: IE8
  11398. } else {
  11399. this.range.select();
  11400. }
  11402. // support: IE
  11403. // Setting the text selection kills the button focus in IE, but
  11404. // restoring the focus doesn't kill the selection.
  11405. this.button.focus();
  11406. },
  11408. _documentClick: {
  11409. mousedown: function( event ) {
  11410. if ( !this.isOpen ) {
  11411. return;
  11412. }
  11414. if ( !$( event.target ).closest( ".ui-selectmenu-menu, #" + this.ids.button ).length ) {
  11415. this.close( event );
  11416. }
  11417. }
  11418. },
  11420. _buttonEvents: {
  11422. // Prevent text selection from being reset when interacting with the selectmenu (#10144)
  11423. mousedown: function() {
  11424. var selection;
  11426. if ( window.getSelection ) {
  11427. selection = window.getSelection();
  11428. if ( selection.rangeCount ) {
  11429. this.range = selection.getRangeAt( 0 );
  11430. }
  11432. // support: IE8
  11433. } else {
  11434. this.range = document.selection.createRange();
  11435. }
  11436. },
  11438. click: function( event ) {
  11439. this._setSelection();
  11440. this._toggle( event );
  11441. },
  11443. keydown: function( event ) {
  11444. var preventDefault = true;
  11445. switch ( event.keyCode ) {
  11446. case $.ui.keyCode.TAB:
  11447. case $.ui.keyCode.ESCAPE:
  11448. this.close( event );
  11449. preventDefault = false;
  11450. break;
  11451. case $.ui.keyCode.ENTER:
  11452. if ( this.isOpen ) {
  11453. this._selectFocusedItem( event );
  11454. }
  11455. break;
  11456. case $.ui.keyCode.UP:
  11457. if ( event.altKey ) {
  11458. this._toggle( event );
  11459. } else {
  11460. this._move( "prev", event );
  11461. }
  11462. break;
  11463. case $.ui.keyCode.DOWN:
  11464. if ( event.altKey ) {
  11465. this._toggle( event );
  11466. } else {
  11467. this._move( "next", event );
  11468. }
  11469. break;
  11470. case $.ui.keyCode.SPACE:
  11471. if ( this.isOpen ) {
  11472. this._selectFocusedItem( event );
  11473. } else {
  11474. this._toggle( event );
  11475. }
  11476. break;
  11477. case $.ui.keyCode.LEFT:
  11478. this._move( "prev", event );
  11479. break;
  11480. case $.ui.keyCode.RIGHT:
  11481. this._move( "next", event );
  11482. break;
  11483. case $.ui.keyCode.HOME:
  11484. case $.ui.keyCode.PAGE_UP:
  11485. this._move( "first", event );
  11486. break;
  11487. case $.ui.keyCode.END:
  11488. case $.ui.keyCode.PAGE_DOWN:
  11489. this._move( "last", event );
  11490. break;
  11491. default:
  11492. this.menu.trigger( event );
  11493. preventDefault = false;
  11494. }
  11496. if ( preventDefault ) {
  11497. event.preventDefault();
  11498. }
  11499. }
  11500. },
  11502. _selectFocusedItem: function( event ) {
  11503. var item = this.menuItems.eq( this.focusIndex );
  11504. if ( !item.hasClass( "ui-state-disabled" ) ) {
  11505. this._select( item.data( "ui-selectmenu-item" ), event );
  11506. }
  11507. },
  11509. _select: function( item, event ) {
  11510. var oldIndex = this.element[ 0 ].selectedIndex;
  11512. // Change native select element
  11513. this.element[ 0 ].selectedIndex = item.index;
  11514. this._setText( this.buttonText, item.label );
  11515. this._setAria( item );
  11516. this._trigger( "select", event, { item: item } );
  11518. if ( item.index !== oldIndex ) {
  11519. this._trigger( "change", event, { item: item } );
  11520. }
  11522. this.close( event );
  11523. },
  11525. _setAria: function( item ) {
  11526. var id = this.menuItems.eq( item.index ).attr( "id" );
  11528. this.button.attr({
  11529. "aria-labelledby": id,
  11530. "aria-activedescendant": id
  11531. });
  11532. this.menu.attr( "aria-activedescendant", id );
  11533. },
  11535. _setOption: function( key, value ) {
  11536. if ( key === "icons" ) {
  11537. this.button.find( "span.ui-icon" )
  11538. .removeClass( this.options.icons.button )
  11539. .addClass( value.button );
  11540. }
  11542. this._super( key, value );
  11544. if ( key === "appendTo" ) {
  11545. this.menuWrap.appendTo( this._appendTo() );
  11546. }
  11548. if ( key === "disabled" ) {
  11549. this.menuInstance.option( "disabled", value );
  11550. this.button
  11551. .toggleClass( "ui-state-disabled", value )
  11552. .attr( "aria-disabled", value );
  11554. this.element.prop( "disabled", value );
  11555. if ( value ) {
  11556. this.button.attr( "tabindex", -1 );
  11557. this.close();
  11558. } else {
  11559. this.button.attr( "tabindex", 0 );
  11560. }
  11561. }
  11563. if ( key === "width" ) {
  11564. this._resizeButton();
  11565. }
  11566. },
  11568. _appendTo: function() {
  11569. var element = this.options.appendTo;
  11571. if ( element ) {
  11572. element = element.jquery || element.nodeType ?
  11573. $( element ) :
  11574. this.document.find( element ).eq( 0 );
  11575. }
  11577. if ( !element || !element[ 0 ] ) {
  11578. element = this.element.closest( ".ui-front" );
  11579. }
  11581. if ( !element.length ) {
  11582. element = this.document[ 0 ].body;
  11583. }
  11585. return element;
  11586. },
  11588. _toggleAttr: function() {
  11589. this.button
  11590. .toggleClass( "ui-corner-top", this.isOpen )
  11591. .toggleClass( "ui-corner-all", !this.isOpen )
  11592. .attr( "aria-expanded", this.isOpen );
  11593. this.menuWrap.toggleClass( "ui-selectmenu-open", this.isOpen );
  11594. this.menu.attr( "aria-hidden", !this.isOpen );
  11595. },
  11597. _resizeButton: function() {
  11598. var width = this.options.width;
  11600. if ( !width ) {
  11601. width = this.element.show().outerWidth();
  11602. this.element.hide();
  11603. }
  11605. this.button.outerWidth( width );
  11606. },
  11608. _resizeMenu: function() {
  11609. this.menu.outerWidth( Math.max(
  11610. this.button.outerWidth(),
  11612. // support: IE10
  11613. // IE10 wraps long text (possibly a rounding bug)
  11614. // so we add 1px to avoid the wrapping
  11615. this.menu.width( "" ).outerWidth() + 1
  11616. ) );
  11617. },
  11619. _getCreateOptions: function() {
  11620. return { disabled: this.element.prop( "disabled" ) };
  11621. },
  11623. _parseOptions: function( options ) {
  11624. var data = [];
  11625. options.each(function( index, item ) {
  11626. var option = $( item ),
  11627. optgroup = option.parent( "optgroup" );
  11628. data.push({
  11629. element: option,
  11630. index: index,
  11631. value: option.val(),
  11632. label: option.text(),
  11633. optgroup: optgroup.attr( "label" ) || "",
  11634. disabled: optgroup.prop( "disabled" ) || option.prop( "disabled" )
  11635. });
  11636. });
  11637. this.items = data;
  11638. },
  11640. _destroy: function() {
  11641. this.menuWrap.remove();
  11642. this.button.remove();
  11643. this.element.show();
  11644. this.element.removeUniqueId();
  11645. this.label.attr( "for", this.ids.element );
  11646. }
  11647. });
  11650. /*!
  11651. * jQuery UI Slider 1.11.4
  11652. * http://jqueryui.com
  11653. *
  11654. * Copyright jQuery Foundation and other contributors
  11655. * Released under the MIT license.
  11656. * http://jquery.org/license
  11657. *
  11658. * http://api.jqueryui.com/slider/
  11659. */
  11662. var slider = $.widget( "ui.slider", $.ui.mouse, {
  11663. version: "1.11.4",
  11664. widgetEventPrefix: "slide",
  11666. options: {
  11667. animate: false,
  11668. distance: 0,
  11669. max: 100,
  11670. min: 0,
  11671. orientation: "horizontal",
  11672. range: false,
  11673. step: 1,
  11674. value: 0,
  11675. values: null,
  11677. // callbacks
  11678. change: null,
  11679. slide: null,
  11680. start: null,
  11681. stop: null
  11682. },
  11684. // number of pages in a slider
  11685. // (how many times can you page up/down to go through the whole range)
  11686. numPages: 5,
  11688. _create: function() {
  11689. this._keySliding = false;
  11690. this._mouseSliding = false;
  11691. this._animateOff = true;
  11692. this._handleIndex = null;
  11693. this._detectOrientation();
  11694. this._mouseInit();
  11695. this._calculateNewMax();
  11697. this.element
  11698. .addClass( "ui-slider" +
  11699. " ui-slider-" + this.orientation +
  11700. " ui-widget" +
  11701. " ui-widget-content" +
  11702. " ui-corner-all");
  11704. this._refresh();
  11705. this._setOption( "disabled", this.options.disabled );
  11707. this._animateOff = false;
  11708. },
  11710. _refresh: function() {
  11711. this._createRange();
  11712. this._createHandles();
  11713. this._setupEvents();
  11714. this._refreshValue();
  11715. },
  11717. _createHandles: function() {
  11718. var i, handleCount,
  11719. options = this.options,
  11720. existingHandles = this.element.find( ".ui-slider-handle" ).addClass( "ui-state-default ui-corner-all" ),
  11721. handle = "<span class='ui-slider-handle ui-state-default ui-corner-all' tabindex='0'></span>",
  11722. handles = [];
  11724. handleCount = ( options.values && options.values.length ) || 1;
  11726. if ( existingHandles.length > handleCount ) {
  11727. existingHandles.slice( handleCount ).remove();
  11728. existingHandles = existingHandles.slice( 0, handleCount );
  11729. }
  11731. for ( i = existingHandles.length; i < handleCount; i++ ) {
  11732. handles.push( handle );
  11733. }
  11735. this.handles = existingHandles.add( $( handles.join( "" ) ).appendTo( this.element ) );
  11737. this.handle = this.handles.eq( 0 );
  11739. this.handles.each(function( i ) {
  11740. $( this ).data( "ui-slider-handle-index", i );
  11741. });
  11742. },
  11744. _createRange: function() {
  11745. var options = this.options,
  11746. classes = "";
  11748. if ( options.range ) {
  11749. if ( options.range === true ) {
  11750. if ( !options.values ) {
  11751. options.values = [ this._valueMin(), this._valueMin() ];
  11752. } else if ( options.values.length && options.values.length !== 2 ) {
  11753. options.values = [ options.values[0], options.values[0] ];
  11754. } else if ( $.isArray( options.values ) ) {
  11755. options.values = options.values.slice(0);
  11756. }
  11757. }
  11759. if ( !this.range || !this.range.length ) {
  11760. this.range = $( "<div></div>" )
  11761. .appendTo( this.element );
  11763. classes = "ui-slider-range" +
  11764. // note: this isn't the most fittingly semantic framework class for this element,
  11765. // but worked best visually with a variety of themes
  11766. " ui-widget-header ui-corner-all";
  11767. } else {
  11768. this.range.removeClass( "ui-slider-range-min ui-slider-range-max" )
  11769. // Handle range switching from true to min/max
  11770. .css({
  11771. "left": "",
  11772. "bottom": ""
  11773. });
  11774. }
  11776. this.range.addClass( classes +
  11777. ( ( options.range === "min" || options.range === "max" ) ? " ui-slider-range-" + options.range : "" ) );
  11778. } else {
  11779. if ( this.range ) {
  11780. this.range.remove();
  11781. }
  11782. this.range = null;
  11783. }
  11784. },
  11786. _setupEvents: function() {
  11787. this._off( this.handles );
  11788. this._on( this.handles, this._handleEvents );
  11789. this._hoverable( this.handles );
  11790. this._focusable( this.handles );
  11791. },
  11793. _destroy: function() {
  11794. this.handles.remove();
  11795. if ( this.range ) {
  11796. this.range.remove();
  11797. }
  11799. this.element
  11800. .removeClass( "ui-slider" +
  11801. " ui-slider-horizontal" +
  11802. " ui-slider-vertical" +
  11803. " ui-widget" +
  11804. " ui-widget-content" +
  11805. " ui-corner-all" );
  11807. this._mouseDestroy();
  11808. },
  11810. _mouseCapture: function( event ) {
  11811. var position, normValue, distance, closestHandle, index, allowed, offset, mouseOverHandle,
  11812. that = this,
  11813. o = this.options;
  11815. if ( o.disabled ) {
  11816. return false;
  11817. }
  11819. this.elementSize = {
  11820. width: this.element.outerWidth(),
  11821. height: this.element.outerHeight()
  11822. };
  11823. this.elementOffset = this.element.offset();
  11825. position = { x: event.pageX, y: event.pageY };
  11826. normValue = this._normValueFromMouse( position );
  11827. distance = this._valueMax() - this._valueMin() + 1;
  11828. this.handles.each(function( i ) {
  11829. var thisDistance = Math.abs( normValue - that.values(i) );
  11830. if (( distance > thisDistance ) ||
  11831. ( distance === thisDistance &&
  11832. (i === that._lastChangedValue || that.values(i) === o.min ))) {
  11833. distance = thisDistance;
  11834. closestHandle = $( this );
  11835. index = i;
  11836. }
  11837. });
  11839. allowed = this._start( event, index );
  11840. if ( allowed === false ) {
  11841. return false;
  11842. }
  11843. this._mouseSliding = true;
  11845. this._handleIndex = index;
  11847. closestHandle
  11848. .addClass( "ui-state-active" )
  11849. .focus();
  11851. offset = closestHandle.offset();
  11852. mouseOverHandle = !$( event.target ).parents().addBack().is( ".ui-slider-handle" );
  11853. this._clickOffset = mouseOverHandle ? { left: 0, top: 0 } : {
  11854. left: event.pageX - offset.left - ( closestHandle.width() / 2 ),
  11855. top: event.pageY - offset.top -
  11856. ( closestHandle.height() / 2 ) -
  11857. ( parseInt( closestHandle.css("borderTopWidth"), 10 ) || 0 ) -
  11858. ( parseInt( closestHandle.css("borderBottomWidth"), 10 ) || 0) +
  11859. ( parseInt( closestHandle.css("marginTop"), 10 ) || 0)
  11860. };
  11862. if ( !this.handles.hasClass( "ui-state-hover" ) ) {
  11863. this._slide( event, index, normValue );
  11864. }
  11865. this._animateOff = true;
  11866. return true;
  11867. },
  11869. _mouseStart: function() {
  11870. return true;
  11871. },
  11873. _mouseDrag: function( event ) {
  11874. var position = { x: event.pageX, y: event.pageY },
  11875. normValue = this._normValueFromMouse( position );
  11877. this._slide( event, this._handleIndex, normValue );
  11879. return false;
  11880. },
  11882. _mouseStop: function( event ) {
  11883. this.handles.removeClass( "ui-state-active" );
  11884. this._mouseSliding = false;
  11886. this._stop( event, this._handleIndex );
  11887. this._change( event, this._handleIndex );
  11889. this._handleIndex = null;
  11890. this._clickOffset = null;
  11891. this._animateOff = false;
  11893. return false;
  11894. },
  11896. _detectOrientation: function() {
  11897. this.orientation = ( this.options.orientation === "vertical" ) ? "vertical" : "horizontal";
  11898. },
  11900. _normValueFromMouse: function( position ) {
  11901. var pixelTotal,
  11902. pixelMouse,
  11903. percentMouse,
  11904. valueTotal,
  11905. valueMouse;
  11907. if ( this.orientation === "horizontal" ) {
  11908. pixelTotal = this.elementSize.width;
  11909. pixelMouse = position.x - this.elementOffset.left - ( this._clickOffset ? this._clickOffset.left : 0 );
  11910. } else {
  11911. pixelTotal = this.elementSize.height;
  11912. pixelMouse = position.y - this.elementOffset.top - ( this._clickOffset ? this._clickOffset.top : 0 );
  11913. }
  11915. percentMouse = ( pixelMouse / pixelTotal );
  11916. if ( percentMouse > 1 ) {
  11917. percentMouse = 1;
  11918. }
  11919. if ( percentMouse < 0 ) {
  11920. percentMouse = 0;
  11921. }
  11922. if ( this.orientation === "vertical" ) {
  11923. percentMouse = 1 - percentMouse;
  11924. }
  11926. valueTotal = this._valueMax() - this._valueMin();
  11927. valueMouse = this._valueMin() + percentMouse * valueTotal;
  11929. return this._trimAlignValue( valueMouse );
  11930. },
  11932. _start: function( event, index ) {
  11933. var uiHash = {
  11934. handle: this.handles[ index ],
  11935. value: this.value()
  11936. };
  11937. if ( this.options.values && this.options.values.length ) {
  11938. uiHash.value = this.values( index );
  11939. uiHash.values = this.values();
  11940. }
  11941. return this._trigger( "start", event, uiHash );
  11942. },
  11944. _slide: function( event, index, newVal ) {
  11945. var otherVal,
  11946. newValues,
  11947. allowed;
  11949. if ( this.options.values && this.options.values.length ) {
  11950. otherVal = this.values( index ? 0 : 1 );
  11952. if ( ( this.options.values.length === 2 && this.options.range === true ) &&
  11953. ( ( index === 0 && newVal > otherVal) || ( index === 1 && newVal < otherVal ) )
  11954. ) {
  11955. newVal = otherVal;
  11956. }
  11958. if ( newVal !== this.values( index ) ) {
  11959. newValues = this.values();
  11960. newValues[ index ] = newVal;
  11961. // A slide can be canceled by returning false from the slide callback
  11962. allowed = this._trigger( "slide", event, {
  11963. handle: this.handles[ index ],
  11964. value: newVal,
  11965. values: newValues
  11966. } );
  11967. otherVal = this.values( index ? 0 : 1 );
  11968. if ( allowed !== false ) {
  11969. this.values( index, newVal );
  11970. }
  11971. }
  11972. } else {
  11973. if ( newVal !== this.value() ) {
  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. } );
  11979. if ( allowed !== false ) {
  11980. this.value( newVal );
  11981. }
  11982. }
  11983. }
  11984. },
  11986. _stop: function( event, index ) {
  11987. var uiHash = {
  11988. handle: this.handles[ index ],
  11989. value: this.value()
  11990. };
  11991. if ( this.options.values && this.options.values.length ) {
  11992. uiHash.value = this.values( index );
  11993. uiHash.values = this.values();
  11994. }
  11996. this._trigger( "stop", event, uiHash );
  11997. },
  11999. _change: function( event, index ) {
  12000. if ( !this._keySliding && !this._mouseSliding ) {
  12001. var uiHash = {
  12002. handle: this.handles[ index ],
  12003. value: this.value()
  12004. };
  12005. if ( this.options.values && this.options.values.length ) {
  12006. uiHash.value = this.values( index );
  12007. uiHash.values = this.values();
  12008. }
  12010. //store the last changed value index for reference when handles overlap
  12011. this._lastChangedValue = index;
  12013. this._trigger( "change", event, uiHash );
  12014. }
  12015. },
  12017. value: function( newValue ) {
  12018. if ( arguments.length ) {
  12019. this.options.value = this._trimAlignValue( newValue );
  12020. this._refreshValue();
  12021. this._change( null, 0 );
  12022. return;
  12023. }
  12025. return this._value();
  12026. },
  12028. values: function( index, newValue ) {
  12029. var vals,
  12030. newValues,
  12031. i;
  12033. if ( arguments.length > 1 ) {
  12034. this.options.values[ index ] = this._trimAlignValue( newValue );
  12035. this._refreshValue();
  12036. this._change( null, index );
  12037. return;
  12038. }
  12040. if ( arguments.length ) {
  12041. if ( $.isArray( arguments[ 0 ] ) ) {
  12042. vals = this.options.values;
  12043. newValues = arguments[ 0 ];
  12044. for ( i = 0; i < vals.length; i += 1 ) {
  12045. vals[ i ] = this._trimAlignValue( newValues[ i ] );
  12046. this._change( null, i );
  12047. }
  12048. this._refreshValue();
  12049. } else {
  12050. if ( this.options.values && this.options.values.length ) {
  12051. return this._values( index );
  12052. } else {
  12053. return this.value();
  12054. }
  12055. }
  12056. } else {
  12057. return this._values();
  12058. }
  12059. },
  12061. _setOption: function( key, value ) {
  12062. var i,
  12063. valsLength = 0;
  12065. if ( key === "range" && this.options.range === true ) {
  12066. if ( value === "min" ) {
  12067. this.options.value = this._values( 0 );
  12068. this.options.values = null;
  12069. } else if ( value === "max" ) {
  12070. this.options.value = this._values( this.options.values.length - 1 );
  12071. this.options.values = null;
  12072. }
  12073. }
  12075. if ( $.isArray( this.options.values ) ) {
  12076. valsLength = this.options.values.length;
  12077. }
  12079. if ( key === "disabled" ) {
  12080. this.element.toggleClass( "ui-state-disabled", !!value );
  12081. }
  12083. this._super( key, value );
  12085. switch ( key ) {
  12086. case "orientation":
  12087. this._detectOrientation();
  12088. this.element
  12089. .removeClass( "ui-slider-horizontal ui-slider-vertical" )
  12090. .addClass( "ui-slider-" + this.orientation );
  12091. this._refreshValue();
  12093. // Reset positioning from previous orientation
  12094. this.handles.css( value === "horizontal" ? "bottom" : "left", "" );
  12095. break;
  12096. case "value":
  12097. this._animateOff = true;
  12098. this._refreshValue();
  12099. this._change( null, 0 );
  12100. this._animateOff = false;
  12101. break;
  12102. case "values":
  12103. this._animateOff = true;
  12104. this._refreshValue();
  12105. for ( i = 0; i < valsLength; i += 1 ) {
  12106. this._change( null, i );
  12107. }
  12108. this._animateOff = false;
  12109. break;
  12110. case "step":
  12111. case "min":
  12112. case "max":
  12113. this._animateOff = true;
  12114. this._calculateNewMax();
  12115. this._refreshValue();
  12116. this._animateOff = false;
  12117. break;
  12118. case "range":
  12119. this._animateOff = true;
  12120. this._refresh();
  12121. this._animateOff = false;
  12122. break;
  12123. }
  12124. },
  12126. //internal value getter
  12127. // _value() returns value trimmed by min and max, aligned by step
  12128. _value: function() {
  12129. var val = this.options.value;
  12130. val = this._trimAlignValue( val );
  12132. return val;
  12133. },
  12135. //internal values getter
  12136. // _values() returns array of values trimmed by min and max, aligned by step
  12137. // _values( index ) returns single value trimmed by min and max, aligned by step
  12138. _values: function( index ) {
  12139. var val,
  12140. vals,
  12141. i;
  12143. if ( arguments.length ) {
  12144. val = this.options.values[ index ];
  12145. val = this._trimAlignValue( val );
  12147. return val;
  12148. } else if ( this.options.values && this.options.values.length ) {
  12149. // .slice() creates a copy of the array
  12150. // this copy gets trimmed by min and max and then returned
  12151. vals = this.options.values.slice();
  12152. for ( i = 0; i < vals.length; i += 1) {
  12153. vals[ i ] = this._trimAlignValue( vals[ i ] );
  12154. }
  12156. return vals;
  12157. } else {
  12158. return [];
  12159. }
  12160. },
  12162. // returns the step-aligned value that val is closest to, between (inclusive) min and max
  12163. _trimAlignValue: function( val ) {
  12164. if ( val <= this._valueMin() ) {
  12165. return this._valueMin();
  12166. }
  12167. if ( val >= this._valueMax() ) {
  12168. return this._valueMax();
  12169. }
  12170. var step = ( this.options.step > 0 ) ? this.options.step : 1,
  12171. valModStep = (val - this._valueMin()) % step,
  12172. alignValue = val - valModStep;
  12174. if ( Math.abs(valModStep) * 2 >= step ) {
  12175. alignValue += ( valModStep > 0 ) ? step : ( -step );
  12176. }
  12178. // Since JavaScript has problems with large floats, round
  12179. // the final value to 5 digits after the decimal point (see #4124)
  12180. return parseFloat( alignValue.toFixed(5) );
  12181. },
  12183. _calculateNewMax: function() {
  12184. var max = this.options.max,
  12185. min = this._valueMin(),
  12186. step = this.options.step,
  12187. aboveMin = Math.floor( ( +( max - min ).toFixed( this._precision() ) ) / step ) * step;
  12188. max = aboveMin + min;
  12189. this.max = parseFloat( max.toFixed( this._precision() ) );
  12190. },
  12192. _precision: function() {
  12193. var precision = this._precisionOf( this.options.step );
  12194. if ( this.options.min !== null ) {
  12195. precision = Math.max( precision, this._precisionOf( this.options.min ) );
  12196. }
  12197. return precision;
  12198. },
  12200. _precisionOf: function( num ) {
  12201. var str = num.toString(),
  12202. decimal = str.indexOf( "." );
  12203. return decimal === -1 ? 0 : str.length - decimal - 1;
  12204. },
  12206. _valueMin: function() {
  12207. return this.options.min;
  12208. },
  12210. _valueMax: function() {
  12211. return this.max;
  12212. },
  12214. _refreshValue: function() {
  12215. var lastValPercent, valPercent, value, valueMin, valueMax,
  12216. oRange = this.options.range,
  12217. o = this.options,
  12218. that = this,
  12219. animate = ( !this._animateOff ) ? o.animate : false,
  12220. _set = {};
  12222. if ( this.options.values && this.options.values.length ) {
  12223. this.handles.each(function( i ) {
  12224. valPercent = ( that.values(i) - that._valueMin() ) / ( that._valueMax() - that._valueMin() ) * 100;
  12225. _set[ that.orientation === "horizontal" ? "left" : "bottom" ] = valPercent + "%";
  12226. $( this ).stop( 1, 1 )[ animate ? "animate" : "css" ]( _set, o.animate );
  12227. if ( that.options.range === true ) {
  12228. if ( that.orientation === "horizontal" ) {
  12229. if ( i === 0 ) {
  12230. that.range.stop( 1, 1 )[ animate ? "animate" : "css" ]( { left: valPercent + "%" }, o.animate );
  12231. }
  12232. if ( i === 1 ) {
  12233. that.range[ animate ? "animate" : "css" ]( { width: ( valPercent - lastValPercent ) + "%" }, { queue: false, duration: o.animate } );
  12234. }
  12235. } else {
  12236. if ( i === 0 ) {
  12237. that.range.stop( 1, 1 )[ animate ? "animate" : "css" ]( { bottom: ( valPercent ) + "%" }, o.animate );
  12238. }
  12239. if ( i === 1 ) {
  12240. that.range[ animate ? "animate" : "css" ]( { height: ( valPercent - lastValPercent ) + "%" }, { queue: false, duration: o.animate } );
  12241. }
  12242. }
  12243. }
  12244. lastValPercent = valPercent;
  12245. });
  12246. } else {
  12247. value = this.value();
  12248. valueMin = this._valueMin();
  12249. valueMax = this._valueMax();
  12250. valPercent = ( valueMax !== valueMin ) ?
  12251. ( value - valueMin ) / ( valueMax - valueMin ) * 100 :
  12252. 0;
  12253. _set[ this.orientation === "horizontal" ? "left" : "bottom" ] = valPercent + "%";
  12254. this.handle.stop( 1, 1 )[ animate ? "animate" : "css" ]( _set, o.animate );
  12256. if ( oRange === "min" && this.orientation === "horizontal" ) {
  12257. this.range.stop( 1, 1 )[ animate ? "animate" : "css" ]( { width: valPercent + "%" }, o.animate );
  12258. }
  12259. if ( oRange === "max" && this.orientation === "horizontal" ) {
  12260. this.range[ animate ? "animate" : "css" ]( { width: ( 100 - valPercent ) + "%" }, { queue: false, duration: o.animate } );
  12261. }
  12262. if ( oRange === "min" && this.orientation === "vertical" ) {
  12263. this.range.stop( 1, 1 )[ animate ? "animate" : "css" ]( { height: valPercent + "%" }, o.animate );
  12264. }
  12265. if ( oRange === "max" && this.orientation === "vertical" ) {
  12266. this.range[ animate ? "animate" : "css" ]( { height: ( 100 - valPercent ) + "%" }, { queue: false, duration: o.animate } );
  12267. }
  12268. }
  12269. },
  12271. _handleEvents: {
  12272. keydown: function( event ) {
  12273. var allowed, curVal, newVal, step,
  12274. index = $( event.target ).data( "ui-slider-handle-index" );
  12276. switch ( event.keyCode ) {
  12277. case $.ui.keyCode.HOME:
  12278. case $.ui.keyCode.END:
  12279. case $.ui.keyCode.PAGE_UP:
  12280. case $.ui.keyCode.PAGE_DOWN:
  12281. case $.ui.keyCode.UP:
  12282. case $.ui.keyCode.RIGHT:
  12283. case $.ui.keyCode.DOWN:
  12284. case $.ui.keyCode.LEFT:
  12285. event.preventDefault();
  12286. if ( !this._keySliding ) {
  12287. this._keySliding = true;
  12288. $( event.target ).addClass( "ui-state-active" );
  12289. allowed = this._start( event, index );
  12290. if ( allowed === false ) {
  12291. return;
  12292. }
  12293. }
  12294. break;
  12295. }
  12297. step = this.options.step;
  12298. if ( this.options.values && this.options.values.length ) {
  12299. curVal = newVal = this.values( index );
  12300. } else {
  12301. curVal = newVal = this.value();
  12302. }
  12304. switch ( event.keyCode ) {
  12305. case $.ui.keyCode.HOME:
  12306. newVal = this._valueMin();
  12307. break;
  12308. case $.ui.keyCode.END:
  12309. newVal = this._valueMax();
  12310. break;
  12311. case $.ui.keyCode.PAGE_UP:
  12312. newVal = this._trimAlignValue(
  12313. curVal + ( ( this._valueMax() - this._valueMin() ) / this.numPages )
  12314. );
  12315. break;
  12316. case $.ui.keyCode.PAGE_DOWN:
  12317. newVal = this._trimAlignValue(
  12318. curVal - ( (this._valueMax() - this._valueMin()) / this.numPages ) );
  12319. break;
  12320. case $.ui.keyCode.UP:
  12321. case $.ui.keyCode.RIGHT:
  12322. if ( curVal === this._valueMax() ) {
  12323. return;
  12324. }
  12325. newVal = this._trimAlignValue( curVal + step );
  12326. break;
  12327. case $.ui.keyCode.DOWN:
  12328. case $.ui.keyCode.LEFT:
  12329. if ( curVal === this._valueMin() ) {
  12330. return;
  12331. }
  12332. newVal = this._trimAlignValue( curVal - step );
  12333. break;
  12334. }
  12336. this._slide( event, index, newVal );
  12337. },
  12338. keyup: function( event ) {
  12339. var index = $( event.target ).data( "ui-slider-handle-index" );
  12341. if ( this._keySliding ) {
  12342. this._keySliding = false;
  12343. this._stop( event, index );
  12344. this._change( event, index );
  12345. $( event.target ).removeClass( "ui-state-active" );
  12346. }
  12347. }
  12348. }
  12349. });
  12352. /*!
  12353. * jQuery UI Spinner 1.11.4
  12354. * http://jqueryui.com
  12355. *
  12356. * Copyright jQuery Foundation and other contributors
  12357. * Released under the MIT license.
  12358. * http://jquery.org/license
  12359. *
  12360. * http://api.jqueryui.com/spinner/
  12361. */
  12364. function spinner_modifier( fn ) {
  12365. return function() {
  12366. var previous = this.element.val();
  12367. fn.apply( this, arguments );
  12368. this._refresh();
  12369. if ( previous !== this.element.val() ) {
  12370. this._trigger( "change" );
  12371. }
  12372. };
  12373. }
  12375. var spinner = $.widget( "ui.spinner", {
  12376. version: "1.11.4",
  12377. defaultElement: "<input>",
  12378. widgetEventPrefix: "spin",
  12379. options: {
  12380. culture: null,
  12381. icons: {
  12382. down: "ui-icon-triangle-1-s",
  12383. up: "ui-icon-triangle-1-n"
  12384. },
  12385. incremental: true,
  12386. max: null,
  12387. min: null,
  12388. numberFormat: null,
  12389. page: 10,
  12390. step: 1,
  12392. change: null,
  12393. spin: null,
  12394. start: null,
  12395. stop: null
  12396. },
  12398. _create: function() {
  12399. // handle string values that need to be parsed
  12400. this._setOption( "max", this.options.max );
  12401. this._setOption( "min", this.options.min );
  12402. this._setOption( "step", this.options.step );
  12404. // Only format if there is a value, prevents the field from being marked
  12405. // as invalid in Firefox, see #9573.
  12406. if ( this.value() !== "" ) {
  12407. // Format the value, but don't constrain.
  12408. this._value( this.element.val(), true );
  12409. }
  12411. this._draw();
  12412. this._on( this._events );
  12413. this._refresh();
  12415. // turning off autocomplete prevents the browser from remembering the
  12416. // value when navigating through history, so we re-enable autocomplete
  12417. // if the page is unloaded before the widget is destroyed. #7790
  12418. this._on( this.window, {
  12419. beforeunload: function() {
  12420. this.element.removeAttr( "autocomplete" );
  12421. }
  12422. });
  12423. },
  12425. _getCreateOptions: function() {
  12426. var options = {},
  12427. element = this.element;
  12429. $.each( [ "min", "max", "step" ], function( i, option ) {
  12430. var value = element.attr( option );
  12431. if ( value !== undefined && value.length ) {
  12432. options[ option ] = value;
  12433. }
  12434. });
  12436. return options;
  12437. },
  12439. _events: {
  12440. keydown: function( event ) {
  12441. if ( this._start( event ) && this._keydown( event ) ) {
  12442. event.preventDefault();
  12443. }
  12444. },
  12445. keyup: "_stop",
  12446. focus: function() {
  12447. this.previous = this.element.val();
  12448. },
  12449. blur: function( event ) {
  12450. if ( this.cancelBlur ) {
  12451. delete this.cancelBlur;
  12452. return;
  12453. }
  12455. this._stop();
  12456. this._refresh();
  12457. if ( this.previous !== this.element.val() ) {
  12458. this._trigger( "change", event );
  12459. }
  12460. },
  12461. mousewheel: function( event, delta ) {
  12462. if ( !delta ) {
  12463. return;
  12464. }
  12465. if ( !this.spinning && !this._start( event ) ) {
  12466. return false;
  12467. }
  12469. this._spin( (delta > 0 ? 1 : -1) * this.options.step, event );
  12470. clearTimeout( this.mousewheelTimer );
  12471. this.mousewheelTimer = this._delay(function() {
  12472. if ( this.spinning ) {
  12473. this._stop( event );
  12474. }
  12475. }, 100 );
  12476. event.preventDefault();
  12477. },
  12478. "mousedown .ui-spinner-button": function( event ) {
  12479. var previous;
  12481. // We never want the buttons to have focus; whenever the user is
  12482. // interacting with the spinner, the focus should be on the input.
  12483. // If the input is focused then this.previous is properly set from
  12484. // when the input first received focus. If the input is not focused
  12485. // then we need to set this.previous based on the value before spinning.
  12486. previous = this.element[0] === this.document[0].activeElement ?
  12487. this.previous : this.element.val();
  12488. function checkFocus() {
  12489. var isActive = this.element[0] === this.document[0].activeElement;
  12490. if ( !isActive ) {
  12491. this.element.focus();
  12492. this.previous = previous;
  12493. // support: IE
  12494. // IE sets focus asynchronously, so we need to check if focus
  12495. // moved off of the input because the user clicked on the button.
  12496. this._delay(function() {
  12497. this.previous = previous;
  12498. });
  12499. }
  12500. }
  12502. // ensure focus is on (or stays on) the text field
  12503. event.preventDefault();
  12504. checkFocus.call( this );
  12506. // support: IE
  12507. // IE doesn't prevent moving focus even with event.preventDefault()
  12508. // so we set a flag to know when we should ignore the blur event
  12509. // and check (again) if focus moved off of the input.
  12510. this.cancelBlur = true;
  12511. this._delay(function() {
  12512. delete this.cancelBlur;
  12513. checkFocus.call( this );
  12514. });
  12516. if ( this._start( event ) === false ) {
  12517. return;
  12518. }
  12520. this._repeat( null, $( event.currentTarget ).hasClass( "ui-spinner-up" ) ? 1 : -1, event );
  12521. },
  12522. "mouseup .ui-spinner-button": "_stop",
  12523. "mouseenter .ui-spinner-button": function( event ) {
  12524. // button will add ui-state-active if mouse was down while mouseleave and kept down
  12525. if ( !$( event.currentTarget ).hasClass( "ui-state-active" ) ) {
  12526. return;
  12527. }
  12529. if ( this._start( event ) === false ) {
  12530. return false;
  12531. }
  12532. this._repeat( null, $( event.currentTarget ).hasClass( "ui-spinner-up" ) ? 1 : -1, event );
  12533. },
  12534. // TODO: do we really want to consider this a stop?
  12535. // shouldn't we just stop the repeater and wait until mouseup before
  12536. // we trigger the stop event?
  12537. "mouseleave .ui-spinner-button": "_stop"
  12538. },
  12540. _draw: function() {
  12541. var uiSpinner = this.uiSpinner = this.element
  12542. .addClass( "ui-spinner-input" )
  12543. .attr( "autocomplete", "off" )
  12544. .wrap( this._uiSpinnerHtml() )
  12545. .parent()
  12546. // add buttons
  12547. .append( this._buttonHtml() );
  12549. this.element.attr( "role", "spinbutton" );
  12551. // button bindings
  12552. this.buttons = uiSpinner.find( ".ui-spinner-button" )
  12553. .attr( "tabIndex", -1 )
  12554. .button()
  12555. .removeClass( "ui-corner-all" );
  12557. // IE 6 doesn't understand height: 50% for the buttons
  12558. // unless the wrapper has an explicit height
  12559. if ( this.buttons.height() > Math.ceil( uiSpinner.height() * 0.5 ) &&
  12560. uiSpinner.height() > 0 ) {
  12561. uiSpinner.height( uiSpinner.height() );
  12562. }
  12564. // disable spinner if element was already disabled
  12565. if ( this.options.disabled ) {
  12566. this.disable();
  12567. }
  12568. },
  12570. _keydown: function( event ) {
  12571. var options = this.options,
  12572. keyCode = $.ui.keyCode;
  12574. switch ( event.keyCode ) {
  12575. case keyCode.UP:
  12576. this._repeat( null, 1, event );
  12577. return true;
  12578. case keyCode.DOWN:
  12579. this._repeat( null, -1, event );
  12580. return true;
  12581. case keyCode.PAGE_UP:
  12582. this._repeat( null, options.page, event );
  12583. return true;
  12584. case keyCode.PAGE_DOWN:
  12585. this._repeat( null, -options.page, event );
  12586. return true;
  12587. }
  12589. return false;
  12590. },
  12592. _uiSpinnerHtml: function() {
  12593. return "<span class='ui-spinner ui-widget ui-widget-content ui-corner-all'></span>";
  12594. },
  12596. _buttonHtml: function() {
  12597. return "" +
  12598. "<a class='ui-spinner-button ui-spinner-up ui-corner-tr'>" +
  12599. "<span class='ui-icon " + this.options.icons.up + "'>&#9650;</span>" +
  12600. "</a>" +
  12601. "<a class='ui-spinner-button ui-spinner-down ui-corner-br'>" +
  12602. "<span class='ui-icon " + this.options.icons.down + "'>&#9660;</span>" +
  12603. "</a>";
  12604. },
  12606. _start: function( event ) {
  12607. if ( !this.spinning && this._trigger( "start", event ) === false ) {
  12608. return false;
  12609. }
  12611. if ( !this.counter ) {
  12612. this.counter = 1;
  12613. }
  12614. this.spinning = true;
  12615. return true;
  12616. },
  12618. _repeat: function( i, steps, event ) {
  12619. i = i || 500;
  12621. clearTimeout( this.timer );
  12622. this.timer = this._delay(function() {
  12623. this._repeat( 40, steps, event );
  12624. }, i );
  12626. this._spin( steps * this.options.step, event );
  12627. },
  12629. _spin: function( step, event ) {
  12630. var value = this.value() || 0;
  12632. if ( !this.counter ) {
  12633. this.counter = 1;
  12634. }
  12636. value = this._adjustValue( value + step * this._increment( this.counter ) );
  12638. if ( !this.spinning || this._trigger( "spin", event, { value: value } ) !== false) {
  12639. this._value( value );
  12640. this.counter++;
  12641. }
  12642. },
  12644. _increment: function( i ) {
  12645. var incremental = this.options.incremental;
  12647. if ( incremental ) {
  12648. return $.isFunction( incremental ) ?
  12649. incremental( i ) :
  12650. Math.floor( i * i * i / 50000 - i * i / 500 + 17 * i / 200 + 1 );
  12651. }
  12653. return 1;
  12654. },
  12656. _precision: function() {
  12657. var precision = this._precisionOf( this.options.step );
  12658. if ( this.options.min !== null ) {
  12659. precision = Math.max( precision, this._precisionOf( this.options.min ) );
  12660. }
  12661. return precision;
  12662. },
  12664. _precisionOf: function( num ) {
  12665. var str = num.toString(),
  12666. decimal = str.indexOf( "." );
  12667. return decimal === -1 ? 0 : str.length - decimal - 1;
  12668. },
  12670. _adjustValue: function( value ) {
  12671. var base, aboveMin,
  12672. options = this.options;
  12674. // make sure we're at a valid step
  12675. // - find out where we are relative to the base (min or 0)
  12676. base = options.min !== null ? options.min : 0;
  12677. aboveMin = value - base;
  12678. // - round to the nearest step
  12679. aboveMin = Math.round(aboveMin / options.step) * options.step;
  12680. // - rounding is based on 0, so adjust back to our base
  12681. value = base + aboveMin;
  12683. // fix precision from bad JS floating point math
  12684. value = parseFloat( value.toFixed( this._precision() ) );
  12686. // clamp the value
  12687. if ( options.max !== null && value > options.max) {
  12688. return options.max;
  12689. }
  12690. if ( options.min !== null && value < options.min ) {
  12691. return options.min;
  12692. }
  12694. return value;
  12695. },
  12697. _stop: function( event ) {
  12698. if ( !this.spinning ) {
  12699. return;
  12700. }
  12702. clearTimeout( this.timer );
  12703. clearTimeout( this.mousewheelTimer );
  12704. this.counter = 0;
  12705. this.spinning = false;
  12706. this._trigger( "stop", event );
  12707. },
  12709. _setOption: function( key, value ) {
  12710. if ( key === "culture" || key === "numberFormat" ) {
  12711. var prevValue = this._parse( this.element.val() );
  12712. this.options[ key ] = value;
  12713. this.element.val( this._format( prevValue ) );
  12714. return;
  12715. }
  12717. if ( key === "max" || key === "min" || key === "step" ) {
  12718. if ( typeof value === "string" ) {
  12719. value = this._parse( value );
  12720. }
  12721. }
  12722. if ( key === "icons" ) {
  12723. this.buttons.first().find( ".ui-icon" )
  12724. .removeClass( this.options.icons.up )
  12725. .addClass( value.up );
  12726. this.buttons.last().find( ".ui-icon" )
  12727. .removeClass( this.options.icons.down )
  12728. .addClass( value.down );
  12729. }
  12731. this._super( key, value );
  12733. if ( key === "disabled" ) {
  12734. this.widget().toggleClass( "ui-state-disabled", !!value );
  12735. this.element.prop( "disabled", !!value );
  12736. this.buttons.button( value ? "disable" : "enable" );
  12737. }
  12738. },
  12740. _setOptions: spinner_modifier(function( options ) {
  12741. this._super( options );
  12742. }),
  12744. _parse: function( val ) {
  12745. if ( typeof val === "string" && val !== "" ) {
  12746. val = window.Globalize && this.options.numberFormat ?
  12747. Globalize.parseFloat( val, 10, this.options.culture ) : +val;
  12748. }
  12749. return val === "" || isNaN( val ) ? null : val;
  12750. },
  12752. _format: function( value ) {
  12753. if ( value === "" ) {
  12754. return "";
  12755. }
  12756. return window.Globalize && this.options.numberFormat ?
  12757. Globalize.format( value, this.options.numberFormat, this.options.culture ) :
  12758. value;
  12759. },
  12761. _refresh: function() {
  12762. this.element.attr({
  12763. "aria-valuemin": this.options.min,
  12764. "aria-valuemax": this.options.max,
  12765. // TODO: what should we do with values that can't be parsed?
  12766. "aria-valuenow": this._parse( this.element.val() )
  12767. });
  12768. },
  12770. isValid: function() {
  12771. var value = this.value();
  12773. // null is invalid
  12774. if ( value === null ) {
  12775. return false;
  12776. }
  12778. // if value gets adjusted, it's invalid
  12779. return value === this._adjustValue( value );
  12780. },
  12782. // update the value without triggering change
  12783. _value: function( value, allowAny ) {
  12784. var parsed;
  12785. if ( value !== "" ) {
  12786. parsed = this._parse( value );
  12787. if ( parsed !== null ) {
  12788. if ( !allowAny ) {
  12789. parsed = this._adjustValue( parsed );
  12790. }
  12791. value = this._format( parsed );
  12792. }
  12793. }
  12794. this.element.val( value );
  12795. this._refresh();
  12796. },
  12798. _destroy: function() {
  12799. this.element
  12800. .removeClass( "ui-spinner-input" )
  12801. .prop( "disabled", false )
  12802. .removeAttr( "autocomplete" )
  12803. .removeAttr( "role" )
  12804. .removeAttr( "aria-valuemin" )
  12805. .removeAttr( "aria-valuemax" )
  12806. .removeAttr( "aria-valuenow" );
  12807. this.uiSpinner.replaceWith( this.element );
  12808. },
  12810. stepUp: spinner_modifier(function( steps ) {
  12811. this._stepUp( steps );
  12812. }),
  12813. _stepUp: function( steps ) {
  12814. if ( this._start() ) {
  12815. this._spin( (steps || 1) * this.options.step );
  12816. this._stop();
  12817. }
  12818. },
  12820. stepDown: spinner_modifier(function( steps ) {
  12821. this._stepDown( steps );
  12822. }),
  12823. _stepDown: function( steps ) {
  12824. if ( this._start() ) {
  12825. this._spin( (steps || 1) * -this.options.step );
  12826. this._stop();
  12827. }
  12828. },
  12830. pageUp: spinner_modifier(function( pages ) {
  12831. this._stepUp( (pages || 1) * this.options.page );
  12832. }),
  12834. pageDown: spinner_modifier(function( pages ) {
  12835. this._stepDown( (pages || 1) * this.options.page );
  12836. }),
  12838. value: function( newVal ) {
  12839. if ( !arguments.length ) {
  12840. return this._parse( this.element.val() );
  12841. }
  12842. spinner_modifier( this._value ).call( this, newVal );
  12843. },
  12845. widget: function() {
  12846. return this.uiSpinner;
  12847. }
  12848. });
  12851. /*!
  12852. * jQuery UI Tabs 1.11.4
  12853. * http://jqueryui.com
  12854. *
  12855. * Copyright jQuery Foundation and other contributors
  12856. * Released under the MIT license.
  12857. * http://jquery.org/license
  12858. *
  12859. * http://api.jqueryui.com/tabs/
  12860. */
  12863. var tabs = $.widget( "ui.tabs", {
  12864. version: "1.11.4",
  12865. delay: 300,
  12866. options: {
  12867. active: null,
  12868. collapsible: false,
  12869. event: "click",
  12870. heightStyle: "content",
  12871. hide: null,
  12872. show: null,
  12874. // callbacks
  12875. activate: null,
  12876. beforeActivate: null,
  12877. beforeLoad: null,
  12878. load: null
  12879. },
  12881. _isLocal: (function() {
  12882. var rhash = /#.*$/;
  12884. return function( anchor ) {
  12885. var anchorUrl, locationUrl;
  12887. // support: IE7
  12888. // IE7 doesn't normalize the href property when set via script (#9317)
  12889. anchor = anchor.cloneNode( false );
  12891. anchorUrl = anchor.href.replace( rhash, "" );
  12892. locationUrl = location.href.replace( rhash, "" );
  12894. // decoding may throw an error if the URL isn't UTF-8 (#9518)
  12895. try {
  12896. anchorUrl = decodeURIComponent( anchorUrl );
  12897. } catch ( error ) {}
  12898. try {
  12899. locationUrl = decodeURIComponent( locationUrl );
  12900. } catch ( error ) {}
  12902. return anchor.hash.length > 1 && anchorUrl === locationUrl;
  12903. };
  12904. })(),
  12906. _create: function() {
  12907. var that = this,
  12908. options = this.options;
  12910. this.running = false;
  12912. this.element
  12913. .addClass( "ui-tabs ui-widget ui-widget-content ui-corner-all" )
  12914. .toggleClass( "ui-tabs-collapsible", options.collapsible );
  12916. this._processTabs();
  12917. options.active = this._initialActive();
  12919. // Take disabling tabs via class attribute from HTML
  12920. // into account and update option properly.
  12921. if ( $.isArray( options.disabled ) ) {
  12922. options.disabled = $.unique( options.disabled.concat(
  12923. $.map( this.tabs.filter( ".ui-state-disabled" ), function( li ) {
  12924. return that.tabs.index( li );
  12925. })
  12926. ) ).sort();
  12927. }
  12929. // check for length avoids error when initializing empty list
  12930. if ( this.options.active !== false && this.anchors.length ) {
  12931. this.active = this._findActive( options.active );
  12932. } else {
  12933. this.active = $();
  12934. }
  12936. this._refresh();
  12938. if ( this.active.length ) {
  12939. this.load( options.active );
  12940. }
  12941. },
  12943. _initialActive: function() {
  12944. var active = this.options.active,
  12945. collapsible = this.options.collapsible,
  12946. locationHash = location.hash.substring( 1 );
  12948. if ( active === null ) {
  12949. // check the fragment identifier in the URL
  12950. if ( locationHash ) {
  12951. this.tabs.each(function( i, tab ) {
  12952. if ( $( tab ).attr( "aria-controls" ) === locationHash ) {
  12953. active = i;
  12954. return false;
  12955. }
  12956. });
  12957. }
  12959. // check for a tab marked active via a class
  12960. if ( active === null ) {
  12961. active = this.tabs.index( this.tabs.filter( ".ui-tabs-active" ) );
  12962. }
  12964. // no active tab, set to false
  12965. if ( active === null || active === -1 ) {
  12966. active = this.tabs.length ? 0 : false;
  12967. }
  12968. }
  12970. // handle numbers: negative, out of range
  12971. if ( active !== false ) {
  12972. active = this.tabs.index( this.tabs.eq( active ) );
  12973. if ( active === -1 ) {
  12974. active = collapsible ? false : 0;
  12975. }
  12976. }
  12978. // don't allow collapsible: false and active: false
  12979. if ( !collapsible && active === false && this.anchors.length ) {
  12980. active = 0;
  12981. }
  12983. return active;
  12984. },
  12986. _getCreateEventData: function() {
  12987. return {
  12988. tab: this.active,
  12989. panel: !this.active.length ? $() : this._getPanelForTab( this.active )
  12990. };
  12991. },
  12993. _tabKeydown: function( event ) {
  12994. var focusedTab = $( this.document[0].activeElement ).closest( "li" ),
  12995. selectedIndex = this.tabs.index( focusedTab ),
  12996. goingForward = true;
  12998. if ( this._handlePageNav( event ) ) {
  12999. return;
  13000. }
  13002. switch ( event.keyCode ) {
  13003. case $.ui.keyCode.RIGHT:
  13004. case $.ui.keyCode.DOWN:
  13005. selectedIndex++;
  13006. break;
  13007. case $.ui.keyCode.UP:
  13008. case $.ui.keyCode.LEFT:
  13009. goingForward = false;
  13010. selectedIndex--;
  13011. break;
  13012. case $.ui.keyCode.END:
  13013. selectedIndex = this.anchors.length - 1;
  13014. break;
  13015. case $.ui.keyCode.HOME:
  13016. selectedIndex = 0;
  13017. break;
  13018. case $.ui.keyCode.SPACE:
  13019. // Activate only, no collapsing
  13020. event.preventDefault();
  13021. clearTimeout( this.activating );
  13022. this._activate( selectedIndex );
  13023. return;
  13024. case $.ui.keyCode.ENTER:
  13025. // Toggle (cancel delayed activation, allow collapsing)
  13026. event.preventDefault();
  13027. clearTimeout( this.activating );
  13028. // Determine if we should collapse or activate
  13029. this._activate( selectedIndex === this.options.active ? false : selectedIndex );
  13030. return;
  13031. default:
  13032. return;
  13033. }
  13035. // Focus the appropriate tab, based on which key was pressed
  13036. event.preventDefault();
  13037. clearTimeout( this.activating );
  13038. selectedIndex = this._focusNextTab( selectedIndex, goingForward );
  13040. // Navigating with control/command key will prevent automatic activation
  13041. if ( !event.ctrlKey && !event.metaKey ) {
  13043. // Update aria-selected immediately so that AT think the tab is already selected.
  13044. // Otherwise AT may confuse the user by stating that they need to activate the tab,
  13045. // but the tab will already be activated by the time the announcement finishes.
  13046. focusedTab.attr( "aria-selected", "false" );
  13047. this.tabs.eq( selectedIndex ).attr( "aria-selected", "true" );
  13049. this.activating = this._delay(function() {
  13050. this.option( "active", selectedIndex );
  13051. }, this.delay );
  13052. }
  13053. },
  13055. _panelKeydown: function( event ) {
  13056. if ( this._handlePageNav( event ) ) {
  13057. return;
  13058. }
  13060. // Ctrl+up moves focus to the current tab
  13061. if ( event.ctrlKey && event.keyCode === $.ui.keyCode.UP ) {
  13062. event.preventDefault();
  13063. this.active.focus();
  13064. }
  13065. },
  13067. // Alt+page up/down moves focus to the previous/next tab (and activates)
  13068. _handlePageNav: function( event ) {
  13069. if ( event.altKey && event.keyCode === $.ui.keyCode.PAGE_UP ) {
  13070. this._activate( this._focusNextTab( this.options.active - 1, false ) );
  13071. return true;
  13072. }
  13073. if ( event.altKey && event.keyCode === $.ui.keyCode.PAGE_DOWN ) {
  13074. this._activate( this._focusNextTab( this.options.active + 1, true ) );
  13075. return true;
  13076. }
  13077. },
  13079. _findNextTab: function( index, goingForward ) {
  13080. var lastTabIndex = this.tabs.length - 1;
  13082. function constrain() {
  13083. if ( index > lastTabIndex ) {
  13084. index = 0;
  13085. }
  13086. if ( index < 0 ) {
  13087. index = lastTabIndex;
  13088. }
  13089. return index;
  13090. }
  13092. while ( $.inArray( constrain(), this.options.disabled ) !== -1 ) {
  13093. index = goingForward ? index + 1 : index - 1;
  13094. }
  13096. return index;
  13097. },
  13099. _focusNextTab: function( index, goingForward ) {
  13100. index = this._findNextTab( index, goingForward );
  13101. this.tabs.eq( index ).focus();
  13102. return index;
  13103. },
  13105. _setOption: function( key, value ) {
  13106. if ( key === "active" ) {
  13107. // _activate() will handle invalid values and update this.options
  13108. this._activate( value );
  13109. return;
  13110. }
  13112. if ( key === "disabled" ) {
  13113. // don't use the widget factory's disabled handling
  13114. this._setupDisabled( value );
  13115. return;
  13116. }
  13118. this._super( key, value);
  13120. if ( key === "collapsible" ) {
  13121. this.element.toggleClass( "ui-tabs-collapsible", value );
  13122. // Setting collapsible: false while collapsed; open first panel
  13123. if ( !value && this.options.active === false ) {
  13124. this._activate( 0 );
  13125. }
  13126. }
  13128. if ( key === "event" ) {
  13129. this._setupEvents( value );
  13130. }
  13132. if ( key === "heightStyle" ) {
  13133. this._setupHeightStyle( value );
  13134. }
  13135. },
  13137. _sanitizeSelector: function( hash ) {
  13138. return hash ? hash.replace( /[!"$%&'()*+,.\/:;<=>?@\[\]\^`{|}~]/g, "\\$&" ) : "";
  13139. },
  13141. refresh: function() {
  13142. var options = this.options,
  13143. lis = this.tablist.children( ":has(a[href])" );
  13145. // get disabled tabs from class attribute from HTML
  13146. // this will get converted to a boolean if needed in _refresh()
  13147. options.disabled = $.map( lis.filter( ".ui-state-disabled" ), function( tab ) {
  13148. return lis.index( tab );
  13149. });
  13151. this._processTabs();
  13153. // was collapsed or no tabs
  13154. if ( options.active === false || !this.anchors.length ) {
  13155. options.active = false;
  13156. this.active = $();
  13157. // was active, but active tab is gone
  13158. } else if ( this.active.length && !$.contains( this.tablist[ 0 ], this.active[ 0 ] ) ) {
  13159. // all remaining tabs are disabled
  13160. if ( this.tabs.length === options.disabled.length ) {
  13161. options.active = false;
  13162. this.active = $();
  13163. // activate previous tab
  13164. } else {
  13165. this._activate( this._findNextTab( Math.max( 0, options.active - 1 ), false ) );
  13166. }
  13167. // was active, active tab still exists
  13168. } else {
  13169. // make sure active index is correct
  13170. options.active = this.tabs.index( this.active );
  13171. }
  13173. this._refresh();
  13174. },
  13176. _refresh: function() {
  13177. this._setupDisabled( this.options.disabled );
  13178. this._setupEvents( this.options.event );
  13179. this._setupHeightStyle( this.options.heightStyle );
  13181. this.tabs.not( this.active ).attr({
  13182. "aria-selected": "false",
  13183. "aria-expanded": "false",
  13184. tabIndex: -1
  13185. });
  13186. this.panels.not( this._getPanelForTab( this.active ) )
  13187. .hide()
  13188. .attr({
  13189. "aria-hidden": "true"
  13190. });
  13192. // Make sure one tab is in the tab order
  13193. if ( !this.active.length ) {
  13194. this.tabs.eq( 0 ).attr( "tabIndex", 0 );
  13195. } else {
  13196. this.active
  13197. .addClass( "ui-tabs-active ui-state-active" )
  13198. .attr({
  13199. "aria-selected": "true",
  13200. "aria-expanded": "true",
  13201. tabIndex: 0
  13202. });
  13203. this._getPanelForTab( this.active )
  13204. .show()
  13205. .attr({
  13206. "aria-hidden": "false"
  13207. });
  13208. }
  13209. },
  13211. _processTabs: function() {
  13212. var that = this,
  13213. prevTabs = this.tabs,
  13214. prevAnchors = this.anchors,
  13215. prevPanels = this.panels;
  13217. this.tablist = this._getList()
  13218. .addClass( "ui-tabs-nav ui-helper-reset ui-helper-clearfix ui-widget-header ui-corner-all" )
  13219. .attr( "role", "tablist" )
  13221. // Prevent users from focusing disabled tabs via click
  13222. .delegate( "> li", "mousedown" + this.eventNamespace, function( event ) {
  13223. if ( $( this ).is( ".ui-state-disabled" ) ) {
  13224. event.preventDefault();
  13225. }
  13226. })
  13228. // support: IE <9
  13229. // Preventing the default action in mousedown doesn't prevent IE
  13230. // from focusing the element, so if the anchor gets focused, blur.
  13231. // We don't have to worry about focusing the previously focused
  13232. // element since clicking on a non-focusable element should focus
  13233. // the body anyway.
  13234. .delegate( ".ui-tabs-anchor", "focus" + this.eventNamespace, function() {
  13235. if ( $( this ).closest( "li" ).is( ".ui-state-disabled" ) ) {
  13236. this.blur();
  13237. }
  13238. });
  13240. this.tabs = this.tablist.find( "> li:has(a[href])" )
  13241. .addClass( "ui-state-default ui-corner-top" )
  13242. .attr({
  13243. role: "tab",
  13244. tabIndex: -1
  13245. });
  13247. this.anchors = this.tabs.map(function() {
  13248. return $( "a", this )[ 0 ];
  13249. })
  13250. .addClass( "ui-tabs-anchor" )
  13251. .attr({
  13252. role: "presentation",
  13253. tabIndex: -1
  13254. });
  13256. this.panels = $();
  13258. this.anchors.each(function( i, anchor ) {
  13259. var selector, panel, panelId,
  13260. anchorId = $( anchor ).uniqueId().attr( "id" ),
  13261. tab = $( anchor ).closest( "li" ),
  13262. originalAriaControls = tab.attr( "aria-controls" );
  13264. // inline tab
  13265. if ( that._isLocal( anchor ) ) {
  13266. selector = anchor.hash;
  13267. panelId = selector.substring( 1 );
  13268. panel = that.element.find( that._sanitizeSelector( selector ) );
  13269. // remote tab
  13270. } else {
  13271. // If the tab doesn't already have aria-controls,
  13272. // generate an id by using a throw-away element
  13273. panelId = tab.attr( "aria-controls" ) || $( {} ).uniqueId()[ 0 ].id;
  13274. selector = "#" + panelId;
  13275. panel = that.element.find( selector );
  13276. if ( !panel.length ) {
  13277. panel = that._createPanel( panelId );
  13278. panel.insertAfter( that.panels[ i - 1 ] || that.tablist );
  13279. }
  13280. panel.attr( "aria-live", "polite" );
  13281. }
  13283. if ( panel.length) {
  13284. that.panels = that.panels.add( panel );
  13285. }
  13286. if ( originalAriaControls ) {
  13287. tab.data( "ui-tabs-aria-controls", originalAriaControls );
  13288. }
  13289. tab.attr({
  13290. "aria-controls": panelId,
  13291. "aria-labelledby": anchorId
  13292. });
  13293. panel.attr( "aria-labelledby", anchorId );
  13294. });
  13296. this.panels
  13297. .addClass( "ui-tabs-panel ui-widget-content ui-corner-bottom" )
  13298. .attr( "role", "tabpanel" );
  13300. // Avoid memory leaks (#10056)
  13301. if ( prevTabs ) {
  13302. this._off( prevTabs.not( this.tabs ) );
  13303. this._off( prevAnchors.not( this.anchors ) );
  13304. this._off( prevPanels.not( this.panels ) );
  13305. }
  13306. },
  13308. // allow overriding how to find the list for rare usage scenarios (#7715)
  13309. _getList: function() {
  13310. return this.tablist || this.element.find( "ol,ul" ).eq( 0 );
  13311. },
  13313. _createPanel: function( id ) {
  13314. return $( "<div>" )
  13315. .attr( "id", id )
  13316. .addClass( "ui-tabs-panel ui-widget-content ui-corner-bottom" )
  13317. .data( "ui-tabs-destroy", true );
  13318. },
  13320. _setupDisabled: function( disabled ) {
  13321. if ( $.isArray( disabled ) ) {
  13322. if ( !disabled.length ) {
  13323. disabled = false;
  13324. } else if ( disabled.length === this.anchors.length ) {
  13325. disabled = true;
  13326. }
  13327. }
  13329. // disable tabs
  13330. for ( var i = 0, li; ( li = this.tabs[ i ] ); i++ ) {
  13331. if ( disabled === true || $.inArray( i, disabled ) !== -1 ) {
  13332. $( li )
  13333. .addClass( "ui-state-disabled" )
  13334. .attr( "aria-disabled", "true" );
  13335. } else {
  13336. $( li )
  13337. .removeClass( "ui-state-disabled" )
  13338. .removeAttr( "aria-disabled" );
  13339. }
  13340. }
  13342. this.options.disabled = disabled;
  13343. },
  13345. _setupEvents: function( event ) {
  13346. var events = {};
  13347. if ( event ) {
  13348. $.each( event.split(" "), function( index, eventName ) {
  13349. events[ eventName ] = "_eventHandler";
  13350. });
  13351. }
  13353. this._off( this.anchors.add( this.tabs ).add( this.panels ) );
  13354. // Always prevent the default action, even when disabled
  13355. this._on( true, this.anchors, {
  13356. click: function( event ) {
  13357. event.preventDefault();
  13358. }
  13359. });
  13360. this._on( this.anchors, events );
  13361. this._on( this.tabs, { keydown: "_tabKeydown" } );
  13362. this._on( this.panels, { keydown: "_panelKeydown" } );
  13364. this._focusable( this.tabs );
  13365. this._hoverable( this.tabs );
  13366. },
  13368. _setupHeightStyle: function( heightStyle ) {
  13369. var maxHeight,
  13370. parent = this.element.parent();
  13372. if ( heightStyle === "fill" ) {
  13373. maxHeight = parent.height();
  13374. maxHeight -= this.element.outerHeight() - this.element.height();
  13376. this.element.siblings( ":visible" ).each(function() {
  13377. var elem = $( this ),
  13378. position = elem.css( "position" );
  13380. if ( position === "absolute" || position === "fixed" ) {
  13381. return;
  13382. }
  13383. maxHeight -= elem.outerHeight( true );
  13384. });
  13386. this.element.children().not( this.panels ).each(function() {
  13387. maxHeight -= $( this ).outerHeight( true );
  13388. });
  13390. this.panels.each(function() {
  13391. $( this ).height( Math.max( 0, maxHeight -
  13392. $( this ).innerHeight() + $( this ).height() ) );
  13393. })
  13394. .css( "overflow", "auto" );
  13395. } else if ( heightStyle === "auto" ) {
  13396. maxHeight = 0;
  13397. this.panels.each(function() {
  13398. maxHeight = Math.max( maxHeight, $( this ).height( "" ).height() );
  13399. }).height( maxHeight );
  13400. }
  13401. },
  13403. _eventHandler: function( event ) {
  13404. var options = this.options,
  13405. active = this.active,
  13406. anchor = $( event.currentTarget ),
  13407. tab = anchor.closest( "li" ),
  13408. clickedIsActive = tab[ 0 ] === active[ 0 ],
  13409. collapsing = clickedIsActive && options.collapsible,
  13410. toShow = collapsing ? $() : this._getPanelForTab( tab ),
  13411. toHide = !active.length ? $() : this._getPanelForTab( active ),
  13412. eventData = {
  13413. oldTab: active,
  13414. oldPanel: toHide,
  13415. newTab: collapsing ? $() : tab,
  13416. newPanel: toShow
  13417. };
  13419. event.preventDefault();
  13421. if ( tab.hasClass( "ui-state-disabled" ) ||
  13422. // tab is already loading
  13423. tab.hasClass( "ui-tabs-loading" ) ||
  13424. // can't switch durning an animation
  13425. this.running ||
  13426. // click on active header, but not collapsible
  13427. ( clickedIsActive && !options.collapsible ) ||
  13428. // allow canceling activation
  13429. ( this._trigger( "beforeActivate", event, eventData ) === false ) ) {
  13430. return;
  13431. }
  13433. options.active = collapsing ? false : this.tabs.index( tab );
  13435. this.active = clickedIsActive ? $() : tab;
  13436. if ( this.xhr ) {
  13437. this.xhr.abort();
  13438. }
  13440. if ( !toHide.length && !toShow.length ) {
  13441. $.error( "jQuery UI Tabs: Mismatching fragment identifier." );
  13442. }
  13444. if ( toShow.length ) {
  13445. this.load( this.tabs.index( tab ), event );
  13446. }
  13447. this._toggle( event, eventData );
  13448. },
  13450. // handles show/hide for selecting tabs
  13451. _toggle: function( event, eventData ) {
  13452. var that = this,
  13453. toShow = eventData.newPanel,
  13454. toHide = eventData.oldPanel;
  13456. this.running = true;
  13458. function complete() {
  13459. that.running = false;
  13460. that._trigger( "activate", event, eventData );
  13461. }
  13463. function show() {
  13464. eventData.newTab.closest( "li" ).addClass( "ui-tabs-active ui-state-active" );
  13466. if ( toShow.length && that.options.show ) {
  13467. that._show( toShow, that.options.show, complete );
  13468. } else {
  13469. toShow.show();
  13470. complete();
  13471. }
  13472. }
  13474. // start out by hiding, then showing, then completing
  13475. if ( toHide.length && this.options.hide ) {
  13476. this._hide( toHide, this.options.hide, function() {
  13477. eventData.oldTab.closest( "li" ).removeClass( "ui-tabs-active ui-state-active" );
  13478. show();
  13479. });
  13480. } else {
  13481. eventData.oldTab.closest( "li" ).removeClass( "ui-tabs-active ui-state-active" );
  13482. toHide.hide();
  13483. show();
  13484. }
  13486. toHide.attr( "aria-hidden", "true" );
  13487. eventData.oldTab.attr({
  13488. "aria-selected": "false",
  13489. "aria-expanded": "false"
  13490. });
  13491. // If we're switching tabs, remove the old tab from the tab order.
  13492. // If we're opening from collapsed state, remove the previous tab from the tab order.
  13493. // If we're collapsing, then keep the collapsing tab in the tab order.
  13494. if ( toShow.length && toHide.length ) {
  13495. eventData.oldTab.attr( "tabIndex", -1 );
  13496. } else if ( toShow.length ) {
  13497. this.tabs.filter(function() {
  13498. return $( this ).attr( "tabIndex" ) === 0;
  13499. })
  13500. .attr( "tabIndex", -1 );
  13501. }
  13503. toShow.attr( "aria-hidden", "false" );
  13504. eventData.newTab.attr({
  13505. "aria-selected": "true",
  13506. "aria-expanded": "true",
  13507. tabIndex: 0
  13508. });
  13509. },
  13511. _activate: function( index ) {
  13512. var anchor,
  13513. active = this._findActive( index );
  13515. // trying to activate the already active panel
  13516. if ( active[ 0 ] === this.active[ 0 ] ) {
  13517. return;
  13518. }
  13520. // trying to collapse, simulate a click on the current active header
  13521. if ( !active.length ) {
  13522. active = this.active;
  13523. }
  13525. anchor = active.find( ".ui-tabs-anchor" )[ 0 ];
  13526. this._eventHandler({
  13527. target: anchor,
  13528. currentTarget: anchor,
  13529. preventDefault: $.noop
  13530. });
  13531. },
  13533. _findActive: function( index ) {
  13534. return index === false ? $() : this.tabs.eq( index );
  13535. },
  13537. _getIndex: function( index ) {
  13538. // meta-function to give users option to provide a href string instead of a numerical index.
  13539. if ( typeof index === "string" ) {
  13540. index = this.anchors.index( this.anchors.filter( "[href$='" + index + "']" ) );
  13541. }
  13543. return index;
  13544. },
  13546. _destroy: function() {
  13547. if ( this.xhr ) {
  13548. this.xhr.abort();
  13549. }
  13551. this.element.removeClass( "ui-tabs ui-widget ui-widget-content ui-corner-all ui-tabs-collapsible" );
  13553. this.tablist
  13554. .removeClass( "ui-tabs-nav ui-helper-reset ui-helper-clearfix ui-widget-header ui-corner-all" )
  13555. .removeAttr( "role" );
  13557. this.anchors
  13558. .removeClass( "ui-tabs-anchor" )
  13559. .removeAttr( "role" )
  13560. .removeAttr( "tabIndex" )
  13561. .removeUniqueId();
  13563. this.tablist.unbind( this.eventNamespace );
  13565. this.tabs.add( this.panels ).each(function() {
  13566. if ( $.data( this, "ui-tabs-destroy" ) ) {
  13567. $( this ).remove();
  13568. } else {
  13569. $( this )
  13570. .removeClass( "ui-state-default ui-state-active ui-state-disabled " +
  13571. "ui-corner-top ui-corner-bottom ui-widget-content ui-tabs-active ui-tabs-panel" )
  13572. .removeAttr( "tabIndex" )
  13573. .removeAttr( "aria-live" )
  13574. .removeAttr( "aria-busy" )
  13575. .removeAttr( "aria-selected" )
  13576. .removeAttr( "aria-labelledby" )
  13577. .removeAttr( "aria-hidden" )
  13578. .removeAttr( "aria-expanded" )
  13579. .removeAttr( "role" );
  13580. }
  13581. });
  13583. this.tabs.each(function() {
  13584. var li = $( this ),
  13585. prev = li.data( "ui-tabs-aria-controls" );
  13586. if ( prev ) {
  13587. li
  13588. .attr( "aria-controls", prev )
  13589. .removeData( "ui-tabs-aria-controls" );
  13590. } else {
  13591. li.removeAttr( "aria-controls" );
  13592. }
  13593. });
  13595. this.panels.show();
  13597. if ( this.options.heightStyle !== "content" ) {
  13598. this.panels.css( "height", "" );
  13599. }
  13600. },
  13602. enable: function( index ) {
  13603. var disabled = this.options.disabled;
  13604. if ( disabled === false ) {
  13605. return;
  13606. }
  13608. if ( index === undefined ) {
  13609. disabled = false;
  13610. } else {
  13611. index = this._getIndex( index );
  13612. if ( $.isArray( disabled ) ) {
  13613. disabled = $.map( disabled, function( num ) {
  13614. return num !== index ? num : null;
  13615. });
  13616. } else {
  13617. disabled = $.map( this.tabs, function( li, num ) {
  13618. return num !== index ? num : null;
  13619. });
  13620. }
  13621. }
  13622. this._setupDisabled( disabled );
  13623. },
  13625. disable: function( index ) {
  13626. var disabled = this.options.disabled;
  13627. if ( disabled === true ) {
  13628. return;
  13629. }
  13631. if ( index === undefined ) {
  13632. disabled = true;
  13633. } else {
  13634. index = this._getIndex( index );
  13635. if ( $.inArray( index, disabled ) !== -1 ) {
  13636. return;
  13637. }
  13638. if ( $.isArray( disabled ) ) {
  13639. disabled = $.merge( [ index ], disabled ).sort();
  13640. } else {
  13641. disabled = [ index ];
  13642. }
  13643. }
  13644. this._setupDisabled( disabled );
  13645. },
  13647. load: function( index, event ) {
  13648. index = this._getIndex( index );
  13649. var that = this,
  13650. tab = this.tabs.eq( index ),
  13651. anchor = tab.find( ".ui-tabs-anchor" ),
  13652. panel = this._getPanelForTab( tab ),
  13653. eventData = {
  13654. tab: tab,
  13655. panel: panel
  13656. },
  13657. complete = function( jqXHR, status ) {
  13658. if ( status === "abort" ) {
  13659. that.panels.stop( false, true );
  13660. }
  13662. tab.removeClass( "ui-tabs-loading" );
  13663. panel.removeAttr( "aria-busy" );
  13665. if ( jqXHR === that.xhr ) {
  13666. delete that.xhr;
  13667. }
  13668. };
  13670. // not remote
  13671. if ( this._isLocal( anchor[ 0 ] ) ) {
  13672. return;
  13673. }
  13675. this.xhr = $.ajax( this._ajaxSettings( anchor, event, eventData ) );
  13677. // support: jQuery <1.8
  13678. // jQuery <1.8 returns false if the request is canceled in beforeSend,
  13679. // but as of 1.8, $.ajax() always returns a jqXHR object.
  13680. if ( this.xhr && this.xhr.statusText !== "canceled" ) {
  13681. tab.addClass( "ui-tabs-loading" );
  13682. panel.attr( "aria-busy", "true" );
  13684. this.xhr
  13685. .done(function( response, status, jqXHR ) {
  13686. // support: jQuery <1.8
  13687. // http://bugs.jquery.com/ticket/11778
  13688. setTimeout(function() {
  13689. panel.html( response );
  13690. that._trigger( "load", event, eventData );
  13692. complete( jqXHR, status );
  13693. }, 1 );
  13694. })
  13695. .fail(function( jqXHR, status ) {
  13696. // support: jQuery <1.8
  13697. // http://bugs.jquery.com/ticket/11778
  13698. setTimeout(function() {
  13699. complete( jqXHR, status );
  13700. }, 1 );
  13701. });
  13702. }
  13703. },
  13705. _ajaxSettings: function( anchor, event, eventData ) {
  13706. var that = this;
  13707. return {
  13708. url: anchor.attr( "href" ),
  13709. beforeSend: function( jqXHR, settings ) {
  13710. return that._trigger( "beforeLoad", event,
  13711. $.extend( { jqXHR: jqXHR, ajaxSettings: settings }, eventData ) );
  13712. }
  13713. };
  13714. },
  13716. _getPanelForTab: function( tab ) {
  13717. var id = $( tab ).attr( "aria-controls" );
  13718. return this.element.find( this._sanitizeSelector( "#" + id ) );
  13719. }
  13720. });
  13723. /*!
  13724. * jQuery UI Tooltip 1.11.4
  13725. * http://jqueryui.com
  13726. *
  13727. * Copyright jQuery Foundation and other contributors
  13728. * Released under the MIT license.
  13729. * http://jquery.org/license
  13730. *
  13731. * http://api.jqueryui.com/tooltip/
  13732. */
  13735. var tooltip = $.widget( "ui.tooltip", {
  13736. version: "1.11.4",
  13737. options: {
  13738. content: function() {
  13739. // support: IE<9, Opera in jQuery <1.7
  13740. // .text() can't accept undefined, so coerce to a string
  13741. var title = $( this ).attr( "title" ) || "";
  13742. // Escape title, since we're going from an attribute to raw HTML
  13743. return $( "<a>" ).text( title ).html();
  13744. },
  13745. hide: true,
  13746. // Disabled elements have inconsistent behavior across browsers (#8661)
  13747. items: "[title]:not([disabled])",
  13748. position: {
  13749. my: "left top+15",
  13750. at: "left bottom",
  13751. collision: "flipfit flip"
  13752. },
  13753. show: true,
  13754. tooltipClass: null,
  13755. track: false,
  13757. // callbacks
  13758. close: null,
  13759. open: null
  13760. },
  13762. _addDescribedBy: function( elem, id ) {
  13763. var describedby = (elem.attr( "aria-describedby" ) || "").split( /\s+/ );
  13764. describedby.push( id );
  13765. elem
  13766. .data( "ui-tooltip-id", id )
  13767. .attr( "aria-describedby", $.trim( describedby.join( " " ) ) );
  13768. },
  13770. _removeDescribedBy: function( elem ) {
  13771. var id = elem.data( "ui-tooltip-id" ),
  13772. describedby = (elem.attr( "aria-describedby" ) || "").split( /\s+/ ),
  13773. index = $.inArray( id, describedby );
  13775. if ( index !== -1 ) {
  13776. describedby.splice( index, 1 );
  13777. }
  13779. elem.removeData( "ui-tooltip-id" );
  13780. describedby = $.trim( describedby.join( " " ) );
  13781. if ( describedby ) {
  13782. elem.attr( "aria-describedby", describedby );
  13783. } else {
  13784. elem.removeAttr( "aria-describedby" );
  13785. }
  13786. },
  13788. _create: function() {
  13789. this._on({
  13790. mouseover: "open",
  13791. focusin: "open"
  13792. });
  13794. // IDs of generated tooltips, needed for destroy
  13795. this.tooltips = {};
  13797. // IDs of parent tooltips where we removed the title attribute
  13798. this.parents = {};
  13800. if ( this.options.disabled ) {
  13801. this._disable();
  13802. }
  13804. // Append the aria-live region so tooltips announce correctly
  13805. this.liveRegion = $( "<div>" )
  13806. .attr({
  13807. role: "log",
  13808. "aria-live": "assertive",
  13809. "aria-relevant": "additions"
  13810. })
  13811. .addClass( "ui-helper-hidden-accessible" )
  13812. .appendTo( this.document[ 0 ].body );
  13813. },
  13815. _setOption: function( key, value ) {
  13816. var that = this;
  13818. if ( key === "disabled" ) {
  13819. this[ value ? "_disable" : "_enable" ]();
  13820. this.options[ key ] = value;
  13821. // disable element style changes
  13822. return;
  13823. }
  13825. this._super( key, value );
  13827. if ( key === "content" ) {
  13828. $.each( this.tooltips, function( id, tooltipData ) {
  13829. that._updateContent( tooltipData.element );
  13830. });
  13831. }
  13832. },
  13834. _disable: function() {
  13835. var that = this;
  13837. // close open tooltips
  13838. $.each( this.tooltips, function( id, tooltipData ) {
  13839. var event = $.Event( "blur" );
  13840. event.target = event.currentTarget = tooltipData.element[ 0 ];
  13841. that.close( event, true );
  13842. });
  13844. // remove title attributes to prevent native tooltips
  13845. this.element.find( this.options.items ).addBack().each(function() {
  13846. var element = $( this );
  13847. if ( element.is( "[title]" ) ) {
  13848. element
  13849. .data( "ui-tooltip-title", element.attr( "title" ) )
  13850. .removeAttr( "title" );
  13851. }
  13852. });
  13853. },
  13855. _enable: function() {
  13856. // restore title attributes
  13857. this.element.find( this.options.items ).addBack().each(function() {
  13858. var element = $( this );
  13859. if ( element.data( "ui-tooltip-title" ) ) {
  13860. element.attr( "title", element.data( "ui-tooltip-title" ) );
  13861. }
  13862. });
  13863. },
  13865. open: function( event ) {
  13866. var that = this,
  13867. target = $( event ? event.target : this.element )
  13868. // we need closest here due to mouseover bubbling,
  13869. // but always pointing at the same event target
  13870. .closest( this.options.items );
  13872. // No element to show a tooltip for or the tooltip is already open
  13873. if ( !target.length || target.data( "ui-tooltip-id" ) ) {
  13874. return;
  13875. }
  13877. if ( target.attr( "title" ) ) {
  13878. target.data( "ui-tooltip-title", target.attr( "title" ) );
  13879. }
  13881. target.data( "ui-tooltip-open", true );
  13883. // kill parent tooltips, custom or native, for hover
  13884. if ( event && event.type === "mouseover" ) {
  13885. target.parents().each(function() {
  13886. var parent = $( this ),
  13887. blurEvent;
  13888. if ( parent.data( "ui-tooltip-open" ) ) {
  13889. blurEvent = $.Event( "blur" );
  13890. blurEvent.target = blurEvent.currentTarget = this;
  13891. that.close( blurEvent, true );
  13892. }
  13893. if ( parent.attr( "title" ) ) {
  13894. parent.uniqueId();
  13895. that.parents[ this.id ] = {
  13896. element: this,
  13897. title: parent.attr( "title" )
  13898. };
  13899. parent.attr( "title", "" );
  13900. }
  13901. });
  13902. }
  13904. this._registerCloseHandlers( event, target );
  13905. this._updateContent( target, event );
  13906. },
  13908. _updateContent: function( target, event ) {
  13909. var content,
  13910. contentOption = this.options.content,
  13911. that = this,
  13912. eventType = event ? event.type : null;
  13914. if ( typeof contentOption === "string" ) {
  13915. return this._open( event, target, contentOption );
  13916. }
  13918. content = contentOption.call( target[0], function( response ) {
  13920. // IE may instantly serve a cached response for ajax requests
  13921. // delay this call to _open so the other call to _open runs first
  13922. that._delay(function() {
  13924. // Ignore async response if tooltip was closed already
  13925. if ( !target.data( "ui-tooltip-open" ) ) {
  13926. return;
  13927. }
  13929. // jQuery creates a special event for focusin when it doesn't
  13930. // exist natively. To improve performance, the native event
  13931. // object is reused and the type is changed. Therefore, we can't
  13932. // rely on the type being correct after the event finished
  13933. // bubbling, so we set it back to the previous value. (#8740)
  13934. if ( event ) {
  13935. event.type = eventType;
  13936. }
  13937. this._open( event, target, response );
  13938. });
  13939. });
  13940. if ( content ) {
  13941. this._open( event, target, content );
  13942. }
  13943. },
  13945. _open: function( event, target, content ) {
  13946. var tooltipData, tooltip, delayedShow, a11yContent,
  13947. positionOption = $.extend( {}, this.options.position );
  13949. if ( !content ) {
  13950. return;
  13951. }
  13953. // Content can be updated multiple times. If the tooltip already
  13954. // exists, then just update the content and bail.
  13955. tooltipData = this._find( target );
  13956. if ( tooltipData ) {
  13957. tooltipData.tooltip.find( ".ui-tooltip-content" ).html( content );
  13958. return;
  13959. }
  13961. // if we have a title, clear it to prevent the native tooltip
  13962. // we have to check first to avoid defining a title if none exists
  13963. // (we don't want to cause an element to start matching [title])
  13964. //
  13965. // We use removeAttr only for key events, to allow IE to export the correct
  13966. // accessible attributes. For mouse events, set to empty string to avoid
  13967. // native tooltip showing up (happens only when removing inside mouseover).
  13968. if ( target.is( "[title]" ) ) {
  13969. if ( event && event.type === "mouseover" ) {
  13970. target.attr( "title", "" );
  13971. } else {
  13972. target.removeAttr( "title" );
  13973. }
  13974. }
  13976. tooltipData = this._tooltip( target );
  13977. tooltip = tooltipData.tooltip;
  13978. this._addDescribedBy( target, tooltip.attr( "id" ) );
  13979. tooltip.find( ".ui-tooltip-content" ).html( content );
  13981. // Support: Voiceover on OS X, JAWS on IE <= 9
  13982. // JAWS announces deletions even when aria-relevant="additions"
  13983. // Voiceover will sometimes re-read the entire log region's contents from the beginning
  13984. this.liveRegion.children().hide();
  13985. if ( content.clone ) {
  13986. a11yContent = content.clone();
  13987. a11yContent.removeAttr( "id" ).find( "[id]" ).removeAttr( "id" );
  13988. } else {
  13989. a11yContent = content;
  13990. }
  13991. $( "<div>" ).html( a11yContent ).appendTo( this.liveRegion );
  13993. function position( event ) {
  13994. positionOption.of = event;
  13995. if ( tooltip.is( ":hidden" ) ) {
  13996. return;
  13997. }
  13998. tooltip.position( positionOption );
  13999. }
  14000. if ( this.options.track && event && /^mouse/.test( event.type ) ) {
  14001. this._on( this.document, {
  14002. mousemove: position
  14003. });
  14004. // trigger once to override element-relative positioning
  14005. position( event );
  14006. } else {
  14007. tooltip.position( $.extend({
  14008. of: target
  14009. }, this.options.position ) );
  14010. }
  14012. tooltip.hide();
  14014. this._show( tooltip, this.options.show );
  14015. // Handle tracking tooltips that are shown with a delay (#8644). As soon
  14016. // as the tooltip is visible, position the tooltip using the most recent
  14017. // event.
  14018. if ( this.options.show && this.options.show.delay ) {
  14019. delayedShow = this.delayedShow = setInterval(function() {
  14020. if ( tooltip.is( ":visible" ) ) {
  14021. position( positionOption.of );
  14022. clearInterval( delayedShow );
  14023. }
  14024. }, $.fx.interval );
  14025. }
  14027. this._trigger( "open", event, { tooltip: tooltip } );
  14028. },
  14030. _registerCloseHandlers: function( event, target ) {
  14031. var events = {
  14032. keyup: function( event ) {
  14033. if ( event.keyCode === $.ui.keyCode.ESCAPE ) {
  14034. var fakeEvent = $.Event(event);
  14035. fakeEvent.currentTarget = target[0];
  14036. this.close( fakeEvent, true );
  14037. }
  14038. }
  14039. };
  14041. // Only bind remove handler for delegated targets. Non-delegated
  14042. // tooltips will handle this in destroy.
  14043. if ( target[ 0 ] !== this.element[ 0 ] ) {
  14044. events.remove = function() {
  14045. this._removeTooltip( this._find( target ).tooltip );
  14046. };
  14047. }
  14049. if ( !event || event.type === "mouseover" ) {
  14050. events.mouseleave = "close";
  14051. }
  14052. if ( !event || event.type === "focusin" ) {
  14053. events.focusout = "close";
  14054. }
  14055. this._on( true, target, events );
  14056. },
  14058. close: function( event ) {
  14059. var tooltip,
  14060. that = this,
  14061. target = $( event ? event.currentTarget : this.element ),
  14062. tooltipData = this._find( target );
  14064. // The tooltip may already be closed
  14065. if ( !tooltipData ) {
  14067. // We set ui-tooltip-open immediately upon open (in open()), but only set the
  14068. // additional data once there's actually content to show (in _open()). So even if the
  14069. // tooltip doesn't have full data, we always remove ui-tooltip-open in case we're in
  14070. // the period between open() and _open().
  14071. target.removeData( "ui-tooltip-open" );
  14072. return;
  14073. }
  14075. tooltip = tooltipData.tooltip;
  14077. // disabling closes the tooltip, so we need to track when we're closing
  14078. // to avoid an infinite loop in case the tooltip becomes disabled on close
  14079. if ( tooltipData.closing ) {
  14080. return;
  14081. }
  14083. // Clear the interval for delayed tracking tooltips
  14084. clearInterval( this.delayedShow );
  14086. // only set title if we had one before (see comment in _open())
  14087. // If the title attribute has changed since open(), don't restore
  14088. if ( target.data( "ui-tooltip-title" ) && !target.attr( "title" ) ) {
  14089. target.attr( "title", target.data( "ui-tooltip-title" ) );
  14090. }
  14092. this._removeDescribedBy( target );
  14094. tooltipData.hiding = true;
  14095. tooltip.stop( true );
  14096. this._hide( tooltip, this.options.hide, function() {
  14097. that._removeTooltip( $( this ) );
  14098. });
  14100. target.removeData( "ui-tooltip-open" );
  14101. this._off( target, "mouseleave focusout keyup" );
  14103. // Remove 'remove' binding only on delegated targets
  14104. if ( target[ 0 ] !== this.element[ 0 ] ) {
  14105. this._off( target, "remove" );
  14106. }
  14107. this._off( this.document, "mousemove" );
  14109. if ( event && event.type === "mouseleave" ) {
  14110. $.each( this.parents, function( id, parent ) {
  14111. $( parent.element ).attr( "title", parent.title );
  14112. delete that.parents[ id ];
  14113. });
  14114. }
  14116. tooltipData.closing = true;
  14117. this._trigger( "close", event, { tooltip: tooltip } );
  14118. if ( !tooltipData.hiding ) {
  14119. tooltipData.closing = false;
  14120. }
  14121. },
  14123. _tooltip: function( element ) {
  14124. var tooltip = $( "<div>" )
  14125. .attr( "role", "tooltip" )
  14126. .addClass( "ui-tooltip ui-widget ui-corner-all ui-widget-content " +
  14127. ( this.options.tooltipClass || "" ) ),
  14128. id = tooltip.uniqueId().attr( "id" );
  14130. $( "<div>" )
  14131. .addClass( "ui-tooltip-content" )
  14132. .appendTo( tooltip );
  14134. tooltip.appendTo( this.document[0].body );
  14136. return this.tooltips[ id ] = {
  14137. element: element,
  14138. tooltip: tooltip
  14139. };
  14140. },
  14142. _find: function( target ) {
  14143. var id = target.data( "ui-tooltip-id" );
  14144. return id ? this.tooltips[ id ] : null;
  14145. },
  14147. _removeTooltip: function( tooltip ) {
  14148. tooltip.remove();
  14149. delete this.tooltips[ tooltip.attr( "id" ) ];
  14150. },
  14152. _destroy: function() {
  14153. var that = this;
  14155. // close open tooltips
  14156. $.each( this.tooltips, function( id, tooltipData ) {
  14157. // Delegate to close method to handle common cleanup
  14158. var event = $.Event( "blur" ),
  14159. element = tooltipData.element;
  14160. event.target = event.currentTarget = element[ 0 ];
  14161. that.close( event, true );
  14163. // Remove immediately; destroying an open tooltip doesn't use the
  14164. // hide animation
  14165. $( "#" + id ).remove();
  14167. // Restore the title
  14168. if ( element.data( "ui-tooltip-title" ) ) {
  14169. // If the title attribute has changed since open(), don't restore
  14170. if ( !element.attr( "title" ) ) {
  14171. element.attr( "title", element.data( "ui-tooltip-title" ) );
  14172. }
  14173. element.removeData( "ui-tooltip-title" );
  14174. }
  14175. });
  14176. this.liveRegion.remove();
  14177. }
  14178. });
  14181. /*!
  14182. * jQuery UI Effects 1.11.4
  14183. * http://jqueryui.com
  14184. *
  14185. * Copyright jQuery Foundation and other contributors
  14186. * Released under the MIT license.
  14187. * http://jquery.org/license
  14188. *
  14189. * http://api.jqueryui.com/category/effects-core/
  14190. */
  14193. var dataSpace = "ui-effects-",
  14195. // Create a local jQuery because jQuery Color relies on it and the
  14196. // global may not exist with AMD and a custom build (#10199)
  14197. jQuery = $;
  14199. $.effects = {
  14200. effect: {}
  14201. };
  14203. /*!
  14204. * jQuery Color Animations v2.1.2
  14205. * https://github.com/jquery/jquery-color
  14206. *
  14207. * Copyright 2014 jQuery Foundation and other contributors
  14208. * Released under the MIT license.
  14209. * http://jquery.org/license
  14210. *
  14211. * Date: Wed Jan 16 08:47:09 2013 -0600
  14212. */
  14213. (function( jQuery, undefined ) {
  14215. var stepHooks = "backgroundColor borderBottomColor borderLeftColor borderRightColor borderTopColor color columnRuleColor outlineColor textDecorationColor textEmphasisColor",
  14217. // plusequals test for += 100 -= 100
  14218. rplusequals = /^([\-+])=\s*(\d+\.?\d*)/,
  14219. // a set of RE's that can match strings and generate color tuples.
  14220. stringParsers = [ {
  14221. re: /rgba?\(\s*(\d{1,3})\s*,\s*(\d{1,3})\s*,\s*(\d{1,3})\s*(?:,\s*(\d?(?:\.\d+)?)\s*)?\)/,
  14222. parse: function( execResult ) {
  14223. return [
  14224. execResult[ 1 ],
  14225. execResult[ 2 ],
  14226. execResult[ 3 ],
  14227. execResult[ 4 ]
  14228. ];
  14229. }
  14230. }, {
  14231. re: /rgba?\(\s*(\d+(?:\.\d+)?)\%\s*,\s*(\d+(?:\.\d+)?)\%\s*,\s*(\d+(?:\.\d+)?)\%\s*(?:,\s*(\d?(?:\.\d+)?)\s*)?\)/,
  14232. parse: function( execResult ) {
  14233. return [
  14234. execResult[ 1 ] * 2.55,
  14235. execResult[ 2 ] * 2.55,
  14236. execResult[ 3 ] * 2.55,
  14237. execResult[ 4 ]
  14238. ];
  14239. }
  14240. }, {
  14241. // this regex ignores A-F because it's compared against an already lowercased string
  14242. re: /#([a-f0-9]{2})([a-f0-9]{2})([a-f0-9]{2})/,
  14243. parse: function( execResult ) {
  14244. return [
  14245. parseInt( execResult[ 1 ], 16 ),
  14246. parseInt( execResult[ 2 ], 16 ),
  14247. parseInt( execResult[ 3 ], 16 )
  14248. ];
  14249. }
  14250. }, {
  14251. // this regex ignores A-F because it's compared against an already lowercased string
  14252. re: /#([a-f0-9])([a-f0-9])([a-f0-9])/,
  14253. parse: function( execResult ) {
  14254. return [
  14255. parseInt( execResult[ 1 ] + execResult[ 1 ], 16 ),
  14256. parseInt( execResult[ 2 ] + execResult[ 2 ], 16 ),
  14257. parseInt( execResult[ 3 ] + execResult[ 3 ], 16 )
  14258. ];
  14259. }
  14260. }, {
  14261. re: /hsla?\(\s*(\d+(?:\.\d+)?)\s*,\s*(\d+(?:\.\d+)?)\%\s*,\s*(\d+(?:\.\d+)?)\%\s*(?:,\s*(\d?(?:\.\d+)?)\s*)?\)/,
  14262. space: "hsla",
  14263. parse: function( execResult ) {
  14264. return [
  14265. execResult[ 1 ],
  14266. execResult[ 2 ] / 100,
  14267. execResult[ 3 ] / 100,
  14268. execResult[ 4 ]
  14269. ];
  14270. }
  14271. } ],
  14273. // jQuery.Color( )
  14274. color = jQuery.Color = function( color, green, blue, alpha ) {
  14275. return new jQuery.Color.fn.parse( color, green, blue, alpha );
  14276. },
  14277. spaces = {
  14278. rgba: {
  14279. props: {
  14280. red: {
  14281. idx: 0,
  14282. type: "byte"
  14283. },
  14284. green: {
  14285. idx: 1,
  14286. type: "byte"
  14287. },
  14288. blue: {
  14289. idx: 2,
  14290. type: "byte"
  14291. }
  14292. }
  14293. },
  14295. hsla: {
  14296. props: {
  14297. hue: {
  14298. idx: 0,
  14299. type: "degrees"
  14300. },
  14301. saturation: {
  14302. idx: 1,
  14303. type: "percent"
  14304. },
  14305. lightness: {
  14306. idx: 2,
  14307. type: "percent"
  14308. }
  14309. }
  14310. }
  14311. },
  14312. propTypes = {
  14313. "byte": {
  14314. floor: true,
  14315. max: 255
  14316. },
  14317. "percent": {
  14318. max: 1
  14319. },
  14320. "degrees": {
  14321. mod: 360,
  14322. floor: true
  14323. }
  14324. },
  14325. support = color.support = {},
  14327. // element for support tests
  14328. supportElem = jQuery( "<p>" )[ 0 ],
  14330. // colors = jQuery.Color.names
  14331. colors,
  14333. // local aliases of functions called often
  14334. each = jQuery.each;
  14336. // determine rgba support immediately
  14337. supportElem.style.cssText = "background-color:rgba(1,1,1,.5)";
  14338. support.rgba = supportElem.style.backgroundColor.indexOf( "rgba" ) > -1;
  14340. // define cache name and alpha properties
  14341. // for rgba and hsla spaces
  14342. each( spaces, function( spaceName, space ) {
  14343. space.cache = "_" + spaceName;
  14344. space.props.alpha = {
  14345. idx: 3,
  14346. type: "percent",
  14347. def: 1
  14348. };
  14349. });
  14351. function clamp( value, prop, allowEmpty ) {
  14352. var type = propTypes[ prop.type ] || {};
  14354. if ( value == null ) {
  14355. return (allowEmpty || !prop.def) ? null : prop.def;
  14356. }
  14358. // ~~ is an short way of doing floor for positive numbers
  14359. value = type.floor ? ~~value : parseFloat( value );
  14361. // IE will pass in empty strings as value for alpha,
  14362. // which will hit this case
  14363. if ( isNaN( value ) ) {
  14364. return prop.def;
  14365. }
  14367. if ( type.mod ) {
  14368. // we add mod before modding to make sure that negatives values
  14369. // get converted properly: -10 -> 350
  14370. return (value + type.mod) % type.mod;
  14371. }
  14373. // for now all property types without mod have min and max
  14374. return 0 > value ? 0 : type.max < value ? type.max : value;
  14375. }
  14377. function stringParse( string ) {
  14378. var inst = color(),
  14379. rgba = inst._rgba = [];
  14381. string = string.toLowerCase();
  14383. each( stringParsers, function( i, parser ) {
  14384. var parsed,
  14385. match = parser.re.exec( string ),
  14386. values = match && parser.parse( match ),
  14387. spaceName = parser.space || "rgba";
  14389. if ( values ) {
  14390. parsed = inst[ spaceName ]( values );
  14392. // if this was an rgba parse the assignment might happen twice
  14393. // oh well....
  14394. inst[ spaces[ spaceName ].cache ] = parsed[ spaces[ spaceName ].cache ];
  14395. rgba = inst._rgba = parsed._rgba;
  14397. // exit each( stringParsers ) here because we matched
  14398. return false;
  14399. }
  14400. });
  14402. // Found a stringParser that handled it
  14403. if ( rgba.length ) {
  14405. // if this came from a parsed string, force "transparent" when alpha is 0
  14406. // chrome, (and maybe others) return "transparent" as rgba(0,0,0,0)
  14407. if ( rgba.join() === "0,0,0,0" ) {
  14408. jQuery.extend( rgba, colors.transparent );
  14409. }
  14410. return inst;
  14411. }
  14413. // named colors
  14414. return colors[ string ];
  14415. }
  14417. color.fn = jQuery.extend( color.prototype, {
  14418. parse: function( red, green, blue, alpha ) {
  14419. if ( red === undefined ) {
  14420. this._rgba = [ null, null, null, null ];
  14421. return this;
  14422. }
  14423. if ( red.jquery || red.nodeType ) {
  14424. red = jQuery( red ).css( green );
  14425. green = undefined;
  14426. }
  14428. var inst = this,
  14429. type = jQuery.type( red ),
  14430. rgba = this._rgba = [];
  14432. // more than 1 argument specified - assume ( red, green, blue, alpha )
  14433. if ( green !== undefined ) {
  14434. red = [ red, green, blue, alpha ];
  14435. type = "array";
  14436. }
  14438. if ( type === "string" ) {
  14439. return this.parse( stringParse( red ) || colors._default );
  14440. }
  14442. if ( type === "array" ) {
  14443. each( spaces.rgba.props, function( key, prop ) {
  14444. rgba[ prop.idx ] = clamp( red[ prop.idx ], prop );
  14445. });
  14446. return this;
  14447. }
  14449. if ( type === "object" ) {
  14450. if ( red instanceof color ) {
  14451. each( spaces, function( spaceName, space ) {
  14452. if ( red[ space.cache ] ) {
  14453. inst[ space.cache ] = red[ space.cache ].slice();
  14454. }
  14455. });
  14456. } else {
  14457. each( spaces, function( spaceName, space ) {
  14458. var cache = space.cache;
  14459. each( space.props, function( key, prop ) {
  14461. // if the cache doesn't exist, and we know how to convert
  14462. if ( !inst[ cache ] && space.to ) {
  14464. // if the value was null, we don't need to copy it
  14465. // if the key was alpha, we don't need to copy it either
  14466. if ( key === "alpha" || red[ key ] == null ) {
  14467. return;
  14468. }
  14469. inst[ cache ] = space.to( inst._rgba );
  14470. }
  14472. // this is the only case where we allow nulls for ALL properties.
  14473. // call clamp with alwaysAllowEmpty
  14474. inst[ cache ][ prop.idx ] = clamp( red[ key ], prop, true );
  14475. });
  14477. // everything defined but alpha?
  14478. if ( inst[ cache ] && jQuery.inArray( null, inst[ cache ].slice( 0, 3 ) ) < 0 ) {
  14479. // use the default of 1
  14480. inst[ cache ][ 3 ] = 1;
  14481. if ( space.from ) {
  14482. inst._rgba = space.from( inst[ cache ] );
  14483. }
  14484. }
  14485. });
  14486. }
  14487. return this;
  14488. }
  14489. },
  14490. is: function( compare ) {
  14491. var is = color( compare ),
  14492. same = true,
  14493. inst = this;
  14495. each( spaces, function( _, space ) {
  14496. var localCache,
  14497. isCache = is[ space.cache ];
  14498. if (isCache) {
  14499. localCache = inst[ space.cache ] || space.to && space.to( inst._rgba ) || [];
  14500. each( space.props, function( _, prop ) {
  14501. if ( isCache[ prop.idx ] != null ) {
  14502. same = ( isCache[ prop.idx ] === localCache[ prop.idx ] );
  14503. return same;
  14504. }
  14505. });
  14506. }
  14507. return same;
  14508. });
  14509. return same;
  14510. },
  14511. _space: function() {
  14512. var used = [],
  14513. inst = this;
  14514. each( spaces, function( spaceName, space ) {
  14515. if ( inst[ space.cache ] ) {
  14516. used.push( spaceName );
  14517. }
  14518. });
  14519. return used.pop();
  14520. },
  14521. transition: function( other, distance ) {
  14522. var end = color( other ),
  14523. spaceName = end._space(),
  14524. space = spaces[ spaceName ],
  14525. startColor = this.alpha() === 0 ? color( "transparent" ) : this,
  14526. start = startColor[ space.cache ] || space.to( startColor._rgba ),
  14527. result = start.slice();
  14529. end = end[ space.cache ];
  14530. each( space.props, function( key, prop ) {
  14531. var index = prop.idx,
  14532. startValue = start[ index ],
  14533. endValue = end[ index ],
  14534. type = propTypes[ prop.type ] || {};
  14536. // if null, don't override start value
  14537. if ( endValue === null ) {
  14538. return;
  14539. }
  14540. // if null - use end
  14541. if ( startValue === null ) {
  14542. result[ index ] = endValue;
  14543. } else {
  14544. if ( type.mod ) {
  14545. if ( endValue - startValue > type.mod / 2 ) {
  14546. startValue += type.mod;
  14547. } else if ( startValue - endValue > type.mod / 2 ) {
  14548. startValue -= type.mod;
  14549. }
  14550. }
  14551. result[ index ] = clamp( ( endValue - startValue ) * distance + startValue, prop );
  14552. }
  14553. });
  14554. return this[ spaceName ]( result );
  14555. },
  14556. blend: function( opaque ) {
  14557. // if we are already opaque - return ourself
  14558. if ( this._rgba[ 3 ] === 1 ) {
  14559. return this;
  14560. }
  14562. var rgb = this._rgba.slice(),
  14563. a = rgb.pop(),
  14564. blend = color( opaque )._rgba;
  14566. return color( jQuery.map( rgb, function( v, i ) {
  14567. return ( 1 - a ) * blend[ i ] + a * v;
  14568. }));
  14569. },
  14570. toRgbaString: function() {
  14571. var prefix = "rgba(",
  14572. rgba = jQuery.map( this._rgba, function( v, i ) {
  14573. return v == null ? ( i > 2 ? 1 : 0 ) : v;
  14574. });
  14576. if ( rgba[ 3 ] === 1 ) {
  14577. rgba.pop();
  14578. prefix = "rgb(";
  14579. }
  14581. return prefix + rgba.join() + ")";
  14582. },
  14583. toHslaString: function() {
  14584. var prefix = "hsla(",
  14585. hsla = jQuery.map( this.hsla(), function( v, i ) {
  14586. if ( v == null ) {
  14587. v = i > 2 ? 1 : 0;
  14588. }
  14590. // catch 1 and 2
  14591. if ( i && i < 3 ) {
  14592. v = Math.round( v * 100 ) + "%";
  14593. }
  14594. return v;
  14595. });
  14597. if ( hsla[ 3 ] === 1 ) {
  14598. hsla.pop();
  14599. prefix = "hsl(";
  14600. }
  14601. return prefix + hsla.join() + ")";
  14602. },
  14603. toHexString: function( includeAlpha ) {
  14604. var rgba = this._rgba.slice(),
  14605. alpha = rgba.pop();
  14607. if ( includeAlpha ) {
  14608. rgba.push( ~~( alpha * 255 ) );
  14609. }
  14611. return "#" + jQuery.map( rgba, function( v ) {
  14613. // default to 0 when nulls exist
  14614. v = ( v || 0 ).toString( 16 );
  14615. return v.length === 1 ? "0" + v : v;
  14616. }).join("");
  14617. },
  14618. toString: function() {
  14619. return this._rgba[ 3 ] === 0 ? "transparent" : this.toRgbaString();
  14620. }
  14621. });
  14622. color.fn.parse.prototype = color.fn;
  14624. // hsla conversions adapted from:
  14625. // https://code.google.com/p/maashaack/source/browse/packages/graphics/trunk/src/graphics/colors/HUE2RGB.as?r=5021
  14627. function hue2rgb( p, q, h ) {
  14628. h = ( h + 1 ) % 1;
  14629. if ( h * 6 < 1 ) {
  14630. return p + ( q - p ) * h * 6;
  14631. }
  14632. if ( h * 2 < 1) {
  14633. return q;
  14634. }
  14635. if ( h * 3 < 2 ) {
  14636. return p + ( q - p ) * ( ( 2 / 3 ) - h ) * 6;
  14637. }
  14638. return p;
  14639. }
  14641. spaces.hsla.to = function( rgba ) {
  14642. if ( rgba[ 0 ] == null || rgba[ 1 ] == null || rgba[ 2 ] == null ) {
  14643. return [ null, null, null, rgba[ 3 ] ];
  14644. }
  14645. var r = rgba[ 0 ] / 255,
  14646. g = rgba[ 1 ] / 255,
  14647. b = rgba[ 2 ] / 255,
  14648. a = rgba[ 3 ],
  14649. max = Math.max( r, g, b ),
  14650. min = Math.min( r, g, b ),
  14651. diff = max - min,
  14652. add = max + min,
  14653. l = add * 0.5,
  14654. h, s;
  14656. if ( min === max ) {
  14657. h = 0;
  14658. } else if ( r === max ) {
  14659. h = ( 60 * ( g - b ) / diff ) + 360;
  14660. } else if ( g === max ) {
  14661. h = ( 60 * ( b - r ) / diff ) + 120;
  14662. } else {
  14663. h = ( 60 * ( r - g ) / diff ) + 240;
  14664. }
  14666. // chroma (diff) == 0 means greyscale which, by definition, saturation = 0%
  14667. // otherwise, saturation is based on the ratio of chroma (diff) to lightness (add)
  14668. if ( diff === 0 ) {
  14669. s = 0;
  14670. } else if ( l <= 0.5 ) {
  14671. s = diff / add;
  14672. } else {
  14673. s = diff / ( 2 - add );
  14674. }
  14675. return [ Math.round(h) % 360, s, l, a == null ? 1 : a ];
  14676. };
  14678. spaces.hsla.from = function( hsla ) {
  14679. if ( hsla[ 0 ] == null || hsla[ 1 ] == null || hsla[ 2 ] == null ) {
  14680. return [ null, null, null, hsla[ 3 ] ];
  14681. }
  14682. var h = hsla[ 0 ] / 360,
  14683. s = hsla[ 1 ],
  14684. l = hsla[ 2 ],
  14685. a = hsla[ 3 ],
  14686. q = l <= 0.5 ? l * ( 1 + s ) : l + s - l * s,
  14687. p = 2 * l - q;
  14689. return [
  14690. Math.round( hue2rgb( p, q, h + ( 1 / 3 ) ) * 255 ),
  14691. Math.round( hue2rgb( p, q, h ) * 255 ),
  14692. Math.round( hue2rgb( p, q, h - ( 1 / 3 ) ) * 255 ),
  14693. a
  14694. ];
  14695. };
  14697. each( spaces, function( spaceName, space ) {
  14698. var props = space.props,
  14699. cache = space.cache,
  14700. to = space.to,
  14701. from = space.from;
  14703. // makes rgba() and hsla()
  14704. color.fn[ spaceName ] = function( value ) {
  14706. // generate a cache for this space if it doesn't exist
  14707. if ( to && !this[ cache ] ) {
  14708. this[ cache ] = to( this._rgba );
  14709. }
  14710. if ( value === undefined ) {
  14711. return this[ cache ].slice();
  14712. }
  14714. var ret,
  14715. type = jQuery.type( value ),
  14716. arr = ( type === "array" || type === "object" ) ? value : arguments,
  14717. local = this[ cache ].slice();
  14719. each( props, function( key, prop ) {
  14720. var val = arr[ type === "object" ? key : prop.idx ];
  14721. if ( val == null ) {
  14722. val = local[ prop.idx ];
  14723. }
  14724. local[ prop.idx ] = clamp( val, prop );
  14725. });
  14727. if ( from ) {
  14728. ret = color( from( local ) );
  14729. ret[ cache ] = local;
  14730. return ret;
  14731. } else {
  14732. return color( local );
  14733. }
  14734. };
  14736. // makes red() green() blue() alpha() hue() saturation() lightness()
  14737. each( props, function( key, prop ) {
  14738. // alpha is included in more than one space
  14739. if ( color.fn[ key ] ) {
  14740. return;
  14741. }
  14742. color.fn[ key ] = function( value ) {
  14743. var vtype = jQuery.type( value ),
  14744. fn = ( key === "alpha" ? ( this._hsla ? "hsla" : "rgba" ) : spaceName ),
  14745. local = this[ fn ](),
  14746. cur = local[ prop.idx ],
  14747. match;
  14749. if ( vtype === "undefined" ) {
  14750. return cur;
  14751. }
  14753. if ( vtype === "function" ) {
  14754. value = value.call( this, cur );
  14755. vtype = jQuery.type( value );
  14756. }
  14757. if ( value == null && prop.empty ) {
  14758. return this;
  14759. }
  14760. if ( vtype === "string" ) {
  14761. match = rplusequals.exec( value );
  14762. if ( match ) {
  14763. value = cur + parseFloat( match[ 2 ] ) * ( match[ 1 ] === "+" ? 1 : -1 );
  14764. }
  14765. }
  14766. local[ prop.idx ] = value;
  14767. return this[ fn ]( local );
  14768. };
  14769. });
  14770. });
  14772. // add cssHook and .fx.step function for each named hook.
  14773. // accept a space separated string of properties
  14774. color.hook = function( hook ) {
  14775. var hooks = hook.split( " " );
  14776. each( hooks, function( i, hook ) {
  14777. jQuery.cssHooks[ hook ] = {
  14778. set: function( elem, value ) {
  14779. var parsed, curElem,
  14780. backgroundColor = "";
  14782. if ( value !== "transparent" && ( jQuery.type( value ) !== "string" || ( parsed = stringParse( value ) ) ) ) {
  14783. value = color( parsed || value );
  14784. if ( !support.rgba && value._rgba[ 3 ] !== 1 ) {
  14785. curElem = hook === "backgroundColor" ? elem.parentNode : elem;
  14786. while (
  14787. (backgroundColor === "" || backgroundColor === "transparent") &&
  14788. curElem && curElem.style
  14789. ) {
  14790. try {
  14791. backgroundColor = jQuery.css( curElem, "backgroundColor" );
  14792. curElem = curElem.parentNode;
  14793. } catch ( e ) {
  14794. }
  14795. }
  14797. value = value.blend( backgroundColor && backgroundColor !== "transparent" ?
  14798. backgroundColor :
  14799. "_default" );
  14800. }
  14802. value = value.toRgbaString();
  14803. }
  14804. try {
  14805. elem.style[ hook ] = value;
  14806. } catch ( e ) {
  14807. // wrapped to prevent IE from throwing errors on "invalid" values like 'auto' or 'inherit'
  14808. }
  14809. }
  14810. };
  14811. jQuery.fx.step[ hook ] = function( fx ) {
  14812. if ( !fx.colorInit ) {
  14813. fx.start = color( fx.elem, hook );
  14814. fx.end = color( fx.end );
  14815. fx.colorInit = true;
  14816. }
  14817. jQuery.cssHooks[ hook ].set( fx.elem, fx.start.transition( fx.end, fx.pos ) );
  14818. };
  14819. });
  14821. };
  14823. color.hook( stepHooks );
  14825. jQuery.cssHooks.borderColor = {
  14826. expand: function( value ) {
  14827. var expanded = {};
  14829. each( [ "Top", "Right", "Bottom", "Left" ], function( i, part ) {
  14830. expanded[ "border" + part + "Color" ] = value;
  14831. });
  14832. return expanded;
  14833. }
  14834. };
  14836. // Basic color names only.
  14837. // Usage of any of the other color names requires adding yourself or including
  14838. // jquery.color.svg-names.js.
  14839. colors = jQuery.Color.names = {
  14840. // 4.1. Basic color keywords
  14841. aqua: "#00ffff",
  14842. black: "#000000",
  14843. blue: "#0000ff",
  14844. fuchsia: "#ff00ff",
  14845. gray: "#808080",
  14846. green: "#008000",
  14847. lime: "#00ff00",
  14848. maroon: "#800000",
  14849. navy: "#000080",
  14850. olive: "#808000",
  14851. purple: "#800080",
  14852. red: "#ff0000",
  14853. silver: "#c0c0c0",
  14854. teal: "#008080",
  14855. white: "#ffffff",
  14856. yellow: "#ffff00",
  14858. // 4.2.3. "transparent" color keyword
  14859. transparent: [ null, null, null, 0 ],
  14861. _default: "#ffffff"
  14862. };
  14864. })( jQuery );
  14866. /******************************************************************************/
  14867. /****************************** CLASS ANIMATIONS ******************************/
  14868. /******************************************************************************/
  14869. (function() {
  14871. var classAnimationActions = [ "add", "remove", "toggle" ],
  14872. shorthandStyles = {
  14873. border: 1,
  14874. borderBottom: 1,
  14875. borderColor: 1,
  14876. borderLeft: 1,
  14877. borderRight: 1,
  14878. borderTop: 1,
  14879. borderWidth: 1,
  14880. margin: 1,
  14881. padding: 1
  14882. };
  14884. $.each([ "borderLeftStyle", "borderRightStyle", "borderBottomStyle", "borderTopStyle" ], function( _, prop ) {
  14885. $.fx.step[ prop ] = function( fx ) {
  14886. if ( fx.end !== "none" && !fx.setAttr || fx.pos === 1 && !fx.setAttr ) {
  14887. jQuery.style( fx.elem, prop, fx.end );
  14888. fx.setAttr = true;
  14889. }
  14890. };
  14891. });
  14893. function getElementStyles( elem ) {
  14894. var key, len,
  14895. style = elem.ownerDocument.defaultView ?
  14896. elem.ownerDocument.defaultView.getComputedStyle( elem, null ) :
  14897. elem.currentStyle,
  14898. styles = {};
  14900. if ( style && style.length && style[ 0 ] && style[ style[ 0 ] ] ) {
  14901. len = style.length;
  14902. while ( len-- ) {
  14903. key = style[ len ];
  14904. if ( typeof style[ key ] === "string" ) {
  14905. styles[ $.camelCase( key ) ] = style[ key ];
  14906. }
  14907. }
  14908. // support: Opera, IE <9
  14909. } else {
  14910. for ( key in style ) {
  14911. if ( typeof style[ key ] === "string" ) {
  14912. styles[ key ] = style[ key ];
  14913. }
  14914. }
  14915. }
  14917. return styles;
  14918. }
  14920. function styleDifference( oldStyle, newStyle ) {
  14921. var diff = {},
  14922. name, value;
  14924. for ( name in newStyle ) {
  14925. value = newStyle[ name ];
  14926. if ( oldStyle[ name ] !== value ) {
  14927. if ( !shorthandStyles[ name ] ) {
  14928. if ( $.fx.step[ name ] || !isNaN( parseFloat( value ) ) ) {
  14929. diff[ name ] = value;
  14930. }
  14931. }
  14932. }
  14933. }
  14935. return diff;
  14936. }
  14938. // support: jQuery <1.8
  14939. if ( !$.fn.addBack ) {
  14940. $.fn.addBack = function( selector ) {
  14941. return this.add( selector == null ?
  14942. this.prevObject : this.prevObject.filter( selector )
  14943. );
  14944. };
  14945. }
  14947. $.effects.animateClass = function( value, duration, easing, callback ) {
  14948. var o = $.speed( duration, easing, callback );
  14950. return this.queue( function() {
  14951. var animated = $( this ),
  14952. baseClass = animated.attr( "class" ) || "",
  14953. applyClassChange,
  14954. allAnimations = o.children ? animated.find( "*" ).addBack() : animated;
  14956. // map the animated objects to store the original styles.
  14957. allAnimations = allAnimations.map(function() {
  14958. var el = $( this );
  14959. return {
  14960. el: el,
  14961. start: getElementStyles( this )
  14962. };
  14963. });
  14965. // apply class change
  14966. applyClassChange = function() {
  14967. $.each( classAnimationActions, function(i, action) {
  14968. if ( value[ action ] ) {
  14969. animated[ action + "Class" ]( value[ action ] );
  14970. }
  14971. });
  14972. };
  14973. applyClassChange();
  14975. // map all animated objects again - calculate new styles and diff
  14976. allAnimations = allAnimations.map(function() {
  14977. this.end = getElementStyles( this.el[ 0 ] );
  14978. this.diff = styleDifference( this.start, this.end );
  14979. return this;
  14980. });
  14982. // apply original class
  14983. animated.attr( "class", baseClass );
  14985. // map all animated objects again - this time collecting a promise
  14986. allAnimations = allAnimations.map(function() {
  14987. var styleInfo = this,
  14988. dfd = $.Deferred(),
  14989. opts = $.extend({}, o, {
  14990. queue: false,
  14991. complete: function() {
  14992. dfd.resolve( styleInfo );
  14993. }
  14994. });
  14996. this.el.animate( this.diff, opts );
  14997. return dfd.promise();
  14998. });
  15000. // once all animations have completed:
  15001. $.when.apply( $, allAnimations.get() ).done(function() {
  15003. // set the final class
  15004. applyClassChange();
  15006. // for each animated element,
  15007. // clear all css properties that were animated
  15008. $.each( arguments, function() {
  15009. var el = this.el;
  15010. $.each( this.diff, function(key) {
  15011. el.css( key, "" );
  15012. });
  15013. });
  15015. // this is guarnteed to be there if you use jQuery.speed()
  15016. // it also handles dequeuing the next anim...
  15017. o.complete.call( animated[ 0 ] );
  15018. });
  15019. });
  15020. };
  15022. $.fn.extend({
  15023. addClass: (function( orig ) {
  15024. return function( classNames, speed, easing, callback ) {
  15025. return speed ?
  15026. $.effects.animateClass.call( this,
  15027. { add: classNames }, speed, easing, callback ) :
  15028. orig.apply( this, arguments );
  15029. };
  15030. })( $.fn.addClass ),
  15032. removeClass: (function( orig ) {
  15033. return function( classNames, speed, easing, callback ) {
  15034. return arguments.length > 1 ?
  15035. $.effects.animateClass.call( this,
  15036. { remove: classNames }, speed, easing, callback ) :
  15037. orig.apply( this, arguments );
  15038. };
  15039. })( $.fn.removeClass ),
  15041. toggleClass: (function( orig ) {
  15042. return function( classNames, force, speed, easing, callback ) {
  15043. if ( typeof force === "boolean" || force === undefined ) {
  15044. if ( !speed ) {
  15045. // without speed parameter
  15046. return orig.apply( this, arguments );
  15047. } else {
  15048. return $.effects.animateClass.call( this,
  15049. (force ? { add: classNames } : { remove: classNames }),
  15050. speed, easing, callback );
  15051. }
  15052. } else {
  15053. // without force parameter
  15054. return $.effects.animateClass.call( this,
  15055. { toggle: classNames }, force, speed, easing );
  15056. }
  15057. };
  15058. })( $.fn.toggleClass ),
  15060. switchClass: function( remove, add, speed, easing, callback) {
  15061. return $.effects.animateClass.call( this, {
  15062. add: add,
  15063. remove: remove
  15064. }, speed, easing, callback );
  15065. }
  15066. });
  15068. })();
  15070. /******************************************************************************/
  15071. /*********************************** EFFECTS **********************************/
  15072. /******************************************************************************/
  15074. (function() {
  15076. $.extend( $.effects, {
  15077. version: "1.11.4",
  15079. // Saves a set of properties in a data storage
  15080. save: function( element, set ) {
  15081. for ( var i = 0; i < set.length; i++ ) {
  15082. if ( set[ i ] !== null ) {
  15083. element.data( dataSpace + set[ i ], element[ 0 ].style[ set[ i ] ] );
  15084. }
  15085. }
  15086. },
  15088. // Restores a set of previously saved properties from a data storage
  15089. restore: function( element, set ) {
  15090. var val, i;
  15091. for ( i = 0; i < set.length; i++ ) {
  15092. if ( set[ i ] !== null ) {
  15093. val = element.data( dataSpace + set[ i ] );
  15094. // support: jQuery 1.6.2
  15095. // http://bugs.jquery.com/ticket/9917
  15096. // jQuery 1.6.2 incorrectly returns undefined for any falsy value.
  15097. // We can't differentiate between "" and 0 here, so we just assume
  15098. // empty string since it's likely to be a more common value...
  15099. if ( val === undefined ) {
  15100. val = "";
  15101. }
  15102. element.css( set[ i ], val );
  15103. }
  15104. }
  15105. },
  15107. setMode: function( el, mode ) {
  15108. if (mode === "toggle") {
  15109. mode = el.is( ":hidden" ) ? "show" : "hide";
  15110. }
  15111. return mode;
  15112. },
  15114. // Translates a [top,left] array into a baseline value
  15115. // this should be a little more flexible in the future to handle a string & hash
  15116. getBaseline: function( origin, original ) {
  15117. var y, x;
  15118. switch ( origin[ 0 ] ) {
  15119. case "top": y = 0; break;
  15120. case "middle": y = 0.5; break;
  15121. case "bottom": y = 1; break;
  15122. default: y = origin[ 0 ] / original.height;
  15123. }
  15124. switch ( origin[ 1 ] ) {
  15125. case "left": x = 0; break;
  15126. case "center": x = 0.5; break;
  15127. case "right": x = 1; break;
  15128. default: x = origin[ 1 ] / original.width;
  15129. }
  15130. return {
  15131. x: x,
  15132. y: y
  15133. };
  15134. },
  15136. // Wraps the element around a wrapper that copies position properties
  15137. createWrapper: function( element ) {
  15139. // if the element is already wrapped, return it
  15140. if ( element.parent().is( ".ui-effects-wrapper" )) {
  15141. return element.parent();
  15142. }
  15144. // wrap the element
  15145. var props = {
  15146. width: element.outerWidth(true),
  15147. height: element.outerHeight(true),
  15148. "float": element.css( "float" )
  15149. },
  15150. wrapper = $( "<div></div>" )
  15151. .addClass( "ui-effects-wrapper" )
  15152. .css({
  15153. fontSize: "100%",
  15154. background: "transparent",
  15155. border: "none",
  15156. margin: 0,
  15157. padding: 0
  15158. }),
  15159. // Store the size in case width/height are defined in % - Fixes #5245
  15160. size = {
  15161. width: element.width(),
  15162. height: element.height()
  15163. },
  15164. active = document.activeElement;
  15166. // support: Firefox
  15167. // Firefox incorrectly exposes anonymous content
  15168. // https://bugzilla.mozilla.org/show_bug.cgi?id=561664
  15169. try {
  15170. active.id;
  15171. } catch ( e ) {
  15172. active = document.body;
  15173. }
  15175. element.wrap( wrapper );
  15177. // Fixes #7595 - Elements lose focus when wrapped.
  15178. if ( element[ 0 ] === active || $.contains( element[ 0 ], active ) ) {
  15179. $( active ).focus();
  15180. }
  15182. wrapper = element.parent(); //Hotfix for jQuery 1.4 since some change in wrap() seems to actually lose the reference to the wrapped element
  15184. // transfer positioning properties to the wrapper
  15185. if ( element.css( "position" ) === "static" ) {
  15186. wrapper.css({ position: "relative" });
  15187. element.css({ position: "relative" });
  15188. } else {
  15189. $.extend( props, {
  15190. position: element.css( "position" ),
  15191. zIndex: element.css( "z-index" )
  15192. });
  15193. $.each([ "top", "left", "bottom", "right" ], function(i, pos) {
  15194. props[ pos ] = element.css( pos );
  15195. if ( isNaN( parseInt( props[ pos ], 10 ) ) ) {
  15196. props[ pos ] = "auto";
  15197. }
  15198. });
  15199. element.css({
  15200. position: "relative",
  15201. top: 0,
  15202. left: 0,
  15203. right: "auto",
  15204. bottom: "auto"
  15205. });
  15206. }
  15207. element.css(size);
  15209. return wrapper.css( props ).show();
  15210. },
  15212. removeWrapper: function( element ) {
  15213. var active = document.activeElement;
  15215. if ( element.parent().is( ".ui-effects-wrapper" ) ) {
  15216. element.parent().replaceWith( element );
  15218. // Fixes #7595 - Elements lose focus when wrapped.
  15219. if ( element[ 0 ] === active || $.contains( element[ 0 ], active ) ) {
  15220. $( active ).focus();
  15221. }
  15222. }
  15224. return element;
  15225. },
  15227. setTransition: function( element, list, factor, value ) {
  15228. value = value || {};
  15229. $.each( list, function( i, x ) {
  15230. var unit = element.cssUnit( x );
  15231. if ( unit[ 0 ] > 0 ) {
  15232. value[ x ] = unit[ 0 ] * factor + unit[ 1 ];
  15233. }
  15234. });
  15235. return value;
  15236. }
  15237. });
  15239. // return an effect options object for the given parameters:
  15240. function _normalizeArguments( effect, options, speed, callback ) {
  15242. // allow passing all options as the first parameter
  15243. if ( $.isPlainObject( effect ) ) {
  15244. options = effect;
  15245. effect = effect.effect;
  15246. }
  15248. // convert to an object
  15249. effect = { effect: effect };
  15251. // catch (effect, null, ...)
  15252. if ( options == null ) {
  15253. options = {};
  15254. }
  15256. // catch (effect, callback)
  15257. if ( $.isFunction( options ) ) {
  15258. callback = options;
  15259. speed = null;
  15260. options = {};
  15261. }
  15263. // catch (effect, speed, ?)
  15264. if ( typeof options === "number" || $.fx.speeds[ options ] ) {
  15265. callback = speed;
  15266. speed = options;
  15267. options = {};
  15268. }
  15270. // catch (effect, options, callback)
  15271. if ( $.isFunction( speed ) ) {
  15272. callback = speed;
  15273. speed = null;
  15274. }
  15276. // add options to effect
  15277. if ( options ) {
  15278. $.extend( effect, options );
  15279. }
  15281. speed = speed || options.duration;
  15282. effect.duration = $.fx.off ? 0 :
  15283. typeof speed === "number" ? speed :
  15284. speed in $.fx.speeds ? $.fx.speeds[ speed ] :
  15285. $.fx.speeds._default;
  15287. effect.complete = callback || options.complete;
  15289. return effect;
  15290. }
  15292. function standardAnimationOption( option ) {
  15293. // Valid standard speeds (nothing, number, named speed)
  15294. if ( !option || typeof option === "number" || $.fx.speeds[ option ] ) {
  15295. return true;
  15296. }
  15298. // Invalid strings - treat as "normal" speed
  15299. if ( typeof option === "string" && !$.effects.effect[ option ] ) {
  15300. return true;
  15301. }
  15303. // Complete callback
  15304. if ( $.isFunction( option ) ) {
  15305. return true;
  15306. }
  15308. // Options hash (but not naming an effect)
  15309. if ( typeof option === "object" && !option.effect ) {
  15310. return true;
  15311. }
  15313. // Didn't match any standard API
  15314. return false;
  15315. }
  15317. $.fn.extend({
  15318. effect: function( /* effect, options, speed, callback */ ) {
  15319. var args = _normalizeArguments.apply( this, arguments ),
  15320. mode = args.mode,
  15321. queue = args.queue,
  15322. effectMethod = $.effects.effect[ args.effect ];
  15324. if ( $.fx.off || !effectMethod ) {
  15325. // delegate to the original method (e.g., .show()) if possible
  15326. if ( mode ) {
  15327. return this[ mode ]( args.duration, args.complete );
  15328. } else {
  15329. return this.each( function() {
  15330. if ( args.complete ) {
  15331. args.complete.call( this );
  15332. }
  15333. });
  15334. }
  15335. }
  15337. function run( next ) {
  15338. var elem = $( this ),
  15339. complete = args.complete,
  15340. mode = args.mode;
  15342. function done() {
  15343. if ( $.isFunction( complete ) ) {
  15344. complete.call( elem[0] );
  15345. }
  15346. if ( $.isFunction( next ) ) {
  15347. next();
  15348. }
  15349. }
  15351. // If the element already has the correct final state, delegate to
  15352. // the core methods so the internal tracking of "olddisplay" works.
  15353. if ( elem.is( ":hidden" ) ? mode === "hide" : mode === "show" ) {
  15354. elem[ mode ]();
  15355. done();
  15356. } else {
  15357. effectMethod.call( elem[0], args, done );
  15358. }
  15359. }
  15361. return queue === false ? this.each( run ) : this.queue( queue || "fx", run );
  15362. },
  15364. show: (function( orig ) {
  15365. return function( option ) {
  15366. if ( standardAnimationOption( option ) ) {
  15367. return orig.apply( this, arguments );
  15368. } else {
  15369. var args = _normalizeArguments.apply( this, arguments );
  15370. args.mode = "show";
  15371. return this.effect.call( this, args );
  15372. }
  15373. };
  15374. })( $.fn.show ),
  15376. hide: (function( orig ) {
  15377. return function( option ) {
  15378. if ( standardAnimationOption( option ) ) {
  15379. return orig.apply( this, arguments );
  15380. } else {
  15381. var args = _normalizeArguments.apply( this, arguments );
  15382. args.mode = "hide";
  15383. return this.effect.call( this, args );
  15384. }
  15385. };
  15386. })( $.fn.hide ),
  15388. toggle: (function( orig ) {
  15389. return function( option ) {
  15390. if ( standardAnimationOption( option ) || typeof option === "boolean" ) {
  15391. return orig.apply( this, arguments );
  15392. } else {
  15393. var args = _normalizeArguments.apply( this, arguments );
  15394. args.mode = "toggle";
  15395. return this.effect.call( this, args );
  15396. }
  15397. };
  15398. })( $.fn.toggle ),
  15400. // helper functions
  15401. cssUnit: function(key) {
  15402. var style = this.css( key ),
  15403. val = [];
  15405. $.each( [ "em", "px", "%", "pt" ], function( i, unit ) {
  15406. if ( style.indexOf( unit ) > 0 ) {
  15407. val = [ parseFloat( style ), unit ];
  15408. }
  15409. });
  15410. return val;
  15411. }
  15412. });
  15414. })();
  15416. /******************************************************************************/
  15417. /*********************************** EASING ***********************************/
  15418. /******************************************************************************/
  15420. (function() {
  15422. // based on easing equations from Robert Penner (http://www.robertpenner.com/easing)
  15424. var baseEasings = {};
  15426. $.each( [ "Quad", "Cubic", "Quart", "Quint", "Expo" ], function( i, name ) {
  15427. baseEasings[ name ] = function( p ) {
  15428. return Math.pow( p, i + 2 );
  15429. };
  15430. });
  15432. $.extend( baseEasings, {
  15433. Sine: function( p ) {
  15434. return 1 - Math.cos( p * Math.PI / 2 );
  15435. },
  15436. Circ: function( p ) {
  15437. return 1 - Math.sqrt( 1 - p * p );
  15438. },
  15439. Elastic: function( p ) {
  15440. return p === 0 || p === 1 ? p :
  15441. -Math.pow( 2, 8 * (p - 1) ) * Math.sin( ( (p - 1) * 80 - 7.5 ) * Math.PI / 15 );
  15442. },
  15443. Back: function( p ) {
  15444. return p * p * ( 3 * p - 2 );
  15445. },
  15446. Bounce: function( p ) {
  15447. var pow2,
  15448. bounce = 4;
  15450. while ( p < ( ( pow2 = Math.pow( 2, --bounce ) ) - 1 ) / 11 ) {}
  15451. return 1 / Math.pow( 4, 3 - bounce ) - 7.5625 * Math.pow( ( pow2 * 3 - 2 ) / 22 - p, 2 );
  15452. }
  15453. });
  15455. $.each( baseEasings, function( name, easeIn ) {
  15456. $.easing[ "easeIn" + name ] = easeIn;
  15457. $.easing[ "easeOut" + name ] = function( p ) {
  15458. return 1 - easeIn( 1 - p );
  15459. };
  15460. $.easing[ "easeInOut" + name ] = function( p ) {
  15461. return p < 0.5 ?
  15462. easeIn( p * 2 ) / 2 :
  15463. 1 - easeIn( p * -2 + 2 ) / 2;
  15464. };
  15465. });
  15467. })();
  15469. var effect = $.effects;
  15472. /*!
  15473. * jQuery UI Effects Blind 1.11.4
  15474. * http://jqueryui.com
  15475. *
  15476. * Copyright jQuery Foundation and other contributors
  15477. * Released under the MIT license.
  15478. * http://jquery.org/license
  15479. *
  15480. * http://api.jqueryui.com/blind-effect/
  15481. */
  15484. var effectBlind = $.effects.effect.blind = function( o, done ) {
  15485. // Create element
  15486. var el = $( this ),
  15487. rvertical = /up|down|vertical/,
  15488. rpositivemotion = /up|left|vertical|horizontal/,
  15489. props = [ "position", "top", "bottom", "left", "right", "height", "width" ],
  15490. mode = $.effects.setMode( el, o.mode || "hide" ),
  15491. direction = o.direction || "up",
  15492. vertical = rvertical.test( direction ),
  15493. ref = vertical ? "height" : "width",
  15494. ref2 = vertical ? "top" : "left",
  15495. motion = rpositivemotion.test( direction ),
  15496. animation = {},
  15497. show = mode === "show",
  15498. wrapper, distance, margin;
  15500. // if already wrapped, the wrapper's properties are my property. #6245
  15501. if ( el.parent().is( ".ui-effects-wrapper" ) ) {
  15502. $.effects.save( el.parent(), props );
  15503. } else {
  15504. $.effects.save( el, props );
  15505. }
  15506. el.show();
  15507. wrapper = $.effects.createWrapper( el ).css({
  15508. overflow: "hidden"
  15509. });
  15511. distance = wrapper[ ref ]();
  15512. margin = parseFloat( wrapper.css( ref2 ) ) || 0;
  15514. animation[ ref ] = show ? distance : 0;
  15515. if ( !motion ) {
  15516. el
  15517. .css( vertical ? "bottom" : "right", 0 )
  15518. .css( vertical ? "top" : "left", "auto" )
  15519. .css({ position: "absolute" });
  15521. animation[ ref2 ] = show ? margin : distance + margin;
  15522. }
  15524. // start at 0 if we are showing
  15525. if ( show ) {
  15526. wrapper.css( ref, 0 );
  15527. if ( !motion ) {
  15528. wrapper.css( ref2, margin + distance );
  15529. }
  15530. }
  15532. // Animate
  15533. wrapper.animate( animation, {
  15534. duration: o.duration,
  15535. easing: o.easing,
  15536. queue: false,
  15537. complete: function() {
  15538. if ( mode === "hide" ) {
  15539. el.hide();
  15540. }
  15541. $.effects.restore( el, props );
  15542. $.effects.removeWrapper( el );
  15543. done();
  15544. }
  15545. });
  15546. };
  15549. /*!
  15550. * jQuery UI Effects Bounce 1.11.4
  15551. * http://jqueryui.com
  15552. *
  15553. * Copyright jQuery Foundation and other contributors
  15554. * Released under the MIT license.
  15555. * http://jquery.org/license
  15556. *
  15557. * http://api.jqueryui.com/bounce-effect/
  15558. */
  15561. var effectBounce = $.effects.effect.bounce = function( o, done ) {
  15562. var el = $( this ),
  15563. props = [ "position", "top", "bottom", "left", "right", "height", "width" ],
  15565. // defaults:
  15566. mode = $.effects.setMode( el, o.mode || "effect" ),
  15567. hide = mode === "hide",
  15568. show = mode === "show",
  15569. direction = o.direction || "up",
  15570. distance = o.distance,
  15571. times = o.times || 5,
  15573. // number of internal animations
  15574. anims = times * 2 + ( show || hide ? 1 : 0 ),
  15575. speed = o.duration / anims,
  15576. easing = o.easing,
  15578. // utility:
  15579. ref = ( direction === "up" || direction === "down" ) ? "top" : "left",
  15580. motion = ( direction === "up" || direction === "left" ),
  15581. i,
  15582. upAnim,
  15583. downAnim,
  15585. // we will need to re-assemble the queue to stack our animations in place
  15586. queue = el.queue(),
  15587. queuelen = queue.length;
  15589. // Avoid touching opacity to prevent clearType and PNG issues in IE
  15590. if ( show || hide ) {
  15591. props.push( "opacity" );
  15592. }
  15594. $.effects.save( el, props );
  15595. el.show();
  15596. $.effects.createWrapper( el ); // Create Wrapper
  15598. // default distance for the BIGGEST bounce is the outer Distance / 3
  15599. if ( !distance ) {
  15600. distance = el[ ref === "top" ? "outerHeight" : "outerWidth" ]() / 3;
  15601. }
  15603. if ( show ) {
  15604. downAnim = { opacity: 1 };
  15605. downAnim[ ref ] = 0;
  15607. // if we are showing, force opacity 0 and set the initial position
  15608. // then do the "first" animation
  15609. el.css( "opacity", 0 )
  15610. .css( ref, motion ? -distance * 2 : distance * 2 )
  15611. .animate( downAnim, speed, easing );
  15612. }
  15614. // start at the smallest distance if we are hiding
  15615. if ( hide ) {
  15616. distance = distance / Math.pow( 2, times - 1 );
  15617. }
  15619. downAnim = {};
  15620. downAnim[ ref ] = 0;
  15621. // Bounces up/down/left/right then back to 0 -- times * 2 animations happen here
  15622. for ( i = 0; i < times; i++ ) {
  15623. upAnim = {};
  15624. upAnim[ ref ] = ( motion ? "-=" : "+=" ) + distance;
  15626. el.animate( upAnim, speed, easing )
  15627. .animate( downAnim, speed, easing );
  15629. distance = hide ? distance * 2 : distance / 2;
  15630. }
  15632. // Last Bounce when Hiding
  15633. if ( hide ) {
  15634. upAnim = { opacity: 0 };
  15635. upAnim[ ref ] = ( motion ? "-=" : "+=" ) + distance;
  15637. el.animate( upAnim, speed, easing );
  15638. }
  15640. el.queue(function() {
  15641. if ( hide ) {
  15642. el.hide();
  15643. }
  15644. $.effects.restore( el, props );
  15645. $.effects.removeWrapper( el );
  15646. done();
  15647. });
  15649. // inject all the animations we just queued to be first in line (after "inprogress")
  15650. if ( queuelen > 1) {
  15651. queue.splice.apply( queue,
  15652. [ 1, 0 ].concat( queue.splice( queuelen, anims + 1 ) ) );
  15653. }
  15654. el.dequeue();
  15656. };
  15659. /*!
  15660. * jQuery UI Effects Clip 1.11.4
  15661. * http://jqueryui.com
  15662. *
  15663. * Copyright jQuery Foundation and other contributors
  15664. * Released under the MIT license.
  15665. * http://jquery.org/license
  15666. *
  15667. * http://api.jqueryui.com/clip-effect/
  15668. */
  15671. var effectClip = $.effects.effect.clip = function( o, done ) {
  15672. // Create element
  15673. var el = $( this ),
  15674. props = [ "position", "top", "bottom", "left", "right", "height", "width" ],
  15675. mode = $.effects.setMode( el, o.mode || "hide" ),
  15676. show = mode === "show",
  15677. direction = o.direction || "vertical",
  15678. vert = direction === "vertical",
  15679. size = vert ? "height" : "width",
  15680. position = vert ? "top" : "left",
  15681. animation = {},
  15682. wrapper, animate, distance;
  15684. // Save & Show
  15685. $.effects.save( el, props );
  15686. el.show();
  15688. // Create Wrapper
  15689. wrapper = $.effects.createWrapper( el ).css({
  15690. overflow: "hidden"
  15691. });
  15692. animate = ( el[0].tagName === "IMG" ) ? wrapper : el;
  15693. distance = animate[ size ]();
  15695. // Shift
  15696. if ( show ) {
  15697. animate.css( size, 0 );
  15698. animate.css( position, distance / 2 );
  15699. }
  15701. // Create Animation Object:
  15702. animation[ size ] = show ? distance : 0;
  15703. animation[ position ] = show ? 0 : distance / 2;
  15705. // Animate
  15706. animate.animate( animation, {
  15707. queue: false,
  15708. duration: o.duration,
  15709. easing: o.easing,
  15710. complete: function() {
  15711. if ( !show ) {
  15712. el.hide();
  15713. }
  15714. $.effects.restore( el, props );
  15715. $.effects.removeWrapper( el );
  15716. done();
  15717. }
  15718. });
  15720. };
  15723. /*!
  15724. * jQuery UI Effects Drop 1.11.4
  15725. * http://jqueryui.com
  15726. *
  15727. * Copyright jQuery Foundation and other contributors
  15728. * Released under the MIT license.
  15729. * http://jquery.org/license
  15730. *
  15731. * http://api.jqueryui.com/drop-effect/
  15732. */
  15735. var effectDrop = $.effects.effect.drop = function( o, done ) {
  15737. var el = $( this ),
  15738. props = [ "position", "top", "bottom", "left", "right", "opacity", "height", "width" ],
  15739. mode = $.effects.setMode( el, o.mode || "hide" ),
  15740. show = mode === "show",
  15741. direction = o.direction || "left",
  15742. ref = ( direction === "up" || direction === "down" ) ? "top" : "left",
  15743. motion = ( direction === "up" || direction === "left" ) ? "pos" : "neg",
  15744. animation = {
  15745. opacity: show ? 1 : 0
  15746. },
  15747. distance;
  15749. // Adjust
  15750. $.effects.save( el, props );
  15751. el.show();
  15752. $.effects.createWrapper( el );
  15754. distance = o.distance || el[ ref === "top" ? "outerHeight" : "outerWidth" ]( true ) / 2;
  15756. if ( show ) {
  15757. el
  15758. .css( "opacity", 0 )
  15759. .css( ref, motion === "pos" ? -distance : distance );
  15760. }
  15762. // Animation
  15763. animation[ ref ] = ( show ?
  15764. ( motion === "pos" ? "+=" : "-=" ) :
  15765. ( motion === "pos" ? "-=" : "+=" ) ) +
  15766. distance;
  15768. // Animate
  15769. el.animate( animation, {
  15770. queue: false,
  15771. duration: o.duration,
  15772. easing: o.easing,
  15773. complete: function() {
  15774. if ( mode === "hide" ) {
  15775. el.hide();
  15776. }
  15777. $.effects.restore( el, props );
  15778. $.effects.removeWrapper( el );
  15779. done();
  15780. }
  15781. });
  15782. };
  15785. /*!
  15786. * jQuery UI Effects Explode 1.11.4
  15787. * http://jqueryui.com
  15788. *
  15789. * Copyright jQuery Foundation and other contributors
  15790. * Released under the MIT license.
  15791. * http://jquery.org/license
  15792. *
  15793. * http://api.jqueryui.com/explode-effect/
  15794. */
  15797. var effectExplode = $.effects.effect.explode = function( o, done ) {
  15799. var rows = o.pieces ? Math.round( Math.sqrt( o.pieces ) ) : 3,
  15800. cells = rows,
  15801. el = $( this ),
  15802. mode = $.effects.setMode( el, o.mode || "hide" ),
  15803. show = mode === "show",
  15805. // show and then visibility:hidden the element before calculating offset
  15806. offset = el.show().css( "visibility", "hidden" ).offset(),
  15808. // width and height of a piece
  15809. width = Math.ceil( el.outerWidth() / cells ),
  15810. height = Math.ceil( el.outerHeight() / rows ),
  15811. pieces = [],
  15813. // loop
  15814. i, j, left, top, mx, my;
  15816. // children animate complete:
  15817. function childComplete() {
  15818. pieces.push( this );
  15819. if ( pieces.length === rows * cells ) {
  15820. animComplete();
  15821. }
  15822. }
  15824. // clone the element for each row and cell.
  15825. for ( i = 0; i < rows ; i++ ) { // ===>
  15826. top = offset.top + i * height;
  15827. my = i - ( rows - 1 ) / 2 ;
  15829. for ( j = 0; j < cells ; j++ ) { // |||
  15830. left = offset.left + j * width;
  15831. mx = j - ( cells - 1 ) / 2 ;
  15833. // Create a clone of the now hidden main element that will be absolute positioned
  15834. // within a wrapper div off the -left and -top equal to size of our pieces
  15835. el
  15836. .clone()
  15837. .appendTo( "body" )
  15838. .wrap( "<div></div>" )
  15839. .css({
  15840. position: "absolute",
  15841. visibility: "visible",
  15842. left: -j * width,
  15843. top: -i * height
  15844. })
  15846. // select the wrapper - make it overflow: hidden and absolute positioned based on
  15847. // where the original was located +left and +top equal to the size of pieces
  15848. .parent()
  15849. .addClass( "ui-effects-explode" )
  15850. .css({
  15851. position: "absolute",
  15852. overflow: "hidden",
  15853. width: width,
  15854. height: height,
  15855. left: left + ( show ? mx * width : 0 ),
  15856. top: top + ( show ? my * height : 0 ),
  15857. opacity: show ? 0 : 1
  15858. }).animate({
  15859. left: left + ( show ? 0 : mx * width ),
  15860. top: top + ( show ? 0 : my * height ),
  15861. opacity: show ? 1 : 0
  15862. }, o.duration || 500, o.easing, childComplete );
  15863. }
  15864. }
  15866. function animComplete() {
  15867. el.css({
  15868. visibility: "visible"
  15869. });
  15870. $( pieces ).remove();
  15871. if ( !show ) {
  15872. el.hide();
  15873. }
  15874. done();
  15875. }
  15876. };
  15879. /*!
  15880. * jQuery UI Effects Fade 1.11.4
  15881. * http://jqueryui.com
  15882. *
  15883. * Copyright jQuery Foundation and other contributors
  15884. * Released under the MIT license.
  15885. * http://jquery.org/license
  15886. *
  15887. * http://api.jqueryui.com/fade-effect/
  15888. */
  15891. var effectFade = $.effects.effect.fade = function( o, done ) {
  15892. var el = $( this ),
  15893. mode = $.effects.setMode( el, o.mode || "toggle" );
  15895. el.animate({
  15896. opacity: mode
  15897. }, {
  15898. queue: false,
  15899. duration: o.duration,
  15900. easing: o.easing,
  15901. complete: done
  15902. });
  15903. };
  15906. /*!
  15907. * jQuery UI Effects Fold 1.11.4
  15908. * http://jqueryui.com
  15909. *
  15910. * Copyright jQuery Foundation and other contributors
  15911. * Released under the MIT license.
  15912. * http://jquery.org/license
  15913. *
  15914. * http://api.jqueryui.com/fold-effect/
  15915. */
  15918. var effectFold = $.effects.effect.fold = function( o, done ) {
  15920. // Create element
  15921. var el = $( this ),
  15922. props = [ "position", "top", "bottom", "left", "right", "height", "width" ],
  15923. mode = $.effects.setMode( el, o.mode || "hide" ),
  15924. show = mode === "show",
  15925. hide = mode === "hide",
  15926. size = o.size || 15,
  15927. percent = /([0-9]+)%/.exec( size ),
  15928. horizFirst = !!o.horizFirst,
  15929. widthFirst = show !== horizFirst,
  15930. ref = widthFirst ? [ "width", "height" ] : [ "height", "width" ],
  15931. duration = o.duration / 2,
  15932. wrapper, distance,
  15933. animation1 = {},
  15934. animation2 = {};
  15936. $.effects.save( el, props );
  15937. el.show();
  15939. // Create Wrapper
  15940. wrapper = $.effects.createWrapper( el ).css({
  15941. overflow: "hidden"
  15942. });
  15943. distance = widthFirst ?
  15944. [ wrapper.width(), wrapper.height() ] :
  15945. [ wrapper.height(), wrapper.width() ];
  15947. if ( percent ) {
  15948. size = parseInt( percent[ 1 ], 10 ) / 100 * distance[ hide ? 0 : 1 ];
  15949. }
  15950. if ( show ) {
  15951. wrapper.css( horizFirst ? {
  15952. height: 0,
  15953. width: size
  15954. } : {
  15955. height: size,
  15956. width: 0
  15957. });
  15958. }
  15960. // Animation
  15961. animation1[ ref[ 0 ] ] = show ? distance[ 0 ] : size;
  15962. animation2[ ref[ 1 ] ] = show ? distance[ 1 ] : 0;
  15964. // Animate
  15965. wrapper
  15966. .animate( animation1, duration, o.easing )
  15967. .animate( animation2, duration, o.easing, function() {
  15968. if ( hide ) {
  15969. el.hide();
  15970. }
  15971. $.effects.restore( el, props );
  15972. $.effects.removeWrapper( el );
  15973. done();
  15974. });
  15976. };
  15979. /*!
  15980. * jQuery UI Effects Highlight 1.11.4
  15981. * http://jqueryui.com
  15982. *
  15983. * Copyright jQuery Foundation and other contributors
  15984. * Released under the MIT license.
  15985. * http://jquery.org/license
  15986. *
  15987. * http://api.jqueryui.com/highlight-effect/
  15988. */
  15991. var effectHighlight = $.effects.effect.highlight = function( o, done ) {
  15992. var elem = $( this ),
  15993. props = [ "backgroundImage", "backgroundColor", "opacity" ],
  15994. mode = $.effects.setMode( elem, o.mode || "show" ),
  15995. animation = {
  15996. backgroundColor: elem.css( "backgroundColor" )
  15997. };
  15999. if (mode === "hide") {
  16000. animation.opacity = 0;
  16001. }
  16003. $.effects.save( elem, props );
  16005. elem
  16006. .show()
  16007. .css({
  16008. backgroundImage: "none",
  16009. backgroundColor: o.color || "#ffff99"
  16010. })
  16011. .animate( animation, {
  16012. queue: false,
  16013. duration: o.duration,
  16014. easing: o.easing,
  16015. complete: function() {
  16016. if ( mode === "hide" ) {
  16017. elem.hide();
  16018. }
  16019. $.effects.restore( elem, props );
  16020. done();
  16021. }
  16022. });
  16023. };
  16026. /*!
  16027. * jQuery UI Effects Size 1.11.4
  16028. * http://jqueryui.com
  16029. *
  16030. * Copyright jQuery Foundation and other contributors
  16031. * Released under the MIT license.
  16032. * http://jquery.org/license
  16033. *
  16034. * http://api.jqueryui.com/size-effect/
  16035. */
  16038. var effectSize = $.effects.effect.size = function( o, done ) {
  16040. // Create element
  16041. var original, baseline, factor,
  16042. el = $( this ),
  16043. props0 = [ "position", "top", "bottom", "left", "right", "width", "height", "overflow", "opacity" ],
  16045. // Always restore
  16046. props1 = [ "position", "top", "bottom", "left", "right", "overflow", "opacity" ],
  16048. // Copy for children
  16049. props2 = [ "width", "height", "overflow" ],
  16050. cProps = [ "fontSize" ],
  16051. vProps = [ "borderTopWidth", "borderBottomWidth", "paddingTop", "paddingBottom" ],
  16052. hProps = [ "borderLeftWidth", "borderRightWidth", "paddingLeft", "paddingRight" ],
  16054. // Set options
  16055. mode = $.effects.setMode( el, o.mode || "effect" ),
  16056. restore = o.restore || mode !== "effect",
  16057. scale = o.scale || "both",
  16058. origin = o.origin || [ "middle", "center" ],
  16059. position = el.css( "position" ),
  16060. props = restore ? props0 : props1,
  16061. zero = {
  16062. height: 0,
  16063. width: 0,
  16064. outerHeight: 0,
  16065. outerWidth: 0
  16066. };
  16068. if ( mode === "show" ) {
  16069. el.show();
  16070. }
  16071. original = {
  16072. height: el.height(),
  16073. width: el.width(),
  16074. outerHeight: el.outerHeight(),
  16075. outerWidth: el.outerWidth()
  16076. };
  16078. if ( o.mode === "toggle" && mode === "show" ) {
  16079. el.from = o.to || zero;
  16080. el.to = o.from || original;
  16081. } else {
  16082. el.from = o.from || ( mode === "show" ? zero : original );
  16083. el.to = o.to || ( mode === "hide" ? zero : original );
  16084. }
  16086. // Set scaling factor
  16087. factor = {
  16088. from: {
  16089. y: el.from.height / original.height,
  16090. x: el.from.width / original.width
  16091. },
  16092. to: {
  16093. y: el.to.height / original.height,
  16094. x: el.to.width / original.width
  16095. }
  16096. };
  16098. // Scale the css box
  16099. if ( scale === "box" || scale === "both" ) {
  16101. // Vertical props scaling
  16102. if ( factor.from.y !== factor.to.y ) {
  16103. props = props.concat( vProps );
  16104. el.from = $.effects.setTransition( el, vProps, factor.from.y, el.from );
  16105. el.to = $.effects.setTransition( el, vProps, factor.to.y, el.to );
  16106. }
  16108. // Horizontal props scaling
  16109. if ( factor.from.x !== factor.to.x ) {
  16110. props = props.concat( hProps );
  16111. el.from = $.effects.setTransition( el, hProps, factor.from.x, el.from );
  16112. el.to = $.effects.setTransition( el, hProps, factor.to.x, el.to );
  16113. }
  16114. }
  16116. // Scale the content
  16117. if ( scale === "content" || scale === "both" ) {
  16119. // Vertical props scaling
  16120. if ( factor.from.y !== factor.to.y ) {
  16121. props = props.concat( cProps ).concat( props2 );
  16122. el.from = $.effects.setTransition( el, cProps, factor.from.y, el.from );
  16123. el.to = $.effects.setTransition( el, cProps, factor.to.y, el.to );
  16124. }
  16125. }
  16127. $.effects.save( el, props );
  16128. el.show();
  16129. $.effects.createWrapper( el );
  16130. el.css( "overflow", "hidden" ).css( el.from );
  16132. // Adjust
  16133. if (origin) { // Calculate baseline shifts
  16134. baseline = $.effects.getBaseline( origin, original );
  16135. el.from.top = ( original.outerHeight - el.outerHeight() ) * baseline.y;
  16136. el.from.left = ( original.outerWidth - el.outerWidth() ) * baseline.x;
  16137. el.to.top = ( original.outerHeight - el.to.outerHeight ) * baseline.y;
  16138. el.to.left = ( original.outerWidth - el.to.outerWidth ) * baseline.x;
  16139. }
  16140. el.css( el.from ); // set top & left
  16142. // Animate
  16143. if ( scale === "content" || scale === "both" ) { // Scale the children
  16145. // Add margins/font-size
  16146. vProps = vProps.concat([ "marginTop", "marginBottom" ]).concat(cProps);
  16147. hProps = hProps.concat([ "marginLeft", "marginRight" ]);
  16148. props2 = props0.concat(vProps).concat(hProps);
  16150. el.find( "*[width]" ).each( function() {
  16151. var child = $( this ),
  16152. c_original = {
  16153. height: child.height(),
  16154. width: child.width(),
  16155. outerHeight: child.outerHeight(),
  16156. outerWidth: child.outerWidth()
  16157. };
  16158. if (restore) {
  16159. $.effects.save(child, props2);
  16160. }
  16162. child.from = {
  16163. height: c_original.height * factor.from.y,
  16164. width: c_original.width * factor.from.x,
  16165. outerHeight: c_original.outerHeight * factor.from.y,
  16166. outerWidth: c_original.outerWidth * factor.from.x
  16167. };
  16168. child.to = {
  16169. height: c_original.height * factor.to.y,
  16170. width: c_original.width * factor.to.x,
  16171. outerHeight: c_original.height * factor.to.y,
  16172. outerWidth: c_original.width * factor.to.x
  16173. };
  16175. // Vertical props scaling
  16176. if ( factor.from.y !== factor.to.y ) {
  16177. child.from = $.effects.setTransition( child, vProps, factor.from.y, child.from );
  16178. child.to = $.effects.setTransition( child, vProps, factor.to.y, child.to );
  16179. }
  16181. // Horizontal props scaling
  16182. if ( factor.from.x !== factor.to.x ) {
  16183. child.from = $.effects.setTransition( child, hProps, factor.from.x, child.from );
  16184. child.to = $.effects.setTransition( child, hProps, factor.to.x, child.to );
  16185. }
  16187. // Animate children
  16188. child.css( child.from );
  16189. child.animate( child.to, o.duration, o.easing, function() {
  16191. // Restore children
  16192. if ( restore ) {
  16193. $.effects.restore( child, props2 );
  16194. }
  16195. });
  16196. });
  16197. }
  16199. // Animate
  16200. el.animate( el.to, {
  16201. queue: false,
  16202. duration: o.duration,
  16203. easing: o.easing,
  16204. complete: function() {
  16205. if ( el.to.opacity === 0 ) {
  16206. el.css( "opacity", el.from.opacity );
  16207. }
  16208. if ( mode === "hide" ) {
  16209. el.hide();
  16210. }
  16211. $.effects.restore( el, props );
  16212. if ( !restore ) {
  16214. // we need to calculate our new positioning based on the scaling
  16215. if ( position === "static" ) {
  16216. el.css({
  16217. position: "relative",
  16218. top: el.to.top,
  16219. left: el.to.left
  16220. });
  16221. } else {
  16222. $.each([ "top", "left" ], function( idx, pos ) {
  16223. el.css( pos, function( _, str ) {
  16224. var val = parseInt( str, 10 ),
  16225. toRef = idx ? el.to.left : el.to.top;
  16227. // if original was "auto", recalculate the new value from wrapper
  16228. if ( str === "auto" ) {
  16229. return toRef + "px";
  16230. }
  16232. return val + toRef + "px";
  16233. });
  16234. });
  16235. }
  16236. }
  16238. $.effects.removeWrapper( el );
  16239. done();
  16240. }
  16241. });
  16243. };
  16246. /*!
  16247. * jQuery UI Effects Scale 1.11.4
  16248. * http://jqueryui.com
  16249. *
  16250. * Copyright jQuery Foundation and other contributors
  16251. * Released under the MIT license.
  16252. * http://jquery.org/license
  16253. *
  16254. * http://api.jqueryui.com/scale-effect/
  16255. */
  16258. var effectScale = $.effects.effect.scale = function( o, done ) {
  16260. // Create element
  16261. var el = $( this ),
  16262. options = $.extend( true, {}, o ),
  16263. mode = $.effects.setMode( el, o.mode || "effect" ),
  16264. percent = parseInt( o.percent, 10 ) ||
  16265. ( parseInt( o.percent, 10 ) === 0 ? 0 : ( mode === "hide" ? 0 : 100 ) ),
  16266. direction = o.direction || "both",
  16267. origin = o.origin,
  16268. original = {
  16269. height: el.height(),
  16270. width: el.width(),
  16271. outerHeight: el.outerHeight(),
  16272. outerWidth: el.outerWidth()
  16273. },
  16274. factor = {
  16275. y: direction !== "horizontal" ? (percent / 100) : 1,
  16276. x: direction !== "vertical" ? (percent / 100) : 1
  16277. };
  16279. // We are going to pass this effect to the size effect:
  16280. options.effect = "size";
  16281. options.queue = false;
  16282. options.complete = done;
  16284. // Set default origin and restore for show/hide
  16285. if ( mode !== "effect" ) {
  16286. options.origin = origin || [ "middle", "center" ];
  16287. options.restore = true;
  16288. }
  16290. options.from = o.from || ( mode === "show" ? {
  16291. height: 0,
  16292. width: 0,
  16293. outerHeight: 0,
  16294. outerWidth: 0
  16295. } : original );
  16296. options.to = {
  16297. height: original.height * factor.y,
  16298. width: original.width * factor.x,
  16299. outerHeight: original.outerHeight * factor.y,
  16300. outerWidth: original.outerWidth * factor.x
  16301. };
  16303. // Fade option to support puff
  16304. if ( options.fade ) {
  16305. if ( mode === "show" ) {
  16306. options.from.opacity = 0;
  16307. options.to.opacity = 1;
  16308. }
  16309. if ( mode === "hide" ) {
  16310. options.from.opacity = 1;
  16311. options.to.opacity = 0;
  16312. }
  16313. }
  16315. // Animate
  16316. el.effect( options );
  16318. };
  16321. /*!
  16322. * jQuery UI Effects Puff 1.11.4
  16323. * http://jqueryui.com
  16324. *
  16325. * Copyright jQuery Foundation and other contributors
  16326. * Released under the MIT license.
  16327. * http://jquery.org/license
  16328. *
  16329. * http://api.jqueryui.com/puff-effect/
  16330. */
  16333. var effectPuff = $.effects.effect.puff = function( o, done ) {
  16334. var elem = $( this ),
  16335. mode = $.effects.setMode( elem, o.mode || "hide" ),
  16336. hide = mode === "hide",
  16337. percent = parseInt( o.percent, 10 ) || 150,
  16338. factor = percent / 100,
  16339. original = {
  16340. height: elem.height(),
  16341. width: elem.width(),
  16342. outerHeight: elem.outerHeight(),
  16343. outerWidth: elem.outerWidth()
  16344. };
  16346. $.extend( o, {
  16347. effect: "scale",
  16348. queue: false,
  16349. fade: true,
  16350. mode: mode,
  16351. complete: done,
  16352. percent: hide ? percent : 100,
  16353. from: hide ?
  16354. original :
  16355. {
  16356. height: original.height * factor,
  16357. width: original.width * factor,
  16358. outerHeight: original.outerHeight * factor,
  16359. outerWidth: original.outerWidth * factor
  16360. }
  16361. });
  16363. elem.effect( o );
  16364. };
  16367. /*!
  16368. * jQuery UI Effects Pulsate 1.11.4
  16369. * http://jqueryui.com
  16370. *
  16371. * Copyright jQuery Foundation and other contributors
  16372. * Released under the MIT license.
  16373. * http://jquery.org/license
  16374. *
  16375. * http://api.jqueryui.com/pulsate-effect/
  16376. */
  16379. var effectPulsate = $.effects.effect.pulsate = function( o, done ) {
  16380. var elem = $( this ),
  16381. mode = $.effects.setMode( elem, o.mode || "show" ),
  16382. show = mode === "show",
  16383. hide = mode === "hide",
  16384. showhide = ( show || mode === "hide" ),
  16386. // showing or hiding leaves of the "last" animation
  16387. anims = ( ( o.times || 5 ) * 2 ) + ( showhide ? 1 : 0 ),
  16388. duration = o.duration / anims,
  16389. animateTo = 0,
  16390. queue = elem.queue(),
  16391. queuelen = queue.length,
  16392. i;
  16394. if ( show || !elem.is(":visible")) {
  16395. elem.css( "opacity", 0 ).show();
  16396. animateTo = 1;
  16397. }
  16399. // anims - 1 opacity "toggles"
  16400. for ( i = 1; i < anims; i++ ) {
  16401. elem.animate({
  16402. opacity: animateTo
  16403. }, duration, o.easing );
  16404. animateTo = 1 - animateTo;
  16405. }
  16407. elem.animate({
  16408. opacity: animateTo
  16409. }, duration, o.easing);
  16411. elem.queue(function() {
  16412. if ( hide ) {
  16413. elem.hide();
  16414. }
  16415. done();
  16416. });
  16418. // We just queued up "anims" animations, we need to put them next in the queue
  16419. if ( queuelen > 1 ) {
  16420. queue.splice.apply( queue,
  16421. [ 1, 0 ].concat( queue.splice( queuelen, anims + 1 ) ) );
  16422. }
  16423. elem.dequeue();
  16424. };
  16427. /*!
  16428. * jQuery UI Effects Shake 1.11.4
  16429. * http://jqueryui.com
  16430. *
  16431. * Copyright jQuery Foundation and other contributors
  16432. * Released under the MIT license.
  16433. * http://jquery.org/license
  16434. *
  16435. * http://api.jqueryui.com/shake-effect/
  16436. */
  16439. var effectShake = $.effects.effect.shake = function( o, done ) {
  16441. var el = $( this ),
  16442. props = [ "position", "top", "bottom", "left", "right", "height", "width" ],
  16443. mode = $.effects.setMode( el, o.mode || "effect" ),
  16444. direction = o.direction || "left",
  16445. distance = o.distance || 20,
  16446. times = o.times || 3,
  16447. anims = times * 2 + 1,
  16448. speed = Math.round( o.duration / anims ),
  16449. ref = (direction === "up" || direction === "down") ? "top" : "left",
  16450. positiveMotion = (direction === "up" || direction === "left"),
  16451. animation = {},
  16452. animation1 = {},
  16453. animation2 = {},
  16454. i,
  16456. // we will need to re-assemble the queue to stack our animations in place
  16457. queue = el.queue(),
  16458. queuelen = queue.length;
  16460. $.effects.save( el, props );
  16461. el.show();
  16462. $.effects.createWrapper( el );
  16464. // Animation
  16465. animation[ ref ] = ( positiveMotion ? "-=" : "+=" ) + distance;
  16466. animation1[ ref ] = ( positiveMotion ? "+=" : "-=" ) + distance * 2;
  16467. animation2[ ref ] = ( positiveMotion ? "-=" : "+=" ) + distance * 2;
  16469. // Animate
  16470. el.animate( animation, speed, o.easing );
  16472. // Shakes
  16473. for ( i = 1; i < times; i++ ) {
  16474. el.animate( animation1, speed, o.easing ).animate( animation2, speed, o.easing );
  16475. }
  16476. el
  16477. .animate( animation1, speed, o.easing )
  16478. .animate( animation, speed / 2, o.easing )
  16479. .queue(function() {
  16480. if ( mode === "hide" ) {
  16481. el.hide();
  16482. }
  16483. $.effects.restore( el, props );
  16484. $.effects.removeWrapper( el );
  16485. done();
  16486. });
  16488. // inject all the animations we just queued to be first in line (after "inprogress")
  16489. if ( queuelen > 1) {
  16490. queue.splice.apply( queue,
  16491. [ 1, 0 ].concat( queue.splice( queuelen, anims + 1 ) ) );
  16492. }
  16493. el.dequeue();
  16495. };
  16498. /*!
  16499. * jQuery UI Effects Slide 1.11.4
  16500. * http://jqueryui.com
  16501. *
  16502. * Copyright jQuery Foundation and other contributors
  16503. * Released under the MIT license.
  16504. * http://jquery.org/license
  16505. *
  16506. * http://api.jqueryui.com/slide-effect/
  16507. */
  16510. var effectSlide = $.effects.effect.slide = function( o, done ) {
  16512. // Create element
  16513. var el = $( this ),
  16514. props = [ "position", "top", "bottom", "left", "right", "width", "height" ],
  16515. mode = $.effects.setMode( el, o.mode || "show" ),
  16516. show = mode === "show",
  16517. direction = o.direction || "left",
  16518. ref = (direction === "up" || direction === "down") ? "top" : "left",
  16519. positiveMotion = (direction === "up" || direction === "left"),
  16520. distance,
  16521. animation = {};
  16523. // Adjust
  16524. $.effects.save( el, props );
  16525. el.show();
  16526. distance = o.distance || el[ ref === "top" ? "outerHeight" : "outerWidth" ]( true );
  16528. $.effects.createWrapper( el ).css({
  16529. overflow: "hidden"
  16530. });
  16532. if ( show ) {
  16533. el.css( ref, positiveMotion ? (isNaN(distance) ? "-" + distance : -distance) : distance );
  16534. }
  16536. // Animation
  16537. animation[ ref ] = ( show ?
  16538. ( positiveMotion ? "+=" : "-=") :
  16539. ( positiveMotion ? "-=" : "+=")) +
  16540. distance;
  16542. // Animate
  16543. el.animate( animation, {
  16544. queue: false,
  16545. duration: o.duration,
  16546. easing: o.easing,
  16547. complete: function() {
  16548. if ( mode === "hide" ) {
  16549. el.hide();
  16550. }
  16551. $.effects.restore( el, props );
  16552. $.effects.removeWrapper( el );
  16553. done();
  16554. }
  16555. });
  16556. };
  16559. /*!
  16560. * jQuery UI Effects Transfer 1.11.4
  16561. * http://jqueryui.com
  16562. *
  16563. * Copyright jQuery Foundation and other contributors
  16564. * Released under the MIT license.
  16565. * http://jquery.org/license
  16566. *
  16567. * http://api.jqueryui.com/transfer-effect/
  16568. */
  16571. var effectTransfer = $.effects.effect.transfer = function( o, done ) {
  16572. var elem = $( this ),
  16573. target = $( o.to ),
  16574. targetFixed = target.css( "position" ) === "fixed",
  16575. body = $("body"),
  16576. fixTop = targetFixed ? body.scrollTop() : 0,
  16577. fixLeft = targetFixed ? body.scrollLeft() : 0,
  16578. endPosition = target.offset(),
  16579. animation = {
  16580. top: endPosition.top - fixTop,
  16581. left: endPosition.left - fixLeft,
  16582. height: target.innerHeight(),
  16583. width: target.innerWidth()
  16584. },
  16585. startPosition = elem.offset(),
  16586. transfer = $( "<div class='ui-effects-transfer'></div>" )
  16587. .appendTo( document.body )
  16588. .addClass( o.className )
  16589. .css({
  16590. top: startPosition.top - fixTop,
  16591. left: startPosition.left - fixLeft,
  16592. height: elem.innerHeight(),
  16593. width: elem.innerWidth(),
  16594. position: targetFixed ? "fixed" : "absolute"
  16595. })
  16596. .animate( animation, o.duration, o.easing, function() {
  16597. transfer.remove();
  16598. done();
  16599. });
  16600. };
  16604. }));