jquery-ui.js

   1 /*! jQuery UI - v1.11.4 - 2015-03-11
   2 * http://jqueryui.com
   3 * Includes: core.js, widget.js, mouse.js, position.js, accordion.js, autocomplete.js, button.js, datepicker.js, dialog.js, draggable.js, droppable.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, menu.js, progressbar.js, resizable.js, selectable.js, selectmenu.js, slider.js, sortable.js, spinner.js, tabs.js, tooltip.js
   4 * Copyright 2015 jQuery Foundation and other contributors; Licensed MIT */
   5
   6 (function( factory ) {
   7         if ( typeof define === "function" && define.amd ) {
   8
   9                 // AMD. Register as an anonymous module.
  10                 define([ "jquery" ], factory );
  11         } else {
  12
  13                 // Browser globals
  14                 factory( jQuery );
  15         }
  16 }(function( $ ) {
  17 /*!
  18  * jQuery UI Core 1.11.4
  19  * http://jqueryui.com
  20  *
  21  * Copyright jQuery Foundation and other contributors
  22  * Released under the MIT license.
  23  * http://jquery.org/license
  24  *
  25  * http://api.jqueryui.com/category/ui-core/
  26  */
  27
  28
  29 // $.ui might exist from components with no dependencies, e.g., $.ui.position
  30 $.ui = $.ui || {};
  31
  32 $.extend( $.ui, {
  33         version: "1.11.4",
  34
  35         keyCode: {
  36                 BACKSPACE: 8,
  37                 COMMA: 188,
  38                 DELETE: 46,
  39                 DOWN: 40,
  40                 END: 35,
  41                 ENTER: 13,
  42                 ESCAPE: 27,
  43                 HOME: 36,
  44                 LEFT: 37,
  45                 PAGE_DOWN: 34,
  46                 PAGE_UP: 33,
  47                 PERIOD: 190,
  48                 RIGHT: 39,
  49                 SPACE: 32,
  50                 TAB: 9,
  51                 UP: 38
  52         }
  53 });
  54
  55 // plugins
  56 $.fn.extend({
  57         scrollParent: function( includeHidden ) {
  58                 var position = this.css( "position" ),
  59                         excludeStaticParent = position === "absolute",
  60                         overflowRegex = includeHidden ? /(auto|scroll|hidden)/ : /(auto|scroll)/,
  61                         scrollParent = this.parents().filter( function() {
  62                                 var parent = $( this );
  63                                 if ( excludeStaticParent && parent.css( "position" ) === "static" ) {
  64                                         return false;
  65                                 }
  66                                 return overflowRegex.test( parent.css( "overflow" ) + parent.css( "overflow-y" ) + parent.css( "overflow-x" ) );
  67                         }).eq( 0 );
  68
  69                 return position === "fixed" || !scrollParent.length ? $( this[ 0 ].ownerDocument || document ) : scrollParent;
  70         },
  71
  72         uniqueId: (function() {
  73                 var uuid = 0;
  74
  75                 return function() {
  76                         return this.each(function() {
  77                                 if ( !this.id ) {
  78                                         this.id = "ui-id-" + ( ++uuid );
  79                                 }
  80                         });
  81                 };
  82         })(),
  83
  84         removeUniqueId: function() {
  85                 return this.each(function() {
  86                         if ( /^ui-id-\d+$/.test( this.id ) ) {
  87                                 $( this ).removeAttr( "id" );
  88                         }
  89                 });
  90         }
  91 });
  92
  93 // selectors
  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 }
 114
 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 }
 121
 122 $.extend( $.expr[ ":" ], {
 123         data: $.expr.createPseudo ?
 124                 $.expr.createPseudo(function( dataName ) {
 125                         return function( elem ) {
 126                                 return !!$.data( elem, dataName );
 127                         };
 128                 }) :
 129                 // support: jQuery <1.8
 130                 function( elem, i, match ) {
 131                         return !!$.data( elem, match[ 3 ] );
 132                 },
 133
 134         focusable: function( element ) {
 135                 return focusable( element, !isNaN( $.attr( element, "tabindex" ) ) );
 136         },
 137
 138         tabbable: function( element ) {
 139                 var tabIndex = $.attr( element, "tabindex" ),
 140                         isTabIndexNaN = isNaN( tabIndex );
 141                 return ( isTabIndexNaN || tabIndex >= 0 ) && focusable( element, !isTabIndexNaN );
 142         }
 143 });
 144
 145 // support: jQuery <1.8
 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                         };
 156
 157                 function reduce( elem, size, border, margin ) {
 158                         $.each( side, function() {
 159                                 size -= parseFloat( $.css( elem, "padding" + this ) ) || 0;
 160                                 if ( border ) {
 161                                         size -= parseFloat( $.css( elem, "border" + this + "Width" ) ) || 0;
 162                                 }
 163                                 if ( margin ) {
 164                                         size -= parseFloat( $.css( elem, "margin" + this ) ) || 0;
 165                                 }
 166                         });
 167                         return size;
 168                 }
 169
 170                 $.fn[ "inner" + name ] = function( size ) {
 171                         if ( size === undefined ) {
 172                                 return orig[ "inner" + name ].call( this );
 173                         }
 174
 175                         return this.each(function() {
 176                                 $( this ).css( type, reduce( this, size ) + "px" );
 177                         });
 178                 };
 179
 180                 $.fn[ "outer" + name] = function( size, margin ) {
 181                         if ( typeof size !== "number" ) {
 182                                 return orig[ "outer" + name ].call( this, size );
 183                         }
 184
 185                         return this.each(function() {
 186                                 $( this).css( type, reduce( this, size, true, margin ) + "px" );
 187                         });
 188                 };
 189         });
 190 }
 191
 192 // support: jQuery <1.8
 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 }
 200
 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 }
 213
 214 // deprecated
 215 $.ui.ie = !!/msie [\w.]+/.exec( navigator.userAgent.toLowerCase() );
 216
 217 $.fn.extend({
 218         focus: (function( orig ) {
 219                 return function( delay, fn ) {
 220                         return typeof delay === "number" ?
 221                                 this.each(function() {
 222                                         var elem = this;
 223                                         setTimeout(function() {
 224                                                 $( elem ).focus();
 225                                                 if ( fn ) {
 226                                                         fn.call( elem );
 227                                                 }
 228                                         }, delay );
 229                                 }) :
 230                                 orig.apply( this, arguments );
 231                 };
 232         })( $.fn.focus ),
 233
 234         disableSelection: (function() {
 235                 var eventType = "onselectstart" in document.createElement( "div" ) ?
 236                         "selectstart" :
 237                         "mousedown";
 238
 239                 return function() {
 240                         return this.bind( eventType + ".ui-disableSelection", function( event ) {
 241                                 event.preventDefault();
 242                         });
 243                 };
 244         })(),
 245
 246         enableSelection: function() {
 247                 return this.unbind( ".ui-disableSelection" );
 248         },
 249
 250         zIndex: function( zIndex ) {
 251                 if ( zIndex !== undefined ) {
 252                         return this.css( "zIndex", zIndex );
 253                 }
 254
 255                 if ( this.length ) {
 256                         var elem = $( this[ 0 ] ), position, value;
 257                         while ( elem.length && elem[ 0 ] !== document ) {
 258                                 // Ignore z-index if position is set to a value where z-index is ignored by the browser
 259                                 // This makes behavior of this function consistent across browsers
 260                                 // WebKit always returns auto if the element is positioned
 261                                 position = elem.css( "position" );
 262                                 if ( position === "absolute" || position === "relative" || position === "fixed" ) {
 263                                         // IE returns 0 when zIndex is not specified
 264                                         // other browsers return a string
 265                                         // we ignore the case of nested elements with an explicit value of 0
 266                                         // <div style="z-index: -10;"><div style="z-index: 0;"></div></div>
 267                                         value = parseInt( elem.css( "zIndex" ), 10 );
 268                                         if ( !isNaN( value ) && value !== 0 ) {
 269                                                 return value;
 270                                         }
 271                                 }
 272                                 elem = elem.parent();
 273                         }
 274                 }
 275
 276                 return 0;
 277         }
 278 });
 279
 280 // $.ui.plugin is deprecated. Use $.widget() extensions instead.
 281 $.ui.plugin = {
 282         add: function( module, option, set ) {
 283                 var i,
 284                         proto = $.ui[ module ].prototype;
 285                 for ( i in set ) {
 286                         proto.plugins[ i ] = proto.plugins[ i ] || [];
 287                         proto.plugins[ i ].push( [ option, set[ i ] ] );
 288                 }
 289         },
 290         call: function( instance, name, args, allowDisconnected ) {
 291                 var i,
 292                         set = instance.plugins[ name ];
 293
 294                 if ( !set ) {
 295                         return;
 296                 }
 297
 298                 if ( !allowDisconnected && ( !instance.element[ 0 ].parentNode || instance.element[ 0 ].parentNode.nodeType === 11 ) ) {
 299                         return;
 300                 }
 301
 302                 for ( i = 0; i < set.length; i++ ) {
 303                         if ( instance.options[ set[ i ][ 0 ] ] ) {
 304                                 set[ i ][ 1 ].apply( instance.element, args );
 305                         }
 306                 }
 307         }
 308 };
 309
 310
 311 /*!
 312  * jQuery UI Widget 1.11.4
 313  * http://jqueryui.com
 314  *
 315  * Copyright jQuery Foundation and other contributors
 316  * Released under the MIT license.
 317  * http://jquery.org/license
 318  *
 319  * http://api.jqueryui.com/jQuery.widget/
 320  */
 321
 322
 323 var widget_uuid = 0,
 324         widget_slice = Array.prototype.slice;
 325
 326 $.cleanData = (function( orig ) {
 327         return function( elems ) {
 328                 var events, elem, i;
 329                 for ( i = 0; (elem = elems[i]) != null; i++ ) {
 330                         try {
 331
 332                                 // Only trigger remove when necessary to save time
 333                                 events = $._data( elem, "events" );
 334                                 if ( events && events.remove ) {
 335                                         $( elem ).triggerHandler( "remove" );
 336                                 }
 337
 338                         // http://bugs.jquery.com/ticket/8235
 339                         } catch ( e ) {}
 340                 }
 341                 orig( elems );
 342         };
 343 })( $.cleanData );
 344
 345 $.widget = function( name, base, prototype ) {
 346         var fullName, existingConstructor, constructor, basePrototype,
 347                 // proxiedPrototype allows the provided prototype to remain unmodified
 348                 // so that it can be used as a mixin for multiple widgets (#8876)
 349                 proxiedPrototype = {},
 350                 namespace = name.split( "." )[ 0 ];
 351
 352         name = name.split( "." )[ 1 ];
 353         fullName = namespace + "-" + name;
 354
 355         if ( !prototype ) {
 356                 prototype = base;
 357                 base = $.Widget;
 358         }
 359
 360         // create selector for plugin
 361         $.expr[ ":" ][ fullName.toLowerCase() ] = function( elem ) {
 362                 return !!$.data( elem, fullName );
 363         };
 364
 365         $[ namespace ] = $[ namespace ] || {};
 366         existingConstructor = $[ namespace ][ name ];
 367         constructor = $[ namespace ][ name ] = function( options, element ) {
 368                 // allow instantiation without "new" keyword
 369                 if ( !this._createWidget ) {
 370                         return new constructor( options, element );
 371                 }
 372
 373                 // allow instantiation without initializing for simple inheritance
 374                 // must use "new" keyword (the code above always passes args)
 375                 if ( arguments.length ) {
 376                         this._createWidget( options, element );
 377                 }
 378         };
 379         // extend with the existing constructor to carry over any static properties
 380         $.extend( constructor, existingConstructor, {
 381                 version: prototype.version,
 382                 // copy the object used to create the prototype in case we need to
 383                 // redefine the widget later
 384                 _proto: $.extend( {}, prototype ),
 385                 // track widgets that inherit from this widget in case this widget is
 386                 // redefined after a widget inherits from it
 387                 _childConstructors: []
 388         });
 389
 390         basePrototype = new base();
 391         // we need to make the options hash a property directly on the new instance
 392         // otherwise we'll modify the options hash on the prototype that we're
 393         // inheriting from
 394         basePrototype.options = $.widget.extend( {}, basePrototype.options );
 395         $.each( prototype, function( prop, value ) {
 396                 if ( !$.isFunction( value ) ) {
 397                         proxiedPrototype[ prop ] = value;
 398                         return;
 399                 }
 400                 proxiedPrototype[ prop ] = (function() {
 401                         var _super = function() {
 402                                         return base.prototype[ prop ].apply( this, arguments );
 403                                 },
 404                                 _superApply = function( args ) {
 405                                         return base.prototype[ prop ].apply( this, args );
 406                                 };
 407                         return function() {
 408                                 var __super = this._super,
 409                                         __superApply = this._superApply,
 410                                         returnValue;
 411
 412                                 this._super = _super;
 413                                 this._superApply = _superApply;
 414
 415                                 returnValue = value.apply( this, arguments );
 416
 417                                 this._super = __super;
 418                                 this._superApply = __superApply;
 419
 420                                 return returnValue;
 421                         };
 422                 })();
 423         });
 424         constructor.prototype = $.widget.extend( basePrototype, {
 425                 // TODO: remove support for widgetEventPrefix
 426                 // always use the name + a colon as the prefix, e.g., draggable:start
 427                 // don't prefix for widgets that aren't DOM-based
 428                 widgetEventPrefix: existingConstructor ? (basePrototype.widgetEventPrefix || name) : name
 429         }, proxiedPrototype, {
 430                 constructor: constructor,
 431                 namespace: namespace,
 432                 widgetName: name,
 433                 widgetFullName: fullName
 434         });
 435
 436         // If this widget is being redefined then we need to find all widgets that
 437         // are inheriting from it and redefine all of them so that they inherit from
 438         // the new version of this widget. We're essentially trying to replace one
 439         // level in the prototype chain.
 440         if ( existingConstructor ) {
 441                 $.each( existingConstructor._childConstructors, function( i, child ) {
 442                         var childPrototype = child.prototype;
 443
 444                         // redefine the child widget using the same prototype that was
 445                         // originally used, but inherit from the new version of the base
 446                         $.widget( childPrototype.namespace + "." + childPrototype.widgetName, constructor, child._proto );
 447                 });
 448                 // remove the list of existing child constructors from the old constructor
 449                 // so the old child constructors can be garbage collected
 450                 delete existingConstructor._childConstructors;
 451         } else {
 452                 base._childConstructors.push( constructor );
 453         }
 454
 455         $.widget.bridge( name, constructor );
 456
 457         return constructor;
 458 };
 459
 460 $.widget.extend = function( target ) {
 461         var input = widget_slice.call( arguments, 1 ),
 462                 inputIndex = 0,
 463                 inputLength = input.length,
 464                 key,
 465                 value;
 466         for ( ; inputIndex < inputLength; inputIndex++ ) {
 467                 for ( key in input[ inputIndex ] ) {
 468                         value = input[ inputIndex ][ key ];
 469                         if ( input[ inputIndex ].hasOwnProperty( key ) && value !== undefined ) {
 470                                 // Clone objects
 471                                 if ( $.isPlainObject( value ) ) {
 472                                         target[ key ] = $.isPlainObject( target[ key ] ) ?
 473                                                 $.widget.extend( {}, target[ key ], value ) :
 474                                                 // Don't extend strings, arrays, etc. with objects
 475                                                 $.widget.extend( {}, value );
 476                                 // Copy everything else by reference
 477                                 } else {
 478                                         target[ key ] = value;
 479                                 }
 480                         }
 481                 }
 482         }
 483         return target;
 484 };
 485
 486 $.widget.bridge = function( name, object ) {
 487         var fullName = object.prototype.widgetFullName || name;
 488         $.fn[ name ] = function( options ) {
 489                 var isMethodCall = typeof options === "string",
 490                         args = widget_slice.call( arguments, 1 ),
 491                         returnValue = this;
 492
 493                 if ( isMethodCall ) {
 494                         this.each(function() {
 495                                 var methodValue,
 496                                         instance = $.data( this, fullName );
 497                                 if ( options === "instance" ) {
 498                                         returnValue = instance;
 499                                         return false;
 500                                 }
 501                                 if ( !instance ) {
 502                                         return $.error( "cannot call methods on " + name + " prior to initialization; " +
 503                                                 "attempted to call method '" + options + "'" );
 504                                 }
 505                                 if ( !$.isFunction( instance[options] ) || options.charAt( 0 ) === "_" ) {
 506                                         return $.error( "no such method '" + options + "' for " + name + " widget instance" );
 507                                 }
 508                                 methodValue = instance[ options ].apply( instance, args );
 509                                 if ( methodValue !== instance && methodValue !== undefined ) {
 510                                         returnValue = methodValue && methodValue.jquery ?
 511                                                 returnValue.pushStack( methodValue.get() ) :
 512                                                 methodValue;
 513                                         return false;
 514                                 }
 515                         });
 516                 } else {
 517
 518                         // Allow multiple hashes to be passed on init
 519                         if ( args.length ) {
 520                                 options = $.widget.extend.apply( null, [ options ].concat(args) );
 521                         }
 522
 523                         this.each(function() {
 524                                 var instance = $.data( this, fullName );
 525                                 if ( instance ) {
 526                                         instance.option( options || {} );
 527                                         if ( instance._init ) {
 528                                                 instance._init();
 529                                         }
 530                                 } else {
 531                                         $.data( this, fullName, new object( options, this ) );
 532                                 }
 533                         });
 534                 }
 535
 536                 return returnValue;
 537         };
 538 };
 539
 540 $.Widget = function( /* options, element */ ) {};
 541 $.Widget._childConstructors = [];
 542
 543 $.Widget.prototype = {
 544         widgetName: "widget",
 545         widgetEventPrefix: "",
 546         defaultElement: "<div>",
 547         options: {
 548                 disabled: false,
 549
 550                 // callbacks
 551                 create: null
 552         },
 553         _createWidget: function( options, element ) {
 554                 element = $( element || this.defaultElement || this )[ 0 ];
 555                 this.element = $( element );
 556                 this.uuid = widget_uuid++;
 557                 this.eventNamespace = "." + this.widgetName + this.uuid;
 558
 559                 this.bindings = $();
 560                 this.hoverable = $();
 561                 this.focusable = $();
 562
 563                 if ( element !== this ) {
 564                         $.data( element, this.widgetFullName, this );
 565                         this._on( true, this.element, {
 566                                 remove: function( event ) {
 567                                         if ( event.target === element ) {
 568                                                 this.destroy();
 569                                         }
 570                                 }
 571                         });
 572                         this.document = $( element.style ?
 573                                 // element within the document
 574                                 element.ownerDocument :
 575                                 // element is window or document
 576                                 element.document || element );
 577                         this.window = $( this.document[0].defaultView || this.document[0].parentWindow );
 578                 }
 579
 580                 this.options = $.widget.extend( {},
 581                         this.options,
 582                         this._getCreateOptions(),
 583                         options );
 584
 585                 this._create();
 586                 this._trigger( "create", null, this._getCreateEventData() );
 587                 this._init();
 588         },
 589         _getCreateOptions: $.noop,
 590         _getCreateEventData: $.noop,
 591         _create: $.noop,
 592         _init: $.noop,
 593
 594         destroy: function() {
 595                 this._destroy();
 596                 // we can probably remove the unbind calls in 2.0
 597                 // all event bindings should go through this._on()
 598                 this.element
 599                         .unbind( this.eventNamespace )
 600                         .removeData( this.widgetFullName )
 601                         // support: jquery <1.6.3
 602                         // http://bugs.jquery.com/ticket/9413
 603                         .removeData( $.camelCase( this.widgetFullName ) );
 604                 this.widget()
 605                         .unbind( this.eventNamespace )
 606                         .removeAttr( "aria-disabled" )
 607                         .removeClass(
 608                                 this.widgetFullName + "-disabled " +
 609                                 "ui-state-disabled" );
 610
 611                 // clean up events and states
 612                 this.bindings.unbind( this.eventNamespace );
 613                 this.hoverable.removeClass( "ui-state-hover" );
 614                 this.focusable.removeClass( "ui-state-focus" );
 615         },
 616         _destroy: $.noop,
 617
 618         widget: function() {
 619                 return this.element;
 620         },
 621
 622         option: function( key, value ) {
 623                 var options = key,
 624                         parts,
 625                         curOption,
 626                         i;
 627
 628                 if ( arguments.length === 0 ) {
 629                         // don't return a reference to the internal hash
 630                         return $.widget.extend( {}, this.options );
 631                 }
 632
 633                 if ( typeof key === "string" ) {
 634                         // handle nested keys, e.g., "foo.bar" => { foo: { bar: ___ } }
 635                         options = {};
 636                         parts = key.split( "." );
 637                         key = parts.shift();
 638                         if ( parts.length ) {
 639                                 curOption = options[ key ] = $.widget.extend( {}, this.options[ key ] );
 640                                 for ( i = 0; i < parts.length - 1; i++ ) {
 641                                         curOption[ parts[ i ] ] = curOption[ parts[ i ] ] || {};
 642                                         curOption = curOption[ parts[ i ] ];
 643                                 }
 644                                 key = parts.pop();
 645                                 if ( arguments.length === 1 ) {
 646                                         return curOption[ key ] === undefined ? null : curOption[ key ];
 647                                 }
 648                                 curOption[ key ] = value;
 649                         } else {
 650                                 if ( arguments.length === 1 ) {
 651                                         return this.options[ key ] === undefined ? null : this.options[ key ];
 652                                 }
 653                                 options[ key ] = value;
 654                         }
 655                 }
 656
 657                 this._setOptions( options );
 658
 659                 return this;
 660         },
 661         _setOptions: function( options ) {
 662                 var key;
 663
 664                 for ( key in options ) {
 665                         this._setOption( key, options[ key ] );
 666                 }
 667
 668                 return this;
 669         },
 670         _setOption: function( key, value ) {
 671                 this.options[ key ] = value;
 672
 673                 if ( key === "disabled" ) {
 674                         this.widget()
 675                                 .toggleClass( this.widgetFullName + "-disabled", !!value );
 676
 677                         // If the widget is becoming disabled, then nothing is interactive
 678                         if ( value ) {
 679                                 this.hoverable.removeClass( "ui-state-hover" );
 680                                 this.focusable.removeClass( "ui-state-focus" );
 681                         }
 682                 }
 683
 684                 return this;
 685         },
 686
 687         enable: function() {
 688                 return this._setOptions({ disabled: false });
 689         },
 690         disable: function() {
 691                 return this._setOptions({ disabled: true });
 692         },
 693
 694         _on: function( suppressDisabledCheck, element, handlers ) {
 695                 var delegateElement,
 696                         instance = this;
 697
 698                 // no suppressDisabledCheck flag, shuffle arguments
 699                 if ( typeof suppressDisabledCheck !== "boolean" ) {
 700                         handlers = element;
 701                         element = suppressDisabledCheck;
 702                         suppressDisabledCheck = false;
 703                 }
 704
 705                 // no element argument, shuffle and use this.element
 706                 if ( !handlers ) {
 707                         handlers = element;
 708                         element = this.element;
 709                         delegateElement = this.widget();
 710                 } else {
 711                         element = delegateElement = $( element );
 712                         this.bindings = this.bindings.add( element );
 713                 }
 714
 715                 $.each( handlers, function( event, handler ) {
 716                         function handlerProxy() {
 717                                 // allow widgets to customize the disabled handling
 718                                 // - disabled as an array instead of boolean
 719                                 // - disabled class as method for disabling individual parts
 720                                 if ( !suppressDisabledCheck &&
 721                                                 ( instance.options.disabled === true ||
 722                                                         $( this ).hasClass( "ui-state-disabled" ) ) ) {
 723                                         return;
 724                                 }
 725                                 return ( typeof handler === "string" ? instance[ handler ] : handler )
 726                                         .apply( instance, arguments );
 727                         }
 728
 729                         // copy the guid so direct unbinding works
 730                         if ( typeof handler !== "string" ) {
 731                                 handlerProxy.guid = handler.guid =
 732                                         handler.guid || handlerProxy.guid || $.guid++;
 733                         }
 734
 735                         var match = event.match( /^([\w:-]*)\s*(.*)$/ ),
 736                                 eventName = match[1] + instance.eventNamespace,
 737                                 selector = match[2];
 738                         if ( selector ) {
 739                                 delegateElement.delegate( selector, eventName, handlerProxy );
 740                         } else {
 741                                 element.bind( eventName, handlerProxy );
 742                         }
 743                 });
 744         },
 745
 746         _off: function( element, eventName ) {
 747                 eventName = (eventName || "").split( " " ).join( this.eventNamespace + " " ) +
 748                         this.eventNamespace;
 749                 element.unbind( eventName ).undelegate( eventName );
 750
 751                 // Clear the stack to avoid memory leaks (#10056)
 752                 this.bindings = $( this.bindings.not( element ).get() );
 753                 this.focusable = $( this.focusable.not( element ).get() );
 754                 this.hoverable = $( this.hoverable.not( element ).get() );
 755         },
 756
 757         _delay: function( handler, delay ) {
 758                 function handlerProxy() {
 759                         return ( typeof handler === "string" ? instance[ handler ] : handler )
 760                                 .apply( instance, arguments );
 761                 }
 762                 var instance = this;
 763                 return setTimeout( handlerProxy, delay || 0 );
 764         },
 765
 766         _hoverable: function( element ) {
 767                 this.hoverable = this.hoverable.add( element );
 768                 this._on( element, {
 769                         mouseenter: function( event ) {
 770                                 $( event.currentTarget ).addClass( "ui-state-hover" );
 771                         },
 772                         mouseleave: function( event ) {
 773                                 $( event.currentTarget ).removeClass( "ui-state-hover" );
 774                         }
 775                 });
 776         },
 777
 778         _focusable: function( element ) {
 779                 this.focusable = this.focusable.add( element );
 780                 this._on( element, {
 781                         focusin: function( event ) {
 782                                 $( event.currentTarget ).addClass( "ui-state-focus" );
 783                         },
 784                         focusout: function( event ) {
 785                                 $( event.currentTarget ).removeClass( "ui-state-focus" );
 786                         }
 787                 });
 788         },
 789
 790         _trigger: function( type, event, data ) {
 791                 var prop, orig,
 792                         callback = this.options[ type ];
 793
 794                 data = data || {};
 795                 event = $.Event( event );
 796                 event.type = ( type === this.widgetEventPrefix ?
 797                         type :
 798                         this.widgetEventPrefix + type ).toLowerCase();
 799                 // the original event may come from any element
 800                 // so we need to reset the target on the new event
 801                 event.target = this.element[ 0 ];
 802
 803                 // copy original event properties over to the new event
 804                 orig = event.originalEvent;
 805                 if ( orig ) {
 806                         for ( prop in orig ) {
 807                                 if ( !( prop in event ) ) {
 808                                         event[ prop ] = orig[ prop ];
 809                                 }
 810                         }
 811                 }
 812
 813                 this.element.trigger( event, data );
 814                 return !( $.isFunction( callback ) &&
 815                         callback.apply( this.element[0], [ event ].concat( data ) ) === false ||
 816                         event.isDefaultPrevented() );
 817         }
 818 };
 819
 820 $.each( { show: "fadeIn", hide: "fadeOut" }, function( method, defaultEffect ) {
 821         $.Widget.prototype[ "_" + method ] = function( element, options, callback ) {
 822                 if ( typeof options === "string" ) {
 823                         options = { effect: options };
 824                 }
 825                 var hasOptions,
 826                         effectName = !options ?
 827                                 method :
 828                                 options === true || typeof options === "number" ?
 829                                         defaultEffect :
 830                                         options.effect || defaultEffect;
 831                 options = options || {};
 832                 if ( typeof options === "number" ) {
 833                         options = { duration: options };
 834                 }
 835                 hasOptions = !$.isEmptyObject( options );
 836                 options.complete = callback;
 837                 if ( options.delay ) {
 838                         element.delay( options.delay );
 839                 }
 840                 if ( hasOptions && $.effects && $.effects.effect[ effectName ] ) {
 841                         element[ method ]( options );
 842                 } else if ( effectName !== method && element[ effectName ] ) {
 843                         element[ effectName ]( options.duration, options.easing, callback );
 844                 } else {
 845                         element.queue(function( next ) {
 846                                 $( this )[ method ]();
 847                                 if ( callback ) {
 848                                         callback.call( element[ 0 ] );
 849                                 }
 850                                 next();
 851                         });
 852                 }
 853         };
 854 });
 855
 856 var widget = $.widget;
 857
 858
 859 /*!
 860  * jQuery UI Mouse 1.11.4
 861  * http://jqueryui.com
 862  *
 863  * Copyright jQuery Foundation and other contributors
 864  * Released under the MIT license.
 865  * http://jquery.org/license
 866  *
 867  * http://api.jqueryui.com/mouse/
 868  */
 869
 870
 871 var mouseHandled = false;
 872 $( document ).mouseup( function() {
 873         mouseHandled = false;
 874 });
 875
 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;
 885
 886                 this.element
 887                         .bind("mousedown." + this.widgetName, function(event) {
 888                                 return that._mouseDown(event);
 889                         })
 890                         .bind("click." + this.widgetName, function(event) {
 891                                 if (true === $.data(event.target, that.widgetName + ".preventClickEvent")) {
 892                                         $.removeData(event.target, that.widgetName + ".preventClickEvent");
 893                                         event.stopImmediatePropagation();
 894                                         return false;
 895                                 }
 896                         });
 897
 898                 this.started = false;
 899         },
 900
 901         // TODO: make sure destroying one instance of mouse doesn't mess with
 902         // other instances of mouse
 903         _mouseDestroy: function() {
 904                 this.element.unbind("." + this.widgetName);
 905                 if ( this._mouseMoveDelegate ) {
 906                         this.document
 907                                 .unbind("mousemove." + this.widgetName, this._mouseMoveDelegate)
 908                                 .unbind("mouseup." + this.widgetName, this._mouseUpDelegate);
 909                 }
 910         },
 911
 912         _mouseDown: function(event) {
 913                 // don't let more than one widget handle mouseStart
 914                 if ( mouseHandled ) {
 915                         return;
 916                 }
 917
 918                 this._mouseMoved = false;
 919
 920                 // we may have missed mouseup (out of window)
 921                 (this._mouseStarted && this._mouseUp(event));
 922
 923                 this._mouseDownEvent = event;
 924
 925                 var that = this,
 926                         btnIsLeft = (event.which === 1),
 927                         // event.target.nodeName works around a bug in IE 8 with
 928                         // disabled inputs (#7620)
 929                         elIsCancel = (typeof this.options.cancel === "string" && event.target.nodeName ? $(event.target).closest(this.options.cancel).length : false);
 930                 if (!btnIsLeft || elIsCancel || !this._mouseCapture(event)) {
 931                         return true;
 932                 }
 933
 934                 this.mouseDelayMet = !this.options.delay;
 935                 if (!this.mouseDelayMet) {
 936                         this._mouseDelayTimer = setTimeout(function() {
 937                                 that.mouseDelayMet = true;
 938                         }, this.options.delay);
 939                 }
 940
 941                 if (this._mouseDistanceMet(event) && this._mouseDelayMet(event)) {
 942                         this._mouseStarted = (this._mouseStart(event) !== false);
 943                         if (!this._mouseStarted) {
 944                                 event.preventDefault();
 945                                 return true;
 946                         }
 947                 }
 948
 949                 // Click event may never have fired (Gecko & Opera)
 950                 if (true === $.data(event.target, this.widgetName + ".preventClickEvent")) {
 951                         $.removeData(event.target, this.widgetName + ".preventClickEvent");
 952                 }
 953
 954                 // these delegates are required to keep context
 955                 this._mouseMoveDelegate = function(event) {
 956                         return that._mouseMove(event);
 957                 };
 958                 this._mouseUpDelegate = function(event) {
 959                         return that._mouseUp(event);
 960                 };
 961
 962                 this.document
 963                         .bind( "mousemove." + this.widgetName, this._mouseMoveDelegate )
 964                         .bind( "mouseup." + this.widgetName, this._mouseUpDelegate );
 965
 966                 event.preventDefault();
 967
 968                 mouseHandled = true;
 969                 return true;
 970         },
 971
 972         _mouseMove: function(event) {
 973                 // Only check for mouseups outside the document if you've moved inside the document
 974                 // at least once. This prevents the firing of mouseup in the case of IE<9, which will
 975                 // fire a mousemove event if content is placed under the cursor. See #7778
 976                 // Support: IE <9
 977                 if ( this._mouseMoved ) {
 978                         // IE mouseup check - mouseup happened when mouse was out of window
 979                         if ($.ui.ie && ( !document.documentMode || document.documentMode < 9 ) && !event.button) {
 980                                 return this._mouseUp(event);
 981
 982                         // Iframe mouseup check - mouseup occurred in another document
 983                         } else if ( !event.which ) {
 984                                 return this._mouseUp( event );
 985                         }
 986                 }
 987
 988                 if ( event.which || event.button ) {
 989                         this._mouseMoved = true;
 990                 }
 991
 992                 if (this._mouseStarted) {
 993                         this._mouseDrag(event);
 994                         return event.preventDefault();
 995                 }
 996
 997                 if (this._mouseDistanceMet(event) && this._mouseDelayMet(event)) {
 998                         this._mouseStarted =
 999                                 (this._mouseStart(this._mouseDownEvent, event) !== false);
1000                         (this._mouseStarted ? this._mouseDrag(event) : this._mouseUp(event));
1001                 }
1002
1003                 return !this._mouseStarted;
1004         },
1005
1006         _mouseUp: function(event) {
1007                 this.document
1008                         .unbind( "mousemove." + this.widgetName, this._mouseMoveDelegate )
1009                         .unbind( "mouseup." + this.widgetName, this._mouseUpDelegate );
1010
1011                 if (this._mouseStarted) {
1012                         this._mouseStarted = false;
1013
1014                         if (event.target === this._mouseDownEvent.target) {
1015                                 $.data(event.target, this.widgetName + ".preventClickEvent", true);
1016                         }
1017
1018                         this._mouseStop(event);
1019                 }
1020
1021                 mouseHandled = false;
1022                 return false;
1023         },
1024
1025         _mouseDistanceMet: function(event) {
1026                 return (Math.max(
1027                                 Math.abs(this._mouseDownEvent.pageX - event.pageX),
1028                                 Math.abs(this._mouseDownEvent.pageY - event.pageY)
1029                         ) >= this.options.distance
1030                 );
1031         },
1032
1033         _mouseDelayMet: function(/* event */) {
1034                 return this.mouseDelayMet;
1035         },
1036
1037         // These are placeholder methods, to be overriden by extending plugin
1038         _mouseStart: function(/* event */) {},
1039         _mouseDrag: function(/* event */) {},
1040         _mouseStop: function(/* event */) {},
1041         _mouseCapture: function(/* event */) { return true; }
1042 });
1043
1044
1045 /*!
1046  * jQuery UI Position 1.11.4
1047  * http://jqueryui.com
1048  *
1049  * Copyright jQuery Foundation and other contributors
1050  * Released under the MIT license.
1051  * http://jquery.org/license
1052  *
1053  * http://api.jqueryui.com/position/
1054  */
1055
1056 (function() {
1057
1058 $.ui = $.ui || {};
1059
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;
1070
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 }
1077
1078 function parseCss( element, property ) {
1079         return parseInt( $.css( element, property ), 10 ) || 0;
1080 }
1081
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 }
1111
1112 $.position = {
1113         scrollbarWidth: function() {
1114                 if ( cachedScrollbarWidth !== undefined ) {
1115                         return cachedScrollbarWidth;
1116                 }
1117                 var w1, w2,
1118                         div = $( "<div style='display:block;position:absolute;width:50px;height:50px;overflow:hidden;'><div style='height:100px;width:auto;'></div></div>" ),
1119                         innerDiv = div.children()[0];
1120
1121                 $( "body" ).append( div );
1122                 w1 = innerDiv.offsetWidth;
1123                 div.css( "overflow", "scroll" );
1124
1125                 w2 = innerDiv.offsetWidth;
1126
1127                 if ( w1 === w2 ) {
1128                         w2 = div[0].clientWidth;
1129                 }
1130
1131                 div.remove();
1132
1133                 return (cachedScrollbarWidth = w1 - w2);
1134         },
1135         getScrollInfo: function( within ) {
1136                 var overflowX = within.isWindow || within.isDocument ? "" :
1137                                 within.element.css( "overflow-x" ),
1138                         overflowY = within.isWindow || within.isDocument ? "" :
1139                                 within.element.css( "overflow-y" ),
1140                         hasOverflowX = overflowX === "scroll" ||
1141                                 ( overflowX === "auto" && within.width < within.element[0].scrollWidth ),
1142                         hasOverflowY = overflowY === "scroll" ||
1143                                 ( overflowY === "auto" && within.height < within.element[0].scrollHeight );
1144                 return {
1145                         width: hasOverflowY ? $.position.scrollbarWidth() : 0,
1146                         height: hasOverflowX ? $.position.scrollbarWidth() : 0
1147                 };
1148         },
1149         getWithinInfo: function( element ) {
1150                 var withinElement = $( element || window ),
1151                         isWindow = $.isWindow( withinElement[0] ),
1152                         isDocument = !!withinElement[ 0 ] && withinElement[ 0 ].nodeType === 9;
1153                 return {
1154                         element: withinElement,
1155                         isWindow: isWindow,
1156                         isDocument: isDocument,
1157                         offset: withinElement.offset() || { left: 0, top: 0 },
1158                         scrollLeft: withinElement.scrollLeft(),
1159                         scrollTop: withinElement.scrollTop(),
1160
1161                         // support: jQuery 1.6.x
1162                         // jQuery 1.6 doesn't support .outerWidth/Height() on documents or windows
1163                         width: isWindow || isDocument ? withinElement.width() : withinElement.outerWidth(),
1164                         height: isWindow || isDocument ? withinElement.height() : withinElement.outerHeight()
1165                 };
1166         }
1167 };
1168
1169 $.fn.position = function( options ) {
1170         if ( !options || !options.of ) {
1171                 return _position.apply( this, arguments );
1172         }
1173
1174         // make a copy, we don't want to modify arguments
1175         options = $.extend( {}, options );
1176
1177         var atOffset, targetWidth, targetHeight, targetOffset, basePosition, dimensions,
1178                 target = $( options.of ),
1179                 within = $.position.getWithinInfo( options.within ),
1180                 scrollInfo = $.position.getScrollInfo( within ),
1181                 collision = ( options.collision || "flip" ).split( " " ),
1182                 offsets = {};
1183
1184         dimensions = getDimensions( target );
1185         if ( target[0].preventDefault ) {
1186                 // force left top to allow flipping
1187                 options.at = "left top";
1188         }
1189         targetWidth = dimensions.width;
1190         targetHeight = dimensions.height;
1191         targetOffset = dimensions.offset;
1192         // clone to reuse original targetOffset later
1193         basePosition = $.extend( {}, targetOffset );
1194
1195         // force my and at to have valid horizontal and vertical positions
1196         // if a value is missing or invalid, it will be converted to center
1197         $.each( [ "my", "at" ], function() {
1198                 var pos = ( options[ this ] || "" ).split( " " ),
1199                         horizontalOffset,
1200                         verticalOffset;
1201
1202                 if ( pos.length === 1) {
1203                         pos = rhorizontal.test( pos[ 0 ] ) ?
1204                                 pos.concat( [ "center" ] ) :
1205                                 rvertical.test( pos[ 0 ] ) ?
1206                                         [ "center" ].concat( pos ) :
1207                                         [ "center", "center" ];
1208                 }
1209                 pos[ 0 ] = rhorizontal.test( pos[ 0 ] ) ? pos[ 0 ] : "center";
1210                 pos[ 1 ] = rvertical.test( pos[ 1 ] ) ? pos[ 1 ] : "center";
1211
1212                 // calculate offsets
1213                 horizontalOffset = roffset.exec( pos[ 0 ] );
1214                 verticalOffset = roffset.exec( pos[ 1 ] );
1215                 offsets[ this ] = [
1216                         horizontalOffset ? horizontalOffset[ 0 ] : 0,
1217                         verticalOffset ? verticalOffset[ 0 ] : 0
1218                 ];
1219
1220                 // reduce to just the positions without the offsets
1221                 options[ this ] = [
1222                         rposition.exec( pos[ 0 ] )[ 0 ],
1223                         rposition.exec( pos[ 1 ] )[ 0 ]
1224                 ];
1225         });
1226
1227         // normalize collision option
1228         if ( collision.length === 1 ) {
1229                 collision[ 1 ] = collision[ 0 ];
1230         }
1231
1232         if ( options.at[ 0 ] === "right" ) {
1233                 basePosition.left += targetWidth;
1234         } else if ( options.at[ 0 ] === "center" ) {
1235                 basePosition.left += targetWidth / 2;
1236         }
1237
1238         if ( options.at[ 1 ] === "bottom" ) {
1239                 basePosition.top += targetHeight;
1240         } else if ( options.at[ 1 ] === "center" ) {
1241                 basePosition.top += targetHeight / 2;
1242         }
1243
1244         atOffset = getOffsets( offsets.at, targetWidth, targetHeight );
1245         basePosition.left += atOffset[ 0 ];
1246         basePosition.top += atOffset[ 1 ];
1247
1248         return this.each(function() {
1249                 var collisionPosition, using,
1250                         elem = $( this ),
1251                         elemWidth = elem.outerWidth(),
1252                         elemHeight = elem.outerHeight(),
1253                         marginLeft = parseCss( this, "marginLeft" ),
1254                         marginTop = parseCss( this, "marginTop" ),
1255                         collisionWidth = elemWidth + marginLeft + parseCss( this, "marginRight" ) + scrollInfo.width,
1256                         collisionHeight = elemHeight + marginTop + parseCss( this, "marginBottom" ) + scrollInfo.height,
1257                         position = $.extend( {}, basePosition ),
1258                         myOffset = getOffsets( offsets.my, elem.outerWidth(), elem.outerHeight() );
1259
1260                 if ( options.my[ 0 ] === "right" ) {
1261                         position.left -= elemWidth;
1262                 } else if ( options.my[ 0 ] === "center" ) {
1263                         position.left -= elemWidth / 2;
1264                 }
1265
1266                 if ( options.my[ 1 ] === "bottom" ) {
1267                         position.top -= elemHeight;
1268                 } else if ( options.my[ 1 ] === "center" ) {
1269                         position.top -= elemHeight / 2;
1270                 }
1271
1272                 position.left += myOffset[ 0 ];
1273                 position.top += myOffset[ 1 ];
1274
1275                 // if the browser doesn't support fractions, then round for consistent results
1276                 if ( !supportsOffsetFractions ) {
1277                         position.left = round( position.left );
1278                         position.top = round( position.top );
1279                 }
1280
1281                 collisionPosition = {
1282                         marginLeft: marginLeft,
1283                         marginTop: marginTop
1284                 };
1285
1286                 $.each( [ "left", "top" ], function( i, dir ) {
1287                         if ( $.ui.position[ collision[ i ] ] ) {
1288                                 $.ui.position[ collision[ i ] ][ dir ]( position, {
1289                                         targetWidth: targetWidth,
1290                                         targetHeight: targetHeight,
1291                                         elemWidth: elemWidth,
1292                                         elemHeight: elemHeight,
1293                                         collisionPosition: collisionPosition,
1294                                         collisionWidth: collisionWidth,
1295                                         collisionHeight: collisionHeight,
1296                                         offset: [ atOffset[ 0 ] + myOffset[ 0 ], atOffset [ 1 ] + myOffset[ 1 ] ],
1297                                         my: options.my,
1298                                         at: options.at,
1299                                         within: within,
1300                                         elem: elem
1301                                 });
1302                         }
1303                 });
1304
1305                 if ( options.using ) {
1306                         // adds feedback as second argument to using callback, if present
1307                         using = function( props ) {
1308                                 var left = targetOffset.left - position.left,
1309                                         right = left + targetWidth - elemWidth,
1310                                         top = targetOffset.top - position.top,
1311                                         bottom = top + targetHeight - elemHeight,
1312                                         feedback = {
1313                                                 target: {
1314                                                         element: target,
1315                                                         left: targetOffset.left,
1316                                                         top: targetOffset.top,
1317                                                         width: targetWidth,
1318                                                         height: targetHeight
1319                                                 },
1320                                                 element: {
1321                                                         element: elem,
1322                                                         left: position.left,
1323                                                         top: position.top,
1324                                                         width: elemWidth,
1325                                                         height: elemHeight
1326                                                 },
1327                                                 horizontal: right < 0 ? "left" : left > 0 ? "right" : "center",
1328                                                 vertical: bottom < 0 ? "top" : top > 0 ? "bottom" : "middle"
1329                                         };
1330                                 if ( targetWidth < elemWidth && abs( left + right ) < targetWidth ) {
1331                                         feedback.horizontal = "center";
1332                                 }
1333                                 if ( targetHeight < elemHeight && abs( top + bottom ) < targetHeight ) {
1334                                         feedback.vertical = "middle";
1335                                 }
1336                                 if ( max( abs( left ), abs( right ) ) > max( abs( top ), abs( bottom ) ) ) {
1337                                         feedback.important = "horizontal";
1338                                 } else {
1339                                         feedback.important = "vertical";
1340                                 }
1341                                 options.using.call( this, props, feedback );
1342                         };
1343                 }
1344
1345                 elem.offset( $.extend( position, { using: using } ) );
1346         });
1347 };
1348
1349 $.ui.position = {
1350         fit: {
1351                 left: function( position, data ) {
1352                         var within = data.within,
1353                                 withinOffset = within.isWindow ? within.scrollLeft : within.offset.left,
1354                                 outerWidth = within.width,
1355                                 collisionPosLeft = position.left - data.collisionPosition.marginLeft,
1356                                 overLeft = withinOffset - collisionPosLeft,
1357                                 overRight = collisionPosLeft + data.collisionWidth - outerWidth - withinOffset,
1358                                 newOverRight;
1359
1360                         // element is wider than within
1361                         if ( data.collisionWidth > outerWidth ) {
1362                                 // element is initially over the left side of within
1363                                 if ( overLeft > 0 && overRight <= 0 ) {
1364                                         newOverRight = position.left + overLeft + data.collisionWidth - outerWidth - withinOffset;
1365                                         position.left += overLeft - newOverRight;
1366                                 // element is initially over right side of within
1367                                 } else if ( overRight > 0 && overLeft <= 0 ) {
1368                                         position.left = withinOffset;
1369                                 // element is initially over both left and right sides of within
1370                                 } else {
1371                                         if ( overLeft > overRight ) {
1372                                                 position.left = withinOffset + outerWidth - data.collisionWidth;
1373                                         } else {
1374                                                 position.left = withinOffset;
1375                                         }
1376                                 }
1377                         // too far left -> align with left edge
1378                         } else if ( overLeft > 0 ) {
1379                                 position.left += overLeft;
1380                         // too far right -> align with right edge
1381                         } else if ( overRight > 0 ) {
1382                                 position.left -= overRight;
1383                         // adjust based on position and margin
1384                         } else {
1385                                 position.left = max( position.left - collisionPosLeft, position.left );
1386                         }
1387                 },
1388                 top: function( position, data ) {
1389                         var within = data.within,
1390                                 withinOffset = within.isWindow ? within.scrollTop : within.offset.top,
1391                                 outerHeight = data.within.height,
1392                                 collisionPosTop = position.top - data.collisionPosition.marginTop,
1393                                 overTop = withinOffset - collisionPosTop,
1394                                 overBottom = collisionPosTop + data.collisionHeight - outerHeight - withinOffset,
1395                                 newOverBottom;
1396
1397                         // element is taller than within
1398                         if ( data.collisionHeight > outerHeight ) {
1399                                 // element is initially over the top of within
1400                                 if ( overTop > 0 && overBottom <= 0 ) {
1401                                         newOverBottom = position.top + overTop + data.collisionHeight - outerHeight - withinOffset;
1402                                         position.top += overTop - newOverBottom;
1403                                 // element is initially over bottom of within
1404                                 } else if ( overBottom > 0 && overTop <= 0 ) {
1405                                         position.top = withinOffset;
1406                                 // element is initially over both top and bottom of within
1407                                 } else {
1408                                         if ( overTop > overBottom ) {
1409                                                 position.top = withinOffset + outerHeight - data.collisionHeight;
1410                                         } else {
1411                                                 position.top = withinOffset;
1412                                         }
1413                                 }
1414                         // too far up -> align with top
1415                         } else if ( overTop > 0 ) {
1416                                 position.top += overTop;
1417                         // too far down -> align with bottom edge
1418                         } else if ( overBottom > 0 ) {
1419                                 position.top -= overBottom;
1420                         // adjust based on position and margin
1421                         } else {
1422                                 position.top = max( position.top - collisionPosTop, position.top );
1423                         }
1424                 }
1425         },
1426         flip: {
1427                 left: function( position, data ) {
1428                         var within = data.within,
1429                                 withinOffset = within.offset.left + within.scrollLeft,
1430                                 outerWidth = within.width,
1431                                 offsetLeft = within.isWindow ? within.scrollLeft : within.offset.left,
1432                                 collisionPosLeft = position.left - data.collisionPosition.marginLeft,
1433                                 overLeft = collisionPosLeft - offsetLeft,
1434                                 overRight = collisionPosLeft + data.collisionWidth - outerWidth - offsetLeft,
1435                                 myOffset = data.my[ 0 ] === "left" ?
1436                                         -data.elemWidth :
1437                                         data.my[ 0 ] === "right" ?
1438                                                 data.elemWidth :
1439                                                 0,
1440                                 atOffset = data.at[ 0 ] === "left" ?
1441                                         data.targetWidth :
1442                                         data.at[ 0 ] === "right" ?
1443                                                 -data.targetWidth :
1444                                                 0,
1445                                 offset = -2 * data.offset[ 0 ],
1446                                 newOverRight,
1447                                 newOverLeft;
1448
1449                         if ( overLeft < 0 ) {
1450                                 newOverRight = position.left + myOffset + atOffset + offset + data.collisionWidth - outerWidth - withinOffset;
1451                                 if ( newOverRight < 0 || newOverRight < abs( overLeft ) ) {
1452                                         position.left += myOffset + atOffset + offset;
1453                                 }
1454                         } else if ( overRight > 0 ) {
1455                                 newOverLeft = position.left - data.collisionPosition.marginLeft + myOffset + atOffset + offset - offsetLeft;
1456                                 if ( newOverLeft > 0 || abs( newOverLeft ) < overRight ) {
1457                                         position.left += myOffset + atOffset + offset;
1458                                 }
1459                         }
1460                 },
1461                 top: function( position, data ) {
1462                         var within = data.within,
1463                                 withinOffset = within.offset.top + within.scrollTop,
1464                                 outerHeight = within.height,
1465                                 offsetTop = within.isWindow ? within.scrollTop : within.offset.top,
1466                                 collisionPosTop = position.top - data.collisionPosition.marginTop,
1467                                 overTop = collisionPosTop - offsetTop,
1468                                 overBottom = collisionPosTop + data.collisionHeight - outerHeight - offsetTop,
1469                                 top = data.my[ 1 ] === "top",
1470                                 myOffset = top ?
1471                                         -data.elemHeight :
1472                                         data.my[ 1 ] === "bottom" ?
1473                                                 data.elemHeight :
1474                                                 0,
1475                                 atOffset = data.at[ 1 ] === "top" ?
1476                                         data.targetHeight :
1477                                         data.at[ 1 ] === "bottom" ?
1478                                                 -data.targetHeight :
1479                                                 0,
1480                                 offset = -2 * data.offset[ 1 ],
1481                                 newOverTop,
1482                                 newOverBottom;
1483                         if ( overTop < 0 ) {
1484                                 newOverBottom = position.top + myOffset + atOffset + offset + data.collisionHeight - outerHeight - withinOffset;
1485                                 if ( newOverBottom < 0 || newOverBottom < abs( overTop ) ) {
1486                                         position.top += myOffset + atOffset + offset;
1487                                 }
1488                         } else if ( overBottom > 0 ) {
1489                                 newOverTop = position.top - data.collisionPosition.marginTop + myOffset + atOffset + offset - offsetTop;
1490                                 if ( newOverTop > 0 || abs( newOverTop ) < overBottom ) {
1491                                         position.top += myOffset + atOffset + offset;
1492                                 }
1493                         }
1494                 }
1495         },
1496         flipfit: {
1497                 left: function() {
1498                         $.ui.position.flip.left.apply( this, arguments );
1499                         $.ui.position.fit.left.apply( this, arguments );
1500                 },
1501                 top: function() {
1502                         $.ui.position.flip.top.apply( this, arguments );
1503                         $.ui.position.fit.top.apply( this, arguments );
1504                 }
1505         }
1506 };
1507
1508 // fraction support test
1509 (function() {
1510         var testElement, testElementParent, testElementStyle, offsetLeft, i,
1511                 body = document.getElementsByTagName( "body" )[ 0 ],
1512                 div = document.createElement( "div" );
1513
1514         //Create a "fake body" for testing based on method used in jQuery.support
1515         testElement = document.createElement( body ? "div" : "body" );
1516         testElementStyle = {
1517                 visibility: "hidden",
1518                 width: 0,
1519                 height: 0,
1520                 border: 0,
1521                 margin: 0,
1522                 background: "none"
1523         };
1524         if ( body ) {
1525                 $.extend( testElementStyle, {
1526                         position: "absolute",
1527                         left: "-1000px",
1528                         top: "-1000px"
1529                 });
1530         }
1531         for ( i in testElementStyle ) {
1532                 testElement.style[ i ] = testElementStyle[ i ];
1533         }
1534         testElement.appendChild( div );
1535         testElementParent = body || document.documentElement;
1536         testElementParent.insertBefore( testElement, testElementParent.firstChild );
1537
1538         div.style.cssText = "position: absolute; left: 10.7432222px;";
1539
1540         offsetLeft = $( div ).offset().left;
1541         supportsOffsetFractions = offsetLeft > 10 && offsetLeft < 11;
1542
1543         testElement.innerHTML = "";
1544         testElementParent.removeChild( testElement );
1545 })();
1546
1547 })();
1548
1549 var position = $.ui.position;
1550
1551
1552 /*!
1553  * jQuery UI Accordion 1.11.4
1554  * http://jqueryui.com
1555  *
1556  * Copyright jQuery Foundation and other contributors
1557  * Released under the MIT license.
1558  * http://jquery.org/license
1559  *
1560  * http://api.jqueryui.com/accordion/
1561  */
1562
1563
1564 var accordion = $.widget( "ui.accordion", {
1565         version: "1.11.4",
1566         options: {
1567                 active: 0,
1568                 animate: {},
1569                 collapsible: false,
1570                 event: "click",
1571                 header: "> li > :first-child,> :not(li):even",
1572                 heightStyle: "auto",
1573                 icons: {
1574                         activeHeader: "ui-icon-triangle-1-s",
1575                         header: "ui-icon-triangle-1-e"
1576                 },
1577
1578                 // callbacks
1579                 activate: null,
1580                 beforeActivate: null
1581         },
1582
1583         hideProps: {
1584                 borderTopWidth: "hide",
1585                 borderBottomWidth: "hide",
1586                 paddingTop: "hide",
1587                 paddingBottom: "hide",
1588                 height: "hide"
1589         },
1590
1591         showProps: {
1592                 borderTopWidth: "show",
1593                 borderBottomWidth: "show",
1594                 paddingTop: "show",
1595                 paddingBottom: "show",
1596                 height: "show"
1597         },
1598
1599         _create: function() {
1600                 var options = this.options;
1601                 this.prevShow = this.prevHide = $();
1602                 this.element.addClass( "ui-accordion ui-widget ui-helper-reset" )
1603                         // ARIA
1604                         .attr( "role", "tablist" );
1605
1606                 // don't allow collapsible: false and active: false / null
1607                 if ( !options.collapsible && (options.active === false || options.active == null) ) {
1608                         options.active = 0;
1609                 }
1610
1611                 this._processPanels();
1612                 // handle negative values
1613                 if ( options.active < 0 ) {
1614                         options.active += this.headers.length;
1615                 }
1616                 this._refresh();
1617         },
1618
1619         _getCreateEventData: function() {
1620                 return {
1621                         header: this.active,
1622                         panel: !this.active.length ? $() : this.active.next()
1623                 };
1624         },
1625
1626         _createIcons: function() {
1627                 var icons = this.options.icons;
1628                 if ( icons ) {
1629                         $( "<span>" )
1630                                 .addClass( "ui-accordion-header-icon ui-icon " + icons.header )
1631                                 .prependTo( this.headers );
1632                         this.active.children( ".ui-accordion-header-icon" )
1633                                 .removeClass( icons.header )
1634                                 .addClass( icons.activeHeader );
1635                         this.headers.addClass( "ui-accordion-icons" );
1636                 }
1637         },
1638
1639         _destroyIcons: function() {
1640                 this.headers
1641                         .removeClass( "ui-accordion-icons" )
1642                         .children( ".ui-accordion-header-icon" )
1643                                 .remove();
1644         },
1645
1646         _destroy: function() {
1647                 var contents;
1648
1649                 // clean up main element
1650                 this.element
1651                         .removeClass( "ui-accordion ui-widget ui-helper-reset" )
1652                         .removeAttr( "role" );
1653
1654                 // clean up headers
1655                 this.headers
1656                         .removeClass( "ui-accordion-header ui-accordion-header-active ui-state-default " +
1657                                 "ui-corner-all ui-state-active ui-state-disabled ui-corner-top" )
1658                         .removeAttr( "role" )
1659                         .removeAttr( "aria-expanded" )
1660                         .removeAttr( "aria-selected" )
1661                         .removeAttr( "aria-controls" )
1662                         .removeAttr( "tabIndex" )
1663                         .removeUniqueId();
1664
1665                 this._destroyIcons();
1666
1667                 // clean up content panels
1668                 contents = this.headers.next()
1669                         .removeClass( "ui-helper-reset ui-widget-content ui-corner-bottom " +
1670                                 "ui-accordion-content ui-accordion-content-active ui-state-disabled" )
1671                         .css( "display", "" )
1672                         .removeAttr( "role" )
1673                         .removeAttr( "aria-hidden" )
1674                         .removeAttr( "aria-labelledby" )
1675                         .removeUniqueId();
1676
1677                 if ( this.options.heightStyle !== "content" ) {
1678                         contents.css( "height", "" );
1679                 }
1680         },
1681
1682         _setOption: function( key, value ) {
1683                 if ( key === "active" ) {
1684                         // _activate() will handle invalid values and update this.options
1685                         this._activate( value );
1686                         return;
1687                 }
1688
1689                 if ( key === "event" ) {
1690                         if ( this.options.event ) {
1691                                 this._off( this.headers, this.options.event );
1692                         }
1693                         this._setupEvents( value );
1694                 }
1695
1696                 this._super( key, value );
1697
1698                 // setting collapsible: false while collapsed; open first panel
1699                 if ( key === "collapsible" && !value && this.options.active === false ) {
1700                         this._activate( 0 );
1701                 }
1702
1703                 if ( key === "icons" ) {
1704                         this._destroyIcons();
1705                         if ( value ) {
1706                                 this._createIcons();
1707                         }
1708                 }
1709
1710                 // #5332 - opacity doesn't cascade to positioned elements in IE
1711                 // so we need to add the disabled class to the headers and panels
1712                 if ( key === "disabled" ) {
1713                         this.element
1714                                 .toggleClass( "ui-state-disabled", !!value )
1715                                 .attr( "aria-disabled", value );
1716                         this.headers.add( this.headers.next() )
1717                                 .toggleClass( "ui-state-disabled", !!value );
1718                 }
1719         },
1720
1721         _keydown: function( event ) {
1722                 if ( event.altKey || event.ctrlKey ) {
1723                         return;
1724                 }
1725
1726                 var keyCode = $.ui.keyCode,
1727                         length = this.headers.length,
1728                         currentIndex = this.headers.index( event.target ),
1729                         toFocus = false;
1730
1731                 switch ( event.keyCode ) {
1732                         case keyCode.RIGHT:
1733                         case keyCode.DOWN:
1734                                 toFocus = this.headers[ ( currentIndex + 1 ) % length ];
1735                                 break;
1736                         case keyCode.LEFT:
1737                         case keyCode.UP:
1738                                 toFocus = this.headers[ ( currentIndex - 1 + length ) % length ];
1739                                 break;
1740                         case keyCode.SPACE:
1741                         case keyCode.ENTER:
1742                                 this._eventHandler( event );
1743                                 break;
1744                         case keyCode.HOME:
1745                                 toFocus = this.headers[ 0 ];
1746                                 break;
1747                         case keyCode.END:
1748                                 toFocus = this.headers[ length - 1 ];
1749                                 break;
1750                 }
1751
1752                 if ( toFocus ) {
1753                         $( event.target ).attr( "tabIndex", -1 );
1754                         $( toFocus ).attr( "tabIndex", 0 );
1755                         toFocus.focus();
1756                         event.preventDefault();
1757                 }
1758         },
1759
1760         _panelKeyDown: function( event ) {
1761                 if ( event.keyCode === $.ui.keyCode.UP && event.ctrlKey ) {
1762                         $( event.currentTarget ).prev().focus();
1763                 }
1764         },
1765
1766         refresh: function() {
1767                 var options = this.options;
1768                 this._processPanels();
1769
1770                 // was collapsed or no panel
1771                 if ( ( options.active === false && options.collapsible === true ) || !this.headers.length ) {
1772                         options.active = false;
1773                         this.active = $();
1774                 // active false only when collapsible is true
1775                 } else if ( options.active === false ) {
1776                         this._activate( 0 );
1777                 // was active, but active panel is gone
1778                 } else if ( this.active.length && !$.contains( this.element[ 0 ], this.active[ 0 ] ) ) {
1779                         // all remaining panel are disabled
1780                         if ( this.headers.length === this.headers.find(".ui-state-disabled").length ) {
1781                                 options.active = false;
1782                                 this.active = $();
1783                         // activate previous panel
1784                         } else {
1785                                 this._activate( Math.max( 0, options.active - 1 ) );
1786                         }
1787                 // was active, active panel still exists
1788                 } else {
1789                         // make sure active index is correct
1790                         options.active = this.headers.index( this.active );
1791                 }
1792
1793                 this._destroyIcons();
1794
1795                 this._refresh();
1796         },
1797
1798         _processPanels: function() {
1799                 var prevHeaders = this.headers,
1800                         prevPanels = this.panels;
1801
1802                 this.headers = this.element.find( this.options.header )
1803                         .addClass( "ui-accordion-header ui-state-default ui-corner-all" );
1804
1805                 this.panels = this.headers.next()
1806                         .addClass( "ui-accordion-content ui-helper-reset ui-widget-content ui-corner-bottom" )
1807                         .filter( ":not(.ui-accordion-content-active)" )
1808                         .hide();
1809
1810                 // Avoid memory leaks (#10056)
1811                 if ( prevPanels ) {
1812                         this._off( prevHeaders.not( this.headers ) );
1813                         this._off( prevPanels.not( this.panels ) );
1814                 }
1815         },
1816
1817         _refresh: function() {
1818                 var maxHeight,
1819                         options = this.options,
1820                         heightStyle = options.heightStyle,
1821                         parent = this.element.parent();
1822
1823                 this.active = this._findActive( options.active )
1824                         .addClass( "ui-accordion-header-active ui-state-active ui-corner-top" )
1825                         .removeClass( "ui-corner-all" );
1826                 this.active.next()
1827                         .addClass( "ui-accordion-content-active" )
1828                         .show();
1829
1830                 this.headers
1831                         .attr( "role", "tab" )
1832                         .each(function() {
1833                                 var header = $( this ),
1834                                         headerId = header.uniqueId().attr( "id" ),
1835                                         panel = header.next(),
1836                                         panelId = panel.uniqueId().attr( "id" );
1837                                 header.attr( "aria-controls", panelId );
1838                                 panel.attr( "aria-labelledby", headerId );
1839                         })
1840                         .next()
1841                                 .attr( "role", "tabpanel" );
1842
1843                 this.headers
1844                         .not( this.active )
1845                         .attr({
1846                                 "aria-selected": "false",
1847                                 "aria-expanded": "false",
1848                                 tabIndex: -1
1849                         })
1850                         .next()
1851                                 .attr({
1852                                         "aria-hidden": "true"
1853                                 })
1854                                 .hide();
1855
1856                 // make sure at least one header is in the tab order
1857                 if ( !this.active.length ) {
1858                         this.headers.eq( 0 ).attr( "tabIndex", 0 );
1859                 } else {
1860                         this.active.attr({
1861                                 "aria-selected": "true",
1862                                 "aria-expanded": "true",
1863                                 tabIndex: 0
1864                         })
1865                         .next()
1866                                 .attr({
1867                                         "aria-hidden": "false"
1868                                 });
1869                 }
1870
1871                 this._createIcons();
1872
1873                 this._setupEvents( options.event );
1874
1875                 if ( heightStyle === "fill" ) {
1876                         maxHeight = parent.height();
1877                         this.element.siblings( ":visible" ).each(function() {
1878                                 var elem = $( this ),
1879                                         position = elem.css( "position" );
1880
1881                                 if ( position === "absolute" || position === "fixed" ) {
1882                                         return;
1883                                 }
1884                                 maxHeight -= elem.outerHeight( true );
1885                         });
1886
1887                         this.headers.each(function() {
1888                                 maxHeight -= $( this ).outerHeight( true );
1889                         });
1890
1891                         this.headers.next()
1892                                 .each(function() {
1893                                         $( this ).height( Math.max( 0, maxHeight -
1894                                                 $( this ).innerHeight() + $( this ).height() ) );
1895                                 })
1896                                 .css( "overflow", "auto" );
1897                 } else if ( heightStyle === "auto" ) {
1898                         maxHeight = 0;
1899                         this.headers.next()
1900                                 .each(function() {
1901                                         maxHeight = Math.max( maxHeight, $( this ).css( "height", "" ).height() );
1902                                 })
1903                                 .height( maxHeight );
1904                 }
1905         },
1906
1907         _activate: function( index ) {
1908                 var active = this._findActive( index )[ 0 ];
1909
1910                 // trying to activate the already active panel
1911                 if ( active === this.active[ 0 ] ) {
1912                         return;
1913                 }
1914
1915                 // trying to collapse, simulate a click on the currently active header
1916                 active = active || this.active[ 0 ];
1917
1918                 this._eventHandler({
1919                         target: active,
1920                         currentTarget: active,
1921                         preventDefault: $.noop
1922                 });
1923         },
1924
1925         _findActive: function( selector ) {
1926                 return typeof selector === "number" ? this.headers.eq( selector ) : $();
1927         },
1928
1929         _setupEvents: function( event ) {
1930                 var events = {
1931                         keydown: "_keydown"
1932                 };
1933                 if ( event ) {
1934                         $.each( event.split( " " ), function( index, eventName ) {
1935                                 events[ eventName ] = "_eventHandler";
1936                         });
1937                 }
1938
1939                 this._off( this.headers.add( this.headers.next() ) );
1940                 this._on( this.headers, events );
1941                 this._on( this.headers.next(), { keydown: "_panelKeyDown" });
1942                 this._hoverable( this.headers );
1943                 this._focusable( this.headers );
1944         },
1945
1946         _eventHandler: function( event ) {
1947                 var options = this.options,
1948                         active = this.active,
1949                         clicked = $( event.currentTarget ),
1950                         clickedIsActive = clicked[ 0 ] === active[ 0 ],
1951                         collapsing = clickedIsActive && options.collapsible,
1952                         toShow = collapsing ? $() : clicked.next(),
1953                         toHide = active.next(),
1954                         eventData = {
1955                                 oldHeader: active,
1956                                 oldPanel: toHide,
1957                                 newHeader: collapsing ? $() : clicked,
1958                                 newPanel: toShow
1959                         };
1960
1961                 event.preventDefault();
1962
1963                 if (
1964                                 // click on active header, but not collapsible
1965                                 ( clickedIsActive && !options.collapsible ) ||
1966                                 // allow canceling activation
1967                                 ( this._trigger( "beforeActivate", event, eventData ) === false ) ) {
1968                         return;
1969                 }
1970
1971                 options.active = collapsing ? false : this.headers.index( clicked );
1972
1973                 // when the call to ._toggle() comes after the class changes
1974                 // it causes a very odd bug in IE 8 (see #6720)
1975                 this.active = clickedIsActive ? $() : clicked;
1976                 this._toggle( eventData );
1977
1978                 // switch classes
1979                 // corner classes on the previously active header stay after the animation
1980                 active.removeClass( "ui-accordion-header-active ui-state-active" );
1981                 if ( options.icons ) {
1982                         active.children( ".ui-accordion-header-icon" )
1983                                 .removeClass( options.icons.activeHeader )
1984                                 .addClass( options.icons.header );
1985                 }
1986
1987                 if ( !clickedIsActive ) {
1988                         clicked
1989                                 .removeClass( "ui-corner-all" )
1990                                 .addClass( "ui-accordion-header-active ui-state-active ui-corner-top" );
1991                         if ( options.icons ) {
1992                                 clicked.children( ".ui-accordion-header-icon" )
1993                                         .removeClass( options.icons.header )
1994                                         .addClass( options.icons.activeHeader );
1995                         }
1996
1997                         clicked
1998                                 .next()
1999                                 .addClass( "ui-accordion-content-active" );
2000                 }
2001         },
2002
2003         _toggle: function( data ) {
2004                 var toShow = data.newPanel,
2005                         toHide = this.prevShow.length ? this.prevShow : data.oldPanel;
2006
2007                 // handle activating a panel during the animation for another activation
2008                 this.prevShow.add( this.prevHide ).stop( true, true );
2009                 this.prevShow = toShow;
2010                 this.prevHide = toHide;
2011
2012                 if ( this.options.animate ) {
2013                         this._animate( toShow, toHide, data );
2014                 } else {
2015                         toHide.hide();
2016                         toShow.show();
2017                         this._toggleComplete( data );
2018                 }
2019
2020                 toHide.attr({
2021                         "aria-hidden": "true"
2022                 });
2023                 toHide.prev().attr({
2024                         "aria-selected": "false",
2025                         "aria-expanded": "false"
2026                 });
2027                 // if we're switching panels, remove the old header from the tab order
2028                 // if we're opening from collapsed state, remove the previous header from the tab order
2029                 // if we're collapsing, then keep the collapsing header in the tab order
2030                 if ( toShow.length && toHide.length ) {
2031                         toHide.prev().attr({
2032                                 "tabIndex": -1,
2033                                 "aria-expanded": "false"
2034                         });
2035                 } else if ( toShow.length ) {
2036                         this.headers.filter(function() {
2037                                 return parseInt( $( this ).attr( "tabIndex" ), 10 ) === 0;
2038                         })
2039                         .attr( "tabIndex", -1 );
2040                 }
2041
2042                 toShow
2043                         .attr( "aria-hidden", "false" )
2044                         .prev()
2045                                 .attr({
2046                                         "aria-selected": "true",
2047                                         "aria-expanded": "true",
2048                                         tabIndex: 0
2049                                 });
2050         },
2051
2052         _animate: function( toShow, toHide, data ) {
2053                 var total, easing, duration,
2054                         that = this,
2055                         adjust = 0,
2056                         boxSizing = toShow.css( "box-sizing" ),
2057                         down = toShow.length &&
2058                                 ( !toHide.length || ( toShow.index() < toHide.index() ) ),
2059                         animate = this.options.animate || {},
2060                         options = down && animate.down || animate,
2061                         complete = function() {
2062                                 that._toggleComplete( data );
2063                         };
2064
2065                 if ( typeof options === "number" ) {
2066                         duration = options;
2067                 }
2068                 if ( typeof options === "string" ) {
2069                         easing = options;
2070                 }
2071                 // fall back from options to animation in case of partial down settings
2072                 easing = easing || options.easing || animate.easing;
2073                 duration = duration || options.duration || animate.duration;
2074
2075                 if ( !toHide.length ) {
2076                         return toShow.animate( this.showProps, duration, easing, complete );
2077                 }
2078                 if ( !toShow.length ) {
2079                         return toHide.animate( this.hideProps, duration, easing, complete );
2080                 }
2081
2082                 total = toShow.show().outerHeight();
2083                 toHide.animate( this.hideProps, {
2084                         duration: duration,
2085                         easing: easing,
2086                         step: function( now, fx ) {
2087                                 fx.now = Math.round( now );
2088                         }
2089                 });
2090                 toShow
2091                         .hide()
2092                         .animate( this.showProps, {
2093                                 duration: duration,
2094                                 easing: easing,
2095                                 complete: complete,
2096                                 step: function( now, fx ) {
2097                                         fx.now = Math.round( now );
2098                                         if ( fx.prop !== "height" ) {
2099                                                 if ( boxSizing === "content-box" ) {
2100                                                         adjust += fx.now;
2101                                                 }
2102                                         } else if ( that.options.heightStyle !== "content" ) {
2103                                                 fx.now = Math.round( total - toHide.outerHeight() - adjust );
2104                                                 adjust = 0;
2105                                         }
2106                                 }
2107                         });
2108         },
2109
2110         _toggleComplete: function( data ) {
2111                 var toHide = data.oldPanel;
2112
2113                 toHide
2114                         .removeClass( "ui-accordion-content-active" )
2115                         .prev()
2116                                 .removeClass( "ui-corner-top" )
2117                                 .addClass( "ui-corner-all" );
2118
2119                 // Work around for rendering bug in IE (#5421)
2120                 if ( toHide.length ) {
2121                         toHide.parent()[ 0 ].className = toHide.parent()[ 0 ].className;
2122                 }
2123                 this._trigger( "activate", null, data );
2124         }
2125 });
2126
2127
2128 /*!
2129  * jQuery UI Menu 1.11.4
2130  * http://jqueryui.com
2131  *
2132  * Copyright jQuery Foundation and other contributors
2133  * Released under the MIT license.
2134  * http://jquery.org/license
2135  *
2136  * http://api.jqueryui.com/menu/
2137  */
2138
2139
2140 var menu = $.widget( "ui.menu", {
2141         version: "1.11.4",
2142         defaultElement: "<ul>",
2143         delay: 300,
2144         options: {
2145                 icons: {
2146                         submenu: "ui-icon-carat-1-e"
2147                 },
2148                 items: "> *",
2149                 menus: "ul",
2150                 position: {
2151                         my: "left-1 top",
2152                         at: "right top"
2153                 },
2154                 role: "menu",
2155
2156                 // callbacks
2157                 blur: null,
2158                 focus: null,
2159                 select: null
2160         },
2161
2162         _create: function() {
2163                 this.activeMenu = this.element;
2164
2165                 // Flag used to prevent firing of the click handler
2166                 // as the event bubbles up through nested menus
2167                 this.mouseHandled = false;
2168                 this.element
2169                         .uniqueId()
2170                         .addClass( "ui-menu ui-widget ui-widget-content" )
2171                         .toggleClass( "ui-menu-icons", !!this.element.find( ".ui-icon" ).length )
2172                         .attr({
2173                                 role: this.options.role,
2174                                 tabIndex: 0
2175                         });
2176
2177                 if ( this.options.disabled ) {
2178                         this.element
2179                                 .addClass( "ui-state-disabled" )
2180                                 .attr( "aria-disabled", "true" );
2181                 }
2182
2183                 this._on({
2184                         // Prevent focus from sticking to links inside menu after clicking
2185                         // them (focus should always stay on UL during navigation).
2186                         "mousedown .ui-menu-item": function( event ) {
2187                                 event.preventDefault();
2188                         },
2189                         "click .ui-menu-item": function( event ) {
2190                                 var target = $( event.target );
2191                                 if ( !this.mouseHandled && target.not( ".ui-state-disabled" ).length ) {
2192                                         this.select( event );
2193
2194                                         // Only set the mouseHandled flag if the event will bubble, see #9469.
2195                                         if ( !event.isPropagationStopped() ) {
2196                                                 this.mouseHandled = true;
2197                                         }
2198
2199                                         // Open submenu on click
2200                                         if ( target.has( ".ui-menu" ).length ) {
2201                                                 this.expand( event );
2202                                         } else if ( !this.element.is( ":focus" ) && $( this.document[ 0 ].activeElement ).closest( ".ui-menu" ).length ) {
2203
2204                                                 // Redirect focus to the menu
2205                                                 this.element.trigger( "focus", [ true ] );
2206
2207                                                 // If the active item is on the top level, let it stay active.
2208                                                 // Otherwise, blur the active item since it is no longer visible.
2209                                                 if ( this.active && this.active.parents( ".ui-menu" ).length === 1 ) {
2210                                                         clearTimeout( this.timer );
2211                                                 }
2212                                         }
2213                                 }
2214                         },
2215                         "mouseenter .ui-menu-item": function( event ) {
2216                                 // Ignore mouse events while typeahead is active, see #10458.
2217                                 // Prevents focusing the wrong item when typeahead causes a scroll while the mouse
2218                                 // is over an item in the menu
2219                                 if ( this.previousFilter ) {
2220                                         return;
2221                                 }
2222                                 var target = $( event.currentTarget );
2223                                 // Remove ui-state-active class from siblings of the newly focused menu item
2224                                 // to avoid a jump caused by adjacent elements both having a class with a border
2225                                 target.siblings( ".ui-state-active" ).removeClass( "ui-state-active" );
2226                                 this.focus( event, target );
2227                         },
2228                         mouseleave: "collapseAll",
2229                         "mouseleave .ui-menu": "collapseAll",
2230                         focus: function( event, keepActiveItem ) {
2231                                 // If there's already an active item, keep it active
2232                                 // If not, activate the first item
2233                                 var item = this.active || this.element.find( this.options.items ).eq( 0 );
2234
2235                                 if ( !keepActiveItem ) {
2236                                         this.focus( event, item );
2237                                 }
2238                         },
2239                         blur: function( event ) {
2240                                 this._delay(function() {
2241                                         if ( !$.contains( this.element[0], this.document[0].activeElement ) ) {
2242                                                 this.collapseAll( event );
2243                                         }
2244                                 });
2245                         },
2246                         keydown: "_keydown"
2247                 });
2248
2249                 this.refresh();
2250
2251                 // Clicks outside of a menu collapse any open menus
2252                 this._on( this.document, {
2253                         click: function( event ) {
2254                                 if ( this._closeOnDocumentClick( event ) ) {
2255                                         this.collapseAll( event );
2256                                 }
2257
2258                                 // Reset the mouseHandled flag
2259                                 this.mouseHandled = false;
2260                         }
2261                 });
2262         },
2263
2264         _destroy: function() {
2265                 // Destroy (sub)menus
2266                 this.element
2267                         .removeAttr( "aria-activedescendant" )
2268                         .find( ".ui-menu" ).addBack()
2269                                 .removeClass( "ui-menu ui-widget ui-widget-content ui-menu-icons ui-front" )
2270                                 .removeAttr( "role" )
2271                                 .removeAttr( "tabIndex" )
2272                                 .removeAttr( "aria-labelledby" )
2273                                 .removeAttr( "aria-expanded" )
2274                                 .removeAttr( "aria-hidden" )
2275                                 .removeAttr( "aria-disabled" )
2276                                 .removeUniqueId()
2277                                 .show();
2278
2279                 // Destroy menu items
2280                 this.element.find( ".ui-menu-item" )
2281                         .removeClass( "ui-menu-item" )
2282                         .removeAttr( "role" )
2283                         .removeAttr( "aria-disabled" )
2284                         .removeUniqueId()
2285                         .removeClass( "ui-state-hover" )
2286                         .removeAttr( "tabIndex" )
2287                         .removeAttr( "role" )
2288                         .removeAttr( "aria-haspopup" )
2289                         .children().each( function() {
2290                                 var elem = $( this );
2291                                 if ( elem.data( "ui-menu-submenu-carat" ) ) {
2292                                         elem.remove();
2293                                 }
2294                         });
2295
2296                 // Destroy menu dividers
2297                 this.element.find( ".ui-menu-divider" ).removeClass( "ui-menu-divider ui-widget-content" );
2298         },
2299
2300         _keydown: function( event ) {
2301                 var match, prev, character, skip,
2302                         preventDefault = true;
2303
2304                 switch ( event.keyCode ) {
2305                 case $.ui.keyCode.PAGE_UP:
2306                         this.previousPage( event );
2307                         break;
2308                 case $.ui.keyCode.PAGE_DOWN:
2309                         this.nextPage( event );
2310                         break;
2311                 case $.ui.keyCode.HOME:
2312                         this._move( "first", "first", event );
2313                         break;
2314                 case $.ui.keyCode.END:
2315                         this._move( "last", "last", event );
2316                         break;
2317                 case $.ui.keyCode.UP:
2318                         this.previous( event );
2319                         break;
2320                 case $.ui.keyCode.DOWN:
2321                         this.next( event );
2322                         break;
2323                 case $.ui.keyCode.LEFT:
2324                         this.collapse( event );
2325                         break;
2326                 case $.ui.keyCode.RIGHT:
2327                         if ( this.active && !this.active.is( ".ui-state-disabled" ) ) {
2328                                 this.expand( event );
2329                         }
2330                         break;
2331                 case $.ui.keyCode.ENTER:
2332                 case $.ui.keyCode.SPACE:
2333                         this._activate( event );
2334                         break;
2335                 case $.ui.keyCode.ESCAPE:
2336                         this.collapse( event );
2337                         break;
2338                 default:
2339                         preventDefault = false;
2340                         prev = this.previousFilter || "";
2341                         character = String.fromCharCode( event.keyCode );
2342                         skip = false;
2343
2344                         clearTimeout( this.filterTimer );
2345
2346                         if ( character === prev ) {
2347                                 skip = true;
2348                         } else {
2349                                 character = prev + character;
2350                         }
2351
2352                         match = this._filterMenuItems( character );
2353                         match = skip && match.index( this.active.next() ) !== -1 ?
2354                                 this.active.nextAll( ".ui-menu-item" ) :
2355                                 match;
2356
2357                         // If no matches on the current filter, reset to the last character pressed
2358                         // to move down the menu to the first item that starts with that character
2359                         if ( !match.length ) {
2360                                 character = String.fromCharCode( event.keyCode );
2361                                 match = this._filterMenuItems( character );
2362                         }
2363
2364                         if ( match.length ) {
2365                                 this.focus( event, match );
2366                                 this.previousFilter = character;
2367                                 this.filterTimer = this._delay(function() {
2368                                         delete this.previousFilter;
2369                                 }, 1000 );
2370                         } else {
2371                                 delete this.previousFilter;
2372                         }
2373                 }
2374
2375                 if ( preventDefault ) {
2376                         event.preventDefault();
2377                 }
2378         },
2379
2380         _activate: function( event ) {
2381                 if ( !this.active.is( ".ui-state-disabled" ) ) {
2382                         if ( this.active.is( "[aria-haspopup='true']" ) ) {
2383                                 this.expand( event );
2384                         } else {
2385                                 this.select( event );
2386                         }
2387                 }
2388         },
2389
2390         refresh: function() {
2391                 var menus, items,
2392                         that = this,
2393                         icon = this.options.icons.submenu,
2394                         submenus = this.element.find( this.options.menus );
2395
2396                 this.element.toggleClass( "ui-menu-icons", !!this.element.find( ".ui-icon" ).length );
2397
2398                 // Initialize nested menus
2399                 submenus.filter( ":not(.ui-menu)" )
2400                         .addClass( "ui-menu ui-widget ui-widget-content ui-front" )
2401                         .hide()
2402                         .attr({
2403                                 role: this.options.role,
2404                                 "aria-hidden": "true",
2405                                 "aria-expanded": "false"
2406                         })
2407                         .each(function() {
2408                                 var menu = $( this ),
2409                                         item = menu.parent(),
2410                                         submenuCarat = $( "<span>" )
2411                                                 .addClass( "ui-menu-icon ui-icon " + icon )
2412                                                 .data( "ui-menu-submenu-carat", true );
2413
2414                                 item
2415                                         .attr( "aria-haspopup", "true" )
2416                                         .prepend( submenuCarat );
2417                                 menu.attr( "aria-labelledby", item.attr( "id" ) );
2418                         });
2419
2420                 menus = submenus.add( this.element );
2421                 items = menus.find( this.options.items );
2422
2423                 // Initialize menu-items containing spaces and/or dashes only as dividers
2424                 items.not( ".ui-menu-item" ).each(function() {
2425                         var item = $( this );
2426                         if ( that._isDivider( item ) ) {
2427                                 item.addClass( "ui-widget-content ui-menu-divider" );
2428                         }
2429                 });
2430
2431                 // Don't refresh list items that are already adapted
2432                 items.not( ".ui-menu-item, .ui-menu-divider" )
2433                         .addClass( "ui-menu-item" )
2434                         .uniqueId()
2435                         .attr({
2436                                 tabIndex: -1,
2437                                 role: this._itemRole()
2438                         });
2439
2440                 // Add aria-disabled attribute to any disabled menu item
2441                 items.filter( ".ui-state-disabled" ).attr( "aria-disabled", "true" );
2442
2443                 // If the active item has been removed, blur the menu
2444                 if ( this.active && !$.contains( this.element[ 0 ], this.active[ 0 ] ) ) {
2445                         this.blur();
2446                 }
2447         },
2448
2449         _itemRole: function() {
2450                 return {
2451                         menu: "menuitem",
2452                         listbox: "option"
2453                 }[ this.options.role ];
2454         },
2455
2456         _setOption: function( key, value ) {
2457                 if ( key === "icons" ) {
2458                         this.element.find( ".ui-menu-icon" )
2459                                 .removeClass( this.options.icons.submenu )
2460                                 .addClass( value.submenu );
2461                 }
2462                 if ( key === "disabled" ) {
2463                         this.element
2464                                 .toggleClass( "ui-state-disabled", !!value )
2465                                 .attr( "aria-disabled", value );
2466                 }
2467                 this._super( key, value );
2468         },
2469
2470         focus: function( event, item ) {
2471                 var nested, focused;
2472                 this.blur( event, event && event.type === "focus" );
2473
2474                 this._scrollIntoView( item );
2475
2476                 this.active = item.first();
2477                 focused = this.active.addClass( "ui-state-focus" ).removeClass( "ui-state-active" );
2478                 // Only update aria-activedescendant if there's a role
2479                 // otherwise we assume focus is managed elsewhere
2480                 if ( this.options.role ) {
2481                         this.element.attr( "aria-activedescendant", focused.attr( "id" ) );
2482                 }
2483
2484                 // Highlight active parent menu item, if any
2485                 this.active
2486                         .parent()
2487                         .closest( ".ui-menu-item" )
2488                         .addClass( "ui-state-active" );
2489
2490                 if ( event && event.type === "keydown" ) {
2491                         this._close();
2492                 } else {
2493                         this.timer = this._delay(function() {
2494                                 this._close();
2495                         }, this.delay );
2496                 }
2497
2498                 nested = item.children( ".ui-menu" );
2499                 if ( nested.length && event && ( /^mouse/.test( event.type ) ) ) {
2500                         this._startOpening(nested);
2501                 }
2502                 this.activeMenu = item.parent();
2503
2504                 this._trigger( "focus", event, { item: item } );
2505         },
2506
2507         _scrollIntoView: function( item ) {
2508                 var borderTop, paddingTop, offset, scroll, elementHeight, itemHeight;
2509                 if ( this._hasScroll() ) {
2510                         borderTop = parseFloat( $.css( this.activeMenu[0], "borderTopWidth" ) ) || 0;
2511                         paddingTop = parseFloat( $.css( this.activeMenu[0], "paddingTop" ) ) || 0;
2512                         offset = item.offset().top - this.activeMenu.offset().top - borderTop - paddingTop;
2513                         scroll = this.activeMenu.scrollTop();
2514                         elementHeight = this.activeMenu.height();
2515                         itemHeight = item.outerHeight();
2516
2517                         if ( offset < 0 ) {
2518                                 this.activeMenu.scrollTop( scroll + offset );
2519                         } else if ( offset + itemHeight > elementHeight ) {
2520                                 this.activeMenu.scrollTop( scroll + offset - elementHeight + itemHeight );
2521                         }
2522                 }
2523         },
2524
2525         blur: function( event, fromFocus ) {
2526                 if ( !fromFocus ) {
2527                         clearTimeout( this.timer );
2528                 }
2529
2530                 if ( !this.active ) {
2531                         return;
2532                 }
2533
2534                 this.active.removeClass( "ui-state-focus" );
2535                 this.active = null;
2536
2537                 this._trigger( "blur", event, { item: this.active } );
2538         },
2539
2540         _startOpening: function( submenu ) {
2541                 clearTimeout( this.timer );
2542
2543                 // Don't open if already open fixes a Firefox bug that caused a .5 pixel
2544                 // shift in the submenu position when mousing over the carat icon
2545                 if ( submenu.attr( "aria-hidden" ) !== "true" ) {
2546                         return;
2547                 }
2548
2549                 this.timer = this._delay(function() {
2550                         this._close();
2551                         this._open( submenu );
2552                 }, this.delay );
2553         },
2554
2555         _open: function( submenu ) {
2556                 var position = $.extend({
2557                         of: this.active
2558                 }, this.options.position );
2559
2560                 clearTimeout( this.timer );
2561                 this.element.find( ".ui-menu" ).not( submenu.parents( ".ui-menu" ) )
2562                         .hide()
2563                         .attr( "aria-hidden", "true" );
2564
2565                 submenu
2566                         .show()
2567                         .removeAttr( "aria-hidden" )
2568                         .attr( "aria-expanded", "true" )
2569                         .position( position );
2570         },
2571
2572         collapseAll: function( event, all ) {
2573                 clearTimeout( this.timer );
2574                 this.timer = this._delay(function() {
2575                         // If we were passed an event, look for the submenu that contains the event
2576                         var currentMenu = all ? this.element :
2577                                 $( event && event.target ).closest( this.element.find( ".ui-menu" ) );
2578
2579                         // If we found no valid submenu ancestor, use the main menu to close all sub menus anyway
2580                         if ( !currentMenu.length ) {
2581                                 currentMenu = this.element;
2582                         }
2583
2584                         this._close( currentMenu );
2585
2586                         this.blur( event );
2587                         this.activeMenu = currentMenu;
2588                 }, this.delay );
2589         },
2590
2591         // With no arguments, closes the currently active menu - if nothing is active
2592         // it closes all menus.  If passed an argument, it will search for menus BELOW
2593         _close: function( startMenu ) {
2594                 if ( !startMenu ) {
2595                         startMenu = this.active ? this.active.parent() : this.element;
2596                 }
2597
2598                 startMenu
2599                         .find( ".ui-menu" )
2600                                 .hide()
2601                                 .attr( "aria-hidden", "true" )
2602                                 .attr( "aria-expanded", "false" )
2603                         .end()
2604                         .find( ".ui-state-active" ).not( ".ui-state-focus" )
2605                                 .removeClass( "ui-state-active" );
2606         },
2607
2608         _closeOnDocumentClick: function( event ) {
2609                 return !$( event.target ).closest( ".ui-menu" ).length;
2610         },
2611
2612         _isDivider: function( item ) {
2613
2614                 // Match hyphen, em dash, en dash
2615                 return !/[^\-\u2014\u2013\s]/.test( item.text() );
2616         },
2617
2618         collapse: function( event ) {
2619                 var newItem = this.active &&
2620                         this.active.parent().closest( ".ui-menu-item", this.element );
2621                 if ( newItem && newItem.length ) {
2622                         this._close();
2623                         this.focus( event, newItem );
2624                 }
2625         },
2626
2627         expand: function( event ) {
2628                 var newItem = this.active &&
2629                         this.active
2630                                 .children( ".ui-menu " )
2631                                 .find( this.options.items )
2632                                 .first();
2633
2634                 if ( newItem && newItem.length ) {
2635                         this._open( newItem.parent() );
2636
2637                         // Delay so Firefox will not hide activedescendant change in expanding submenu from AT
2638                         this._delay(function() {
2639                                 this.focus( event, newItem );
2640                         });
2641                 }
2642         },
2643
2644         next: function( event ) {
2645                 this._move( "next", "first", event );
2646         },
2647
2648         previous: function( event ) {
2649                 this._move( "prev", "last", event );
2650         },
2651
2652         isFirstItem: function() {
2653                 return this.active && !this.active.prevAll( ".ui-menu-item" ).length;
2654         },
2655
2656         isLastItem: function() {
2657                 return this.active && !this.active.nextAll( ".ui-menu-item" ).length;
2658         },
2659
2660         _move: function( direction, filter, event ) {
2661                 var next;
2662                 if ( this.active ) {
2663                         if ( direction === "first" || direction === "last" ) {
2664                                 next = this.active
2665                                         [ direction === "first" ? "prevAll" : "nextAll" ]( ".ui-menu-item" )
2666                                         .eq( -1 );
2667                         } else {
2668                                 next = this.active
2669                                         [ direction + "All" ]( ".ui-menu-item" )
2670                                         .eq( 0 );
2671                         }
2672                 }
2673                 if ( !next || !next.length || !this.active ) {
2674                         next = this.activeMenu.find( this.options.items )[ filter ]();
2675                 }
2676
2677                 this.focus( event, next );
2678         },
2679
2680         nextPage: function( event ) {
2681                 var item, base, height;
2682
2683                 if ( !this.active ) {
2684                         this.next( event );
2685                         return;
2686                 }
2687                 if ( this.isLastItem() ) {
2688                         return;
2689                 }
2690                 if ( this._hasScroll() ) {
2691                         base = this.active.offset().top;
2692                         height = this.element.height();
2693                         this.active.nextAll( ".ui-menu-item" ).each(function() {
2694                                 item = $( this );
2695                                 return item.offset().top - base - height < 0;
2696                         });
2697
2698                         this.focus( event, item );
2699                 } else {
2700                         this.focus( event, this.activeMenu.find( this.options.items )
2701                                 [ !this.active ? "first" : "last" ]() );
2702                 }
2703         },
2704
2705         previousPage: function( event ) {
2706                 var item, base, height;
2707                 if ( !this.active ) {
2708                         this.next( event );
2709                         return;
2710                 }
2711                 if ( this.isFirstItem() ) {
2712                         return;
2713                 }
2714                 if ( this._hasScroll() ) {
2715                         base = this.active.offset().top;
2716                         height = this.element.height();
2717                         this.active.prevAll( ".ui-menu-item" ).each(function() {
2718                                 item = $( this );
2719                                 return item.offset().top - base + height > 0;
2720                         });
2721
2722                         this.focus( event, item );
2723                 } else {
2724                         this.focus( event, this.activeMenu.find( this.options.items ).first() );
2725                 }
2726         },
2727
2728         _hasScroll: function() {
2729                 return this.element.outerHeight() < this.element.prop( "scrollHeight" );
2730         },
2731
2732         select: function( event ) {
2733                 // TODO: It should never be possible to not have an active item at this
2734                 // point, but the tests don't trigger mouseenter before click.
2735                 this.active = this.active || $( event.target ).closest( ".ui-menu-item" );
2736                 var ui = { item: this.active };
2737                 if ( !this.active.has( ".ui-menu" ).length ) {
2738                         this.collapseAll( event, true );
2739                 }
2740                 this._trigger( "select", event, ui );
2741         },
2742
2743         _filterMenuItems: function(character) {
2744                 var escapedCharacter = character.replace( /[\-\[\]{}()*+?.,\\\^$|#\s]/g, "\\$&" ),
2745                         regex = new RegExp( "^" + escapedCharacter, "i" );
2746
2747                 return this.activeMenu
2748                         .find( this.options.items )
2749
2750                         // Only match on items, not dividers or other content (#10571)
2751                         .filter( ".ui-menu-item" )
2752                         .filter(function() {
2753                                 return regex.test( $.trim( $( this ).text() ) );
2754                         });
2755         }
2756 });
2757
2758
2759 /*!
2760  * jQuery UI Autocomplete 1.11.4
2761  * http://jqueryui.com
2762  *
2763  * Copyright jQuery Foundation and other contributors
2764  * Released under the MIT license.
2765  * http://jquery.org/license
2766  *
2767  * http://api.jqueryui.com/autocomplete/
2768  */
2769
2770
2771 $.widget( "ui.autocomplete", {
2772         version: "1.11.4",
2773         defaultElement: "<input>",
2774         options: {
2775                 appendTo: null,
2776                 autoFocus: false,
2777                 delay: 300,
2778                 minLength: 1,
2779                 position: {
2780                         my: "left top",
2781                         at: "left bottom",
2782                         collision: "none"
2783                 },
2784                 source: null,
2785
2786                 // callbacks
2787                 change: null,
2788                 close: null,
2789                 focus: null,
2790                 open: null,
2791                 response: null,
2792                 search: null,
2793                 select: null
2794         },
2795
2796         requestIndex: 0,
2797         pending: 0,
2798
2799         _create: function() {
2800                 // Some browsers only repeat keydown events, not keypress events,
2801                 // so we use the suppressKeyPress flag to determine if we've already
2802                 // handled the keydown event. #7269
2803                 // Unfortunately the code for & in keypress is the same as the up arrow,
2804                 // so we use the suppressKeyPressRepeat flag to avoid handling keypress
2805                 // events when we know the keydown event was used to modify the
2806                 // search term. #7799
2807                 var suppressKeyPress, suppressKeyPressRepeat, suppressInput,
2808                         nodeName = this.element[ 0 ].nodeName.toLowerCase(),
2809                         isTextarea = nodeName === "textarea",
2810                         isInput = nodeName === "input";
2811
2812                 this.isMultiLine =
2813                         // Textareas are always multi-line
2814                         isTextarea ? true :
2815                         // Inputs are always single-line, even if inside a contentEditable element
2816                         // IE also treats inputs as contentEditable
2817                         isInput ? false :
2818                         // All other element types are determined by whether or not they're contentEditable
2819                         this.element.prop( "isContentEditable" );
2820
2821                 this.valueMethod = this.element[ isTextarea || isInput ? "val" : "text" ];
2822                 this.isNewMenu = true;
2823
2824                 this.element
2825                         .addClass( "ui-autocomplete-input" )
2826                         .attr( "autocomplete", "off" );
2827
2828                 this._on( this.element, {
2829                         keydown: function( event ) {
2830                                 if ( this.element.prop( "readOnly" ) ) {
2831                                         suppressKeyPress = true;
2832                                         suppressInput = true;
2833                                         suppressKeyPressRepeat = true;
2834                                         return;
2835                                 }
2836
2837                                 suppressKeyPress = false;
2838                                 suppressInput = false;
2839                                 suppressKeyPressRepeat = false;
2840                                 var keyCode = $.ui.keyCode;
2841                                 switch ( event.keyCode ) {
2842                                 case keyCode.PAGE_UP:
2843                                         suppressKeyPress = true;
2844                                         this._move( "previousPage", event );
2845                                         break;
2846                                 case keyCode.PAGE_DOWN:
2847                                         suppressKeyPress = true;
2848                                         this._move( "nextPage", event );
2849                                         break;
2850                                 case keyCode.UP:
2851                                         suppressKeyPress = true;
2852                                         this._keyEvent( "previous", event );
2853                                         break;
2854                                 case keyCode.DOWN:
2855                                         suppressKeyPress = true;
2856                                         this._keyEvent( "next", event );
2857                                         break;
2858                                 case keyCode.ENTER:
2859                                         // when menu is open and has focus
2860                                         if ( this.menu.active ) {
2861                                                 // #6055 - Opera still allows the keypress to occur
2862                                                 // which causes forms to submit
2863                                                 suppressKeyPress = true;
2864                                                 event.preventDefault();
2865                                                 this.menu.select( event );
2866                                         }
2867                                         break;
2868                                 case keyCode.TAB:
2869                                         if ( this.menu.active ) {
2870                                                 this.menu.select( event );
2871                                         }
2872                                         break;
2873                                 case keyCode.ESCAPE:
2874                                         if ( this.menu.element.is( ":visible" ) ) {
2875                                                 if ( !this.isMultiLine ) {
2876                                                         this._value( this.term );
2877                                                 }
2878                                                 this.close( event );
2879                                                 // Different browsers have different default behavior for escape
2880                                                 // Single press can mean undo or clear
2881                                                 // Double press in IE means clear the whole form
2882                                                 event.preventDefault();
2883                                         }
2884                                         break;
2885                                 default:
2886                                         suppressKeyPressRepeat = true;
2887                                         // search timeout should be triggered before the input value is changed
2888                                         this._searchTimeout( event );
2889                                         break;
2890                                 }
2891                         },
2892                         keypress: function( event ) {
2893                                 if ( suppressKeyPress ) {
2894                                         suppressKeyPress = false;
2895                                         if ( !this.isMultiLine || this.menu.element.is( ":visible" ) ) {
2896                                                 event.preventDefault();
2897                                         }
2898                                         return;
2899                                 }
2900                                 if ( suppressKeyPressRepeat ) {
2901                                         return;
2902                                 }
2903
2904                                 // replicate some key handlers to allow them to repeat in Firefox and Opera
2905                                 var keyCode = $.ui.keyCode;
2906                                 switch ( event.keyCode ) {
2907                                 case keyCode.PAGE_UP:
2908                                         this._move( "previousPage", event );
2909                                         break;
2910                                 case keyCode.PAGE_DOWN:
2911                                         this._move( "nextPage", event );
2912                                         break;
2913                                 case keyCode.UP:
2914                                         this._keyEvent( "previous", event );
2915                                         break;
2916                                 case keyCode.DOWN:
2917                                         this._keyEvent( "next", event );
2918                                         break;
2919                                 }
2920                         },
2921                         input: function( event ) {
2922                                 if ( suppressInput ) {
2923                                         suppressInput = false;
2924                                         event.preventDefault();
2925                                         return;
2926                                 }
2927                                 this._searchTimeout( event );
2928                         },
2929                         focus: function() {
2930                                 this.selectedItem = null;
2931                                 this.previous = this._value();
2932                         },
2933                         blur: function( event ) {
2934                                 if ( this.cancelBlur ) {
2935                                         delete this.cancelBlur;
2936                                         return;
2937                                 }
2938
2939                                 clearTimeout( this.searching );
2940                                 this.close( event );
2941                                 this._change( event );
2942                         }
2943                 });
2944
2945                 this._initSource();
2946                 this.menu = $( "<ul>" )
2947                         .addClass( "ui-autocomplete ui-front" )
2948                         .appendTo( this._appendTo() )
2949                         .menu({
2950                                 // disable ARIA support, the live region takes care of that
2951                                 role: null
2952                         })
2953                         .hide()
2954                         .menu( "instance" );
2955
2956                 this._on( this.menu.element, {
2957                         mousedown: function( event ) {
2958                                 // prevent moving focus out of the text field
2959                                 event.preventDefault();
2960
2961                                 // IE doesn't prevent moving focus even with event.preventDefault()
2962                                 // so we set a flag to know when we should ignore the blur event
2963                                 this.cancelBlur = true;
2964                                 this._delay(function() {
2965                                         delete this.cancelBlur;
2966                                 });
2967
2968                                 // clicking on the scrollbar causes focus to shift to the body
2969                                 // but we can't detect a mouseup or a click immediately afterward
2970                                 // so we have to track the next mousedown and close the menu if
2971                                 // the user clicks somewhere outside of the autocomplete
2972                                 var menuElement = this.menu.element[ 0 ];
2973                                 if ( !$( event.target ).closest( ".ui-menu-item" ).length ) {
2974                                         this._delay(function() {
2975                                                 var that = this;
2976                                                 this.document.one( "mousedown", function( event ) {
2977                                                         if ( event.target !== that.element[ 0 ] &&
2978                                                                         event.target !== menuElement &&
2979                                                                         !$.contains( menuElement, event.target ) ) {
2980                                                                 that.close();
2981                                                         }
2982                                                 });
2983                                         });
2984                                 }
2985                         },
2986                         menufocus: function( event, ui ) {
2987                                 var label, item;
2988                                 // support: Firefox
2989                                 // Prevent accidental activation of menu items in Firefox (#7024 #9118)
2990                                 if ( this.isNewMenu ) {
2991                                         this.isNewMenu = false;
2992                                         if ( event.originalEvent && /^mouse/.test( event.originalEvent.type ) ) {
2993                                                 this.menu.blur();
2994
2995                                                 this.document.one( "mousemove", function() {
2996                                                         $( event.target ).trigger( event.originalEvent );
2997                                                 });
2998
2999                                                 return;
3000                                         }
3001                                 }
3002
3003                                 item = ui.item.data( "ui-autocomplete-item" );
3004                                 if ( false !== this._trigger( "focus", event, { item: item } ) ) {
3005                                         // use value to match what will end up in the input, if it was a key event
3006                                         if ( event.originalEvent && /^key/.test( event.originalEvent.type ) ) {
3007                                                 this._value( item.value );
3008                                         }
3009                                 }
3010
3011                                 // Announce the value in the liveRegion
3012                                 label = ui.item.attr( "aria-label" ) || item.value;
3013                                 if ( label && $.trim( label ).length ) {
3014                                         this.liveRegion.children().hide();
3015                                         $( "<div>" ).text( label ).appendTo( this.liveRegion );
3016                                 }
3017                         },
3018                         menuselect: function( event, ui ) {
3019                                 var item = ui.item.data( "ui-autocomplete-item" ),
3020                                         previous = this.previous;
3021
3022                                 // only trigger when focus was lost (click on menu)
3023                                 if ( this.element[ 0 ] !== this.document[ 0 ].activeElement ) {
3024                                         this.element.focus();
3025                                         this.previous = previous;
3026                                         // #6109 - IE triggers two focus events and the second
3027                                         // is asynchronous, so we need to reset the previous
3028                                         // term synchronously and asynchronously :-(
3029                                         this._delay(function() {
3030                                                 this.previous = previous;
3031                                                 this.selectedItem = item;
3032                                         });
3033                                 }
3034
3035                                 if ( false !== this._trigger( "select", event, { item: item } ) ) {
3036                                         this._value( item.value );
3037                                 }
3038                                 // reset the term after the select event
3039                                 // this allows custom select handling to work properly
3040                                 this.term = this._value();
3041
3042                                 this.close( event );
3043                                 this.selectedItem = item;
3044                         }
3045                 });
3046
3047                 this.liveRegion = $( "<span>", {
3048                                 role: "status",
3049                                 "aria-live": "assertive",
3050                                 "aria-relevant": "additions"
3051                         })
3052                         .addClass( "ui-helper-hidden-accessible" )
3053                         .appendTo( this.document[ 0 ].body );
3054
3055                 // turning off autocomplete prevents the browser from remembering the
3056                 // value when navigating through history, so we re-enable autocomplete
3057                 // if the page is unloaded before the widget is destroyed. #7790
3058                 this._on( this.window, {
3059                         beforeunload: function() {
3060                                 this.element.removeAttr( "autocomplete" );
3061                         }
3062                 });
3063         },
3064
3065         _destroy: function() {
3066                 clearTimeout( this.searching );
3067                 this.element
3068                         .removeClass( "ui-autocomplete-input" )
3069                         .removeAttr( "autocomplete" );
3070                 this.menu.element.remove();
3071                 this.liveRegion.remove();
3072         },
3073
3074         _setOption: function( key, value ) {
3075                 this._super( key, value );
3076                 if ( key === "source" ) {
3077                         this._initSource();
3078                 }
3079                 if ( key === "appendTo" ) {
3080                         this.menu.element.appendTo( this._appendTo() );
3081                 }
3082                 if ( key === "disabled" && value && this.xhr ) {
3083                         this.xhr.abort();
3084                 }
3085         },
3086
3087         _appendTo: function() {
3088                 var element = this.options.appendTo;
3089
3090                 if ( element ) {
3091                         element = element.jquery || element.nodeType ?
3092                                 $( element ) :
3093                                 this.document.find( element ).eq( 0 );
3094                 }
3095
3096                 if ( !element || !element[ 0 ] ) {
3097                         element = this.element.closest( ".ui-front" );
3098                 }
3099
3100                 if ( !element.length ) {
3101                         element = this.document[ 0 ].body;
3102                 }
3103
3104                 return element;
3105         },
3106
3107         _initSource: function() {
3108                 var array, url,
3109                         that = this;
3110                 if ( $.isArray( this.options.source ) ) {
3111                         array = this.options.source;
3112                         this.source = function( request, response ) {
3113                                 response( $.ui.autocomplete.filter( array, request.term ) );
3114                         };
3115                 } else if ( typeof this.options.source === "string" ) {
3116                         url = this.options.source;
3117                         this.source = function( request, response ) {
3118                                 if ( that.xhr ) {
3119                                         that.xhr.abort();
3120                                 }
3121                                 that.xhr = $.ajax({
3122                                         url: url,
3123                                         data: request,
3124                                         dataType: "json",
3125                                         success: function( data ) {
3126                                                 response( data );
3127                                         },
3128                                         error: function() {
3129                                                 response([]);
3130                                         }
3131                                 });
3132                         };
3133                 } else {
3134                         this.source = this.options.source;
3135                 }
3136         },
3137
3138         _searchTimeout: function( event ) {
3139                 clearTimeout( this.searching );
3140                 this.searching = this._delay(function() {
3141
3142                         // Search if the value has changed, or if the user retypes the same value (see #7434)
3143                         var equalValues = this.term === this._value(),
3144                                 menuVisible = this.menu.element.is( ":visible" ),
3145                                 modifierKey = event.altKey || event.ctrlKey || event.metaKey || event.shiftKey;
3146
3147                         if ( !equalValues || ( equalValues && !menuVisible && !modifierKey ) ) {
3148                                 this.selectedItem = null;
3149                                 this.search( null, event );
3150                         }
3151                 }, this.options.delay );
3152         },
3153
3154         search: function( value, event ) {
3155                 value = value != null ? value : this._value();
3156
3157                 // always save the actual value, not the one passed as an argument
3158                 this.term = this._value();
3159
3160                 if ( value.length < this.options.minLength ) {
3161                         return this.close( event );
3162                 }
3163
3164                 if ( this._trigger( "search", event ) === false ) {
3165                         return;
3166                 }
3167
3168                 return this._search( value );
3169         },
3170
3171         _search: function( value ) {
3172                 this.pending++;
3173                 this.element.addClass( "ui-autocomplete-loading" );
3174                 this.cancelSearch = false;
3175
3176                 this.source( { term: value }, this._response() );
3177         },
3178
3179         _response: function() {
3180                 var index = ++this.requestIndex;
3181
3182                 return $.proxy(function( content ) {
3183                         if ( index === this.requestIndex ) {
3184                                 this.__response( content );
3185                         }
3186
3187                         this.pending--;
3188                         if ( !this.pending ) {
3189                                 this.element.removeClass( "ui-autocomplete-loading" );
3190                         }
3191                 }, this );
3192         },
3193
3194         __response: function( content ) {
3195                 if ( content ) {
3196                         content = this._normalize( content );
3197                 }
3198                 this._trigger( "response", null, { content: content } );
3199                 if ( !this.options.disabled && content && content.length && !this.cancelSearch ) {
3200                         this._suggest( content );
3201                         this._trigger( "open" );
3202                 } else {
3203                         // use ._close() instead of .close() so we don't cancel future searches
3204                         this._close();
3205                 }
3206         },
3207
3208         close: function( event ) {
3209                 this.cancelSearch = true;
3210                 this._close( event );
3211         },
3212
3213         _close: function( event ) {
3214                 if ( this.menu.element.is( ":visible" ) ) {
3215                         this.menu.element.hide();
3216                         this.menu.blur();
3217                         this.isNewMenu = true;
3218                         this._trigger( "close", event );
3219                 }
3220         },
3221
3222         _change: function( event ) {
3223                 if ( this.previous !== this._value() ) {
3224                         this._trigger( "change", event, { item: this.selectedItem } );
3225                 }
3226         },
3227
3228         _normalize: function( items ) {
3229                 // assume all items have the right format when the first item is complete
3230                 if ( items.length && items[ 0 ].label && items[ 0 ].value ) {
3231                         return items;
3232                 }
3233                 return $.map( items, function( item ) {
3234                         if ( typeof item === "string" ) {
3235                                 return {
3236                                         label: item,
3237                                         value: item
3238                                 };
3239                         }
3240                         return $.extend( {}, item, {
3241                                 label: item.label || item.value,
3242                                 value: item.value || item.label
3243                         });
3244                 });
3245         },
3246
3247         _suggest: function( items ) {
3248                 var ul = this.menu.element.empty();
3249                 this._renderMenu( ul, items );
3250                 this.isNewMenu = true;
3251                 this.menu.refresh();
3252
3253                 // size and position menu
3254                 ul.show();
3255                 this._resizeMenu();
3256                 ul.position( $.extend({
3257                         of: this.element
3258                 }, this.options.position ) );
3259
3260                 if ( this.options.autoFocus ) {
3261                         this.menu.next();
3262                 }
3263         },
3264
3265         _resizeMenu: function() {
3266                 var ul = this.menu.element;
3267                 ul.outerWidth( Math.max(
3268                         // Firefox wraps long text (possibly a rounding bug)
3269                         // so we add 1px to avoid the wrapping (#7513)
3270                         ul.width( "" ).outerWidth() + 1,
3271                         this.element.outerWidth()
3272                 ) );
3273         },
3274
3275         _renderMenu: function( ul, items ) {
3276                 var that = this;
3277                 $.each( items, function( index, item ) {
3278                         that._renderItemData( ul, item );
3279                 });
3280         },
3281
3282         _renderItemData: function( ul, item ) {
3283                 return this._renderItem( ul, item ).data( "ui-autocomplete-item", item );
3284         },
3285
3286         _renderItem: function( ul, item ) {
3287                 return $( "<li>" ).text( item.label ).appendTo( ul );
3288         },
3289
3290         _move: function( direction, event ) {
3291                 if ( !this.menu.element.is( ":visible" ) ) {
3292                         this.search( null, event );
3293                         return;
3294                 }
3295                 if ( this.menu.isFirstItem() && /^previous/.test( direction ) ||
3296                                 this.menu.isLastItem() && /^next/.test( direction ) ) {
3297
3298                         if ( !this.isMultiLine ) {
3299                                 this._value( this.term );
3300                         }
3301
3302                         this.menu.blur();
3303                         return;
3304                 }
3305                 this.menu[ direction ]( event );
3306         },
3307
3308         widget: function() {
3309                 return this.menu.element;
3310         },
3311
3312         _value: function() {
3313                 return this.valueMethod.apply( this.element, arguments );
3314         },
3315
3316         _keyEvent: function( keyEvent, event ) {
3317                 if ( !this.isMultiLine || this.menu.element.is( ":visible" ) ) {
3318                         this._move( keyEvent, event );
3319
3320                         // prevents moving cursor to beginning/end of the text field in some browsers
3321                         event.preventDefault();
3322                 }
3323         }
3324 });
3325
3326 $.extend( $.ui.autocomplete, {
3327         escapeRegex: function( value ) {
3328                 return value.replace( /[\-\[\]{}()*+?.,\\\^$|#\s]/g, "\\$&" );
3329         },
3330         filter: function( array, term ) {
3331                 var matcher = new RegExp( $.ui.autocomplete.escapeRegex( term ), "i" );
3332                 return $.grep( array, function( value ) {
3333                         return matcher.test( value.label || value.value || value );
3334                 });
3335         }
3336 });
3337
3338 // live region extension, adding a `messages` option
3339 // NOTE: This is an experimental API. We are still investigating
3340 // a full solution for string manipulation and internationalization.
3341 $.widget( "ui.autocomplete", $.ui.autocomplete, {
3342         options: {
3343                 messages: {
3344                         noResults: "No search results.",
3345                         results: function( amount ) {
3346                                 return amount + ( amount > 1 ? " results are" : " result is" ) +
3347                                         " available, use up and down arrow keys to navigate.";
3348                         }
3349                 }
3350         },
3351
3352         __response: function( content ) {
3353                 var message;
3354                 this._superApply( arguments );
3355                 if ( this.options.disabled || this.cancelSearch ) {
3356                         return;
3357                 }
3358                 if ( content && content.length ) {
3359                         message = this.options.messages.results( content.length );
3360                 } else {
3361                         message = this.options.messages.noResults;
3362                 }
3363                 this.liveRegion.children().hide();
3364                 $( "<div>" ).text( message ).appendTo( this.liveRegion );
3365         }
3366 });
3367
3368 var autocomplete = $.ui.autocomplete;
3369
3370
3371 /*!
3372  * jQuery UI Button 1.11.4
3373  * http://jqueryui.com
3374  *
3375  * Copyright jQuery Foundation and other contributors
3376  * Released under the MIT license.
3377  * http://jquery.org/license
3378  *
3379  * http://api.jqueryui.com/button/
3380  */
3381
3382
3383 var lastActive,
3384         baseClasses = "ui-button ui-widget ui-state-default ui-corner-all",
3385         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",
3386         formResetHandler = function() {
3387                 var form = $( this );
3388                 setTimeout(function() {
3389                         form.find( ":ui-button" ).button( "refresh" );
3390                 }, 1 );
3391         },
3392         radioGroup = function( radio ) {
3393                 var name = radio.name,
3394                         form = radio.form,
3395                         radios = $( [] );
3396                 if ( name ) {
3397                         name = name.replace( /'/g, "\\'" );
3398                         if ( form ) {
3399                                 radios = $( form ).find( "[name='" + name + "'][type=radio]" );
3400                         } else {
3401                                 radios = $( "[name='" + name + "'][type=radio]", radio.ownerDocument )
3402                                         .filter(function() {
3403                                                 return !this.form;
3404                                         });
3405                         }
3406                 }
3407                 return radios;
3408         };
3409
3410 $.widget( "ui.button", {
3411         version: "1.11.4",
3412         defaultElement: "<button>",
3413         options: {
3414                 disabled: null,
3415                 text: true,
3416                 label: null,
3417                 icons: {
3418                         primary: null,
3419                         secondary: null
3420                 }
3421         },
3422         _create: function() {
3423                 this.element.closest( "form" )
3424                         .unbind( "reset" + this.eventNamespace )
3425                         .bind( "reset" + this.eventNamespace, formResetHandler );
3426
3427                 if ( typeof this.options.disabled !== "boolean" ) {
3428                         this.options.disabled = !!this.element.prop( "disabled" );
3429                 } else {
3430                         this.element.prop( "disabled", this.options.disabled );
3431                 }
3432
3433                 this._determineButtonType();
3434                 this.hasTitle = !!this.buttonElement.attr( "title" );
3435
3436                 var that = this,
3437                         options = this.options,
3438                         toggleButton = this.type === "checkbox" || this.type === "radio",
3439                         activeClass = !toggleButton ? "ui-state-active" : "";
3440
3441                 if ( options.label === null ) {
3442                         options.label = (this.type === "input" ? this.buttonElement.val() : this.buttonElement.html());
3443                 }
3444
3445                 this._hoverable( this.buttonElement );
3446
3447                 this.buttonElement
3448                         .addClass( baseClasses )
3449                         .attr( "role", "button" )
3450                         .bind( "mouseenter" + this.eventNamespace, function() {
3451                                 if ( options.disabled ) {
3452                                         return;
3453                                 }
3454                                 if ( this === lastActive ) {
3455                                         $( this ).addClass( "ui-state-active" );
3456                                 }
3457                         })
3458                         .bind( "mouseleave" + this.eventNamespace, function() {
3459                                 if ( options.disabled ) {
3460                                         return;
3461                                 }
3462                                 $( this ).removeClass( activeClass );
3463                         })
3464                         .bind( "click" + this.eventNamespace, function( event ) {
3465                                 if ( options.disabled ) {
3466                                         event.preventDefault();
3467                                         event.stopImmediatePropagation();
3468                                 }
3469                         });
3470
3471                 // Can't use _focusable() because the element that receives focus
3472                 // and the element that gets the ui-state-focus class are different
3473                 this._on({
3474                         focus: function() {
3475                                 this.buttonElement.addClass( "ui-state-focus" );
3476                         },
3477                         blur: function() {
3478                                 this.buttonElement.removeClass( "ui-state-focus" );
3479                         }
3480                 });
3481
3482                 if ( toggleButton ) {
3483                         this.element.bind( "change" + this.eventNamespace, function() {
3484                                 that.refresh();
3485                         });
3486                 }
3487
3488                 if ( this.type === "checkbox" ) {
3489                         this.buttonElement.bind( "click" + this.eventNamespace, function() {
3490                                 if ( options.disabled ) {
3491                                         return false;
3492                                 }
3493                         });
3494                 } else if ( this.type === "radio" ) {
3495                         this.buttonElement.bind( "click" + this.eventNamespace, function() {
3496                                 if ( options.disabled ) {
3497                                         return false;
3498                                 }
3499                                 $( this ).addClass( "ui-state-active" );
3500                                 that.buttonElement.attr( "aria-pressed", "true" );
3501
3502                                 var radio = that.element[ 0 ];
3503                                 radioGroup( radio )
3504                                         .not( radio )
3505                                         .map(function() {
3506                                                 return $( this ).button( "widget" )[ 0 ];
3507                                         })
3508                                         .removeClass( "ui-state-active" )
3509                                         .attr( "aria-pressed", "false" );
3510                         });
3511                 } else {
3512                         this.buttonElement
3513                                 .bind( "mousedown" + this.eventNamespace, function() {
3514                                         if ( options.disabled ) {
3515                                                 return false;
3516                                         }
3517                                         $( this ).addClass( "ui-state-active" );
3518                                         lastActive = this;
3519                                         that.document.one( "mouseup", function() {
3520                                                 lastActive = null;
3521                                         });
3522                                 })
3523                                 .bind( "mouseup" + this.eventNamespace, function() {
3524                                         if ( options.disabled ) {
3525                                                 return false;
3526                                         }
3527                                         $( this ).removeClass( "ui-state-active" );
3528                                 })
3529                                 .bind( "keydown" + this.eventNamespace, function(event) {
3530                                         if ( options.disabled ) {
3531                                                 return false;
3532                                         }
3533                                         if ( event.keyCode === $.ui.keyCode.SPACE || event.keyCode === $.ui.keyCode.ENTER ) {
3534                                                 $( this ).addClass( "ui-state-active" );
3535                                         }
3536                                 })
3537                                 // see #8559, we bind to blur here in case the button element loses
3538                                 // focus between keydown and keyup, it would be left in an "active" state
3539                                 .bind( "keyup" + this.eventNamespace + " blur" + this.eventNamespace, function() {
3540                                         $( this ).removeClass( "ui-state-active" );
3541                                 });
3542
3543                         if ( this.buttonElement.is("a") ) {
3544                                 this.buttonElement.keyup(function(event) {
3545                                         if ( event.keyCode === $.ui.keyCode.SPACE ) {
3546                                                 // TODO pass through original event correctly (just as 2nd argument doesn't work)
3547                                                 $( this ).click();
3548                                         }
3549                                 });
3550                         }
3551                 }
3552
3553                 this._setOption( "disabled", options.disabled );
3554                 this._resetButton();
3555         },
3556
3557         _determineButtonType: function() {
3558                 var ancestor, labelSelector, checked;
3559
3560                 if ( this.element.is("[type=checkbox]") ) {
3561                         this.type = "checkbox";
3562                 } else if ( this.element.is("[type=radio]") ) {
3563                         this.type = "radio";
3564                 } else if ( this.element.is("input") ) {
3565                         this.type = "input";
3566                 } else {
3567                         this.type = "button";
3568                 }
3569
3570                 if ( this.type === "checkbox" || this.type === "radio" ) {
3571                         // we don't search against the document in case the element
3572                         // is disconnected from the DOM
3573                         ancestor = this.element.parents().last();
3574                         labelSelector = "label[for='" + this.element.attr("id") + "']";
3575                         this.buttonElement = ancestor.find( labelSelector );
3576                         if ( !this.buttonElement.length ) {
3577                                 ancestor = ancestor.length ? ancestor.siblings() : this.element.siblings();
3578                                 this.buttonElement = ancestor.filter( labelSelector );
3579                                 if ( !this.buttonElement.length ) {
3580                                         this.buttonElement = ancestor.find( labelSelector );
3581                                 }
3582                         }
3583                         this.element.addClass( "ui-helper-hidden-accessible" );
3584
3585                         checked = this.element.is( ":checked" );
3586                         if ( checked ) {
3587                                 this.buttonElement.addClass( "ui-state-active" );
3588                         }
3589                         this.buttonElement.prop( "aria-pressed", checked );
3590                 } else {
3591                         this.buttonElement = this.element;
3592                 }
3593         },
3594
3595         widget: function() {
3596                 return this.buttonElement;
3597         },
3598
3599         _destroy: function() {
3600                 this.element
3601                         .removeClass( "ui-helper-hidden-accessible" );
3602                 this.buttonElement
3603                         .removeClass( baseClasses + " ui-state-active " + typeClasses )
3604                         .removeAttr( "role" )
3605                         .removeAttr( "aria-pressed" )
3606                         .html( this.buttonElement.find(".ui-button-text").html() );
3607
3608                 if ( !this.hasTitle ) {
3609                         this.buttonElement.removeAttr( "title" );
3610                 }
3611         },
3612
3613         _setOption: function( key, value ) {
3614                 this._super( key, value );
3615                 if ( key === "disabled" ) {
3616                         this.widget().toggleClass( "ui-state-disabled", !!value );
3617                         this.element.prop( "disabled", !!value );
3618                         if ( value ) {
3619                                 if ( this.type === "checkbox" || this.type === "radio" ) {
3620                                         this.buttonElement.removeClass( "ui-state-focus" );
3621                                 } else {
3622                                         this.buttonElement.removeClass( "ui-state-focus ui-state-active" );
3623                                 }
3624                         }
3625                         return;
3626                 }
3627                 this._resetButton();
3628         },
3629
3630         refresh: function() {
3631                 //See #8237 & #8828
3632                 var isDisabled = this.element.is( "input, button" ) ? this.element.is( ":disabled" ) : this.element.hasClass( "ui-button-disabled" );
3633
3634                 if ( isDisabled !== this.options.disabled ) {
3635                         this._setOption( "disabled", isDisabled );
3636                 }
3637                 if ( this.type === "radio" ) {
3638                         radioGroup( this.element[0] ).each(function() {
3639                                 if ( $( this ).is( ":checked" ) ) {
3640                                         $( this ).button( "widget" )
3641                                                 .addClass( "ui-state-active" )
3642                                                 .attr( "aria-pressed", "true" );
3643                                 } else {
3644                                         $( this ).button( "widget" )
3645                                                 .removeClass( "ui-state-active" )
3646                                                 .attr( "aria-pressed", "false" );
3647                                 }
3648                         });
3649                 } else if ( this.type === "checkbox" ) {
3650                         if ( this.element.is( ":checked" ) ) {
3651                                 this.buttonElement
3652                                         .addClass( "ui-state-active" )
3653                                         .attr( "aria-pressed", "true" );
3654                         } else {
3655                                 this.buttonElement
3656                                         .removeClass( "ui-state-active" )
3657                                         .attr( "aria-pressed", "false" );
3658                         }
3659                 }
3660         },
3661
3662         _resetButton: function() {
3663                 if ( this.type === "input" ) {
3664                         if ( this.options.label ) {
3665                                 this.element.val( this.options.label );
3666                         }
3667                         return;
3668                 }
3669                 var buttonElement = this.buttonElement.removeClass( typeClasses ),
3670                         buttonText = $( "<span></span>", this.document[0] )
3671                                 .addClass( "ui-button-text" )
3672                                 .html( this.options.label )
3673                                 .appendTo( buttonElement.empty() )
3674                                 .text(),
3675                         icons = this.options.icons,
3676                         multipleIcons = icons.primary && icons.secondary,
3677                         buttonClasses = [];
3678
3679                 if ( icons.primary || icons.secondary ) {
3680                         if ( this.options.text ) {
3681                                 buttonClasses.push( "ui-button-text-icon" + ( multipleIcons ? "s" : ( icons.primary ? "-primary" : "-secondary" ) ) );
3682                         }
3683
3684                         if ( icons.primary ) {
3685                                 buttonElement.prepend( "<span class='ui-button-icon-primary ui-icon " + icons.primary + "'></span>" );
3686                         }
3687
3688                         if ( icons.secondary ) {
3689                                 buttonElement.append( "<span class='ui-button-icon-secondary ui-icon " + icons.secondary + "'></span>" );
3690                         }
3691
3692                         if ( !this.options.text ) {
3693                                 buttonClasses.push( multipleIcons ? "ui-button-icons-only" : "ui-button-icon-only" );
3694
3695                                 if ( !this.hasTitle ) {
3696                                         buttonElement.attr( "title", $.trim( buttonText ) );
3697                                 }
3698                         }
3699                 } else {
3700                         buttonClasses.push( "ui-button-text-only" );
3701                 }
3702                 buttonElement.addClass( buttonClasses.join( " " ) );
3703         }
3704 });
3705
3706 $.widget( "ui.buttonset", {
3707         version: "1.11.4",
3708         options: {
3709                 items: "button, input[type=button], input[type=submit], input[type=reset], input[type=checkbox], input[type=radio], a, :data(ui-button)"
3710         },
3711
3712         _create: function() {
3713                 this.element.addClass( "ui-buttonset" );
3714         },
3715
3716         _init: function() {
3717                 this.refresh();
3718         },
3719
3720         _setOption: function( key, value ) {
3721                 if ( key === "disabled" ) {
3722                         this.buttons.button( "option", key, value );
3723                 }
3724
3725                 this._super( key, value );
3726         },
3727
3728         refresh: function() {
3729                 var rtl = this.element.css( "direction" ) === "rtl",
3730                         allButtons = this.element.find( this.options.items ),
3731                         existingButtons = allButtons.filter( ":ui-button" );
3732
3733                 // Initialize new buttons
3734                 allButtons.not( ":ui-button" ).button();
3735
3736                 // Refresh existing buttons
3737                 existingButtons.button( "refresh" );
3738
3739                 this.buttons = allButtons
3740                         .map(function() {
3741                                 return $( this ).button( "widget" )[ 0 ];
3742                         })
3743                                 .removeClass( "ui-corner-all ui-corner-left ui-corner-right" )
3744                                 .filter( ":first" )
3745                                         .addClass( rtl ? "ui-corner-right" : "ui-corner-left" )
3746                                 .end()
3747                                 .filter( ":last" )
3748                                         .addClass( rtl ? "ui-corner-left" : "ui-corner-right" )
3749                                 .end()
3750                         .end();
3751         },
3752
3753         _destroy: function() {
3754                 this.element.removeClass( "ui-buttonset" );
3755                 this.buttons
3756                         .map(function() {
3757                                 return $( this ).button( "widget" )[ 0 ];
3758                         })
3759                                 .removeClass( "ui-corner-left ui-corner-right" )
3760                         .end()
3761                         .button( "destroy" );
3762         }
3763 });
3764
3765 var button = $.ui.button;
3766
3767
3768 /*!
3769  * jQuery UI Datepicker 1.11.4
3770  * http://jqueryui.com
3771  *
3772  * Copyright jQuery Foundation and other contributors
3773  * Released under the MIT license.
3774  * http://jquery.org/license
3775  *
3776  * http://api.jqueryui.com/datepicker/
3777  */
3778
3779
3780 $.extend($.ui, { datepicker: { version: "1.11.4" } });
3781
3782 var datepicker_instActive;
3783
3784 function datepicker_getZindex( elem ) {
3785         var position, value;
3786         while ( elem.length && elem[ 0 ] !== document ) {
3787                 // Ignore z-index if position is set to a value where z-index is ignored by the browser
3788                 // This makes behavior of this function consistent across browsers
3789                 // WebKit always returns auto if the element is positioned
3790                 position = elem.css( "position" );
3791                 if ( position === "absolute" || position === "relative" || position === "fixed" ) {
3792                         // IE returns 0 when zIndex is not specified
3793                         // other browsers return a string
3794                         // we ignore the case of nested elements with an explicit value of 0
3795                         // <div style="z-index: -10;"><div style="z-index: 0;"></div></div>
3796                         value = parseInt( elem.css( "zIndex" ), 10 );
3797                         if ( !isNaN( value ) && value !== 0 ) {
3798                                 return value;
3799                         }
3800                 }
3801                 elem = elem.parent();
3802         }
3803
3804         return 0;
3805 }
3806 /* Date picker manager.
3807    Use the singleton instance of this class, $.datepicker, to interact with the date picker.
3808    Settings for (groups of) date pickers are maintained in an instance object,
3809    allowing multiple different settings on the same page. */
3810
3811 function Datepicker() {
3812         this._curInst = null; // The current instance in use
3813         this._keyEvent = false; // If the last event was a key event
3814         this._disabledInputs = []; // List of date picker inputs that have been disabled
3815         this._datepickerShowing = false; // True if the popup picker is showing , false if not
3816         this._inDialog = false; // True if showing within a "dialog", false if not
3817         this._mainDivId = "ui-datepicker-div"; // The ID of the main datepicker division
3818         this._inlineClass = "ui-datepicker-inline"; // The name of the inline marker class
3819         this._appendClass = "ui-datepicker-append"; // The name of the append marker class
3820         this._triggerClass = "ui-datepicker-trigger"; // The name of the trigger marker class
3821         this._dialogClass = "ui-datepicker-dialog"; // The name of the dialog marker class
3822         this._disableClass = "ui-datepicker-disabled"; // The name of the disabled covering marker class
3823         this._unselectableClass = "ui-datepicker-unselectable"; // The name of the unselectable cell marker class
3824         this._currentClass = "ui-datepicker-current-day"; // The name of the current day marker class
3825         this._dayOverClass = "ui-datepicker-days-cell-over"; // The name of the day hover marker class
3826         this.regional = []; // Available regional settings, indexed by language code
3827         this.regional[""] = { // Default regional settings
3828                 closeText: "Done", // Display text for close link
3829                 prevText: "Prev", // Display text for previous month link
3830                 nextText: "Next", // Display text for next month link
3831                 currentText: "Today", // Display text for current month link
3832                 monthNames: ["January","February","March","April","May","June",
3833                         "July","August","September","October","November","December"], // Names of months for drop-down and formatting
3834                 monthNamesShort: ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"], // For formatting
3835                 dayNames: ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"], // For formatting
3836                 dayNamesShort: ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"], // For formatting
3837                 dayNamesMin: ["Su","Mo","Tu","We","Th","Fr","Sa"], // Column headings for days starting at Sunday
3838                 weekHeader: "Wk", // Column header for week of the year
3839                 dateFormat: "mm/dd/yy", // See format options on parseDate
3840                 firstDay: 0, // The first day of the week, Sun = 0, Mon = 1, ...
3841                 isRTL: false, // True if right-to-left language, false if left-to-right
3842                 showMonthAfterYear: false, // True if the year select precedes month, false for month then year
3843                 yearSuffix: "" // Additional text to append to the year in the month headers
3844         };
3845         this._defaults = { // Global defaults for all the date picker instances
3846                 showOn: "focus", // "focus" for popup on focus,
3847                         // "button" for trigger button, or "both" for either
3848                 showAnim: "fadeIn", // Name of jQuery animation for popup
3849                 showOptions: {}, // Options for enhanced animations
3850                 defaultDate: null, // Used when field is blank: actual date,
3851                         // +/-number for offset from today, null for today
3852                 appendText: "", // Display text following the input box, e.g. showing the format
3853                 buttonText: "...", // Text for trigger button
3854                 buttonImage: "", // URL for trigger button image
3855                 buttonImageOnly: false, // True if the image appears alone, false if it appears on a button
3856                 hideIfNoPrevNext: false, // True to hide next/previous month links
3857                         // if not applicable, false to just disable them
3858                 navigationAsDateFormat: false, // True if date formatting applied to prev/today/next links
3859                 gotoCurrent: false, // True if today link goes back to current selection instead
3860                 changeMonth: false, // True if month can be selected directly, false if only prev/next
3861                 changeYear: false, // True if year can be selected directly, false if only prev/next
3862                 yearRange: "c-10:c+10", // Range of years to display in drop-down,
3863                         // either relative to today's year (-nn:+nn), relative to currently displayed year
3864                         // (c-nn:c+nn), absolute (nnnn:nnnn), or a combination of the above (nnnn:-n)
3865                 showOtherMonths: false, // True to show dates in other months, false to leave blank
3866                 selectOtherMonths: false, // True to allow selection of dates in other months, false for unselectable
3867                 showWeek: false, // True to show week of the year, false to not show it
3868                 calculateWeek: this.iso8601Week, // How to calculate the week of the year,
3869                         // takes a Date and returns the number of the week for it
3870                 shortYearCutoff: "+10", // Short year values < this are in the current century,
3871                         // > this are in the previous century,
3872                         // string value starting with "+" for current year + value
3873                 minDate: null, // The earliest selectable date, or null for no limit
3874                 maxDate: null, // The latest selectable date, or null for no limit
3875                 duration: "fast", // Duration of display/closure
3876                 beforeShowDay: null, // Function that takes a date and returns an array with
3877                         // [0] = true if selectable, false if not, [1] = custom CSS class name(s) or "",
3878                         // [2] = cell title (optional), e.g. $.datepicker.noWeekends
3879                 beforeShow: null, // Function that takes an input field and
3880                         // returns a set of custom settings for the date picker
3881                 onSelect: null, // Define a callback function when a date is selected
3882                 onChangeMonthYear: null, // Define a callback function when the month or year is changed
3883                 onClose: null, // Define a callback function when the datepicker is closed
3884                 numberOfMonths: 1, // Number of months to show at a time
3885                 showCurrentAtPos: 0, // The position in multipe months at which to show the current month (starting at 0)
3886                 stepMonths: 1, // Number of months to step back/forward
3887                 stepBigMonths: 12, // Number of months to step back/forward for the big links
3888                 altField: "", // Selector for an alternate field to store selected dates into
3889                 altFormat: "", // The date format to use for the alternate field
3890                 constrainInput: true, // The input is constrained by the current date format
3891                 showButtonPanel: false, // True to show button panel, false to not show it
3892                 autoSize: false, // True to size the input for the date format, false to leave as is
3893                 disabled: false // The initial disabled state
3894         };
3895         $.extend(this._defaults, this.regional[""]);
3896         this.regional.en = $.extend( true, {}, this.regional[ "" ]);
3897         this.regional[ "en-US" ] = $.extend( true, {}, this.regional.en );
3898         this.dpDiv = datepicker_bindHover($("<div id='" + this._mainDivId + "' class='ui-datepicker ui-widget ui-widget-content ui-helper-clearfix ui-corner-all'></div>"));
3899 }
3900
3901 $.extend(Datepicker.prototype, {
3902         /* Class name added to elements to indicate already configured with a date picker. */
3903         markerClassName: "hasDatepicker",
3904
3905         //Keep track of the maximum number of rows displayed (see #7043)
3906         maxRows: 4,
3907
3908         // TODO rename to "widget" when switching to widget factory
3909         _widgetDatepicker: function() {
3910                 return this.dpDiv;
3911         },
3912
3913         /* Override the default settings for all instances of the date picker.
3914          * @param  settings  object - the new settings to use as defaults (anonymous object)
3915          * @return the manager object
3916          */
3917         setDefaults: function(settings) {
3918                 datepicker_extendRemove(this._defaults, settings || {});
3919                 return this;
3920         },
3921
3922         /* Attach the date picker to a jQuery selection.
3923          * @param  target       element - the target input field or division or span
3924          * @param  settings  object - the new settings to use for this date picker instance (anonymous)
3925          */
3926         _attachDatepicker: function(target, settings) {
3927                 var nodeName, inline, inst;
3928                 nodeName = target.nodeName.toLowerCase();
3929                 inline = (nodeName === "div" || nodeName === "span");
3930                 if (!target.id) {
3931                         this.uuid += 1;
3932                         target.id = "dp" + this.uuid;
3933                 }
3934                 inst = this._newInst($(target), inline);
3935                 inst.settings = $.extend({}, settings || {});
3936                 if (nodeName === "input") {
3937                         this._connectDatepicker(target, inst);
3938                 } else if (inline) {
3939                         this._inlineDatepicker(target, inst);
3940                 }
3941         },
3942
3943         /* Create a new instance object. */
3944         _newInst: function(target, inline) {
3945                 var id = target[0].id.replace(/([^A-Za-z0-9_\-])/g, "\\\\$1"); // escape jQuery meta chars
3946                 return {id: id, input: target, // associated target
3947                         selectedDay: 0, selectedMonth: 0, selectedYear: 0, // current selection
3948                         drawMonth: 0, drawYear: 0, // month being drawn
3949                         inline: inline, // is datepicker inline or not
3950                         dpDiv: (!inline ? this.dpDiv : // presentation div
3951                         datepicker_bindHover($("<div class='" + this._inlineClass + " ui-datepicker ui-widget ui-widget-content ui-helper-clearfix ui-corner-all'></div>")))};
3952         },
3953
3954         /* Attach the date picker to an input field. */
3955         _connectDatepicker: function(target, inst) {
3956                 var input = $(target);
3957                 inst.append = $([]);
3958                 inst.trigger = $([]);
3959                 if (input.hasClass(this.markerClassName)) {
3960                         return;
3961                 }
3962                 this._attachments(input, inst);
3963                 input.addClass(this.markerClassName).keydown(this._doKeyDown).
3964                         keypress(this._doKeyPress).keyup(this._doKeyUp);
3965                 this._autoSize(inst);
3966                 $.data(target, "datepicker", inst);
3967                 //If disabled option is true, disable the datepicker once it has been attached to the input (see ticket #5665)
3968                 if( inst.settings.disabled ) {
3969                         this._disableDatepicker( target );
3970                 }
3971         },
3972
3973         /* Make attachments based on settings. */
3974         _attachments: function(input, inst) {
3975                 var showOn, buttonText, buttonImage,
3976                         appendText = this._get(inst, "appendText"),
3977                         isRTL = this._get(inst, "isRTL");
3978
3979                 if (inst.append) {
3980                         inst.append.remove();
3981                 }
3982                 if (appendText) {
3983                         inst.append = $("<span class='" + this._appendClass + "'>" + appendText + "</span>");
3984                         input[isRTL ? "before" : "after"](inst.append);
3985                 }
3986
3987                 input.unbind("focus", this._showDatepicker);
3988
3989                 if (inst.trigger) {
3990                         inst.trigger.remove();
3991                 }
3992
3993                 showOn = this._get(inst, "showOn");
3994                 if (showOn === "focus" || showOn === "both") { // pop-up date picker when in the marked field
3995                         input.focus(this._showDatepicker);
3996                 }
3997                 if (showOn === "button" || showOn === "both") { // pop-up date picker when button clicked
3998                         buttonText = this._get(inst, "buttonText");
3999                         buttonImage = this._get(inst, "buttonImage");
4000                         inst.trigger = $(this._get(inst, "buttonImageOnly") ?
4001                                 $("<img/>").addClass(this._triggerClass).
4002                                         attr({ src: buttonImage, alt: buttonText, title: buttonText }) :
4003                                 $("<button type='button'></button>").addClass(this._triggerClass).
4004                                         html(!buttonImage ? buttonText : $("<img/>").attr(
4005                                         { src:buttonImage, alt:buttonText, title:buttonText })));
4006                         input[isRTL ? "before" : "after"](inst.trigger);
4007                         inst.trigger.click(function() {
4008                                 if ($.datepicker._datepickerShowing && $.datepicker._lastInput === input[0]) {
4009                                         $.datepicker._hideDatepicker();
4010                                 } else if ($.datepicker._datepickerShowing && $.datepicker._lastInput !== input[0]) {
4011                                         $.datepicker._hideDatepicker();
4012                                         $.datepicker._showDatepicker(input[0]);
4013                                 } else {
4014                                         $.datepicker._showDatepicker(input[0]);
4015                                 }
4016                                 return false;
4017                         });
4018                 }
4019         },
4020
4021         /* Apply the maximum length for the date format. */
4022         _autoSize: function(inst) {
4023                 if (this._get(inst, "autoSize") && !inst.inline) {
4024                         var findMax, max, maxI, i,
4025                                 date = new Date(2009, 12 - 1, 20), // Ensure double digits
4026                                 dateFormat = this._get(inst, "dateFormat");
4027
4028                         if (dateFormat.match(/[DM]/)) {
4029                                 findMax = function(names) {
4030                                         max = 0;
4031                                         maxI = 0;
4032                                         for (i = 0; i < names.length; i++) {
4033                                                 if (names[i].length > max) {
4034                                                         max = names[i].length;
4035                                                         maxI = i;
4036                                                 }
4037                                         }
4038                                         return maxI;
4039                                 };
4040                                 date.setMonth(findMax(this._get(inst, (dateFormat.match(/MM/) ?
4041                                         "monthNames" : "monthNamesShort"))));
4042                                 date.setDate(findMax(this._get(inst, (dateFormat.match(/DD/) ?
4043                                         "dayNames" : "dayNamesShort"))) + 20 - date.getDay());
4044                         }
4045                         inst.input.attr("size", this._formatDate(inst, date).length);
4046                 }
4047         },
4048
4049         /* Attach an inline date picker to a div. */
4050         _inlineDatepicker: function(target, inst) {
4051                 var divSpan = $(target);
4052                 if (divSpan.hasClass(this.markerClassName)) {
4053                         return;
4054                 }
4055                 divSpan.addClass(this.markerClassName).append(inst.dpDiv);
4056                 $.data(target, "datepicker", inst);
4057                 this._setDate(inst, this._getDefaultDate(inst), true);
4058                 this._updateDatepicker(inst);
4059                 this._updateAlternate(inst);
4060                 //If disabled option is true, disable the datepicker before showing it (see ticket #5665)
4061                 if( inst.settings.disabled ) {
4062                         this._disableDatepicker( target );
4063                 }
4064                 // Set display:block in place of inst.dpDiv.show() which won't work on disconnected elements
4065                 // http://bugs.jqueryui.com/ticket/7552 - A Datepicker created on a detached div has zero height
4066                 inst.dpDiv.css( "display", "block" );
4067         },
4068
4069         /* Pop-up the date picker in a "dialog" box.
4070          * @param  input element - ignored
4071          * @param  date string or Date - the initial date to display
4072          * @param  onSelect  function - the function to call when a date is selected
4073          * @param  settings  object - update the dialog date picker instance's settings (anonymous object)
4074          * @param  pos int[2] - coordinates for the dialog's position within the screen or
4075          *                                      event - with x/y coordinates or
4076          *                                      leave empty for default (screen centre)
4077          * @return the manager object
4078          */
4079         _dialogDatepicker: function(input, date, onSelect, settings, pos) {
4080                 var id, browserWidth, browserHeight, scrollX, scrollY,
4081                         inst = this._dialogInst; // internal instance
4082
4083                 if (!inst) {
4084                         this.uuid += 1;
4085                         id = "dp" + this.uuid;
4086                         this._dialogInput = $("<input type='text' id='" + id +
4087                                 "' style='position: absolute; top: -100px; width: 0px;'/>");
4088                         this._dialogInput.keydown(this._doKeyDown);
4089                         $("body").append(this._dialogInput);
4090                         inst = this._dialogInst = this._newInst(this._dialogInput, false);
4091                         inst.settings = {};
4092                         $.data(this._dialogInput[0], "datepicker", inst);
4093                 }
4094                 datepicker_extendRemove(inst.settings, settings || {});
4095                 date = (date && date.constructor === Date ? this._formatDate(inst, date) : date);
4096                 this._dialogInput.val(date);
4097
4098                 this._pos = (pos ? (pos.length ? pos : [pos.pageX, pos.pageY]) : null);
4099                 if (!this._pos) {
4100                         browserWidth = document.documentElement.clientWidth;
4101                         browserHeight = document.documentElement.clientHeight;
4102                         scrollX = document.documentElement.scrollLeft || document.body.scrollLeft;
4103                         scrollY = document.documentElement.scrollTop || document.body.scrollTop;
4104                         this._pos = // should use actual width/height below
4105                                 [(browserWidth / 2) - 100 + scrollX, (browserHeight / 2) - 150 + scrollY];
4106                 }
4107
4108                 // move input on screen for focus, but hidden behind dialog
4109                 this._dialogInput.css("left", (this._pos[0] + 20) + "px").css("top", this._pos[1] + "px");
4110                 inst.settings.onSelect = onSelect;
4111                 this._inDialog = true;
4112                 this.dpDiv.addClass(this._dialogClass);
4113                 this._showDatepicker(this._dialogInput[0]);
4114                 if ($.blockUI) {
4115                         $.blockUI(this.dpDiv);
4116                 }
4117                 $.data(this._dialogInput[0], "datepicker", inst);
4118                 return this;
4119         },
4120
4121         /* Detach a datepicker from its control.
4122          * @param  target       element - the target input field or division or span
4123          */
4124         _destroyDatepicker: function(target) {
4125                 var nodeName,
4126                         $target = $(target),
4127                         inst = $.data(target, "datepicker");
4128
4129                 if (!$target.hasClass(this.markerClassName)) {
4130                         return;
4131                 }
4132
4133                 nodeName = target.nodeName.toLowerCase();
4134                 $.removeData(target, "datepicker");
4135                 if (nodeName === "input") {
4136                         inst.append.remove();
4137                         inst.trigger.remove();
4138                         $target.removeClass(this.markerClassName).
4139                                 unbind("focus", this._showDatepicker).
4140                                 unbind("keydown", this._doKeyDown).
4141                                 unbind("keypress", this._doKeyPress).
4142                                 unbind("keyup", this._doKeyUp);
4143                 } else if (nodeName === "div" || nodeName === "span") {
4144                         $target.removeClass(this.markerClassName).empty();
4145                 }
4146
4147                 if ( datepicker_instActive === inst ) {
4148                         datepicker_instActive = null;
4149                 }
4150         },
4151
4152         /* Enable the date picker to a jQuery selection.
4153          * @param  target       element - the target input field or division or span
4154          */
4155         _enableDatepicker: function(target) {
4156                 var nodeName, inline,
4157                         $target = $(target),
4158                         inst = $.data(target, "datepicker");
4159
4160                 if (!$target.hasClass(this.markerClassName)) {
4161                         return;
4162                 }
4163
4164                 nodeName = target.nodeName.toLowerCase();
4165                 if (nodeName === "input") {
4166                         target.disabled = false;
4167                         inst.trigger.filter("button").
4168                                 each(function() { this.disabled = false; }).end().
4169                                 filter("img").css({opacity: "1.0", cursor: ""});
4170                 } else if (nodeName === "div" || nodeName === "span") {
4171                         inline = $target.children("." + this._inlineClass);
4172                         inline.children().removeClass("ui-state-disabled");
4173                         inline.find("select.ui-datepicker-month, select.ui-datepicker-year").
4174                                 prop("disabled", false);
4175                 }
4176                 this._disabledInputs = $.map(this._disabledInputs,
4177                         function(value) { return (value === target ? null : value); }); // delete entry
4178         },
4179
4180         /* Disable the date picker to a jQuery selection.
4181          * @param  target       element - the target input field or division or span
4182          */
4183         _disableDatepicker: function(target) {
4184                 var nodeName, inline,
4185                         $target = $(target),
4186                         inst = $.data(target, "datepicker");
4187
4188                 if (!$target.hasClass(this.markerClassName)) {
4189                         return;
4190                 }
4191
4192                 nodeName = target.nodeName.toLowerCase();
4193                 if (nodeName === "input") {
4194                         target.disabled = true;
4195                         inst.trigger.filter("button").
4196                                 each(function() { this.disabled = true; }).end().
4197                                 filter("img").css({opacity: "0.5", cursor: "default"});
4198                 } else if (nodeName === "div" || nodeName === "span") {
4199                         inline = $target.children("." + this._inlineClass);
4200                         inline.children().addClass("ui-state-disabled");
4201                         inline.find("select.ui-datepicker-month, select.ui-datepicker-year").
4202                                 prop("disabled", true);
4203                 }
4204                 this._disabledInputs = $.map(this._disabledInputs,
4205                         function(value) { return (value === target ? null : value); }); // delete entry
4206                 this._disabledInputs[this._disabledInputs.length] = target;
4207         },
4208
4209         /* Is the first field in a jQuery collection disabled as a datepicker?
4210          * @param  target       element - the target input field or division or span
4211          * @return boolean - true if disabled, false if enabled
4212          */
4213         _isDisabledDatepicker: function(target) {
4214                 if (!target) {
4215                         return false;
4216                 }
4217                 for (var i = 0; i < this._disabledInputs.length; i++) {
4218                         if (this._disabledInputs[i] === target) {
4219                                 return true;
4220                         }
4221                 }
4222                 return false;
4223         },
4224
4225         /* Retrieve the instance data for the target control.
4226          * @param  target  element - the target input field or division or span
4227          * @return  object - the associated instance data
4228          * @throws  error if a jQuery problem getting data
4229          */
4230         _getInst: function(target) {
4231                 try {
4232                         return $.data(target, "datepicker");
4233                 }
4234                 catch (err) {
4235                         throw "Missing instance data for this datepicker";
4236                 }
4237         },
4238
4239         /* Update or retrieve the settings for a date picker attached to an input field or division.
4240          * @param  target  element - the target input field or division or span
4241          * @param  name object - the new settings to update or
4242          *                              string - the name of the setting to change or retrieve,
4243          *                              when retrieving also "all" for all instance settings or
4244          *                              "defaults" for all global defaults
4245          * @param  value   any - the new value for the setting
4246          *                              (omit if above is an object or to retrieve a value)
4247          */
4248         _optionDatepicker: function(target, name, value) {
4249                 var settings, date, minDate, maxDate,
4250                         inst = this._getInst(target);
4251
4252                 if (arguments.length === 2 && typeof name === "string") {
4253                         return (name === "defaults" ? $.extend({}, $.datepicker._defaults) :
4254                                 (inst ? (name === "all" ? $.extend({}, inst.settings) :
4255                                 this._get(inst, name)) : null));
4256                 }
4257
4258                 settings = name || {};
4259                 if (typeof name === "string") {
4260                         settings = {};
4261                         settings[name] = value;
4262                 }
4263
4264                 if (inst) {
4265                         if (this._curInst === inst) {
4266                                 this._hideDatepicker();
4267                         }
4268
4269                         date = this._getDateDatepicker(target, true);
4270                         minDate = this._getMinMaxDate(inst, "min");
4271                         maxDate = this._getMinMaxDate(inst, "max");
4272                         datepicker_extendRemove(inst.settings, settings);
4273                         // reformat the old minDate/maxDate values if dateFormat changes and a new minDate/maxDate isn't provided
4274                         if (minDate !== null && settings.dateFormat !== undefined && settings.minDate === undefined) {
4275                                 inst.settings.minDate = this._formatDate(inst, minDate);
4276                         }
4277                         if (maxDate !== null && settings.dateFormat !== undefined && settings.maxDate === undefined) {
4278                                 inst.settings.maxDate = this._formatDate(inst, maxDate);
4279                         }
4280                         if ( "disabled" in settings ) {
4281                                 if ( settings.disabled ) {
4282                                         this._disableDatepicker(target);
4283                                 } else {
4284                                         this._enableDatepicker(target);
4285                                 }
4286                         }
4287                         this._attachments($(target), inst);
4288                         this._autoSize(inst);
4289                         this._setDate(inst, date);
4290                         this._updateAlternate(inst);
4291                         this._updateDatepicker(inst);
4292                 }
4293         },
4294
4295         // change method deprecated
4296         _changeDatepicker: function(target, name, value) {
4297                 this._optionDatepicker(target, name, value);
4298         },
4299
4300         /* Redraw the date picker attached to an input field or division.
4301          * @param  target  element - the target input field or division or span
4302          */
4303         _refreshDatepicker: function(target) {
4304                 var inst = this._getInst(target);
4305                 if (inst) {
4306                         this._updateDatepicker(inst);
4307                 }
4308         },
4309
4310         /* Set the dates for a jQuery selection.
4311          * @param  target element - the target input field or division or span
4312          * @param  date Date - the new date
4313          */
4314         _setDateDatepicker: function(target, date) {
4315                 var inst = this._getInst(target);
4316                 if (inst) {
4317                         this._setDate(inst, date);
4318                         this._updateDatepicker(inst);
4319                         this._updateAlternate(inst);
4320                 }
4321         },
4322
4323         /* Get the date(s) for the first entry in a jQuery selection.
4324          * @param  target element - the target input field or division or span
4325          * @param  noDefault boolean - true if no default date is to be used
4326          * @return Date - the current date
4327          */
4328         _getDateDatepicker: function(target, noDefault) {
4329                 var inst = this._getInst(target);
4330                 if (inst && !inst.inline) {
4331                         this._setDateFromField(inst, noDefault);
4332                 }
4333                 return (inst ? this._getDate(inst) : null);
4334         },
4335
4336         /* Handle keystrokes. */
4337         _doKeyDown: function(event) {
4338                 var onSelect, dateStr, sel,
4339                         inst = $.datepicker._getInst(event.target),
4340                         handled = true,
4341                         isRTL = inst.dpDiv.is(".ui-datepicker-rtl");
4342
4343                 inst._keyEvent = true;
4344                 if ($.datepicker._datepickerShowing) {
4345                         switch (event.keyCode) {
4346                                 case 9: $.datepicker._hideDatepicker();
4347                                                 handled = false;
4348                                                 break; // hide on tab out
4349                                 case 13: sel = $("td." + $.datepicker._dayOverClass + ":not(." +
4350                                                                         $.datepicker._currentClass + ")", inst.dpDiv);
4351                                                 if (sel[0]) {
4352                                                         $.datepicker._selectDay(event.target, inst.selectedMonth, inst.selectedYear, sel[0]);
4353                                                 }
4354
4355                                                 onSelect = $.datepicker._get(inst, "onSelect");
4356                                                 if (onSelect) {
4357                                                         dateStr = $.datepicker._formatDate(inst);
4358
4359                                                         // trigger custom callback
4360                                                         onSelect.apply((inst.input ? inst.input[0] : null), [dateStr, inst]);
4361                                                 } else {
4362                                                         $.datepicker._hideDatepicker();
4363                                                 }
4364
4365                                                 return false; // don't submit the form
4366                                 case 27: $.datepicker._hideDatepicker();
4367                                                 break; // hide on escape
4368                                 case 33: $.datepicker._adjustDate(event.target, (event.ctrlKey ?
4369                                                         -$.datepicker._get(inst, "stepBigMonths") :
4370                                                         -$.datepicker._get(inst, "stepMonths")), "M");
4371                                                 break; // previous month/year on page up/+ ctrl
4372                                 case 34: $.datepicker._adjustDate(event.target, (event.ctrlKey ?
4373                                                         +$.datepicker._get(inst, "stepBigMonths") :
4374                                                         +$.datepicker._get(inst, "stepMonths")), "M");
4375                                                 break; // next month/year on page down/+ ctrl
4376                                 case 35: if (event.ctrlKey || event.metaKey) {
4377                                                         $.datepicker._clearDate(event.target);
4378                                                 }
4379                                                 handled = event.ctrlKey || event.metaKey;
4380                                                 break; // clear on ctrl or command +end
4381                                 case 36: if (event.ctrlKey || event.metaKey) {
4382                                                         $.datepicker._gotoToday(event.target);
4383                                                 }
4384                                                 handled = event.ctrlKey || event.metaKey;
4385                                                 break; // current on ctrl or command +home
4386                                 case 37: if (event.ctrlKey || event.metaKey) {
4387                                                         $.datepicker._adjustDate(event.target, (isRTL ? +1 : -1), "D");
4388                                                 }
4389                                                 handled = event.ctrlKey || event.metaKey;
4390                                                 // -1 day on ctrl or command +left
4391                                                 if (event.originalEvent.altKey) {
4392                                                         $.datepicker._adjustDate(event.target, (event.ctrlKey ?
4393                                                                 -$.datepicker._get(inst, "stepBigMonths") :
4394                                                                 -$.datepicker._get(inst, "stepMonths")), "M");
4395                                                 }
4396                                                 // next month/year on alt +left on Mac
4397                                                 break;
4398                                 case 38: if (event.ctrlKey || event.metaKey) {
4399                                                         $.datepicker._adjustDate(event.target, -7, "D");
4400                                                 }
4401                                                 handled = event.ctrlKey || event.metaKey;
4402                                                 break; // -1 week on ctrl or command +up
4403                                 case 39: if (event.ctrlKey || event.metaKey) {
4404                                                         $.datepicker._adjustDate(event.target, (isRTL ? -1 : +1), "D");
4405                                                 }
4406                                                 handled = event.ctrlKey || event.metaKey;
4407                                                 // +1 day on ctrl or command +right
4408                                                 if (event.originalEvent.altKey) {
4409                                                         $.datepicker._adjustDate(event.target, (event.ctrlKey ?
4410                                                                 +$.datepicker._get(inst, "stepBigMonths") :
4411                                                                 +$.datepicker._get(inst, "stepMonths")), "M");
4412                                                 }
4413                                                 // next month/year on alt +right
4414                                                 break;
4415                                 case 40: if (event.ctrlKey || event.metaKey) {
4416                                                         $.datepicker._adjustDate(event.target, +7, "D");
4417                                                 }
4418                                                 handled = event.ctrlKey || event.metaKey;
4419                                                 break; // +1 week on ctrl or command +down
4420                                 default: handled = false;
4421                         }
4422                 } else if (event.keyCode === 36 && event.ctrlKey) { // display the date picker on ctrl+home
4423                         $.datepicker._showDatepicker(this);
4424                 } else {
4425                         handled = false;
4426                 }
4427
4428                 if (handled) {
4429                         event.preventDefault();
4430                         event.stopPropagation();
4431                 }
4432         },
4433
4434         /* Filter entered characters - based on date format. */
4435         _doKeyPress: function(event) {
4436                 var chars, chr,
4437                         inst = $.datepicker._getInst(event.target);
4438
4439                 if ($.datepicker._get(inst, "constrainInput")) {
4440                         chars = $.datepicker._possibleChars($.datepicker._get(inst, "dateFormat"));
4441                         chr = String.fromCharCode(event.charCode == null ? event.keyCode : event.charCode);
4442                         return event.ctrlKey || event.metaKey || (chr < " " || !chars || chars.indexOf(chr) > -1);
4443                 }
4444         },
4445
4446         /* Synchronise manual entry and field/alternate field. */
4447         _doKeyUp: function(event) {
4448                 var date,
4449                         inst = $.datepicker._getInst(event.target);
4450
4451                 if (inst.input.val() !== inst.lastVal) {
4452                         try {
4453                                 date = $.datepicker.parseDate($.datepicker._get(inst, "dateFormat"),
4454                                         (inst.input ? inst.input.val() : null),
4455                                         $.datepicker._getFormatConfig(inst));
4456
4457                                 if (date) { // only if valid
4458                                         $.datepicker._setDateFromField(inst);
4459                                         $.datepicker._updateAlternate(inst);
4460                                         $.datepicker._updateDatepicker(inst);
4461                                 }
4462                         }
4463                         catch (err) {
4464                         }
4465                 }
4466                 return true;
4467         },
4468
4469         /* Pop-up the date picker for a given input field.
4470          * If false returned from beforeShow event handler do not show.
4471          * @param  input  element - the input field attached to the date picker or
4472          *                                      event - if triggered by focus
4473          */
4474         _showDatepicker: function(input) {
4475                 input = input.target || input;
4476                 if (input.nodeName.toLowerCase() !== "input") { // find from button/image trigger
4477                         input = $("input", input.parentNode)[0];
4478                 }
4479
4480                 if ($.datepicker._isDisabledDatepicker(input) || $.datepicker._lastInput === input) { // already here
4481                         return;
4482                 }
4483
4484                 var inst, beforeShow, beforeShowSettings, isFixed,
4485                         offset, showAnim, duration;
4486
4487                 inst = $.datepicker._getInst(input);
4488                 if ($.datepicker._curInst && $.datepicker._curInst !== inst) {
4489                         $.datepicker._curInst.dpDiv.stop(true, true);
4490                         if ( inst && $.datepicker._datepickerShowing ) {
4491                                 $.datepicker._hideDatepicker( $.datepicker._curInst.input[0] );
4492                         }
4493                 }
4494
4495                 beforeShow = $.datepicker._get(inst, "beforeShow");
4496                 beforeShowSettings = beforeShow ? beforeShow.apply(input, [input, inst]) : {};
4497                 if(beforeShowSettings === false){
4498                         return;
4499                 }
4500                 datepicker_extendRemove(inst.settings, beforeShowSettings);
4501
4502                 inst.lastVal = null;
4503                 $.datepicker._lastInput = input;
4504                 $.datepicker._setDateFromField(inst);
4505
4506                 if ($.datepicker._inDialog) { // hide cursor
4507                         input.value = "";
4508                 }
4509                 if (!$.datepicker._pos) { // position below input
4510                         $.datepicker._pos = $.datepicker._findPos(input);
4511                         $.datepicker._pos[1] += input.offsetHeight; // add the height
4512                 }
4513
4514                 isFixed = false;
4515                 $(input).parents().each(function() {
4516                         isFixed |= $(this).css("position") === "fixed";
4517                         return !isFixed;
4518                 });
4519
4520                 offset = {left: $.datepicker._pos[0], top: $.datepicker._pos[1]};
4521                 $.datepicker._pos = null;
4522                 //to avoid flashes on Firefox
4523                 inst.dpDiv.empty();
4524                 // determine sizing offscreen
4525                 inst.dpDiv.css({position: "absolute", display: "block", top: "-1000px"});
4526                 $.datepicker._updateDatepicker(inst);
4527                 // fix width for dynamic number of date pickers
4528                 // and adjust position before showing
4529                 offset = $.datepicker._checkOffset(inst, offset, isFixed);
4530                 inst.dpDiv.css({position: ($.datepicker._inDialog && $.blockUI ?
4531                         "static" : (isFixed ? "fixed" : "absolute")), display: "none",
4532                         left: offset.left + "px", top: offset.top + "px"});
4533
4534                 if (!inst.inline) {
4535                         showAnim = $.datepicker._get(inst, "showAnim");
4536                         duration = $.datepicker._get(inst, "duration");
4537                         inst.dpDiv.css( "z-index", datepicker_getZindex( $( input ) ) + 1 );
4538                         $.datepicker._datepickerShowing = true;
4539
4540                         if ( $.effects && $.effects.effect[ showAnim ] ) {
4541                                 inst.dpDiv.show(showAnim, $.datepicker._get(inst, "showOptions"), duration);
4542                         } else {
4543                                 inst.dpDiv[showAnim || "show"](showAnim ? duration : null);
4544                         }
4545
4546                         if ( $.datepicker._shouldFocusInput( inst ) ) {
4547                                 inst.input.focus();
4548                         }
4549
4550                         $.datepicker._curInst = inst;
4551                 }
4552         },
4553
4554         /* Generate the date picker content. */
4555         _updateDatepicker: function(inst) {
4556                 this.maxRows = 4; //Reset the max number of rows being displayed (see #7043)
4557                 datepicker_instActive = inst; // for delegate hover events
4558                 inst.dpDiv.empty().append(this._generateHTML(inst));
4559                 this._attachHandlers(inst);
4560
4561                 var origyearshtml,
4562                         numMonths = this._getNumberOfMonths(inst),
4563                         cols = numMonths[1],
4564                         width = 17,
4565                         activeCell = inst.dpDiv.find( "." + this._dayOverClass + " a" );
4566
4567                 if ( activeCell.length > 0 ) {
4568                         datepicker_handleMouseover.apply( activeCell.get( 0 ) );
4569                 }
4570
4571                 inst.dpDiv.removeClass("ui-datepicker-multi-2 ui-datepicker-multi-3 ui-datepicker-multi-4").width("");
4572                 if (cols > 1) {
4573                         inst.dpDiv.addClass("ui-datepicker-multi-" + cols).css("width", (width * cols) + "em");
4574                 }
4575                 inst.dpDiv[(numMonths[0] !== 1 || numMonths[1] !== 1 ? "add" : "remove") +
4576                         "Class"]("ui-datepicker-multi");
4577                 inst.dpDiv[(this._get(inst, "isRTL") ? "add" : "remove") +
4578                         "Class"]("ui-datepicker-rtl");
4579
4580                 if (inst === $.datepicker._curInst && $.datepicker._datepickerShowing && $.datepicker._shouldFocusInput( inst ) ) {
4581                         inst.input.focus();
4582                 }
4583
4584                 // deffered render of the years select (to avoid flashes on Firefox)
4585                 if( inst.yearshtml ){
4586                         origyearshtml = inst.yearshtml;
4587                         setTimeout(function(){
4588                                 //assure that inst.yearshtml didn't change.
4589                                 if( origyearshtml === inst.yearshtml && inst.yearshtml ){
4590                                         inst.dpDiv.find("select.ui-datepicker-year:first").replaceWith(inst.yearshtml);
4591                                 }
4592                                 origyearshtml = inst.yearshtml = null;
4593                         }, 0);
4594                 }
4595         },
4596
4597         // #6694 - don't focus the input if it's already focused
4598         // this breaks the change event in IE
4599         // Support: IE and jQuery <1.9
4600         _shouldFocusInput: function( inst ) {
4601                 return inst.input && inst.input.is( ":visible" ) && !inst.input.is( ":disabled" ) && !inst.input.is( ":focus" );
4602         },
4603
4604         /* Check positioning to remain on screen. */
4605         _checkOffset: function(inst, offset, isFixed) {
4606                 var dpWidth = inst.dpDiv.outerWidth(),
4607                         dpHeight = inst.dpDiv.outerHeight(),
4608                         inputWidth = inst.input ? inst.input.outerWidth() : 0,
4609                         inputHeight = inst.input ? inst.input.outerHeight() : 0,
4610                         viewWidth = document.documentElement.clientWidth + (isFixed ? 0 : $(document).scrollLeft()),
4611                         viewHeight = document.documentElement.clientHeight + (isFixed ? 0 : $(document).scrollTop());
4612
4613                 offset.left -= (this._get(inst, "isRTL") ? (dpWidth - inputWidth) : 0);
4614                 offset.left -= (isFixed && offset.left === inst.input.offset().left) ? $(document).scrollLeft() : 0;
4615                 offset.top -= (isFixed && offset.top === (inst.input.offset().top + inputHeight)) ? $(document).scrollTop() : 0;
4616
4617                 // now check if datepicker is showing outside window viewport - move to a better place if so.
4618                 offset.left -= Math.min(offset.left, (offset.left + dpWidth > viewWidth && viewWidth > dpWidth) ?
4619                         Math.abs(offset.left + dpWidth - viewWidth) : 0);
4620                 offset.top -= Math.min(offset.top, (offset.top + dpHeight > viewHeight && viewHeight > dpHeight) ?
4621                         Math.abs(dpHeight + inputHeight) : 0);
4622
4623                 return offset;
4624         },
4625
4626         /* Find an object's position on the screen. */
4627         _findPos: function(obj) {
4628                 var position,
4629                         inst = this._getInst(obj),
4630                         isRTL = this._get(inst, "isRTL");
4631
4632                 while (obj && (obj.type === "hidden" || obj.nodeType !== 1 || $.expr.filters.hidden(obj))) {
4633                         obj = obj[isRTL ? "previousSibling" : "nextSibling"];
4634                 }
4635
4636                 position = $(obj).offset();
4637                 return [position.left, position.top];
4638         },
4639
4640         /* Hide the date picker from view.
4641          * @param  input  element - the input field attached to the date picker
4642          */
4643         _hideDatepicker: function(input) {
4644                 var showAnim, duration, postProcess, onClose,
4645                         inst = this._curInst;
4646
4647                 if (!inst || (input && inst !== $.data(input, "datepicker"))) {
4648                         return;
4649                 }
4650
4651                 if (this._datepickerShowing) {
4652                         showAnim = this._get(inst, "showAnim");
4653                         duration = this._get(inst, "duration");
4654                         postProcess = function() {
4655                                 $.datepicker._tidyDialog(inst);
4656                         };
4657
4658                         // DEPRECATED: after BC for 1.8.x $.effects[ showAnim ] is not needed
4659                         if ( $.effects && ( $.effects.effect[ showAnim ] || $.effects[ showAnim ] ) ) {
4660                                 inst.dpDiv.hide(showAnim, $.datepicker._get(inst, "showOptions"), duration, postProcess);
4661                         } else {
4662                                 inst.dpDiv[(showAnim === "slideDown" ? "slideUp" :
4663                                         (showAnim === "fadeIn" ? "fadeOut" : "hide"))]((showAnim ? duration : null), postProcess);
4664                         }
4665
4666                         if (!showAnim) {
4667                                 postProcess();
4668                         }
4669                         this._datepickerShowing = false;
4670
4671                         onClose = this._get(inst, "onClose");
4672                         if (onClose) {
4673                                 onClose.apply((inst.input ? inst.input[0] : null), [(inst.input ? inst.input.val() : ""), inst]);
4674                         }
4675
4676                         this._lastInput = null;
4677                         if (this._inDialog) {
4678                                 this._dialogInput.css({ position: "absolute", left: "0", top: "-100px" });
4679                                 if ($.blockUI) {
4680                                         $.unblockUI();
4681                                         $("body").append(this.dpDiv);
4682                                 }
4683                         }
4684                         this._inDialog = false;
4685                 }
4686         },
4687
4688         /* Tidy up after a dialog display. */
4689         _tidyDialog: function(inst) {
4690                 inst.dpDiv.removeClass(this._dialogClass).unbind(".ui-datepicker-calendar");
4691         },
4692
4693         /* Close date picker if clicked elsewhere. */
4694         _checkExternalClick: function(event) {
4695                 if (!$.datepicker._curInst) {
4696                         return;
4697                 }
4698
4699                 var $target = $(event.target),
4700                         inst = $.datepicker._getInst($target[0]);
4701
4702                 if ( ( ( $target[0].id !== $.datepicker._mainDivId &&
4703                                 $target.parents("#" + $.datepicker._mainDivId).length === 0 &&
4704                                 !$target.hasClass($.datepicker.markerClassName) &&
4705                                 !$target.closest("." + $.datepicker._triggerClass).length &&
4706                                 $.datepicker._datepickerShowing && !($.datepicker._inDialog && $.blockUI) ) ) ||
4707                         ( $target.hasClass($.datepicker.markerClassName) && $.datepicker._curInst !== inst ) ) {
4708                                 $.datepicker._hideDatepicker();
4709                 }
4710         },
4711
4712         /* Adjust one of the date sub-fields. */
4713         _adjustDate: function(id, offset, period) {
4714                 var target = $(id),
4715                         inst = this._getInst(target[0]);
4716
4717                 if (this._isDisabledDatepicker(target[0])) {
4718                         return;
4719                 }
4720                 this._adjustInstDate(inst, offset +
4721                         (period === "M" ? this._get(inst, "showCurrentAtPos") : 0), // undo positioning
4722                         period);
4723                 this._updateDatepicker(inst);
4724         },
4725
4726         /* Action for current link. */
4727         _gotoToday: function(id) {
4728                 var date,
4729                         target = $(id),
4730                         inst = this._getInst(target[0]);
4731
4732                 if (this._get(inst, "gotoCurrent") && inst.currentDay) {
4733                         inst.selectedDay = inst.currentDay;
4734                         inst.drawMonth = inst.selectedMonth = inst.currentMonth;
4735                         inst.drawYear = inst.selectedYear = inst.currentYear;
4736                 } else {
4737                         date = new Date();
4738                         inst.selectedDay = date.getDate();
4739                         inst.drawMonth = inst.selectedMonth = date.getMonth();
4740                         inst.drawYear = inst.selectedYear = date.getFullYear();
4741                 }
4742                 this._notifyChange(inst);
4743                 this._adjustDate(target);
4744         },
4745
4746         /* Action for selecting a new month/year. */
4747         _selectMonthYear: function(id, select, period) {
4748                 var target = $(id),
4749                         inst = this._getInst(target[0]);
4750
4751                 inst["selected" + (period === "M" ? "Month" : "Year")] =
4752                 inst["draw" + (period === "M" ? "Month" : "Year")] =
4753                         parseInt(select.options[select.selectedIndex].value,10);
4754
4755                 this._notifyChange(inst);
4756                 this._adjustDate(target);
4757         },
4758
4759         /* Action for selecting a day. */
4760         _selectDay: function(id, month, year, td) {
4761                 var inst,
4762                         target = $(id);
4763
4764                 if ($(td).hasClass(this._unselectableClass) || this._isDisabledDatepicker(target[0])) {
4765                         return;
4766                 }
4767
4768                 inst = this._getInst(target[0]);
4769                 inst.selectedDay = inst.currentDay = $("a", td).html();
4770                 inst.selectedMonth = inst.currentMonth = month;
4771                 inst.selectedYear = inst.currentYear = year;
4772                 this._selectDate(id, this._formatDate(inst,
4773                         inst.currentDay, inst.currentMonth, inst.currentYear));
4774         },
4775
4776         /* Erase the input field and hide the date picker. */
4777         _clearDate: function(id) {
4778                 var target = $(id);
4779                 this._selectDate(target, "");
4780         },
4781
4782         /* Update the input field with the selected date. */
4783         _selectDate: function(id, dateStr) {
4784                 var onSelect,
4785                         target = $(id),
4786                         inst = this._getInst(target[0]);
4787
4788                 dateStr = (dateStr != null ? dateStr : this._formatDate(inst));
4789                 if (inst.input) {
4790                         inst.input.val(dateStr);
4791                 }
4792                 this._updateAlternate(inst);
4793
4794                 onSelect = this._get(inst, "onSelect");
4795                 if (onSelect) {
4796                         onSelect.apply((inst.input ? inst.input[0] : null), [dateStr, inst]);  // trigger custom callback
4797                 } else if (inst.input) {
4798                         inst.input.trigger("change"); // fire the change event
4799                 }
4800
4801                 if (inst.inline){
4802                         this._updateDatepicker(inst);
4803                 } else {
4804                         this._hideDatepicker();
4805                         this._lastInput = inst.input[0];
4806                         if (typeof(inst.input[0]) !== "object") {
4807                                 inst.input.focus(); // restore focus
4808                         }
4809                         this._lastInput = null;
4810                 }
4811         },
4812
4813         /* Update any alternate field to synchronise with the main field. */
4814         _updateAlternate: function(inst) {
4815                 var altFormat, date, dateStr,
4816                         altField = this._get(inst, "altField");
4817
4818                 if (altField) { // update alternate field too
4819                         altFormat = this._get(inst, "altFormat") || this._get(inst, "dateFormat");
4820                         date = this._getDate(inst);
4821                         dateStr = this.formatDate(altFormat, date, this._getFormatConfig(inst));
4822                         $(altField).each(function() { $(this).val(dateStr); });
4823                 }
4824         },
4825
4826         /* Set as beforeShowDay function to prevent selection of weekends.
4827          * @param  date  Date - the date to customise
4828          * @return [boolean, string] - is this date selectable?, what is its CSS class?
4829          */
4830         noWeekends: function(date) {
4831                 var day = date.getDay();
4832                 return [(day > 0 && day < 6), ""];
4833         },
4834
4835         /* Set as calculateWeek to determine the week of the year based on the ISO 8601 definition.
4836          * @param  date  Date - the date to get the week for
4837          * @return  number - the number of the week within the year that contains this date
4838          */
4839         iso8601Week: function(date) {
4840                 var time,
4841                         checkDate = new Date(date.getTime());
4842
4843                 // Find Thursday of this week starting on Monday
4844                 checkDate.setDate(checkDate.getDate() + 4 - (checkDate.getDay() || 7));
4845
4846                 time = checkDate.getTime();
4847                 checkDate.setMonth(0); // Compare with Jan 1
4848                 checkDate.setDate(1);
4849                 return Math.floor(Math.round((time - checkDate) / 86400000) / 7) + 1;
4850         },
4851
4852         /* Parse a string value into a date object.
4853          * See formatDate below for the possible formats.
4854          *
4855          * @param  format string - the expected format of the date
4856          * @param  value string - the date in the above format
4857          * @param  settings Object - attributes include:
4858          *                                      shortYearCutoff  number - the cutoff year for determining the century (optional)
4859          *                                      dayNamesShort   string[7] - abbreviated names of the days from Sunday (optional)
4860          *                                      dayNames                string[7] - names of the days from Sunday (optional)
4861          *                                      monthNamesShort string[12] - abbreviated names of the months (optional)
4862          *                                      monthNames              string[12] - names of the months (optional)
4863          * @return  Date - the extracted date value or null if value is blank
4864          */
4865         parseDate: function (format, value, settings) {
4866                 if (format == null || value == null) {
4867                         throw "Invalid arguments";
4868                 }
4869
4870                 value = (typeof value === "object" ? value.toString() : value + "");
4871                 if (value === "") {
4872                         return null;
4873                 }
4874
4875                 var iFormat, dim, extra,
4876                         iValue = 0,
4877                         shortYearCutoffTemp = (settings ? settings.shortYearCutoff : null) || this._defaults.shortYearCutoff,
4878                         shortYearCutoff = (typeof shortYearCutoffTemp !== "string" ? shortYearCutoffTemp :
4879                                 new Date().getFullYear() % 100 + parseInt(shortYearCutoffTemp, 10)),
4880                         dayNamesShort = (settings ? settings.dayNamesShort : null) || this._defaults.dayNamesShort,
4881                         dayNames = (settings ? settings.dayNames : null) || this._defaults.dayNames,
4882                         monthNamesShort = (settings ? settings.monthNamesShort : null) || this._defaults.monthNamesShort,
4883                         monthNames = (settings ? settings.monthNames : null) || this._defaults.monthNames,
4884                         year = -1,
4885                         month = -1,
4886                         day = -1,
4887                         doy = -1,
4888                         literal = false,
4889                         date,
4890                         // Check whether a format character is doubled
4891                         lookAhead = function(match) {
4892                                 var matches = (iFormat + 1 < format.length && format.charAt(iFormat + 1) === match);
4893                                 if (matches) {
4894                                         iFormat++;
4895                                 }
4896                                 return matches;
4897                         },
4898                         // Extract a number from the string value
4899                         getNumber = function(match) {
4900                                 var isDoubled = lookAhead(match),
4901                                         size = (match === "@" ? 14 : (match === "!" ? 20 :
4902                                         (match === "y" && isDoubled ? 4 : (match === "o" ? 3 : 2)))),
4903                                         minSize = (match === "y" ? size : 1),
4904                                         digits = new RegExp("^\\d{" + minSize + "," + size + "}"),
4905                                         num = value.substring(iValue).match(digits);
4906                                 if (!num) {
4907                                         throw "Missing number at position " + iValue;
4908                                 }
4909                                 iValue += num[0].length;
4910                                 return parseInt(num[0], 10);
4911                         },
4912                         // Extract a name from the string value and convert to an index
4913                         getName = function(match, shortNames, longNames) {
4914                                 var index = -1,
4915                                         names = $.map(lookAhead(match) ? longNames : shortNames, function (v, k) {
4916                                                 return [ [k, v] ];
4917                                         }).sort(function (a, b) {
4918                                                 return -(a[1].length - b[1].length);
4919                                         });
4920
4921                                 $.each(names, function (i, pair) {
4922                                         var name = pair[1];
4923                                         if (value.substr(iValue, name.length).toLowerCase() === name.toLowerCase()) {
4924                                                 index = pair[0];
4925                                                 iValue += name.length;
4926                                                 return false;
4927                                         }
4928                                 });
4929                                 if (index !== -1) {
4930                                         return index + 1;
4931                                 } else {
4932                                         throw "Unknown name at position " + iValue;
4933                                 }
4934                         },
4935                         // Confirm that a literal character matches the string value
4936                         checkLiteral = function() {
4937                                 if (value.charAt(iValue) !== format.charAt(iFormat)) {
4938                                         throw "Unexpected literal at position " + iValue;
4939                                 }
4940                                 iValue++;
4941                         };
4942
4943                 for (iFormat = 0; iFormat < format.length; iFormat++) {
4944                         if (literal) {
4945                                 if (format.charAt(iFormat) === "'" && !lookAhead("'")) {
4946                                         literal = false;
4947                                 } else {
4948                                         checkLiteral();
4949                                 }
4950                         } else {
4951                                 switch (format.charAt(iFormat)) {
4952                                         case "d":
4953                                                 day = getNumber("d");
4954                                                 break;
4955                                         case "D":
4956                                                 getName("D", dayNamesShort, dayNames);
4957                                                 break;
4958                                         case "o":
4959                                                 doy = getNumber("o");
4960                                                 break;
4961                                         case "m":
4962                                                 month = getNumber("m");
4963                                                 break;
4964                                         case "M":
4965                                                 month = getName("M", monthNamesShort, monthNames);
4966                                                 break;
4967                                         case "y":
4968                                                 year = getNumber("y");
4969                                                 break;
4970                                         case "@":
4971                                                 date = new Date(getNumber("@"));
4972                                                 year = date.getFullYear();
4973                                                 month = date.getMonth() + 1;
4974                                                 day = date.getDate();
4975                                                 break;
4976                                         case "!":
4977                                                 date = new Date((getNumber("!") - this._ticksTo1970) / 10000);
4978                                                 year = date.getFullYear();
4979                                                 month = date.getMonth() + 1;
4980                                                 day = date.getDate();
4981                                                 break;
4982                                         case "'":
4983                                                 if (lookAhead("'")){
4984                                                         checkLiteral();
4985                                                 } else {
4986                                                         literal = true;
4987                                                 }
4988                                                 break;
4989                                         default:
4990                                                 checkLiteral();
4991                                 }
4992                         }
4993                 }
4994
4995                 if (iValue < value.length){
4996                         extra = value.substr(iValue);
4997                         if (!/^\s+/.test(extra)) {
4998                                 throw "Extra/unparsed characters found in date: " + extra;
4999                         }
5000                 }
5001
5002                 if (year === -1) {
5003                         year = new Date().getFullYear();
5004                 } else if (year < 100) {
5005                         year += new Date().getFullYear() - new Date().getFullYear() % 100 +
5006                                 (year <= shortYearCutoff ? 0 : -100);
5007                 }
5008
5009                 if (doy > -1) {
5010                         month = 1;
5011                         day = doy;
5012                         do {
5013                                 dim = this._getDaysInMonth(year, month - 1);
5014                                 if (day <= dim) {
5015                                         break;
5016                                 }
5017                                 month++;
5018                                 day -= dim;
5019                         } while (true);
5020                 }
5021
5022                 date = this._daylightSavingAdjust(new Date(year, month - 1, day));
5023                 if (date.getFullYear() !== year || date.getMonth() + 1 !== month || date.getDate() !== day) {
5024                         throw "Invalid date"; // E.g. 31/02/00
5025                 }
5026                 return date;
5027         },
5028
5029         /* Standard date formats. */
5030         ATOM: "yy-mm-dd", // RFC 3339 (ISO 8601)
5031         COOKIE: "D, dd M yy",
5032         ISO_8601: "yy-mm-dd",
5033         RFC_822: "D, d M y",
5034         RFC_850: "DD, dd-M-y",
5035         RFC_1036: "D, d M y",
5036         RFC_1123: "D, d M yy",
5037         RFC_2822: "D, d M yy",
5038         RSS: "D, d M y", // RFC 822
5039         TICKS: "!",
5040         TIMESTAMP: "@",
5041         W3C: "yy-mm-dd", // ISO 8601
5042
5043         _ticksTo1970: (((1970 - 1) * 365 + Math.floor(1970 / 4) - Math.floor(1970 / 100) +
5044                 Math.floor(1970 / 400)) * 24 * 60 * 60 * 10000000),
5045
5046         /* Format a date object into a string value.
5047          * The format can be combinations of the following:
5048          * d  - day of month (no leading zero)
5049          * dd - day of month (two digit)
5050          * o  - day of year (no leading zeros)
5051          * oo - day of year (three digit)
5052          * D  - day name short
5053          * DD - day name long
5054          * m  - month of year (no leading zero)
5055          * mm - month of year (two digit)
5056          * M  - month name short
5057          * MM - month name long
5058          * y  - year (two digit)
5059          * yy - year (four digit)
5060          * @ - Unix timestamp (ms since 01/01/1970)
5061          * ! - Windows ticks (100ns since 01/01/0001)
5062          * "..." - literal text
5063          * '' - single quote
5064          *
5065          * @param  format string - the desired format of the date
5066          * @param  date Date - the date value to format
5067          * @param  settings Object - attributes include:
5068          *                                      dayNamesShort   string[7] - abbreviated names of the days from Sunday (optional)
5069          *                                      dayNames                string[7] - names of the days from Sunday (optional)
5070          *                                      monthNamesShort string[12] - abbreviated names of the months (optional)
5071          *                                      monthNames              string[12] - names of the months (optional)
5072          * @return  string - the date in the above format
5073          */
5074         formatDate: function (format, date, settings) {
5075                 if (!date) {
5076                         return "";
5077                 }
5078
5079                 var iFormat,
5080                         dayNamesShort = (settings ? settings.dayNamesShort : null) || this._defaults.dayNamesShort,
5081                         dayNames = (settings ? settings.dayNames : null) || this._defaults.dayNames,
5082                         monthNamesShort = (settings ? settings.monthNamesShort : null) || this._defaults.monthNamesShort,
5083                         monthNames = (settings ? settings.monthNames : null) || this._defaults.monthNames,
5084                         // Check whether a format character is doubled
5085                         lookAhead = function(match) {
5086                                 var matches = (iFormat + 1 < format.length && format.charAt(iFormat + 1) === match);
5087                                 if (matches) {
5088                                         iFormat++;
5089                                 }
5090                                 return matches;
5091                         },
5092                         // Format a number, with leading zero if necessary
5093                         formatNumber = function(match, value, len) {
5094                                 var num = "" + value;
5095                                 if (lookAhead(match)) {
5096                                         while (num.length < len) {
5097                                                 num = "0" + num;
5098                                         }
5099                                 }
5100                                 return num;
5101                         },
5102                         // Format a name, short or long as requested
5103                         formatName = function(match, value, shortNames, longNames) {
5104                                 return (lookAhead(match) ? longNames[value] : shortNames[value]);
5105                         },
5106                         output = "",
5107                         literal = false;
5108
5109                 if (date) {
5110                         for (iFormat = 0; iFormat < format.length; iFormat++) {
5111                                 if (literal) {
5112                                         if (format.charAt(iFormat) === "'" && !lookAhead("'")) {
5113                                                 literal = false;
5114                                         } else {
5115                                                 output += format.charAt(iFormat);
5116                                         }
5117                                 } else {
5118                                         switch (format.charAt(iFormat)) {
5119                                                 case "d":
5120                                                         output += formatNumber("d", date.getDate(), 2);
5121                                                         break;
5122                                                 case "D":
5123                                                         output += formatName("D", date.getDay(), dayNamesShort, dayNames);
5124                                                         break;
5125                                                 case "o":
5126                                                         output += formatNumber("o",
5127                                                                 Math.round((new Date(date.getFullYear(), date.getMonth(), date.getDate()).getTime() - new Date(date.getFullYear(), 0, 0).getTime()) / 86400000), 3);
5128                                                         break;
5129                                                 case "m":
5130                                                         output += formatNumber("m", date.getMonth() + 1, 2);
5131                                                         break;
5132                                                 case "M":
5133                                                         output += formatName("M", date.getMonth(), monthNamesShort, monthNames);
5134                                                         break;
5135                                                 case "y":
5136                                                         output += (lookAhead("y") ? date.getFullYear() :
5137                                                                 (date.getYear() % 100 < 10 ? "0" : "") + date.getYear() % 100);
5138                                                         break;
5139                                                 case "@":
5140                                                         output += date.getTime();
5141                                                         break;
5142                                                 case "!":
5143                                                         output += date.getTime() * 10000 + this._ticksTo1970;
5144                                                         break;
5145                                                 case "'":
5146                                                         if (lookAhead("'")) {
5147                                                                 output += "'";
5148                                                         } else {
5149                                                                 literal = true;
5150                                                         }
5151                                                         break;
5152                                                 default:
5153                                                         output += format.charAt(iFormat);
5154                                         }
5155                                 }
5156                         }
5157                 }
5158                 return output;
5159         },
5160
5161         /* Extract all possible characters from the date format. */
5162         _possibleChars: function (format) {
5163                 var iFormat,
5164                         chars = "",
5165                         literal = false,
5166                         // Check whether a format character is doubled
5167                         lookAhead = function(match) {
5168                                 var matches = (iFormat + 1 < format.length && format.charAt(iFormat + 1) === match);
5169                                 if (matches) {
5170                                         iFormat++;
5171                                 }
5172                                 return matches;
5173                         };
5174
5175                 for (iFormat = 0; iFormat < format.length; iFormat++) {
5176                         if (literal) {
5177                                 if (format.charAt(iFormat) === "'" && !lookAhead("'")) {
5178                                         literal = false;
5179                                 } else {
5180                                         chars += format.charAt(iFormat);
5181                                 }
5182                         } else {
5183                                 switch (format.charAt(iFormat)) {
5184                                         case "d": case "m": case "y": case "@":
5185                                                 chars += "0123456789";
5186                                                 break;
5187                                         case "D": case "M":
5188                                                 return null; // Accept anything
5189                                         case "'":
5190                                                 if (lookAhead("'")) {
5191                                                         chars += "'";
5192                                                 } else {
5193                                                         literal = true;
5194                                                 }
5195                                                 break;
5196                                         default:
5197                                                 chars += format.charAt(iFormat);
5198                                 }
5199                         }
5200                 }
5201                 return chars;
5202         },
5203
5204         /* Get a setting value, defaulting if necessary. */
5205         _get: function(inst, name) {
5206                 return inst.settings[name] !== undefined ?
5207                         inst.settings[name] : this._defaults[name];
5208         },
5209
5210         /* Parse existing date and initialise date picker. */
5211         _setDateFromField: function(inst, noDefault) {
5212                 if (inst.input.val() === inst.lastVal) {
5213                         return;
5214                 }
5215
5216                 var dateFormat = this._get(inst, "dateFormat"),
5217                         dates = inst.lastVal = inst.input ? inst.input.val() : null,
5218                         defaultDate = this._getDefaultDate(inst),
5219                         date = defaultDate,
5220                         settings = this._getFormatConfig(inst);
5221
5222                 try {
5223                         date = this.parseDate(dateFormat, dates, settings) || defaultDate;
5224                 } catch (event) {
5225                         dates = (noDefault ? "" : dates);
5226                 }
5227                 inst.selectedDay = date.getDate();
5228                 inst.drawMonth = inst.selectedMonth = date.getMonth();
5229                 inst.drawYear = inst.selectedYear = date.getFullYear();
5230                 inst.currentDay = (dates ? date.getDate() : 0);
5231                 inst.currentMonth = (dates ? date.getMonth() : 0);
5232                 inst.currentYear = (dates ? date.getFullYear() : 0);
5233                 this._adjustInstDate(inst);
5234         },
5235
5236         /* Retrieve the default date shown on opening. */
5237         _getDefaultDate: function(inst) {
5238                 return this._restrictMinMax(inst,
5239                         this._determineDate(inst, this._get(inst, "defaultDate"), new Date()));
5240         },
5241
5242         /* A date may be specified as an exact value or a relative one. */
5243         _determineDate: function(inst, date, defaultDate) {
5244                 var offsetNumeric = function(offset) {
5245                                 var date = new Date();
5246                                 date.setDate(date.getDate() + offset);
5247                                 return date;
5248                         },
5249                         offsetString = function(offset) {
5250                                 try {
5251                                         return $.datepicker.parseDate($.datepicker._get(inst, "dateFormat"),
5252                                                 offset, $.datepicker._getFormatConfig(inst));
5253                                 }
5254                                 catch (e) {
5255                                         // Ignore
5256                                 }
5257
5258                                 var date = (offset.toLowerCase().match(/^c/) ?
5259                                         $.datepicker._getDate(inst) : null) || new Date(),
5260                                         year = date.getFullYear(),
5261                                         month = date.getMonth(),
5262                                         day = date.getDate(),
5263                                         pattern = /([+\-]?[0-9]+)\s*(d|D|w|W|m|M|y|Y)?/g,
5264                                         matches = pattern.exec(offset);
5265
5266                                 while (matches) {
5267                                         switch (matches[2] || "d") {
5268                                                 case "d" : case "D" :
5269                                                         day += parseInt(matches[1],10); break;
5270                                                 case "w" : case "W" :
5271                                                         day += parseInt(matches[1],10) * 7; break;
5272                                                 case "m" : case "M" :
5273                                                         month += parseInt(matches[1],10);
5274                                                         day = Math.min(day, $.datepicker._getDaysInMonth(year, month));
5275                                                         break;
5276                                                 case "y": case "Y" :
5277                                                         year += parseInt(matches[1],10);
5278                                                         day = Math.min(day, $.datepicker._getDaysInMonth(year, month));
5279                                                         break;
5280                                         }
5281                                         matches = pattern.exec(offset);
5282                                 }
5283                                 return new Date(year, month, day);
5284                         },
5285                         newDate = (date == null || date === "" ? defaultDate : (typeof date === "string" ? offsetString(date) :
5286                                 (typeof date === "number" ? (isNaN(date) ? defaultDate : offsetNumeric(date)) : new Date(date.getTime()))));
5287
5288                 newDate = (newDate && newDate.toString() === "Invalid Date" ? defaultDate : newDate);
5289                 if (newDate) {
5290                         newDate.setHours(0);
5291                         newDate.setMinutes(0);
5292                         newDate.setSeconds(0);
5293                         newDate.setMilliseconds(0);
5294                 }
5295                 return this._daylightSavingAdjust(newDate);
5296         },
5297
5298         /* Handle switch to/from daylight saving.
5299          * Hours may be non-zero on daylight saving cut-over:
5300          * > 12 when midnight changeover, but then cannot generate
5301          * midnight datetime, so jump to 1AM, otherwise reset.
5302          * @param  date  (Date) the date to check
5303          * @return  (Date) the corrected date
5304          */
5305         _daylightSavingAdjust: function(date) {
5306                 if (!date) {
5307                         return null;
5308                 }
5309                 date.setHours(date.getHours() > 12 ? date.getHours() + 2 : 0);
5310                 return date;
5311         },
5312
5313         /* Set the date(s) directly. */
5314         _setDate: function(inst, date, noChange) {
5315                 var clear = !date,
5316                         origMonth = inst.selectedMonth,
5317                         origYear = inst.selectedYear,
5318                         newDate = this._restrictMinMax(inst, this._determineDate(inst, date, new Date()));
5319
5320                 inst.selectedDay = inst.currentDay = newDate.getDate();
5321                 inst.drawMonth = inst.selectedMonth = inst.currentMonth = newDate.getMonth();
5322                 inst.drawYear = inst.selectedYear = inst.currentYear = newDate.getFullYear();
5323                 if ((origMonth !== inst.selectedMonth || origYear !== inst.selectedYear) && !noChange) {
5324                         this._notifyChange(inst);
5325                 }
5326                 this._adjustInstDate(inst);
5327                 if (inst.input) {
5328                         inst.input.val(clear ? "" : this._formatDate(inst));
5329                 }
5330         },
5331
5332         /* Retrieve the date(s) directly. */
5333         _getDate: function(inst) {
5334                 var startDate = (!inst.currentYear || (inst.input && inst.input.val() === "") ? null :
5335                         this._daylightSavingAdjust(new Date(
5336                         inst.currentYear, inst.currentMonth, inst.currentDay)));
5337                         return startDate;
5338         },
5339
5340         /* Attach the onxxx handlers.  These are declared statically so
5341          * they work with static code transformers like Caja.
5342          */
5343         _attachHandlers: function(inst) {
5344                 var stepMonths = this._get(inst, "stepMonths"),
5345                         id = "#" + inst.id.replace( /\\\\/g, "\\" );
5346                 inst.dpDiv.find("[data-handler]").map(function () {
5347                         var handler = {
5348                                 prev: function () {
5349                                         $.datepicker._adjustDate(id, -stepMonths, "M");
5350                                 },
5351                                 next: function () {
5352                                         $.datepicker._adjustDate(id, +stepMonths, "M");
5353                                 },
5354                                 hide: function () {
5355                                         $.datepicker._hideDatepicker();
5356                                 },
5357                                 today: function () {
5358                                         $.datepicker._gotoToday(id);
5359                                 },
5360                                 selectDay: function () {
5361                                         $.datepicker._selectDay(id, +this.getAttribute("data-month"), +this.getAttribute("data-year"), this);
5362                                         return false;
5363                                 },
5364                                 selectMonth: function () {
5365                                         $.datepicker._selectMonthYear(id, this, "M");
5366                                         return false;
5367                                 },
5368                                 selectYear: function () {
5369                                         $.datepicker._selectMonthYear(id, this, "Y");
5370                                         return false;
5371                                 }
5372                         };
5373                         $(this).bind(this.getAttribute("data-event"), handler[this.getAttribute("data-handler")]);
5374                 });
5375         },
5376
5377         /* Generate the HTML for the current state of the date picker. */
5378         _generateHTML: function(inst) {
5379                 var maxDraw, prevText, prev, nextText, next, currentText, gotoDate,
5380                         controls, buttonPanel, firstDay, showWeek, dayNames, dayNamesMin,
5381                         monthNames, monthNamesShort, beforeShowDay, showOtherMonths,
5382                         selectOtherMonths, defaultDate, html, dow, row, group, col, selectedDate,
5383                         cornerClass, calender, thead, day, daysInMonth, leadDays, curRows, numRows,
5384                         printDate, dRow, tbody, daySettings, otherMonth, unselectable,
5385                         tempDate = new Date(),
5386                         today = this._daylightSavingAdjust(
5387                                 new Date(tempDate.getFullYear(), tempDate.getMonth(), tempDate.getDate())), // clear time
5388                         isRTL = this._get(inst, "isRTL"),
5389                         showButtonPanel = this._get(inst, "showButtonPanel"),
5390                         hideIfNoPrevNext = this._get(inst, "hideIfNoPrevNext"),
5391                         navigationAsDateFormat = this._get(inst, "navigationAsDateFormat"),
5392                         numMonths = this._getNumberOfMonths(inst),
5393                         showCurrentAtPos = this._get(inst, "showCurrentAtPos"),
5394                         stepMonths = this._get(inst, "stepMonths"),
5395                         isMultiMonth = (numMonths[0] !== 1 || numMonths[1] !== 1),
5396                         currentDate = this._daylightSavingAdjust((!inst.currentDay ? new Date(9999, 9, 9) :
5397                                 new Date(inst.currentYear, inst.currentMonth, inst.currentDay))),
5398                         minDate = this._getMinMaxDate(inst, "min"),
5399                         maxDate = this._getMinMaxDate(inst, "max"),
5400                         drawMonth = inst.drawMonth - showCurrentAtPos,
5401                         drawYear = inst.drawYear;
5402
5403                 if (drawMonth < 0) {
5404                         drawMonth += 12;
5405                         drawYear--;
5406                 }
5407                 if (maxDate) {
5408                         maxDraw = this._daylightSavingAdjust(new Date(maxDate.getFullYear(),
5409                                 maxDate.getMonth() - (numMonths[0] * numMonths[1]) + 1, maxDate.getDate()));
5410                         maxDraw = (minDate && maxDraw < minDate ? minDate : maxDraw);
5411                         while (this._daylightSavingAdjust(new Date(drawYear, drawMonth, 1)) > maxDraw) {
5412                                 drawMonth--;
5413                                 if (drawMonth < 0) {
5414                                         drawMonth = 11;
5415                                         drawYear--;
5416                                 }
5417                         }
5418                 }
5419                 inst.drawMonth = drawMonth;
5420                 inst.drawYear = drawYear;
5421
5422                 prevText = this._get(inst, "prevText");
5423                 prevText = (!navigationAsDateFormat ? prevText : this.formatDate(prevText,
5424                         this._daylightSavingAdjust(new Date(drawYear, drawMonth - stepMonths, 1)),
5425                         this._getFormatConfig(inst)));
5426
5427                 prev = (this._canAdjustMonth(inst, -1, drawYear, drawMonth) ?
5428                         "<a class='ui-datepicker-prev ui-corner-all' data-handler='prev' data-event='click'" +
5429                         " title='" + prevText + "'><span class='ui-icon ui-icon-circle-triangle-" + ( isRTL ? "e" : "w") + "'>" + prevText + "</span></a>" :
5430                         (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>"));
5431
5432                 nextText = this._get(inst, "nextText");
5433                 nextText = (!navigationAsDateFormat ? nextText : this.formatDate(nextText,
5434                         this._daylightSavingAdjust(new Date(drawYear, drawMonth + stepMonths, 1)),
5435                         this._getFormatConfig(inst)));
5436
5437                 next = (this._canAdjustMonth(inst, +1, drawYear, drawMonth) ?
5438                         "<a class='ui-datepicker-next ui-corner-all' data-handler='next' data-event='click'" +
5439                         " title='" + nextText + "'><span class='ui-icon ui-icon-circle-triangle-" + ( isRTL ? "w" : "e") + "'>" + nextText + "</span></a>" :
5440                         (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>"));
5441
5442                 currentText = this._get(inst, "currentText");
5443                 gotoDate = (this._get(inst, "gotoCurrent") && inst.currentDay ? currentDate : today);
5444                 currentText = (!navigationAsDateFormat ? currentText :
5445                         this.formatDate(currentText, gotoDate, this._getFormatConfig(inst)));
5446
5447                 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'>" +
5448                         this._get(inst, "closeText") + "</button>" : "");
5449
5450                 buttonPanel = (showButtonPanel) ? "<div class='ui-datepicker-buttonpane ui-widget-content'>" + (isRTL ? controls : "") +
5451                         (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'" +
5452                         ">" + currentText + "</button>" : "") + (isRTL ? "" : controls) + "</div>" : "";
5453
5454                 firstDay = parseInt(this._get(inst, "firstDay"),10);
5455                 firstDay = (isNaN(firstDay) ? 0 : firstDay);
5456
5457                 showWeek = this._get(inst, "showWeek");
5458                 dayNames = this._get(inst, "dayNames");
5459                 dayNamesMin = this._get(inst, "dayNamesMin");
5460                 monthNames = this._get(inst, "monthNames");
5461                 monthNamesShort = this._get(inst, "monthNamesShort");
5462                 beforeShowDay = this._get(inst, "beforeShowDay");
5463                 showOtherMonths = this._get(inst, "showOtherMonths");
5464                 selectOtherMonths = this._get(inst, "selectOtherMonths");
5465                 defaultDate = this._getDefaultDate(inst);
5466                 html = "";
5467                 dow;
5468                 for (row = 0; row < numMonths[0]; row++) {
5469                         group = "";
5470                         this.maxRows = 4;
5471                         for (col = 0; col < numMonths[1]; col++) {
5472                                 selectedDate = this._daylightSavingAdjust(new Date(drawYear, drawMonth, inst.selectedDay));
5473                                 cornerClass = " ui-corner-all";
5474                                 calender = "";
5475                                 if (isMultiMonth) {
5476                                         calender += "<div class='ui-datepicker-group";
5477                                         if (numMonths[1] > 1) {
5478                                                 switch (col) {
5479                                                         case 0: calender += " ui-datepicker-group-first";
5480                                                                 cornerClass = " ui-corner-" + (isRTL ? "right" : "left"); break;
5481                                                         case numMonths[1]-1: calender += " ui-datepicker-group-last";
5482                                                                 cornerClass = " ui-corner-" + (isRTL ? "left" : "right"); break;
5483                                                         default: calender += " ui-datepicker-group-middle"; cornerClass = ""; break;
5484                                                 }
5485                                         }
5486                                         calender += "'>";
5487                                 }
5488                                 calender += "<div class='ui-datepicker-header ui-widget-header ui-helper-clearfix" + cornerClass + "'>" +
5489                                         (/all|left/.test(cornerClass) && row === 0 ? (isRTL ? next : prev) : "") +
5490                                         (/all|right/.test(cornerClass) && row === 0 ? (isRTL ? prev : next) : "") +
5491                                         this._generateMonthYearHeader(inst, drawMonth, drawYear, minDate, maxDate,
5492                                         row > 0 || col > 0, monthNames, monthNamesShort) + // draw month headers
5493                                         "</div><table class='ui-datepicker-calendar'><thead>" +
5494                                         "<tr>";
5495                                 thead = (showWeek ? "<th class='ui-datepicker-week-col'>" + this._get(inst, "weekHeader") + "</th>" : "");
5496                                 for (dow = 0; dow < 7; dow++) { // days of the week
5497                                         day = (dow + firstDay) % 7;
5498                                         thead += "<th scope='col'" + ((dow + firstDay + 6) % 7 >= 5 ? " class='ui-datepicker-week-end'" : "") + ">" +
5499                                                 "<span title='" + dayNames[day] + "'>" + dayNamesMin[day] + "</span></th>";
5500                                 }
5501                                 calender += thead + "</tr></thead><tbody>";
5502                                 daysInMonth = this._getDaysInMonth(drawYear, drawMonth);
5503                                 if (drawYear === inst.selectedYear && drawMonth === inst.selectedMonth) {
5504                                         inst.selectedDay = Math.min(inst.selectedDay, daysInMonth);
5505                                 }
5506                                 leadDays = (this._getFirstDayOfMonth(drawYear, drawMonth) - firstDay + 7) % 7;
5507                                 curRows = Math.ceil((leadDays + daysInMonth) / 7); // calculate the number of rows to generate
5508                                 numRows = (isMultiMonth ? this.maxRows > curRows ? this.maxRows : curRows : curRows); //If multiple months, use the higher number of rows (see #7043)
5509                                 this.maxRows = numRows;
5510                                 printDate = this._daylightSavingAdjust(new Date(drawYear, drawMonth, 1 - leadDays));
5511                                 for (dRow = 0; dRow < numRows; dRow++) { // create date picker rows
5512                                         calender += "<tr>";
5513                                         tbody = (!showWeek ? "" : "<td class='ui-datepicker-week-col'>" +
5514                                                 this._get(inst, "calculateWeek")(printDate) + "</td>");
5515                                         for (dow = 0; dow < 7; dow++) { // create date picker days
5516                                                 daySettings = (beforeShowDay ?
5517                                                         beforeShowDay.apply((inst.input ? inst.input[0] : null), [printDate]) : [true, ""]);
5518                                                 otherMonth = (printDate.getMonth() !== drawMonth);
5519                                                 unselectable = (otherMonth && !selectOtherMonths) || !daySettings[0] ||
5520                                                         (minDate && printDate < minDate) || (maxDate && printDate > maxDate);
5521                                                 tbody += "<td class='" +
5522                                                         ((dow + firstDay + 6) % 7 >= 5 ? " ui-datepicker-week-end" : "") + // highlight weekends
5523                                                         (otherMonth ? " ui-datepicker-other-month" : "") + // highlight days from other months
5524                                                         ((printDate.getTime() === selectedDate.getTime() && drawMonth === inst.selectedMonth && inst._keyEvent) || // user pressed key
5525                                                         (defaultDate.getTime() === printDate.getTime() && defaultDate.getTime() === selectedDate.getTime()) ?
5526                                                         // or defaultDate is current printedDate and defaultDate is selectedDate
5527                                                         " " + this._dayOverClass : "") + // highlight selected day
5528                                                         (unselectable ? " " + this._unselectableClass + " ui-state-disabled": "") +  // highlight unselectable days
5529                                                         (otherMonth && !showOtherMonths ? "" : " " + daySettings[1] + // highlight custom dates
5530                                                         (printDate.getTime() === currentDate.getTime() ? " " + this._currentClass : "") + // highlight selected day
5531                                                         (printDate.getTime() === today.getTime() ? " ui-datepicker-today" : "")) + "'" + // highlight today (if different)
5532                                                         ((!otherMonth || showOtherMonths) && daySettings[2] ? " title='" + daySettings[2].replace(/'/g, "&#39;") + "'" : "") + // cell title
5533                                                         (unselectable ? "" : " data-handler='selectDay' data-event='click' data-month='" + printDate.getMonth() + "' data-year='" + printDate.getFullYear() + "'") + ">" + // actions
5534                                                         (otherMonth && !showOtherMonths ? "&#xa0;" : // display for other months
5535                                                         (unselectable ? "<span class='ui-state-default'>" + printDate.getDate() + "</span>" : "<a class='ui-state-default" +
5536                                                         (printDate.getTime() === today.getTime() ? " ui-state-highlight" : "") +
5537                                                         (printDate.getTime() === currentDate.getTime() ? " ui-state-active" : "") + // highlight selected day
5538                                                         (otherMonth ? " ui-priority-secondary" : "") + // distinguish dates from other months
5539                                                         "' href='#'>" + printDate.getDate() + "</a>")) + "</td>"; // display selectable date
5540                                                 printDate.setDate(printDate.getDate() + 1);
5541                                                 printDate = this._daylightSavingAdjust(printDate);
5542                                         }
5543                                         calender += tbody + "</tr>";
5544                                 }
5545                                 drawMonth++;
5546                                 if (drawMonth > 11) {
5547                                         drawMonth = 0;
5548                                         drawYear++;
5549                                 }
5550                                 calender += "</tbody></table>" + (isMultiMonth ? "</div>" +
5551                                                         ((numMonths[0] > 0 && col === numMonths[1]-1) ? "<div class='ui-datepicker-row-break'></div>" : "") : "");
5552                                 group += calender;
5553                         }
5554                         html += group;
5555                 }
5556                 html += buttonPanel;
5557                 inst._keyEvent = false;
5558                 return html;
5559         },
5560
5561         /* Generate the month and year header. */
5562         _generateMonthYearHeader: function(inst, drawMonth, drawYear, minDate, maxDate,
5563                         secondary, monthNames, monthNamesShort) {
5564
5565                 var inMinYear, inMaxYear, month, years, thisYear, determineYear, year, endYear,
5566                         changeMonth = this._get(inst, "changeMonth"),
5567                         changeYear = this._get(inst, "changeYear"),
5568                         showMonthAfterYear = this._get(inst, "showMonthAfterYear"),
5569                         html = "<div class='ui-datepicker-title'>",
5570                         monthHtml = "";
5571
5572                 // month selection
5573                 if (secondary || !changeMonth) {
5574                         monthHtml += "<span class='ui-datepicker-month'>" + monthNames[drawMonth] + "</span>";
5575                 } else {
5576                         inMinYear = (minDate && minDate.getFullYear() === drawYear);
5577                         inMaxYear = (maxDate && maxDate.getFullYear() === drawYear);
5578                         monthHtml += "<select class='ui-datepicker-month' data-handler='selectMonth' data-event='change'>";
5579                         for ( month = 0; month < 12; month++) {
5580                                 if ((!inMinYear || month >= minDate.getMonth()) && (!inMaxYear || month <= maxDate.getMonth())) {
5581                                         monthHtml += "<option value='" + month + "'" +
5582                                                 (month === drawMonth ? " selected='selected'" : "") +
5583                                                 ">" + monthNamesShort[month] + "</option>";
5584                                 }
5585                         }
5586                         monthHtml += "</select>";
5587                 }
5588
5589                 if (!showMonthAfterYear) {
5590                         html += monthHtml + (secondary || !(changeMonth && changeYear) ? "&#xa0;" : "");
5591                 }
5592
5593                 // year selection
5594                 if ( !inst.yearshtml ) {
5595                         inst.yearshtml = "";
5596                         if (secondary || !changeYear) {
5597                                 html += "<span class='ui-datepicker-year'>" + drawYear + "</span>";
5598                         } else {
5599                                 // determine range of years to display
5600                                 years = this._get(inst, "yearRange").split(":");
5601                                 thisYear = new Date().getFullYear();
5602                                 determineYear = function(value) {
5603                                         var year = (value.match(/c[+\-].*/) ? drawYear + parseInt(value.substring(1), 10) :
5604                                                 (value.match(/[+\-].*/) ? thisYear + parseInt(value, 10) :
5605                                                 parseInt(value, 10)));
5606                                         return (isNaN(year) ? thisYear : year);
5607                                 };
5608                                 year = determineYear(years[0]);
5609                                 endYear = Math.max(year, determineYear(years[1] || ""));
5610                                 year = (minDate ? Math.max(year, minDate.getFullYear()) : year);
5611                                 endYear = (maxDate ? Math.min(endYear, maxDate.getFullYear()) : endYear);
5612                                 inst.yearshtml += "<select class='ui-datepicker-year' data-handler='selectYear' data-event='change'>";
5613                                 for (; year <= endYear; year++) {
5614                                         inst.yearshtml += "<option value='" + year + "'" +
5615                                                 (year === drawYear ? " selected='selected'" : "") +
5616                                                 ">" + year + "</option>";
5617                                 }
5618                                 inst.yearshtml += "</select>";
5619
5620                                 html += inst.yearshtml;
5621                                 inst.yearshtml = null;
5622                         }
5623                 }
5624
5625                 html += this._get(inst, "yearSuffix");
5626                 if (showMonthAfterYear) {
5627                         html += (secondary || !(changeMonth && changeYear) ? "&#xa0;" : "") + monthHtml;
5628                 }
5629                 html += "</div>"; // Close datepicker_header
5630                 return html;
5631         },
5632
5633         /* Adjust one of the date sub-fields. */
5634         _adjustInstDate: function(inst, offset, period) {
5635                 var year = inst.drawYear + (period === "Y" ? offset : 0),
5636                         month = inst.drawMonth + (period === "M" ? offset : 0),
5637                         day = Math.min(inst.selectedDay, this._getDaysInMonth(year, month)) + (period === "D" ? offset : 0),
5638                         date = this._restrictMinMax(inst, this._daylightSavingAdjust(new Date(year, month, day)));
5639
5640                 inst.selectedDay = date.getDate();
5641                 inst.drawMonth = inst.selectedMonth = date.getMonth();
5642                 inst.drawYear = inst.selectedYear = date.getFullYear();
5643                 if (period === "M" || period === "Y") {
5644                         this._notifyChange(inst);
5645                 }
5646         },
5647
5648         /* Ensure a date is within any min/max bounds. */
5649         _restrictMinMax: function(inst, date) {
5650                 var minDate = this._getMinMaxDate(inst, "min"),
5651                         maxDate = this._getMinMaxDate(inst, "max"),
5652                         newDate = (minDate && date < minDate ? minDate : date);
5653                 return (maxDate && newDate > maxDate ? maxDate : newDate);
5654         },
5655
5656         /* Notify change of month/year. */
5657         _notifyChange: function(inst) {
5658                 var onChange = this._get(inst, "onChangeMonthYear");
5659                 if (onChange) {
5660                         onChange.apply((inst.input ? inst.input[0] : null),
5661                                 [inst.selectedYear, inst.selectedMonth + 1, inst]);
5662                 }
5663         },
5664
5665         /* Determine the number of months to show. */
5666         _getNumberOfMonths: function(inst) {
5667                 var numMonths = this._get(inst, "numberOfMonths");
5668                 return (numMonths == null ? [1, 1] : (typeof numMonths === "number" ? [1, numMonths] : numMonths));
5669         },
5670
5671         /* Determine the current maximum date - ensure no time components are set. */
5672         _getMinMaxDate: function(inst, minMax) {
5673                 return this._determineDate(inst, this._get(inst, minMax + "Date"), null);
5674         },
5675
5676         /* Find the number of days in a given month. */
5677         _getDaysInMonth: function(year, month) {
5678                 return 32 - this._daylightSavingAdjust(new Date(year, month, 32)).getDate();
5679         },
5680
5681         /* Find the day of the week of the first of a month. */
5682         _getFirstDayOfMonth: function(year, month) {
5683                 return new Date(year, month, 1).getDay();
5684         },
5685
5686         /* Determines if we should allow a "next/prev" month display change. */
5687         _canAdjustMonth: function(inst, offset, curYear, curMonth) {
5688                 var numMonths = this._getNumberOfMonths(inst),
5689                         date = this._daylightSavingAdjust(new Date(curYear,
5690                         curMonth + (offset < 0 ? offset : numMonths[0] * numMonths[1]), 1));
5691
5692                 if (offset < 0) {
5693                         date.setDate(this._getDaysInMonth(date.getFullYear(), date.getMonth()));
5694                 }
5695                 return this._isInRange(inst, date);
5696         },
5697
5698         /* Is the given date in the accepted range? */
5699         _isInRange: function(inst, date) {
5700                 var yearSplit, currentYear,
5701                         minDate = this._getMinMaxDate(inst, "min"),
5702                         maxDate = this._getMinMaxDate(inst, "max"),
5703                         minYear = null,
5704                         maxYear = null,
5705                         years = this._get(inst, "yearRange");
5706                         if (years){
5707                                 yearSplit = years.split(":");
5708                                 currentYear = new Date().getFullYear();
5709                                 minYear = parseInt(yearSplit[0], 10);
5710                                 maxYear = parseInt(yearSplit[1], 10);
5711                                 if ( yearSplit[0].match(/[+\-].*/) ) {
5712                                         minYear += currentYear;
5713                                 }
5714                                 if ( yearSplit[1].match(/[+\-].*/) ) {
5715                                         maxYear += currentYear;
5716                                 }
5717                         }
5718
5719                 return ((!minDate || date.getTime() >= minDate.getTime()) &&
5720                         (!maxDate || date.getTime() <= maxDate.getTime()) &&
5721                         (!minYear || date.getFullYear() >= minYear) &&
5722                         (!maxYear || date.getFullYear() <= maxYear));
5723         },
5724
5725         /* Provide the configuration settings for formatting/parsing. */
5726         _getFormatConfig: function(inst) {
5727                 var shortYearCutoff = this._get(inst, "shortYearCutoff");
5728                 shortYearCutoff = (typeof shortYearCutoff !== "string" ? shortYearCutoff :
5729                         new Date().getFullYear() % 100 + parseInt(shortYearCutoff, 10));
5730                 return {shortYearCutoff: shortYearCutoff,
5731                         dayNamesShort: this._get(inst, "dayNamesShort"), dayNames: this._get(inst, "dayNames"),
5732                         monthNamesShort: this._get(inst, "monthNamesShort"), monthNames: this._get(inst, "monthNames")};
5733         },
5734
5735         /* Format the given date for display. */
5736         _formatDate: function(inst, day, month, year) {
5737                 if (!day) {
5738                         inst.currentDay = inst.selectedDay;
5739                         inst.currentMonth = inst.selectedMonth;
5740                         inst.currentYear = inst.selectedYear;
5741                 }
5742                 var date = (day ? (typeof day === "object" ? day :
5743                         this._daylightSavingAdjust(new Date(year, month, day))) :
5744                         this._daylightSavingAdjust(new Date(inst.currentYear, inst.currentMonth, inst.currentDay)));
5745                 return this.formatDate(this._get(inst, "dateFormat"), date, this._getFormatConfig(inst));
5746         }
5747 });
5748
5749 /*
5750  * Bind hover events for datepicker elements.
5751  * Done via delegate so the binding only occurs once in the lifetime of the parent div.
5752  * Global datepicker_instActive, set by _updateDatepicker allows the handlers to find their way back to the active picker.
5753  */
5754 function datepicker_bindHover(dpDiv) {
5755         var selector = "button, .ui-datepicker-prev, .ui-datepicker-next, .ui-datepicker-calendar td a";
5756         return dpDiv.delegate(selector, "mouseout", function() {
5757                         $(this).removeClass("ui-state-hover");
5758                         if (this.className.indexOf("ui-datepicker-prev") !== -1) {
5759                                 $(this).removeClass("ui-datepicker-prev-hover");
5760                         }
5761                         if (this.className.indexOf("ui-datepicker-next") !== -1) {
5762                                 $(this).removeClass("ui-datepicker-next-hover");
5763                         }
5764                 })
5765                 .delegate( selector, "mouseover", datepicker_handleMouseover );
5766 }
5767
5768 function datepicker_handleMouseover() {
5769         if (!$.datepicker._isDisabledDatepicker( datepicker_instActive.inline? datepicker_instActive.dpDiv.parent()[0] : datepicker_instActive.input[0])) {
5770                 $(this).parents(".ui-datepicker-calendar").find("a").removeClass("ui-state-hover");
5771                 $(this).addClass("ui-state-hover");
5772                 if (this.className.indexOf("ui-datepicker-prev") !== -1) {
5773                         $(this).addClass("ui-datepicker-prev-hover");
5774                 }
5775                 if (this.className.indexOf("ui-datepicker-next") !== -1) {
5776                         $(this).addClass("ui-datepicker-next-hover");
5777                 }
5778         }
5779 }
5780
5781 /* jQuery extend now ignores nulls! */
5782 function datepicker_extendRemove(target, props) {
5783         $.extend(target, props);
5784         for (var name in props) {
5785                 if (props[name] == null) {
5786                         target[name] = props[name];
5787                 }
5788         }
5789         return target;
5790 }
5791
5792 /* Invoke the datepicker functionality.
5793    @param  options  string - a command, optionally followed by additional parameters or
5794                                         Object - settings for attaching new datepicker functionality
5795    @return  jQuery object */
5796 $.fn.datepicker = function(options){
5797
5798         /* Verify an empty collection wasn't passed - Fixes #6976 */
5799         if ( !this.length ) {
5800                 return this;
5801         }
5802
5803         /* Initialise the date picker. */
5804         if (!$.datepicker.initialized) {
5805                 $(document).mousedown($.datepicker._checkExternalClick);
5806                 $.datepicker.initialized = true;
5807         }
5808
5809         /* Append datepicker main container to body if not exist. */
5810         if ($("#"+$.datepicker._mainDivId).length === 0) {
5811                 $("body").append($.datepicker.dpDiv);
5812         }
5813
5814         var otherArgs = Array.prototype.slice.call(arguments, 1);
5815         if (typeof options === "string" && (options === "isDisabled" || options === "getDate" || options === "widget")) {
5816                 return $.datepicker["_" + options + "Datepicker"].
5817                         apply($.datepicker, [this[0]].concat(otherArgs));
5818         }
5819         if (options === "option" && arguments.length === 2 && typeof arguments[1] === "string") {
5820                 return $.datepicker["_" + options + "Datepicker"].
5821                         apply($.datepicker, [this[0]].concat(otherArgs));
5822         }
5823         return this.each(function() {
5824                 typeof options === "string" ?
5825                         $.datepicker["_" + options + "Datepicker"].
5826                                 apply($.datepicker, [this].concat(otherArgs)) :
5827                         $.datepicker._attachDatepicker(this, options);
5828         });
5829 };
5830
5831 $.datepicker = new Datepicker(); // singleton instance
5832 $.datepicker.initialized = false;
5833 $.datepicker.uuid = new Date().getTime();
5834 $.datepicker.version = "1.11.4";
5835
5836 var datepicker = $.datepicker;
5837
5838
5839 /*!
5840  * jQuery UI Draggable 1.11.4
5841  * http://jqueryui.com
5842  *
5843  * Copyright jQuery Foundation and other contributors
5844  * Released under the MIT license.
5845  * http://jquery.org/license
5846  *
5847  * http://api.jqueryui.com/draggable/
5848  */
5849
5850
5851 $.widget("ui.draggable", $.ui.mouse, {
5852         version: "1.11.4",
5853         widgetEventPrefix: "drag",
5854         options: {
5855                 addClasses: true,
5856                 appendTo: "parent",
5857                 axis: false,
5858                 connectToSortable: false,
5859                 containment: false,
5860                 cursor: "auto",
5861                 cursorAt: false,
5862                 grid: false,
5863                 handle: false,
5864                 helper: "original",
5865                 iframeFix: false,
5866                 opacity: false,
5867                 refreshPositions: false,
5868                 revert: false,
5869                 revertDuration: 500,
5870                 scope: "default",
5871                 scroll: true,
5872                 scrollSensitivity: 20,
5873                 scrollSpeed: 20,
5874                 snap: false,
5875                 snapMode: "both",
5876                 snapTolerance: 20,
5877                 stack: false,
5878                 zIndex: false,
5879
5880                 // callbacks
5881                 drag: null,
5882                 start: null,
5883                 stop: null
5884         },
5885         _create: function() {
5886
5887                 if ( this.options.helper === "original" ) {
5888                         this._setPositionRelative();
5889                 }
5890                 if (this.options.addClasses){
5891                         this.element.addClass("ui-draggable");
5892                 }
5893                 if (this.options.disabled){
5894                         this.element.addClass("ui-draggable-disabled");
5895                 }
5896                 this._setHandleClassName();
5897
5898                 this._mouseInit();
5899         },
5900
5901         _setOption: function( key, value ) {
5902                 this._super( key, value );
5903                 if ( key === "handle" ) {
5904                         this._removeHandleClassName();
5905                         this._setHandleClassName();
5906                 }
5907         },
5908
5909         _destroy: function() {
5910                 if ( ( this.helper || this.element ).is( ".ui-draggable-dragging" ) ) {
5911                         this.destroyOnClear = true;
5912                         return;
5913                 }
5914                 this.element.removeClass( "ui-draggable ui-draggable-dragging ui-draggable-disabled" );
5915                 this._removeHandleClassName();
5916                 this._mouseDestroy();
5917         },
5918
5919         _mouseCapture: function(event) {
5920                 var o = this.options;
5921
5922                 this._blurActiveElement( event );
5923
5924                 // among others, prevent a drag on a resizable-handle
5925                 if (this.helper || o.disabled || $(event.target).closest(".ui-resizable-handle").length > 0) {
5926                         return false;
5927                 }
5928
5929                 //Quit if we're not on a valid handle
5930                 this.handle = this._getHandle(event);
5931                 if (!this.handle) {
5932                         return false;
5933                 }
5934
5935                 this._blockFrames( o.iframeFix === true ? "iframe" : o.iframeFix );
5936
5937                 return true;
5938
5939         },
5940
5941         _blockFrames: function( selector ) {
5942                 this.iframeBlocks = this.document.find( selector ).map(function() {
5943                         var iframe = $( this );
5944
5945                         return $( "<div>" )
5946                                 .css( "position", "absolute" )
5947                                 .appendTo( iframe.parent() )
5948                                 .outerWidth( iframe.outerWidth() )
5949                                 .outerHeight( iframe.outerHeight() )
5950                                 .offset( iframe.offset() )[ 0 ];
5951                 });
5952         },
5953
5954         _unblockFrames: function() {
5955                 if ( this.iframeBlocks ) {
5956                         this.iframeBlocks.remove();
5957                         delete this.iframeBlocks;
5958                 }
5959         },
5960
5961         _blurActiveElement: function( event ) {
5962                 var document = this.document[ 0 ];
5963
5964                 // Only need to blur if the event occurred on the draggable itself, see #10527
5965                 if ( !this.handleElement.is( event.target ) ) {
5966                         return;
5967                 }
5968
5969                 // support: IE9
5970                 // IE9 throws an "Unspecified error" accessing document.activeElement from an <iframe>
5971                 try {
5972
5973                         // Support: IE9, IE10
5974                         // If the <body> is blurred, IE will switch windows, see #9520
5975                         if ( document.activeElement && document.activeElement.nodeName.toLowerCase() !== "body" ) {
5976
5977                                 // Blur any element that currently has focus, see #4261
5978                                 $( document.activeElement ).blur();
5979                         }
5980                 } catch ( error ) {}
5981         },
5982
5983         _mouseStart: function(event) {
5984
5985                 var o = this.options;
5986
5987                 //Create and append the visible helper
5988                 this.helper = this._createHelper(event);
5989
5990                 this.helper.addClass("ui-draggable-dragging");
5991
5992                 //Cache the helper size
5993                 this._cacheHelperProportions();
5994
5995                 //If ddmanager is used for droppables, set the global draggable
5996                 if ($.ui.ddmanager) {
5997                         $.ui.ddmanager.current = this;
5998                 }
5999
6000                 /*
6001                  * - Position generation -
6002                  * This block generates everything position related - it's the core of draggables.
6003                  */
6004
6005                 //Cache the margins of the original element
6006                 this._cacheMargins();
6007
6008                 //Store the helper's css position
6009                 this.cssPosition = this.helper.css( "position" );
6010                 this.scrollParent = this.helper.scrollParent( true );
6011                 this.offsetParent = this.helper.offsetParent();
6012                 this.hasFixedAncestor = this.helper.parents().filter(function() {
6013                                 return $( this ).css( "position" ) === "fixed";
6014                         }).length > 0;
6015
6016                 //The element's absolute position on the page minus margins
6017                 this.positionAbs = this.element.offset();
6018                 this._refreshOffsets( event );
6019
6020                 //Generate the original position
6021                 this.originalPosition = this.position = this._generatePosition( event, false );
6022                 this.originalPageX = event.pageX;
6023                 this.originalPageY = event.pageY;
6024
6025                 //Adjust the mouse offset relative to the helper if "cursorAt" is supplied
6026                 (o.cursorAt && this._adjustOffsetFromHelper(o.cursorAt));
6027
6028                 //Set a containment if given in the options
6029                 this._setContainment();
6030
6031                 //Trigger event + callbacks
6032                 if (this._trigger("start", event) === false) {
6033                         this._clear();
6034                         return false;
6035                 }
6036
6037                 //Recache the helper size
6038                 this._cacheHelperProportions();
6039
6040                 //Prepare the droppable offsets
6041                 if ($.ui.ddmanager && !o.dropBehaviour) {
6042                         $.ui.ddmanager.prepareOffsets(this, event);
6043                 }
6044
6045                 // Reset helper's right/bottom css if they're set and set explicit width/height instead
6046                 // as this prevents resizing of elements with right/bottom set (see #7772)
6047                 this._normalizeRightBottom();
6048
6049                 this._mouseDrag(event, true); //Execute the drag once - this causes the helper not to be visible before getting its correct position
6050
6051                 //If the ddmanager is used for droppables, inform the manager that dragging has started (see #5003)
6052                 if ( $.ui.ddmanager ) {
6053                         $.ui.ddmanager.dragStart(this, event);
6054                 }
6055
6056                 return true;
6057         },
6058
6059         _refreshOffsets: function( event ) {
6060                 this.offset = {
6061                         top: this.positionAbs.top - this.margins.top,
6062                         left: this.positionAbs.left - this.margins.left,
6063                         scroll: false,
6064                         parent: this._getParentOffset(),
6065                         relative: this._getRelativeOffset()
6066                 };
6067
6068                 this.offset.click = {
6069                         left: event.pageX - this.offset.left,
6070                         top: event.pageY - this.offset.top
6071                 };
6072         },
6073
6074         _mouseDrag: function(event, noPropagation) {
6075                 // reset any necessary cached properties (see #5009)
6076                 if ( this.hasFixedAncestor ) {
6077                         this.offset.parent = this._getParentOffset();
6078                 }
6079
6080                 //Compute the helpers position
6081                 this.position = this._generatePosition( event, true );
6082                 this.positionAbs = this._convertPositionTo("absolute");
6083
6084                 //Call plugins and callbacks and use the resulting position if something is returned
6085                 if (!noPropagation) {
6086                         var ui = this._uiHash();
6087                         if (this._trigger("drag", event, ui) === false) {
6088                                 this._mouseUp({});
6089                                 return false;
6090                         }
6091                         this.position = ui.position;
6092                 }
6093
6094                 this.helper[ 0 ].style.left = this.position.left + "px";
6095                 this.helper[ 0 ].style.top = this.position.top + "px";
6096
6097                 if ($.ui.ddmanager) {
6098                         $.ui.ddmanager.drag(this, event);
6099                 }
6100
6101                 return false;
6102         },
6103
6104         _mouseStop: function(event) {
6105
6106                 //If we are using droppables, inform the manager about the drop
6107                 var that = this,
6108                         dropped = false;
6109                 if ($.ui.ddmanager && !this.options.dropBehaviour) {
6110                         dropped = $.ui.ddmanager.drop(this, event);
6111                 }
6112
6113                 //if a drop comes from outside (a sortable)
6114                 if (this.dropped) {
6115                         dropped = this.dropped;
6116                         this.dropped = false;
6117                 }
6118
6119                 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))) {
6120                         $(this.helper).animate(this.originalPosition, parseInt(this.options.revertDuration, 10), function() {
6121                                 if (that._trigger("stop", event) !== false) {
6122                                         that._clear();
6123                                 }
6124                         });
6125                 } else {
6126                         if (this._trigger("stop", event) !== false) {
6127                                 this._clear();
6128                         }
6129                 }
6130
6131                 return false;
6132         },
6133
6134         _mouseUp: function( event ) {
6135                 this._unblockFrames();
6136
6137                 //If the ddmanager is used for droppables, inform the manager that dragging has stopped (see #5003)
6138                 if ( $.ui.ddmanager ) {
6139                         $.ui.ddmanager.dragStop(this, event);
6140                 }
6141
6142                 // Only need to focus if the event occurred on the draggable itself, see #10527
6143                 if ( this.handleElement.is( event.target ) ) {
6144                         // The interaction is over; whether or not the click resulted in a drag, focus the element
6145                         this.element.focus();
6146                 }
6147
6148                 return $.ui.mouse.prototype._mouseUp.call(this, event);
6149         },
6150
6151         cancel: function() {
6152
6153                 if (this.helper.is(".ui-draggable-dragging")) {
6154                         this._mouseUp({});
6155                 } else {
6156                         this._clear();
6157                 }
6158
6159                 return this;
6160
6161         },
6162
6163         _getHandle: function(event) {
6164                 return this.options.handle ?
6165                         !!$( event.target ).closest( this.element.find( this.options.handle ) ).length :
6166                         true;
6167         },
6168
6169         _setHandleClassName: function() {
6170                 this.handleElement = this.options.handle ?
6171                         this.element.find( this.options.handle ) : this.element;
6172                 this.handleElement.addClass( "ui-draggable-handle" );
6173         },
6174
6175         _removeHandleClassName: function() {
6176                 this.handleElement.removeClass( "ui-draggable-handle" );
6177         },
6178
6179         _createHelper: function(event) {
6180
6181                 var o = this.options,
6182                         helperIsFunction = $.isFunction( o.helper ),
6183                         helper = helperIsFunction ?
6184                                 $( o.helper.apply( this.element[ 0 ], [ event ] ) ) :
6185                                 ( o.helper === "clone" ?
6186                                         this.element.clone().removeAttr( "id" ) :
6187                                         this.element );
6188
6189                 if (!helper.parents("body").length) {
6190                         helper.appendTo((o.appendTo === "parent" ? this.element[0].parentNode : o.appendTo));
6191                 }
6192
6193                 // http://bugs.jqueryui.com/ticket/9446
6194                 // a helper function can return the original element
6195                 // which wouldn't have been set to relative in _create
6196                 if ( helperIsFunction && helper[ 0 ] === this.element[ 0 ] ) {
6197                         this._setPositionRelative();
6198                 }
6199
6200                 if (helper[0] !== this.element[0] && !(/(fixed|absolute)/).test(helper.css("position"))) {
6201                         helper.css("position", "absolute");
6202                 }
6203
6204                 return helper;
6205
6206         },
6207
6208         _setPositionRelative: function() {
6209                 if ( !( /^(?:r|a|f)/ ).test( this.element.css( "position" ) ) ) {
6210                         this.element[ 0 ].style.position = "relative";
6211                 }
6212         },
6213
6214         _adjustOffsetFromHelper: function(obj) {
6215                 if (typeof obj === "string") {
6216                         obj = obj.split(" ");
6217                 }
6218                 if ($.isArray(obj)) {
6219                         obj = { left: +obj[0], top: +obj[1] || 0 };
6220                 }
6221                 if ("left" in obj) {
6222                         this.offset.click.left = obj.left + this.margins.left;
6223                 }
6224                 if ("right" in obj) {
6225                         this.offset.click.left = this.helperProportions.width - obj.right + this.margins.left;
6226                 }
6227                 if ("top" in obj) {
6228                         this.offset.click.top = obj.top + this.margins.top;
6229                 }
6230                 if ("bottom" in obj) {
6231                         this.offset.click.top = this.helperProportions.height - obj.bottom + this.margins.top;
6232                 }
6233         },
6234
6235         _isRootNode: function( element ) {
6236                 return ( /(html|body)/i ).test( element.tagName ) || element === this.document[ 0 ];
6237         },
6238
6239         _getParentOffset: function() {
6240
6241                 //Get the offsetParent and cache its position
6242                 var po = this.offsetParent.offset(),
6243                         document = this.document[ 0 ];
6244
6245                 // This is a special case where we need to modify a offset calculated on start, since the following happened:
6246                 // 1. The position of the helper is absolute, so it's position is calculated based on the next positioned parent
6247                 // 2. The actual offset parent is a child of the scroll parent, and the scroll parent isn't the document, which means that
6248                 //    the scroll is included in the initial calculation of the offset of the parent, and never recalculated upon drag
6249                 if (this.cssPosition === "absolute" && this.scrollParent[0] !== document && $.contains(this.scrollParent[0], this.offsetParent[0])) {
6250                         po.left += this.scrollParent.scrollLeft();
6251                         po.top += this.scrollParent.scrollTop();
6252                 }
6253
6254                 if ( this._isRootNode( this.offsetParent[ 0 ] ) ) {
6255                         po = { top: 0, left: 0 };
6256                 }
6257
6258                 return {
6259                         top: po.top + (parseInt(this.offsetParent.css("borderTopWidth"), 10) || 0),
6260                         left: po.left + (parseInt(this.offsetParent.css("borderLeftWidth"), 10) || 0)
6261                 };
6262
6263         },
6264
6265         _getRelativeOffset: function() {
6266                 if ( this.cssPosition !== "relative" ) {
6267                         return { top: 0, left: 0 };
6268                 }
6269
6270                 var p = this.element.position(),
6271                         scrollIsRootNode = this._isRootNode( this.scrollParent[ 0 ] );
6272
6273                 return {
6274                         top: p.top - ( parseInt(this.helper.css( "top" ), 10) || 0 ) + ( !scrollIsRootNode ? this.scrollParent.scrollTop() : 0 ),
6275                         left: p.left - ( parseInt(this.helper.css( "left" ), 10) || 0 ) + ( !scrollIsRootNode ? this.scrollParent.scrollLeft() : 0 )
6276                 };
6277
6278         },
6279
6280         _cacheMargins: function() {
6281                 this.margins = {
6282                         left: (parseInt(this.element.css("marginLeft"), 10) || 0),
6283                         top: (parseInt(this.element.css("marginTop"), 10) || 0),
6284                         right: (parseInt(this.element.css("marginRight"), 10) || 0),
6285                         bottom: (parseInt(this.element.css("marginBottom"), 10) || 0)
6286                 };
6287         },
6288
6289         _cacheHelperProportions: function() {
6290                 this.helperProportions = {
6291                         width: this.helper.outerWidth(),
6292                         height: this.helper.outerHeight()
6293                 };
6294         },
6295
6296         _setContainment: function() {
6297
6298                 var isUserScrollable, c, ce,
6299                         o = this.options,
6300                         document = this.document[ 0 ];
6301
6302                 this.relativeContainer = null;
6303
6304                 if ( !o.containment ) {
6305                         this.containment = null;
6306                         return;
6307                 }
6308
6309                 if ( o.containment === "window" ) {
6310                         this.containment = [
6311                                 $( window ).scrollLeft() - this.offset.relative.left - this.offset.parent.left,
6312                                 $( window ).scrollTop() - this.offset.relative.top - this.offset.parent.top,
6313                                 $( window ).scrollLeft() + $( window ).width() - this.helperProportions.width - this.margins.left,
6314                                 $( window ).scrollTop() + ( $( window ).height() || document.body.parentNode.scrollHeight ) - this.helperProportions.height - this.margins.top
6315                         ];
6316                         return;
6317                 }
6318
6319                 if ( o.containment === "document") {
6320                         this.containment = [
6321                                 0,
6322                                 0,
6323                                 $( document ).width() - this.helperProportions.width - this.margins.left,
6324                                 ( $( document ).height() || document.body.parentNode.scrollHeight ) - this.helperProportions.height - this.margins.top
6325                         ];
6326                         return;
6327                 }
6328
6329                 if ( o.containment.constructor === Array ) {
6330                         this.containment = o.containment;
6331                         return;
6332                 }
6333
6334                 if ( o.containment === "parent" ) {
6335                         o.containment = this.helper[ 0 ].parentNode;
6336                 }
6337
6338                 c = $( o.containment );
6339                 ce = c[ 0 ];
6340
6341                 if ( !ce ) {
6342                         return;
6343                 }
6344
6345                 isUserScrollable = /(scroll|auto)/.test( c.css( "overflow" ) );
6346
6347                 this.containment = [
6348                         ( parseInt( c.css( "borderLeftWidth" ), 10 ) || 0 ) + ( parseInt( c.css( "paddingLeft" ), 10 ) || 0 ),
6349                         ( parseInt( c.css( "borderTopWidth" ), 10 ) || 0 ) + ( parseInt( c.css( "paddingTop" ), 10 ) || 0 ),
6350                         ( isUserScrollable ? Math.max( ce.scrollWidth, ce.offsetWidth ) : ce.offsetWidth ) -
6351                                 ( parseInt( c.css( "borderRightWidth" ), 10 ) || 0 ) -
6352                                 ( parseInt( c.css( "paddingRight" ), 10 ) || 0 ) -
6353                                 this.helperProportions.width -
6354                                 this.margins.left -
6355                                 this.margins.right,
6356                         ( isUserScrollable ? Math.max( ce.scrollHeight, ce.offsetHeight ) : ce.offsetHeight ) -
6357                                 ( parseInt( c.css( "borderBottomWidth" ), 10 ) || 0 ) -
6358                                 ( parseInt( c.css( "paddingBottom" ), 10 ) || 0 ) -
6359                                 this.helperProportions.height -
6360                                 this.margins.top -
6361                                 this.margins.bottom
6362                 ];
6363                 this.relativeContainer = c;
6364         },
6365
6366         _convertPositionTo: function(d, pos) {
6367
6368                 if (!pos) {
6369                         pos = this.position;
6370                 }
6371
6372                 var mod = d === "absolute" ? 1 : -1,
6373                         scrollIsRootNode = this._isRootNode( this.scrollParent[ 0 ] );
6374
6375                 return {
6376                         top: (
6377                                 pos.top +                                                                                                                               // The absolute mouse position
6378                                 this.offset.relative.top * mod +                                                                                // Only for relative positioned nodes: Relative offset from element to offset parent
6379                                 this.offset.parent.top * mod -                                                                          // The offsetParent's offset without borders (offset + border)
6380                                 ( ( this.cssPosition === "fixed" ? -this.offset.scroll.top : ( scrollIsRootNode ? 0 : this.offset.scroll.top ) ) * mod)
6381                         ),
6382                         left: (
6383                                 pos.left +                                                                                                                              // The absolute mouse position
6384                                 this.offset.relative.left * mod +                                                                               // Only for relative positioned nodes: Relative offset from element to offset parent
6385                                 this.offset.parent.left * mod   -                                                                               // The offsetParent's offset without borders (offset + border)
6386                                 ( ( this.cssPosition === "fixed" ? -this.offset.scroll.left : ( scrollIsRootNode ? 0 : this.offset.scroll.left ) ) * mod)
6387                         )
6388                 };
6389
6390         },
6391
6392         _generatePosition: function( event, constrainPosition ) {
6393
6394                 var containment, co, top, left,
6395                         o = this.options,
6396                         scrollIsRootNode = this._isRootNode( this.scrollParent[ 0 ] ),
6397                         pageX = event.pageX,
6398                         pageY = event.pageY;
6399
6400                 // Cache the scroll
6401                 if ( !scrollIsRootNode || !this.offset.scroll ) {
6402                         this.offset.scroll = {
6403                                 top: this.scrollParent.scrollTop(),
6404                                 left: this.scrollParent.scrollLeft()
6405                         };
6406                 }
6407
6408                 /*
6409                  * - Position constraining -
6410                  * Constrain the position to a mix of grid, containment.
6411                  */
6412
6413                 // If we are not dragging yet, we won't check for options
6414                 if ( constrainPosition ) {
6415                         if ( this.containment ) {
6416                                 if ( this.relativeContainer ){
6417                                         co = this.relativeContainer.offset();
6418                                         containment = [
6419                                                 this.containment[ 0 ] + co.left,
6420                                                 this.containment[ 1 ] + co.top,
6421                                                 this.containment[ 2 ] + co.left,
6422                                                 this.containment[ 3 ] + co.top
6423                                         ];
6424                                 } else {
6425                                         containment = this.containment;
6426                                 }
6427
6428                                 if (event.pageX - this.offset.click.left < containment[0]) {
6429                                         pageX = containment[0] + this.offset.click.left;
6430                                 }
6431                                 if (event.pageY - this.offset.click.top < containment[1]) {
6432                                         pageY = containment[1] + this.offset.click.top;
6433                                 }
6434                                 if (event.pageX - this.offset.click.left > containment[2]) {
6435                                         pageX = containment[2] + this.offset.click.left;
6436                                 }
6437                                 if (event.pageY - this.offset.click.top > containment[3]) {
6438                                         pageY = containment[3] + this.offset.click.top;
6439                                 }
6440                         }
6441
6442                         if (o.grid) {
6443                                 //Check for grid elements set to 0 to prevent divide by 0 error causing invalid argument errors in IE (see ticket #6950)
6444                                 top = o.grid[1] ? this.originalPageY + Math.round((pageY - this.originalPageY) / o.grid[1]) * o.grid[1] : this.originalPageY;
6445                                 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;
6446
6447                                 left = o.grid[0] ? this.originalPageX + Math.round((pageX - this.originalPageX) / o.grid[0]) * o.grid[0] : this.originalPageX;
6448                                 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;
6449                         }
6450
6451                         if ( o.axis === "y" ) {
6452                                 pageX = this.originalPageX;
6453                         }
6454
6455                         if ( o.axis === "x" ) {
6456                                 pageY = this.originalPageY;
6457                         }
6458                 }
6459
6460                 return {
6461                         top: (
6462                                 pageY -                                                                                                                                 // The absolute mouse position
6463                                 this.offset.click.top   -                                                                                               // Click offset (relative to the element)
6464                                 this.offset.relative.top -                                                                                              // Only for relative positioned nodes: Relative offset from element to offset parent
6465                                 this.offset.parent.top +                                                                                                // The offsetParent's offset without borders (offset + border)
6466                                 ( this.cssPosition === "fixed" ? -this.offset.scroll.top : ( scrollIsRootNode ? 0 : this.offset.scroll.top ) )
6467                         ),
6468                         left: (
6469                                 pageX -                                                                                                                                 // The absolute mouse position
6470                                 this.offset.click.left -                                                                                                // Click offset (relative to the element)
6471                                 this.offset.relative.left -                                                                                             // Only for relative positioned nodes: Relative offset from element to offset parent
6472                                 this.offset.parent.left +                                                                                               // The offsetParent's offset without borders (offset + border)
6473                                 ( this.cssPosition === "fixed" ? -this.offset.scroll.left : ( scrollIsRootNode ? 0 : this.offset.scroll.left ) )
6474                         )
6475                 };
6476
6477         },
6478
6479         _clear: function() {
6480                 this.helper.removeClass("ui-draggable-dragging");
6481                 if (this.helper[0] !== this.element[0] && !this.cancelHelperRemoval) {
6482                         this.helper.remove();
6483                 }
6484                 this.helper = null;
6485                 this.cancelHelperRemoval = false;
6486                 if ( this.destroyOnClear ) {
6487                         this.destroy();
6488                 }
6489         },
6490
6491         _normalizeRightBottom: function() {
6492                 if ( this.options.axis !== "y" && this.helper.css( "right" ) !== "auto" ) {
6493                         this.helper.width( this.helper.width() );
6494                         this.helper.css( "right", "auto" );
6495                 }
6496                 if ( this.options.axis !== "x" && this.helper.css( "bottom" ) !== "auto" ) {
6497                         this.helper.height( this.helper.height() );
6498                         this.helper.css( "bottom", "auto" );
6499                 }
6500         },
6501
6502         // From now on bulk stuff - mainly helpers
6503
6504         _trigger: function( type, event, ui ) {
6505                 ui = ui || this._uiHash();
6506                 $.ui.plugin.call( this, type, [ event, ui, this ], true );
6507
6508                 // Absolute position and offset (see #6884 ) have to be recalculated after plugins
6509                 if ( /^(drag|start|stop)/.test( type ) ) {
6510                         this.positionAbs = this._convertPositionTo( "absolute" );
6511                         ui.offset = this.positionAbs;
6512                 }
6513                 return $.Widget.prototype._trigger.call( this, type, event, ui );
6514         },
6515
6516         plugins: {},
6517
6518         _uiHash: function() {
6519                 return {
6520                         helper: this.helper,
6521                         position: this.position,
6522                         originalPosition: this.originalPosition,
6523                         offset: this.positionAbs
6524                 };
6525         }
6526
6527 });
6528
6529 $.ui.plugin.add( "draggable", "connectToSortable", {
6530         start: function( event, ui, draggable ) {
6531                 var uiSortable = $.extend( {}, ui, {
6532                         item: draggable.element
6533                 });
6534
6535                 draggable.sortables = [];
6536                 $( draggable.options.connectToSortable ).each(function() {
6537                         var sortable = $( this ).sortable( "instance" );
6538
6539                         if ( sortable && !sortable.options.disabled ) {
6540                                 draggable.sortables.push( sortable );
6541
6542                                 // refreshPositions is called at drag start to refresh the containerCache
6543                                 // which is used in drag. This ensures it's initialized and synchronized
6544                                 // with any changes that might have happened on the page since initialization.
6545                                 sortable.refreshPositions();
6546                                 sortable._trigger("activate", event, uiSortable);
6547                         }
6548                 });
6549         },
6550         stop: function( event, ui, draggable ) {
6551                 var uiSortable = $.extend( {}, ui, {
6552                         item: draggable.element
6553                 });
6554
6555                 draggable.cancelHelperRemoval = false;
6556
6557                 $.each( draggable.sortables, function() {
6558                         var sortable = this;
6559
6560                         if ( sortable.isOver ) {
6561                                 sortable.isOver = 0;
6562
6563                                 // Allow this sortable to handle removing the helper
6564                                 draggable.cancelHelperRemoval = true;
6565                                 sortable.cancelHelperRemoval = false;
6566
6567                                 // Use _storedCSS To restore properties in the sortable,
6568                                 // as this also handles revert (#9675) since the draggable
6569                                 // may have modified them in unexpected ways (#8809)
6570                                 sortable._storedCSS = {
6571                                         position: sortable.placeholder.css( "position" ),
6572                                         top: sortable.placeholder.css( "top" ),
6573                                         left: sortable.placeholder.css( "left" )
6574                                 };
6575
6576                                 sortable._mouseStop(event);
6577
6578                                 // Once drag has ended, the sortable should return to using
6579                                 // its original helper, not the shared helper from draggable
6580                                 sortable.options.helper = sortable.options._helper;
6581                         } else {
6582                                 // Prevent this Sortable from removing the helper.
6583                                 // However, don't set the draggable to remove the helper
6584                                 // either as another connected Sortable may yet handle the removal.
6585                                 sortable.cancelHelperRemoval = true;
6586
6587                                 sortable._trigger( "deactivate", event, uiSortable );
6588                         }
6589                 });
6590         },
6591         drag: function( event, ui, draggable ) {
6592                 $.each( draggable.sortables, function() {
6593                         var innermostIntersecting = false,
6594                                 sortable = this;
6595
6596                         // Copy over variables that sortable's _intersectsWith uses
6597                         sortable.positionAbs = draggable.positionAbs;
6598                         sortable.helperProportions = draggable.helperProportions;
6599                         sortable.offset.click = draggable.offset.click;
6600
6601                         if ( sortable._intersectsWith( sortable.containerCache ) ) {
6602                                 innermostIntersecting = true;
6603
6604                                 $.each( draggable.sortables, function() {
6605                                         // Copy over variables that sortable's _intersectsWith uses
6606                                         this.positionAbs = draggable.positionAbs;
6607                                         this.helperProportions = draggable.helperProportions;
6608                                         this.offset.click = draggable.offset.click;
6609
6610                                         if ( this !== sortable &&
6611                                                         this._intersectsWith( this.containerCache ) &&
6612                                                         $.contains( sortable.element[ 0 ], this.element[ 0 ] ) ) {
6613                                                 innermostIntersecting = false;
6614                                         }
6615
6616                                         return innermostIntersecting;
6617                                 });
6618                         }
6619
6620                         if ( innermostIntersecting ) {
6621                                 // If it intersects, we use a little isOver variable and set it once,
6622                                 // so that the move-in stuff gets fired only once.
6623                                 if ( !sortable.isOver ) {
6624                                         sortable.isOver = 1;
6625
6626                                         // Store draggable's parent in case we need to reappend to it later.
6627                                         draggable._parent = ui.helper.parent();
6628
6629                                         sortable.currentItem = ui.helper
6630                                                 .appendTo( sortable.element )
6631                                                 .data( "ui-sortable-item", true );
6632
6633                                         // Store helper option to later restore it
6634                                         sortable.options._helper = sortable.options.helper;
6635
6636                                         sortable.options.helper = function() {
6637                                                 return ui.helper[ 0 ];
6638                                         };
6639
6640                                         // Fire the start events of the sortable with our passed browser event,
6641                                         // and our own helper (so it doesn't create a new one)
6642                                         event.target = sortable.currentItem[ 0 ];
6643                                         sortable._mouseCapture( event, true );
6644                                         sortable._mouseStart( event, true, true );
6645
6646                                         // Because the browser event is way off the new appended portlet,
6647                                         // modify necessary variables to reflect the changes
6648                                         sortable.offset.click.top = draggable.offset.click.top;
6649                                         sortable.offset.click.left = draggable.offset.click.left;
6650                                         sortable.offset.parent.left -= draggable.offset.parent.left -
6651                                                 sortable.offset.parent.left;
6652                                         sortable.offset.parent.top -= draggable.offset.parent.top -
6653                                                 sortable.offset.parent.top;
6654
6655                                         draggable._trigger( "toSortable", event );
6656
6657                                         // Inform draggable that the helper is in a valid drop zone,
6658                                         // used solely in the revert option to handle "valid/invalid".
6659                                         draggable.dropped = sortable.element;
6660
6661                                         // Need to refreshPositions of all sortables in the case that
6662                                         // adding to one sortable changes the location of the other sortables (#9675)
6663                                         $.each( draggable.sortables, function() {
6664                                                 this.refreshPositions();
6665                                         });
6666
6667                                         // hack so receive/update callbacks work (mostly)
6668                                         draggable.currentItem = draggable.element;
6669                                         sortable.fromOutside = draggable;
6670                                 }
6671
6672                                 if ( sortable.currentItem ) {
6673                                         sortable._mouseDrag( event );
6674                                         // Copy the sortable's position because the draggable's can potentially reflect
6675                                         // a relative position, while sortable is always absolute, which the dragged
6676                                         // element has now become. (#8809)
6677                                         ui.position = sortable.position;
6678                                 }
6679                         } else {
6680                                 // If it doesn't intersect with the sortable, and it intersected before,
6681                                 // we fake the drag stop of the sortable, but make sure it doesn't remove
6682                                 // the helper by using cancelHelperRemoval.
6683                                 if ( sortable.isOver ) {
6684
6685                                         sortable.isOver = 0;
6686                                         sortable.cancelHelperRemoval = true;
6687
6688                                         // Calling sortable's mouseStop would trigger a revert,
6689                                         // so revert must be temporarily false until after mouseStop is called.
6690                                         sortable.options._revert = sortable.options.revert;
6691                                         sortable.options.revert = false;
6692
6693                                         sortable._trigger( "out", event, sortable._uiHash( sortable ) );
6694                                         sortable._mouseStop( event, true );
6695
6696                                         // restore sortable behaviors that were modfied
6697                                         // when the draggable entered the sortable area (#9481)
6698                                         sortable.options.revert = sortable.options._revert;
6699                                         sortable.options.helper = sortable.options._helper;
6700
6701                                         if ( sortable.placeholder ) {
6702                                                 sortable.placeholder.remove();
6703                                         }
6704
6705                                         // Restore and recalculate the draggable's offset considering the sortable
6706                                         // may have modified them in unexpected ways. (#8809, #10669)
6707                                         ui.helper.appendTo( draggable._parent );
6708                                         draggable._refreshOffsets( event );
6709                                         ui.position = draggable._generatePosition( event, true );
6710
6711                                         draggable._trigger( "fromSortable", event );
6712
6713                                         // Inform draggable that the helper is no longer in a valid drop zone
6714                                         draggable.dropped = false;
6715
6716                                         // Need to refreshPositions of all sortables just in case removing
6717                                         // from one sortable changes the location of other sortables (#9675)
6718                                         $.each( draggable.sortables, function() {
6719                                                 this.refreshPositions();
6720                                         });
6721                                 }
6722                         }
6723                 });
6724         }
6725 });
6726
6727 $.ui.plugin.add("draggable", "cursor", {
6728         start: function( event, ui, instance ) {
6729                 var t = $( "body" ),
6730                         o = instance.options;
6731
6732                 if (t.css("cursor")) {
6733                         o._cursor = t.css("cursor");
6734                 }
6735                 t.css("cursor", o.cursor);
6736         },
6737         stop: function( event, ui, instance ) {
6738                 var o = instance.options;
6739                 if (o._cursor) {
6740                         $("body").css("cursor", o._cursor);
6741                 }
6742         }
6743 });
6744
6745 $.ui.plugin.add("draggable", "opacity", {
6746         start: function( event, ui, instance ) {
6747                 var t = $( ui.helper ),
6748                         o = instance.options;
6749                 if (t.css("opacity")) {
6750                         o._opacity = t.css("opacity");
6751                 }
6752                 t.css("opacity", o.opacity);
6753         },
6754         stop: function( event, ui, instance ) {
6755                 var o = instance.options;
6756                 if (o._opacity) {
6757                         $(ui.helper).css("opacity", o._opacity);
6758                 }
6759         }
6760 });
6761
6762 $.ui.plugin.add("draggable", "scroll", {
6763         start: function( event, ui, i ) {
6764                 if ( !i.scrollParentNotHidden ) {
6765                         i.scrollParentNotHidden = i.helper.scrollParent( false );
6766                 }
6767
6768                 if ( i.scrollParentNotHidden[ 0 ] !== i.document[ 0 ] && i.scrollParentNotHidden[ 0 ].tagName !== "HTML" ) {
6769                         i.overflowOffset = i.scrollParentNotHidden.offset();
6770                 }
6771         },
6772         drag: function( event, ui, i  ) {
6773
6774                 var o = i.options,
6775                         scrolled = false,
6776                         scrollParent = i.scrollParentNotHidden[ 0 ],
6777                         document = i.document[ 0 ];
6778
6779                 if ( scrollParent !== document && scrollParent.tagName !== "HTML" ) {
6780                         if ( !o.axis || o.axis !== "x" ) {
6781                                 if ( ( i.overflowOffset.top + scrollParent.offsetHeight ) - event.pageY < o.scrollSensitivity ) {
6782                                         scrollParent.scrollTop = scrolled = scrollParent.scrollTop + o.scrollSpeed;
6783                                 } else if ( event.pageY - i.overflowOffset.top < o.scrollSensitivity ) {
6784                                         scrollParent.scrollTop = scrolled = scrollParent.scrollTop - o.scrollSpeed;
6785                                 }
6786                         }
6787
6788                         if ( !o.axis || o.axis !== "y" ) {
6789                                 if ( ( i.overflowOffset.left + scrollParent.offsetWidth ) - event.pageX < o.scrollSensitivity ) {
6790                                         scrollParent.scrollLeft = scrolled = scrollParent.scrollLeft + o.scrollSpeed;
6791                                 } else if ( event.pageX - i.overflowOffset.left < o.scrollSensitivity ) {
6792                                         scrollParent.scrollLeft = scrolled = scrollParent.scrollLeft - o.scrollSpeed;
6793                                 }
6794                         }
6795
6796                 } else {
6797
6798                         if (!o.axis || o.axis !== "x") {
6799                                 if (event.pageY - $(document).scrollTop() < o.scrollSensitivity) {
6800                                         scrolled = $(document).scrollTop($(document).scrollTop() - o.scrollSpeed);
6801                                 } else if ($(window).height() - (event.pageY - $(document).scrollTop()) < o.scrollSensitivity) {
6802                                         scrolled = $(document).scrollTop($(document).scrollTop() + o.scrollSpeed);
6803                                 }
6804                         }
6805
6806                         if (!o.axis || o.axis !== "y") {
6807                                 if (event.pageX - $(document).scrollLeft() < o.scrollSensitivity) {
6808                                         scrolled = $(document).scrollLeft($(document).scrollLeft() - o.scrollSpeed);
6809                                 } else if ($(window).width() - (event.pageX - $(document).scrollLeft()) < o.scrollSensitivity) {
6810                                         scrolled = $(document).scrollLeft($(document).scrollLeft() + o.scrollSpeed);
6811                                 }
6812                         }
6813
6814                 }
6815
6816                 if (scrolled !== false && $.ui.ddmanager && !o.dropBehaviour) {
6817                         $.ui.ddmanager.prepareOffsets(i, event);
6818                 }
6819
6820         }
6821 });
6822
6823 $.ui.plugin.add("draggable", "snap", {
6824         start: function( event, ui, i ) {
6825
6826                 var o = i.options;
6827
6828                 i.snapElements = [];
6829
6830                 $(o.snap.constructor !== String ? ( o.snap.items || ":data(ui-draggable)" ) : o.snap).each(function() {
6831                         var $t = $(this),
6832                                 $o = $t.offset();
6833                         if (this !== i.element[0]) {
6834                                 i.snapElements.push({
6835                                         item: this,
6836                                         width: $t.outerWidth(), height: $t.outerHeight(),
6837                                         top: $o.top, left: $o.left
6838                                 });
6839                         }
6840                 });
6841
6842         },
6843         drag: function( event, ui, inst ) {
6844
6845                 var ts, bs, ls, rs, l, r, t, b, i, first,
6846                         o = inst.options,
6847                         d = o.snapTolerance,
6848                         x1 = ui.offset.left, x2 = x1 + inst.helperProportions.width,
6849                         y1 = ui.offset.top, y2 = y1 + inst.helperProportions.height;
6850
6851                 for (i = inst.snapElements.length - 1; i >= 0; i--){
6852
6853                         l = inst.snapElements[i].left - inst.margins.left;
6854                         r = l + inst.snapElements[i].width;
6855                         t = inst.snapElements[i].top - inst.margins.top;
6856                         b = t + inst.snapElements[i].height;
6857
6858                         if ( x2 < l - d || x1 > r + d || y2 < t - d || y1 > b + d || !$.contains( inst.snapElements[ i ].item.ownerDocument, inst.snapElements[ i ].item ) ) {
6859                                 if (inst.snapElements[i].snapping) {
6860                                         (inst.options.snap.release && inst.options.snap.release.call(inst.element, event, $.extend(inst._uiHash(), { snapItem: inst.snapElements[i].item })));
6861                                 }
6862                                 inst.snapElements[i].snapping = false;
6863                                 continue;
6864                         }
6865
6866                         if (o.snapMode !== "inner") {
6867                                 ts = Math.abs(t - y2) <= d;
6868                                 bs = Math.abs(b - y1) <= d;
6869                                 ls = Math.abs(l - x2) <= d;
6870                                 rs = Math.abs(r - x1) <= d;
6871                                 if (ts) {
6872                                         ui.position.top = inst._convertPositionTo("relative", { top: t - inst.helperProportions.height, left: 0 }).top;
6873                                 }
6874                                 if (bs) {
6875                                         ui.position.top = inst._convertPositionTo("relative", { top: b, left: 0 }).top;
6876                                 }
6877                                 if (ls) {
6878                                         ui.position.left = inst._convertPositionTo("relative", { top: 0, left: l - inst.helperProportions.width }).left;
6879                                 }
6880                                 if (rs) {
6881                                         ui.position.left = inst._convertPositionTo("relative", { top: 0, left: r }).left;
6882                                 }
6883                         }
6884
6885                         first = (ts || bs || ls || rs);
6886
6887                         if (o.snapMode !== "outer") {
6888                                 ts = Math.abs(t - y1) <= d;
6889                                 bs = Math.abs(b - y2) <= d;
6890                                 ls = Math.abs(l - x1) <= d;
6891                                 rs = Math.abs(r - x2) <= d;
6892                                 if (ts) {
6893                                         ui.position.top = inst._convertPositionTo("relative", { top: t, left: 0 }).top;
6894                                 }
6895                                 if (bs) {
6896                                         ui.position.top = inst._convertPositionTo("relative", { top: b - inst.helperProportions.height, left: 0 }).top;
6897                                 }
6898                                 if (ls) {
6899                                         ui.position.left = inst._convertPositionTo("relative", { top: 0, left: l }).left;
6900                                 }
6901                                 if (rs) {
6902                                         ui.position.left = inst._convertPositionTo("relative", { top: 0, left: r - inst.helperProportions.width }).left;
6903                                 }
6904                         }
6905
6906                         if (!inst.snapElements[i].snapping && (ts || bs || ls || rs || first)) {
6907                                 (inst.options.snap.snap && inst.options.snap.snap.call(inst.element, event, $.extend(inst._uiHash(), { snapItem: inst.snapElements[i].item })));
6908                         }
6909                         inst.snapElements[i].snapping = (ts || bs || ls || rs || first);
6910
6911                 }
6912
6913         }
6914 });
6915
6916 $.ui.plugin.add("draggable", "stack", {
6917         start: function( event, ui, instance ) {
6918                 var min,
6919                         o = instance.options,
6920                         group = $.makeArray($(o.stack)).sort(function(a, b) {
6921                                 return (parseInt($(a).css("zIndex"), 10) || 0) - (parseInt($(b).css("zIndex"), 10) || 0);
6922                         });
6923
6924                 if (!group.length) { return; }
6925
6926                 min = parseInt($(group[0]).css("zIndex"), 10) || 0;
6927                 $(group).each(function(i) {
6928                         $(this).css("zIndex", min + i);
6929                 });
6930                 this.css("zIndex", (min + group.length));
6931         }
6932 });
6933
6934 $.ui.plugin.add("draggable", "zIndex", {
6935         start: function( event, ui, instance ) {
6936                 var t = $( ui.helper ),
6937                         o = instance.options;
6938
6939                 if (t.css("zIndex")) {
6940                         o._zIndex = t.css("zIndex");
6941                 }
6942                 t.css("zIndex", o.zIndex);
6943         },
6944         stop: function( event, ui, instance ) {
6945                 var o = instance.options;
6946
6947                 if (o._zIndex) {
6948                         $(ui.helper).css("zIndex", o._zIndex);
6949                 }
6950         }
6951 });
6952
6953 var draggable = $.ui.draggable;
6954
6955
6956 /*!
6957  * jQuery UI Resizable 1.11.4
6958  * http://jqueryui.com
6959  *
6960  * Copyright jQuery Foundation and other contributors
6961  * Released under the MIT license.
6962  * http://jquery.org/license
6963  *
6964  * http://api.jqueryui.com/resizable/
6965  */
6966
6967
6968 $.widget("ui.resizable", $.ui.mouse, {
6969         version: "1.11.4",
6970         widgetEventPrefix: "resize",
6971         options: {
6972                 alsoResize: false,
6973                 animate: false,
6974                 animateDuration: "slow",
6975                 animateEasing: "swing",
6976                 aspectRatio: false,
6977                 autoHide: false,
6978                 containment: false,
6979                 ghost: false,
6980                 grid: false,
6981                 handles: "e,s,se",
6982                 helper: false,
6983                 maxHeight: null,
6984                 maxWidth: null,
6985                 minHeight: 10,
6986                 minWidth: 10,
6987                 // See #7960
6988                 zIndex: 90,
6989
6990                 // callbacks
6991                 resize: null,
6992                 start: null,
6993                 stop: null
6994         },
6995
6996         _num: function( value ) {
6997                 return parseInt( value, 10 ) || 0;
6998         },
6999
7000         _isNumber: function( value ) {
7001                 return !isNaN( parseInt( value, 10 ) );
7002         },
7003
7004         _hasScroll: function( el, a ) {
7005
7006                 if ( $( el ).css( "overflow" ) === "hidden") {
7007                         return false;
7008                 }
7009
7010                 var scroll = ( a && a === "left" ) ? "scrollLeft" : "scrollTop",
7011                         has = false;
7012
7013                 if ( el[ scroll ] > 0 ) {
7014                         return true;
7015                 }
7016
7017                 // TODO: determine which cases actually cause this to happen
7018                 // if the element doesn't have the scroll set, see if it's possible to
7019                 // set the scroll
7020                 el[ scroll ] = 1;
7021                 has = ( el[ scroll ] > 0 );
7022                 el[ scroll ] = 0;
7023                 return has;
7024         },
7025
7026         _create: function() {
7027
7028                 var n, i, handle, axis, hname,
7029                         that = this,
7030                         o = this.options;
7031                 this.element.addClass("ui-resizable");
7032
7033                 $.extend(this, {
7034                         _aspectRatio: !!(o.aspectRatio),
7035                         aspectRatio: o.aspectRatio,
7036                         originalElement: this.element,
7037                         _proportionallyResizeElements: [],
7038                         _helper: o.helper || o.ghost || o.animate ? o.helper || "ui-resizable-helper" : null
7039                 });
7040
7041                 // Wrap the element if it cannot hold child nodes
7042                 if (this.element[0].nodeName.match(/^(canvas|textarea|input|select|button|img)$/i)) {
7043
7044                         this.element.wrap(
7045                                 $("<div class='ui-wrapper' style='overflow: hidden;'></div>").css({
7046                                         position: this.element.css("position"),
7047                                         width: this.element.outerWidth(),
7048                                         height: this.element.outerHeight(),
7049                                         top: this.element.css("top"),
7050                                         left: this.element.css("left")
7051                                 })
7052                         );
7053
7054                         this.element = this.element.parent().data(
7055                                 "ui-resizable", this.element.resizable( "instance" )
7056                         );
7057
7058                         this.elementIsWrapper = true;
7059
7060                         this.element.css({
7061                                 marginLeft: this.originalElement.css("marginLeft"),
7062                                 marginTop: this.originalElement.css("marginTop"),
7063                                 marginRight: this.originalElement.css("marginRight"),
7064                                 marginBottom: this.originalElement.css("marginBottom")
7065                         });
7066                         this.originalElement.css({
7067                                 marginLeft: 0,
7068                                 marginTop: 0,
7069                                 marginRight: 0,
7070                                 marginBottom: 0
7071                         });
7072                         // support: Safari
7073                         // Prevent Safari textarea resize
7074                         this.originalResizeStyle = this.originalElement.css("resize");
7075                         this.originalElement.css("resize", "none");
7076
7077                         this._proportionallyResizeElements.push( this.originalElement.css({
7078                                 position: "static",
7079                                 zoom: 1,
7080                                 display: "block"
7081                         }) );
7082
7083                         // support: IE9
7084                         // avoid IE jump (hard set the margin)
7085                         this.originalElement.css({ margin: this.originalElement.css("margin") });
7086
7087                         this._proportionallyResize();
7088                 }
7089
7090                 this.handles = o.handles ||
7091                         ( !$(".ui-resizable-handle", this.element).length ?
7092                                 "e,s,se" : {
7093                                         n: ".ui-resizable-n",
7094                                         e: ".ui-resizable-e",
7095                                         s: ".ui-resizable-s",
7096                                         w: ".ui-resizable-w",
7097                                         se: ".ui-resizable-se",
7098                                         sw: ".ui-resizable-sw",
7099                                         ne: ".ui-resizable-ne",
7100                                         nw: ".ui-resizable-nw"
7101                                 } );
7102
7103                 this._handles = $();
7104                 if ( this.handles.constructor === String ) {
7105
7106                         if ( this.handles === "all") {
7107                                 this.handles = "n,e,s,w,se,sw,ne,nw";
7108                         }
7109
7110                         n = this.handles.split(",");
7111                         this.handles = {};
7112
7113                         for (i = 0; i < n.length; i++) {
7114
7115                                 handle = $.trim(n[i]);
7116                                 hname = "ui-resizable-" + handle;
7117                                 axis = $("<div class='ui-resizable-handle " + hname + "'></div>");
7118
7119                                 axis.css({ zIndex: o.zIndex });
7120
7121                                 // TODO : What's going on here?
7122                                 if ("se" === handle) {
7123                                         axis.addClass("ui-icon ui-icon-gripsmall-diagonal-se");
7124                                 }
7125
7126                                 this.handles[handle] = ".ui-resizable-" + handle;
7127                                 this.element.append(axis);
7128                         }
7129
7130                 }
7131
7132                 this._renderAxis = function(target) {
7133
7134                         var i, axis, padPos, padWrapper;
7135
7136                         target = target || this.element;
7137
7138                         for (i in this.handles) {
7139
7140                                 if (this.handles[i].constructor === String) {
7141                                         this.handles[i] = this.element.children( this.handles[ i ] ).first().show();
7142                                 } else if ( this.handles[ i ].jquery || this.handles[ i ].nodeType ) {
7143                                         this.handles[ i ] = $( this.handles[ i ] );
7144                                         this._on( this.handles[ i ], { "mousedown": that._mouseDown });
7145                                 }
7146
7147                                 if (this.elementIsWrapper && this.originalElement[0].nodeName.match(/^(textarea|input|select|button)$/i)) {
7148
7149                                         axis = $(this.handles[i], this.element);
7150
7151                                         padWrapper = /sw|ne|nw|se|n|s/.test(i) ? axis.outerHeight() : axis.outerWidth();
7152
7153                                         padPos = [ "padding",
7154                                                 /ne|nw|n/.test(i) ? "Top" :
7155                                                 /se|sw|s/.test(i) ? "Bottom" :
7156                                                 /^e$/.test(i) ? "Right" : "Left" ].join("");
7157
7158                                         target.css(padPos, padWrapper);
7159
7160                                         this._proportionallyResize();
7161                                 }
7162
7163                                 this._handles = this._handles.add( this.handles[ i ] );
7164                         }
7165                 };
7166
7167                 // TODO: make renderAxis a prototype function
7168                 this._renderAxis(this.element);
7169
7170                 this._handles = this._handles.add( this.element.find( ".ui-resizable-handle" ) );
7171                 this._handles.disableSelection();
7172
7173                 this._handles.mouseover(function() {
7174                         if (!that.resizing) {
7175                                 if (this.className) {
7176                                         axis = this.className.match(/ui-resizable-(se|sw|ne|nw|n|e|s|w)/i);
7177                                 }
7178                                 that.axis = axis && axis[1] ? axis[1] : "se";
7179                         }
7180                 });
7181
7182                 if (o.autoHide) {
7183                         this._handles.hide();
7184                         $(this.element)
7185                                 .addClass("ui-resizable-autohide")
7186                                 .mouseenter(function() {
7187                                         if (o.disabled) {
7188                                                 return;
7189                                         }
7190                                         $(this).removeClass("ui-resizable-autohide");
7191                                         that._handles.show();
7192                                 })
7193                                 .mouseleave(function() {
7194                                         if (o.disabled) {
7195                                                 return;
7196                                         }
7197                                         if (!that.resizing) {
7198                                                 $(this).addClass("ui-resizable-autohide");
7199                                                 that._handles.hide();
7200                                         }
7201                                 });
7202                 }
7203
7204                 this._mouseInit();
7205         },
7206
7207         _destroy: function() {
7208
7209                 this._mouseDestroy();
7210
7211                 var wrapper,
7212                         _destroy = function(exp) {
7213                                 $(exp)
7214                                         .removeClass("ui-resizable ui-resizable-disabled ui-resizable-resizing")
7215                                         .removeData("resizable")
7216                                         .removeData("ui-resizable")
7217                                         .unbind(".resizable")
7218                                         .find(".ui-resizable-handle")
7219                                                 .remove();
7220                         };
7221
7222                 // TODO: Unwrap at same DOM position
7223                 if (this.elementIsWrapper) {
7224                         _destroy(this.element);
7225                         wrapper = this.element;
7226                         this.originalElement.css({
7227                                 position: wrapper.css("position"),
7228                                 width: wrapper.outerWidth(),
7229                                 height: wrapper.outerHeight(),
7230                                 top: wrapper.css("top"),
7231                                 left: wrapper.css("left")
7232                         }).insertAfter( wrapper );
7233                         wrapper.remove();
7234                 }
7235
7236                 this.originalElement.css("resize", this.originalResizeStyle);
7237                 _destroy(this.originalElement);
7238
7239                 return this;
7240         },
7241
7242         _mouseCapture: function(event) {
7243                 var i, handle,
7244                         capture = false;
7245
7246                 for (i in this.handles) {
7247                         handle = $(this.handles[i])[0];
7248                         if (handle === event.target || $.contains(handle, event.target)) {
7249                                 capture = true;
7250                         }
7251                 }
7252
7253                 return !this.options.disabled && capture;
7254         },
7255
7256         _mouseStart: function(event) {
7257
7258                 var curleft, curtop, cursor,
7259                         o = this.options,
7260                         el = this.element;
7261
7262                 this.resizing = true;
7263
7264                 this._renderProxy();
7265
7266                 curleft = this._num(this.helper.css("left"));
7267                 curtop = this._num(this.helper.css("top"));
7268
7269                 if (o.containment) {
7270                         curleft += $(o.containment).scrollLeft() || 0;
7271                         curtop += $(o.containment).scrollTop() || 0;
7272                 }
7273
7274                 this.offset = this.helper.offset();
7275                 this.position = { left: curleft, top: curtop };
7276
7277                 this.size = this._helper ? {
7278                                 width: this.helper.width(),
7279                                 height: this.helper.height()
7280                         } : {
7281                                 width: el.width(),
7282                                 height: el.height()
7283                         };
7284
7285                 this.originalSize = this._helper ? {
7286                                 width: el.outerWidth(),
7287                                 height: el.outerHeight()
7288                         } : {
7289                                 width: el.width(),
7290                                 height: el.height()
7291                         };
7292
7293                 this.sizeDiff = {
7294                         width: el.outerWidth() - el.width(),
7295                         height: el.outerHeight() - el.height()
7296                 };
7297
7298                 this.originalPosition = { left: curleft, top: curtop };
7299                 this.originalMousePosition = { left: event.pageX, top: event.pageY };
7300
7301                 this.aspectRatio = (typeof o.aspectRatio === "number") ?
7302                         o.aspectRatio :
7303                         ((this.originalSize.width / this.originalSize.height) || 1);
7304
7305                 cursor = $(".ui-resizable-" + this.axis).css("cursor");
7306                 $("body").css("cursor", cursor === "auto" ? this.axis + "-resize" : cursor);
7307
7308                 el.addClass("ui-resizable-resizing");
7309                 this._propagate("start", event);
7310                 return true;
7311         },
7312
7313         _mouseDrag: function(event) {
7314
7315                 var data, props,
7316                         smp = this.originalMousePosition,
7317                         a = this.axis,
7318                         dx = (event.pageX - smp.left) || 0,
7319                         dy = (event.pageY - smp.top) || 0,
7320                         trigger = this._change[a];
7321
7322                 this._updatePrevProperties();
7323
7324                 if (!trigger) {
7325                         return false;
7326                 }
7327
7328                 data = trigger.apply(this, [ event, dx, dy ]);
7329
7330                 this._updateVirtualBoundaries(event.shiftKey);
7331                 if (this._aspectRatio || event.shiftKey) {
7332                         data = this._updateRatio(data, event);
7333                 }
7334
7335                 data = this._respectSize(data, event);
7336
7337                 this._updateCache(data);
7338
7339                 this._propagate("resize", event);
7340
7341                 props = this._applyChanges();
7342
7343                 if ( !this._helper && this._proportionallyResizeElements.length ) {
7344                         this._proportionallyResize();
7345                 }
7346
7347                 if ( !$.isEmptyObject( props ) ) {
7348                         this._updatePrevProperties();
7349                         this._trigger( "resize", event, this.ui() );
7350                         this._applyChanges();
7351                 }
7352
7353                 return false;
7354         },
7355
7356         _mouseStop: function(event) {
7357
7358                 this.resizing = false;
7359                 var pr, ista, soffseth, soffsetw, s, left, top,
7360                         o = this.options, that = this;
7361
7362                 if (this._helper) {
7363
7364                         pr = this._proportionallyResizeElements;
7365                         ista = pr.length && (/textarea/i).test(pr[0].nodeName);
7366                         soffseth = ista && this._hasScroll(pr[0], "left") ? 0 : that.sizeDiff.height;
7367                         soffsetw = ista ? 0 : that.sizeDiff.width;
7368
7369                         s = {
7370                                 width: (that.helper.width()  - soffsetw),
7371                                 height: (that.helper.height() - soffseth)
7372                         };
7373                         left = (parseInt(that.element.css("left"), 10) +
7374                                 (that.position.left - that.originalPosition.left)) || null;
7375                         top = (parseInt(that.element.css("top"), 10) +
7376                                 (that.position.top - that.originalPosition.top)) || null;
7377
7378                         if (!o.animate) {
7379                                 this.element.css($.extend(s, { top: top, left: left }));
7380                         }
7381
7382                         that.helper.height(that.size.height);
7383                         that.helper.width(that.size.width);
7384
7385                         if (this._helper && !o.animate) {
7386                                 this._proportionallyResize();
7387                         }
7388                 }
7389
7390                 $("body").css("cursor", "auto");
7391
7392                 this.element.removeClass("ui-resizable-resizing");
7393
7394                 this._propagate("stop", event);
7395
7396                 if (this._helper) {
7397                         this.helper.remove();
7398                 }
7399
7400                 return false;
7401
7402         },
7403
7404         _updatePrevProperties: function() {
7405                 this.prevPosition = {
7406                         top: this.position.top,
7407                         left: this.position.left
7408                 };
7409                 this.prevSize = {
7410                         width: this.size.width,
7411                         height: this.size.height
7412                 };
7413         },
7414
7415         _applyChanges: function() {
7416                 var props = {};
7417
7418                 if ( this.position.top !== this.prevPosition.top ) {
7419                         props.top = this.position.top + "px";
7420                 }
7421                 if ( this.position.left !== this.prevPosition.left ) {
7422                         props.left = this.position.left + "px";
7423                 }
7424                 if ( this.size.width !== this.prevSize.width ) {
7425                         props.width = this.size.width + "px";
7426                 }
7427                 if ( this.size.height !== this.prevSize.height ) {
7428                         props.height = this.size.height + "px";
7429                 }
7430
7431                 this.helper.css( props );
7432
7433                 return props;
7434         },
7435
7436         _updateVirtualBoundaries: function(forceAspectRatio) {
7437                 var pMinWidth, pMaxWidth, pMinHeight, pMaxHeight, b,
7438                         o = this.options;
7439
7440                 b = {
7441                         minWidth: this._isNumber(o.minWidth) ? o.minWidth : 0,
7442                         maxWidth: this._isNumber(o.maxWidth) ? o.maxWidth : Infinity,
7443                         minHeight: this._isNumber(o.minHeight) ? o.minHeight : 0,
7444                         maxHeight: this._isNumber(o.maxHeight) ? o.maxHeight : Infinity
7445                 };
7446
7447                 if (this._aspectRatio || forceAspectRatio) {
7448                         pMinWidth = b.minHeight * this.aspectRatio;
7449                         pMinHeight = b.minWidth / this.aspectRatio;
7450                         pMaxWidth = b.maxHeight * this.aspectRatio;
7451                         pMaxHeight = b.maxWidth / this.aspectRatio;
7452
7453                         if (pMinWidth > b.minWidth) {
7454                                 b.minWidth = pMinWidth;
7455                         }
7456                         if (pMinHeight > b.minHeight) {
7457                                 b.minHeight = pMinHeight;
7458                         }
7459                         if (pMaxWidth < b.maxWidth) {
7460                                 b.maxWidth = pMaxWidth;
7461                         }
7462                         if (pMaxHeight < b.maxHeight) {
7463                                 b.maxHeight = pMaxHeight;
7464                         }
7465                 }
7466                 this._vBoundaries = b;
7467         },
7468
7469         _updateCache: function(data) {
7470                 this.offset = this.helper.offset();
7471                 if (this._isNumber(data.left)) {
7472                         this.position.left = data.left;
7473                 }
7474                 if (this._isNumber(data.top)) {
7475                         this.position.top = data.top;
7476                 }
7477                 if (this._isNumber(data.height)) {
7478                         this.size.height = data.height;
7479                 }
7480                 if (this._isNumber(data.width)) {
7481                         this.size.width = data.width;
7482                 }
7483         },
7484
7485         _updateRatio: function( data ) {
7486
7487                 var cpos = this.position,
7488                         csize = this.size,
7489                         a = this.axis;
7490
7491                 if (this._isNumber(data.height)) {
7492                         data.width = (data.height * this.aspectRatio);
7493                 } else if (this._isNumber(data.width)) {
7494                         data.height = (data.width / this.aspectRatio);
7495                 }
7496
7497                 if (a === "sw") {
7498                         data.left = cpos.left + (csize.width - data.width);
7499                         data.top = null;
7500                 }
7501                 if (a === "nw") {
7502                         data.top = cpos.top + (csize.height - data.height);
7503                         data.left = cpos.left + (csize.width - data.width);
7504                 }
7505
7506                 return data;
7507         },
7508
7509         _respectSize: function( data ) {
7510
7511                 var o = this._vBoundaries,
7512                         a = this.axis,
7513                         ismaxw = this._isNumber(data.width) && o.maxWidth && (o.maxWidth < data.width),
7514                         ismaxh = this._isNumber(data.height) && o.maxHeight && (o.maxHeight < data.height),
7515                         isminw = this._isNumber(data.width) && o.minWidth && (o.minWidth > data.width),
7516                         isminh = this._isNumber(data.height) && o.minHeight && (o.minHeight > data.height),
7517                         dw = this.originalPosition.left + this.originalSize.width,
7518                         dh = this.position.top + this.size.height,
7519                         cw = /sw|nw|w/.test(a), ch = /nw|ne|n/.test(a);
7520                 if (isminw) {
7521                         data.width = o.minWidth;
7522                 }
7523                 if (isminh) {
7524                         data.height = o.minHeight;
7525                 }
7526                 if (ismaxw) {
7527                         data.width = o.maxWidth;
7528                 }
7529                 if (ismaxh) {
7530                         data.height = o.maxHeight;
7531                 }
7532
7533                 if (isminw && cw) {
7534                         data.left = dw - o.minWidth;
7535                 }
7536                 if (ismaxw && cw) {
7537                         data.left = dw - o.maxWidth;
7538                 }
7539                 if (isminh && ch) {
7540                         data.top = dh - o.minHeight;
7541                 }
7542                 if (ismaxh && ch) {
7543                         data.top = dh - o.maxHeight;
7544                 }
7545
7546                 // Fixing jump error on top/left - bug #2330
7547                 if (!data.width && !data.height && !data.left && data.top) {
7548                         data.top = null;
7549                 } else if (!data.width && !data.height && !data.top && data.left) {
7550                         data.left = null;
7551                 }
7552
7553                 return data;
7554         },
7555
7556         _getPaddingPlusBorderDimensions: function( element ) {
7557                 var i = 0,
7558                         widths = [],
7559                         borders = [
7560                                 element.css( "borderTopWidth" ),
7561                                 element.css( "borderRightWidth" ),
7562                                 element.css( "borderBottomWidth" ),
7563                                 element.css( "borderLeftWidth" )
7564                         ],
7565                         paddings = [
7566                                 element.css( "paddingTop" ),
7567                                 element.css( "paddingRight" ),
7568                                 element.css( "paddingBottom" ),
7569                                 element.css( "paddingLeft" )
7570                         ];
7571
7572                 for ( ; i < 4; i++ ) {
7573                         widths[ i ] = ( parseInt( borders[ i ], 10 ) || 0 );
7574                         widths[ i ] += ( parseInt( paddings[ i ], 10 ) || 0 );
7575                 }
7576
7577                 return {
7578                         height: widths[ 0 ] + widths[ 2 ],
7579                         width: widths[ 1 ] + widths[ 3 ]
7580                 };
7581         },
7582
7583         _proportionallyResize: function() {
7584
7585                 if (!this._proportionallyResizeElements.length) {
7586                         return;
7587                 }
7588
7589                 var prel,
7590                         i = 0,
7591                         element = this.helper || this.element;
7592
7593                 for ( ; i < this._proportionallyResizeElements.length; i++) {
7594
7595                         prel = this._proportionallyResizeElements[i];
7596
7597                         // TODO: Seems like a bug to cache this.outerDimensions
7598                         // considering that we are in a loop.
7599                         if (!this.outerDimensions) {
7600                                 this.outerDimensions = this._getPaddingPlusBorderDimensions( prel );
7601                         }
7602
7603                         prel.css({
7604                                 height: (element.height() - this.outerDimensions.height) || 0,
7605                                 width: (element.width() - this.outerDimensions.width) || 0
7606                         });
7607
7608                 }
7609
7610         },
7611
7612         _renderProxy: function() {
7613
7614                 var el = this.element, o = this.options;
7615                 this.elementOffset = el.offset();
7616
7617                 if (this._helper) {
7618
7619                         this.helper = this.helper || $("<div style='overflow:hidden;'></div>");
7620
7621                         this.helper.addClass(this._helper).css({
7622                                 width: this.element.outerWidth() - 1,
7623                                 height: this.element.outerHeight() - 1,
7624                                 position: "absolute",
7625                                 left: this.elementOffset.left + "px",
7626                                 top: this.elementOffset.top + "px",
7627                                 zIndex: ++o.zIndex //TODO: Don't modify option
7628                         });
7629
7630                         this.helper
7631                                 .appendTo("body")
7632                                 .disableSelection();
7633
7634                 } else {
7635                         this.helper = this.element;
7636                 }
7637
7638         },
7639
7640         _change: {
7641                 e: function(event, dx) {
7642                         return { width: this.originalSize.width + dx };
7643                 },
7644                 w: function(event, dx) {
7645                         var cs = this.originalSize, sp = this.originalPosition;
7646                         return { left: sp.left + dx, width: cs.width - dx };
7647                 },
7648                 n: function(event, dx, dy) {
7649                         var cs = this.originalSize, sp = this.originalPosition;
7650                         return { top: sp.top + dy, height: cs.height - dy };
7651                 },
7652                 s: function(event, dx, dy) {
7653                         return { height: this.originalSize.height + dy };
7654                 },
7655                 se: function(event, dx, dy) {
7656                         return $.extend(this._change.s.apply(this, arguments),
7657                                 this._change.e.apply(this, [ event, dx, dy ]));
7658                 },
7659                 sw: function(event, dx, dy) {
7660                         return $.extend(this._change.s.apply(this, arguments),
7661                                 this._change.w.apply(this, [ event, dx, dy ]));
7662                 },
7663                 ne: function(event, dx, dy) {
7664                         return $.extend(this._change.n.apply(this, arguments),
7665                                 this._change.e.apply(this, [ event, dx, dy ]));
7666                 },
7667                 nw: function(event, dx, dy) {
7668                         return $.extend(this._change.n.apply(this, arguments),
7669                                 this._change.w.apply(this, [ event, dx, dy ]));
7670                 }
7671         },
7672
7673         _propagate: function(n, event) {
7674                 $.ui.plugin.call(this, n, [ event, this.ui() ]);
7675                 (n !== "resize" && this._trigger(n, event, this.ui()));
7676         },
7677
7678         plugins: {},
7679
7680         ui: function() {
7681                 return {
7682                         originalElement: this.originalElement,
7683                         element: this.element,
7684                         helper: this.helper,
7685                         position: this.position,
7686                         size: this.size,
7687                         originalSize: this.originalSize,
7688                         originalPosition: this.originalPosition
7689                 };
7690         }
7691
7692 });
7693
7694 /*
7695  * Resizable Extensions
7696  */
7697
7698 $.ui.plugin.add("resizable", "animate", {
7699
7700         stop: function( event ) {
7701                 var that = $(this).resizable( "instance" ),
7702                         o = that.options,
7703                         pr = that._proportionallyResizeElements,
7704                         ista = pr.length && (/textarea/i).test(pr[0].nodeName),
7705                         soffseth = ista && that._hasScroll(pr[0], "left") ? 0 : that.sizeDiff.height,
7706                         soffsetw = ista ? 0 : that.sizeDiff.width,
7707                         style = { width: (that.size.width - soffsetw), height: (that.size.height - soffseth) },
7708                         left = (parseInt(that.element.css("left"), 10) +
7709                                 (that.position.left - that.originalPosition.left)) || null,
7710                         top = (parseInt(that.element.css("top"), 10) +
7711                                 (that.position.top - that.originalPosition.top)) || null;
7712
7713                 that.element.animate(
7714                         $.extend(style, top && left ? { top: top, left: left } : {}), {
7715                                 duration: o.animateDuration,
7716                                 easing: o.animateEasing,
7717                                 step: function() {
7718
7719                                         var data = {
7720                                                 width: parseInt(that.element.css("width"), 10),
7721                                                 height: parseInt(that.element.css("height"), 10),
7722                                                 top: parseInt(that.element.css("top"), 10),
7723                                                 left: parseInt(that.element.css("left"), 10)
7724                                         };
7725
7726                                         if (pr && pr.length) {
7727                                                 $(pr[0]).css({ width: data.width, height: data.height });
7728                                         }
7729
7730                                         // propagating resize, and updating values for each animation step
7731                                         that._updateCache(data);
7732                                         that._propagate("resize", event);
7733
7734                                 }
7735                         }
7736                 );
7737         }
7738
7739 });
7740
7741 $.ui.plugin.add( "resizable", "containment", {
7742
7743         start: function() {
7744                 var element, p, co, ch, cw, width, height,
7745                         that = $( this ).resizable( "instance" ),
7746                         o = that.options,
7747                         el = that.element,
7748                         oc = o.containment,
7749                         ce = ( oc instanceof $ ) ? oc.get( 0 ) : ( /parent/.test( oc ) ) ? el.parent().get( 0 ) : oc;
7750
7751                 if ( !ce ) {
7752                         return;
7753                 }
7754
7755                 that.containerElement = $( ce );
7756
7757                 if ( /document/.test( oc ) || oc === document ) {
7758                         that.containerOffset = {
7759                                 left: 0,
7760                                 top: 0
7761                         };
7762                         that.containerPosition = {
7763                                 left: 0,
7764                                 top: 0
7765                         };
7766
7767                         that.parentData = {
7768                                 element: $( document ),
7769                                 left: 0,
7770                                 top: 0,
7771                                 width: $( document ).width(),
7772                                 height: $( document ).height() || document.body.parentNode.scrollHeight
7773                         };
7774                 } else {
7775                         element = $( ce );
7776                         p = [];
7777                         $([ "Top", "Right", "Left", "Bottom" ]).each(function( i, name ) {
7778                                 p[ i ] = that._num( element.css( "padding" + name ) );
7779                         });
7780
7781                         that.containerOffset = element.offset();
7782                         that.containerPosition = element.position();
7783                         that.containerSize = {
7784                                 height: ( element.innerHeight() - p[ 3 ] ),
7785                                 width: ( element.innerWidth() - p[ 1 ] )
7786                         };
7787
7788                         co = that.containerOffset;
7789                         ch = that.containerSize.height;
7790                         cw = that.containerSize.width;
7791                         width = ( that._hasScroll ( ce, "left" ) ? ce.scrollWidth : cw );
7792                         height = ( that._hasScroll ( ce ) ? ce.scrollHeight : ch ) ;
7793
7794                         that.parentData = {
7795                                 element: ce,
7796                                 left: co.left,
7797                                 top: co.top,
7798                                 width: width,
7799                                 height: height
7800                         };
7801                 }
7802         },
7803
7804         resize: function( event ) {
7805                 var woset, hoset, isParent, isOffsetRelative,
7806                         that = $( this ).resizable( "instance" ),
7807                         o = that.options,
7808                         co = that.containerOffset,
7809                         cp = that.position,
7810                         pRatio = that._aspectRatio || event.shiftKey,
7811                         cop = {
7812                                 top: 0,
7813                                 left: 0
7814                         },
7815                         ce = that.containerElement,
7816                         continueResize = true;
7817
7818                 if ( ce[ 0 ] !== document && ( /static/ ).test( ce.css( "position" ) ) ) {
7819                         cop = co;
7820                 }
7821
7822                 if ( cp.left < ( that._helper ? co.left : 0 ) ) {
7823                         that.size.width = that.size.width +
7824                                 ( that._helper ?
7825                                         ( that.position.left - co.left ) :
7826                                         ( that.position.left - cop.left ) );
7827
7828                         if ( pRatio ) {
7829                                 that.size.height = that.size.width / that.aspectRatio;
7830                                 continueResize = false;
7831                         }
7832                         that.position.left = o.helper ? co.left : 0;
7833                 }
7834
7835                 if ( cp.top < ( that._helper ? co.top : 0 ) ) {
7836                         that.size.height = that.size.height +
7837                                 ( that._helper ?
7838                                         ( that.position.top - co.top ) :
7839                                         that.position.top );
7840
7841                         if ( pRatio ) {
7842                                 that.size.width = that.size.height * that.aspectRatio;
7843                                 continueResize = false;
7844                         }
7845                         that.position.top = that._helper ? co.top : 0;
7846                 }
7847
7848                 isParent = that.containerElement.get( 0 ) === that.element.parent().get( 0 );
7849                 isOffsetRelative = /relative|absolute/.test( that.containerElement.css( "position" ) );
7850
7851                 if ( isParent && isOffsetRelative ) {
7852                         that.offset.left = that.parentData.left + that.position.left;
7853                         that.offset.top = that.parentData.top + that.position.top;
7854                 } else {
7855                         that.offset.left = that.element.offset().left;
7856                         that.offset.top = that.element.offset().top;
7857                 }
7858
7859                 woset = Math.abs( that.sizeDiff.width +
7860                         (that._helper ?
7861                                 that.offset.left - cop.left :
7862                                 (that.offset.left - co.left)) );
7863
7864                 hoset = Math.abs( that.sizeDiff.height +
7865                         (that._helper ?
7866                                 that.offset.top - cop.top :
7867                                 (that.offset.top - co.top)) );
7868
7869                 if ( woset + that.size.width >= that.parentData.width ) {
7870                         that.size.width = that.parentData.width - woset;
7871                         if ( pRatio ) {
7872                                 that.size.height = that.size.width / that.aspectRatio;
7873                                 continueResize = false;
7874                         }
7875                 }
7876
7877                 if ( hoset + that.size.height >= that.parentData.height ) {
7878                         that.size.height = that.parentData.height - hoset;
7879                         if ( pRatio ) {
7880                                 that.size.width = that.size.height * that.aspectRatio;
7881                                 continueResize = false;
7882                         }
7883                 }
7884
7885                 if ( !continueResize ) {
7886                         that.position.left = that.prevPosition.left;
7887                         that.position.top = that.prevPosition.top;
7888                         that.size.width = that.prevSize.width;
7889                         that.size.height = that.prevSize.height;
7890                 }
7891         },
7892
7893         stop: function() {
7894                 var that = $( this ).resizable( "instance" ),
7895                         o = that.options,
7896                         co = that.containerOffset,
7897                         cop = that.containerPosition,
7898                         ce = that.containerElement,
7899                         helper = $( that.helper ),
7900                         ho = helper.offset(),
7901                         w = helper.outerWidth() - that.sizeDiff.width,
7902                         h = helper.outerHeight() - that.sizeDiff.height;
7903
7904                 if ( that._helper && !o.animate && ( /relative/ ).test( ce.css( "position" ) ) ) {
7905                         $( this ).css({
7906                                 left: ho.left - cop.left - co.left,
7907                                 width: w,
7908                                 height: h
7909                         });
7910                 }
7911
7912                 if ( that._helper && !o.animate && ( /static/ ).test( ce.css( "position" ) ) ) {
7913                         $( this ).css({
7914                                 left: ho.left - cop.left - co.left,
7915                                 width: w,
7916                                 height: h
7917                         });
7918                 }
7919         }
7920 });
7921
7922 $.ui.plugin.add("resizable", "alsoResize", {
7923
7924         start: function() {
7925                 var that = $(this).resizable( "instance" ),
7926                         o = that.options;
7927
7928                 $(o.alsoResize).each(function() {
7929                         var el = $(this);
7930                         el.data("ui-resizable-alsoresize", {
7931                                 width: parseInt(el.width(), 10), height: parseInt(el.height(), 10),
7932                                 left: parseInt(el.css("left"), 10), top: parseInt(el.css("top"), 10)
7933                         });
7934                 });
7935         },
7936
7937         resize: function(event, ui) {
7938                 var that = $(this).resizable( "instance" ),
7939                         o = that.options,
7940                         os = that.originalSize,
7941                         op = that.originalPosition,
7942                         delta = {
7943                                 height: (that.size.height - os.height) || 0,
7944                                 width: (that.size.width - os.width) || 0,
7945                                 top: (that.position.top - op.top) || 0,
7946                                 left: (that.position.left - op.left) || 0
7947                         };
7948
7949                         $(o.alsoResize).each(function() {
7950                                 var el = $(this), start = $(this).data("ui-resizable-alsoresize"), style = {},
7951                                         css = el.parents(ui.originalElement[0]).length ?
7952                                                         [ "width", "height" ] :
7953                                                         [ "width", "height", "top", "left" ];
7954
7955                                 $.each(css, function(i, prop) {
7956                                         var sum = (start[prop] || 0) + (delta[prop] || 0);
7957                                         if (sum && sum >= 0) {
7958                                                 style[prop] = sum || null;
7959                                         }
7960                                 });
7961
7962                                 el.css(style);
7963                         });
7964         },
7965
7966         stop: function() {
7967                 $(this).removeData("resizable-alsoresize");
7968         }
7969 });
7970
7971 $.ui.plugin.add("resizable", "ghost", {
7972
7973         start: function() {
7974
7975                 var that = $(this).resizable( "instance" ), o = that.options, cs = that.size;
7976
7977                 that.ghost = that.originalElement.clone();
7978                 that.ghost
7979                         .css({
7980                                 opacity: 0.25,
7981                                 display: "block",
7982                                 position: "relative",
7983                                 height: cs.height,
7984                                 width: cs.width,
7985                                 margin: 0,
7986                                 left: 0,
7987                                 top: 0
7988                         })
7989                         .addClass("ui-resizable-ghost")
7990                         .addClass(typeof o.ghost === "string" ? o.ghost : "");
7991
7992                 that.ghost.appendTo(that.helper);
7993
7994         },
7995
7996         resize: function() {
7997                 var that = $(this).resizable( "instance" );
7998                 if (that.ghost) {
7999                         that.ghost.css({
8000                                 position: "relative",
8001                                 height: that.size.height,
8002                                 width: that.size.width
8003                         });
8004                 }
8005         },
8006
8007         stop: function() {
8008                 var that = $(this).resizable( "instance" );
8009                 if (that.ghost && that.helper) {
8010                         that.helper.get(0).removeChild(that.ghost.get(0));
8011                 }
8012         }
8013
8014 });
8015
8016 $.ui.plugin.add("resizable", "grid", {
8017
8018         resize: function() {
8019                 var outerDimensions,
8020                         that = $(this).resizable( "instance" ),
8021                         o = that.options,
8022                         cs = that.size,
8023                         os = that.originalSize,
8024                         op = that.originalPosition,
8025                         a = that.axis,
8026                         grid = typeof o.grid === "number" ? [ o.grid, o.grid ] : o.grid,
8027                         gridX = (grid[0] || 1),
8028                         gridY = (grid[1] || 1),
8029                         ox = Math.round((cs.width - os.width) / gridX) * gridX,
8030                         oy = Math.round((cs.height - os.height) / gridY) * gridY,
8031                         newWidth = os.width + ox,
8032                         newHeight = os.height + oy,
8033                         isMaxWidth = o.maxWidth && (o.maxWidth < newWidth),
8034                         isMaxHeight = o.maxHeight && (o.maxHeight < newHeight),
8035                         isMinWidth = o.minWidth && (o.minWidth > newWidth),
8036                         isMinHeight = o.minHeight && (o.minHeight > newHeight);
8037
8038                 o.grid = grid;
8039
8040                 if (isMinWidth) {
8041                         newWidth += gridX;
8042                 }
8043                 if (isMinHeight) {
8044                         newHeight += gridY;
8045                 }
8046                 if (isMaxWidth) {
8047                         newWidth -= gridX;
8048                 }
8049                 if (isMaxHeight) {
8050                         newHeight -= gridY;
8051                 }
8052
8053                 if (/^(se|s|e)$/.test(a)) {
8054                         that.size.width = newWidth;
8055                         that.size.height = newHeight;
8056                 } else if (/^(ne)$/.test(a)) {
8057                         that.size.width = newWidth;
8058                         that.size.height = newHeight;
8059                         that.position.top = op.top - oy;
8060                 } else if (/^(sw)$/.test(a)) {
8061                         that.size.width = newWidth;
8062                         that.size.height = newHeight;
8063                         that.position.left = op.left - ox;
8064                 } else {
8065                         if ( newHeight - gridY <= 0 || newWidth - gridX <= 0) {
8066                                 outerDimensions = that._getPaddingPlusBorderDimensions( this );
8067                         }
8068
8069                         if ( newHeight - gridY > 0 ) {
8070                                 that.size.height = newHeight;
8071                                 that.position.top = op.top - oy;
8072                         } else {
8073                                 newHeight = gridY - outerDimensions.height;
8074                                 that.size.height = newHeight;
8075                                 that.position.top = op.top + os.height - newHeight;
8076                         }
8077                         if ( newWidth - gridX > 0 ) {
8078                                 that.size.width = newWidth;
8079                                 that.position.left = op.left - ox;
8080                         } else {
8081                                 newWidth = gridX - outerDimensions.width;
8082                                 that.size.width = newWidth;
8083                                 that.position.left = op.left + os.width - newWidth;
8084                         }
8085                 }
8086         }
8087
8088 });
8089
8090 var resizable = $.ui.resizable;
8091
8092
8093 /*!
8094  * jQuery UI Dialog 1.11.4
8095  * http://jqueryui.com
8096  *
8097  * Copyright jQuery Foundation and other contributors
8098  * Released under the MIT license.
8099  * http://jquery.org/license
8100  *
8101  * http://api.jqueryui.com/dialog/
8102  */
8103
8104
8105 var dialog = $.widget( "ui.dialog", {
8106         version: "1.11.4",
8107         options: {
8108                 appendTo: "body",
8109                 autoOpen: true,
8110                 buttons: [],
8111                 closeOnEscape: true,
8112                 closeText: "Close",
8113                 dialogClass: "",
8114                 draggable: true,
8115                 hide: null,
8116                 height: "auto",
8117                 maxHeight: null,
8118                 maxWidth: null,
8119                 minHeight: 150,
8120                 minWidth: 150,
8121                 modal: false,
8122                 position: {
8123                         my: "center",
8124                         at: "center",
8125                         of: window,
8126                         collision: "fit",
8127                         // Ensure the titlebar is always visible
8128                         using: function( pos ) {
8129                                 var topOffset = $( this ).css( pos ).offset().top;
8130                                 if ( topOffset < 0 ) {
8131                                         $( this ).css( "top", pos.top - topOffset );
8132                                 }
8133                         }
8134                 },
8135                 resizable: true,
8136                 show: null,
8137                 title: null,
8138                 width: 300,
8139
8140                 // callbacks
8141                 beforeClose: null,
8142                 close: null,
8143                 drag: null,
8144                 dragStart: null,
8145                 dragStop: null,
8146                 focus: null,
8147                 open: null,
8148                 resize: null,
8149                 resizeStart: null,
8150                 resizeStop: null
8151         },
8152
8153         sizeRelatedOptions: {
8154                 buttons: true,
8155                 height: true,
8156                 maxHeight: true,
8157                 maxWidth: true,
8158                 minHeight: true,
8159                 minWidth: true,
8160                 width: true
8161         },
8162
8163         resizableRelatedOptions: {
8164                 maxHeight: true,
8165                 maxWidth: true,
8166                 minHeight: true,
8167                 minWidth: true
8168         },
8169
8170         _create: function() {
8171                 this.originalCss = {
8172                         display: this.element[ 0 ].style.display,
8173                         width: this.element[ 0 ].style.width,
8174                         minHeight: this.element[ 0 ].style.minHeight,
8175                         maxHeight: this.element[ 0 ].style.maxHeight,
8176                         height: this.element[ 0 ].style.height
8177                 };
8178                 this.originalPosition = {
8179                         parent: this.element.parent(),
8180                         index: this.element.parent().children().index( this.element )
8181                 };
8182                 this.originalTitle = this.element.attr( "title" );
8183                 this.options.title = this.options.title || this.originalTitle;
8184
8185                 this._createWrapper();
8186
8187                 this.element
8188                         .show()
8189                         .removeAttr( "title" )
8190                         .addClass( "ui-dialog-content ui-widget-content" )
8191                         .appendTo( this.uiDialog );
8192
8193                 this._createTitlebar();
8194                 this._createButtonPane();
8195
8196                 if ( this.options.draggable && $.fn.draggable ) {
8197                         this._makeDraggable();
8198                 }
8199                 if ( this.options.resizable && $.fn.resizable ) {
8200                         this._makeResizable();
8201                 }
8202
8203                 this._isOpen = false;
8204
8205                 this._trackFocus();
8206         },
8207
8208         _init: function() {
8209                 if ( this.options.autoOpen ) {
8210                         this.open();
8211                 }
8212         },
8213
8214         _appendTo: function() {
8215                 var element = this.options.appendTo;
8216                 if ( element && (element.jquery || element.nodeType) ) {
8217                         return $( element );
8218                 }
8219                 return this.document.find( element || "body" ).eq( 0 );
8220         },
8221
8222         _destroy: function() {
8223                 var next,
8224                         originalPosition = this.originalPosition;
8225
8226                 this._untrackInstance();
8227                 this._destroyOverlay();
8228
8229                 this.element
8230                         .removeUniqueId()
8231                         .removeClass( "ui-dialog-content ui-widget-content" )
8232                         .css( this.originalCss )
8233                         // Without detaching first, the following becomes really slow
8234                         .detach();
8235
8236                 this.uiDialog.stop( true, true ).remove();
8237
8238                 if ( this.originalTitle ) {
8239                         this.element.attr( "title", this.originalTitle );
8240                 }
8241
8242                 next = originalPosition.parent.children().eq( originalPosition.index );
8243                 // Don't try to place the dialog next to itself (#8613)
8244                 if ( next.length && next[ 0 ] !== this.element[ 0 ] ) {
8245                         next.before( this.element );
8246                 } else {
8247                         originalPosition.parent.append( this.element );
8248                 }
8249         },
8250
8251         widget: function() {
8252                 return this.uiDialog;
8253         },
8254
8255         disable: $.noop,
8256         enable: $.noop,
8257
8258         close: function( event ) {
8259                 var activeElement,
8260                         that = this;
8261
8262                 if ( !this._isOpen || this._trigger( "beforeClose", event ) === false ) {
8263                         return;
8264                 }
8265
8266                 this._isOpen = false;
8267                 this._focusedElement = null;
8268                 this._destroyOverlay();
8269                 this._untrackInstance();
8270
8271                 if ( !this.opener.filter( ":focusable" ).focus().length ) {
8272
8273                         // support: IE9
8274                         // IE9 throws an "Unspecified error" accessing document.activeElement from an <iframe>
8275                         try {
8276                                 activeElement = this.document[ 0 ].activeElement;
8277
8278                                 // Support: IE9, IE10
8279                                 // If the <body> is blurred, IE will switch windows, see #4520
8280                                 if ( activeElement && activeElement.nodeName.toLowerCase() !== "body" ) {
8281
8282                                         // Hiding a focused element doesn't trigger blur in WebKit
8283                                         // so in case we have nothing to focus on, explicitly blur the active element
8284                                         // https://bugs.webkit.org/show_bug.cgi?id=47182
8285                                         $( activeElement ).blur();
8286                                 }
8287                         } catch ( error ) {}
8288                 }
8289
8290                 this._hide( this.uiDialog, this.options.hide, function() {
8291                         that._trigger( "close", event );
8292                 });
8293         },
8294
8295         isOpen: function() {
8296                 return this._isOpen;
8297         },
8298
8299         moveToTop: function() {
8300                 this._moveToTop();
8301         },
8302
8303         _moveToTop: function( event, silent ) {
8304                 var moved = false,
8305                         zIndices = this.uiDialog.siblings( ".ui-front:visible" ).map(function() {
8306                                 return +$( this ).css( "z-index" );
8307                         }).get(),
8308                         zIndexMax = Math.max.apply( null, zIndices );
8309
8310                 if ( zIndexMax >= +this.uiDialog.css( "z-index" ) ) {
8311                         this.uiDialog.css( "z-index", zIndexMax + 1 );
8312                         moved = true;
8313                 }
8314
8315                 if ( moved && !silent ) {
8316                         this._trigger( "focus", event );
8317                 }
8318                 return moved;
8319         },
8320
8321         open: function() {
8322                 var that = this;
8323                 if ( this._isOpen ) {
8324                         if ( this._moveToTop() ) {
8325                                 this._focusTabbable();
8326                         }
8327                         return;
8328                 }
8329
8330                 this._isOpen = true;
8331                 this.opener = $( this.document[ 0 ].activeElement );
8332
8333                 this._size();
8334                 this._position();
8335                 this._createOverlay();
8336                 this._moveToTop( null, true );
8337
8338                 // Ensure the overlay is moved to the top with the dialog, but only when
8339                 // opening. The overlay shouldn't move after the dialog is open so that
8340                 // modeless dialogs opened after the modal dialog stack properly.
8341                 if ( this.overlay ) {
8342                         this.overlay.css( "z-index", this.uiDialog.css( "z-index" ) - 1 );
8343                 }
8344
8345                 this._show( this.uiDialog, this.options.show, function() {
8346                         that._focusTabbable();
8347                         that._trigger( "focus" );
8348                 });
8349
8350                 // Track the dialog immediately upon openening in case a focus event
8351                 // somehow occurs outside of the dialog before an element inside the
8352                 // dialog is focused (#10152)
8353                 this._makeFocusTarget();
8354
8355                 this._trigger( "open" );
8356         },
8357
8358         _focusTabbable: function() {
8359                 // Set focus to the first match:
8360                 // 1. An element that was focused previously
8361                 // 2. First element inside the dialog matching [autofocus]
8362                 // 3. Tabbable element inside the content element
8363                 // 4. Tabbable element inside the buttonpane
8364                 // 5. The close button
8365                 // 6. The dialog itself
8366                 var hasFocus = this._focusedElement;
8367                 if ( !hasFocus ) {
8368                         hasFocus = this.element.find( "[autofocus]" );
8369                 }
8370                 if ( !hasFocus.length ) {
8371                         hasFocus = this.element.find( ":tabbable" );
8372                 }
8373                 if ( !hasFocus.length ) {
8374                         hasFocus = this.uiDialogButtonPane.find( ":tabbable" );
8375                 }
8376                 if ( !hasFocus.length ) {
8377                         hasFocus = this.uiDialogTitlebarClose.filter( ":tabbable" );
8378                 }
8379                 if ( !hasFocus.length ) {
8380                         hasFocus = this.uiDialog;
8381                 }
8382                 hasFocus.eq( 0 ).focus();
8383         },
8384
8385         _keepFocus: function( event ) {
8386                 function checkFocus() {
8387                         var activeElement = this.document[0].activeElement,
8388                                 isActive = this.uiDialog[0] === activeElement ||
8389                                         $.contains( this.uiDialog[0], activeElement );
8390                         if ( !isActive ) {
8391                                 this._focusTabbable();
8392                         }
8393                 }
8394                 event.preventDefault();
8395                 checkFocus.call( this );
8396                 // support: IE
8397                 // IE <= 8 doesn't prevent moving focus even with event.preventDefault()
8398                 // so we check again later
8399                 this._delay( checkFocus );
8400         },
8401
8402         _createWrapper: function() {
8403                 this.uiDialog = $("<div>")
8404                         .addClass( "ui-dialog ui-widget ui-widget-content ui-corner-all ui-front " +
8405                                 this.options.dialogClass )
8406                         .hide()
8407                         .attr({
8408                                 // Setting tabIndex makes the div focusable
8409                                 tabIndex: -1,
8410                                 role: "dialog"
8411                         })
8412                         .appendTo( this._appendTo() );
8413
8414                 this._on( this.uiDialog, {
8415                         keydown: function( event ) {
8416                                 if ( this.options.closeOnEscape && !event.isDefaultPrevented() && event.keyCode &&
8417                                                 event.keyCode === $.ui.keyCode.ESCAPE ) {
8418                                         event.preventDefault();
8419                                         this.close( event );
8420                                         return;
8421                                 }
8422
8423                                 // prevent tabbing out of dialogs
8424                                 if ( event.keyCode !== $.ui.keyCode.TAB || event.isDefaultPrevented() ) {
8425                                         return;
8426                                 }
8427                                 var tabbables = this.uiDialog.find( ":tabbable" ),
8428                                         first = tabbables.filter( ":first" ),
8429                                         last = tabbables.filter( ":last" );
8430
8431                                 if ( ( event.target === last[0] || event.target === this.uiDialog[0] ) && !event.shiftKey ) {
8432                                         this._delay(function() {
8433                                                 first.focus();
8434                                         });
8435                                         event.preventDefault();
8436                                 } else if ( ( event.target === first[0] || event.target === this.uiDialog[0] ) && event.shiftKey ) {
8437                                         this._delay(function() {
8438                                                 last.focus();
8439                                         });
8440                                         event.preventDefault();
8441                                 }
8442                         },
8443                         mousedown: function( event ) {
8444                                 if ( this._moveToTop( event ) ) {
8445                                         this._focusTabbable();
8446                                 }
8447                         }
8448                 });
8449
8450                 // We assume that any existing aria-describedby attribute means
8451                 // that the dialog content is marked up properly
8452                 // otherwise we brute force the content as the description
8453                 if ( !this.element.find( "[aria-describedby]" ).length ) {
8454                         this.uiDialog.attr({
8455                                 "aria-describedby": this.element.uniqueId().attr( "id" )
8456                         });
8457                 }
8458         },
8459
8460         _createTitlebar: function() {
8461                 var uiDialogTitle;
8462
8463                 this.uiDialogTitlebar = $( "<div>" )
8464                         .addClass( "ui-dialog-titlebar ui-widget-header ui-corner-all ui-helper-clearfix" )
8465                         .prependTo( this.uiDialog );
8466                 this._on( this.uiDialogTitlebar, {
8467                         mousedown: function( event ) {
8468                                 // Don't prevent click on close button (#8838)
8469                                 // Focusing a dialog that is partially scrolled out of view
8470                                 // causes the browser to scroll it into view, preventing the click event
8471                                 if ( !$( event.target ).closest( ".ui-dialog-titlebar-close" ) ) {
8472                                         // Dialog isn't getting focus when dragging (#8063)
8473                                         this.uiDialog.focus();
8474                                 }
8475                         }
8476                 });
8477
8478                 // support: IE
8479                 // Use type="button" to prevent enter keypresses in textboxes from closing the
8480                 // dialog in IE (#9312)
8481                 this.uiDialogTitlebarClose = $( "<button type='button'></button>" )
8482                         .button({
8483                                 label: this.options.closeText,
8484                                 icons: {
8485                                         primary: "ui-icon-closethick"
8486                                 },
8487                                 text: false
8488                         })
8489                         .addClass( "ui-dialog-titlebar-close" )
8490                         .appendTo( this.uiDialogTitlebar );
8491                 this._on( this.uiDialogTitlebarClose, {
8492                         click: function( event ) {
8493                                 event.preventDefault();
8494                                 this.close( event );
8495                         }
8496                 });
8497
8498                 uiDialogTitle = $( "<span>" )
8499                         .uniqueId()
8500                         .addClass( "ui-dialog-title" )
8501                         .prependTo( this.uiDialogTitlebar );
8502                 this._title( uiDialogTitle );
8503
8504                 this.uiDialog.attr({
8505                         "aria-labelledby": uiDialogTitle.attr( "id" )
8506                 });
8507         },
8508
8509         _title: function( title ) {
8510                 if ( !this.options.title ) {
8511                         title.html( "&#160;" );
8512                 }
8513                 title.text( this.options.title );
8514         },
8515
8516         _createButtonPane: function() {
8517                 this.uiDialogButtonPane = $( "<div>" )
8518                         .addClass( "ui-dialog-buttonpane ui-widget-content ui-helper-clearfix" );
8519
8520                 this.uiButtonSet = $( "<div>" )
8521                         .addClass( "ui-dialog-buttonset" )
8522                         .appendTo( this.uiDialogButtonPane );
8523
8524                 this._createButtons();
8525         },
8526
8527         _createButtons: function() {
8528                 var that = this,
8529                         buttons = this.options.buttons;
8530
8531                 // if we already have a button pane, remove it
8532                 this.uiDialogButtonPane.remove();
8533                 this.uiButtonSet.empty();
8534
8535                 if ( $.isEmptyObject( buttons ) || ($.isArray( buttons ) && !buttons.length) ) {
8536                         this.uiDialog.removeClass( "ui-dialog-buttons" );
8537                         return;
8538                 }
8539
8540                 $.each( buttons, function( name, props ) {
8541                         var click, buttonOptions;
8542                         props = $.isFunction( props ) ?
8543                                 { click: props, text: name } :
8544                                 props;
8545                         // Default to a non-submitting button
8546                         props = $.extend( { type: "button" }, props );
8547                         // Change the context for the click callback to be the main element
8548                         click = props.click;
8549                         props.click = function() {
8550                                 click.apply( that.element[ 0 ], arguments );
8551                         };
8552                         buttonOptions = {
8553                                 icons: props.icons,
8554                                 text: props.showText
8555                         };
8556                         delete props.icons;
8557                         delete props.showText;
8558                         $( "<button></button>", props )
8559                                 .button( buttonOptions )
8560                                 .appendTo( that.uiButtonSet );
8561                 });
8562                 this.uiDialog.addClass( "ui-dialog-buttons" );
8563                 this.uiDialogButtonPane.appendTo( this.uiDialog );
8564         },
8565
8566         _makeDraggable: function() {
8567                 var that = this,
8568                         options = this.options;
8569
8570                 function filteredUi( ui ) {
8571                         return {
8572                                 position: ui.position,
8573                                 offset: ui.offset
8574                         };
8575                 }
8576
8577                 this.uiDialog.draggable({
8578                         cancel: ".ui-dialog-content, .ui-dialog-titlebar-close",
8579                         handle: ".ui-dialog-titlebar",
8580                         containment: "document",
8581                         start: function( event, ui ) {
8582                                 $( this ).addClass( "ui-dialog-dragging" );
8583                                 that._blockFrames();
8584                                 that._trigger( "dragStart", event, filteredUi( ui ) );
8585                         },
8586                         drag: function( event, ui ) {
8587                                 that._trigger( "drag", event, filteredUi( ui ) );
8588                         },
8589                         stop: function( event, ui ) {
8590                                 var left = ui.offset.left - that.document.scrollLeft(),
8591                                         top = ui.offset.top - that.document.scrollTop();
8592
8593                                 options.position = {
8594                                         my: "left top",
8595                                         at: "left" + (left >= 0 ? "+" : "") + left + " " +
8596                                                 "top" + (top >= 0 ? "+" : "") + top,
8597                                         of: that.window
8598                                 };
8599                                 $( this ).removeClass( "ui-dialog-dragging" );
8600                                 that._unblockFrames();
8601                                 that._trigger( "dragStop", event, filteredUi( ui ) );
8602                         }
8603                 });
8604         },
8605
8606         _makeResizable: function() {
8607                 var that = this,
8608                         options = this.options,
8609                         handles = options.resizable,
8610                         // .ui-resizable has position: relative defined in the stylesheet
8611                         // but dialogs have to use absolute or fixed positioning
8612                         position = this.uiDialog.css("position"),
8613                         resizeHandles = typeof handles === "string" ?
8614                                 handles :
8615                                 "n,e,s,w,se,sw,ne,nw";
8616
8617                 function filteredUi( ui ) {
8618                         return {
8619                                 originalPosition: ui.originalPosition,
8620                                 originalSize: ui.originalSize,
8621                                 position: ui.position,
8622                                 size: ui.size
8623                         };
8624                 }
8625
8626                 this.uiDialog.resizable({
8627                         cancel: ".ui-dialog-content",
8628                         containment: "document",
8629                         alsoResize: this.element,
8630                         maxWidth: options.maxWidth,
8631                         maxHeight: options.maxHeight,
8632                         minWidth: options.minWidth,
8633                         minHeight: this._minHeight(),
8634                         handles: resizeHandles,
8635                         start: function( event, ui ) {
8636                                 $( this ).addClass( "ui-dialog-resizing" );
8637                                 that._blockFrames();
8638                                 that._trigger( "resizeStart", event, filteredUi( ui ) );
8639                         },
8640                         resize: function( event, ui ) {
8641                                 that._trigger( "resize", event, filteredUi( ui ) );
8642                         },
8643                         stop: function( event, ui ) {
8644                                 var offset = that.uiDialog.offset(),
8645                                         left = offset.left - that.document.scrollLeft(),
8646                                         top = offset.top - that.document.scrollTop();
8647
8648                                 options.height = that.uiDialog.height();
8649                                 options.width = that.uiDialog.width();
8650                                 options.position = {
8651                                         my: "left top",
8652                                         at: "left" + (left >= 0 ? "+" : "") + left + " " +
8653                                                 "top" + (top >= 0 ? "+" : "") + top,
8654                                         of: that.window
8655                                 };
8656                                 $( this ).removeClass( "ui-dialog-resizing" );
8657                                 that._unblockFrames();
8658                                 that._trigger( "resizeStop", event, filteredUi( ui ) );
8659                         }
8660                 })
8661                 .css( "position", position );
8662         },
8663
8664         _trackFocus: function() {
8665                 this._on( this.widget(), {
8666                         focusin: function( event ) {
8667                                 this._makeFocusTarget();
8668                                 this._focusedElement = $( event.target );
8669                         }
8670                 });
8671         },
8672
8673         _makeFocusTarget: function() {
8674                 this._untrackInstance();
8675                 this._trackingInstances().unshift( this );
8676         },
8677
8678         _untrackInstance: function() {
8679                 var instances = this._trackingInstances(),
8680                         exists = $.inArray( this, instances );
8681                 if ( exists !== -1 ) {
8682                         instances.splice( exists, 1 );
8683                 }
8684         },
8685
8686         _trackingInstances: function() {
8687                 var instances = this.document.data( "ui-dialog-instances" );
8688                 if ( !instances ) {
8689                         instances = [];
8690                         this.document.data( "ui-dialog-instances", instances );
8691                 }
8692                 return instances;
8693         },
8694
8695         _minHeight: function() {
8696                 var options = this.options;
8697
8698                 return options.height === "auto" ?
8699                         options.minHeight :
8700                         Math.min( options.minHeight, options.height );
8701         },
8702
8703         _position: function() {
8704                 // Need to show the dialog to get the actual offset in the position plugin
8705                 var isVisible = this.uiDialog.is( ":visible" );
8706                 if ( !isVisible ) {
8707                         this.uiDialog.show();
8708                 }
8709                 this.uiDialog.position( this.options.position );
8710                 if ( !isVisible ) {
8711                         this.uiDialog.hide();
8712                 }
8713         },
8714
8715         _setOptions: function( options ) {
8716                 var that = this,
8717                         resize = false,
8718                         resizableOptions = {};
8719
8720                 $.each( options, function( key, value ) {
8721                         that._setOption( key, value );
8722
8723                         if ( key in that.sizeRelatedOptions ) {
8724                                 resize = true;
8725                         }
8726                         if ( key in that.resizableRelatedOptions ) {
8727                                 resizableOptions[ key ] = value;
8728                         }
8729                 });
8730
8731                 if ( resize ) {
8732                         this._size();
8733                         this._position();
8734                 }
8735                 if ( this.uiDialog.is( ":data(ui-resizable)" ) ) {
8736                         this.uiDialog.resizable( "option", resizableOptions );
8737                 }
8738         },
8739
8740         _setOption: function( key, value ) {
8741                 var isDraggable, isResizable,
8742                         uiDialog = this.uiDialog;
8743
8744                 if ( key === "dialogClass" ) {
8745                         uiDialog
8746                                 .removeClass( this.options.dialogClass )
8747                                 .addClass( value );
8748                 }
8749
8750                 if ( key === "disabled" ) {
8751                         return;
8752                 }
8753
8754                 this._super( key, value );
8755
8756                 if ( key === "appendTo" ) {
8757                         this.uiDialog.appendTo( this._appendTo() );
8758                 }
8759
8760                 if ( key === "buttons" ) {
8761                         this._createButtons();
8762                 }
8763
8764                 if ( key === "closeText" ) {
8765                         this.uiDialogTitlebarClose.button({
8766                                 // Ensure that we always pass a string
8767                                 label: "" + value
8768                         });
8769                 }
8770
8771                 if ( key === "draggable" ) {
8772                         isDraggable = uiDialog.is( ":data(ui-draggable)" );
8773                         if ( isDraggable && !value ) {
8774                                 uiDialog.draggable( "destroy" );
8775                         }
8776
8777                         if ( !isDraggable && value ) {
8778                                 this._makeDraggable();
8779                         }
8780                 }
8781
8782                 if ( key === "position" ) {
8783                         this._position();
8784                 }
8785
8786                 if ( key === "resizable" ) {
8787                         // currently resizable, becoming non-resizable
8788                         isResizable = uiDialog.is( ":data(ui-resizable)" );
8789                         if ( isResizable && !value ) {
8790                                 uiDialog.resizable( "destroy" );
8791                         }
8792
8793                         // currently resizable, changing handles
8794                         if ( isResizable && typeof value === "string" ) {
8795                                 uiDialog.resizable( "option", "handles", value );
8796                         }
8797
8798                         // currently non-resizable, becoming resizable
8799                         if ( !isResizable && value !== false ) {
8800                                 this._makeResizable();
8801                         }
8802                 }
8803
8804                 if ( key === "title" ) {
8805                         this._title( this.uiDialogTitlebar.find( ".ui-dialog-title" ) );
8806                 }
8807         },
8808
8809         _size: function() {
8810                 // If the user has resized the dialog, the .ui-dialog and .ui-dialog-content
8811                 // divs will both have width and height set, so we need to reset them
8812                 var nonContentHeight, minContentHeight, maxContentHeight,
8813                         options = this.options;
8814
8815                 // Reset content sizing
8816                 this.element.show().css({
8817                         width: "auto",
8818                         minHeight: 0,
8819                         maxHeight: "none",
8820                         height: 0
8821                 });
8822
8823                 if ( options.minWidth > options.width ) {
8824                         options.width = options.minWidth;
8825                 }
8826
8827                 // reset wrapper sizing
8828                 // determine the height of all the non-content elements
8829                 nonContentHeight = this.uiDialog.css({
8830                                 height: "auto",
8831                                 width: options.width
8832                         })
8833                         .outerHeight();
8834                 minContentHeight = Math.max( 0, options.minHeight - nonContentHeight );
8835                 maxContentHeight = typeof options.maxHeight === "number" ?
8836                         Math.max( 0, options.maxHeight - nonContentHeight ) :
8837                         "none";
8838
8839                 if ( options.height === "auto" ) {
8840                         this.element.css({
8841                                 minHeight: minContentHeight,
8842                                 maxHeight: maxContentHeight,
8843                                 height: "auto"
8844                         });
8845                 } else {
8846                         this.element.height( Math.max( 0, options.height - nonContentHeight ) );
8847                 }
8848
8849                 if ( this.uiDialog.is( ":data(ui-resizable)" ) ) {
8850                         this.uiDialog.resizable( "option", "minHeight", this._minHeight() );
8851                 }
8852         },
8853
8854         _blockFrames: function() {
8855                 this.iframeBlocks = this.document.find( "iframe" ).map(function() {
8856                         var iframe = $( this );
8857
8858                         return $( "<div>" )
8859                                 .css({
8860                                         position: "absolute",
8861                                         width: iframe.outerWidth(),
8862                                         height: iframe.outerHeight()
8863                                 })
8864                                 .appendTo( iframe.parent() )
8865                                 .offset( iframe.offset() )[0];
8866                 });
8867         },
8868
8869         _unblockFrames: function() {
8870                 if ( this.iframeBlocks ) {
8871                         this.iframeBlocks.remove();
8872                         delete this.iframeBlocks;
8873                 }
8874         },
8875
8876         _allowInteraction: function( event ) {
8877                 if ( $( event.target ).closest( ".ui-dialog" ).length ) {
8878                         return true;
8879                 }
8880
8881                 // TODO: Remove hack when datepicker implements
8882                 // the .ui-front logic (#8989)
8883                 return !!$( event.target ).closest( ".ui-datepicker" ).length;
8884         },
8885
8886         _createOverlay: function() {
8887                 if ( !this.options.modal ) {
8888                         return;
8889                 }
8890
8891                 // We use a delay in case the overlay is created from an
8892                 // event that we're going to be cancelling (#2804)
8893                 var isOpening = true;
8894                 this._delay(function() {
8895                         isOpening = false;
8896                 });
8897
8898                 if ( !this.document.data( "ui-dialog-overlays" ) ) {
8899
8900                         // Prevent use of anchors and inputs
8901                         // Using _on() for an event handler shared across many instances is
8902                         // safe because the dialogs stack and must be closed in reverse order
8903                         this._on( this.document, {
8904                                 focusin: function( event ) {
8905                                         if ( isOpening ) {
8906                                                 return;
8907                                         }
8908
8909                                         if ( !this._allowInteraction( event ) ) {
8910                                                 event.preventDefault();
8911                                                 this._trackingInstances()[ 0 ]._focusTabbable();
8912                                         }
8913                                 }
8914                         });
8915                 }
8916
8917                 this.overlay = $( "<div>" )
8918                         .addClass( "ui-widget-overlay ui-front" )
8919                         .appendTo( this._appendTo() );
8920                 this._on( this.overlay, {
8921                         mousedown: "_keepFocus"
8922                 });
8923                 this.document.data( "ui-dialog-overlays",
8924                         (this.document.data( "ui-dialog-overlays" ) || 0) + 1 );
8925         },
8926
8927         _destroyOverlay: function() {
8928                 if ( !this.options.modal ) {
8929                         return;
8930                 }
8931
8932                 if ( this.overlay ) {
8933                         var overlays = this.document.data( "ui-dialog-overlays" ) - 1;
8934
8935                         if ( !overlays ) {
8936                                 this.document
8937                                         .unbind( "focusin" )
8938                                         .removeData( "ui-dialog-overlays" );
8939                         } else {
8940                                 this.document.data( "ui-dialog-overlays", overlays );
8941                         }
8942
8943                         this.overlay.remove();
8944                         this.overlay = null;
8945                 }
8946         }
8947 });
8948
8949
8950 /*!
8951  * jQuery UI Droppable 1.11.4
8952  * http://jqueryui.com
8953  *
8954  * Copyright jQuery Foundation and other contributors
8955  * Released under the MIT license.
8956  * http://jquery.org/license
8957  *
8958  * http://api.jqueryui.com/droppable/
8959  */
8960
8961
8962 $.widget( "ui.droppable", {
8963         version: "1.11.4",
8964         widgetEventPrefix: "drop",
8965         options: {
8966                 accept: "*",
8967                 activeClass: false,
8968                 addClasses: true,
8969                 greedy: false,
8970                 hoverClass: false,
8971                 scope: "default",
8972                 tolerance: "intersect",
8973
8974                 // callbacks
8975                 activate: null,
8976                 deactivate: null,
8977                 drop: null,
8978                 out: null,
8979                 over: null
8980         },
8981         _create: function() {
8982
8983                 var proportions,
8984                         o = this.options,
8985                         accept = o.accept;
8986
8987                 this.isover = false;
8988                 this.isout = true;
8989
8990                 this.accept = $.isFunction( accept ) ? accept : function( d ) {
8991                         return d.is( accept );
8992                 };
8993
8994                 this.proportions = function( /* valueToWrite */ ) {
8995                         if ( arguments.length ) {
8996                                 // Store the droppable's proportions
8997                                 proportions = arguments[ 0 ];
8998                         } else {
8999                                 // Retrieve or derive the droppable's proportions
9000                                 return proportions ?
9001                                         proportions :
9002                                         proportions = {
9003                                                 width: this.element[ 0 ].offsetWidth,
9004                                                 height: this.element[ 0 ].offsetHeight
9005                                         };
9006                         }
9007                 };
9008
9009                 this._addToManager( o.scope );
9010
9011                 o.addClasses && this.element.addClass( "ui-droppable" );
9012
9013         },
9014
9015         _addToManager: function( scope ) {
9016                 // Add the reference and positions to the manager
9017                 $.ui.ddmanager.droppables[ scope ] = $.ui.ddmanager.droppables[ scope ] || [];
9018                 $.ui.ddmanager.droppables[ scope ].push( this );
9019         },
9020
9021         _splice: function( drop ) {
9022                 var i = 0;
9023                 for ( ; i < drop.length; i++ ) {
9024                         if ( drop[ i ] === this ) {
9025                                 drop.splice( i, 1 );
9026                         }
9027                 }
9028         },
9029
9030         _destroy: function() {
9031                 var drop = $.ui.ddmanager.droppables[ this.options.scope ];
9032
9033                 this._splice( drop );
9034
9035                 this.element.removeClass( "ui-droppable ui-droppable-disabled" );
9036         },
9037
9038         _setOption: function( key, value ) {
9039
9040                 if ( key === "accept" ) {
9041                         this.accept = $.isFunction( value ) ? value : function( d ) {
9042                                 return d.is( value );
9043                         };
9044                 } else if ( key === "scope" ) {
9045                         var drop = $.ui.ddmanager.droppables[ this.options.scope ];
9046
9047                         this._splice( drop );
9048                         this._addToManager( value );
9049                 }
9050
9051                 this._super( key, value );
9052         },
9053
9054         _activate: function( event ) {
9055                 var draggable = $.ui.ddmanager.current;
9056                 if ( this.options.activeClass ) {
9057                         this.element.addClass( this.options.activeClass );
9058                 }
9059                 if ( draggable ){
9060                         this._trigger( "activate", event, this.ui( draggable ) );
9061                 }
9062         },
9063
9064         _deactivate: function( event ) {
9065                 var draggable = $.ui.ddmanager.current;
9066                 if ( this.options.activeClass ) {
9067                         this.element.removeClass( this.options.activeClass );
9068                 }
9069                 if ( draggable ){
9070                         this._trigger( "deactivate", event, this.ui( draggable ) );
9071                 }
9072         },
9073
9074         _over: function( event ) {
9075
9076                 var draggable = $.ui.ddmanager.current;
9077
9078                 // Bail if draggable and droppable are same element
9079                 if ( !draggable || ( draggable.currentItem || draggable.element )[ 0 ] === this.element[ 0 ] ) {
9080                         return;
9081                 }
9082
9083                 if ( this.accept.call( this.element[ 0 ], ( draggable.currentItem || draggable.element ) ) ) {
9084                         if ( this.options.hoverClass ) {
9085                                 this.element.addClass( this.options.hoverClass );
9086                         }
9087                         this._trigger( "over", event, this.ui( draggable ) );
9088                 }
9089
9090         },
9091
9092         _out: function( event ) {
9093
9094                 var draggable = $.ui.ddmanager.current;
9095
9096                 // Bail if draggable and droppable are same element
9097                 if ( !draggable || ( draggable.currentItem || draggable.element )[ 0 ] === this.element[ 0 ] ) {
9098                         return;
9099                 }
9100
9101                 if ( this.accept.call( this.element[ 0 ], ( draggable.currentItem || draggable.element ) ) ) {
9102                         if ( this.options.hoverClass ) {
9103                                 this.element.removeClass( this.options.hoverClass );
9104                         }
9105                         this._trigger( "out", event, this.ui( draggable ) );
9106                 }
9107
9108         },
9109
9110         _drop: function( event, custom ) {
9111
9112                 var draggable = custom || $.ui.ddmanager.current,
9113                         childrenIntersection = false;
9114
9115                 // Bail if draggable and droppable are same element
9116                 if ( !draggable || ( draggable.currentItem || draggable.element )[ 0 ] === this.element[ 0 ] ) {
9117                         return false;
9118                 }
9119
9120                 this.element.find( ":data(ui-droppable)" ).not( ".ui-draggable-dragging" ).each(function() {
9121                         var inst = $( this ).droppable( "instance" );
9122                         if (
9123                                 inst.options.greedy &&
9124                                 !inst.options.disabled &&
9125                                 inst.options.scope === draggable.options.scope &&
9126                                 inst.accept.call( inst.element[ 0 ], ( draggable.currentItem || draggable.element ) ) &&
9127                                 $.ui.intersect( draggable, $.extend( inst, { offset: inst.element.offset() } ), inst.options.tolerance, event )
9128                         ) { childrenIntersection = true; return false; }
9129                 });
9130                 if ( childrenIntersection ) {
9131                         return false;
9132                 }
9133
9134                 if ( this.accept.call( this.element[ 0 ], ( draggable.currentItem || draggable.element ) ) ) {
9135                         if ( this.options.activeClass ) {
9136                                 this.element.removeClass( this.options.activeClass );
9137                         }
9138                         if ( this.options.hoverClass ) {
9139                                 this.element.removeClass( this.options.hoverClass );
9140                         }
9141                         this._trigger( "drop", event, this.ui( draggable ) );
9142                         return this.element;
9143                 }
9144
9145                 return false;
9146
9147         },
9148
9149         ui: function( c ) {
9150                 return {
9151                         draggable: ( c.currentItem || c.element ),
9152                         helper: c.helper,
9153                         position: c.position,
9154                         offset: c.positionAbs
9155                 };
9156         }
9157
9158 });
9159
9160 $.ui.intersect = (function() {
9161         function isOverAxis( x, reference, size ) {
9162                 return ( x >= reference ) && ( x < ( reference + size ) );
9163         }
9164
9165         return function( draggable, droppable, toleranceMode, event ) {
9166
9167                 if ( !droppable.offset ) {
9168                         return false;
9169                 }
9170
9171                 var x1 = ( draggable.positionAbs || draggable.position.absolute ).left + draggable.margins.left,
9172                         y1 = ( draggable.positionAbs || draggable.position.absolute ).top + draggable.margins.top,
9173                         x2 = x1 + draggable.helperProportions.width,
9174                         y2 = y1 + draggable.helperProportions.height,
9175                         l = droppable.offset.left,
9176                         t = droppable.offset.top,
9177                         r = l + droppable.proportions().width,
9178                         b = t + droppable.proportions().height;
9179
9180                 switch ( toleranceMode ) {
9181                 case "fit":
9182                         return ( l <= x1 && x2 <= r && t <= y1 && y2 <= b );
9183                 case "intersect":
9184                         return ( l < x1 + ( draggable.helperProportions.width / 2 ) && // Right Half
9185                                 x2 - ( draggable.helperProportions.width / 2 ) < r && // Left Half
9186                                 t < y1 + ( draggable.helperProportions.height / 2 ) && // Bottom Half
9187                                 y2 - ( draggable.helperProportions.height / 2 ) < b ); // Top Half
9188                 case "pointer":
9189                         return isOverAxis( event.pageY, t, droppable.proportions().height ) && isOverAxis( event.pageX, l, droppable.proportions().width );
9190                 case "touch":
9191                         return (
9192                                 ( y1 >= t && y1 <= b ) || // Top edge touching
9193                                 ( y2 >= t && y2 <= b ) || // Bottom edge touching
9194                                 ( y1 < t && y2 > b ) // Surrounded vertically
9195                         ) && (
9196                                 ( x1 >= l && x1 <= r ) || // Left edge touching
9197                                 ( x2 >= l && x2 <= r ) || // Right edge touching
9198                                 ( x1 < l && x2 > r ) // Surrounded horizontally
9199                         );
9200                 default:
9201                         return false;
9202                 }
9203         };
9204 })();
9205
9206 /*
9207         This manager tracks offsets of draggables and droppables
9208 */
9209 $.ui.ddmanager = {
9210         current: null,
9211         droppables: { "default": [] },
9212         prepareOffsets: function( t, event ) {
9213
9214                 var i, j,
9215                         m = $.ui.ddmanager.droppables[ t.options.scope ] || [],
9216                         type = event ? event.type : null, // workaround for #2317
9217                         list = ( t.currentItem || t.element ).find( ":data(ui-droppable)" ).addBack();
9218
9219                 droppablesLoop: for ( i = 0; i < m.length; i++ ) {
9220
9221                         // No disabled and non-accepted
9222                         if ( m[ i ].options.disabled || ( t && !m[ i ].accept.call( m[ i ].element[ 0 ], ( t.currentItem || t.element ) ) ) ) {
9223                                 continue;
9224                         }
9225
9226                         // Filter out elements in the current dragged item
9227                         for ( j = 0; j < list.length; j++ ) {
9228                                 if ( list[ j ] === m[ i ].element[ 0 ] ) {
9229                                         m[ i ].proportions().height = 0;
9230                                         continue droppablesLoop;
9231                                 }
9232                         }
9233
9234                         m[ i ].visible = m[ i ].element.css( "display" ) !== "none";
9235                         if ( !m[ i ].visible ) {
9236                                 continue;
9237                         }
9238
9239                         // Activate the droppable if used directly from draggables
9240                         if ( type === "mousedown" ) {
9241                                 m[ i ]._activate.call( m[ i ], event );
9242                         }
9243
9244                         m[ i ].offset = m[ i ].element.offset();
9245                         m[ i ].proportions({ width: m[ i ].element[ 0 ].offsetWidth, height: m[ i ].element[ 0 ].offsetHeight });
9246
9247                 }
9248
9249         },
9250         drop: function( draggable, event ) {
9251
9252                 var dropped = false;
9253                 // Create a copy of the droppables in case the list changes during the drop (#9116)
9254                 $.each( ( $.ui.ddmanager.droppables[ draggable.options.scope ] || [] ).slice(), function() {
9255
9256                         if ( !this.options ) {
9257                                 return;
9258                         }
9259                         if ( !this.options.disabled && this.visible && $.ui.intersect( draggable, this, this.options.tolerance, event ) ) {
9260                                 dropped = this._drop.call( this, event ) || dropped;
9261                         }
9262
9263                         if ( !this.options.disabled && this.visible && this.accept.call( this.element[ 0 ], ( draggable.currentItem || draggable.element ) ) ) {
9264                                 this.isout = true;
9265                                 this.isover = false;
9266                                 this._deactivate.call( this, event );
9267                         }
9268
9269                 });
9270                 return dropped;
9271
9272         },
9273         dragStart: function( draggable, event ) {
9274                 // Listen for scrolling so that if the dragging causes scrolling the position of the droppables can be recalculated (see #5003)
9275                 draggable.element.parentsUntil( "body" ).bind( "scroll.droppable", function() {
9276                         if ( !draggable.options.refreshPositions ) {
9277                                 $.ui.ddmanager.prepareOffsets( draggable, event );
9278                         }
9279                 });
9280         },
9281         drag: function( draggable, event ) {
9282
9283                 // If you have a highly dynamic page, you might try this option. It renders positions every time you move the mouse.
9284                 if ( draggable.options.refreshPositions ) {
9285                         $.ui.ddmanager.prepareOffsets( draggable, event );
9286                 }
9287
9288                 // Run through all droppables and check their positions based on specific tolerance options
9289                 $.each( $.ui.ddmanager.droppables[ draggable.options.scope ] || [], function() {
9290
9291                         if ( this.options.disabled || this.greedyChild || !this.visible ) {
9292                                 return;
9293                         }
9294
9295                         var parentInstance, scope, parent,
9296                                 intersects = $.ui.intersect( draggable, this, this.options.tolerance, event ),
9297                                 c = !intersects && this.isover ? "isout" : ( intersects && !this.isover ? "isover" : null );
9298                         if ( !c ) {
9299                                 return;
9300                         }
9301
9302                         if ( this.options.greedy ) {
9303                                 // find droppable parents with same scope
9304                                 scope = this.options.scope;
9305                                 parent = this.element.parents( ":data(ui-droppable)" ).filter(function() {
9306                                         return $( this ).droppable( "instance" ).options.scope === scope;
9307                                 });
9308
9309                                 if ( parent.length ) {
9310                                         parentInstance = $( parent[ 0 ] ).droppable( "instance" );
9311                                         parentInstance.greedyChild = ( c === "isover" );
9312                                 }
9313                         }
9314
9315                         // we just moved into a greedy child
9316                         if ( parentInstance && c === "isover" ) {
9317                                 parentInstance.isover = false;
9318                                 parentInstance.isout = true;
9319                                 parentInstance._out.call( parentInstance, event );
9320                         }
9321
9322                         this[ c ] = true;
9323                         this[c === "isout" ? "isover" : "isout"] = false;
9324                         this[c === "isover" ? "_over" : "_out"].call( this, event );
9325
9326                         // we just moved out of a greedy child
9327                         if ( parentInstance && c === "isout" ) {
9328                                 parentInstance.isout = false;
9329                                 parentInstance.isover = true;
9330                                 parentInstance._over.call( parentInstance, event );
9331                         }
9332                 });
9333
9334         },
9335         dragStop: function( draggable, event ) {
9336                 draggable.element.parentsUntil( "body" ).unbind( "scroll.droppable" );
9337                 // Call prepareOffsets one final time since IE does not fire return scroll events when overflow was caused by drag (see #5003)
9338                 if ( !draggable.options.refreshPositions ) {
9339                         $.ui.ddmanager.prepareOffsets( draggable, event );
9340                 }
9341         }
9342 };
9343
9344 var droppable = $.ui.droppable;
9345
9346
9347 /*!
9348  * jQuery UI Effects 1.11.4
9349  * http://jqueryui.com
9350  *
9351  * Copyright jQuery Foundation and other contributors
9352  * Released under the MIT license.
9353  * http://jquery.org/license
9354  *
9355  * http://api.jqueryui.com/category/effects-core/
9356  */
9357
9358
9359 var dataSpace = "ui-effects-",
9360
9361         // Create a local jQuery because jQuery Color relies on it and the
9362         // global may not exist with AMD and a custom build (#10199)
9363         jQuery = $;
9364
9365 $.effects = {
9366         effect: {}
9367 };
9368
9369 /*!
9370  * jQuery Color Animations v2.1.2
9371  * https://github.com/jquery/jquery-color
9372  *
9373  * Copyright 2014 jQuery Foundation and other contributors
9374  * Released under the MIT license.
9375  * http://jquery.org/license
9376  *
9377  * Date: Wed Jan 16 08:47:09 2013 -0600
9378  */
9379 (function( jQuery, undefined ) {
9380
9381         var stepHooks = "backgroundColor borderBottomColor borderLeftColor borderRightColor borderTopColor color columnRuleColor outlineColor textDecorationColor textEmphasisColor",
9382
9383         // plusequals test for += 100 -= 100
9384         rplusequals = /^([\-+])=\s*(\d+\.?\d*)/,
9385         // a set of RE's that can match strings and generate color tuples.
9386         stringParsers = [ {
9387                         re: /rgba?\(\s*(\d{1,3})\s*,\s*(\d{1,3})\s*,\s*(\d{1,3})\s*(?:,\s*(\d?(?:\.\d+)?)\s*)?\)/,
9388                         parse: function( execResult ) {
9389                                 return [
9390                                         execResult[ 1 ],
9391                                         execResult[ 2 ],
9392                                         execResult[ 3 ],
9393                                         execResult[ 4 ]
9394                                 ];
9395                         }
9396                 }, {
9397                         re: /rgba?\(\s*(\d+(?:\.\d+)?)\%\s*,\s*(\d+(?:\.\d+)?)\%\s*,\s*(\d+(?:\.\d+)?)\%\s*(?:,\s*(\d?(?:\.\d+)?)\s*)?\)/,
9398                         parse: function( execResult ) {
9399                                 return [
9400                                         execResult[ 1 ] * 2.55,
9401                                         execResult[ 2 ] * 2.55,
9402                                         execResult[ 3 ] * 2.55,
9403                                         execResult[ 4 ]
9404                                 ];
9405                         }
9406                 }, {
9407                         // this regex ignores A-F because it's compared against an already lowercased string
9408                         re: /#([a-f0-9]{2})([a-f0-9]{2})([a-f0-9]{2})/,
9409                         parse: function( execResult ) {
9410                                 return [
9411                                         parseInt( execResult[ 1 ], 16 ),
9412                                         parseInt( execResult[ 2 ], 16 ),
9413                                         parseInt( execResult[ 3 ], 16 )
9414                                 ];
9415                         }
9416                 }, {
9417                         // this regex ignores A-F because it's compared against an already lowercased string
9418                         re: /#([a-f0-9])([a-f0-9])([a-f0-9])/,
9419                         parse: function( execResult ) {
9420                                 return [
9421                                         parseInt( execResult[ 1 ] + execResult[ 1 ], 16 ),
9422                                         parseInt( execResult[ 2 ] + execResult[ 2 ], 16 ),
9423                                         parseInt( execResult[ 3 ] + execResult[ 3 ], 16 )
9424                                 ];
9425                         }
9426                 }, {
9427                         re: /hsla?\(\s*(\d+(?:\.\d+)?)\s*,\s*(\d+(?:\.\d+)?)\%\s*,\s*(\d+(?:\.\d+)?)\%\s*(?:,\s*(\d?(?:\.\d+)?)\s*)?\)/,
9428                         space: "hsla",
9429                         parse: function( execResult ) {
9430                                 return [
9431                                         execResult[ 1 ],
9432                                         execResult[ 2 ] / 100,
9433                                         execResult[ 3 ] / 100,
9434                                         execResult[ 4 ]
9435                                 ];
9436                         }
9437                 } ],
9438
9439         // jQuery.Color( )
9440         color = jQuery.Color = function( color, green, blue, alpha ) {
9441                 return new jQuery.Color.fn.parse( color, green, blue, alpha );
9442         },
9443         spaces = {
9444                 rgba: {
9445                         props: {
9446                                 red: {
9447                                         idx: 0,
9448                                         type: "byte"
9449                                 },
9450                                 green: {
9451                                         idx: 1,
9452                                         type: "byte"
9453                                 },
9454                                 blue: {
9455                                         idx: 2,
9456                                         type: "byte"
9457                                 }
9458                         }
9459                 },
9460
9461                 hsla: {
9462                         props: {
9463                                 hue: {
9464                                         idx: 0,
9465                                         type: "degrees"
9466                                 },
9467                                 saturation: {
9468                                         idx: 1,
9469                                         type: "percent"
9470                                 },
9471                                 lightness: {
9472                                         idx: 2,
9473                                         type: "percent"
9474                                 }
9475                         }
9476                 }
9477         },
9478         propTypes = {
9479                 "byte": {
9480                         floor: true,
9481                         max: 255
9482                 },
9483                 "percent": {
9484                         max: 1
9485                 },
9486                 "degrees": {
9487                         mod: 360,
9488                         floor: true
9489                 }
9490         },
9491         support = color.support = {},
9492
9493         // element for support tests
9494         supportElem = jQuery( "<p>" )[ 0 ],
9495
9496         // colors = jQuery.Color.names
9497         colors,
9498
9499         // local aliases of functions called often
9500         each = jQuery.each;
9501
9502 // determine rgba support immediately
9503 supportElem.style.cssText = "background-color:rgba(1,1,1,.5)";
9504 support.rgba = supportElem.style.backgroundColor.indexOf( "rgba" ) > -1;
9505
9506 // define cache name and alpha properties
9507 // for rgba and hsla spaces
9508 each( spaces, function( spaceName, space ) {
9509         space.cache = "_" + spaceName;
9510         space.props.alpha = {
9511                 idx: 3,
9512                 type: "percent",
9513                 def: 1
9514         };
9515 });
9516
9517 function clamp( value, prop, allowEmpty ) {
9518         var type = propTypes[ prop.type ] || {};
9519
9520         if ( value == null ) {
9521                 return (allowEmpty || !prop.def) ? null : prop.def;
9522         }
9523
9524         // ~~ is an short way of doing floor for positive numbers
9525         value = type.floor ? ~~value : parseFloat( value );
9526
9527         // IE will pass in empty strings as value for alpha,
9528         // which will hit this case
9529         if ( isNaN( value ) ) {
9530                 return prop.def;
9531         }
9532
9533         if ( type.mod ) {
9534                 // we add mod before modding to make sure that negatives values
9535                 // get converted properly: -10 -> 350
9536                 return (value + type.mod) % type.mod;
9537         }
9538
9539         // for now all property types without mod have min and max
9540         return 0 > value ? 0 : type.max < value ? type.max : value;
9541 }
9542
9543 function stringParse( string ) {
9544         var inst = color(),
9545                 rgba = inst._rgba = [];
9546
9547         string = string.toLowerCase();
9548
9549         each( stringParsers, function( i, parser ) {
9550                 var parsed,
9551                         match = parser.re.exec( string ),
9552                         values = match && parser.parse( match ),
9553                         spaceName = parser.space || "rgba";
9554
9555                 if ( values ) {
9556                         parsed = inst[ spaceName ]( values );
9557
9558                         // if this was an rgba parse the assignment might happen twice
9559                         // oh well....
9560                         inst[ spaces[ spaceName ].cache ] = parsed[ spaces[ spaceName ].cache ];
9561                         rgba = inst._rgba = parsed._rgba;
9562
9563                         // exit each( stringParsers ) here because we matched
9564                         return false;
9565                 }
9566         });
9567
9568         // Found a stringParser that handled it
9569         if ( rgba.length ) {
9570
9571                 // if this came from a parsed string, force "transparent" when alpha is 0
9572                 // chrome, (and maybe others) return "transparent" as rgba(0,0,0,0)
9573                 if ( rgba.join() === "0,0,0,0" ) {
9574                         jQuery.extend( rgba, colors.transparent );
9575                 }
9576                 return inst;
9577         }
9578
9579         // named colors
9580         return colors[ string ];
9581 }
9582
9583 color.fn = jQuery.extend( color.prototype, {
9584         parse: function( red, green, blue, alpha ) {
9585                 if ( red === undefined ) {
9586                         this._rgba = [ null, null, null, null ];
9587                         return this;
9588                 }
9589                 if ( red.jquery || red.nodeType ) {
9590                         red = jQuery( red ).css( green );
9591                         green = undefined;
9592                 }
9593
9594                 var inst = this,
9595                         type = jQuery.type( red ),
9596                         rgba = this._rgba = [];
9597
9598                 // more than 1 argument specified - assume ( red, green, blue, alpha )
9599                 if ( green !== undefined ) {
9600                         red = [ red, green, blue, alpha ];
9601                         type = "array";
9602                 }
9603
9604                 if ( type === "string" ) {
9605                         return this.parse( stringParse( red ) || colors._default );
9606                 }
9607
9608                 if ( type === "array" ) {
9609                         each( spaces.rgba.props, function( key, prop ) {
9610                                 rgba[ prop.idx ] = clamp( red[ prop.idx ], prop );
9611                         });
9612                         return this;
9613                 }
9614
9615                 if ( type === "object" ) {
9616                         if ( red instanceof color ) {
9617                                 each( spaces, function( spaceName, space ) {
9618                                         if ( red[ space.cache ] ) {
9619                                                 inst[ space.cache ] = red[ space.cache ].slice();
9620                                         }
9621                                 });
9622                         } else {
9623                                 each( spaces, function( spaceName, space ) {
9624                                         var cache = space.cache;
9625                                         each( space.props, function( key, prop ) {
9626
9627                                                 // if the cache doesn't exist, and we know how to convert
9628                                                 if ( !inst[ cache ] && space.to ) {
9629
9630                                                         // if the value was null, we don't need to copy it
9631                                                         // if the key was alpha, we don't need to copy it either
9632                                                         if ( key === "alpha" || red[ key ] == null ) {
9633                                                                 return;
9634                                                         }
9635                                                         inst[ cache ] = space.to( inst._rgba );
9636                                                 }
9637
9638                                                 // this is the only case where we allow nulls for ALL properties.
9639                                                 // call clamp with alwaysAllowEmpty
9640                                                 inst[ cache ][ prop.idx ] = clamp( red[ key ], prop, true );
9641                                         });
9642
9643                                         // everything defined but alpha?
9644                                         if ( inst[ cache ] && jQuery.inArray( null, inst[ cache ].slice( 0, 3 ) ) < 0 ) {
9645                                                 // use the default of 1
9646                                                 inst[ cache ][ 3 ] = 1;
9647                                                 if ( space.from ) {
9648                                                         inst._rgba = space.from( inst[ cache ] );
9649                                                 }
9650                                         }
9651                                 });
9652                         }
9653                         return this;
9654                 }
9655         },
9656         is: function( compare ) {
9657                 var is = color( compare ),
9658                         same = true,
9659                         inst = this;
9660
9661                 each( spaces, function( _, space ) {
9662                         var localCache,
9663                                 isCache = is[ space.cache ];
9664                         if (isCache) {
9665                                 localCache = inst[ space.cache ] || space.to && space.to( inst._rgba ) || [];
9666                                 each( space.props, function( _, prop ) {
9667                                         if ( isCache[ prop.idx ] != null ) {
9668                                                 same = ( isCache[ prop.idx ] === localCache[ prop.idx ] );
9669                                                 return same;
9670                                         }
9671                                 });
9672                         }
9673                         return same;
9674                 });
9675                 return same;
9676         },
9677         _space: function() {
9678                 var used = [],
9679                         inst = this;
9680                 each( spaces, function( spaceName, space ) {
9681                         if ( inst[ space.cache ] ) {
9682                                 used.push( spaceName );
9683                         }
9684                 });
9685                 return used.pop();
9686         },
9687         transition: function( other, distance ) {
9688                 var end = color( other ),
9689                         spaceName = end._space(),
9690                         space = spaces[ spaceName ],
9691                         startColor = this.alpha() === 0 ? color( "transparent" ) : this,
9692                         start = startColor[ space.cache ] || space.to( startColor._rgba ),
9693                         result = start.slice();
9694
9695                 end = end[ space.cache ];
9696                 each( space.props, function( key, prop ) {
9697                         var index = prop.idx,
9698                                 startValue = start[ index ],
9699                                 endValue = end[ index ],
9700                                 type = propTypes[ prop.type ] || {};
9701
9702                         // if null, don't override start value
9703                         if ( endValue === null ) {
9704                                 return;
9705                         }
9706                         // if null - use end
9707                         if ( startValue === null ) {
9708                                 result[ index ] = endValue;
9709                         } else {
9710                                 if ( type.mod ) {
9711                                         if ( endValue - startValue > type.mod / 2 ) {
9712                                                 startValue += type.mod;
9713                                         } else if ( startValue - endValue > type.mod / 2 ) {
9714                                                 startValue -= type.mod;
9715                                         }
9716                                 }
9717                                 result[ index ] = clamp( ( endValue - startValue ) * distance + startValue, prop );
9718                         }
9719                 });
9720                 return this[ spaceName ]( result );
9721         },
9722         blend: function( opaque ) {
9723                 // if we are already opaque - return ourself
9724                 if ( this._rgba[ 3 ] === 1 ) {
9725                         return this;
9726                 }
9727
9728                 var rgb = this._rgba.slice(),
9729                         a = rgb.pop(),
9730                         blend = color( opaque )._rgba;
9731
9732                 return color( jQuery.map( rgb, function( v, i ) {
9733                         return ( 1 - a ) * blend[ i ] + a * v;
9734                 }));
9735         },
9736         toRgbaString: function() {
9737                 var prefix = "rgba(",
9738                         rgba = jQuery.map( this._rgba, function( v, i ) {
9739                                 return v == null ? ( i > 2 ? 1 : 0 ) : v;
9740                         });
9741
9742                 if ( rgba[ 3 ] === 1 ) {
9743                         rgba.pop();
9744                         prefix = "rgb(";
9745                 }
9746
9747                 return prefix + rgba.join() + ")";
9748         },
9749         toHslaString: function() {
9750                 var prefix = "hsla(",
9751                         hsla = jQuery.map( this.hsla(), function( v, i ) {
9752                                 if ( v == null ) {
9753                                         v = i > 2 ? 1 : 0;
9754                                 }
9755
9756                                 // catch 1 and 2
9757                                 if ( i && i < 3 ) {
9758                                         v = Math.round( v * 100 ) + "%";
9759                                 }
9760                                 return v;
9761                         });
9762
9763                 if ( hsla[ 3 ] === 1 ) {
9764                         hsla.pop();
9765                         prefix = "hsl(";
9766                 }
9767                 return prefix + hsla.join() + ")";
9768         },
9769         toHexString: function( includeAlpha ) {
9770                 var rgba = this._rgba.slice(),
9771                         alpha = rgba.pop();
9772
9773                 if ( includeAlpha ) {
9774                         rgba.push( ~~( alpha * 255 ) );
9775                 }
9776
9777                 return "#" + jQuery.map( rgba, function( v ) {
9778
9779                         // default to 0 when nulls exist
9780                         v = ( v || 0 ).toString( 16 );
9781                         return v.length === 1 ? "0" + v : v;
9782                 }).join("");
9783         },
9784         toString: function() {
9785                 return this._rgba[ 3 ] === 0 ? "transparent" : this.toRgbaString();
9786         }
9787 });
9788 color.fn.parse.prototype = color.fn;
9789
9790 // hsla conversions adapted from:
9791 // https://code.google.com/p/maashaack/source/browse/packages/graphics/trunk/src/graphics/colors/HUE2RGB.as?r=5021
9792
9793 function hue2rgb( p, q, h ) {
9794         h = ( h + 1 ) % 1;
9795         if ( h * 6 < 1 ) {
9796                 return p + ( q - p ) * h * 6;
9797         }
9798         if ( h * 2 < 1) {
9799                 return q;
9800         }
9801         if ( h * 3 < 2 ) {
9802                 return p + ( q - p ) * ( ( 2 / 3 ) - h ) * 6;
9803         }
9804         return p;
9805 }
9806
9807 spaces.hsla.to = function( rgba ) {
9808         if ( rgba[ 0 ] == null || rgba[ 1 ] == null || rgba[ 2 ] == null ) {
9809                 return [ null, null, null, rgba[ 3 ] ];
9810         }
9811         var r = rgba[ 0 ] / 255,
9812                 g = rgba[ 1 ] / 255,
9813                 b = rgba[ 2 ] / 255,
9814                 a = rgba[ 3 ],
9815                 max = Math.max( r, g, b ),
9816                 min = Math.min( r, g, b ),
9817                 diff = max - min,
9818                 add = max + min,
9819                 l = add * 0.5,
9820                 h, s;
9821
9822         if ( min === max ) {
9823                 h = 0;
9824         } else if ( r === max ) {
9825                 h = ( 60 * ( g - b ) / diff ) + 360;
9826         } else if ( g === max ) {
9827                 h = ( 60 * ( b - r ) / diff ) + 120;
9828         } else {
9829                 h = ( 60 * ( r - g ) / diff ) + 240;
9830         }
9831
9832         // chroma (diff) == 0 means greyscale which, by definition, saturation = 0%
9833         // otherwise, saturation is based on the ratio of chroma (diff) to lightness (add)
9834         if ( diff === 0 ) {
9835                 s = 0;
9836         } else if ( l <= 0.5 ) {
9837                 s = diff / add;
9838         } else {
9839                 s = diff / ( 2 - add );
9840         }
9841         return [ Math.round(h) % 360, s, l, a == null ? 1 : a ];
9842 };
9843
9844 spaces.hsla.from = function( hsla ) {
9845         if ( hsla[ 0 ] == null || hsla[ 1 ] == null || hsla[ 2 ] == null ) {
9846                 return [ null, null, null, hsla[ 3 ] ];
9847         }
9848         var h = hsla[ 0 ] / 360,
9849                 s = hsla[ 1 ],
9850                 l = hsla[ 2 ],
9851                 a = hsla[ 3 ],
9852                 q = l <= 0.5 ? l * ( 1 + s ) : l + s - l * s,
9853                 p = 2 * l - q;
9854
9855         return [
9856                 Math.round( hue2rgb( p, q, h + ( 1 / 3 ) ) * 255 ),
9857                 Math.round( hue2rgb( p, q, h ) * 255 ),
9858                 Math.round( hue2rgb( p, q, h - ( 1 / 3 ) ) * 255 ),
9859                 a
9860         ];
9861 };
9862
9863 each( spaces, function( spaceName, space ) {
9864         var props = space.props,
9865                 cache = space.cache,
9866                 to = space.to,
9867                 from = space.from;
9868
9869         // makes rgba() and hsla()
9870         color.fn[ spaceName ] = function( value ) {
9871
9872                 // generate a cache for this space if it doesn't exist
9873                 if ( to && !this[ cache ] ) {
9874                         this[ cache ] = to( this._rgba );
9875                 }
9876                 if ( value === undefined ) {
9877                         return this[ cache ].slice();
9878                 }
9879
9880                 var ret,
9881                         type = jQuery.type( value ),
9882                         arr = ( type === "array" || type === "object" ) ? value : arguments,
9883                         local = this[ cache ].slice();
9884
9885                 each( props, function( key, prop ) {
9886                         var val = arr[ type === "object" ? key : prop.idx ];
9887                         if ( val == null ) {
9888                                 val = local[ prop.idx ];
9889                         }
9890                         local[ prop.idx ] = clamp( val, prop );
9891                 });
9892
9893                 if ( from ) {
9894                         ret = color( from( local ) );
9895                         ret[ cache ] = local;
9896                         return ret;
9897                 } else {
9898                         return color( local );
9899                 }
9900         };
9901
9902         // makes red() green() blue() alpha() hue() saturation() lightness()
9903         each( props, function( key, prop ) {
9904                 // alpha is included in more than one space
9905                 if ( color.fn[ key ] ) {
9906                         return;
9907                 }
9908                 color.fn[ key ] = function( value ) {
9909                         var vtype = jQuery.type( value ),
9910                                 fn = ( key === "alpha" ? ( this._hsla ? "hsla" : "rgba" ) : spaceName ),
9911                                 local = this[ fn ](),
9912                                 cur = local[ prop.idx ],
9913                                 match;
9914
9915                         if ( vtype === "undefined" ) {
9916                                 return cur;
9917                         }
9918
9919                         if ( vtype === "function" ) {
9920                                 value = value.call( this, cur );
9921                                 vtype = jQuery.type( value );
9922                         }
9923                         if ( value == null && prop.empty ) {
9924                                 return this;
9925                         }
9926                         if ( vtype === "string" ) {
9927                                 match = rplusequals.exec( value );
9928                                 if ( match ) {
9929                                         value = cur + parseFloat( match[ 2 ] ) * ( match[ 1 ] === "+" ? 1 : -1 );
9930                                 }
9931                         }
9932                         local[ prop.idx ] = value;
9933                         return this[ fn ]( local );
9934                 };
9935         });
9936 });
9937
9938 // add cssHook and .fx.step function for each named hook.
9939 // accept a space separated string of properties
9940 color.hook = function( hook ) {
9941         var hooks = hook.split( " " );
9942         each( hooks, function( i, hook ) {
9943                 jQuery.cssHooks[ hook ] = {
9944                         set: function( elem, value ) {
9945                                 var parsed, curElem,
9946                                         backgroundColor = "";
9947
9948                                 if ( value !== "transparent" && ( jQuery.type( value ) !== "string" || ( parsed = stringParse( value ) ) ) ) {
9949                                         value = color( parsed || value );
9950                                         if ( !support.rgba && value._rgba[ 3 ] !== 1 ) {
9951                                                 curElem = hook === "backgroundColor" ? elem.parentNode : elem;
9952                                                 while (
9953                                                         (backgroundColor === "" || backgroundColor === "transparent") &&
9954                                                         curElem && curElem.style
9955                                                 ) {
9956                                                         try {
9957                                                                 backgroundColor = jQuery.css( curElem, "backgroundColor" );
9958                                                                 curElem = curElem.parentNode;
9959                                                         } catch ( e ) {
9960                                                         }
9961                                                 }
9962
9963                                                 value = value.blend( backgroundColor && backgroundColor !== "transparent" ?
9964                                                         backgroundColor :
9965                                                         "_default" );
9966                                         }
9967
9968                                         value = value.toRgbaString();
9969                                 }
9970                                 try {
9971                                         elem.style[ hook ] = value;
9972                                 } catch ( e ) {
9973                                         // wrapped to prevent IE from throwing errors on "invalid" values like 'auto' or 'inherit'
9974                                 }
9975                         }
9976                 };
9977                 jQuery.fx.step[ hook ] = function( fx ) {
9978                         if ( !fx.colorInit ) {
9979                                 fx.start = color( fx.elem, hook );
9980                                 fx.end = color( fx.end );
9981                                 fx.colorInit = true;
9982                         }
9983                         jQuery.cssHooks[ hook ].set( fx.elem, fx.start.transition( fx.end, fx.pos ) );
9984                 };
9985         });
9986
9987 };
9988
9989 color.hook( stepHooks );
9990
9991 jQuery.cssHooks.borderColor = {
9992         expand: function( value ) {
9993                 var expanded = {};
9994
9995                 each( [ "Top", "Right", "Bottom", "Left" ], function( i, part ) {
9996                         expanded[ "border" + part + "Color" ] = value;
9997                 });
9998                 return expanded;
9999         }
10000 };
10001
10002 // Basic color names only.
10003 // Usage of any of the other color names requires adding yourself or including
10004 // jquery.color.svg-names.js.
10005 colors = jQuery.Color.names = {
10006         // 4.1. Basic color keywords
10007         aqua: "#00ffff",
10008         black: "#000000",
10009         blue: "#0000ff",
10010         fuchsia: "#ff00ff",
10011         gray: "#808080",
10012         green: "#008000",
10013         lime: "#00ff00",
10014         maroon: "#800000",
10015         navy: "#000080",
10016         olive: "#808000",
10017         purple: "#800080",
10018         red: "#ff0000",
10019         silver: "#c0c0c0",
10020         teal: "#008080",
10021         white: "#ffffff",
10022         yellow: "#ffff00",
10023
10024         // 4.2.3. "transparent" color keyword
10025         transparent: [ null, null, null, 0 ],
10026
10027         _default: "#ffffff"
10028 };
10029
10030 })( jQuery );
10031
10032 /******************************************************************************/
10033 /****************************** CLASS ANIMATIONS ******************************/
10034 /******************************************************************************/
10035 (function() {
10036
10037 var classAnimationActions = [ "add", "remove", "toggle" ],
10038         shorthandStyles = {
10039                 border: 1,
10040                 borderBottom: 1,
10041                 borderColor: 1,
10042                 borderLeft: 1,
10043                 borderRight: 1,
10044                 borderTop: 1,
10045                 borderWidth: 1,
10046                 margin: 1,
10047                 padding: 1
10048         };
10049
10050 $.each([ "borderLeftStyle", "borderRightStyle", "borderBottomStyle", "borderTopStyle" ], function( _, prop ) {
10051         $.fx.step[ prop ] = function( fx ) {
10052                 if ( fx.end !== "none" && !fx.setAttr || fx.pos === 1 && !fx.setAttr ) {
10053                         jQuery.style( fx.elem, prop, fx.end );
10054                         fx.setAttr = true;
10055                 }
10056         };
10057 });
10058
10059 function getElementStyles( elem ) {
10060         var key, len,
10061                 style = elem.ownerDocument.defaultView ?
10062                         elem.ownerDocument.defaultView.getComputedStyle( elem, null ) :
10063                         elem.currentStyle,
10064                 styles = {};
10065
10066         if ( style && style.length && style[ 0 ] && style[ style[ 0 ] ] ) {
10067                 len = style.length;
10068                 while ( len-- ) {
10069                         key = style[ len ];
10070                         if ( typeof style[ key ] === "string" ) {
10071                                 styles[ $.camelCase( key ) ] = style[ key ];
10072                         }
10073                 }
10074         // support: Opera, IE <9
10075         } else {
10076                 for ( key in style ) {
10077                         if ( typeof style[ key ] === "string" ) {
10078                                 styles[ key ] = style[ key ];
10079                         }
10080                 }
10081         }
10082
10083         return styles;
10084 }
10085
10086 function styleDifference( oldStyle, newStyle ) {
10087         var diff = {},
10088                 name, value;
10089
10090         for ( name in newStyle ) {
10091                 value = newStyle[ name ];
10092                 if ( oldStyle[ name ] !== value ) {
10093                         if ( !shorthandStyles[ name ] ) {
10094                                 if ( $.fx.step[ name ] || !isNaN( parseFloat( value ) ) ) {
10095                                         diff[ name ] = value;
10096                                 }
10097                         }
10098                 }
10099         }
10100
10101         return diff;
10102 }
10103
10104 // support: jQuery <1.8
10105 if ( !$.fn.addBack ) {
10106         $.fn.addBack = function( selector ) {
10107                 return this.add( selector == null ?
10108                         this.prevObject : this.prevObject.filter( selector )
10109                 );
10110         };
10111 }
10112
10113 $.effects.animateClass = function( value, duration, easing, callback ) {
10114         var o = $.speed( duration, easing, callback );
10115
10116         return this.queue( function() {
10117                 var animated = $( this ),
10118                         baseClass = animated.attr( "class" ) || "",
10119                         applyClassChange,
10120                         allAnimations = o.children ? animated.find( "*" ).addBack() : animated;
10121
10122                 // map the animated objects to store the original styles.
10123                 allAnimations = allAnimations.map(function() {
10124                         var el = $( this );
10125                         return {
10126                                 el: el,
10127                                 start: getElementStyles( this )
10128                         };
10129                 });
10130
10131                 // apply class change
10132                 applyClassChange = function() {
10133                         $.each( classAnimationActions, function(i, action) {
10134                                 if ( value[ action ] ) {
10135                                         animated[ action + "Class" ]( value[ action ] );
10136                                 }
10137                         });
10138                 };
10139                 applyClassChange();
10140
10141                 // map all animated objects again - calculate new styles and diff
10142                 allAnimations = allAnimations.map(function() {
10143                         this.end = getElementStyles( this.el[ 0 ] );
10144                         this.diff = styleDifference( this.start, this.end );
10145                         return this;
10146                 });
10147
10148                 // apply original class
10149                 animated.attr( "class", baseClass );
10150
10151                 // map all animated objects again - this time collecting a promise
10152                 allAnimations = allAnimations.map(function() {
10153                         var styleInfo = this,
10154                                 dfd = $.Deferred(),
10155                                 opts = $.extend({}, o, {
10156                                         queue: false,
10157                                         complete: function() {
10158                                                 dfd.resolve( styleInfo );
10159                                         }
10160                                 });
10161
10162                         this.el.animate( this.diff, opts );
10163                         return dfd.promise();
10164                 });
10165
10166                 // once all animations have completed:
10167                 $.when.apply( $, allAnimations.get() ).done(function() {
10168
10169                         // set the final class
10170                         applyClassChange();
10171
10172                         // for each animated element,
10173                         // clear all css properties that were animated
10174                         $.each( arguments, function() {
10175                                 var el = this.el;
10176                                 $.each( this.diff, function(key) {
10177                                         el.css( key, "" );
10178                                 });
10179                         });
10180
10181                         // this is guarnteed to be there if you use jQuery.speed()
10182                         // it also handles dequeuing the next anim...
10183                         o.complete.call( animated[ 0 ] );
10184                 });
10185         });
10186 };
10187
10188 $.fn.extend({
10189         addClass: (function( orig ) {
10190                 return function( classNames, speed, easing, callback ) {
10191                         return speed ?
10192                                 $.effects.animateClass.call( this,
10193                                         { add: classNames }, speed, easing, callback ) :
10194                                 orig.apply( this, arguments );
10195                 };
10196         })( $.fn.addClass ),
10197
10198         removeClass: (function( orig ) {
10199                 return function( classNames, speed, easing, callback ) {
10200                         return arguments.length > 1 ?
10201                                 $.effects.animateClass.call( this,
10202                                         { remove: classNames }, speed, easing, callback ) :
10203                                 orig.apply( this, arguments );
10204                 };
10205         })( $.fn.removeClass ),
10206
10207         toggleClass: (function( orig ) {
10208                 return function( classNames, force, speed, easing, callback ) {
10209                         if ( typeof force === "boolean" || force === undefined ) {
10210                                 if ( !speed ) {
10211                                         // without speed parameter
10212                                         return orig.apply( this, arguments );
10213                                 } else {
10214                                         return $.effects.animateClass.call( this,
10215                                                 (force ? { add: classNames } : { remove: classNames }),
10216                                                 speed, easing, callback );
10217                                 }
10218                         } else {
10219                                 // without force parameter
10220                                 return $.effects.animateClass.call( this,
10221                                         { toggle: classNames }, force, speed, easing );
10222                         }
10223                 };
10224         })( $.fn.toggleClass ),
10225
10226         switchClass: function( remove, add, speed, easing, callback) {
10227                 return $.effects.animateClass.call( this, {
10228                         add: add,
10229                         remove: remove
10230                 }, speed, easing, callback );
10231         }
10232 });
10233
10234 })();
10235
10236 /******************************************************************************/
10237 /*********************************** EFFECTS **********************************/
10238 /******************************************************************************/
10239
10240 (function() {
10241
10242 $.extend( $.effects, {
10243         version: "1.11.4",
10244
10245         // Saves a set of properties in a data storage
10246         save: function( element, set ) {
10247                 for ( var i = 0; i < set.length; i++ ) {
10248                         if ( set[ i ] !== null ) {
10249                                 element.data( dataSpace + set[ i ], element[ 0 ].style[ set[ i ] ] );
10250                         }
10251                 }
10252         },
10253
10254         // Restores a set of previously saved properties from a data storage
10255         restore: function( element, set ) {
10256                 var val, i;
10257                 for ( i = 0; i < set.length; i++ ) {
10258                         if ( set[ i ] !== null ) {
10259                                 val = element.data( dataSpace + set[ i ] );
10260                                 // support: jQuery 1.6.2
10261                                 // http://bugs.jquery.com/ticket/9917
10262                                 // jQuery 1.6.2 incorrectly returns undefined for any falsy value.
10263                                 // We can't differentiate between "" and 0 here, so we just assume
10264                                 // empty string since it's likely to be a more common value...
10265                                 if ( val === undefined ) {
10266                                         val = "";
10267                                 }
10268                                 element.css( set[ i ], val );
10269                         }
10270                 }
10271         },
10272
10273         setMode: function( el, mode ) {
10274                 if (mode === "toggle") {
10275                         mode = el.is( ":hidden" ) ? "show" : "hide";
10276                 }
10277                 return mode;
10278         },
10279
10280         // Translates a [top,left] array into a baseline value
10281         // this should be a little more flexible in the future to handle a string & hash
10282         getBaseline: function( origin, original ) {
10283                 var y, x;
10284                 switch ( origin[ 0 ] ) {
10285                         case "top": y = 0; break;
10286                         case "middle": y = 0.5; break;
10287                         case "bottom": y = 1; break;
10288                         default: y = origin[ 0 ] / original.height;
10289                 }
10290                 switch ( origin[ 1 ] ) {
10291                         case "left": x = 0; break;
10292                         case "center": x = 0.5; break;
10293                         case "right": x = 1; break;
10294                         default: x = origin[ 1 ] / original.width;
10295                 }
10296                 return {
10297                         x: x,
10298                         y: y
10299                 };
10300         },
10301
10302         // Wraps the element around a wrapper that copies position properties
10303         createWrapper: function( element ) {
10304
10305                 // if the element is already wrapped, return it
10306                 if ( element.parent().is( ".ui-effects-wrapper" )) {
10307                         return element.parent();
10308                 }
10309
10310                 // wrap the element
10311                 var props = {
10312                                 width: element.outerWidth(true),
10313                                 height: element.outerHeight(true),
10314                                 "float": element.css( "float" )
10315                         },
10316                         wrapper = $( "<div></div>" )
10317                                 .addClass( "ui-effects-wrapper" )
10318                                 .css({
10319                                         fontSize: "100%",
10320                                         background: "transparent",
10321                                         border: "none",
10322                                         margin: 0,
10323                                         padding: 0
10324                                 }),
10325                         // Store the size in case width/height are defined in % - Fixes #5245
10326                         size = {
10327                                 width: element.width(),
10328                                 height: element.height()
10329                         },
10330                         active = document.activeElement;
10331
10332                 // support: Firefox
10333                 // Firefox incorrectly exposes anonymous content
10334                 // https://bugzilla.mozilla.org/show_bug.cgi?id=561664
10335                 try {
10336                         active.id;
10337                 } catch ( e ) {
10338                         active = document.body;
10339                 }
10340
10341                 element.wrap( wrapper );
10342
10343                 // Fixes #7595 - Elements lose focus when wrapped.
10344                 if ( element[ 0 ] === active || $.contains( element[ 0 ], active ) ) {
10345                         $( active ).focus();
10346                 }
10347
10348                 wrapper = element.parent(); //Hotfix for jQuery 1.4 since some change in wrap() seems to actually lose the reference to the wrapped element
10349
10350                 // transfer positioning properties to the wrapper
10351                 if ( element.css( "position" ) === "static" ) {
10352                         wrapper.css({ position: "relative" });
10353                         element.css({ position: "relative" });
10354                 } else {
10355                         $.extend( props, {
10356                                 position: element.css( "position" ),
10357                                 zIndex: element.css( "z-index" )
10358                         });
10359                         $.each([ "top", "left", "bottom", "right" ], function(i, pos) {
10360                                 props[ pos ] = element.css( pos );
10361                                 if ( isNaN( parseInt( props[ pos ], 10 ) ) ) {
10362                                         props[ pos ] = "auto";
10363                                 }
10364                         });
10365                         element.css({
10366                                 position: "relative",
10367                                 top: 0,
10368                                 left: 0,
10369                                 right: "auto",
10370                                 bottom: "auto"
10371                         });
10372                 }
10373                 element.css(size);
10374
10375                 return wrapper.css( props ).show();
10376         },
10377
10378         removeWrapper: function( element ) {
10379                 var active = document.activeElement;
10380
10381                 if ( element.parent().is( ".ui-effects-wrapper" ) ) {
10382                         element.parent().replaceWith( element );
10383
10384                         // Fixes #7595 - Elements lose focus when wrapped.
10385                         if ( element[ 0 ] === active || $.contains( element[ 0 ], active ) ) {
10386                                 $( active ).focus();
10387                         }
10388                 }
10389
10390                 return element;
10391         },
10392
10393         setTransition: function( element, list, factor, value ) {
10394                 value = value || {};
10395                 $.each( list, function( i, x ) {
10396                         var unit = element.cssUnit( x );
10397                         if ( unit[ 0 ] > 0 ) {
10398                                 value[ x ] = unit[ 0 ] * factor + unit[ 1 ];
10399                         }
10400                 });
10401                 return value;
10402         }
10403 });
10404
10405 // return an effect options object for the given parameters:
10406 function _normalizeArguments( effect, options, speed, callback ) {
10407
10408         // allow passing all options as the first parameter
10409         if ( $.isPlainObject( effect ) ) {
10410                 options = effect;
10411                 effect = effect.effect;
10412         }
10413
10414         // convert to an object
10415         effect = { effect: effect };
10416
10417         // catch (effect, null, ...)
10418         if ( options == null ) {
10419                 options = {};
10420         }
10421
10422         // catch (effect, callback)
10423         if ( $.isFunction( options ) ) {
10424                 callback = options;
10425                 speed = null;
10426                 options = {};
10427         }
10428
10429         // catch (effect, speed, ?)
10430         if ( typeof options === "number" || $.fx.speeds[ options ] ) {
10431                 callback = speed;
10432                 speed = options;
10433                 options = {};
10434         }
10435
10436         // catch (effect, options, callback)
10437         if ( $.isFunction( speed ) ) {
10438                 callback = speed;
10439                 speed = null;
10440         }
10441
10442         // add options to effect
10443         if ( options ) {
10444                 $.extend( effect, options );
10445         }
10446
10447         speed = speed || options.duration;
10448         effect.duration = $.fx.off ? 0 :
10449                 typeof speed === "number" ? speed :
10450                 speed in $.fx.speeds ? $.fx.speeds[ speed ] :
10451                 $.fx.speeds._default;
10452
10453         effect.complete = callback || options.complete;
10454
10455         return effect;
10456 }
10457
10458 function standardAnimationOption( option ) {
10459         // Valid standard speeds (nothing, number, named speed)
10460         if ( !option || typeof option === "number" || $.fx.speeds[ option ] ) {
10461                 return true;
10462         }
10463
10464         // Invalid strings - treat as "normal" speed
10465         if ( typeof option === "string" && !$.effects.effect[ option ] ) {
10466                 return true;
10467         }
10468
10469         // Complete callback
10470         if ( $.isFunction( option ) ) {
10471                 return true;
10472         }
10473
10474         // Options hash (but not naming an effect)
10475         if ( typeof option === "object" && !option.effect ) {
10476                 return true;
10477         }
10478
10479         // Didn't match any standard API
10480         return false;
10481 }
10482
10483 $.fn.extend({
10484         effect: function( /* effect, options, speed, callback */ ) {
10485                 var args = _normalizeArguments.apply( this, arguments ),
10486                         mode = args.mode,
10487                         queue = args.queue,
10488                         effectMethod = $.effects.effect[ args.effect ];
10489
10490                 if ( $.fx.off || !effectMethod ) {
10491                         // delegate to the original method (e.g., .show()) if possible
10492                         if ( mode ) {
10493                                 return this[ mode ]( args.duration, args.complete );
10494                         } else {
10495                                 return this.each( function() {
10496                                         if ( args.complete ) {
10497                                                 args.complete.call( this );
10498                                         }
10499                                 });
10500                         }
10501                 }
10502
10503                 function run( next ) {
10504                         var elem = $( this ),
10505                                 complete = args.complete,
10506                                 mode = args.mode;
10507
10508                         function done() {
10509                                 if ( $.isFunction( complete ) ) {
10510                                         complete.call( elem[0] );
10511                                 }
10512                                 if ( $.isFunction( next ) ) {
10513                                         next();
10514                                 }
10515                         }
10516
10517                         // If the element already has the correct final state, delegate to
10518                         // the core methods so the internal tracking of "olddisplay" works.
10519                         if ( elem.is( ":hidden" ) ? mode === "hide" : mode === "show" ) {
10520                                 elem[ mode ]();
10521                                 done();
10522                         } else {
10523                                 effectMethod.call( elem[0], args, done );
10524                         }
10525                 }
10526
10527                 return queue === false ? this.each( run ) : this.queue( queue || "fx", run );
10528         },
10529
10530         show: (function( orig ) {
10531                 return function( option ) {
10532                         if ( standardAnimationOption( option ) ) {
10533                                 return orig.apply( this, arguments );
10534                         } else {
10535                                 var args = _normalizeArguments.apply( this, arguments );
10536                                 args.mode = "show";
10537                                 return this.effect.call( this, args );
10538                         }
10539                 };
10540         })( $.fn.show ),
10541
10542         hide: (function( orig ) {
10543                 return function( option ) {
10544                         if ( standardAnimationOption( option ) ) {
10545                                 return orig.apply( this, arguments );
10546                         } else {
10547                                 var args = _normalizeArguments.apply( this, arguments );
10548                                 args.mode = "hide";
10549                                 return this.effect.call( this, args );
10550                         }
10551                 };
10552         })( $.fn.hide ),
10553
10554         toggle: (function( orig ) {
10555                 return function( option ) {
10556                         if ( standardAnimationOption( option ) || typeof option === "boolean" ) {
10557                                 return orig.apply( this, arguments );
10558                         } else {
10559                                 var args = _normalizeArguments.apply( this, arguments );
10560                                 args.mode = "toggle";
10561                                 return this.effect.call( this, args );
10562                         }
10563                 };
10564         })( $.fn.toggle ),
10565
10566         // helper functions
10567         cssUnit: function(key) {
10568                 var style = this.css( key ),
10569                         val = [];
10570
10571                 $.each( [ "em", "px", "%", "pt" ], function( i, unit ) {
10572                         if ( style.indexOf( unit ) > 0 ) {
10573                                 val = [ parseFloat( style ), unit ];
10574                         }
10575                 });
10576                 return val;
10577         }
10578 });
10579
10580 })();
10581
10582 /******************************************************************************/
10583 /*********************************** EASING ***********************************/
10584 /******************************************************************************/
10585
10586 (function() {
10587
10588 // based on easing equations from Robert Penner (http://www.robertpenner.com/easing)
10589
10590 var baseEasings = {};
10591
10592 $.each( [ "Quad", "Cubic", "Quart", "Quint", "Expo" ], function( i, name ) {
10593         baseEasings[ name ] = function( p ) {
10594                 return Math.pow( p, i + 2 );
10595         };
10596 });
10597
10598 $.extend( baseEasings, {
10599         Sine: function( p ) {
10600                 return 1 - Math.cos( p * Math.PI / 2 );
10601         },
10602         Circ: function( p ) {
10603                 return 1 - Math.sqrt( 1 - p * p );
10604         },
10605         Elastic: function( p ) {
10606                 return p === 0 || p === 1 ? p :
10607                         -Math.pow( 2, 8 * (p - 1) ) * Math.sin( ( (p - 1) * 80 - 7.5 ) * Math.PI / 15 );
10608         },
10609         Back: function( p ) {
10610                 return p * p * ( 3 * p - 2 );
10611         },
10612         Bounce: function( p ) {
10613                 var pow2,
10614                         bounce = 4;
10615
10616                 while ( p < ( ( pow2 = Math.pow( 2, --bounce ) ) - 1 ) / 11 ) {}
10617                 return 1 / Math.pow( 4, 3 - bounce ) - 7.5625 * Math.pow( ( pow2 * 3 - 2 ) / 22 - p, 2 );
10618         }
10619 });
10620
10621 $.each( baseEasings, function( name, easeIn ) {
10622         $.easing[ "easeIn" + name ] = easeIn;
10623         $.easing[ "easeOut" + name ] = function( p ) {
10624                 return 1 - easeIn( 1 - p );
10625         };
10626         $.easing[ "easeInOut" + name ] = function( p ) {
10627                 return p < 0.5 ?
10628                         easeIn( p * 2 ) / 2 :
10629                         1 - easeIn( p * -2 + 2 ) / 2;
10630         };
10631 });
10632
10633 })();
10634
10635 var effect = $.effects;
10636
10637
10638 /*!
10639  * jQuery UI Effects Blind 1.11.4
10640  * http://jqueryui.com
10641  *
10642  * Copyright jQuery Foundation and other contributors
10643  * Released under the MIT license.
10644  * http://jquery.org/license
10645  *
10646  * http://api.jqueryui.com/blind-effect/
10647  */
10648
10649
10650 var effectBlind = $.effects.effect.blind = function( o, done ) {
10651         // Create element
10652         var el = $( this ),
10653                 rvertical = /up|down|vertical/,
10654                 rpositivemotion = /up|left|vertical|horizontal/,
10655                 props = [ "position", "top", "bottom", "left", "right", "height", "width" ],
10656                 mode = $.effects.setMode( el, o.mode || "hide" ),
10657                 direction = o.direction || "up",
10658                 vertical = rvertical.test( direction ),
10659                 ref = vertical ? "height" : "width",
10660                 ref2 = vertical ? "top" : "left",
10661                 motion = rpositivemotion.test( direction ),
10662                 animation = {},
10663                 show = mode === "show",
10664                 wrapper, distance, margin;
10665
10666         // if already wrapped, the wrapper's properties are my property. #6245
10667         if ( el.parent().is( ".ui-effects-wrapper" ) ) {
10668                 $.effects.save( el.parent(), props );
10669         } else {
10670                 $.effects.save( el, props );
10671         }
10672         el.show();
10673         wrapper = $.effects.createWrapper( el ).css({
10674                 overflow: "hidden"
10675         });
10676
10677         distance = wrapper[ ref ]();
10678         margin = parseFloat( wrapper.css( ref2 ) ) || 0;
10679
10680         animation[ ref ] = show ? distance : 0;
10681         if ( !motion ) {
10682                 el
10683                         .css( vertical ? "bottom" : "right", 0 )
10684                         .css( vertical ? "top" : "left", "auto" )
10685                         .css({ position: "absolute" });
10686
10687                 animation[ ref2 ] = show ? margin : distance + margin;
10688         }
10689
10690         // start at 0 if we are showing
10691         if ( show ) {
10692                 wrapper.css( ref, 0 );
10693                 if ( !motion ) {
10694                         wrapper.css( ref2, margin + distance );
10695                 }
10696         }
10697
10698         // Animate
10699         wrapper.animate( animation, {
10700                 duration: o.duration,
10701                 easing: o.easing,
10702                 queue: false,
10703                 complete: function() {
10704                         if ( mode === "hide" ) {
10705                                 el.hide();
10706                         }
10707                         $.effects.restore( el, props );
10708                         $.effects.removeWrapper( el );
10709                         done();
10710                 }
10711         });
10712 };
10713
10714
10715 /*!
10716  * jQuery UI Effects Bounce 1.11.4
10717  * http://jqueryui.com
10718  *
10719  * Copyright jQuery Foundation and other contributors
10720  * Released under the MIT license.
10721  * http://jquery.org/license
10722  *
10723  * http://api.jqueryui.com/bounce-effect/
10724  */
10725
10726
10727 var effectBounce = $.effects.effect.bounce = function( o, done ) {
10728         var el = $( this ),
10729                 props = [ "position", "top", "bottom", "left", "right", "height", "width" ],
10730
10731                 // defaults:
10732                 mode = $.effects.setMode( el, o.mode || "effect" ),
10733                 hide = mode === "hide",
10734                 show = mode === "show",
10735                 direction = o.direction || "up",
10736                 distance = o.distance,
10737                 times = o.times || 5,
10738
10739                 // number of internal animations
10740                 anims = times * 2 + ( show || hide ? 1 : 0 ),
10741                 speed = o.duration / anims,
10742                 easing = o.easing,
10743
10744                 // utility:
10745                 ref = ( direction === "up" || direction === "down" ) ? "top" : "left",
10746                 motion = ( direction === "up" || direction === "left" ),
10747                 i,
10748                 upAnim,
10749                 downAnim,
10750
10751                 // we will need to re-assemble the queue to stack our animations in place
10752                 queue = el.queue(),
10753                 queuelen = queue.length;
10754
10755         // Avoid touching opacity to prevent clearType and PNG issues in IE
10756         if ( show || hide ) {
10757                 props.push( "opacity" );
10758         }
10759
10760         $.effects.save( el, props );
10761         el.show();
10762         $.effects.createWrapper( el ); // Create Wrapper
10763
10764         // default distance for the BIGGEST bounce is the outer Distance / 3
10765         if ( !distance ) {
10766                 distance = el[ ref === "top" ? "outerHeight" : "outerWidth" ]() / 3;
10767         }
10768
10769         if ( show ) {
10770                 downAnim = { opacity: 1 };
10771                 downAnim[ ref ] = 0;
10772
10773                 // if we are showing, force opacity 0 and set the initial position
10774                 // then do the "first" animation
10775                 el.css( "opacity", 0 )
10776                         .css( ref, motion ? -distance * 2 : distance * 2 )
10777                         .animate( downAnim, speed, easing );
10778         }
10779
10780         // start at the smallest distance if we are hiding
10781         if ( hide ) {
10782                 distance = distance / Math.pow( 2, times - 1 );
10783         }
10784
10785         downAnim = {};
10786         downAnim[ ref ] = 0;
10787         // Bounces up/down/left/right then back to 0 -- times * 2 animations happen here
10788         for ( i = 0; i < times; i++ ) {
10789                 upAnim = {};
10790                 upAnim[ ref ] = ( motion ? "-=" : "+=" ) + distance;
10791
10792                 el.animate( upAnim, speed, easing )
10793                         .animate( downAnim, speed, easing );
10794
10795                 distance = hide ? distance * 2 : distance / 2;
10796         }
10797
10798         // Last Bounce when Hiding
10799         if ( hide ) {
10800                 upAnim = { opacity: 0 };
10801                 upAnim[ ref ] = ( motion ? "-=" : "+=" ) + distance;
10802
10803                 el.animate( upAnim, speed, easing );
10804         }
10805
10806         el.queue(function() {
10807                 if ( hide ) {
10808                         el.hide();
10809                 }
10810                 $.effects.restore( el, props );
10811                 $.effects.removeWrapper( el );
10812                 done();
10813         });
10814
10815         // inject all the animations we just queued to be first in line (after "inprogress")
10816         if ( queuelen > 1) {
10817                 queue.splice.apply( queue,
10818                         [ 1, 0 ].concat( queue.splice( queuelen, anims + 1 ) ) );
10819         }
10820         el.dequeue();
10821
10822 };
10823
10824
10825 /*!
10826  * jQuery UI Effects Clip 1.11.4
10827  * http://jqueryui.com
10828  *
10829  * Copyright jQuery Foundation and other contributors
10830  * Released under the MIT license.
10831  * http://jquery.org/license
10832  *
10833  * http://api.jqueryui.com/clip-effect/
10834  */
10835
10836
10837 var effectClip = $.effects.effect.clip = function( o, done ) {
10838         // Create element
10839         var el = $( this ),
10840                 props = [ "position", "top", "bottom", "left", "right", "height", "width" ],
10841                 mode = $.effects.setMode( el, o.mode || "hide" ),
10842                 show = mode === "show",
10843                 direction = o.direction || "vertical",
10844                 vert = direction === "vertical",
10845                 size = vert ? "height" : "width",
10846                 position = vert ? "top" : "left",
10847                 animation = {},
10848                 wrapper, animate, distance;
10849
10850         // Save & Show
10851         $.effects.save( el, props );
10852         el.show();
10853
10854         // Create Wrapper
10855         wrapper = $.effects.createWrapper( el ).css({
10856                 overflow: "hidden"
10857         });
10858         animate = ( el[0].tagName === "IMG" ) ? wrapper : el;
10859         distance = animate[ size ]();
10860
10861         // Shift
10862         if ( show ) {
10863                 animate.css( size, 0 );
10864                 animate.css( position, distance / 2 );
10865         }
10866
10867         // Create Animation Object:
10868         animation[ size ] = show ? distance : 0;
10869         animation[ position ] = show ? 0 : distance / 2;
10870
10871         // Animate
10872         animate.animate( animation, {
10873                 queue: false,
10874                 duration: o.duration,
10875                 easing: o.easing,
10876                 complete: function() {
10877                         if ( !show ) {
10878                                 el.hide();
10879                         }
10880                         $.effects.restore( el, props );
10881                         $.effects.removeWrapper( el );
10882                         done();
10883                 }
10884         });
10885
10886 };
10887
10888
10889 /*!
10890  * jQuery UI Effects Drop 1.11.4
10891  * http://jqueryui.com
10892  *
10893  * Copyright jQuery Foundation and other contributors
10894  * Released under the MIT license.
10895  * http://jquery.org/license
10896  *
10897  * http://api.jqueryui.com/drop-effect/
10898  */
10899
10900
10901 var effectDrop = $.effects.effect.drop = function( o, done ) {
10902
10903         var el = $( this ),
10904                 props = [ "position", "top", "bottom", "left", "right", "opacity", "height", "width" ],
10905                 mode = $.effects.setMode( el, o.mode || "hide" ),
10906                 show = mode === "show",
10907                 direction = o.direction || "left",
10908                 ref = ( direction === "up" || direction === "down" ) ? "top" : "left",
10909                 motion = ( direction === "up" || direction === "left" ) ? "pos" : "neg",
10910                 animation = {
10911                         opacity: show ? 1 : 0
10912                 },
10913                 distance;
10914
10915         // Adjust
10916         $.effects.save( el, props );
10917         el.show();
10918         $.effects.createWrapper( el );
10919
10920         distance = o.distance || el[ ref === "top" ? "outerHeight" : "outerWidth" ]( true ) / 2;
10921
10922         if ( show ) {
10923                 el
10924                         .css( "opacity", 0 )
10925                         .css( ref, motion === "pos" ? -distance : distance );
10926         }
10927
10928         // Animation
10929         animation[ ref ] = ( show ?
10930                 ( motion === "pos" ? "+=" : "-=" ) :
10931                 ( motion === "pos" ? "-=" : "+=" ) ) +
10932                 distance;
10933
10934         // Animate
10935         el.animate( animation, {
10936                 queue: false,
10937                 duration: o.duration,
10938                 easing: o.easing,
10939                 complete: function() {
10940                         if ( mode === "hide" ) {
10941                                 el.hide();
10942                         }
10943                         $.effects.restore( el, props );
10944                         $.effects.removeWrapper( el );
10945                         done();
10946                 }
10947         });
10948 };
10949
10950
10951 /*!
10952  * jQuery UI Effects Explode 1.11.4
10953  * http://jqueryui.com
10954  *
10955  * Copyright jQuery Foundation and other contributors
10956  * Released under the MIT license.
10957  * http://jquery.org/license
10958  *
10959  * http://api.jqueryui.com/explode-effect/
10960  */
10961
10962
10963 var effectExplode = $.effects.effect.explode = function( o, done ) {
10964
10965         var rows = o.pieces ? Math.round( Math.sqrt( o.pieces ) ) : 3,
10966                 cells = rows,
10967                 el = $( this ),
10968                 mode = $.effects.setMode( el, o.mode || "hide" ),
10969                 show = mode === "show",
10970
10971                 // show and then visibility:hidden the element before calculating offset
10972                 offset = el.show().css( "visibility", "hidden" ).offset(),
10973
10974                 // width and height of a piece
10975                 width = Math.ceil( el.outerWidth() / cells ),
10976                 height = Math.ceil( el.outerHeight() / rows ),
10977                 pieces = [],
10978
10979                 // loop
10980                 i, j, left, top, mx, my;
10981
10982         // children animate complete:
10983         function childComplete() {
10984                 pieces.push( this );
10985                 if ( pieces.length === rows * cells ) {
10986                         animComplete();
10987                 }
10988         }
10989
10990         // clone the element for each row and cell.
10991         for ( i = 0; i < rows ; i++ ) { // ===>
10992                 top = offset.top + i * height;
10993                 my = i - ( rows - 1 ) / 2 ;
10994
10995                 for ( j = 0; j < cells ; j++ ) { // |||
10996                         left = offset.left + j * width;
10997                         mx = j - ( cells - 1 ) / 2 ;
10998
10999                         // Create a clone of the now hidden main element that will be absolute positioned
11000                         // within a wrapper div off the -left and -top equal to size of our pieces
11001                         el
11002                                 .clone()
11003                                 .appendTo( "body" )
11004                                 .wrap( "<div></div>" )
11005                                 .css({
11006                                         position: "absolute",
11007                                         visibility: "visible",
11008                                         left: -j * width,
11009                                         top: -i * height
11010                                 })
11011
11012                         // select the wrapper - make it overflow: hidden and absolute positioned based on
11013                         // where the original was located +left and +top equal to the size of pieces
11014                                 .parent()
11015                                 .addClass( "ui-effects-explode" )
11016                                 .css({
11017                                         position: "absolute",
11018                                         overflow: "hidden",
11019                                         width: width,
11020                                         height: height,
11021                                         left: left + ( show ? mx * width : 0 ),
11022                                         top: top + ( show ? my * height : 0 ),
11023                                         opacity: show ? 0 : 1
11024                                 }).animate({
11025                                         left: left + ( show ? 0 : mx * width ),
11026                                         top: top + ( show ? 0 : my * height ),
11027                                         opacity: show ? 1 : 0
11028                                 }, o.duration || 500, o.easing, childComplete );
11029                 }
11030         }
11031
11032         function animComplete() {
11033                 el.css({
11034                         visibility: "visible"
11035                 });
11036                 $( pieces ).remove();
11037                 if ( !show ) {
11038                         el.hide();
11039                 }
11040                 done();
11041         }
11042 };
11043
11044
11045 /*!
11046  * jQuery UI Effects Fade 1.11.4
11047  * http://jqueryui.com
11048  *
11049  * Copyright jQuery Foundation and other contributors
11050  * Released under the MIT license.
11051  * http://jquery.org/license
11052  *
11053  * http://api.jqueryui.com/fade-effect/
11054  */
11055
11056
11057 var effectFade = $.effects.effect.fade = function( o, done ) {
11058         var el = $( this ),
11059                 mode = $.effects.setMode( el, o.mode || "toggle" );
11060
11061         el.animate({
11062                 opacity: mode
11063         }, {
11064                 queue: false,
11065                 duration: o.duration,
11066                 easing: o.easing,
11067                 complete: done
11068         });
11069 };
11070
11071
11072 /*!
11073  * jQuery UI Effects Fold 1.11.4
11074  * http://jqueryui.com
11075  *
11076  * Copyright jQuery Foundation and other contributors
11077  * Released under the MIT license.
11078  * http://jquery.org/license
11079  *
11080  * http://api.jqueryui.com/fold-effect/
11081  */
11082
11083
11084 var effectFold = $.effects.effect.fold = function( o, done ) {
11085
11086         // Create element
11087         var el = $( this ),
11088                 props = [ "position", "top", "bottom", "left", "right", "height", "width" ],
11089                 mode = $.effects.setMode( el, o.mode || "hide" ),
11090                 show = mode === "show",
11091                 hide = mode === "hide",
11092                 size = o.size || 15,
11093                 percent = /([0-9]+)%/.exec( size ),
11094                 horizFirst = !!o.horizFirst,
11095                 widthFirst = show !== horizFirst,
11096                 ref = widthFirst ? [ "width", "height" ] : [ "height", "width" ],
11097                 duration = o.duration / 2,
11098                 wrapper, distance,
11099                 animation1 = {},
11100                 animation2 = {};
11101
11102         $.effects.save( el, props );
11103         el.show();
11104
11105         // Create Wrapper
11106         wrapper = $.effects.createWrapper( el ).css({
11107                 overflow: "hidden"
11108         });
11109         distance = widthFirst ?
11110                 [ wrapper.width(), wrapper.height() ] :
11111                 [ wrapper.height(), wrapper.width() ];
11112
11113         if ( percent ) {
11114                 size = parseInt( percent[ 1 ], 10 ) / 100 * distance[ hide ? 0 : 1 ];
11115         }
11116         if ( show ) {
11117                 wrapper.css( horizFirst ? {
11118                         height: 0,
11119                         width: size
11120                 } : {
11121                         height: size,
11122                         width: 0
11123                 });
11124         }
11125
11126         // Animation
11127         animation1[ ref[ 0 ] ] = show ? distance[ 0 ] : size;
11128         animation2[ ref[ 1 ] ] = show ? distance[ 1 ] : 0;
11129
11130         // Animate
11131         wrapper
11132                 .animate( animation1, duration, o.easing )
11133                 .animate( animation2, duration, o.easing, function() {
11134                         if ( hide ) {
11135                                 el.hide();
11136                         }
11137                         $.effects.restore( el, props );
11138                         $.effects.removeWrapper( el );
11139                         done();
11140                 });
11141
11142 };
11143
11144
11145 /*!
11146  * jQuery UI Effects Highlight 1.11.4
11147  * http://jqueryui.com
11148  *
11149  * Copyright jQuery Foundation and other contributors
11150  * Released under the MIT license.
11151  * http://jquery.org/license
11152  *
11153  * http://api.jqueryui.com/highlight-effect/
11154  */
11155
11156
11157 var effectHighlight = $.effects.effect.highlight = function( o, done ) {
11158         var elem = $( this ),
11159                 props = [ "backgroundImage", "backgroundColor", "opacity" ],
11160                 mode = $.effects.setMode( elem, o.mode || "show" ),
11161                 animation = {
11162                         backgroundColor: elem.css( "backgroundColor" )
11163                 };
11164
11165         if (mode === "hide") {
11166                 animation.opacity = 0;
11167         }
11168
11169         $.effects.save( elem, props );
11170
11171         elem
11172                 .show()
11173                 .css({
11174                         backgroundImage: "none",
11175                         backgroundColor: o.color || "#ffff99"
11176                 })
11177                 .animate( animation, {
11178                         queue: false,
11179                         duration: o.duration,
11180                         easing: o.easing,
11181                         complete: function() {
11182                                 if ( mode === "hide" ) {
11183                                         elem.hide();
11184                                 }
11185                                 $.effects.restore( elem, props );
11186                                 done();
11187                         }
11188                 });
11189 };
11190
11191
11192 /*!
11193  * jQuery UI Effects Size 1.11.4
11194  * http://jqueryui.com
11195  *
11196  * Copyright jQuery Foundation and other contributors
11197  * Released under the MIT license.
11198  * http://jquery.org/license
11199  *
11200  * http://api.jqueryui.com/size-effect/
11201  */
11202
11203
11204 var effectSize = $.effects.effect.size = function( o, done ) {
11205
11206         // Create element
11207         var original, baseline, factor,
11208                 el = $( this ),
11209                 props0 = [ "position", "top", "bottom", "left", "right", "width", "height", "overflow", "opacity" ],
11210
11211                 // Always restore
11212                 props1 = [ "position", "top", "bottom", "left", "right", "overflow", "opacity" ],
11213
11214                 // Copy for children
11215                 props2 = [ "width", "height", "overflow" ],
11216                 cProps = [ "fontSize" ],
11217                 vProps = [ "borderTopWidth", "borderBottomWidth", "paddingTop", "paddingBottom" ],
11218                 hProps = [ "borderLeftWidth", "borderRightWidth", "paddingLeft", "paddingRight" ],
11219
11220                 // Set options
11221                 mode = $.effects.setMode( el, o.mode || "effect" ),
11222                 restore = o.restore || mode !== "effect",
11223                 scale = o.scale || "both",
11224                 origin = o.origin || [ "middle", "center" ],
11225                 position = el.css( "position" ),
11226                 props = restore ? props0 : props1,
11227                 zero = {
11228                         height: 0,
11229                         width: 0,
11230                         outerHeight: 0,
11231                         outerWidth: 0
11232                 };
11233
11234         if ( mode === "show" ) {
11235                 el.show();
11236         }
11237         original = {
11238                 height: el.height(),
11239                 width: el.width(),
11240                 outerHeight: el.outerHeight(),
11241                 outerWidth: el.outerWidth()
11242         };
11243
11244         if ( o.mode === "toggle" && mode === "show" ) {
11245                 el.from = o.to || zero;
11246                 el.to = o.from || original;
11247         } else {
11248                 el.from = o.from || ( mode === "show" ? zero : original );
11249                 el.to = o.to || ( mode === "hide" ? zero : original );
11250         }
11251
11252         // Set scaling factor
11253         factor = {
11254                 from: {
11255                         y: el.from.height / original.height,
11256                         x: el.from.width / original.width
11257                 },
11258                 to: {
11259                         y: el.to.height / original.height,
11260                         x: el.to.width / original.width
11261                 }
11262         };
11263
11264         // Scale the css box
11265         if ( scale === "box" || scale === "both" ) {
11266
11267                 // Vertical props scaling
11268                 if ( factor.from.y !== factor.to.y ) {
11269                         props = props.concat( vProps );
11270                         el.from = $.effects.setTransition( el, vProps, factor.from.y, el.from );
11271                         el.to = $.effects.setTransition( el, vProps, factor.to.y, el.to );
11272                 }
11273
11274                 // Horizontal props scaling
11275                 if ( factor.from.x !== factor.to.x ) {
11276                         props = props.concat( hProps );
11277                         el.from = $.effects.setTransition( el, hProps, factor.from.x, el.from );
11278                         el.to = $.effects.setTransition( el, hProps, factor.to.x, el.to );
11279                 }
11280         }
11281
11282         // Scale the content
11283         if ( scale === "content" || scale === "both" ) {
11284
11285                 // Vertical props scaling
11286                 if ( factor.from.y !== factor.to.y ) {
11287                         props = props.concat( cProps ).concat( props2 );
11288                         el.from = $.effects.setTransition( el, cProps, factor.from.y, el.from );
11289                         el.to = $.effects.setTransition( el, cProps, factor.to.y, el.to );
11290                 }
11291         }
11292
11293         $.effects.save( el, props );
11294         el.show();
11295         $.effects.createWrapper( el );
11296         el.css( "overflow", "hidden" ).css( el.from );
11297
11298         // Adjust
11299         if (origin) { // Calculate baseline shifts
11300                 baseline = $.effects.getBaseline( origin, original );
11301                 el.from.top = ( original.outerHeight - el.outerHeight() ) * baseline.y;
11302                 el.from.left = ( original.outerWidth - el.outerWidth() ) * baseline.x;
11303                 el.to.top = ( original.outerHeight - el.to.outerHeight ) * baseline.y;
11304                 el.to.left = ( original.outerWidth - el.to.outerWidth ) * baseline.x;
11305         }
11306         el.css( el.from ); // set top & left
11307
11308         // Animate
11309         if ( scale === "content" || scale === "both" ) { // Scale the children
11310
11311                 // Add margins/font-size
11312                 vProps = vProps.concat([ "marginTop", "marginBottom" ]).concat(cProps);
11313                 hProps = hProps.concat([ "marginLeft", "marginRight" ]);
11314                 props2 = props0.concat(vProps).concat(hProps);
11315
11316                 el.find( "*[width]" ).each( function() {
11317                         var child = $( this ),
11318                                 c_original = {
11319                                         height: child.height(),
11320                                         width: child.width(),
11321                                         outerHeight: child.outerHeight(),
11322                                         outerWidth: child.outerWidth()
11323                                 };
11324                         if (restore) {
11325                                 $.effects.save(child, props2);
11326                         }
11327
11328                         child.from = {
11329                                 height: c_original.height * factor.from.y,
11330                                 width: c_original.width * factor.from.x,
11331                                 outerHeight: c_original.outerHeight * factor.from.y,
11332                                 outerWidth: c_original.outerWidth * factor.from.x
11333                         };
11334                         child.to = {
11335                                 height: c_original.height * factor.to.y,
11336                                 width: c_original.width * factor.to.x,
11337                                 outerHeight: c_original.height * factor.to.y,
11338                                 outerWidth: c_original.width * factor.to.x
11339                         };
11340
11341                         // Vertical props scaling
11342                         if ( factor.from.y !== factor.to.y ) {
11343                                 child.from = $.effects.setTransition( child, vProps, factor.from.y, child.from );
11344                                 child.to = $.effects.setTransition( child, vProps, factor.to.y, child.to );
11345                         }
11346
11347                         // Horizontal props scaling
11348                         if ( factor.from.x !== factor.to.x ) {
11349                                 child.from = $.effects.setTransition( child, hProps, factor.from.x, child.from );
11350                                 child.to = $.effects.setTransition( child, hProps, factor.to.x, child.to );
11351                         }
11352
11353                         // Animate children
11354                         child.css( child.from );
11355                         child.animate( child.to, o.duration, o.easing, function() {
11356
11357                                 // Restore children
11358                                 if ( restore ) {
11359                                         $.effects.restore( child, props2 );
11360                                 }
11361                         });
11362                 });
11363         }
11364
11365         // Animate
11366         el.animate( el.to, {
11367                 queue: false,
11368                 duration: o.duration,
11369                 easing: o.easing,
11370                 complete: function() {
11371                         if ( el.to.opacity === 0 ) {
11372                                 el.css( "opacity", el.from.opacity );
11373                         }
11374                         if ( mode === "hide" ) {
11375                                 el.hide();
11376                         }
11377                         $.effects.restore( el, props );
11378                         if ( !restore ) {
11379
11380                                 // we need to calculate our new positioning based on the scaling
11381                                 if ( position === "static" ) {
11382                                         el.css({
11383                                                 position: "relative",
11384                                                 top: el.to.top,
11385                                                 left: el.to.left
11386                                         });
11387                                 } else {
11388                                         $.each([ "top", "left" ], function( idx, pos ) {
11389                                                 el.css( pos, function( _, str ) {
11390                                                         var val = parseInt( str, 10 ),
11391                                                                 toRef = idx ? el.to.left : el.to.top;
11392
11393                                                         // if original was "auto", recalculate the new value from wrapper
11394                                                         if ( str === "auto" ) {
11395                                                                 return toRef + "px";
11396                                                         }
11397
11398                                                         return val + toRef + "px";
11399                                                 });
11400                                         });
11401                                 }
11402                         }
11403
11404                         $.effects.removeWrapper( el );
11405                         done();
11406                 }
11407         });
11408
11409 };
11410
11411
11412 /*!
11413  * jQuery UI Effects Scale 1.11.4
11414  * http://jqueryui.com
11415  *
11416  * Copyright jQuery Foundation and other contributors
11417  * Released under the MIT license.
11418  * http://jquery.org/license
11419  *
11420  * http://api.jqueryui.com/scale-effect/
11421  */
11422
11423
11424 var effectScale = $.effects.effect.scale = function( o, done ) {
11425
11426         // Create element
11427         var el = $( this ),
11428                 options = $.extend( true, {}, o ),
11429                 mode = $.effects.setMode( el, o.mode || "effect" ),
11430                 percent = parseInt( o.percent, 10 ) ||
11431                         ( parseInt( o.percent, 10 ) === 0 ? 0 : ( mode === "hide" ? 0 : 100 ) ),
11432                 direction = o.direction || "both",
11433                 origin = o.origin,
11434                 original = {
11435                         height: el.height(),
11436                         width: el.width(),
11437                         outerHeight: el.outerHeight(),
11438                         outerWidth: el.outerWidth()
11439                 },
11440                 factor = {
11441                         y: direction !== "horizontal" ? (percent / 100) : 1,
11442                         x: direction !== "vertical" ? (percent / 100) : 1
11443                 };
11444
11445         // We are going to pass this effect to the size effect:
11446         options.effect = "size";
11447         options.queue = false;
11448         options.complete = done;
11449
11450         // Set default origin and restore for show/hide
11451         if ( mode !== "effect" ) {
11452                 options.origin = origin || [ "middle", "center" ];
11453                 options.restore = true;
11454         }
11455
11456         options.from = o.from || ( mode === "show" ? {
11457                 height: 0,
11458                 width: 0,
11459                 outerHeight: 0,
11460                 outerWidth: 0
11461         } : original );
11462         options.to = {
11463                 height: original.height * factor.y,
11464                 width: original.width * factor.x,
11465                 outerHeight: original.outerHeight * factor.y,
11466                 outerWidth: original.outerWidth * factor.x
11467         };
11468
11469         // Fade option to support puff
11470         if ( options.fade ) {
11471                 if ( mode === "show" ) {
11472                         options.from.opacity = 0;
11473                         options.to.opacity = 1;
11474                 }
11475                 if ( mode === "hide" ) {
11476                         options.from.opacity = 1;
11477                         options.to.opacity = 0;
11478                 }
11479         }
11480
11481         // Animate
11482         el.effect( options );
11483
11484 };
11485
11486
11487 /*!
11488  * jQuery UI Effects Puff 1.11.4
11489  * http://jqueryui.com
11490  *
11491  * Copyright jQuery Foundation and other contributors
11492  * Released under the MIT license.
11493  * http://jquery.org/license
11494  *
11495  * http://api.jqueryui.com/puff-effect/
11496  */
11497
11498
11499 var effectPuff = $.effects.effect.puff = function( o, done ) {
11500         var elem = $( this ),
11501                 mode = $.effects.setMode( elem, o.mode || "hide" ),
11502                 hide = mode === "hide",
11503                 percent = parseInt( o.percent, 10 ) || 150,
11504                 factor = percent / 100,
11505                 original = {
11506                         height: elem.height(),
11507                         width: elem.width(),
11508                         outerHeight: elem.outerHeight(),
11509                         outerWidth: elem.outerWidth()
11510                 };
11511
11512         $.extend( o, {
11513                 effect: "scale",
11514                 queue: false,
11515                 fade: true,
11516                 mode: mode,
11517                 complete: done,
11518                 percent: hide ? percent : 100,
11519                 from: hide ?
11520                         original :
11521                         {
11522                                 height: original.height * factor,
11523                                 width: original.width * factor,
11524                                 outerHeight: original.outerHeight * factor,
11525                                 outerWidth: original.outerWidth * factor
11526                         }
11527         });
11528
11529         elem.effect( o );
11530 };
11531
11532
11533 /*!
11534  * jQuery UI Effects Pulsate 1.11.4
11535  * http://jqueryui.com
11536  *
11537  * Copyright jQuery Foundation and other contributors
11538  * Released under the MIT license.
11539  * http://jquery.org/license
11540  *
11541  * http://api.jqueryui.com/pulsate-effect/
11542  */
11543
11544
11545 var effectPulsate = $.effects.effect.pulsate = function( o, done ) {
11546         var elem = $( this ),
11547                 mode = $.effects.setMode( elem, o.mode || "show" ),
11548                 show = mode === "show",
11549                 hide = mode === "hide",
11550                 showhide = ( show || mode === "hide" ),
11551
11552                 // showing or hiding leaves of the "last" animation
11553                 anims = ( ( o.times || 5 ) * 2 ) + ( showhide ? 1 : 0 ),
11554                 duration = o.duration / anims,
11555                 animateTo = 0,
11556                 queue = elem.queue(),
11557                 queuelen = queue.length,
11558                 i;
11559
11560         if ( show || !elem.is(":visible")) {
11561                 elem.css( "opacity", 0 ).show();
11562                 animateTo = 1;
11563         }
11564
11565         // anims - 1 opacity "toggles"
11566         for ( i = 1; i < anims; i++ ) {
11567                 elem.animate({
11568                         opacity: animateTo
11569                 }, duration, o.easing );
11570                 animateTo = 1 - animateTo;
11571         }
11572
11573         elem.animate({
11574                 opacity: animateTo
11575         }, duration, o.easing);
11576
11577         elem.queue(function() {
11578                 if ( hide ) {
11579                         elem.hide();
11580                 }
11581                 done();
11582         });
11583
11584         // We just queued up "anims" animations, we need to put them next in the queue
11585         if ( queuelen > 1 ) {
11586                 queue.splice.apply( queue,
11587                         [ 1, 0 ].concat( queue.splice( queuelen, anims + 1 ) ) );
11588         }
11589         elem.dequeue();
11590 };
11591
11592
11593 /*!
11594  * jQuery UI Effects Shake 1.11.4
11595  * http://jqueryui.com
11596  *
11597  * Copyright jQuery Foundation and other contributors
11598  * Released under the MIT license.
11599  * http://jquery.org/license
11600  *
11601  * http://api.jqueryui.com/shake-effect/
11602  */
11603
11604
11605 var effectShake = $.effects.effect.shake = function( o, done ) {
11606
11607         var el = $( this ),
11608                 props = [ "position", "top", "bottom", "left", "right", "height", "width" ],
11609                 mode = $.effects.setMode( el, o.mode || "effect" ),
11610                 direction = o.direction || "left",
11611                 distance = o.distance || 20,
11612                 times = o.times || 3,
11613                 anims = times * 2 + 1,
11614                 speed = Math.round( o.duration / anims ),
11615                 ref = (direction === "up" || direction === "down") ? "top" : "left",
11616                 positiveMotion = (direction === "up" || direction === "left"),
11617                 animation = {},
11618                 animation1 = {},
11619                 animation2 = {},
11620                 i,
11621
11622                 // we will need to re-assemble the queue to stack our animations in place
11623                 queue = el.queue(),
11624                 queuelen = queue.length;
11625
11626         $.effects.save( el, props );
11627         el.show();
11628         $.effects.createWrapper( el );
11629
11630         // Animation
11631         animation[ ref ] = ( positiveMotion ? "-=" : "+=" ) + distance;
11632         animation1[ ref ] = ( positiveMotion ? "+=" : "-=" ) + distance * 2;
11633         animation2[ ref ] = ( positiveMotion ? "-=" : "+=" ) + distance * 2;
11634
11635         // Animate
11636         el.animate( animation, speed, o.easing );
11637
11638         // Shakes
11639         for ( i = 1; i < times; i++ ) {
11640                 el.animate( animation1, speed, o.easing ).animate( animation2, speed, o.easing );
11641         }
11642         el
11643                 .animate( animation1, speed, o.easing )
11644                 .animate( animation, speed / 2, o.easing )
11645                 .queue(function() {
11646                         if ( mode === "hide" ) {
11647                                 el.hide();
11648                         }
11649                         $.effects.restore( el, props );
11650                         $.effects.removeWrapper( el );
11651                         done();
11652                 });
11653
11654         // inject all the animations we just queued to be first in line (after "inprogress")
11655         if ( queuelen > 1) {
11656                 queue.splice.apply( queue,
11657                         [ 1, 0 ].concat( queue.splice( queuelen, anims + 1 ) ) );
11658         }
11659         el.dequeue();
11660
11661 };
11662
11663
11664 /*!
11665  * jQuery UI Effects Slide 1.11.4
11666  * http://jqueryui.com
11667  *
11668  * Copyright jQuery Foundation and other contributors
11669  * Released under the MIT license.
11670  * http://jquery.org/license
11671  *
11672  * http://api.jqueryui.com/slide-effect/
11673  */
11674
11675
11676 var effectSlide = $.effects.effect.slide = function( o, done ) {
11677
11678         // Create element
11679         var el = $( this ),
11680                 props = [ "position", "top", "bottom", "left", "right", "width", "height" ],
11681                 mode = $.effects.setMode( el, o.mode || "show" ),
11682                 show = mode === "show",
11683                 direction = o.direction || "left",
11684                 ref = (direction === "up" || direction === "down") ? "top" : "left",
11685                 positiveMotion = (direction === "up" || direction === "left"),
11686                 distance,
11687                 animation = {};
11688
11689         // Adjust
11690         $.effects.save( el, props );
11691         el.show();
11692         distance = o.distance || el[ ref === "top" ? "outerHeight" : "outerWidth" ]( true );
11693
11694         $.effects.createWrapper( el ).css({
11695                 overflow: "hidden"
11696         });
11697
11698         if ( show ) {
11699                 el.css( ref, positiveMotion ? (isNaN(distance) ? "-" + distance : -distance) : distance );
11700         }
11701
11702         // Animation
11703         animation[ ref ] = ( show ?
11704                 ( positiveMotion ? "+=" : "-=") :
11705                 ( positiveMotion ? "-=" : "+=")) +
11706                 distance;
11707
11708         // Animate
11709         el.animate( animation, {
11710                 queue: false,
11711                 duration: o.duration,
11712                 easing: o.easing,
11713                 complete: function() {
11714                         if ( mode === "hide" ) {
11715                                 el.hide();
11716                         }
11717                         $.effects.restore( el, props );
11718                         $.effects.removeWrapper( el );
11719                         done();
11720                 }
11721         });
11722 };
11723
11724
11725 /*!
11726  * jQuery UI Effects Transfer 1.11.4
11727  * http://jqueryui.com
11728  *
11729  * Copyright jQuery Foundation and other contributors
11730  * Released under the MIT license.
11731  * http://jquery.org/license
11732  *
11733  * http://api.jqueryui.com/transfer-effect/
11734  */
11735
11736
11737 var effectTransfer = $.effects.effect.transfer = function( o, done ) {
11738         var elem = $( this ),
11739                 target = $( o.to ),
11740                 targetFixed = target.css( "position" ) === "fixed",
11741                 body = $("body"),
11742                 fixTop = targetFixed ? body.scrollTop() : 0,
11743                 fixLeft = targetFixed ? body.scrollLeft() : 0,
11744                 endPosition = target.offset(),
11745                 animation = {
11746                         top: endPosition.top - fixTop,
11747                         left: endPosition.left - fixLeft,
11748                         height: target.innerHeight(),
11749                         width: target.innerWidth()
11750                 },
11751                 startPosition = elem.offset(),
11752                 transfer = $( "<div class='ui-effects-transfer'></div>" )
11753                         .appendTo( document.body )
11754                         .addClass( o.className )
11755                         .css({
11756                                 top: startPosition.top - fixTop,
11757                                 left: startPosition.left - fixLeft,
11758                                 height: elem.innerHeight(),
11759                                 width: elem.innerWidth(),
11760                                 position: targetFixed ? "fixed" : "absolute"
11761                         })
11762                         .animate( animation, o.duration, o.easing, function() {
11763                                 transfer.remove();
11764                                 done();
11765                         });
11766 };
11767
11768
11769 /*!
11770  * jQuery UI Progressbar 1.11.4
11771  * http://jqueryui.com
11772  *
11773  * Copyright jQuery Foundation and other contributors
11774  * Released under the MIT license.
11775  * http://jquery.org/license
11776  *
11777  * http://api.jqueryui.com/progressbar/
11778  */
11779
11780
11781 var progressbar = $.widget( "ui.progressbar", {
11782         version: "1.11.4",
11783         options: {
11784                 max: 100,
11785                 value: 0,
11786
11787                 change: null,
11788                 complete: null
11789         },
11790
11791         min: 0,
11792
11793         _create: function() {
11794                 // Constrain initial value
11795                 this.oldValue = this.options.value = this._constrainedValue();
11796
11797                 this.element
11798                         .addClass( "ui-progressbar ui-widget ui-widget-content ui-corner-all" )
11799                         .attr({
11800                                 // Only set static values, aria-valuenow and aria-valuemax are
11801                                 // set inside _refreshValue()
11802                                 role: "progressbar",
11803                                 "aria-valuemin": this.min
11804                         });
11805
11806                 this.valueDiv = $( "<div class='ui-progressbar-value ui-widget-header ui-corner-left'></div>" )
11807                         .appendTo( this.element );
11808
11809                 this._refreshValue();
11810         },
11811
11812         _destroy: function() {
11813                 this.element
11814                         .removeClass( "ui-progressbar ui-widget ui-widget-content ui-corner-all" )
11815                         .removeAttr( "role" )
11816                         .removeAttr( "aria-valuemin" )
11817                         .removeAttr( "aria-valuemax" )
11818                         .removeAttr( "aria-valuenow" );
11819
11820                 this.valueDiv.remove();
11821         },
11822
11823         value: function( newValue ) {
11824                 if ( newValue === undefined ) {
11825                         return this.options.value;
11826                 }
11827
11828                 this.options.value = this._constrainedValue( newValue );
11829                 this._refreshValue();
11830         },
11831
11832         _constrainedValue: function( newValue ) {
11833                 if ( newValue === undefined ) {
11834                         newValue = this.options.value;
11835                 }
11836
11837                 this.indeterminate = newValue === false;
11838
11839                 // sanitize value
11840                 if ( typeof newValue !== "number" ) {
11841                         newValue = 0;
11842                 }
11843
11844                 return this.indeterminate ? false :
11845                         Math.min( this.options.max, Math.max( this.min, newValue ) );
11846         },
11847
11848         _setOptions: function( options ) {
11849                 // Ensure "value" option is set after other values (like max)
11850                 var value = options.value;
11851                 delete options.value;
11852
11853                 this._super( options );
11854
11855                 this.options.value = this._constrainedValue( value );
11856                 this._refreshValue();
11857         },
11858
11859         _setOption: function( key, value ) {
11860                 if ( key === "max" ) {
11861                         // Don't allow a max less than min
11862                         value = Math.max( this.min, value );
11863                 }
11864                 if ( key === "disabled" ) {
11865                         this.element
11866                                 .toggleClass( "ui-state-disabled", !!value )
11867                                 .attr( "aria-disabled", value );
11868                 }
11869                 this._super( key, value );
11870         },
11871
11872         _percentage: function() {
11873                 return this.indeterminate ? 100 : 100 * ( this.options.value - this.min ) / ( this.options.max - this.min );
11874         },
11875
11876         _refreshValue: function() {
11877                 var value = this.options.value,
11878                         percentage = this._percentage();
11879
11880                 this.valueDiv
11881                         .toggle( this.indeterminate || value > this.min )
11882                         .toggleClass( "ui-corner-right", value === this.options.max )
11883                         .width( percentage.toFixed(0) + "%" );
11884
11885                 this.element.toggleClass( "ui-progressbar-indeterminate", this.indeterminate );
11886
11887                 if ( this.indeterminate ) {
11888                         this.element.removeAttr( "aria-valuenow" );
11889                         if ( !this.overlayDiv ) {
11890                                 this.overlayDiv = $( "<div class='ui-progressbar-overlay'></div>" ).appendTo( this.valueDiv );
11891                         }
11892                 } else {
11893                         this.element.attr({
11894                                 "aria-valuemax": this.options.max,
11895                                 "aria-valuenow": value
11896                         });
11897                         if ( this.overlayDiv ) {
11898                                 this.overlayDiv.remove();
11899                                 this.overlayDiv = null;
11900                         }
11901                 }
11902
11903                 if ( this.oldValue !== value ) {
11904                         this.oldValue = value;
11905                         this._trigger( "change" );
11906                 }
11907                 if ( value === this.options.max ) {
11908                         this._trigger( "complete" );
11909                 }
11910         }
11911 });
11912
11913
11914 /*!
11915  * jQuery UI Selectable 1.11.4
11916  * http://jqueryui.com
11917  *
11918  * Copyright jQuery Foundation and other contributors
11919  * Released under the MIT license.
11920  * http://jquery.org/license
11921  *
11922  * http://api.jqueryui.com/selectable/
11923  */
11924
11925
11926 var selectable = $.widget("ui.selectable", $.ui.mouse, {
11927         version: "1.11.4",
11928         options: {
11929                 appendTo: "body",
11930                 autoRefresh: true,
11931                 distance: 0,
11932                 filter: "*",
11933                 tolerance: "touch",
11934
11935                 // callbacks
11936                 selected: null,
11937                 selecting: null,
11938                 start: null,
11939                 stop: null,
11940                 unselected: null,
11941                 unselecting: null
11942         },
11943         _create: function() {
11944                 var selectees,
11945                         that = this;
11946
11947                 this.element.addClass("ui-selectable");
11948
11949                 this.dragged = false;
11950
11951                 // cache selectee children based on filter
11952                 this.refresh = function() {
11953                         selectees = $(that.options.filter, that.element[0]);
11954                         selectees.addClass("ui-selectee");
11955                         selectees.each(function() {
11956                                 var $this = $(this),
11957                                         pos = $this.offset();
11958                                 $.data(this, "selectable-item", {
11959                                         element: this,
11960                                         $element: $this,
11961                                         left: pos.left,
11962                                         top: pos.top,
11963                                         right: pos.left + $this.outerWidth(),
11964                                         bottom: pos.top + $this.outerHeight(),
11965                                         startselected: false,
11966                                         selected: $this.hasClass("ui-selected"),
11967                                         selecting: $this.hasClass("ui-selecting"),
11968                                         unselecting: $this.hasClass("ui-unselecting")
11969                                 });
11970                         });
11971                 };
11972                 this.refresh();
11973
11974                 this.selectees = selectees.addClass("ui-selectee");
11975
11976                 this._mouseInit();
11977
11978                 this.helper = $("<div class='ui-selectable-helper'></div>");
11979         },
11980
11981         _destroy: function() {
11982                 this.selectees
11983                         .removeClass("ui-selectee")
11984                         .removeData("selectable-item");
11985                 this.element
11986                         .removeClass("ui-selectable ui-selectable-disabled");
11987                 this._mouseDestroy();
11988         },
11989
11990         _mouseStart: function(event) {
11991                 var that = this,
11992                         options = this.options;
11993
11994                 this.opos = [ event.pageX, event.pageY ];
11995
11996                 if (this.options.disabled) {
11997                         return;
11998                 }
11999
12000                 this.selectees = $(options.filter, this.element[0]);
12001
12002                 this._trigger("start", event);
12003
12004                 $(options.appendTo).append(this.helper);
12005                 // position helper (lasso)
12006                 this.helper.css({
12007                         "left": event.pageX,
12008                         "top": event.pageY,
12009                         "width": 0,
12010                         "height": 0
12011                 });
12012
12013                 if (options.autoRefresh) {
12014                         this.refresh();
12015                 }
12016
12017                 this.selectees.filter(".ui-selected").each(function() {
12018                         var selectee = $.data(this, "selectable-item");
12019                         selectee.startselected = true;
12020                         if (!event.metaKey && !event.ctrlKey) {
12021                                 selectee.$element.removeClass("ui-selected");
12022                                 selectee.selected = false;
12023                                 selectee.$element.addClass("ui-unselecting");
12024                                 selectee.unselecting = true;
12025                                 // selectable UNSELECTING callback
12026                                 that._trigger("unselecting", event, {
12027                                         unselecting: selectee.element
12028                                 });
12029                         }
12030                 });
12031
12032                 $(event.target).parents().addBack().each(function() {
12033                         var doSelect,
12034                                 selectee = $.data(this, "selectable-item");
12035                         if (selectee) {
12036                                 doSelect = (!event.metaKey && !event.ctrlKey) || !selectee.$element.hasClass("ui-selected");
12037                                 selectee.$element
12038                                         .removeClass(doSelect ? "ui-unselecting" : "ui-selected")
12039                                         .addClass(doSelect ? "ui-selecting" : "ui-unselecting");
12040                                 selectee.unselecting = !doSelect;
12041                                 selectee.selecting = doSelect;
12042                                 selectee.selected = doSelect;
12043                                 // selectable (UN)SELECTING callback
12044                                 if (doSelect) {
12045                                         that._trigger("selecting", event, {
12046                                                 selecting: selectee.element
12047                                         });
12048                                 } else {
12049                                         that._trigger("unselecting", event, {
12050                                                 unselecting: selectee.element
12051                                         });
12052                                 }
12053                                 return false;
12054                         }
12055                 });
12056
12057         },
12058
12059         _mouseDrag: function(event) {
12060
12061                 this.dragged = true;
12062
12063                 if (this.options.disabled) {
12064                         return;
12065                 }
12066
12067                 var tmp,
12068                         that = this,
12069                         options = this.options,
12070                         x1 = this.opos[0],
12071                         y1 = this.opos[1],
12072                         x2 = event.pageX,
12073                         y2 = event.pageY;
12074
12075                 if (x1 > x2) { tmp = x2; x2 = x1; x1 = tmp; }
12076                 if (y1 > y2) { tmp = y2; y2 = y1; y1 = tmp; }
12077                 this.helper.css({ left: x1, top: y1, width: x2 - x1, height: y2 - y1 });
12078
12079                 this.selectees.each(function() {
12080                         var selectee = $.data(this, "selectable-item"),
12081                                 hit = false;
12082
12083                         //prevent helper from being selected if appendTo: selectable
12084                         if (!selectee || selectee.element === that.element[0]) {
12085                                 return;
12086                         }
12087
12088                         if (options.tolerance === "touch") {
12089                                 hit = ( !(selectee.left > x2 || selectee.right < x1 || selectee.top > y2 || selectee.bottom < y1) );
12090                         } else if (options.tolerance === "fit") {
12091                                 hit = (selectee.left > x1 && selectee.right < x2 && selectee.top > y1 && selectee.bottom < y2);
12092                         }
12093
12094                         if (hit) {
12095                                 // SELECT
12096                                 if (selectee.selected) {
12097                                         selectee.$element.removeClass("ui-selected");
12098                                         selectee.selected = false;
12099                                 }
12100                                 if (selectee.unselecting) {
12101                                         selectee.$element.removeClass("ui-unselecting");
12102                                         selectee.unselecting = false;
12103                                 }
12104                                 if (!selectee.selecting) {
12105                                         selectee.$element.addClass("ui-selecting");
12106                                         selectee.selecting = true;
12107                                         // selectable SELECTING callback
12108                                         that._trigger("selecting", event, {
12109                                                 selecting: selectee.element
12110                                         });
12111                                 }
12112                         } else {
12113                                 // UNSELECT
12114                                 if (selectee.selecting) {
12115                                         if ((event.metaKey || event.ctrlKey) && selectee.startselected) {
12116                                                 selectee.$element.removeClass("ui-selecting");
12117                                                 selectee.selecting = false;
12118                                                 selectee.$element.addClass("ui-selected");
12119                                                 selectee.selected = true;
12120                                         } else {
12121                                                 selectee.$element.removeClass("ui-selecting");
12122                                                 selectee.selecting = false;
12123                                                 if (selectee.startselected) {
12124                                                         selectee.$element.addClass("ui-unselecting");
12125                                                         selectee.unselecting = true;
12126                                                 }
12127                                                 // selectable UNSELECTING callback
12128                                                 that._trigger("unselecting", event, {
12129                                                         unselecting: selectee.element
12130                                                 });
12131                                         }
12132                                 }
12133                                 if (selectee.selected) {
12134                                         if (!event.metaKey && !event.ctrlKey && !selectee.startselected) {
12135                                                 selectee.$element.removeClass("ui-selected");
12136                                                 selectee.selected = false;
12137
12138                                                 selectee.$element.addClass("ui-unselecting");
12139                                                 selectee.unselecting = true;
12140                                                 // selectable UNSELECTING callback
12141                                                 that._trigger("unselecting", event, {
12142                                                         unselecting: selectee.element
12143                                                 });
12144                                         }
12145                                 }
12146                         }
12147                 });
12148
12149                 return false;
12150         },
12151
12152         _mouseStop: function(event) {
12153                 var that = this;
12154
12155                 this.dragged = false;
12156
12157                 $(".ui-unselecting", this.element[0]).each(function() {
12158                         var selectee = $.data(this, "selectable-item");
12159                         selectee.$element.removeClass("ui-unselecting");
12160                         selectee.unselecting = false;
12161                         selectee.startselected = false;
12162                         that._trigger("unselected", event, {
12163                                 unselected: selectee.element
12164                         });
12165                 });
12166                 $(".ui-selecting", this.element[0]).each(function() {
12167                         var selectee = $.data(this, "selectable-item");
12168                         selectee.$element.removeClass("ui-selecting").addClass("ui-selected");
12169                         selectee.selecting = false;
12170                         selectee.selected = true;
12171                         selectee.startselected = true;
12172                         that._trigger("selected", event, {
12173                                 selected: selectee.element
12174                         });
12175                 });
12176                 this._trigger("stop", event);
12177
12178                 this.helper.remove();
12179
12180                 return false;
12181         }
12182
12183 });
12184
12185
12186 /*!
12187  * jQuery UI Selectmenu 1.11.4
12188  * http://jqueryui.com
12189  *
12190  * Copyright jQuery Foundation and other contributors
12191  * Released under the MIT license.
12192  * http://jquery.org/license
12193  *
12194  * http://api.jqueryui.com/selectmenu
12195  */
12196
12197
12198 var selectmenu = $.widget( "ui.selectmenu", {
12199         version: "1.11.4",
12200         defaultElement: "<select>",
12201         options: {
12202                 appendTo: null,
12203                 disabled: null,
12204                 icons: {
12205                         button: "ui-icon-triangle-1-s"
12206                 },
12207                 position: {
12208                         my: "left top",
12209                         at: "left bottom",
12210                         collision: "none"
12211                 },
12212                 width: null,
12213
12214                 // callbacks
12215                 change: null,
12216                 close: null,
12217                 focus: null,
12218                 open: null,
12219                 select: null
12220         },
12221
12222         _create: function() {
12223                 var selectmenuId = this.element.uniqueId().attr( "id" );
12224                 this.ids = {
12225                         element: selectmenuId,
12226                         button: selectmenuId + "-button",
12227                         menu: selectmenuId + "-menu"
12228                 };
12229
12230                 this._drawButton();
12231                 this._drawMenu();
12232
12233                 if ( this.options.disabled ) {
12234                         this.disable();
12235                 }
12236         },
12237
12238         _drawButton: function() {
12239                 var that = this;
12240
12241                 // Associate existing label with the new button
12242                 this.label = $( "label[for='" + this.ids.element + "']" ).attr( "for", this.ids.button );
12243                 this._on( this.label, {
12244                         click: function( event ) {
12245                                 this.button.focus();
12246                                 event.preventDefault();
12247                         }
12248                 });
12249
12250                 // Hide original select element
12251                 this.element.hide();
12252
12253                 // Create button
12254                 this.button = $( "<span>", {
12255                         "class": "ui-selectmenu-button ui-widget ui-state-default ui-corner-all",
12256                         tabindex: this.options.disabled ? -1 : 0,
12257                         id: this.ids.button,
12258                         role: "combobox",
12259                         "aria-expanded": "false",
12260                         "aria-autocomplete": "list",
12261                         "aria-owns": this.ids.menu,
12262                         "aria-haspopup": "true"
12263                 })
12264                         .insertAfter( this.element );
12265
12266                 $( "<span>", {
12267                         "class": "ui-icon " + this.options.icons.button
12268                 })
12269                         .prependTo( this.button );
12270
12271                 this.buttonText = $( "<span>", {
12272                         "class": "ui-selectmenu-text"
12273                 })
12274                         .appendTo( this.button );
12275
12276                 this._setText( this.buttonText, this.element.find( "option:selected" ).text() );
12277                 this._resizeButton();
12278
12279                 this._on( this.button, this._buttonEvents );
12280                 this.button.one( "focusin", function() {
12281
12282                         // Delay rendering the menu items until the button receives focus.
12283                         // The menu may have already been rendered via a programmatic open.
12284                         if ( !that.menuItems ) {
12285                                 that._refreshMenu();
12286                         }
12287                 });
12288                 this._hoverable( this.button );
12289                 this._focusable( this.button );
12290         },
12291
12292         _drawMenu: function() {
12293                 var that = this;
12294
12295                 // Create menu
12296                 this.menu = $( "<ul>", {
12297                         "aria-hidden": "true",
12298                         "aria-labelledby": this.ids.button,
12299                         id: this.ids.menu
12300                 });
12301
12302                 // Wrap menu
12303                 this.menuWrap = $( "<div>", {
12304                         "class": "ui-selectmenu-menu ui-front"
12305                 })
12306                         .append( this.menu )
12307                         .appendTo( this._appendTo() );
12308
12309                 // Initialize menu widget
12310                 this.menuInstance = this.menu
12311                         .menu({
12312                                 role: "listbox",
12313                                 select: function( event, ui ) {
12314                                         event.preventDefault();
12315
12316                                         // support: IE8
12317                                         // If the item was selected via a click, the text selection
12318                                         // will be destroyed in IE
12319                                         that._setSelection();
12320
12321                                         that._select( ui.item.data( "ui-selectmenu-item" ), event );
12322                                 },
12323                                 focus: function( event, ui ) {
12324                                         var item = ui.item.data( "ui-selectmenu-item" );
12325
12326                                         // Prevent inital focus from firing and check if its a newly focused item
12327                                         if ( that.focusIndex != null && item.index !== that.focusIndex ) {
12328                                                 that._trigger( "focus", event, { item: item } );
12329                                                 if ( !that.isOpen ) {
12330                                                         that._select( item, event );
12331                                                 }
12332                                         }
12333                                         that.focusIndex = item.index;
12334
12335                                         that.button.attr( "aria-activedescendant",
12336                                                 that.menuItems.eq( item.index ).attr( "id" ) );
12337                                 }
12338                         })
12339                         .menu( "instance" );
12340
12341                 // Adjust menu styles to dropdown
12342                 this.menu
12343                         .addClass( "ui-corner-bottom" )
12344                         .removeClass( "ui-corner-all" );
12345
12346                 // Don't close the menu on mouseleave
12347                 this.menuInstance._off( this.menu, "mouseleave" );
12348
12349                 // Cancel the menu's collapseAll on document click
12350                 this.menuInstance._closeOnDocumentClick = function() {
12351                         return false;
12352                 };
12353
12354                 // Selects often contain empty items, but never contain dividers
12355                 this.menuInstance._isDivider = function() {
12356                         return false;
12357                 };
12358         },
12359
12360         refresh: function() {
12361                 this._refreshMenu();
12362                 this._setText( this.buttonText, this._getSelectedItem().text() );
12363                 if ( !this.options.width ) {
12364                         this._resizeButton();
12365                 }
12366         },
12367
12368         _refreshMenu: function() {
12369                 this.menu.empty();
12370
12371                 var item,
12372                         options = this.element.find( "option" );
12373
12374                 if ( !options.length ) {
12375                         return;
12376                 }
12377
12378                 this._parseOptions( options );
12379                 this._renderMenu( this.menu, this.items );
12380
12381                 this.menuInstance.refresh();
12382                 this.menuItems = this.menu.find( "li" ).not( ".ui-selectmenu-optgroup" );
12383
12384                 item = this._getSelectedItem();
12385
12386                 // Update the menu to have the correct item focused
12387                 this.menuInstance.focus( null, item );
12388                 this._setAria( item.data( "ui-selectmenu-item" ) );
12389
12390                 // Set disabled state
12391                 this._setOption( "disabled", this.element.prop( "disabled" ) );
12392         },
12393
12394         open: function( event ) {
12395                 if ( this.options.disabled ) {
12396                         return;
12397                 }
12398
12399                 // If this is the first time the menu is being opened, render the items
12400                 if ( !this.menuItems ) {
12401                         this._refreshMenu();
12402                 } else {
12403
12404                         // Menu clears focus on close, reset focus to selected item
12405                         this.menu.find( ".ui-state-focus" ).removeClass( "ui-state-focus" );
12406                         this.menuInstance.focus( null, this._getSelectedItem() );
12407                 }
12408
12409                 this.isOpen = true;
12410                 this._toggleAttr();
12411                 this._resizeMenu();
12412                 this._position();
12413
12414                 this._on( this.document, this._documentClick );
12415
12416                 this._trigger( "open", event );
12417         },
12418
12419         _position: function() {
12420                 this.menuWrap.position( $.extend( { of: this.button }, this.options.position ) );
12421         },
12422
12423         close: function( event ) {
12424                 if ( !this.isOpen ) {
12425                         return;
12426                 }
12427
12428                 this.isOpen = false;
12429                 this._toggleAttr();
12430
12431                 this.range = null;
12432                 this._off( this.document );
12433
12434                 this._trigger( "close", event );
12435         },
12436
12437         widget: function() {
12438                 return this.button;
12439         },
12440
12441         menuWidget: function() {
12442                 return this.menu;
12443         },
12444
12445         _renderMenu: function( ul, items ) {
12446                 var that = this,
12447                         currentOptgroup = "";
12448
12449                 $.each( items, function( index, item ) {
12450                         if ( item.optgroup !== currentOptgroup ) {
12451                                 $( "<li>", {
12452                                         "class": "ui-selectmenu-optgroup ui-menu-divider" +
12453                                                 ( item.element.parent( "optgroup" ).prop( "disabled" ) ?
12454                                                         " ui-state-disabled" :
12455                                                         "" ),
12456                                         text: item.optgroup
12457                                 })
12458                                         .appendTo( ul );
12459
12460                                 currentOptgroup = item.optgroup;
12461                         }
12462
12463                         that._renderItemData( ul, item );
12464                 });
12465         },
12466
12467         _renderItemData: function( ul, item ) {
12468                 return this._renderItem( ul, item ).data( "ui-selectmenu-item", item );
12469         },
12470
12471         _renderItem: function( ul, item ) {
12472                 var li = $( "<li>" );
12473
12474                 if ( item.disabled ) {
12475                         li.addClass( "ui-state-disabled" );
12476                 }
12477                 this._setText( li, item.label );
12478
12479                 return li.appendTo( ul );
12480         },
12481
12482         _setText: function( element, value ) {
12483                 if ( value ) {
12484                         element.text( value );
12485                 } else {
12486                         element.html( "&#160;" );
12487                 }
12488         },
12489
12490         _move: function( direction, event ) {
12491                 var item, next,
12492                         filter = ".ui-menu-item";
12493
12494                 if ( this.isOpen ) {
12495                         item = this.menuItems.eq( this.focusIndex );
12496                 } else {
12497                         item = this.menuItems.eq( this.element[ 0 ].selectedIndex );
12498                         filter += ":not(.ui-state-disabled)";
12499                 }
12500
12501                 if ( direction === "first" || direction === "last" ) {
12502                         next = item[ direction === "first" ? "prevAll" : "nextAll" ]( filter ).eq( -1 );
12503                 } else {
12504                         next = item[ direction + "All" ]( filter ).eq( 0 );
12505                 }
12506
12507                 if ( next.length ) {
12508                         this.menuInstance.focus( event, next );
12509                 }
12510         },
12511
12512         _getSelectedItem: function() {
12513                 return this.menuItems.eq( this.element[ 0 ].selectedIndex );
12514         },
12515
12516         _toggle: function( event ) {
12517                 this[ this.isOpen ? "close" : "open" ]( event );
12518         },
12519
12520         _setSelection: function() {
12521                 var selection;
12522
12523                 if ( !this.range ) {
12524                         return;
12525                 }
12526
12527                 if ( window.getSelection ) {
12528                         selection = window.getSelection();
12529                         selection.removeAllRanges();
12530                         selection.addRange( this.range );
12531
12532                 // support: IE8
12533                 } else {
12534                         this.range.select();
12535                 }
12536
12537                 // support: IE
12538                 // Setting the text selection kills the button focus in IE, but
12539                 // restoring the focus doesn't kill the selection.
12540                 this.button.focus();
12541         },
12542
12543         _documentClick: {
12544                 mousedown: function( event ) {
12545                         if ( !this.isOpen ) {
12546                                 return;
12547                         }
12548
12549                         if ( !$( event.target ).closest( ".ui-selectmenu-menu, #" + this.ids.button ).length ) {
12550                                 this.close( event );
12551                         }
12552                 }
12553         },
12554
12555         _buttonEvents: {
12556
12557                 // Prevent text selection from being reset when interacting with the selectmenu (#10144)
12558                 mousedown: function() {
12559                         var selection;
12560
12561                         if ( window.getSelection ) {
12562                                 selection = window.getSelection();
12563                                 if ( selection.rangeCount ) {
12564                                         this.range = selection.getRangeAt( 0 );
12565                                 }
12566
12567                         // support: IE8
12568                         } else {
12569                                 this.range = document.selection.createRange();
12570                         }
12571                 },
12572
12573                 click: function( event ) {
12574                         this._setSelection();
12575                         this._toggle( event );
12576                 },
12577
12578                 keydown: function( event ) {
12579                         var preventDefault = true;
12580                         switch ( event.keyCode ) {
12581                                 case $.ui.keyCode.TAB:
12582                                 case $.ui.keyCode.ESCAPE:
12583                                         this.close( event );
12584                                         preventDefault = false;
12585                                         break;
12586                                 case $.ui.keyCode.ENTER:
12587                                         if ( this.isOpen ) {
12588                                                 this._selectFocusedItem( event );
12589                                         }
12590                                         break;
12591                                 case $.ui.keyCode.UP:
12592                                         if ( event.altKey ) {
12593                                                 this._toggle( event );
12594                                         } else {
12595                                                 this._move( "prev", event );
12596                                         }
12597                                         break;
12598                                 case $.ui.keyCode.DOWN:
12599                                         if ( event.altKey ) {
12600                                                 this._toggle( event );
12601                                         } else {
12602                                                 this._move( "next", event );
12603                                         }
12604                                         break;
12605                                 case $.ui.keyCode.SPACE:
12606                                         if ( this.isOpen ) {
12607                                                 this._selectFocusedItem( event );
12608                                         } else {
12609                                                 this._toggle( event );
12610                                         }
12611                                         break;
12612                                 case $.ui.keyCode.LEFT:
12613                                         this._move( "prev", event );
12614                                         break;
12615                                 case $.ui.keyCode.RIGHT:
12616                                         this._move( "next", event );
12617                                         break;
12618                                 case $.ui.keyCode.HOME:
12619                                 case $.ui.keyCode.PAGE_UP:
12620                                         this._move( "first", event );
12621                                         break;
12622                                 case $.ui.keyCode.END:
12623                                 case $.ui.keyCode.PAGE_DOWN:
12624                                         this._move( "last", event );
12625                                         break;
12626                                 default:
12627                                         this.menu.trigger( event );
12628                                         preventDefault = false;
12629                         }
12630
12631                         if ( preventDefault ) {
12632                                 event.preventDefault();
12633                         }
12634                 }
12635         },
12636
12637         _selectFocusedItem: function( event ) {
12638                 var item = this.menuItems.eq( this.focusIndex );
12639                 if ( !item.hasClass( "ui-state-disabled" ) ) {
12640                         this._select( item.data( "ui-selectmenu-item" ), event );
12641                 }
12642         },
12643
12644         _select: function( item, event ) {
12645                 var oldIndex = this.element[ 0 ].selectedIndex;
12646
12647                 // Change native select element
12648                 this.element[ 0 ].selectedIndex = item.index;
12649                 this._setText( this.buttonText, item.label );
12650                 this._setAria( item );
12651                 this._trigger( "select", event, { item: item } );
12652
12653                 if ( item.index !== oldIndex ) {
12654                         this._trigger( "change", event, { item: item } );
12655                 }
12656
12657                 this.close( event );
12658         },
12659
12660         _setAria: function( item ) {
12661                 var id = this.menuItems.eq( item.index ).attr( "id" );
12662
12663                 this.button.attr({
12664                         "aria-labelledby": id,
12665                         "aria-activedescendant": id
12666                 });
12667                 this.menu.attr( "aria-activedescendant", id );
12668         },
12669
12670         _setOption: function( key, value ) {
12671                 if ( key === "icons" ) {
12672                         this.button.find( "span.ui-icon" )
12673                                 .removeClass( this.options.icons.button )
12674                                 .addClass( value.button );
12675                 }
12676
12677                 this._super( key, value );
12678
12679                 if ( key === "appendTo" ) {
12680                         this.menuWrap.appendTo( this._appendTo() );
12681                 }
12682
12683                 if ( key === "disabled" ) {
12684                         this.menuInstance.option( "disabled", value );
12685                         this.button
12686                                 .toggleClass( "ui-state-disabled", value )
12687                                 .attr( "aria-disabled", value );
12688
12689                         this.element.prop( "disabled", value );
12690                         if ( value ) {
12691                                 this.button.attr( "tabindex", -1 );
12692                                 this.close();
12693                         } else {
12694                                 this.button.attr( "tabindex", 0 );
12695                         }
12696                 }
12697
12698                 if ( key === "width" ) {
12699                         this._resizeButton();
12700                 }
12701         },
12702
12703         _appendTo: function() {
12704                 var element = this.options.appendTo;
12705
12706                 if ( element ) {
12707                         element = element.jquery || element.nodeType ?
12708                                 $( element ) :
12709                                 this.document.find( element ).eq( 0 );
12710                 }
12711
12712                 if ( !element || !element[ 0 ] ) {
12713                         element = this.element.closest( ".ui-front" );
12714                 }
12715
12716                 if ( !element.length ) {
12717                         element = this.document[ 0 ].body;
12718                 }
12719
12720                 return element;
12721         },
12722
12723         _toggleAttr: function() {
12724                 this.button
12725                         .toggleClass( "ui-corner-top", this.isOpen )
12726                         .toggleClass( "ui-corner-all", !this.isOpen )
12727                         .attr( "aria-expanded", this.isOpen );
12728                 this.menuWrap.toggleClass( "ui-selectmenu-open", this.isOpen );
12729                 this.menu.attr( "aria-hidden", !this.isOpen );
12730         },
12731
12732         _resizeButton: function() {
12733                 var width = this.options.width;
12734
12735                 if ( !width ) {
12736                         width = this.element.show().outerWidth();
12737                         this.element.hide();
12738                 }
12739
12740                 this.button.outerWidth( width );
12741         },
12742
12743         _resizeMenu: function() {
12744                 this.menu.outerWidth( Math.max(
12745                         this.button.outerWidth(),
12746
12747                         // support: IE10
12748                         // IE10 wraps long text (possibly a rounding bug)
12749                         // so we add 1px to avoid the wrapping
12750                         this.menu.width( "" ).outerWidth() + 1
12751                 ) );
12752         },
12753
12754         _getCreateOptions: function() {
12755                 return { disabled: this.element.prop( "disabled" ) };
12756         },
12757
12758         _parseOptions: function( options ) {
12759                 var data = [];
12760                 options.each(function( index, item ) {
12761                         var option = $( item ),
12762                                 optgroup = option.parent( "optgroup" );
12763                         data.push({
12764                                 element: option,
12765                                 index: index,
12766                                 value: option.val(),
12767                                 label: option.text(),
12768                                 optgroup: optgroup.attr( "label" ) || "",
12769                                 disabled: optgroup.prop( "disabled" ) || option.prop( "disabled" )
12770                         });
12771                 });
12772                 this.items = data;
12773         },
12774
12775         _destroy: function() {
12776                 this.menuWrap.remove();
12777                 this.button.remove();
12778                 this.element.show();
12779                 this.element.removeUniqueId();
12780                 this.label.attr( "for", this.ids.element );
12781         }
12782 });
12783
12784
12785 /*!
12786  * jQuery UI Slider 1.11.4
12787  * http://jqueryui.com
12788  *
12789  * Copyright jQuery Foundation and other contributors
12790  * Released under the MIT license.
12791  * http://jquery.org/license
12792  *
12793  * http://api.jqueryui.com/slider/
12794  */
12795
12796
12797 var slider = $.widget( "ui.slider", $.ui.mouse, {
12798         version: "1.11.4",
12799         widgetEventPrefix: "slide",
12800
12801         options: {
12802                 animate: false,
12803                 distance: 0,
12804                 max: 100,
12805                 min: 0,
12806                 orientation: "horizontal",
12807                 range: false,
12808                 step: 1,
12809                 value: 0,
12810                 values: null,
12811
12812                 // callbacks
12813                 change: null,
12814                 slide: null,
12815                 start: null,
12816                 stop: null
12817         },
12818
12819         // number of pages in a slider
12820         // (how many times can you page up/down to go through the whole range)
12821         numPages: 5,
12822
12823         _create: function() {
12824                 this._keySliding = false;
12825                 this._mouseSliding = false;
12826                 this._animateOff = true;
12827                 this._handleIndex = null;
12828                 this._detectOrientation();
12829                 this._mouseInit();
12830                 this._calculateNewMax();
12831
12832                 this.element
12833                         .addClass( "ui-slider" +
12834                                 " ui-slider-" + this.orientation +
12835                                 " ui-widget" +
12836                                 " ui-widget-content" +
12837                                 " ui-corner-all");
12838
12839                 this._refresh();
12840                 this._setOption( "disabled", this.options.disabled );
12841
12842                 this._animateOff = false;
12843         },
12844
12845         _refresh: function() {
12846                 this._createRange();
12847                 this._createHandles();
12848                 this._setupEvents();
12849                 this._refreshValue();
12850         },
12851
12852         _createHandles: function() {
12853                 var i, handleCount,
12854                         options = this.options,
12855                         existingHandles = this.element.find( ".ui-slider-handle" ).addClass( "ui-state-default ui-corner-all" ),
12856                         handle = "<span class='ui-slider-handle ui-state-default ui-corner-all' tabindex='0'></span>",
12857                         handles = [];
12858
12859                 handleCount = ( options.values && options.values.length ) || 1;
12860
12861                 if ( existingHandles.length > handleCount ) {
12862                         existingHandles.slice( handleCount ).remove();
12863                         existingHandles = existingHandles.slice( 0, handleCount );
12864                 }
12865
12866                 for ( i = existingHandles.length; i < handleCount; i++ ) {
12867                         handles.push( handle );
12868                 }
12869
12870                 this.handles = existingHandles.add( $( handles.join( "" ) ).appendTo( this.element ) );
12871
12872                 this.handle = this.handles.eq( 0 );
12873
12874                 this.handles.each(function( i ) {
12875                         $( this ).data( "ui-slider-handle-index", i );
12876                 });
12877         },
12878
12879         _createRange: function() {
12880                 var options = this.options,
12881                         classes = "";
12882
12883                 if ( options.range ) {
12884                         if ( options.range === true ) {
12885                                 if ( !options.values ) {
12886                                         options.values = [ this._valueMin(), this._valueMin() ];
12887                                 } else if ( options.values.length && options.values.length !== 2 ) {
12888                                         options.values = [ options.values[0], options.values[0] ];
12889                                 } else if ( $.isArray( options.values ) ) {
12890                                         options.values = options.values.slice(0);
12891                                 }
12892                         }
12893
12894                         if ( !this.range || !this.range.length ) {
12895                                 this.range = $( "<div></div>" )
12896                                         .appendTo( this.element );
12897
12898                                 classes = "ui-slider-range" +
12899                                 // note: this isn't the most fittingly semantic framework class for this element,
12900                                 // but worked best visually with a variety of themes
12901                                 " ui-widget-header ui-corner-all";
12902                         } else {
12903                                 this.range.removeClass( "ui-slider-range-min ui-slider-range-max" )
12904                                         // Handle range switching from true to min/max
12905                                         .css({
12906                                                 "left": "",
12907                                                 "bottom": ""
12908                                         });
12909                         }
12910
12911                         this.range.addClass( classes +
12912                                 ( ( options.range === "min" || options.range === "max" ) ? " ui-slider-range-" + options.range : "" ) );
12913                 } else {
12914                         if ( this.range ) {
12915                                 this.range.remove();
12916                         }
12917                         this.range = null;
12918                 }
12919         },
12920
12921         _setupEvents: function() {
12922                 this._off( this.handles );
12923                 this._on( this.handles, this._handleEvents );
12924                 this._hoverable( this.handles );
12925                 this._focusable( this.handles );
12926         },
12927
12928         _destroy: function() {
12929                 this.handles.remove();
12930                 if ( this.range ) {
12931                         this.range.remove();
12932                 }
12933
12934                 this.element
12935                         .removeClass( "ui-slider" +
12936                                 " ui-slider-horizontal" +
12937                                 " ui-slider-vertical" +
12938                                 " ui-widget" +
12939                                 " ui-widget-content" +
12940                                 " ui-corner-all" );
12941
12942                 this._mouseDestroy();
12943         },
12944
12945         _mouseCapture: function( event ) {
12946                 var position, normValue, distance, closestHandle, index, allowed, offset, mouseOverHandle,
12947                         that = this,
12948                         o = this.options;
12949
12950                 if ( o.disabled ) {
12951                         return false;
12952                 }
12953
12954                 this.elementSize = {
12955                         width: this.element.outerWidth(),
12956                         height: this.element.outerHeight()
12957                 };
12958                 this.elementOffset = this.element.offset();
12959
12960                 position = { x: event.pageX, y: event.pageY };
12961                 normValue = this._normValueFromMouse( position );
12962                 distance = this._valueMax() - this._valueMin() + 1;
12963                 this.handles.each(function( i ) {
12964                         var thisDistance = Math.abs( normValue - that.values(i) );
12965                         if (( distance > thisDistance ) ||
12966                                 ( distance === thisDistance &&
12967                                         (i === that._lastChangedValue || that.values(i) === o.min ))) {
12968                                 distance = thisDistance;
12969                                 closestHandle = $( this );
12970                                 index = i;
12971                         }
12972                 });
12973
12974                 allowed = this._start( event, index );
12975                 if ( allowed === false ) {
12976                         return false;
12977                 }
12978                 this._mouseSliding = true;
12979
12980                 this._handleIndex = index;
12981
12982                 closestHandle
12983                         .addClass( "ui-state-active" )
12984                         .focus();
12985
12986                 offset = closestHandle.offset();
12987                 mouseOverHandle = !$( event.target ).parents().addBack().is( ".ui-slider-handle" );
12988                 this._clickOffset = mouseOverHandle ? { left: 0, top: 0 } : {
12989                         left: event.pageX - offset.left - ( closestHandle.width() / 2 ),
12990                         top: event.pageY - offset.top -
12991                                 ( closestHandle.height() / 2 ) -
12992                                 ( parseInt( closestHandle.css("borderTopWidth"), 10 ) || 0 ) -
12993                                 ( parseInt( closestHandle.css("borderBottomWidth"), 10 ) || 0) +
12994                                 ( parseInt( closestHandle.css("marginTop"), 10 ) || 0)
12995                 };
12996
12997                 if ( !this.handles.hasClass( "ui-state-hover" ) ) {
12998                         this._slide( event, index, normValue );
12999                 }
13000                 this._animateOff = true;
13001                 return true;
13002         },
13003
13004         _mouseStart: function() {
13005                 return true;
13006         },
13007
13008         _mouseDrag: function( event ) {
13009                 var position = { x: event.pageX, y: event.pageY },
13010                         normValue = this._normValueFromMouse( position );
13011
13012                 this._slide( event, this._handleIndex, normValue );
13013
13014                 return false;
13015         },
13016
13017         _mouseStop: function( event ) {
13018                 this.handles.removeClass( "ui-state-active" );
13019                 this._mouseSliding = false;
13020
13021                 this._stop( event, this._handleIndex );
13022                 this._change( event, this._handleIndex );
13023
13024                 this._handleIndex = null;
13025                 this._clickOffset = null;
13026                 this._animateOff = false;
13027
13028                 return false;
13029         },
13030
13031         _detectOrientation: function() {
13032                 this.orientation = ( this.options.orientation === "vertical" ) ? "vertical" : "horizontal";
13033         },
13034
13035         _normValueFromMouse: function( position ) {
13036                 var pixelTotal,
13037                         pixelMouse,
13038                         percentMouse,
13039                         valueTotal,
13040                         valueMouse;
13041
13042                 if ( this.orientation === "horizontal" ) {
13043                         pixelTotal = this.elementSize.width;
13044                         pixelMouse = position.x - this.elementOffset.left - ( this._clickOffset ? this._clickOffset.left : 0 );
13045                 } else {
13046                         pixelTotal = this.elementSize.height;
13047                         pixelMouse = position.y - this.elementOffset.top - ( this._clickOffset ? this._clickOffset.top : 0 );
13048                 }
13049
13050                 percentMouse = ( pixelMouse / pixelTotal );
13051                 if ( percentMouse > 1 ) {
13052                         percentMouse = 1;
13053                 }
13054                 if ( percentMouse < 0 ) {
13055                         percentMouse = 0;
13056                 }
13057                 if ( this.orientation === "vertical" ) {
13058                         percentMouse = 1 - percentMouse;
13059                 }
13060
13061                 valueTotal = this._valueMax() - this._valueMin();
13062                 valueMouse = this._valueMin() + percentMouse * valueTotal;
13063
13064                 return this._trimAlignValue( valueMouse );
13065         },
13066
13067         _start: function( event, index ) {
13068                 var uiHash = {
13069                         handle: this.handles[ index ],
13070                         value: this.value()
13071                 };
13072                 if ( this.options.values && this.options.values.length ) {
13073                         uiHash.value = this.values( index );
13074                         uiHash.values = this.values();
13075                 }
13076                 return this._trigger( "start", event, uiHash );
13077         },
13078
13079         _slide: function( event, index, newVal ) {
13080                 var otherVal,
13081                         newValues,
13082                         allowed;
13083
13084                 if ( this.options.values && this.options.values.length ) {
13085                         otherVal = this.values( index ? 0 : 1 );
13086
13087                         if ( ( this.options.values.length === 2 && this.options.range === true ) &&
13088                                         ( ( index === 0 && newVal > otherVal) || ( index === 1 && newVal < otherVal ) )
13089                                 ) {
13090                                 newVal = otherVal;
13091                         }
13092
13093                         if ( newVal !== this.values( index ) ) {
13094                                 newValues = this.values();
13095                                 newValues[ index ] = newVal;
13096                                 // A slide can be canceled by returning false from the slide callback
13097                                 allowed = this._trigger( "slide", event, {
13098                                         handle: this.handles[ index ],
13099                                         value: newVal,
13100                                         values: newValues
13101                                 } );
13102                                 otherVal = this.values( index ? 0 : 1 );
13103                                 if ( allowed !== false ) {
13104                                         this.values( index, newVal );
13105                                 }
13106                         }
13107                 } else {
13108                         if ( newVal !== this.value() ) {
13109                                 // A slide can be canceled by returning false from the slide callback
13110                                 allowed = this._trigger( "slide", event, {
13111                                         handle: this.handles[ index ],
13112                                         value: newVal
13113                                 } );
13114                                 if ( allowed !== false ) {
13115                                         this.value( newVal );
13116                                 }
13117                         }
13118                 }
13119         },
13120
13121         _stop: function( event, index ) {
13122                 var uiHash = {
13123                         handle: this.handles[ index ],
13124                         value: this.value()
13125                 };
13126                 if ( this.options.values && this.options.values.length ) {
13127                         uiHash.value = this.values( index );
13128                         uiHash.values = this.values();
13129                 }
13130
13131                 this._trigger( "stop", event, uiHash );
13132         },
13133
13134         _change: function( event, index ) {
13135                 if ( !this._keySliding && !this._mouseSliding ) {
13136                         var uiHash = {
13137                                 handle: this.handles[ index ],
13138                                 value: this.value()
13139                         };
13140                         if ( this.options.values && this.options.values.length ) {
13141                                 uiHash.value = this.values( index );
13142                                 uiHash.values = this.values();
13143                         }
13144
13145                         //store the last changed value index for reference when handles overlap
13146                         this._lastChangedValue = index;
13147
13148                         this._trigger( "change", event, uiHash );
13149                 }
13150         },
13151
13152         value: function( newValue ) {
13153                 if ( arguments.length ) {
13154                         this.options.value = this._trimAlignValue( newValue );
13155                         this._refreshValue();
13156                         this._change( null, 0 );
13157                         return;
13158                 }
13159
13160                 return this._value();
13161         },
13162
13163         values: function( index, newValue ) {
13164                 var vals,
13165                         newValues,
13166                         i;
13167
13168                 if ( arguments.length > 1 ) {
13169                         this.options.values[ index ] = this._trimAlignValue( newValue );
13170                         this._refreshValue();
13171                         this._change( null, index );
13172                         return;
13173                 }
13174
13175                 if ( arguments.length ) {
13176                         if ( $.isArray( arguments[ 0 ] ) ) {
13177                                 vals = this.options.values;
13178                                 newValues = arguments[ 0 ];
13179                                 for ( i = 0; i < vals.length; i += 1 ) {
13180                                         vals[ i ] = this._trimAlignValue( newValues[ i ] );
13181                                         this._change( null, i );
13182                                 }
13183                                 this._refreshValue();
13184                         } else {
13185                                 if ( this.options.values && this.options.values.length ) {
13186                                         return this._values( index );
13187                                 } else {
13188                                         return this.value();
13189                                 }
13190                         }
13191                 } else {
13192                         return this._values();
13193                 }
13194         },
13195
13196         _setOption: function( key, value ) {
13197                 var i,
13198                         valsLength = 0;
13199
13200                 if ( key === "range" && this.options.range === true ) {
13201                         if ( value === "min" ) {
13202                                 this.options.value = this._values( 0 );
13203                                 this.options.values = null;
13204                         } else if ( value === "max" ) {
13205                                 this.options.value = this._values( this.options.values.length - 1 );
13206                                 this.options.values = null;
13207                         }
13208                 }
13209
13210                 if ( $.isArray( this.options.values ) ) {
13211                         valsLength = this.options.values.length;
13212                 }
13213
13214                 if ( key === "disabled" ) {
13215                         this.element.toggleClass( "ui-state-disabled", !!value );
13216                 }
13217
13218                 this._super( key, value );
13219
13220                 switch ( key ) {
13221                         case "orientation":
13222                                 this._detectOrientation();
13223                                 this.element
13224                                         .removeClass( "ui-slider-horizontal ui-slider-vertical" )
13225                                         .addClass( "ui-slider-" + this.orientation );
13226                                 this._refreshValue();
13227
13228                                 // Reset positioning from previous orientation
13229                                 this.handles.css( value === "horizontal" ? "bottom" : "left", "" );
13230                                 break;
13231                         case "value":
13232                                 this._animateOff = true;
13233                                 this._refreshValue();
13234                                 this._change( null, 0 );
13235                                 this._animateOff = false;
13236                                 break;
13237                         case "values":
13238                                 this._animateOff = true;
13239                                 this._refreshValue();
13240                                 for ( i = 0; i < valsLength; i += 1 ) {
13241                                         this._change( null, i );
13242                                 }
13243                                 this._animateOff = false;
13244                                 break;
13245                         case "step":
13246                         case "min":
13247                         case "max":
13248                                 this._animateOff = true;
13249                                 this._calculateNewMax();
13250                                 this._refreshValue();
13251                                 this._animateOff = false;
13252                                 break;
13253                         case "range":
13254                                 this._animateOff = true;
13255                                 this._refresh();
13256                                 this._animateOff = false;
13257                                 break;
13258                 }
13259         },
13260
13261         //internal value getter
13262         // _value() returns value trimmed by min and max, aligned by step
13263         _value: function() {
13264                 var val = this.options.value;
13265                 val = this._trimAlignValue( val );
13266
13267                 return val;
13268         },
13269
13270         //internal values getter
13271         // _values() returns array of values trimmed by min and max, aligned by step
13272         // _values( index ) returns single value trimmed by min and max, aligned by step
13273         _values: function( index ) {
13274                 var val,
13275                         vals,
13276                         i;
13277
13278                 if ( arguments.length ) {
13279                         val = this.options.values[ index ];
13280                         val = this._trimAlignValue( val );
13281
13282                         return val;
13283                 } else if ( this.options.values && this.options.values.length ) {
13284                         // .slice() creates a copy of the array
13285                         // this copy gets trimmed by min and max and then returned
13286                         vals = this.options.values.slice();
13287                         for ( i = 0; i < vals.length; i += 1) {
13288                                 vals[ i ] = this._trimAlignValue( vals[ i ] );
13289                         }
13290
13291                         return vals;
13292                 } else {
13293                         return [];
13294                 }
13295         },
13296
13297         // returns the step-aligned value that val is closest to, between (inclusive) min and max
13298         _trimAlignValue: function( val ) {
13299                 if ( val <= this._valueMin() ) {
13300                         return this._valueMin();
13301                 }
13302                 if ( val >= this._valueMax() ) {
13303                         return this._valueMax();
13304                 }
13305                 var step = ( this.options.step > 0 ) ? this.options.step : 1,
13306                         valModStep = (val - this._valueMin()) % step,
13307                         alignValue = val - valModStep;
13308
13309                 if ( Math.abs(valModStep) * 2 >= step ) {
13310                         alignValue += ( valModStep > 0 ) ? step : ( -step );
13311                 }
13312
13313                 // Since JavaScript has problems with large floats, round
13314                 // the final value to 5 digits after the decimal point (see #4124)
13315                 return parseFloat( alignValue.toFixed(5) );
13316         },
13317
13318         _calculateNewMax: function() {
13319                 var max = this.options.max,
13320                         min = this._valueMin(),
13321                         step = this.options.step,
13322                         aboveMin = Math.floor( ( +( max - min ).toFixed( this._precision() ) ) / step ) * step;
13323                 max = aboveMin + min;
13324                 this.max = parseFloat( max.toFixed( this._precision() ) );
13325         },
13326
13327         _precision: function() {
13328                 var precision = this._precisionOf( this.options.step );
13329                 if ( this.options.min !== null ) {
13330                         precision = Math.max( precision, this._precisionOf( this.options.min ) );
13331                 }
13332                 return precision;
13333         },
13334
13335         _precisionOf: function( num ) {
13336                 var str = num.toString(),
13337                         decimal = str.indexOf( "." );
13338                 return decimal === -1 ? 0 : str.length - decimal - 1;
13339         },
13340
13341         _valueMin: function() {
13342                 return this.options.min;
13343         },
13344
13345         _valueMax: function() {
13346                 return this.max;
13347         },
13348
13349         _refreshValue: function() {
13350                 var lastValPercent, valPercent, value, valueMin, valueMax,
13351                         oRange = this.options.range,
13352                         o = this.options,
13353                         that = this,
13354                         animate = ( !this._animateOff ) ? o.animate : false,
13355                         _set = {};
13356
13357                 if ( this.options.values && this.options.values.length ) {
13358                         this.handles.each(function( i ) {
13359                                 valPercent = ( that.values(i) - that._valueMin() ) / ( that._valueMax() - that._valueMin() ) * 100;
13360                                 _set[ that.orientation === "horizontal" ? "left" : "bottom" ] = valPercent + "%";
13361                                 $( this ).stop( 1, 1 )[ animate ? "animate" : "css" ]( _set, o.animate );
13362                                 if ( that.options.range === true ) {
13363                                         if ( that.orientation === "horizontal" ) {
13364                                                 if ( i === 0 ) {
13365                                                         that.range.stop( 1, 1 )[ animate ? "animate" : "css" ]( { left: valPercent + "%" }, o.animate );
13366                                                 }
13367                                                 if ( i === 1 ) {
13368                                                         that.range[ animate ? "animate" : "css" ]( { width: ( valPercent - lastValPercent ) + "%" }, { queue: false, duration: o.animate } );
13369                                                 }
13370                                         } else {
13371                                                 if ( i === 0 ) {
13372                                                         that.range.stop( 1, 1 )[ animate ? "animate" : "css" ]( { bottom: ( valPercent ) + "%" }, o.animate );
13373                                                 }
13374                                                 if ( i === 1 ) {
13375                                                         that.range[ animate ? "animate" : "css" ]( { height: ( valPercent - lastValPercent ) + "%" }, { queue: false, duration: o.animate } );
13376                                                 }
13377                                         }
13378                                 }
13379                                 lastValPercent = valPercent;
13380                         });
13381                 } else {
13382                         value = this.value();
13383                         valueMin = this._valueMin();
13384                         valueMax = this._valueMax();
13385                         valPercent = ( valueMax !== valueMin ) ?
13386                                         ( value - valueMin ) / ( valueMax - valueMin ) * 100 :
13387                                         0;
13388                         _set[ this.orientation === "horizontal" ? "left" : "bottom" ] = valPercent + "%";
13389                         this.handle.stop( 1, 1 )[ animate ? "animate" : "css" ]( _set, o.animate );
13390
13391                         if ( oRange === "min" && this.orientation === "horizontal" ) {
13392                                 this.range.stop( 1, 1 )[ animate ? "animate" : "css" ]( { width: valPercent + "%" }, o.animate );
13393                         }
13394                         if ( oRange === "max" && this.orientation === "horizontal" ) {
13395                                 this.range[ animate ? "animate" : "css" ]( { width: ( 100 - valPercent ) + "%" }, { queue: false, duration: o.animate } );
13396                         }
13397                         if ( oRange === "min" && this.orientation === "vertical" ) {
13398                                 this.range.stop( 1, 1 )[ animate ? "animate" : "css" ]( { height: valPercent + "%" }, o.animate );
13399                         }
13400                         if ( oRange === "max" && this.orientation === "vertical" ) {
13401                                 this.range[ animate ? "animate" : "css" ]( { height: ( 100 - valPercent ) + "%" }, { queue: false, duration: o.animate } );
13402                         }
13403                 }
13404         },
13405
13406         _handleEvents: {
13407                 keydown: function( event ) {
13408                         var allowed, curVal, newVal, step,
13409                                 index = $( event.target ).data( "ui-slider-handle-index" );
13410
13411                         switch ( event.keyCode ) {
13412                                 case $.ui.keyCode.HOME:
13413                                 case $.ui.keyCode.END:
13414                                 case $.ui.keyCode.PAGE_UP:
13415                                 case $.ui.keyCode.PAGE_DOWN:
13416                                 case $.ui.keyCode.UP:
13417                                 case $.ui.keyCode.RIGHT:
13418                                 case $.ui.keyCode.DOWN:
13419                                 case $.ui.keyCode.LEFT:
13420                                         event.preventDefault();
13421                                         if ( !this._keySliding ) {
13422                                                 this._keySliding = true;
13423                                                 $( event.target ).addClass( "ui-state-active" );
13424                                                 allowed = this._start( event, index );
13425                                                 if ( allowed === false ) {
13426                                                         return;
13427                                                 }
13428                                         }
13429                                         break;
13430                         }
13431
13432                         step = this.options.step;
13433                         if ( this.options.values && this.options.values.length ) {
13434                                 curVal = newVal = this.values( index );
13435                         } else {
13436                                 curVal = newVal = this.value();
13437                         }
13438
13439                         switch ( event.keyCode ) {
13440                                 case $.ui.keyCode.HOME:
13441                                         newVal = this._valueMin();
13442                                         break;
13443                                 case $.ui.keyCode.END:
13444                                         newVal = this._valueMax();
13445                                         break;
13446                                 case $.ui.keyCode.PAGE_UP:
13447                                         newVal = this._trimAlignValue(
13448                                                 curVal + ( ( this._valueMax() - this._valueMin() ) / this.numPages )
13449                                         );
13450                                         break;
13451                                 case $.ui.keyCode.PAGE_DOWN:
13452                                         newVal = this._trimAlignValue(
13453                                                 curVal - ( (this._valueMax() - this._valueMin()) / this.numPages ) );
13454                                         break;
13455                                 case $.ui.keyCode.UP:
13456                                 case $.ui.keyCode.RIGHT:
13457                                         if ( curVal === this._valueMax() ) {
13458                                                 return;
13459                                         }
13460                                         newVal = this._trimAlignValue( curVal + step );
13461                                         break;
13462                                 case $.ui.keyCode.DOWN:
13463                                 case $.ui.keyCode.LEFT:
13464                                         if ( curVal === this._valueMin() ) {
13465                                                 return;
13466                                         }
13467                                         newVal = this._trimAlignValue( curVal - step );
13468                                         break;
13469                         }
13470
13471                         this._slide( event, index, newVal );
13472                 },
13473                 keyup: function( event ) {
13474                         var index = $( event.target ).data( "ui-slider-handle-index" );
13475
13476                         if ( this._keySliding ) {
13477                                 this._keySliding = false;
13478                                 this._stop( event, index );
13479                                 this._change( event, index );
13480                                 $( event.target ).removeClass( "ui-state-active" );
13481                         }
13482                 }
13483         }
13484 });
13485
13486
13487 /*!
13488  * jQuery UI Sortable 1.11.4
13489  * http://jqueryui.com
13490  *
13491  * Copyright jQuery Foundation and other contributors
13492  * Released under the MIT license.
13493  * http://jquery.org/license
13494  *
13495  * http://api.jqueryui.com/sortable/
13496  */
13497
13498
13499 var sortable = $.widget("ui.sortable", $.ui.mouse, {
13500         version: "1.11.4",
13501         widgetEventPrefix: "sort",
13502         ready: false,
13503         options: {
13504                 appendTo: "parent",
13505                 axis: false,
13506                 connectWith: false,
13507                 containment: false,
13508                 cursor: "auto",
13509                 cursorAt: false,
13510                 dropOnEmpty: true,
13511                 forcePlaceholderSize: false,
13512                 forceHelperSize: false,
13513                 grid: false,
13514                 handle: false,
13515                 helper: "original",
13516                 items: "> *",
13517                 opacity: false,
13518                 placeholder: false,
13519                 revert: false,
13520                 scroll: true,
13521                 scrollSensitivity: 20,
13522                 scrollSpeed: 20,
13523                 scope: "default",
13524                 tolerance: "intersect",
13525                 zIndex: 1000,
13526
13527                 // callbacks
13528                 activate: null,
13529                 beforeStop: null,
13530                 change: null,
13531                 deactivate: null,
13532                 out: null,
13533                 over: null,
13534                 receive: null,
13535                 remove: null,
13536                 sort: null,
13537                 start: null,
13538                 stop: null,
13539                 update: null
13540         },
13541
13542         _isOverAxis: function( x, reference, size ) {
13543                 return ( x >= reference ) && ( x < ( reference + size ) );
13544         },
13545
13546         _isFloating: function( item ) {
13547                 return (/left|right/).test(item.css("float")) || (/inline|table-cell/).test(item.css("display"));
13548         },
13549
13550         _create: function() {
13551                 this.containerCache = {};
13552                 this.element.addClass("ui-sortable");
13553
13554                 //Get the items
13555                 this.refresh();
13556
13557                 //Let's determine the parent's offset
13558                 this.offset = this.element.offset();
13559
13560                 //Initialize mouse events for interaction
13561                 this._mouseInit();
13562
13563                 this._setHandleClassName();
13564
13565                 //We're ready to go
13566                 this.ready = true;
13567
13568         },
13569
13570         _setOption: function( key, value ) {
13571                 this._super( key, value );
13572
13573                 if ( key === "handle" ) {
13574                         this._setHandleClassName();
13575                 }
13576         },
13577
13578         _setHandleClassName: function() {
13579                 this.element.find( ".ui-sortable-handle" ).removeClass( "ui-sortable-handle" );
13580                 $.each( this.items, function() {
13581                         ( this.instance.options.handle ?
13582                                 this.item.find( this.instance.options.handle ) : this.item )
13583                                 .addClass( "ui-sortable-handle" );
13584                 });
13585         },
13586
13587         _destroy: function() {
13588                 this.element
13589                         .removeClass( "ui-sortable ui-sortable-disabled" )
13590                         .find( ".ui-sortable-handle" )
13591                                 .removeClass( "ui-sortable-handle" );
13592                 this._mouseDestroy();
13593
13594                 for ( var i = this.items.length - 1; i >= 0; i-- ) {
13595                         this.items[i].item.removeData(this.widgetName + "-item");
13596                 }
13597
13598                 return this;
13599         },
13600
13601         _mouseCapture: function(event, overrideHandle) {
13602                 var currentItem = null,
13603                         validHandle = false,
13604                         that = this;
13605
13606                 if (this.reverting) {
13607                         return false;
13608                 }
13609
13610                 if(this.options.disabled || this.options.type === "static") {
13611                         return false;
13612                 }
13613
13614                 //We have to refresh the items data once first
13615                 this._refreshItems(event);
13616
13617                 //Find out if the clicked node (or one of its parents) is a actual item in this.items
13618                 $(event.target).parents().each(function() {
13619                         if($.data(this, that.widgetName + "-item") === that) {
13620                                 currentItem = $(this);
13621                                 return false;
13622                         }
13623                 });
13624                 if($.data(event.target, that.widgetName + "-item") === that) {
13625                         currentItem = $(event.target);
13626                 }
13627
13628                 if(!currentItem) {
13629                         return false;
13630                 }
13631                 if(this.options.handle && !overrideHandle) {
13632                         $(this.options.handle, currentItem).find("*").addBack().each(function() {
13633                                 if(this === event.target) {
13634                                         validHandle = true;
13635                                 }
13636                         });
13637                         if(!validHandle) {
13638                                 return false;
13639                         }
13640                 }
13641
13642                 this.currentItem = currentItem;
13643                 this._removeCurrentsFromItems();
13644                 return true;
13645
13646         },
13647
13648         _mouseStart: function(event, overrideHandle, noActivation) {
13649
13650                 var i, body,
13651                         o = this.options;
13652
13653                 this.currentContainer = this;
13654
13655                 //We only need to call refreshPositions, because the refreshItems call has been moved to mouseCapture
13656                 this.refreshPositions();
13657
13658                 //Create and append the visible helper
13659                 this.helper = this._createHelper(event);
13660
13661                 //Cache the helper size
13662                 this._cacheHelperProportions();
13663
13664                 /*
13665                  * - Position generation -
13666                  * This block generates everything position related - it's the core of draggables.
13667                  */
13668
13669                 //Cache the margins of the original element
13670                 this._cacheMargins();
13671
13672                 //Get the next scrolling parent
13673                 this.scrollParent = this.helper.scrollParent();
13674
13675                 //The element's absolute position on the page minus margins
13676                 this.offset = this.currentItem.offset();
13677                 this.offset = {
13678                         top: this.offset.top - this.margins.top,
13679                         left: this.offset.left - this.margins.left
13680                 };
13681
13682                 $.extend(this.offset, {
13683                         click: { //Where the click happened, relative to the element
13684                                 left: event.pageX - this.offset.left,
13685                                 top: event.pageY - this.offset.top
13686                         },
13687                         parent: this._getParentOffset(),
13688                         relative: this._getRelativeOffset() //This is a relative to absolute position minus the actual position calculation - only used for relative positioned helper
13689                 });
13690
13691                 // Only after we got the offset, we can change the helper's position to absolute
13692                 // TODO: Still need to figure out a way to make relative sorting possible
13693                 this.helper.css("position", "absolute");
13694                 this.cssPosition = this.helper.css("position");
13695
13696                 //Generate the original position
13697                 this.originalPosition = this._generatePosition(event);
13698                 this.originalPageX = event.pageX;
13699                 this.originalPageY = event.pageY;
13700
13701                 //Adjust the mouse offset relative to the helper if "cursorAt" is supplied
13702                 (o.cursorAt && this._adjustOffsetFromHelper(o.cursorAt));
13703
13704                 //Cache the former DOM position
13705                 this.domPosition = { prev: this.currentItem.prev()[0], parent: this.currentItem.parent()[0] };
13706
13707                 //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
13708                 if(this.helper[0] !== this.currentItem[0]) {
13709                         this.currentItem.hide();
13710                 }
13711
13712                 //Create the placeholder
13713                 this._createPlaceholder();
13714
13715                 //Set a containment if given in the options
13716                 if(o.containment) {
13717                         this._setContainment();
13718                 }
13719
13720                 if( o.cursor && o.cursor !== "auto" ) { // cursor option
13721                         body = this.document.find( "body" );
13722
13723                         // support: IE
13724                         this.storedCursor = body.css( "cursor" );
13725                         body.css( "cursor", o.cursor );
13726
13727                         this.storedStylesheet = $( "<style>*{ cursor: "+o.cursor+" !important; }</style>" ).appendTo( body );
13728                 }
13729
13730                 if(o.opacity) { // opacity option
13731                         if (this.helper.css("opacity")) {
13732                                 this._storedOpacity = this.helper.css("opacity");
13733                         }
13734                         this.helper.css("opacity", o.opacity);
13735                 }
13736
13737                 if(o.zIndex) { // zIndex option
13738                         if (this.helper.css("zIndex")) {
13739                                 this._storedZIndex = this.helper.css("zIndex");
13740                         }
13741                         this.helper.css("zIndex", o.zIndex);
13742                 }
13743
13744                 //Prepare scrolling
13745                 if(this.scrollParent[0] !== this.document[0] && this.scrollParent[0].tagName !== "HTML") {
13746                         this.overflowOffset = this.scrollParent.offset();
13747                 }
13748
13749                 //Call callbacks
13750                 this._trigger("start", event, this._uiHash());
13751
13752                 //Recache the helper size
13753                 if(!this._preserveHelperProportions) {
13754                         this._cacheHelperProportions();
13755                 }
13756
13757
13758                 //Post "activate" events to possible containers
13759                 if( !noActivation ) {
13760                         for ( i = this.containers.length - 1; i >= 0; i-- ) {
13761                                 this.containers[ i ]._trigger( "activate", event, this._uiHash( this ) );
13762                         }
13763                 }
13764
13765                 //Prepare possible droppables
13766                 if($.ui.ddmanager) {
13767                         $.ui.ddmanager.current = this;
13768                 }
13769
13770                 if ($.ui.ddmanager && !o.dropBehaviour) {
13771                         $.ui.ddmanager.prepareOffsets(this, event);
13772                 }
13773
13774                 this.dragging = true;
13775
13776                 this.helper.addClass("ui-sortable-helper");
13777                 this._mouseDrag(event); //Execute the drag once - this causes the helper not to be visible before getting its correct position
13778                 return true;
13779
13780         },
13781
13782         _mouseDrag: function(event) {
13783                 var i, item, itemElement, intersection,
13784                         o = this.options,
13785                         scrolled = false;
13786
13787                 //Compute the helpers position
13788                 this.position = this._generatePosition(event);
13789                 this.positionAbs = this._convertPositionTo("absolute");
13790
13791                 if (!this.lastPositionAbs) {
13792                         this.lastPositionAbs = this.positionAbs;
13793                 }
13794
13795                 //Do scrolling
13796                 if(this.options.scroll) {
13797                         if(this.scrollParent[0] !== this.document[0] && this.scrollParent[0].tagName !== "HTML") {
13798
13799                                 if((this.overflowOffset.top + this.scrollParent[0].offsetHeight) - event.pageY < o.scrollSensitivity) {
13800                                         this.scrollParent[0].scrollTop = scrolled = this.scrollParent[0].scrollTop + o.scrollSpeed;
13801                                 } else if(event.pageY - this.overflowOffset.top < o.scrollSensitivity) {
13802                                         this.scrollParent[0].scrollTop = scrolled = this.scrollParent[0].scrollTop - o.scrollSpeed;
13803                                 }
13804
13805                                 if((this.overflowOffset.left + this.scrollParent[0].offsetWidth) - event.pageX < o.scrollSensitivity) {
13806                                         this.scrollParent[0].scrollLeft = scrolled = this.scrollParent[0].scrollLeft + o.scrollSpeed;
13807                                 } else if(event.pageX - this.overflowOffset.left < o.scrollSensitivity) {
13808                                         this.scrollParent[0].scrollLeft = scrolled = this.scrollParent[0].scrollLeft - o.scrollSpeed;
13809                                 }
13810
13811                         } else {
13812
13813                                 if(event.pageY - this.document.scrollTop() < o.scrollSensitivity) {
13814                                         scrolled = this.document.scrollTop(this.document.scrollTop() - o.scrollSpeed);
13815                                 } else if(this.window.height() - (event.pageY - this.document.scrollTop()) < o.scrollSensitivity) {
13816                                         scrolled = this.document.scrollTop(this.document.scrollTop() + o.scrollSpeed);
13817                                 }
13818
13819                                 if(event.pageX - this.document.scrollLeft() < o.scrollSensitivity) {
13820                                         scrolled = this.document.scrollLeft(this.document.scrollLeft() - o.scrollSpeed);
13821                                 } else if(this.window.width() - (event.pageX - this.document.scrollLeft()) < o.scrollSensitivity) {
13822                                         scrolled = this.document.scrollLeft(this.document.scrollLeft() + o.scrollSpeed);
13823                                 }
13824
13825                         }
13826
13827                         if(scrolled !== false && $.ui.ddmanager && !o.dropBehaviour) {
13828                                 $.ui.ddmanager.prepareOffsets(this, event);
13829                         }
13830                 }
13831
13832                 //Regenerate the absolute position used for position checks
13833                 this.positionAbs = this._convertPositionTo("absolute");
13834
13835                 //Set the helper position
13836                 if(!this.options.axis || this.options.axis !== "y") {
13837                         this.helper[0].style.left = this.position.left+"px";
13838                 }
13839                 if(!this.options.axis || this.options.axis !== "x") {
13840                         this.helper[0].style.top = this.position.top+"px";
13841                 }
13842
13843                 //Rearrange
13844                 for (i = this.items.length - 1; i >= 0; i--) {
13845
13846                         //Cache variables and intersection, continue if no intersection
13847                         item = this.items[i];
13848                         itemElement = item.item[0];
13849                         intersection = this._intersectsWithPointer(item);
13850                         if (!intersection) {
13851                                 continue;
13852                         }
13853
13854                         // Only put the placeholder inside the current Container, skip all
13855                         // items from other containers. This works because when moving
13856                         // an item from one container to another the
13857                         // currentContainer is switched before the placeholder is moved.
13858                         //
13859                         // Without this, moving items in "sub-sortables" can cause
13860                         // the placeholder to jitter between the outer and inner container.
13861                         if (item.instance !== this.currentContainer) {
13862                                 continue;
13863                         }
13864
13865                         // cannot intersect with itself
13866                         // no useless actions that have been done before
13867                         // no action if the item moved is the parent of the item checked
13868                         if (itemElement !== this.currentItem[0] &&
13869                                 this.placeholder[intersection === 1 ? "next" : "prev"]()[0] !== itemElement &&
13870                                 !$.contains(this.placeholder[0], itemElement) &&
13871                                 (this.options.type === "semi-dynamic" ? !$.contains(this.element[0], itemElement) : true)
13872                         ) {
13873
13874                                 this.direction = intersection === 1 ? "down" : "up";
13875
13876                                 if (this.options.tolerance === "pointer" || this._intersectsWithSides(item)) {
13877                                         this._rearrange(event, item);
13878                                 } else {
13879                                         break;
13880                                 }
13881
13882                                 this._trigger("change", event, this._uiHash());
13883                                 break;
13884                         }
13885                 }
13886
13887                 //Post events to containers
13888                 this._contactContainers(event);
13889
13890                 //Interconnect with droppables
13891                 if($.ui.ddmanager) {
13892                         $.ui.ddmanager.drag(this, event);
13893                 }
13894
13895                 //Call callbacks
13896                 this._trigger("sort", event, this._uiHash());
13897
13898                 this.lastPositionAbs = this.positionAbs;
13899                 return false;
13900
13901         },
13902
13903         _mouseStop: function(event, noPropagation) {
13904
13905                 if(!event) {
13906                         return;
13907                 }
13908
13909                 //If we are using droppables, inform the manager about the drop
13910                 if ($.ui.ddmanager && !this.options.dropBehaviour) {
13911                         $.ui.ddmanager.drop(this, event);
13912                 }
13913
13914                 if(this.options.revert) {
13915                         var that = this,
13916                                 cur = this.placeholder.offset(),
13917                                 axis = this.options.axis,
13918                                 animation = {};
13919
13920                         if ( !axis || axis === "x" ) {
13921                                 animation.left = cur.left - this.offset.parent.left - this.margins.left + (this.offsetParent[0] === this.document[0].body ? 0 : this.offsetParent[0].scrollLeft);
13922                         }
13923                         if ( !axis || axis === "y" ) {
13924                                 animation.top = cur.top - this.offset.parent.top - this.margins.top + (this.offsetParent[0] === this.document[0].body ? 0 : this.offsetParent[0].scrollTop);
13925                         }
13926                         this.reverting = true;
13927                         $(this.helper).animate( animation, parseInt(this.options.revert, 10) || 500, function() {
13928                                 that._clear(event);
13929                         });
13930                 } else {
13931                         this._clear(event, noPropagation);
13932                 }
13933
13934                 return false;
13935
13936         },
13937
13938         cancel: function() {
13939
13940                 if(this.dragging) {
13941
13942                         this._mouseUp({ target: null });
13943
13944                         if(this.options.helper === "original") {
13945                                 this.currentItem.css(this._storedCSS).removeClass("ui-sortable-helper");
13946                         } else {
13947                                 this.currentItem.show();
13948                         }
13949
13950                         //Post deactivating events to containers
13951                         for (var i = this.containers.length - 1; i >= 0; i--){
13952                                 this.containers[i]._trigger("deactivate", null, this._uiHash(this));
13953                                 if(this.containers[i].containerCache.over) {
13954                                         this.containers[i]._trigger("out", null, this._uiHash(this));
13955                                         this.containers[i].containerCache.over = 0;
13956                                 }
13957                         }
13958
13959                 }
13960
13961                 if (this.placeholder) {
13962                         //$(this.placeholder[0]).remove(); would have been the jQuery way - unfortunately, it unbinds ALL events from the original node!
13963                         if(this.placeholder[0].parentNode) {
13964                                 this.placeholder[0].parentNode.removeChild(this.placeholder[0]);
13965                         }
13966                         if(this.options.helper !== "original" && this.helper && this.helper[0].parentNode) {
13967                                 this.helper.remove();
13968                         }
13969
13970                         $.extend(this, {
13971                                 helper: null,
13972                                 dragging: false,
13973                                 reverting: false,
13974                                 _noFinalSort: null
13975                         });
13976
13977                         if(this.domPosition.prev) {
13978                                 $(this.domPosition.prev).after(this.currentItem);
13979                         } else {
13980                                 $(this.domPosition.parent).prepend(this.currentItem);
13981                         }
13982                 }
13983
13984                 return this;
13985
13986         },
13987
13988         serialize: function(o) {
13989
13990                 var items = this._getItemsAsjQuery(o && o.connected),
13991                         str = [];
13992                 o = o || {};
13993
13994                 $(items).each(function() {
13995                         var res = ($(o.item || this).attr(o.attribute || "id") || "").match(o.expression || (/(.+)[\-=_](.+)/));
13996                         if (res) {
13997                                 str.push((o.key || res[1]+"[]")+"="+(o.key && o.expression ? res[1] : res[2]));
13998                         }
13999                 });
14000
14001                 if(!str.length && o.key) {
14002                         str.push(o.key + "=");
14003                 }
14004
14005                 return str.join("&");
14006
14007         },
14008
14009         toArray: function(o) {
14010
14011                 var items = this._getItemsAsjQuery(o && o.connected),
14012                         ret = [];
14013
14014                 o = o || {};
14015
14016                 items.each(function() { ret.push($(o.item || this).attr(o.attribute || "id") || ""); });
14017                 return ret;
14018
14019         },
14020
14021         /* Be careful with the following core functions */
14022         _intersectsWith: function(item) {
14023
14024                 var x1 = this.positionAbs.left,
14025                         x2 = x1 + this.helperProportions.width,
14026                         y1 = this.positionAbs.top,
14027                         y2 = y1 + this.helperProportions.height,
14028                         l = item.left,
14029                         r = l + item.width,
14030                         t = item.top,
14031                         b = t + item.height,
14032                         dyClick = this.offset.click.top,
14033                         dxClick = this.offset.click.left,
14034                         isOverElementHeight = ( this.options.axis === "x" ) || ( ( y1 + dyClick ) > t && ( y1 + dyClick ) < b ),
14035                         isOverElementWidth = ( this.options.axis === "y" ) || ( ( x1 + dxClick ) > l && ( x1 + dxClick ) < r ),
14036                         isOverElement = isOverElementHeight && isOverElementWidth;
14037
14038                 if ( this.options.tolerance === "pointer" ||
14039                         this.options.forcePointerForContainers ||
14040                         (this.options.tolerance !== "pointer" && this.helperProportions[this.floating ? "width" : "height"] > item[this.floating ? "width" : "height"])
14041                 ) {
14042                         return isOverElement;
14043                 } else {
14044
14045                         return (l < x1 + (this.helperProportions.width / 2) && // Right Half
14046                                 x2 - (this.helperProportions.width / 2) < r && // Left Half
14047                                 t < y1 + (this.helperProportions.height / 2) && // Bottom Half
14048                                 y2 - (this.helperProportions.height / 2) < b ); // Top Half
14049
14050                 }
14051         },
14052
14053         _intersectsWithPointer: function(item) {
14054
14055                 var isOverElementHeight = (this.options.axis === "x") || this._isOverAxis(this.positionAbs.top + this.offset.click.top, item.top, item.height),
14056                         isOverElementWidth = (this.options.axis === "y") || this._isOverAxis(this.positionAbs.left + this.offset.click.left, item.left, item.width),
14057                         isOverElement = isOverElementHeight && isOverElementWidth,
14058                         verticalDirection = this._getDragVerticalDirection(),
14059                         horizontalDirection = this._getDragHorizontalDirection();
14060
14061                 if (!isOverElement) {
14062                         return false;
14063                 }
14064
14065                 return this.floating ?
14066                         ( ((horizontalDirection && horizontalDirection === "right") || verticalDirection === "down") ? 2 : 1 )
14067                         : ( verticalDirection && (verticalDirection === "down" ? 2 : 1) );
14068
14069         },
14070
14071         _intersectsWithSides: function(item) {
14072
14073                 var isOverBottomHalf = this._isOverAxis(this.positionAbs.top + this.offset.click.top, item.top + (item.height/2), item.height),
14074                         isOverRightHalf = this._isOverAxis(this.positionAbs.left + this.offset.click.left, item.left + (item.width/2), item.width),
14075                         verticalDirection = this._getDragVerticalDirection(),
14076                         horizontalDirection = this._getDragHorizontalDirection();
14077
14078                 if (this.floating && horizontalDirection) {
14079                         return ((horizontalDirection === "right" && isOverRightHalf) || (horizontalDirection === "left" && !isOverRightHalf));
14080                 } else {
14081                         return verticalDirection && ((verticalDirection === "down" && isOverBottomHalf) || (verticalDirection === "up" && !isOverBottomHalf));
14082                 }
14083
14084         },
14085
14086         _getDragVerticalDirection: function() {
14087                 var delta = this.positionAbs.top - this.lastPositionAbs.top;
14088                 return delta !== 0 && (delta > 0 ? "down" : "up");
14089         },
14090
14091         _getDragHorizontalDirection: function() {
14092                 var delta = this.positionAbs.left - this.lastPositionAbs.left;
14093                 return delta !== 0 && (delta > 0 ? "right" : "left");
14094         },
14095
14096         refresh: function(event) {
14097                 this._refreshItems(event);
14098                 this._setHandleClassName();
14099                 this.refreshPositions();
14100                 return this;
14101         },
14102
14103         _connectWith: function() {
14104                 var options = this.options;
14105                 return options.connectWith.constructor === String ? [options.connectWith] : options.connectWith;
14106         },
14107
14108         _getItemsAsjQuery: function(connected) {
14109
14110                 var i, j, cur, inst,
14111                         items = [],
14112                         queries = [],
14113                         connectWith = this._connectWith();
14114
14115                 if(connectWith && connected) {
14116                         for (i = connectWith.length - 1; i >= 0; i--){
14117                                 cur = $(connectWith[i], this.document[0]);
14118                                 for ( j = cur.length - 1; j >= 0; j--){
14119                                         inst = $.data(cur[j], this.widgetFullName);
14120                                         if(inst && inst !== this && !inst.options.disabled) {
14121                                                 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]);
14122                                         }
14123                                 }
14124                         }
14125                 }
14126
14127                 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]);
14128
14129                 function addItems() {
14130                         items.push( this );
14131                 }
14132                 for (i = queries.length - 1; i >= 0; i--){
14133                         queries[i][0].each( addItems );
14134                 }
14135
14136                 return $(items);
14137
14138         },
14139
14140         _removeCurrentsFromItems: function() {
14141
14142                 var list = this.currentItem.find(":data(" + this.widgetName + "-item)");
14143
14144                 this.items = $.grep(this.items, function (item) {
14145                         for (var j=0; j < list.length; j++) {
14146                                 if(list[j] === item.item[0]) {
14147                                         return false;
14148                                 }
14149                         }
14150                         return true;
14151                 });
14152
14153         },
14154
14155         _refreshItems: function(event) {
14156
14157                 this.items = [];
14158                 this.containers = [this];
14159
14160                 var i, j, cur, inst, targetData, _queries, item, queriesLength,
14161                         items = this.items,
14162                         queries = [[$.isFunction(this.options.items) ? this.options.items.call(this.element[0], event, { item: this.currentItem }) : $(this.options.items, this.element), this]],
14163                         connectWith = this._connectWith();
14164
14165                 if(connectWith && this.ready) { //Shouldn't be run the first time through due to massive slow-down
14166                         for (i = connectWith.length - 1; i >= 0; i--){
14167                                 cur = $(connectWith[i], this.document[0]);
14168                                 for (j = cur.length - 1; j >= 0; j--){
14169                                         inst = $.data(cur[j], this.widgetFullName);
14170                                         if(inst && inst !== this && !inst.options.disabled) {
14171                                                 queries.push([$.isFunction(inst.options.items) ? inst.options.items.call(inst.element[0], event, { item: this.currentItem }) : $(inst.options.items, inst.element), inst]);
14172                                                 this.containers.push(inst);
14173                                         }
14174                                 }
14175                         }
14176                 }
14177
14178                 for (i = queries.length - 1; i >= 0; i--) {
14179                         targetData = queries[i][1];
14180                         _queries = queries[i][0];
14181
14182                         for (j=0, queriesLength = _queries.length; j < queriesLength; j++) {
14183                                 item = $(_queries[j]);
14184
14185                                 item.data(this.widgetName + "-item", targetData); // Data for target checking (mouse manager)
14186
14187                                 items.push({
14188                                         item: item,
14189                                         instance: targetData,
14190                                         width: 0, height: 0,
14191                                         left: 0, top: 0
14192                                 });
14193                         }
14194                 }
14195
14196         },
14197
14198         refreshPositions: function(fast) {
14199
14200                 // Determine whether items are being displayed horizontally
14201                 this.floating = this.items.length ?
14202                         this.options.axis === "x" || this._isFloating( this.items[ 0 ].item ) :
14203                         false;
14204
14205                 //This has to be redone because due to the item being moved out/into the offsetParent, the offsetParent's position will change
14206                 if(this.offsetParent && this.helper) {
14207                         this.offset.parent = this._getParentOffset();
14208                 }
14209
14210                 var i, item, t, p;
14211
14212                 for (i = this.items.length - 1; i >= 0; i--){
14213                         item = this.items[i];
14214
14215                         //We ignore calculating positions of all connected containers when we're not over them
14216                         if(item.instance !== this.currentContainer && this.currentContainer && item.item[0] !== this.currentItem[0]) {
14217                                 continue;
14218                         }
14219
14220                         t = this.options.toleranceElement ? $(this.options.toleranceElement, item.item) : item.item;
14221
14222                         if (!fast) {
14223                                 item.width = t.outerWidth();
14224                                 item.height = t.outerHeight();
14225                         }
14226
14227                         p = t.offset();
14228                         item.left = p.left;
14229                         item.top = p.top;
14230                 }
14231
14232                 if(this.options.custom && this.options.custom.refreshContainers) {
14233                         this.options.custom.refreshContainers.call(this);
14234                 } else {
14235                         for (i = this.containers.length - 1; i >= 0; i--){
14236                                 p = this.containers[i].element.offset();
14237                                 this.containers[i].containerCache.left = p.left;
14238                                 this.containers[i].containerCache.top = p.top;
14239                                 this.containers[i].containerCache.width = this.containers[i].element.outerWidth();
14240                                 this.containers[i].containerCache.height = this.containers[i].element.outerHeight();
14241                         }
14242                 }
14243
14244                 return this;
14245         },
14246
14247         _createPlaceholder: function(that) {
14248                 that = that || this;
14249                 var className,
14250                         o = that.options;
14251
14252                 if(!o.placeholder || o.placeholder.constructor === String) {
14253                         className = o.placeholder;
14254                         o.placeholder = {
14255                                 element: function() {
14256
14257                                         var nodeName = that.currentItem[0].nodeName.toLowerCase(),
14258                                                 element = $( "<" + nodeName + ">", that.document[0] )
14259                                                         .addClass(className || that.currentItem[0].className+" ui-sortable-placeholder")
14260                                                         .removeClass("ui-sortable-helper");
14261
14262                                         if ( nodeName === "tbody" ) {
14263                                                 that._createTrPlaceholder(
14264                                                         that.currentItem.find( "tr" ).eq( 0 ),
14265                                                         $( "<tr>", that.document[ 0 ] ).appendTo( element )
14266                                                 );
14267                                         } else if ( nodeName === "tr" ) {
14268                                                 that._createTrPlaceholder( that.currentItem, element );
14269                                         } else if ( nodeName === "img" ) {
14270                                                 element.attr( "src", that.currentItem.attr( "src" ) );
14271                                         }
14272
14273                                         if ( !className ) {
14274                                                 element.css( "visibility", "hidden" );
14275                                         }
14276
14277                                         return element;
14278                                 },
14279                                 update: function(container, p) {
14280
14281                                         // 1. If a className is set as 'placeholder option, we don't force sizes - the class is responsible for that
14282                                         // 2. The option 'forcePlaceholderSize can be enabled to force it even if a class name is specified
14283                                         if(className && !o.forcePlaceholderSize) {
14284                                                 return;
14285                                         }
14286
14287                                         //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
14288                                         if(!p.height()) { p.height(that.currentItem.innerHeight() - parseInt(that.currentItem.css("paddingTop")||0, 10) - parseInt(that.currentItem.css("paddingBottom")||0, 10)); }
14289                                         if(!p.width()) { p.width(that.currentItem.innerWidth() - parseInt(that.currentItem.css("paddingLeft")||0, 10) - parseInt(that.currentItem.css("paddingRight")||0, 10)); }
14290                                 }
14291                         };
14292                 }
14293
14294                 //Create the placeholder
14295                 that.placeholder = $(o.placeholder.element.call(that.element, that.currentItem));
14296
14297                 //Append it after the actual current item
14298                 that.currentItem.after(that.placeholder);
14299
14300                 //Update the size of the placeholder (TODO: Logic to fuzzy, see line 316/317)
14301                 o.placeholder.update(that, that.placeholder);
14302
14303         },
14304
14305         _createTrPlaceholder: function( sourceTr, targetTr ) {
14306                 var that = this;
14307
14308                 sourceTr.children().each(function() {
14309                         $( "<td>&#160;</td>", that.document[ 0 ] )
14310                                 .attr( "colspan", $( this ).attr( "colspan" ) || 1 )
14311                                 .appendTo( targetTr );
14312                 });
14313         },
14314
14315         _contactContainers: function(event) {
14316                 var i, j, dist, itemWithLeastDistance, posProperty, sizeProperty, cur, nearBottom, floating, axis,
14317                         innermostContainer = null,
14318                         innermostIndex = null;
14319
14320                 // get innermost container that intersects with item
14321                 for (i = this.containers.length - 1; i >= 0; i--) {
14322
14323                         // never consider a container that's located within the item itself
14324                         if($.contains(this.currentItem[0], this.containers[i].element[0])) {
14325                                 continue;
14326                         }
14327
14328                         if(this._intersectsWith(this.containers[i].containerCache)) {
14329
14330                                 // if we've already found a container and it's more "inner" than this, then continue
14331                                 if(innermostContainer && $.contains(this.containers[i].element[0], innermostContainer.element[0])) {
14332                                         continue;
14333                                 }
14334
14335                                 innermostContainer = this.containers[i];
14336                                 innermostIndex = i;
14337
14338                         } else {
14339                                 // container doesn't intersect. trigger "out" event if necessary
14340                                 if(this.containers[i].containerCache.over) {
14341                                         this.containers[i]._trigger("out", event, this._uiHash(this));
14342                                         this.containers[i].containerCache.over = 0;
14343                                 }
14344                         }
14345
14346                 }
14347
14348                 // if no intersecting containers found, return
14349                 if(!innermostContainer) {
14350                         return;
14351                 }
14352
14353                 // move the item into the container if it's not there already
14354                 if(this.containers.length === 1) {
14355                         if (!this.containers[innermostIndex].containerCache.over) {
14356                                 this.containers[innermostIndex]._trigger("over", event, this._uiHash(this));
14357                                 this.containers[innermostIndex].containerCache.over = 1;
14358                         }
14359                 } else {
14360
14361                         //When entering a new container, we will find the item with the least distance and append our item near it
14362                         dist = 10000;
14363                         itemWithLeastDistance = null;
14364                         floating = innermostContainer.floating || this._isFloating(this.currentItem);
14365                         posProperty = floating ? "left" : "top";
14366                         sizeProperty = floating ? "width" : "height";
14367                         axis = floating ? "clientX" : "clientY";
14368
14369                         for (j = this.items.length - 1; j >= 0; j--) {
14370                                 if(!$.contains(this.containers[innermostIndex].element[0], this.items[j].item[0])) {
14371                                         continue;
14372                                 }
14373                                 if(this.items[j].item[0] === this.currentItem[0]) {
14374                                         continue;
14375                                 }
14376
14377                                 cur = this.items[j].item.offset()[posProperty];
14378                                 nearBottom = false;
14379                                 if ( event[ axis ] - cur > this.items[ j ][ sizeProperty ] / 2 ) {
14380                                         nearBottom = true;
14381                                 }
14382
14383                                 if ( Math.abs( event[ axis ] - cur ) < dist ) {
14384                                         dist = Math.abs( event[ axis ] - cur );
14385                                         itemWithLeastDistance = this.items[ j ];
14386                                         this.direction = nearBottom ? "up": "down";
14387                                 }
14388                         }
14389
14390                         //Check if dropOnEmpty is enabled
14391                         if(!itemWithLeastDistance && !this.options.dropOnEmpty) {
14392                                 return;
14393                         }
14394
14395                         if(this.currentContainer === this.containers[innermostIndex]) {
14396                                 if ( !this.currentContainer.containerCache.over ) {
14397                                         this.containers[ innermostIndex ]._trigger( "over", event, this._uiHash() );
14398                                         this.currentContainer.containerCache.over = 1;
14399                                 }
14400                                 return;
14401                         }
14402
14403                         itemWithLeastDistance ? this._rearrange(event, itemWithLeastDistance, null, true) : this._rearrange(event, null, this.containers[innermostIndex].element, true);
14404                         this._trigger("change", event, this._uiHash());
14405                         this.containers[innermostIndex]._trigger("change", event, this._uiHash(this));
14406                         this.currentContainer = this.containers[innermostIndex];
14407
14408                         //Update the placeholder
14409                         this.options.placeholder.update(this.currentContainer, this.placeholder);
14410
14411                         this.containers[innermostIndex]._trigger("over", event, this._uiHash(this));
14412                         this.containers[innermostIndex].containerCache.over = 1;
14413                 }
14414
14415
14416         },
14417
14418         _createHelper: function(event) {
14419
14420                 var o = this.options,
14421                         helper = $.isFunction(o.helper) ? $(o.helper.apply(this.element[0], [event, this.currentItem])) : (o.helper === "clone" ? this.currentItem.clone() : this.currentItem);
14422
14423                 //Add the helper to the DOM if that didn't happen already
14424                 if(!helper.parents("body").length) {
14425                         $(o.appendTo !== "parent" ? o.appendTo : this.currentItem[0].parentNode)[0].appendChild(helper[0]);
14426                 }
14427
14428                 if(helper[0] === this.currentItem[0]) {
14429                         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") };
14430                 }
14431
14432                 if(!helper[0].style.width || o.forceHelperSize) {
14433                         helper.width(this.currentItem.width());
14434                 }
14435                 if(!helper[0].style.height || o.forceHelperSize) {
14436                         helper.height(this.currentItem.height());
14437                 }
14438
14439                 return helper;
14440
14441         },
14442
14443         _adjustOffsetFromHelper: function(obj) {
14444                 if (typeof obj === "string") {
14445                         obj = obj.split(" ");
14446                 }
14447                 if ($.isArray(obj)) {
14448                         obj = {left: +obj[0], top: +obj[1] || 0};
14449                 }
14450                 if ("left" in obj) {
14451                         this.offset.click.left = obj.left + this.margins.left;
14452                 }
14453                 if ("right" in obj) {
14454                         this.offset.click.left = this.helperProportions.width - obj.right + this.margins.left;
14455                 }
14456                 if ("top" in obj) {
14457                         this.offset.click.top = obj.top + this.margins.top;
14458                 }
14459                 if ("bottom" in obj) {
14460                         this.offset.click.top = this.helperProportions.height - obj.bottom + this.margins.top;
14461                 }
14462         },
14463
14464         _getParentOffset: function() {
14465
14466
14467                 //Get the offsetParent and cache its position
14468                 this.offsetParent = this.helper.offsetParent();
14469                 var po = this.offsetParent.offset();
14470
14471                 // This is a special case where we need to modify a offset calculated on start, since the following happened:
14472                 // 1. The position of the helper is absolute, so it's position is calculated based on the next positioned parent
14473                 // 2. The actual offset parent is a child of the scroll parent, and the scroll parent isn't the document, which means that
14474                 //    the scroll is included in the initial calculation of the offset of the parent, and never recalculated upon drag
14475                 if(this.cssPosition === "absolute" && this.scrollParent[0] !== this.document[0] && $.contains(this.scrollParent[0], this.offsetParent[0])) {
14476                         po.left += this.scrollParent.scrollLeft();
14477                         po.top += this.scrollParent.scrollTop();
14478                 }
14479
14480                 // This needs to be actually done for all browsers, since pageX/pageY includes this information
14481                 // with an ugly IE fix
14482                 if( this.offsetParent[0] === this.document[0].body || (this.offsetParent[0].tagName && this.offsetParent[0].tagName.toLowerCase() === "html" && $.ui.ie)) {
14483                         po = { top: 0, left: 0 };
14484                 }
14485
14486                 return {
14487                         top: po.top + (parseInt(this.offsetParent.css("borderTopWidth"),10) || 0),
14488                         left: po.left + (parseInt(this.offsetParent.css("borderLeftWidth"),10) || 0)
14489                 };
14490
14491         },
14492
14493         _getRelativeOffset: function() {
14494
14495                 if(this.cssPosition === "relative") {
14496                         var p = this.currentItem.position();
14497                         return {
14498                                 top: p.top - (parseInt(this.helper.css("top"),10) || 0) + this.scrollParent.scrollTop(),
14499                                 left: p.left - (parseInt(this.helper.css("left"),10) || 0) + this.scrollParent.scrollLeft()
14500                         };
14501                 } else {
14502                         return { top: 0, left: 0 };
14503                 }
14504
14505         },
14506
14507         _cacheMargins: function() {
14508                 this.margins = {
14509                         left: (parseInt(this.currentItem.css("marginLeft"),10) || 0),
14510                         top: (parseInt(this.currentItem.css("marginTop"),10) || 0)
14511                 };
14512         },
14513
14514         _cacheHelperProportions: function() {
14515                 this.helperProportions = {
14516                         width: this.helper.outerWidth(),
14517                         height: this.helper.outerHeight()
14518                 };
14519         },
14520
14521         _setContainment: function() {
14522
14523                 var ce, co, over,
14524                         o = this.options;
14525                 if(o.containment === "parent") {
14526                         o.containment = this.helper[0].parentNode;
14527                 }
14528                 if(o.containment === "document" || o.containment === "window") {
14529                         this.containment = [
14530                                 0 - this.offset.relative.left - this.offset.parent.left,
14531                                 0 - this.offset.relative.top - this.offset.parent.top,
14532                                 o.containment === "document" ? this.document.width() : this.window.width() - this.helperProportions.width - this.margins.left,
14533                                 (o.containment === "document" ? this.document.width() : this.window.height() || this.document[0].body.parentNode.scrollHeight) - this.helperProportions.height - this.margins.top
14534                         ];
14535                 }
14536
14537                 if(!(/^(document|window|parent)$/).test(o.containment)) {
14538                         ce = $(o.containment)[0];
14539                         co = $(o.containment).offset();
14540                         over = ($(ce).css("overflow") !== "hidden");
14541
14542                         this.containment = [
14543                                 co.left + (parseInt($(ce).css("borderLeftWidth"),10) || 0) + (parseInt($(ce).css("paddingLeft"),10) || 0) - this.margins.left,
14544                                 co.top + (parseInt($(ce).css("borderTopWidth"),10) || 0) + (parseInt($(ce).css("paddingTop"),10) || 0) - this.margins.top,
14545                                 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,
14546                                 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
14547                         ];
14548                 }
14549
14550         },
14551
14552         _convertPositionTo: function(d, pos) {
14553
14554                 if(!pos) {
14555                         pos = this.position;
14556                 }
14557                 var mod = d === "absolute" ? 1 : -1,
14558                         scroll = this.cssPosition === "absolute" && !(this.scrollParent[0] !== this.document[0] && $.contains(this.scrollParent[0], this.offsetParent[0])) ? this.offsetParent : this.scrollParent,
14559                         scrollIsRootNode = (/(html|body)/i).test(scroll[0].tagName);
14560
14561                 return {
14562                         top: (
14563                                 pos.top +                                                                                                                               // The absolute mouse position
14564                                 this.offset.relative.top * mod +                                                                                // Only for relative positioned nodes: Relative offset from element to offset parent
14565                                 this.offset.parent.top * mod -                                                                                  // The offsetParent's offset without borders (offset + border)
14566                                 ( ( this.cssPosition === "fixed" ? -this.scrollParent.scrollTop() : ( scrollIsRootNode ? 0 : scroll.scrollTop() ) ) * mod)
14567                         ),
14568                         left: (
14569                                 pos.left +                                                                                                                              // The absolute mouse position
14570                                 this.offset.relative.left * mod +                                                                               // Only for relative positioned nodes: Relative offset from element to offset parent
14571                                 this.offset.parent.left * mod   -                                                                               // The offsetParent's offset without borders (offset + border)
14572                                 ( ( this.cssPosition === "fixed" ? -this.scrollParent.scrollLeft() : scrollIsRootNode ? 0 : scroll.scrollLeft() ) * mod)
14573                         )
14574                 };
14575
14576         },
14577
14578         _generatePosition: function(event) {
14579
14580                 var top, left,
14581                         o = this.options,
14582                         pageX = event.pageX,
14583                         pageY = event.pageY,
14584                         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);
14585
14586                 // This is another very weird special case that only happens for relative elements:
14587                 // 1. If the css position is relative
14588                 // 2. and the scroll parent is the document or similar to the offset parent
14589                 // we have to refresh the relative offset during the scroll so there are no jumps
14590                 if(this.cssPosition === "relative" && !(this.scrollParent[0] !== this.document[0] && this.scrollParent[0] !== this.offsetParent[0])) {
14591                         this.offset.relative = this._getRelativeOffset();
14592                 }
14593
14594                 /*
14595                  * - Position constraining -
14596                  * Constrain the position to a mix of grid, containment.
14597                  */
14598
14599                 if(this.originalPosition) { //If we are not dragging yet, we won't check for options
14600
14601                         if(this.containment) {
14602                                 if(event.pageX - this.offset.click.left < this.containment[0]) {
14603                                         pageX = this.containment[0] + this.offset.click.left;
14604                                 }
14605                                 if(event.pageY - this.offset.click.top < this.containment[1]) {
14606                                         pageY = this.containment[1] + this.offset.click.top;
14607                                 }
14608                                 if(event.pageX - this.offset.click.left > this.containment[2]) {
14609                                         pageX = this.containment[2] + this.offset.click.left;
14610                                 }
14611                                 if(event.pageY - this.offset.click.top > this.containment[3]) {
14612                                         pageY = this.containment[3] + this.offset.click.top;
14613                                 }
14614                         }
14615
14616                         if(o.grid) {
14617                                 top = this.originalPageY + Math.round((pageY - this.originalPageY) / o.grid[1]) * o.grid[1];
14618                                 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;
14619
14620                                 left = this.originalPageX + Math.round((pageX - this.originalPageX) / o.grid[0]) * o.grid[0];
14621                                 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;
14622                         }
14623
14624                 }
14625
14626                 return {
14627                         top: (
14628                                 pageY -                                                                                                                         // The absolute mouse position
14629                                 this.offset.click.top -                                                                                                 // Click offset (relative to the element)
14630                                 this.offset.relative.top        -                                                                                       // Only for relative positioned nodes: Relative offset from element to offset parent
14631                                 this.offset.parent.top +                                                                                                // The offsetParent's offset without borders (offset + border)
14632                                 ( ( this.cssPosition === "fixed" ? -this.scrollParent.scrollTop() : ( scrollIsRootNode ? 0 : scroll.scrollTop() ) ))
14633                         ),
14634                         left: (
14635                                 pageX -                                                                                                                         // The absolute mouse position
14636                                 this.offset.click.left -                                                                                                // Click offset (relative to the element)
14637                                 this.offset.relative.left       -                                                                                       // Only for relative positioned nodes: Relative offset from element to offset parent
14638                                 this.offset.parent.left +                                                                                               // The offsetParent's offset without borders (offset + border)
14639                                 ( ( this.cssPosition === "fixed" ? -this.scrollParent.scrollLeft() : scrollIsRootNode ? 0 : scroll.scrollLeft() ))
14640                         )
14641                 };
14642
14643         },
14644
14645         _rearrange: function(event, i, a, hardRefresh) {
14646
14647                 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));
14648
14649                 //Various things done here to improve the performance:
14650                 // 1. we create a setTimeout, that calls refreshPositions
14651                 // 2. on the instance, we have a counter variable, that get's higher after every append
14652                 // 3. on the local scope, we copy the counter variable, and check in the timeout, if it's still the same
14653                 // 4. this lets only the last addition to the timeout stack through
14654                 this.counter = this.counter ? ++this.counter : 1;
14655                 var counter = this.counter;
14656
14657                 this._delay(function() {
14658                         if(counter === this.counter) {
14659                                 this.refreshPositions(!hardRefresh); //Precompute after each DOM insertion, NOT on mousemove
14660                         }
14661                 });
14662
14663         },
14664
14665         _clear: function(event, noPropagation) {
14666
14667                 this.reverting = false;
14668                 // We delay all events that have to be triggered to after the point where the placeholder has been removed and
14669                 // everything else normalized again
14670                 var i,
14671                         delayedTriggers = [];
14672
14673                 // We first have to update the dom position of the actual currentItem
14674                 // Note: don't do it if the current item is already removed (by a user), or it gets reappended (see #4088)
14675                 if(!this._noFinalSort && this.currentItem.parent().length) {
14676                         this.placeholder.before(this.currentItem);
14677                 }
14678                 this._noFinalSort = null;
14679
14680                 if(this.helper[0] === this.currentItem[0]) {
14681                         for(i in this._storedCSS) {
14682                                 if(this._storedCSS[i] === "auto" || this._storedCSS[i] === "static") {
14683                                         this._storedCSS[i] = "";
14684                                 }
14685                         }
14686                         this.currentItem.css(this._storedCSS).removeClass("ui-sortable-helper");
14687                 } else {
14688                         this.currentItem.show();
14689                 }
14690
14691                 if(this.fromOutside && !noPropagation) {
14692                         delayedTriggers.push(function(event) { this._trigger("receive", event, this._uiHash(this.fromOutside)); });
14693                 }
14694                 if((this.fromOutside || this.domPosition.prev !== this.currentItem.prev().not(".ui-sortable-helper")[0] || this.domPosition.parent !== this.currentItem.parent()[0]) && !noPropagation) {
14695                         delayedTriggers.push(function(event) { this._trigger("update", event, this._uiHash()); }); //Trigger update callback if the DOM position has changed
14696                 }
14697
14698                 // Check if the items Container has Changed and trigger appropriate
14699                 // events.
14700                 if (this !== this.currentContainer) {
14701                         if(!noPropagation) {
14702                                 delayedTriggers.push(function(event) { this._trigger("remove", event, this._uiHash()); });
14703                                 delayedTriggers.push((function(c) { return function(event) { c._trigger("receive", event, this._uiHash(this)); };  }).call(this, this.currentContainer));
14704                                 delayedTriggers.push((function(c) { return function(event) { c._trigger("update", event, this._uiHash(this));  }; }).call(this, this.currentContainer));
14705                         }
14706                 }
14707
14708
14709                 //Post events to containers
14710                 function delayEvent( type, instance, container ) {
14711                         return function( event ) {
14712                                 container._trigger( type, event, instance._uiHash( instance ) );
14713                         };
14714                 }
14715                 for (i = this.containers.length - 1; i >= 0; i--){
14716                         if (!noPropagation) {
14717                                 delayedTriggers.push( delayEvent( "deactivate", this, this.containers[ i ] ) );
14718                         }
14719                         if(this.containers[i].containerCache.over) {
14720                                 delayedTriggers.push( delayEvent( "out", this, this.containers[ i ] ) );
14721                                 this.containers[i].containerCache.over = 0;
14722                         }
14723                 }
14724
14725                 //Do what was originally in plugins
14726                 if ( this.storedCursor ) {
14727                         this.document.find( "body" ).css( "cursor", this.storedCursor );
14728                         this.storedStylesheet.remove();
14729                 }
14730                 if(this._storedOpacity) {
14731                         this.helper.css("opacity", this._storedOpacity);
14732                 }
14733                 if(this._storedZIndex) {
14734                         this.helper.css("zIndex", this._storedZIndex === "auto" ? "" : this._storedZIndex);
14735                 }
14736
14737                 this.dragging = false;
14738
14739                 if(!noPropagation) {
14740                         this._trigger("beforeStop", event, this._uiHash());
14741                 }
14742
14743                 //$(this.placeholder[0]).remove(); would have been the jQuery way - unfortunately, it unbinds ALL events from the original node!
14744                 this.placeholder[0].parentNode.removeChild(this.placeholder[0]);
14745
14746                 if ( !this.cancelHelperRemoval ) {
14747                         if ( this.helper[ 0 ] !== this.currentItem[ 0 ] ) {
14748                                 this.helper.remove();
14749                         }
14750                         this.helper = null;
14751                 }
14752
14753                 if(!noPropagation) {
14754                         for (i=0; i < delayedTriggers.length; i++) {
14755                                 delayedTriggers[i].call(this, event);
14756                         } //Trigger all delayed events
14757                         this._trigger("stop", event, this._uiHash());
14758                 }
14759
14760                 this.fromOutside = false;
14761                 return !this.cancelHelperRemoval;
14762
14763         },
14764
14765         _trigger: function() {
14766                 if ($.Widget.prototype._trigger.apply(this, arguments) === false) {
14767                         this.cancel();
14768                 }
14769         },
14770
14771         _uiHash: function(_inst) {
14772                 var inst = _inst || this;
14773                 return {
14774                         helper: inst.helper,
14775                         placeholder: inst.placeholder || $([]),
14776                         position: inst.position,
14777                         originalPosition: inst.originalPosition,
14778                         offset: inst.positionAbs,
14779                         item: inst.currentItem,
14780                         sender: _inst ? _inst.element : null
14781                 };
14782         }
14783
14784 });
14785
14786
14787 /*!
14788  * jQuery UI Spinner 1.11.4
14789  * http://jqueryui.com
14790  *
14791  * Copyright jQuery Foundation and other contributors
14792  * Released under the MIT license.
14793  * http://jquery.org/license
14794  *
14795  * http://api.jqueryui.com/spinner/
14796  */
14797
14798
14799 function spinner_modifier( fn ) {
14800         return function() {
14801                 var previous = this.element.val();
14802                 fn.apply( this, arguments );
14803                 this._refresh();
14804                 if ( previous !== this.element.val() ) {
14805                         this._trigger( "change" );
14806                 }
14807         };
14808 }
14809
14810 var spinner = $.widget( "ui.spinner", {
14811         version: "1.11.4",
14812         defaultElement: "<input>",
14813         widgetEventPrefix: "spin",
14814         options: {
14815                 culture: null,
14816                 icons: {
14817                         down: "ui-icon-triangle-1-s",
14818                         up: "ui-icon-triangle-1-n"
14819                 },
14820                 incremental: true,
14821                 max: null,
14822                 min: null,
14823                 numberFormat: null,
14824                 page: 10,
14825                 step: 1,
14826
14827                 change: null,
14828                 spin: null,
14829                 start: null,
14830                 stop: null
14831         },
14832
14833         _create: function() {
14834                 // handle string values that need to be parsed
14835                 this._setOption( "max", this.options.max );
14836                 this._setOption( "min", this.options.min );
14837                 this._setOption( "step", this.options.step );
14838
14839                 // Only format if there is a value, prevents the field from being marked
14840                 // as invalid in Firefox, see #9573.
14841                 if ( this.value() !== "" ) {
14842                         // Format the value, but don't constrain.
14843                         this._value( this.element.val(), true );
14844                 }
14845
14846                 this._draw();
14847                 this._on( this._events );
14848                 this._refresh();
14849
14850                 // turning off autocomplete prevents the browser from remembering the
14851                 // value when navigating through history, so we re-enable autocomplete
14852                 // if the page is unloaded before the widget is destroyed. #7790
14853                 this._on( this.window, {
14854                         beforeunload: function() {
14855                                 this.element.removeAttr( "autocomplete" );
14856                         }
14857                 });
14858         },
14859
14860         _getCreateOptions: function() {
14861                 var options = {},
14862                         element = this.element;
14863
14864                 $.each( [ "min", "max", "step" ], function( i, option ) {
14865                         var value = element.attr( option );
14866                         if ( value !== undefined && value.length ) {
14867                                 options[ option ] = value;
14868                         }
14869                 });
14870
14871                 return options;
14872         },
14873
14874         _events: {
14875                 keydown: function( event ) {
14876                         if ( this._start( event ) && this._keydown( event ) ) {
14877                                 event.preventDefault();
14878                         }
14879                 },
14880                 keyup: "_stop",
14881                 focus: function() {
14882                         this.previous = this.element.val();
14883                 },
14884                 blur: function( event ) {
14885                         if ( this.cancelBlur ) {
14886                                 delete this.cancelBlur;
14887                                 return;
14888                         }
14889
14890                         this._stop();
14891                         this._refresh();
14892                         if ( this.previous !== this.element.val() ) {
14893                                 this._trigger( "change", event );
14894                         }
14895                 },
14896                 mousewheel: function( event, delta ) {
14897                         if ( !delta ) {
14898                                 return;
14899                         }
14900                         if ( !this.spinning && !this._start( event ) ) {
14901                                 return false;
14902                         }
14903
14904                         this._spin( (delta > 0 ? 1 : -1) * this.options.step, event );
14905                         clearTimeout( this.mousewheelTimer );
14906                         this.mousewheelTimer = this._delay(function() {
14907                                 if ( this.spinning ) {
14908                                         this._stop( event );
14909                                 }
14910                         }, 100 );
14911                         event.preventDefault();
14912                 },
14913                 "mousedown .ui-spinner-button": function( event ) {
14914                         var previous;
14915
14916                         // We never want the buttons to have focus; whenever the user is
14917                         // interacting with the spinner, the focus should be on the input.
14918                         // If the input is focused then this.previous is properly set from
14919                         // when the input first received focus. If the input is not focused
14920                         // then we need to set this.previous based on the value before spinning.
14921                         previous = this.element[0] === this.document[0].activeElement ?
14922                                 this.previous : this.element.val();
14923                         function checkFocus() {
14924                                 var isActive = this.element[0] === this.document[0].activeElement;
14925                                 if ( !isActive ) {
14926                                         this.element.focus();
14927                                         this.previous = previous;
14928                                         // support: IE
14929                                         // IE sets focus asynchronously, so we need to check if focus
14930                                         // moved off of the input because the user clicked on the button.
14931                                         this._delay(function() {
14932                                                 this.previous = previous;
14933                                         });
14934                                 }
14935                         }
14936
14937                         // ensure focus is on (or stays on) the text field
14938                         event.preventDefault();
14939                         checkFocus.call( this );
14940
14941                         // support: IE
14942                         // IE doesn't prevent moving focus even with event.preventDefault()
14943                         // so we set a flag to know when we should ignore the blur event
14944                         // and check (again) if focus moved off of the input.
14945                         this.cancelBlur = true;
14946                         this._delay(function() {
14947                                 delete this.cancelBlur;
14948                                 checkFocus.call( this );
14949                         });
14950
14951                         if ( this._start( event ) === false ) {
14952                                 return;
14953                         }
14954
14955                         this._repeat( null, $( event.currentTarget ).hasClass( "ui-spinner-up" ) ? 1 : -1, event );
14956                 },
14957                 "mouseup .ui-spinner-button": "_stop",
14958                 "mouseenter .ui-spinner-button": function( event ) {
14959                         // button will add ui-state-active if mouse was down while mouseleave and kept down
14960                         if ( !$( event.currentTarget ).hasClass( "ui-state-active" ) ) {
14961                                 return;
14962                         }
14963
14964                         if ( this._start( event ) === false ) {
14965                                 return false;
14966                         }
14967                         this._repeat( null, $( event.currentTarget ).hasClass( "ui-spinner-up" ) ? 1 : -1, event );
14968                 },
14969                 // TODO: do we really want to consider this a stop?
14970                 // shouldn't we just stop the repeater and wait until mouseup before
14971                 // we trigger the stop event?
14972                 "mouseleave .ui-spinner-button": "_stop"
14973         },
14974
14975         _draw: function() {
14976                 var uiSpinner = this.uiSpinner = this.element
14977                         .addClass( "ui-spinner-input" )
14978                         .attr( "autocomplete", "off" )
14979                         .wrap( this._uiSpinnerHtml() )
14980                         .parent()
14981                                 // add buttons
14982                                 .append( this._buttonHtml() );
14983
14984                 this.element.attr( "role", "spinbutton" );
14985
14986                 // button bindings
14987                 this.buttons = uiSpinner.find( ".ui-spinner-button" )
14988                         .attr( "tabIndex", -1 )
14989                         .button()
14990                         .removeClass( "ui-corner-all" );
14991
14992                 // IE 6 doesn't understand height: 50% for the buttons
14993                 // unless the wrapper has an explicit height
14994                 if ( this.buttons.height() > Math.ceil( uiSpinner.height() * 0.5 ) &&
14995                                 uiSpinner.height() > 0 ) {
14996                         uiSpinner.height( uiSpinner.height() );
14997                 }
14998
14999                 // disable spinner if element was already disabled
15000                 if ( this.options.disabled ) {
15001                         this.disable();
15002                 }
15003         },
15004
15005         _keydown: function( event ) {
15006                 var options = this.options,
15007                         keyCode = $.ui.keyCode;
15008
15009                 switch ( event.keyCode ) {
15010                 case keyCode.UP:
15011                         this._repeat( null, 1, event );
15012                         return true;
15013                 case keyCode.DOWN:
15014                         this._repeat( null, -1, event );
15015                         return true;
15016                 case keyCode.PAGE_UP:
15017                         this._repeat( null, options.page, event );
15018                         return true;
15019                 case keyCode.PAGE_DOWN:
15020                         this._repeat( null, -options.page, event );
15021                         return true;
15022                 }
15023
15024                 return false;
15025         },
15026
15027         _uiSpinnerHtml: function() {
15028                 return "<span class='ui-spinner ui-widget ui-widget-content ui-corner-all'></span>";
15029         },
15030
15031         _buttonHtml: function() {
15032                 return "" +
15033                         "<a class='ui-spinner-button ui-spinner-up ui-corner-tr'>" +
15034                                 "<span class='ui-icon " + this.options.icons.up + "'>&#9650;</span>" +
15035                         "</a>" +
15036                         "<a class='ui-spinner-button ui-spinner-down ui-corner-br'>" +
15037                                 "<span class='ui-icon " + this.options.icons.down + "'>&#9660;</span>" +
15038                         "</a>";
15039         },
15040
15041         _start: function( event ) {
15042                 if ( !this.spinning && this._trigger( "start", event ) === false ) {
15043                         return false;
15044                 }
15045
15046                 if ( !this.counter ) {
15047                         this.counter = 1;
15048                 }
15049                 this.spinning = true;
15050                 return true;
15051         },
15052
15053         _repeat: function( i, steps, event ) {
15054                 i = i || 500;
15055
15056                 clearTimeout( this.timer );
15057                 this.timer = this._delay(function() {
15058                         this._repeat( 40, steps, event );
15059                 }, i );
15060
15061                 this._spin( steps * this.options.step, event );
15062         },
15063
15064         _spin: function( step, event ) {
15065                 var value = this.value() || 0;
15066
15067                 if ( !this.counter ) {
15068                         this.counter = 1;
15069                 }
15070
15071                 value = this._adjustValue( value + step * this._increment( this.counter ) );
15072
15073                 if ( !this.spinning || this._trigger( "spin", event, { value: value } ) !== false) {
15074                         this._value( value );
15075                         this.counter++;
15076                 }
15077         },
15078
15079         _increment: function( i ) {
15080                 var incremental = this.options.incremental;
15081
15082                 if ( incremental ) {
15083                         return $.isFunction( incremental ) ?
15084                                 incremental( i ) :
15085                                 Math.floor( i * i * i / 50000 - i * i / 500 + 17 * i / 200 + 1 );
15086                 }
15087
15088                 return 1;
15089         },
15090
15091         _precision: function() {
15092                 var precision = this._precisionOf( this.options.step );
15093                 if ( this.options.min !== null ) {
15094                         precision = Math.max( precision, this._precisionOf( this.options.min ) );
15095                 }
15096                 return precision;
15097         },
15098
15099         _precisionOf: function( num ) {
15100                 var str = num.toString(),
15101                         decimal = str.indexOf( "." );
15102                 return decimal === -1 ? 0 : str.length - decimal - 1;
15103         },
15104
15105         _adjustValue: function( value ) {
15106                 var base, aboveMin,
15107                         options = this.options;
15108
15109                 // make sure we're at a valid step
15110                 // - find out where we are relative to the base (min or 0)
15111                 base = options.min !== null ? options.min : 0;
15112                 aboveMin = value - base;
15113                 // - round to the nearest step
15114                 aboveMin = Math.round(aboveMin / options.step) * options.step;
15115                 // - rounding is based on 0, so adjust back to our base
15116                 value = base + aboveMin;
15117
15118                 // fix precision from bad JS floating point math
15119                 value = parseFloat( value.toFixed( this._precision() ) );
15120
15121                 // clamp the value
15122                 if ( options.max !== null && value > options.max) {
15123                         return options.max;
15124                 }
15125                 if ( options.min !== null && value < options.min ) {
15126                         return options.min;
15127                 }
15128
15129                 return value;
15130         },
15131
15132         _stop: function( event ) {
15133                 if ( !this.spinning ) {
15134                         return;
15135                 }
15136
15137                 clearTimeout( this.timer );
15138                 clearTimeout( this.mousewheelTimer );
15139                 this.counter = 0;
15140                 this.spinning = false;
15141                 this._trigger( "stop", event );
15142         },
15143
15144         _setOption: function( key, value ) {
15145                 if ( key === "culture" || key === "numberFormat" ) {
15146                         var prevValue = this._parse( this.element.val() );
15147                         this.options[ key ] = value;
15148                         this.element.val( this._format( prevValue ) );
15149                         return;
15150                 }
15151
15152                 if ( key === "max" || key === "min" || key === "step" ) {
15153                         if ( typeof value === "string" ) {
15154                                 value = this._parse( value );
15155                         }
15156                 }
15157                 if ( key === "icons" ) {
15158                         this.buttons.first().find( ".ui-icon" )
15159                                 .removeClass( this.options.icons.up )
15160                                 .addClass( value.up );
15161                         this.buttons.last().find( ".ui-icon" )
15162                                 .removeClass( this.options.icons.down )
15163                                 .addClass( value.down );
15164                 }
15165
15166                 this._super( key, value );
15167
15168                 if ( key === "disabled" ) {
15169                         this.widget().toggleClass( "ui-state-disabled", !!value );
15170                         this.element.prop( "disabled", !!value );
15171                         this.buttons.button( value ? "disable" : "enable" );
15172                 }
15173         },
15174
15175         _setOptions: spinner_modifier(function( options ) {
15176                 this._super( options );
15177         }),
15178
15179         _parse: function( val ) {
15180                 if ( typeof val === "string" && val !== "" ) {
15181                         val = window.Globalize && this.options.numberFormat ?
15182                                 Globalize.parseFloat( val, 10, this.options.culture ) : +val;
15183                 }
15184                 return val === "" || isNaN( val ) ? null : val;
15185         },
15186
15187         _format: function( value ) {
15188                 if ( value === "" ) {
15189                         return "";
15190                 }
15191                 return window.Globalize && this.options.numberFormat ?
15192                         Globalize.format( value, this.options.numberFormat, this.options.culture ) :
15193                         value;
15194         },
15195
15196         _refresh: function() {
15197                 this.element.attr({
15198                         "aria-valuemin": this.options.min,
15199                         "aria-valuemax": this.options.max,
15200                         // TODO: what should we do with values that can't be parsed?
15201                         "aria-valuenow": this._parse( this.element.val() )
15202                 });
15203         },
15204
15205         isValid: function() {
15206                 var value = this.value();
15207
15208                 // null is invalid
15209                 if ( value === null ) {
15210                         return false;
15211                 }
15212
15213                 // if value gets adjusted, it's invalid
15214                 return value === this._adjustValue( value );
15215         },
15216
15217         // update the value without triggering change
15218         _value: function( value, allowAny ) {
15219                 var parsed;
15220                 if ( value !== "" ) {
15221                         parsed = this._parse( value );
15222                         if ( parsed !== null ) {
15223                                 if ( !allowAny ) {
15224                                         parsed = this._adjustValue( parsed );
15225                                 }
15226                                 value = this._format( parsed );
15227                         }
15228                 }
15229                 this.element.val( value );
15230                 this._refresh();
15231         },
15232
15233         _destroy: function() {
15234                 this.element
15235                         .removeClass( "ui-spinner-input" )
15236                         .prop( "disabled", false )
15237                         .removeAttr( "autocomplete" )
15238                         .removeAttr( "role" )
15239                         .removeAttr( "aria-valuemin" )
15240                         .removeAttr( "aria-valuemax" )
15241                         .removeAttr( "aria-valuenow" );
15242                 this.uiSpinner.replaceWith( this.element );
15243         },
15244
15245         stepUp: spinner_modifier(function( steps ) {
15246                 this._stepUp( steps );
15247         }),
15248         _stepUp: function( steps ) {
15249                 if ( this._start() ) {
15250                         this._spin( (steps || 1) * this.options.step );
15251                         this._stop();
15252                 }
15253         },
15254
15255         stepDown: spinner_modifier(function( steps ) {
15256                 this._stepDown( steps );
15257         }),
15258         _stepDown: function( steps ) {
15259                 if ( this._start() ) {
15260                         this._spin( (steps || 1) * -this.options.step );
15261                         this._stop();
15262                 }
15263         },
15264
15265         pageUp: spinner_modifier(function( pages ) {
15266                 this._stepUp( (pages || 1) * this.options.page );
15267         }),
15268
15269         pageDown: spinner_modifier(function( pages ) {
15270                 this._stepDown( (pages || 1) * this.options.page );
15271         }),
15272
15273         value: function( newVal ) {
15274                 if ( !arguments.length ) {
15275                         return this._parse( this.element.val() );
15276                 }
15277                 spinner_modifier( this._value ).call( this, newVal );
15278         },
15279
15280         widget: function() {
15281                 return this.uiSpinner;
15282         }
15283 });
15284
15285
15286 /*!
15287  * jQuery UI Tabs 1.11.4
15288  * http://jqueryui.com
15289  *
15290  * Copyright jQuery Foundation and other contributors
15291  * Released under the MIT license.
15292  * http://jquery.org/license
15293  *
15294  * http://api.jqueryui.com/tabs/
15295  */
15296
15297
15298 var tabs = $.widget( "ui.tabs", {
15299         version: "1.11.4",
15300         delay: 300,
15301         options: {
15302                 active: null,
15303                 collapsible: false,
15304                 event: "click",
15305                 heightStyle: "content",
15306                 hide: null,
15307                 show: null,
15308
15309                 // callbacks
15310                 activate: null,
15311                 beforeActivate: null,
15312                 beforeLoad: null,
15313                 load: null
15314         },
15315
15316         _isLocal: (function() {
15317                 var rhash = /#.*$/;
15318
15319                 return function( anchor ) {
15320                         var anchorUrl, locationUrl;
15321
15322                         // support: IE7
15323                         // IE7 doesn't normalize the href property when set via script (#9317)
15324                         anchor = anchor.cloneNode( false );
15325
15326                         anchorUrl = anchor.href.replace( rhash, "" );
15327                         locationUrl = location.href.replace( rhash, "" );
15328
15329                         // decoding may throw an error if the URL isn't UTF-8 (#9518)
15330                         try {
15331                                 anchorUrl = decodeURIComponent( anchorUrl );
15332                         } catch ( error ) {}
15333                         try {
15334                                 locationUrl = decodeURIComponent( locationUrl );
15335                         } catch ( error ) {}
15336
15337                         return anchor.hash.length > 1 && anchorUrl === locationUrl;
15338                 };
15339         })(),
15340
15341         _create: function() {
15342                 var that = this,
15343                         options = this.options;
15344
15345                 this.running = false;
15346
15347                 this.element
15348                         .addClass( "ui-tabs ui-widget ui-widget-content ui-corner-all" )
15349                         .toggleClass( "ui-tabs-collapsible", options.collapsible );
15350
15351                 this._processTabs();
15352                 options.active = this._initialActive();
15353
15354                 // Take disabling tabs via class attribute from HTML
15355                 // into account and update option properly.
15356                 if ( $.isArray( options.disabled ) ) {
15357                         options.disabled = $.unique( options.disabled.concat(
15358                                 $.map( this.tabs.filter( ".ui-state-disabled" ), function( li ) {
15359                                         return that.tabs.index( li );
15360                                 })
15361                         ) ).sort();
15362                 }
15363
15364                 // check for length avoids error when initializing empty list
15365                 if ( this.options.active !== false && this.anchors.length ) {
15366                         this.active = this._findActive( options.active );
15367                 } else {
15368                         this.active = $();
15369                 }
15370
15371                 this._refresh();
15372
15373                 if ( this.active.length ) {
15374                         this.load( options.active );
15375                 }
15376         },
15377
15378         _initialActive: function() {
15379                 var active = this.options.active,
15380                         collapsible = this.options.collapsible,
15381                         locationHash = location.hash.substring( 1 );
15382
15383                 if ( active === null ) {
15384                         // check the fragment identifier in the URL
15385                         if ( locationHash ) {
15386                                 this.tabs.each(function( i, tab ) {
15387                                         if ( $( tab ).attr( "aria-controls" ) === locationHash ) {
15388                                                 active = i;
15389                                                 return false;
15390                                         }
15391                                 });
15392                         }
15393
15394                         // check for a tab marked active via a class
15395                         if ( active === null ) {
15396                                 active = this.tabs.index( this.tabs.filter( ".ui-tabs-active" ) );
15397                         }
15398
15399                         // no active tab, set to false
15400                         if ( active === null || active === -1 ) {
15401                                 active = this.tabs.length ? 0 : false;
15402                         }
15403                 }
15404
15405                 // handle numbers: negative, out of range
15406                 if ( active !== false ) {
15407                         active = this.tabs.index( this.tabs.eq( active ) );
15408                         if ( active === -1 ) {
15409                                 active = collapsible ? false : 0;
15410                         }
15411                 }
15412
15413                 // don't allow collapsible: false and active: false
15414                 if ( !collapsible && active === false && this.anchors.length ) {
15415                         active = 0;
15416                 }
15417
15418                 return active;
15419         },
15420
15421         _getCreateEventData: function() {
15422                 return {
15423                         tab: this.active,
15424                         panel: !this.active.length ? $() : this._getPanelForTab( this.active )
15425                 };
15426         },
15427
15428         _tabKeydown: function( event ) {
15429                 var focusedTab = $( this.document[0].activeElement ).closest( "li" ),
15430                         selectedIndex = this.tabs.index( focusedTab ),
15431                         goingForward = true;
15432
15433                 if ( this._handlePageNav( event ) ) {
15434                         return;
15435                 }
15436
15437                 switch ( event.keyCode ) {
15438                         case $.ui.keyCode.RIGHT:
15439                         case $.ui.keyCode.DOWN:
15440                                 selectedIndex++;
15441                                 break;
15442                         case $.ui.keyCode.UP:
15443                         case $.ui.keyCode.LEFT:
15444                                 goingForward = false;
15445                                 selectedIndex--;
15446                                 break;
15447                         case $.ui.keyCode.END:
15448                                 selectedIndex = this.anchors.length - 1;
15449                                 break;
15450                         case $.ui.keyCode.HOME:
15451                                 selectedIndex = 0;
15452                                 break;
15453                         case $.ui.keyCode.SPACE:
15454                                 // Activate only, no collapsing
15455                                 event.preventDefault();
15456                                 clearTimeout( this.activating );
15457                                 this._activate( selectedIndex );
15458                                 return;
15459                         case $.ui.keyCode.ENTER:
15460                                 // Toggle (cancel delayed activation, allow collapsing)
15461                                 event.preventDefault();
15462                                 clearTimeout( this.activating );
15463                                 // Determine if we should collapse or activate
15464                                 this._activate( selectedIndex === this.options.active ? false : selectedIndex );
15465                                 return;
15466                         default:
15467                                 return;
15468                 }
15469
15470                 // Focus the appropriate tab, based on which key was pressed
15471                 event.preventDefault();
15472                 clearTimeout( this.activating );
15473                 selectedIndex = this._focusNextTab( selectedIndex, goingForward );
15474
15475                 // Navigating with control/command key will prevent automatic activation
15476                 if ( !event.ctrlKey && !event.metaKey ) {
15477
15478                         // Update aria-selected immediately so that AT think the tab is already selected.
15479                         // Otherwise AT may confuse the user by stating that they need to activate the tab,
15480                         // but the tab will already be activated by the time the announcement finishes.
15481                         focusedTab.attr( "aria-selected", "false" );
15482                         this.tabs.eq( selectedIndex ).attr( "aria-selected", "true" );
15483
15484                         this.activating = this._delay(function() {
15485                                 this.option( "active", selectedIndex );
15486                         }, this.delay );
15487                 }
15488         },
15489
15490         _panelKeydown: function( event ) {
15491                 if ( this._handlePageNav( event ) ) {
15492                         return;
15493                 }
15494
15495                 // Ctrl+up moves focus to the current tab
15496                 if ( event.ctrlKey && event.keyCode === $.ui.keyCode.UP ) {
15497                         event.preventDefault();
15498                         this.active.focus();
15499                 }
15500         },
15501
15502         // Alt+page up/down moves focus to the previous/next tab (and activates)
15503         _handlePageNav: function( event ) {
15504                 if ( event.altKey && event.keyCode === $.ui.keyCode.PAGE_UP ) {
15505                         this._activate( this._focusNextTab( this.options.active - 1, false ) );
15506                         return true;
15507                 }
15508                 if ( event.altKey && event.keyCode === $.ui.keyCode.PAGE_DOWN ) {
15509                         this._activate( this._focusNextTab( this.options.active + 1, true ) );
15510                         return true;
15511                 }
15512         },
15513
15514         _findNextTab: function( index, goingForward ) {
15515                 var lastTabIndex = this.tabs.length - 1;
15516
15517                 function constrain() {
15518                         if ( index > lastTabIndex ) {
15519                                 index = 0;
15520                         }
15521                         if ( index < 0 ) {
15522                                 index = lastTabIndex;
15523                         }
15524                         return index;
15525                 }
15526
15527                 while ( $.inArray( constrain(), this.options.disabled ) !== -1 ) {
15528                         index = goingForward ? index + 1 : index - 1;
15529                 }
15530
15531                 return index;
15532         },
15533
15534         _focusNextTab: function( index, goingForward ) {
15535                 index = this._findNextTab( index, goingForward );
15536                 this.tabs.eq( index ).focus();
15537                 return index;
15538         },
15539
15540         _setOption: function( key, value ) {
15541                 if ( key === "active" ) {
15542                         // _activate() will handle invalid values and update this.options
15543                         this._activate( value );
15544                         return;
15545                 }
15546
15547                 if ( key === "disabled" ) {
15548                         // don't use the widget factory's disabled handling
15549                         this._setupDisabled( value );
15550                         return;
15551                 }
15552
15553                 this._super( key, value);
15554
15555                 if ( key === "collapsible" ) {
15556                         this.element.toggleClass( "ui-tabs-collapsible", value );
15557                         // Setting collapsible: false while collapsed; open first panel
15558                         if ( !value && this.options.active === false ) {
15559                                 this._activate( 0 );
15560                         }
15561                 }
15562
15563                 if ( key === "event" ) {
15564                         this._setupEvents( value );
15565                 }
15566
15567                 if ( key === "heightStyle" ) {
15568                         this._setupHeightStyle( value );
15569                 }
15570         },
15571
15572         _sanitizeSelector: function( hash ) {
15573                 return hash ? hash.replace( /[!"$%&'()*+,.\/:;<=>?@\[\]\^`{|}~]/g, "\\$&" ) : "";
15574         },
15575
15576         refresh: function() {
15577                 var options = this.options,
15578                         lis = this.tablist.children( ":has(a[href])" );
15579
15580                 // get disabled tabs from class attribute from HTML
15581                 // this will get converted to a boolean if needed in _refresh()
15582                 options.disabled = $.map( lis.filter( ".ui-state-disabled" ), function( tab ) {
15583                         return lis.index( tab );
15584                 });
15585
15586                 this._processTabs();
15587
15588                 // was collapsed or no tabs
15589                 if ( options.active === false || !this.anchors.length ) {
15590                         options.active = false;
15591                         this.active = $();
15592                 // was active, but active tab is gone
15593                 } else if ( this.active.length && !$.contains( this.tablist[ 0 ], this.active[ 0 ] ) ) {
15594                         // all remaining tabs are disabled
15595                         if ( this.tabs.length === options.disabled.length ) {
15596                                 options.active = false;
15597                                 this.active = $();
15598                         // activate previous tab
15599                         } else {
15600                                 this._activate( this._findNextTab( Math.max( 0, options.active - 1 ), false ) );
15601                         }
15602                 // was active, active tab still exists
15603                 } else {
15604                         // make sure active index is correct
15605                         options.active = this.tabs.index( this.active );
15606                 }
15607
15608                 this._refresh();
15609         },
15610
15611         _refresh: function() {
15612                 this._setupDisabled( this.options.disabled );
15613                 this._setupEvents( this.options.event );
15614                 this._setupHeightStyle( this.options.heightStyle );
15615
15616                 this.tabs.not( this.active ).attr({
15617                         "aria-selected": "false",
15618                         "aria-expanded": "false",
15619                         tabIndex: -1
15620                 });
15621                 this.panels.not( this._getPanelForTab( this.active ) )
15622                         .hide()
15623                         .attr({
15624                                 "aria-hidden": "true"
15625                         });
15626
15627                 // Make sure one tab is in the tab order
15628                 if ( !this.active.length ) {
15629                         this.tabs.eq( 0 ).attr( "tabIndex", 0 );
15630                 } else {
15631                         this.active
15632                                 .addClass( "ui-tabs-active ui-state-active" )
15633                                 .attr({
15634                                         "aria-selected": "true",
15635                                         "aria-expanded": "true",
15636                                         tabIndex: 0
15637                                 });
15638                         this._getPanelForTab( this.active )
15639                                 .show()
15640                                 .attr({
15641                                         "aria-hidden": "false"
15642                                 });
15643                 }
15644         },
15645
15646         _processTabs: function() {
15647                 var that = this,
15648                         prevTabs = this.tabs,
15649                         prevAnchors = this.anchors,
15650                         prevPanels = this.panels;
15651
15652                 this.tablist = this._getList()
15653                         .addClass( "ui-tabs-nav ui-helper-reset ui-helper-clearfix ui-widget-header ui-corner-all" )
15654                         .attr( "role", "tablist" )
15655
15656                         // Prevent users from focusing disabled tabs via click
15657                         .delegate( "> li", "mousedown" + this.eventNamespace, function( event ) {
15658                                 if ( $( this ).is( ".ui-state-disabled" ) ) {
15659                                         event.preventDefault();
15660                                 }
15661                         })
15662
15663                         // support: IE <9
15664                         // Preventing the default action in mousedown doesn't prevent IE
15665                         // from focusing the element, so if the anchor gets focused, blur.
15666                         // We don't have to worry about focusing the previously focused
15667                         // element since clicking on a non-focusable element should focus
15668                         // the body anyway.
15669                         .delegate( ".ui-tabs-anchor", "focus" + this.eventNamespace, function() {
15670                                 if ( $( this ).closest( "li" ).is( ".ui-state-disabled" ) ) {
15671                                         this.blur();
15672                                 }
15673                         });
15674
15675                 this.tabs = this.tablist.find( "> li:has(a[href])" )
15676                         .addClass( "ui-state-default ui-corner-top" )
15677                         .attr({
15678                                 role: "tab",
15679                                 tabIndex: -1
15680                         });
15681
15682                 this.anchors = this.tabs.map(function() {
15683                                 return $( "a", this )[ 0 ];
15684                         })
15685                         .addClass( "ui-tabs-anchor" )
15686                         .attr({
15687                                 role: "presentation",
15688                                 tabIndex: -1
15689                         });
15690
15691                 this.panels = $();
15692
15693                 this.anchors.each(function( i, anchor ) {
15694                         var selector, panel, panelId,
15695                                 anchorId = $( anchor ).uniqueId().attr( "id" ),
15696                                 tab = $( anchor ).closest( "li" ),
15697                                 originalAriaControls = tab.attr( "aria-controls" );
15698
15699                         // inline tab
15700                         if ( that._isLocal( anchor ) ) {
15701                                 selector = anchor.hash;
15702                                 panelId = selector.substring( 1 );
15703                                 panel = that.element.find( that._sanitizeSelector( selector ) );
15704                         // remote tab
15705                         } else {
15706                                 // If the tab doesn't already have aria-controls,
15707                                 // generate an id by using a throw-away element
15708                                 panelId = tab.attr( "aria-controls" ) || $( {} ).uniqueId()[ 0 ].id;
15709                                 selector = "#" + panelId;
15710                                 panel = that.element.find( selector );
15711                                 if ( !panel.length ) {
15712                                         panel = that._createPanel( panelId );
15713                                         panel.insertAfter( that.panels[ i - 1 ] || that.tablist );
15714                                 }
15715                                 panel.attr( "aria-live", "polite" );
15716                         }
15717
15718                         if ( panel.length) {
15719                                 that.panels = that.panels.add( panel );
15720                         }
15721                         if ( originalAriaControls ) {
15722                                 tab.data( "ui-tabs-aria-controls", originalAriaControls );
15723                         }
15724                         tab.attr({
15725                                 "aria-controls": panelId,
15726                                 "aria-labelledby": anchorId
15727                         });
15728                         panel.attr( "aria-labelledby", anchorId );
15729                 });
15730
15731                 this.panels
15732                         .addClass( "ui-tabs-panel ui-widget-content ui-corner-bottom" )
15733                         .attr( "role", "tabpanel" );
15734
15735                 // Avoid memory leaks (#10056)
15736                 if ( prevTabs ) {
15737                         this._off( prevTabs.not( this.tabs ) );
15738                         this._off( prevAnchors.not( this.anchors ) );
15739                         this._off( prevPanels.not( this.panels ) );
15740                 }
15741         },
15742
15743         // allow overriding how to find the list for rare usage scenarios (#7715)
15744         _getList: function() {
15745                 return this.tablist || this.element.find( "ol,ul" ).eq( 0 );
15746         },
15747
15748         _createPanel: function( id ) {
15749                 return $( "<div>" )
15750                         .attr( "id", id )
15751                         .addClass( "ui-tabs-panel ui-widget-content ui-corner-bottom" )
15752                         .data( "ui-tabs-destroy", true );
15753         },
15754
15755         _setupDisabled: function( disabled ) {
15756                 if ( $.isArray( disabled ) ) {
15757                         if ( !disabled.length ) {
15758                                 disabled = false;
15759                         } else if ( disabled.length === this.anchors.length ) {
15760                                 disabled = true;
15761                         }
15762                 }
15763
15764                 // disable tabs
15765                 for ( var i = 0, li; ( li = this.tabs[ i ] ); i++ ) {
15766                         if ( disabled === true || $.inArray( i, disabled ) !== -1 ) {
15767                                 $( li )
15768                                         .addClass( "ui-state-disabled" )
15769                                         .attr( "aria-disabled", "true" );
15770                         } else {
15771                                 $( li )
15772                                         .removeClass( "ui-state-disabled" )
15773                                         .removeAttr( "aria-disabled" );
15774                         }
15775                 }
15776
15777                 this.options.disabled = disabled;
15778         },
15779
15780         _setupEvents: function( event ) {
15781                 var events = {};
15782                 if ( event ) {
15783                         $.each( event.split(" "), function( index, eventName ) {
15784                                 events[ eventName ] = "_eventHandler";
15785                         });
15786                 }
15787
15788                 this._off( this.anchors.add( this.tabs ).add( this.panels ) );
15789                 // Always prevent the default action, even when disabled
15790                 this._on( true, this.anchors, {
15791                         click: function( event ) {
15792                                 event.preventDefault();
15793                         }
15794                 });
15795                 this._on( this.anchors, events );
15796                 this._on( this.tabs, { keydown: "_tabKeydown" } );
15797                 this._on( this.panels, { keydown: "_panelKeydown" } );
15798
15799                 this._focusable( this.tabs );
15800                 this._hoverable( this.tabs );
15801         },
15802
15803         _setupHeightStyle: function( heightStyle ) {
15804                 var maxHeight,
15805                         parent = this.element.parent();
15806
15807                 if ( heightStyle === "fill" ) {
15808                         maxHeight = parent.height();
15809                         maxHeight -= this.element.outerHeight() - this.element.height();
15810
15811                         this.element.siblings( ":visible" ).each(function() {
15812                                 var elem = $( this ),
15813                                         position = elem.css( "position" );
15814
15815                                 if ( position === "absolute" || position === "fixed" ) {
15816                                         return;
15817                                 }
15818                                 maxHeight -= elem.outerHeight( true );
15819                         });
15820
15821                         this.element.children().not( this.panels ).each(function() {
15822                                 maxHeight -= $( this ).outerHeight( true );
15823                         });
15824
15825                         this.panels.each(function() {
15826                                 $( this ).height( Math.max( 0, maxHeight -
15827                                         $( this ).innerHeight() + $( this ).height() ) );
15828                         })
15829                         .css( "overflow", "auto" );
15830                 } else if ( heightStyle === "auto" ) {
15831                         maxHeight = 0;
15832                         this.panels.each(function() {
15833                                 maxHeight = Math.max( maxHeight, $( this ).height( "" ).height() );
15834                         }).height( maxHeight );
15835                 }
15836         },
15837
15838         _eventHandler: function( event ) {
15839                 var options = this.options,
15840                         active = this.active,
15841                         anchor = $( event.currentTarget ),
15842                         tab = anchor.closest( "li" ),
15843                         clickedIsActive = tab[ 0 ] === active[ 0 ],
15844                         collapsing = clickedIsActive && options.collapsible,
15845                         toShow = collapsing ? $() : this._getPanelForTab( tab ),
15846                         toHide = !active.length ? $() : this._getPanelForTab( active ),
15847                         eventData = {
15848                                 oldTab: active,
15849                                 oldPanel: toHide,
15850                                 newTab: collapsing ? $() : tab,
15851                                 newPanel: toShow
15852                         };
15853
15854                 event.preventDefault();
15855
15856                 if ( tab.hasClass( "ui-state-disabled" ) ||
15857                                 // tab is already loading
15858                                 tab.hasClass( "ui-tabs-loading" ) ||
15859                                 // can't switch durning an animation
15860                                 this.running ||
15861                                 // click on active header, but not collapsible
15862                                 ( clickedIsActive && !options.collapsible ) ||
15863                                 // allow canceling activation
15864                                 ( this._trigger( "beforeActivate", event, eventData ) === false ) ) {
15865                         return;
15866                 }
15867
15868                 options.active = collapsing ? false : this.tabs.index( tab );
15869
15870                 this.active = clickedIsActive ? $() : tab;
15871                 if ( this.xhr ) {
15872                         this.xhr.abort();
15873                 }
15874
15875                 if ( !toHide.length && !toShow.length ) {
15876                         $.error( "jQuery UI Tabs: Mismatching fragment identifier." );
15877                 }
15878
15879                 if ( toShow.length ) {
15880                         this.load( this.tabs.index( tab ), event );
15881                 }
15882                 this._toggle( event, eventData );
15883         },
15884
15885         // handles show/hide for selecting tabs
15886         _toggle: function( event, eventData ) {
15887                 var that = this,
15888                         toShow = eventData.newPanel,
15889                         toHide = eventData.oldPanel;
15890
15891                 this.running = true;
15892
15893                 function complete() {
15894                         that.running = false;
15895                         that._trigger( "activate", event, eventData );
15896                 }
15897
15898                 function show() {
15899                         eventData.newTab.closest( "li" ).addClass( "ui-tabs-active ui-state-active" );
15900
15901                         if ( toShow.length && that.options.show ) {
15902                                 that._show( toShow, that.options.show, complete );
15903                         } else {
15904                                 toShow.show();
15905                                 complete();
15906                         }
15907                 }
15908
15909                 // start out by hiding, then showing, then completing
15910                 if ( toHide.length && this.options.hide ) {
15911                         this._hide( toHide, this.options.hide, function() {
15912                                 eventData.oldTab.closest( "li" ).removeClass( "ui-tabs-active ui-state-active" );
15913                                 show();
15914                         });
15915                 } else {
15916                         eventData.oldTab.closest( "li" ).removeClass( "ui-tabs-active ui-state-active" );
15917                         toHide.hide();
15918                         show();
15919                 }
15920
15921                 toHide.attr( "aria-hidden", "true" );
15922                 eventData.oldTab.attr({
15923                         "aria-selected": "false",
15924                         "aria-expanded": "false"
15925                 });
15926                 // If we're switching tabs, remove the old tab from the tab order.
15927                 // If we're opening from collapsed state, remove the previous tab from the tab order.
15928                 // If we're collapsing, then keep the collapsing tab in the tab order.
15929                 if ( toShow.length && toHide.length ) {
15930                         eventData.oldTab.attr( "tabIndex", -1 );
15931                 } else if ( toShow.length ) {
15932                         this.tabs.filter(function() {
15933                                 return $( this ).attr( "tabIndex" ) === 0;
15934                         })
15935                         .attr( "tabIndex", -1 );
15936                 }
15937
15938                 toShow.attr( "aria-hidden", "false" );
15939                 eventData.newTab.attr({
15940                         "aria-selected": "true",
15941                         "aria-expanded": "true",
15942                         tabIndex: 0
15943                 });
15944         },
15945
15946         _activate: function( index ) {
15947                 var anchor,
15948                         active = this._findActive( index );
15949
15950                 // trying to activate the already active panel
15951                 if ( active[ 0 ] === this.active[ 0 ] ) {
15952                         return;
15953                 }
15954
15955                 // trying to collapse, simulate a click on the current active header
15956                 if ( !active.length ) {
15957                         active = this.active;
15958                 }
15959
15960                 anchor = active.find( ".ui-tabs-anchor" )[ 0 ];
15961                 this._eventHandler({
15962                         target: anchor,
15963                         currentTarget: anchor,
15964                         preventDefault: $.noop
15965                 });
15966         },
15967
15968         _findActive: function( index ) {
15969                 return index === false ? $() : this.tabs.eq( index );
15970         },
15971
15972         _getIndex: function( index ) {
15973                 // meta-function to give users option to provide a href string instead of a numerical index.
15974                 if ( typeof index === "string" ) {
15975                         index = this.anchors.index( this.anchors.filter( "[href$='" + index + "']" ) );
15976                 }
15977
15978                 return index;
15979         },
15980
15981         _destroy: function() {
15982                 if ( this.xhr ) {
15983                         this.xhr.abort();
15984                 }
15985
15986                 this.element.removeClass( "ui-tabs ui-widget ui-widget-content ui-corner-all ui-tabs-collapsible" );
15987
15988                 this.tablist
15989                         .removeClass( "ui-tabs-nav ui-helper-reset ui-helper-clearfix ui-widget-header ui-corner-all" )
15990                         .removeAttr( "role" );
15991
15992                 this.anchors
15993                         .removeClass( "ui-tabs-anchor" )
15994                         .removeAttr( "role" )
15995                         .removeAttr( "tabIndex" )
15996                         .removeUniqueId();
15997
15998                 this.tablist.unbind( this.eventNamespace );
15999
16000                 this.tabs.add( this.panels ).each(function() {
16001                         if ( $.data( this, "ui-tabs-destroy" ) ) {
16002                                 $( this ).remove();
16003                         } else {
16004                                 $( this )
16005                                         .removeClass( "ui-state-default ui-state-active ui-state-disabled " +
16006                                                 "ui-corner-top ui-corner-bottom ui-widget-content ui-tabs-active ui-tabs-panel" )
16007                                         .removeAttr( "tabIndex" )
16008                                         .removeAttr( "aria-live" )
16009                                         .removeAttr( "aria-busy" )
16010                                         .removeAttr( "aria-selected" )
16011                                         .removeAttr( "aria-labelledby" )
16012                                         .removeAttr( "aria-hidden" )
16013                                         .removeAttr( "aria-expanded" )
16014                                         .removeAttr( "role" );
16015                         }
16016                 });
16017
16018                 this.tabs.each(function() {
16019                         var li = $( this ),
16020                                 prev = li.data( "ui-tabs-aria-controls" );
16021                         if ( prev ) {
16022                                 li
16023                                         .attr( "aria-controls", prev )
16024                                         .removeData( "ui-tabs-aria-controls" );
16025                         } else {
16026                                 li.removeAttr( "aria-controls" );
16027                         }
16028                 });
16029
16030                 this.panels.show();
16031
16032                 if ( this.options.heightStyle !== "content" ) {
16033                         this.panels.css( "height", "" );
16034                 }
16035         },
16036
16037         enable: function( index ) {
16038                 var disabled = this.options.disabled;
16039                 if ( disabled === false ) {
16040                         return;
16041                 }
16042
16043                 if ( index === undefined ) {
16044                         disabled = false;
16045                 } else {
16046                         index = this._getIndex( index );
16047                         if ( $.isArray( disabled ) ) {
16048                                 disabled = $.map( disabled, function( num ) {
16049                                         return num !== index ? num : null;
16050                                 });
16051                         } else {
16052                                 disabled = $.map( this.tabs, function( li, num ) {
16053                                         return num !== index ? num : null;
16054                                 });
16055                         }
16056                 }
16057                 this._setupDisabled( disabled );
16058         },
16059
16060         disable: function( index ) {
16061                 var disabled = this.options.disabled;
16062                 if ( disabled === true ) {
16063                         return;
16064                 }
16065
16066                 if ( index === undefined ) {
16067                         disabled = true;
16068                 } else {
16069                         index = this._getIndex( index );
16070                         if ( $.inArray( index, disabled ) !== -1 ) {
16071                                 return;
16072                         }
16073                         if ( $.isArray( disabled ) ) {
16074                                 disabled = $.merge( [ index ], disabled ).sort();
16075                         } else {
16076                                 disabled = [ index ];
16077                         }
16078                 }
16079                 this._setupDisabled( disabled );
16080         },
16081
16082         load: function( index, event ) {
16083                 index = this._getIndex( index );
16084                 var that = this,
16085                         tab = this.tabs.eq( index ),
16086                         anchor = tab.find( ".ui-tabs-anchor" ),
16087                         panel = this._getPanelForTab( tab ),
16088                         eventData = {
16089                                 tab: tab,
16090                                 panel: panel
16091                         },
16092                         complete = function( jqXHR, status ) {
16093                                 if ( status === "abort" ) {
16094                                         that.panels.stop( false, true );
16095                                 }
16096
16097                                 tab.removeClass( "ui-tabs-loading" );
16098                                 panel.removeAttr( "aria-busy" );
16099
16100                                 if ( jqXHR === that.xhr ) {
16101                                         delete that.xhr;
16102                                 }
16103                         };
16104
16105                 // not remote
16106                 if ( this._isLocal( anchor[ 0 ] ) ) {
16107                         return;
16108                 }
16109
16110                 this.xhr = $.ajax( this._ajaxSettings( anchor, event, eventData ) );
16111
16112                 // support: jQuery <1.8
16113                 // jQuery <1.8 returns false if the request is canceled in beforeSend,
16114                 // but as of 1.8, $.ajax() always returns a jqXHR object.
16115                 if ( this.xhr && this.xhr.statusText !== "canceled" ) {
16116                         tab.addClass( "ui-tabs-loading" );
16117                         panel.attr( "aria-busy", "true" );
16118
16119                         this.xhr
16120                                 .done(function( response, status, jqXHR ) {
16121                                         // support: jQuery <1.8
16122                                         // http://bugs.jquery.com/ticket/11778
16123                                         setTimeout(function() {
16124                                                 panel.html( response );
16125                                                 that._trigger( "load", event, eventData );
16126
16127                                                 complete( jqXHR, status );
16128                                         }, 1 );
16129                                 })
16130                                 .fail(function( jqXHR, status ) {
16131                                         // support: jQuery <1.8
16132                                         // http://bugs.jquery.com/ticket/11778
16133                                         setTimeout(function() {
16134                                                 complete( jqXHR, status );
16135                                         }, 1 );
16136                                 });
16137                 }
16138         },
16139
16140         _ajaxSettings: function( anchor, event, eventData ) {
16141                 var that = this;
16142                 return {
16143                         url: anchor.attr( "href" ),
16144                         beforeSend: function( jqXHR, settings ) {
16145                                 return that._trigger( "beforeLoad", event,
16146                                         $.extend( { jqXHR: jqXHR, ajaxSettings: settings }, eventData ) );
16147                         }
16148                 };
16149         },
16150
16151         _getPanelForTab: function( tab ) {
16152                 var id = $( tab ).attr( "aria-controls" );
16153                 return this.element.find( this._sanitizeSelector( "#" + id ) );
16154         }
16155 });
16156
16157
16158 /*!
16159  * jQuery UI Tooltip 1.11.4
16160  * http://jqueryui.com
16161  *
16162  * Copyright jQuery Foundation and other contributors
16163  * Released under the MIT license.
16164  * http://jquery.org/license
16165  *
16166  * http://api.jqueryui.com/tooltip/
16167  */
16168
16169
16170 var tooltip = $.widget( "ui.tooltip", {
16171         version: "1.11.4",
16172         options: {
16173                 content: function() {
16174                         // support: IE<9, Opera in jQuery <1.7
16175                         // .text() can't accept undefined, so coerce to a string
16176                         var title = $( this ).attr( "title" ) || "";
16177                         // Escape title, since we're going from an attribute to raw HTML
16178                         return $( "<a>" ).text( title ).html();
16179                 },
16180                 hide: true,
16181                 // Disabled elements have inconsistent behavior across browsers (#8661)
16182                 items: "[title]:not([disabled])",
16183                 position: {
16184                         my: "left top+15",
16185                         at: "left bottom",
16186                         collision: "flipfit flip"
16187                 },
16188                 show: true,
16189                 tooltipClass: null,
16190                 track: false,
16191
16192                 // callbacks
16193                 close: null,
16194                 open: null
16195         },
16196
16197         _addDescribedBy: function( elem, id ) {
16198                 var describedby = (elem.attr( "aria-describedby" ) || "").split( /\s+/ );
16199                 describedby.push( id );
16200                 elem
16201                         .data( "ui-tooltip-id", id )
16202                         .attr( "aria-describedby", $.trim( describedby.join( " " ) ) );
16203         },
16204
16205         _removeDescribedBy: function( elem ) {
16206                 var id = elem.data( "ui-tooltip-id" ),
16207                         describedby = (elem.attr( "aria-describedby" ) || "").split( /\s+/ ),
16208                         index = $.inArray( id, describedby );
16209
16210                 if ( index !== -1 ) {
16211                         describedby.splice( index, 1 );
16212                 }
16213
16214                 elem.removeData( "ui-tooltip-id" );
16215                 describedby = $.trim( describedby.join( " " ) );
16216                 if ( describedby ) {
16217                         elem.attr( "aria-describedby", describedby );
16218                 } else {
16219                         elem.removeAttr( "aria-describedby" );
16220                 }
16221         },
16222
16223         _create: function() {
16224                 this._on({
16225                         mouseover: "open",
16226                         focusin: "open"
16227                 });
16228
16229                 // IDs of generated tooltips, needed for destroy
16230                 this.tooltips = {};
16231
16232                 // IDs of parent tooltips where we removed the title attribute
16233                 this.parents = {};
16234
16235                 if ( this.options.disabled ) {
16236                         this._disable();
16237                 }
16238
16239                 // Append the aria-live region so tooltips announce correctly
16240                 this.liveRegion = $( "<div>" )
16241                         .attr({
16242                                 role: "log",
16243                                 "aria-live": "assertive",
16244                                 "aria-relevant": "additions"
16245                         })
16246                         .addClass( "ui-helper-hidden-accessible" )
16247                         .appendTo( this.document[ 0 ].body );
16248         },
16249
16250         _setOption: function( key, value ) {
16251                 var that = this;
16252
16253                 if ( key === "disabled" ) {
16254                         this[ value ? "_disable" : "_enable" ]();
16255                         this.options[ key ] = value;
16256                         // disable element style changes
16257                         return;
16258                 }
16259
16260                 this._super( key, value );
16261
16262                 if ( key === "content" ) {
16263                         $.each( this.tooltips, function( id, tooltipData ) {
16264                                 that._updateContent( tooltipData.element );
16265                         });
16266                 }
16267         },
16268
16269         _disable: function() {
16270                 var that = this;
16271
16272                 // close open tooltips
16273                 $.each( this.tooltips, function( id, tooltipData ) {
16274                         var event = $.Event( "blur" );
16275                         event.target = event.currentTarget = tooltipData.element[ 0 ];
16276                         that.close( event, true );
16277                 });
16278
16279                 // remove title attributes to prevent native tooltips
16280                 this.element.find( this.options.items ).addBack().each(function() {
16281                         var element = $( this );
16282                         if ( element.is( "[title]" ) ) {
16283                                 element
16284                                         .data( "ui-tooltip-title", element.attr( "title" ) )
16285                                         .removeAttr( "title" );
16286                         }
16287                 });
16288         },
16289
16290         _enable: function() {
16291                 // restore title attributes
16292                 this.element.find( this.options.items ).addBack().each(function() {
16293                         var element = $( this );
16294                         if ( element.data( "ui-tooltip-title" ) ) {
16295                                 element.attr( "title", element.data( "ui-tooltip-title" ) );
16296                         }
16297                 });
16298         },
16299
16300         open: function( event ) {
16301                 var that = this,
16302                         target = $( event ? event.target : this.element )
16303                                 // we need closest here due to mouseover bubbling,
16304                                 // but always pointing at the same event target
16305                                 .closest( this.options.items );
16306
16307                 // No element to show a tooltip for or the tooltip is already open
16308                 if ( !target.length || target.data( "ui-tooltip-id" ) ) {
16309                         return;
16310                 }
16311
16312                 if ( target.attr( "title" ) ) {
16313                         target.data( "ui-tooltip-title", target.attr( "title" ) );
16314                 }
16315
16316                 target.data( "ui-tooltip-open", true );
16317
16318                 // kill parent tooltips, custom or native, for hover
16319                 if ( event && event.type === "mouseover" ) {
16320                         target.parents().each(function() {
16321                                 var parent = $( this ),
16322                                         blurEvent;
16323                                 if ( parent.data( "ui-tooltip-open" ) ) {
16324                                         blurEvent = $.Event( "blur" );
16325                                         blurEvent.target = blurEvent.currentTarget = this;
16326                                         that.close( blurEvent, true );
16327                                 }
16328                                 if ( parent.attr( "title" ) ) {
16329                                         parent.uniqueId();
16330                                         that.parents[ this.id ] = {
16331                                                 element: this,
16332                                                 title: parent.attr( "title" )
16333                                         };
16334                                         parent.attr( "title", "" );
16335                                 }
16336                         });
16337                 }
16338
16339                 this._registerCloseHandlers( event, target );
16340                 this._updateContent( target, event );
16341         },
16342
16343         _updateContent: function( target, event ) {
16344                 var content,
16345                         contentOption = this.options.content,
16346                         that = this,
16347                         eventType = event ? event.type : null;
16348
16349                 if ( typeof contentOption === "string" ) {
16350                         return this._open( event, target, contentOption );
16351                 }
16352
16353                 content = contentOption.call( target[0], function( response ) {
16354
16355                         // IE may instantly serve a cached response for ajax requests
16356                         // delay this call to _open so the other call to _open runs first
16357                         that._delay(function() {
16358
16359                                 // Ignore async response if tooltip was closed already
16360                                 if ( !target.data( "ui-tooltip-open" ) ) {
16361                                         return;
16362                                 }
16363
16364                                 // jQuery creates a special event for focusin when it doesn't
16365                                 // exist natively. To improve performance, the native event
16366                                 // object is reused and the type is changed. Therefore, we can't
16367                                 // rely on the type being correct after the event finished
16368                                 // bubbling, so we set it back to the previous value. (#8740)
16369                                 if ( event ) {
16370                                         event.type = eventType;
16371                                 }
16372                                 this._open( event, target, response );
16373                         });
16374                 });
16375                 if ( content ) {
16376                         this._open( event, target, content );
16377                 }
16378         },
16379
16380         _open: function( event, target, content ) {
16381                 var tooltipData, tooltip, delayedShow, a11yContent,
16382                         positionOption = $.extend( {}, this.options.position );
16383
16384                 if ( !content ) {
16385                         return;
16386                 }
16387
16388                 // Content can be updated multiple times. If the tooltip already
16389                 // exists, then just update the content and bail.
16390                 tooltipData = this._find( target );
16391                 if ( tooltipData ) {
16392                         tooltipData.tooltip.find( ".ui-tooltip-content" ).html( content );
16393                         return;
16394                 }
16395
16396                 // if we have a title, clear it to prevent the native tooltip
16397                 // we have to check first to avoid defining a title if none exists
16398                 // (we don't want to cause an element to start matching [title])
16399                 //
16400                 // We use removeAttr only for key events, to allow IE to export the correct
16401                 // accessible attributes. For mouse events, set to empty string to avoid
16402                 // native tooltip showing up (happens only when removing inside mouseover).
16403                 if ( target.is( "[title]" ) ) {
16404                         if ( event && event.type === "mouseover" ) {
16405                                 target.attr( "title", "" );
16406                         } else {
16407                                 target.removeAttr( "title" );
16408                         }
16409                 }
16410
16411                 tooltipData = this._tooltip( target );
16412                 tooltip = tooltipData.tooltip;
16413                 this._addDescribedBy( target, tooltip.attr( "id" ) );
16414                 tooltip.find( ".ui-tooltip-content" ).html( content );
16415
16416                 // Support: Voiceover on OS X, JAWS on IE <= 9
16417                 // JAWS announces deletions even when aria-relevant="additions"
16418                 // Voiceover will sometimes re-read the entire log region's contents from the beginning
16419                 this.liveRegion.children().hide();
16420                 if ( content.clone ) {
16421                         a11yContent = content.clone();
16422                         a11yContent.removeAttr( "id" ).find( "[id]" ).removeAttr( "id" );
16423                 } else {
16424                         a11yContent = content;
16425                 }
16426                 $( "<div>" ).html( a11yContent ).appendTo( this.liveRegion );
16427
16428                 function position( event ) {
16429                         positionOption.of = event;
16430                         if ( tooltip.is( ":hidden" ) ) {
16431                                 return;
16432                         }
16433                         tooltip.position( positionOption );
16434                 }
16435                 if ( this.options.track && event && /^mouse/.test( event.type ) ) {
16436                         this._on( this.document, {
16437                                 mousemove: position
16438                         });
16439                         // trigger once to override element-relative positioning
16440                         position( event );
16441                 } else {
16442                         tooltip.position( $.extend({
16443                                 of: target
16444                         }, this.options.position ) );
16445                 }
16446
16447                 tooltip.hide();
16448
16449                 this._show( tooltip, this.options.show );
16450                 // Handle tracking tooltips that are shown with a delay (#8644). As soon
16451                 // as the tooltip is visible, position the tooltip using the most recent
16452                 // event.
16453                 if ( this.options.show && this.options.show.delay ) {
16454                         delayedShow = this.delayedShow = setInterval(function() {
16455                                 if ( tooltip.is( ":visible" ) ) {
16456                                         position( positionOption.of );
16457                                         clearInterval( delayedShow );
16458                                 }
16459                         }, $.fx.interval );
16460                 }
16461
16462                 this._trigger( "open", event, { tooltip: tooltip } );
16463         },
16464
16465         _registerCloseHandlers: function( event, target ) {
16466                 var events = {
16467                         keyup: function( event ) {
16468                                 if ( event.keyCode === $.ui.keyCode.ESCAPE ) {
16469                                         var fakeEvent = $.Event(event);
16470                                         fakeEvent.currentTarget = target[0];
16471                                         this.close( fakeEvent, true );
16472                                 }
16473                         }
16474                 };
16475
16476                 // Only bind remove handler for delegated targets. Non-delegated
16477                 // tooltips will handle this in destroy.
16478                 if ( target[ 0 ] !== this.element[ 0 ] ) {
16479                         events.remove = function() {
16480                                 this._removeTooltip( this._find( target ).tooltip );
16481                         };
16482                 }
16483
16484                 if ( !event || event.type === "mouseover" ) {
16485                         events.mouseleave = "close";
16486                 }
16487                 if ( !event || event.type === "focusin" ) {
16488                         events.focusout = "close";
16489                 }
16490                 this._on( true, target, events );
16491         },
16492
16493         close: function( event ) {
16494                 var tooltip,
16495                         that = this,
16496                         target = $( event ? event.currentTarget : this.element ),
16497                         tooltipData = this._find( target );
16498
16499                 // The tooltip may already be closed
16500                 if ( !tooltipData ) {
16501
16502                         // We set ui-tooltip-open immediately upon open (in open()), but only set the
16503                         // additional data once there's actually content to show (in _open()). So even if the
16504                         // tooltip doesn't have full data, we always remove ui-tooltip-open in case we're in
16505                         // the period between open() and _open().
16506                         target.removeData( "ui-tooltip-open" );
16507                         return;
16508                 }
16509
16510                 tooltip = tooltipData.tooltip;
16511
16512                 // disabling closes the tooltip, so we need to track when we're closing
16513                 // to avoid an infinite loop in case the tooltip becomes disabled on close
16514                 if ( tooltipData.closing ) {
16515                         return;
16516                 }
16517
16518                 // Clear the interval for delayed tracking tooltips
16519                 clearInterval( this.delayedShow );
16520
16521                 // only set title if we had one before (see comment in _open())
16522                 // If the title attribute has changed since open(), don't restore
16523                 if ( target.data( "ui-tooltip-title" ) && !target.attr( "title" ) ) {
16524                         target.attr( "title", target.data( "ui-tooltip-title" ) );
16525                 }
16526
16527                 this._removeDescribedBy( target );
16528
16529                 tooltipData.hiding = true;
16530                 tooltip.stop( true );
16531                 this._hide( tooltip, this.options.hide, function() {
16532                         that._removeTooltip( $( this ) );
16533                 });
16534
16535                 target.removeData( "ui-tooltip-open" );
16536                 this._off( target, "mouseleave focusout keyup" );
16537
16538                 // Remove 'remove' binding only on delegated targets
16539                 if ( target[ 0 ] !== this.element[ 0 ] ) {
16540                         this._off( target, "remove" );
16541                 }
16542                 this._off( this.document, "mousemove" );
16543
16544                 if ( event && event.type === "mouseleave" ) {
16545                         $.each( this.parents, function( id, parent ) {
16546                                 $( parent.element ).attr( "title", parent.title );
16547                                 delete that.parents[ id ];
16548                         });
16549                 }
16550
16551                 tooltipData.closing = true;
16552                 this._trigger( "close", event, { tooltip: tooltip } );
16553                 if ( !tooltipData.hiding ) {
16554                         tooltipData.closing = false;
16555                 }
16556         },
16557
16558         _tooltip: function( element ) {
16559                 var tooltip = $( "<div>" )
16560                                 .attr( "role", "tooltip" )
16561                                 .addClass( "ui-tooltip ui-widget ui-corner-all ui-widget-content " +
16562                                         ( this.options.tooltipClass || "" ) ),
16563                         id = tooltip.uniqueId().attr( "id" );
16564
16565                 $( "<div>" )
16566                         .addClass( "ui-tooltip-content" )
16567                         .appendTo( tooltip );
16568
16569                 tooltip.appendTo( this.document[0].body );
16570
16571                 return this.tooltips[ id ] = {
16572                         element: element,
16573                         tooltip: tooltip
16574                 };
16575         },
16576
16577         _find: function( target ) {
16578                 var id = target.data( "ui-tooltip-id" );
16579                 return id ? this.tooltips[ id ] : null;
16580         },
16581
16582         _removeTooltip: function( tooltip ) {
16583                 tooltip.remove();
16584                 delete this.tooltips[ tooltip.attr( "id" ) ];
16585         },
16586
16587         _destroy: function() {
16588                 var that = this;
16589
16590                 // close open tooltips
16591                 $.each( this.tooltips, function( id, tooltipData ) {
16592                         // Delegate to close method to handle common cleanup
16593                         var event = $.Event( "blur" ),
16594                                 element = tooltipData.element;
16595                         event.target = event.currentTarget = element[ 0 ];
16596                         that.close( event, true );
16597
16598                         // Remove immediately; destroying an open tooltip doesn't use the
16599                         // hide animation
16600                         $( "#" + id ).remove();
16601
16602                         // Restore the title
16603                         if ( element.data( "ui-tooltip-title" ) ) {
16604                                 // If the title attribute has changed since open(), don't restore
16605                                 if ( !element.attr( "title" ) ) {
16606                                         element.attr( "title", element.data( "ui-tooltip-title" ) );
16607                                 }
16608                                 element.removeData( "ui-tooltip-title" );
16609                         }
16610                 });
16611                 this.liveRegion.remove();
16612         }
16613 });
16614
16615
16616
16617 }));