koha-tmpl/intranet-tmpl/lib/jquery/jquery-ui-1.11.4.js

   1 /*! jQuery UI - v1.11.4 - 2016-02-22
   2 * http://jqueryui.com
   3 * Includes: core.js, widget.js, mouse.js, position.js, draggable.js, droppable.js, sortable.js, accordion.js, autocomplete.js, button.js, datepicker.js, menu.js, progressbar.js, slider.js, tabs.js, effect.js, effect-highlight.js
   4 * Copyright 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 Draggable 1.11.4
1554  * http://jqueryui.com
1555  *
1556  * Copyright jQuery Foundation and other contributors
1557  * Released under the MIT license.
1558  * http://jquery.org/license
1559  *
1560  * http://api.jqueryui.com/draggable/
1561  */
1562
1563
1564 $.widget("ui.draggable", $.ui.mouse, {
1565         version: "1.11.4",
1566         widgetEventPrefix: "drag",
1567         options: {
1568                 addClasses: true,
1569                 appendTo: "parent",
1570                 axis: false,
1571                 connectToSortable: false,
1572                 containment: false,
1573                 cursor: "auto",
1574                 cursorAt: false,
1575                 grid: false,
1576                 handle: false,
1577                 helper: "original",
1578                 iframeFix: false,
1579                 opacity: false,
1580                 refreshPositions: false,
1581                 revert: false,
1582                 revertDuration: 500,
1583                 scope: "default",
1584                 scroll: true,
1585                 scrollSensitivity: 20,
1586                 scrollSpeed: 20,
1587                 snap: false,
1588                 snapMode: "both",
1589                 snapTolerance: 20,
1590                 stack: false,
1591                 zIndex: false,
1592
1593                 // callbacks
1594                 drag: null,
1595                 start: null,
1596                 stop: null
1597         },
1598         _create: function() {
1599
1600                 if ( this.options.helper === "original" ) {
1601                         this._setPositionRelative();
1602                 }
1603                 if (this.options.addClasses){
1604                         this.element.addClass("ui-draggable");
1605                 }
1606                 if (this.options.disabled){
1607                         this.element.addClass("ui-draggable-disabled");
1608                 }
1609                 this._setHandleClassName();
1610
1611                 this._mouseInit();
1612         },
1613
1614         _setOption: function( key, value ) {
1615                 this._super( key, value );
1616                 if ( key === "handle" ) {
1617                         this._removeHandleClassName();
1618                         this._setHandleClassName();
1619                 }
1620         },
1621
1622         _destroy: function() {
1623                 if ( ( this.helper || this.element ).is( ".ui-draggable-dragging" ) ) {
1624                         this.destroyOnClear = true;
1625                         return;
1626                 }
1627                 this.element.removeClass( "ui-draggable ui-draggable-dragging ui-draggable-disabled" );
1628                 this._removeHandleClassName();
1629                 this._mouseDestroy();
1630         },
1631
1632         _mouseCapture: function(event) {
1633                 var o = this.options;
1634
1635                 this._blurActiveElement( event );
1636
1637                 // among others, prevent a drag on a resizable-handle
1638                 if (this.helper || o.disabled || $(event.target).closest(".ui-resizable-handle").length > 0) {
1639                         return false;
1640                 }
1641
1642                 //Quit if we're not on a valid handle
1643                 this.handle = this._getHandle(event);
1644                 if (!this.handle) {
1645                         return false;
1646                 }
1647
1648                 this._blockFrames( o.iframeFix === true ? "iframe" : o.iframeFix );
1649
1650                 return true;
1651
1652         },
1653
1654         _blockFrames: function( selector ) {
1655                 this.iframeBlocks = this.document.find( selector ).map(function() {
1656                         var iframe = $( this );
1657
1658                         return $( "<div>" )
1659                                 .css( "position", "absolute" )
1660                                 .appendTo( iframe.parent() )
1661                                 .outerWidth( iframe.outerWidth() )
1662                                 .outerHeight( iframe.outerHeight() )
1663                                 .offset( iframe.offset() )[ 0 ];
1664                 });
1665         },
1666
1667         _unblockFrames: function() {
1668                 if ( this.iframeBlocks ) {
1669                         this.iframeBlocks.remove();
1670                         delete this.iframeBlocks;
1671                 }
1672         },
1673
1674         _blurActiveElement: function( event ) {
1675                 var document = this.document[ 0 ];
1676
1677                 // Only need to blur if the event occurred on the draggable itself, see #10527
1678                 if ( !this.handleElement.is( event.target ) ) {
1679                         return;
1680                 }
1681
1682                 // support: IE9
1683                 // IE9 throws an "Unspecified error" accessing document.activeElement from an <iframe>
1684                 try {
1685
1686                         // Support: IE9, IE10
1687                         // If the <body> is blurred, IE will switch windows, see #9520
1688                         if ( document.activeElement && document.activeElement.nodeName.toLowerCase() !== "body" ) {
1689
1690                                 // Blur any element that currently has focus, see #4261
1691                                 $( document.activeElement ).blur();
1692                         }
1693                 } catch ( error ) {}
1694         },
1695
1696         _mouseStart: function(event) {
1697
1698                 var o = this.options;
1699
1700                 //Create and append the visible helper
1701                 this.helper = this._createHelper(event);
1702
1703                 this.helper.addClass("ui-draggable-dragging");
1704
1705                 //Cache the helper size
1706                 this._cacheHelperProportions();
1707
1708                 //If ddmanager is used for droppables, set the global draggable
1709                 if ($.ui.ddmanager) {
1710                         $.ui.ddmanager.current = this;
1711                 }
1712
1713                 /*
1714                  * - Position generation -
1715                  * This block generates everything position related - it's the core of draggables.
1716                  */
1717
1718                 //Cache the margins of the original element
1719                 this._cacheMargins();
1720
1721                 //Store the helper's css position
1722                 this.cssPosition = this.helper.css( "position" );
1723                 this.scrollParent = this.helper.scrollParent( true );
1724                 this.offsetParent = this.helper.offsetParent();
1725                 this.hasFixedAncestor = this.helper.parents().filter(function() {
1726                                 return $( this ).css( "position" ) === "fixed";
1727                         }).length > 0;
1728
1729                 //The element's absolute position on the page minus margins
1730                 this.positionAbs = this.element.offset();
1731                 this._refreshOffsets( event );
1732
1733                 //Generate the original position
1734                 this.originalPosition = this.position = this._generatePosition( event, false );
1735                 this.originalPageX = event.pageX;
1736                 this.originalPageY = event.pageY;
1737
1738                 //Adjust the mouse offset relative to the helper if "cursorAt" is supplied
1739                 (o.cursorAt && this._adjustOffsetFromHelper(o.cursorAt));
1740
1741                 //Set a containment if given in the options
1742                 this._setContainment();
1743
1744                 //Trigger event + callbacks
1745                 if (this._trigger("start", event) === false) {
1746                         this._clear();
1747                         return false;
1748                 }
1749
1750                 //Recache the helper size
1751                 this._cacheHelperProportions();
1752
1753                 //Prepare the droppable offsets
1754                 if ($.ui.ddmanager && !o.dropBehaviour) {
1755                         $.ui.ddmanager.prepareOffsets(this, event);
1756                 }
1757
1758                 // Reset helper's right/bottom css if they're set and set explicit width/height instead
1759                 // as this prevents resizing of elements with right/bottom set (see #7772)
1760                 this._normalizeRightBottom();
1761
1762                 this._mouseDrag(event, true); //Execute the drag once - this causes the helper not to be visible before getting its correct position
1763
1764                 //If the ddmanager is used for droppables, inform the manager that dragging has started (see #5003)
1765                 if ( $.ui.ddmanager ) {
1766                         $.ui.ddmanager.dragStart(this, event);
1767                 }
1768
1769                 return true;
1770         },
1771
1772         _refreshOffsets: function( event ) {
1773                 this.offset = {
1774                         top: this.positionAbs.top - this.margins.top,
1775                         left: this.positionAbs.left - this.margins.left,
1776                         scroll: false,
1777                         parent: this._getParentOffset(),
1778                         relative: this._getRelativeOffset()
1779                 };
1780
1781                 this.offset.click = {
1782                         left: event.pageX - this.offset.left,
1783                         top: event.pageY - this.offset.top
1784                 };
1785         },
1786
1787         _mouseDrag: function(event, noPropagation) {
1788                 // reset any necessary cached properties (see #5009)
1789                 if ( this.hasFixedAncestor ) {
1790                         this.offset.parent = this._getParentOffset();
1791                 }
1792
1793                 //Compute the helpers position
1794                 this.position = this._generatePosition( event, true );
1795                 this.positionAbs = this._convertPositionTo("absolute");
1796
1797                 //Call plugins and callbacks and use the resulting position if something is returned
1798                 if (!noPropagation) {
1799                         var ui = this._uiHash();
1800                         if (this._trigger("drag", event, ui) === false) {
1801                                 this._mouseUp({});
1802                                 return false;
1803                         }
1804                         this.position = ui.position;
1805                 }
1806
1807                 this.helper[ 0 ].style.left = this.position.left + "px";
1808                 this.helper[ 0 ].style.top = this.position.top + "px";
1809
1810                 if ($.ui.ddmanager) {
1811                         $.ui.ddmanager.drag(this, event);
1812                 }
1813
1814                 return false;
1815         },
1816
1817         _mouseStop: function(event) {
1818
1819                 //If we are using droppables, inform the manager about the drop
1820                 var that = this,
1821                         dropped = false;
1822                 if ($.ui.ddmanager && !this.options.dropBehaviour) {
1823                         dropped = $.ui.ddmanager.drop(this, event);
1824                 }
1825
1826                 //if a drop comes from outside (a sortable)
1827                 if (this.dropped) {
1828                         dropped = this.dropped;
1829                         this.dropped = false;
1830                 }
1831
1832                 if ((this.options.revert === "invalid" && !dropped) || (this.options.revert === "valid" && dropped) || this.options.revert === true || ($.isFunction(this.options.revert) && this.options.revert.call(this.element, dropped))) {
1833                         $(this.helper).animate(this.originalPosition, parseInt(this.options.revertDuration, 10), function() {
1834                                 if (that._trigger("stop", event) !== false) {
1835                                         that._clear();
1836                                 }
1837                         });
1838                 } else {
1839                         if (this._trigger("stop", event) !== false) {
1840                                 this._clear();
1841                         }
1842                 }
1843
1844                 return false;
1845         },
1846
1847         _mouseUp: function( event ) {
1848                 this._unblockFrames();
1849
1850                 //If the ddmanager is used for droppables, inform the manager that dragging has stopped (see #5003)
1851                 if ( $.ui.ddmanager ) {
1852                         $.ui.ddmanager.dragStop(this, event);
1853                 }
1854
1855                 // Only need to focus if the event occurred on the draggable itself, see #10527
1856                 if ( this.handleElement.is( event.target ) ) {
1857                         // The interaction is over; whether or not the click resulted in a drag, focus the element
1858                         this.element.focus();
1859                 }
1860
1861                 return $.ui.mouse.prototype._mouseUp.call(this, event);
1862         },
1863
1864         cancel: function() {
1865
1866                 if (this.helper.is(".ui-draggable-dragging")) {
1867                         this._mouseUp({});
1868                 } else {
1869                         this._clear();
1870                 }
1871
1872                 return this;
1873
1874         },
1875
1876         _getHandle: function(event) {
1877                 return this.options.handle ?
1878                         !!$( event.target ).closest( this.element.find( this.options.handle ) ).length :
1879                         true;
1880         },
1881
1882         _setHandleClassName: function() {
1883                 this.handleElement = this.options.handle ?
1884                         this.element.find( this.options.handle ) : this.element;
1885                 this.handleElement.addClass( "ui-draggable-handle" );
1886         },
1887
1888         _removeHandleClassName: function() {
1889                 this.handleElement.removeClass( "ui-draggable-handle" );
1890         },
1891
1892         _createHelper: function(event) {
1893
1894                 var o = this.options,
1895                         helperIsFunction = $.isFunction( o.helper ),
1896                         helper = helperIsFunction ?
1897                                 $( o.helper.apply( this.element[ 0 ], [ event ] ) ) :
1898                                 ( o.helper === "clone" ?
1899                                         this.element.clone().removeAttr( "id" ) :
1900                                         this.element );
1901
1902                 if (!helper.parents("body").length) {
1903                         helper.appendTo((o.appendTo === "parent" ? this.element[0].parentNode : o.appendTo));
1904                 }
1905
1906                 // http://bugs.jqueryui.com/ticket/9446
1907                 // a helper function can return the original element
1908                 // which wouldn't have been set to relative in _create
1909                 if ( helperIsFunction && helper[ 0 ] === this.element[ 0 ] ) {
1910                         this._setPositionRelative();
1911                 }
1912
1913                 if (helper[0] !== this.element[0] && !(/(fixed|absolute)/).test(helper.css("position"))) {
1914                         helper.css("position", "absolute");
1915                 }
1916
1917                 return helper;
1918
1919         },
1920
1921         _setPositionRelative: function() {
1922                 if ( !( /^(?:r|a|f)/ ).test( this.element.css( "position" ) ) ) {
1923                         this.element[ 0 ].style.position = "relative";
1924                 }
1925         },
1926
1927         _adjustOffsetFromHelper: function(obj) {
1928                 if (typeof obj === "string") {
1929                         obj = obj.split(" ");
1930                 }
1931                 if ($.isArray(obj)) {
1932                         obj = { left: +obj[0], top: +obj[1] || 0 };
1933                 }
1934                 if ("left" in obj) {
1935                         this.offset.click.left = obj.left + this.margins.left;
1936                 }
1937                 if ("right" in obj) {
1938                         this.offset.click.left = this.helperProportions.width - obj.right + this.margins.left;
1939                 }
1940                 if ("top" in obj) {
1941                         this.offset.click.top = obj.top + this.margins.top;
1942                 }
1943                 if ("bottom" in obj) {
1944                         this.offset.click.top = this.helperProportions.height - obj.bottom + this.margins.top;
1945                 }
1946         },
1947
1948         _isRootNode: function( element ) {
1949                 return ( /(html|body)/i ).test( element.tagName ) || element === this.document[ 0 ];
1950         },
1951
1952         _getParentOffset: function() {
1953
1954                 //Get the offsetParent and cache its position
1955                 var po = this.offsetParent.offset(),
1956                         document = this.document[ 0 ];
1957
1958                 // This is a special case where we need to modify a offset calculated on start, since the following happened:
1959                 // 1. The position of the helper is absolute, so it's position is calculated based on the next positioned parent
1960                 // 2. The actual offset parent is a child of the scroll parent, and the scroll parent isn't the document, which means that
1961                 //    the scroll is included in the initial calculation of the offset of the parent, and never recalculated upon drag
1962                 if (this.cssPosition === "absolute" && this.scrollParent[0] !== document && $.contains(this.scrollParent[0], this.offsetParent[0])) {
1963                         po.left += this.scrollParent.scrollLeft();
1964                         po.top += this.scrollParent.scrollTop();
1965                 }
1966
1967                 if ( this._isRootNode( this.offsetParent[ 0 ] ) ) {
1968                         po = { top: 0, left: 0 };
1969                 }
1970
1971                 return {
1972                         top: po.top + (parseInt(this.offsetParent.css("borderTopWidth"), 10) || 0),
1973                         left: po.left + (parseInt(this.offsetParent.css("borderLeftWidth"), 10) || 0)
1974                 };
1975
1976         },
1977
1978         _getRelativeOffset: function() {
1979                 if ( this.cssPosition !== "relative" ) {
1980                         return { top: 0, left: 0 };
1981                 }
1982
1983                 var p = this.element.position(),
1984                         scrollIsRootNode = this._isRootNode( this.scrollParent[ 0 ] );
1985
1986                 return {
1987                         top: p.top - ( parseInt(this.helper.css( "top" ), 10) || 0 ) + ( !scrollIsRootNode ? this.scrollParent.scrollTop() : 0 ),
1988                         left: p.left - ( parseInt(this.helper.css( "left" ), 10) || 0 ) + ( !scrollIsRootNode ? this.scrollParent.scrollLeft() : 0 )
1989                 };
1990
1991         },
1992
1993         _cacheMargins: function() {
1994                 this.margins = {
1995                         left: (parseInt(this.element.css("marginLeft"), 10) || 0),
1996                         top: (parseInt(this.element.css("marginTop"), 10) || 0),
1997                         right: (parseInt(this.element.css("marginRight"), 10) || 0),
1998                         bottom: (parseInt(this.element.css("marginBottom"), 10) || 0)
1999                 };
2000         },
2001
2002         _cacheHelperProportions: function() {
2003                 this.helperProportions = {
2004                         width: this.helper.outerWidth(),
2005                         height: this.helper.outerHeight()
2006                 };
2007         },
2008
2009         _setContainment: function() {
2010
2011                 var isUserScrollable, c, ce,
2012                         o = this.options,
2013                         document = this.document[ 0 ];
2014
2015                 this.relativeContainer = null;
2016
2017                 if ( !o.containment ) {
2018                         this.containment = null;
2019                         return;
2020                 }
2021
2022                 if ( o.containment === "window" ) {
2023                         this.containment = [
2024                                 $( window ).scrollLeft() - this.offset.relative.left - this.offset.parent.left,
2025                                 $( window ).scrollTop() - this.offset.relative.top - this.offset.parent.top,
2026                                 $( window ).scrollLeft() + $( window ).width() - this.helperProportions.width - this.margins.left,
2027                                 $( window ).scrollTop() + ( $( window ).height() || document.body.parentNode.scrollHeight ) - this.helperProportions.height - this.margins.top
2028                         ];
2029                         return;
2030                 }
2031
2032                 if ( o.containment === "document") {
2033                         this.containment = [
2034                                 0,
2035                                 0,
2036                                 $( document ).width() - this.helperProportions.width - this.margins.left,
2037                                 ( $( document ).height() || document.body.parentNode.scrollHeight ) - this.helperProportions.height - this.margins.top
2038                         ];
2039                         return;
2040                 }
2041
2042                 if ( o.containment.constructor === Array ) {
2043                         this.containment = o.containment;
2044                         return;
2045                 }
2046
2047                 if ( o.containment === "parent" ) {
2048                         o.containment = this.helper[ 0 ].parentNode;
2049                 }
2050
2051                 c = $( o.containment );
2052                 ce = c[ 0 ];
2053
2054                 if ( !ce ) {
2055                         return;
2056                 }
2057
2058                 isUserScrollable = /(scroll|auto)/.test( c.css( "overflow" ) );
2059
2060                 this.containment = [
2061                         ( parseInt( c.css( "borderLeftWidth" ), 10 ) || 0 ) + ( parseInt( c.css( "paddingLeft" ), 10 ) || 0 ),
2062                         ( parseInt( c.css( "borderTopWidth" ), 10 ) || 0 ) + ( parseInt( c.css( "paddingTop" ), 10 ) || 0 ),
2063                         ( isUserScrollable ? Math.max( ce.scrollWidth, ce.offsetWidth ) : ce.offsetWidth ) -
2064                                 ( parseInt( c.css( "borderRightWidth" ), 10 ) || 0 ) -
2065                                 ( parseInt( c.css( "paddingRight" ), 10 ) || 0 ) -
2066                                 this.helperProportions.width -
2067                                 this.margins.left -
2068                                 this.margins.right,
2069                         ( isUserScrollable ? Math.max( ce.scrollHeight, ce.offsetHeight ) : ce.offsetHeight ) -
2070                                 ( parseInt( c.css( "borderBottomWidth" ), 10 ) || 0 ) -
2071                                 ( parseInt( c.css( "paddingBottom" ), 10 ) || 0 ) -
2072                                 this.helperProportions.height -
2073                                 this.margins.top -
2074                                 this.margins.bottom
2075                 ];
2076                 this.relativeContainer = c;
2077         },
2078
2079         _convertPositionTo: function(d, pos) {
2080
2081                 if (!pos) {
2082                         pos = this.position;
2083                 }
2084
2085                 var mod = d === "absolute" ? 1 : -1,
2086                         scrollIsRootNode = this._isRootNode( this.scrollParent[ 0 ] );
2087
2088                 return {
2089                         top: (
2090                                 pos.top +                                                                                                                               // The absolute mouse position
2091                                 this.offset.relative.top * mod +                                                                                // Only for relative positioned nodes: Relative offset from element to offset parent
2092                                 this.offset.parent.top * mod -                                                                          // The offsetParent's offset without borders (offset + border)
2093                                 ( ( this.cssPosition === "fixed" ? -this.offset.scroll.top : ( scrollIsRootNode ? 0 : this.offset.scroll.top ) ) * mod)
2094                         ),
2095                         left: (
2096                                 pos.left +                                                                                                                              // The absolute mouse position
2097                                 this.offset.relative.left * mod +                                                                               // Only for relative positioned nodes: Relative offset from element to offset parent
2098                                 this.offset.parent.left * mod   -                                                                               // The offsetParent's offset without borders (offset + border)
2099                                 ( ( this.cssPosition === "fixed" ? -this.offset.scroll.left : ( scrollIsRootNode ? 0 : this.offset.scroll.left ) ) * mod)
2100                         )
2101                 };
2102
2103         },
2104
2105         _generatePosition: function( event, constrainPosition ) {
2106
2107                 var containment, co, top, left,
2108                         o = this.options,
2109                         scrollIsRootNode = this._isRootNode( this.scrollParent[ 0 ] ),
2110                         pageX = event.pageX,
2111                         pageY = event.pageY;
2112
2113                 // Cache the scroll
2114                 if ( !scrollIsRootNode || !this.offset.scroll ) {
2115                         this.offset.scroll = {
2116                                 top: this.scrollParent.scrollTop(),
2117                                 left: this.scrollParent.scrollLeft()
2118                         };
2119                 }
2120
2121                 /*
2122                  * - Position constraining -
2123                  * Constrain the position to a mix of grid, containment.
2124                  */
2125
2126                 // If we are not dragging yet, we won't check for options
2127                 if ( constrainPosition ) {
2128                         if ( this.containment ) {
2129                                 if ( this.relativeContainer ){
2130                                         co = this.relativeContainer.offset();
2131                                         containment = [
2132                                                 this.containment[ 0 ] + co.left,
2133                                                 this.containment[ 1 ] + co.top,
2134                                                 this.containment[ 2 ] + co.left,
2135                                                 this.containment[ 3 ] + co.top
2136                                         ];
2137                                 } else {
2138                                         containment = this.containment;
2139                                 }
2140
2141                                 if (event.pageX - this.offset.click.left < containment[0]) {
2142                                         pageX = containment[0] + this.offset.click.left;
2143                                 }
2144                                 if (event.pageY - this.offset.click.top < containment[1]) {
2145                                         pageY = containment[1] + this.offset.click.top;
2146                                 }
2147                                 if (event.pageX - this.offset.click.left > containment[2]) {
2148                                         pageX = containment[2] + this.offset.click.left;
2149                                 }
2150                                 if (event.pageY - this.offset.click.top > containment[3]) {
2151                                         pageY = containment[3] + this.offset.click.top;
2152                                 }
2153                         }
2154
2155                         if (o.grid) {
2156                                 //Check for grid elements set to 0 to prevent divide by 0 error causing invalid argument errors in IE (see ticket #6950)
2157                                 top = o.grid[1] ? this.originalPageY + Math.round((pageY - this.originalPageY) / o.grid[1]) * o.grid[1] : this.originalPageY;
2158                                 pageY = containment ? ((top - this.offset.click.top >= containment[1] || top - this.offset.click.top > containment[3]) ? top : ((top - this.offset.click.top >= containment[1]) ? top - o.grid[1] : top + o.grid[1])) : top;
2159
2160                                 left = o.grid[0] ? this.originalPageX + Math.round((pageX - this.originalPageX) / o.grid[0]) * o.grid[0] : this.originalPageX;
2161                                 pageX = containment ? ((left - this.offset.click.left >= containment[0] || left - this.offset.click.left > containment[2]) ? left : ((left - this.offset.click.left >= containment[0]) ? left - o.grid[0] : left + o.grid[0])) : left;
2162                         }
2163
2164                         if ( o.axis === "y" ) {
2165                                 pageX = this.originalPageX;
2166                         }
2167
2168                         if ( o.axis === "x" ) {
2169                                 pageY = this.originalPageY;
2170                         }
2171                 }
2172
2173                 return {
2174                         top: (
2175                                 pageY -                                                                                                                                 // The absolute mouse position
2176                                 this.offset.click.top   -                                                                                               // Click offset (relative to the element)
2177                                 this.offset.relative.top -                                                                                              // Only for relative positioned nodes: Relative offset from element to offset parent
2178                                 this.offset.parent.top +                                                                                                // The offsetParent's offset without borders (offset + border)
2179                                 ( this.cssPosition === "fixed" ? -this.offset.scroll.top : ( scrollIsRootNode ? 0 : this.offset.scroll.top ) )
2180                         ),
2181                         left: (
2182                                 pageX -                                                                                                                                 // The absolute mouse position
2183                                 this.offset.click.left -                                                                                                // Click offset (relative to the element)
2184                                 this.offset.relative.left -                                                                                             // Only for relative positioned nodes: Relative offset from element to offset parent
2185                                 this.offset.parent.left +                                                                                               // The offsetParent's offset without borders (offset + border)
2186                                 ( this.cssPosition === "fixed" ? -this.offset.scroll.left : ( scrollIsRootNode ? 0 : this.offset.scroll.left ) )
2187                         )
2188                 };
2189
2190         },
2191
2192         _clear: function() {
2193                 this.helper.removeClass("ui-draggable-dragging");
2194                 if (this.helper[0] !== this.element[0] && !this.cancelHelperRemoval) {
2195                         this.helper.remove();
2196                 }
2197                 this.helper = null;
2198                 this.cancelHelperRemoval = false;
2199                 if ( this.destroyOnClear ) {
2200                         this.destroy();
2201                 }
2202         },
2203
2204         _normalizeRightBottom: function() {
2205                 if ( this.options.axis !== "y" && this.helper.css( "right" ) !== "auto" ) {
2206                         this.helper.width( this.helper.width() );
2207                         this.helper.css( "right", "auto" );
2208                 }
2209                 if ( this.options.axis !== "x" && this.helper.css( "bottom" ) !== "auto" ) {
2210                         this.helper.height( this.helper.height() );
2211                         this.helper.css( "bottom", "auto" );
2212                 }
2213         },
2214
2215         // From now on bulk stuff - mainly helpers
2216
2217         _trigger: function( type, event, ui ) {
2218                 ui = ui || this._uiHash();
2219                 $.ui.plugin.call( this, type, [ event, ui, this ], true );
2220
2221                 // Absolute position and offset (see #6884 ) have to be recalculated after plugins
2222                 if ( /^(drag|start|stop)/.test( type ) ) {
2223                         this.positionAbs = this._convertPositionTo( "absolute" );
2224                         ui.offset = this.positionAbs;
2225                 }
2226                 return $.Widget.prototype._trigger.call( this, type, event, ui );
2227         },
2228
2229         plugins: {},
2230
2231         _uiHash: function() {
2232                 return {
2233                         helper: this.helper,
2234                         position: this.position,
2235                         originalPosition: this.originalPosition,
2236                         offset: this.positionAbs
2237                 };
2238         }
2239
2240 });
2241
2242 $.ui.plugin.add( "draggable", "connectToSortable", {
2243         start: function( event, ui, draggable ) {
2244                 var uiSortable = $.extend( {}, ui, {
2245                         item: draggable.element
2246                 });
2247
2248                 draggable.sortables = [];
2249                 $( draggable.options.connectToSortable ).each(function() {
2250                         var sortable = $( this ).sortable( "instance" );
2251
2252                         if ( sortable && !sortable.options.disabled ) {
2253                                 draggable.sortables.push( sortable );
2254
2255                                 // refreshPositions is called at drag start to refresh the containerCache
2256                                 // which is used in drag. This ensures it's initialized and synchronized
2257                                 // with any changes that might have happened on the page since initialization.
2258                                 sortable.refreshPositions();
2259                                 sortable._trigger("activate", event, uiSortable);
2260                         }
2261                 });
2262         },
2263         stop: function( event, ui, draggable ) {
2264                 var uiSortable = $.extend( {}, ui, {
2265                         item: draggable.element
2266                 });
2267
2268                 draggable.cancelHelperRemoval = false;
2269
2270                 $.each( draggable.sortables, function() {
2271                         var sortable = this;
2272
2273                         if ( sortable.isOver ) {
2274                                 sortable.isOver = 0;
2275
2276                                 // Allow this sortable to handle removing the helper
2277                                 draggable.cancelHelperRemoval = true;
2278                                 sortable.cancelHelperRemoval = false;
2279
2280                                 // Use _storedCSS To restore properties in the sortable,
2281                                 // as this also handles revert (#9675) since the draggable
2282                                 // may have modified them in unexpected ways (#8809)
2283                                 sortable._storedCSS = {
2284                                         position: sortable.placeholder.css( "position" ),
2285                                         top: sortable.placeholder.css( "top" ),
2286                                         left: sortable.placeholder.css( "left" )
2287                                 };
2288
2289                                 sortable._mouseStop(event);
2290
2291                                 // Once drag has ended, the sortable should return to using
2292                                 // its original helper, not the shared helper from draggable
2293                                 sortable.options.helper = sortable.options._helper;
2294                         } else {
2295                                 // Prevent this Sortable from removing the helper.
2296                                 // However, don't set the draggable to remove the helper
2297                                 // either as another connected Sortable may yet handle the removal.
2298                                 sortable.cancelHelperRemoval = true;
2299
2300                                 sortable._trigger( "deactivate", event, uiSortable );
2301                         }
2302                 });
2303         },
2304         drag: function( event, ui, draggable ) {
2305                 $.each( draggable.sortables, function() {
2306                         var innermostIntersecting = false,
2307                                 sortable = this;
2308
2309                         // Copy over variables that sortable's _intersectsWith uses
2310                         sortable.positionAbs = draggable.positionAbs;
2311                         sortable.helperProportions = draggable.helperProportions;
2312                         sortable.offset.click = draggable.offset.click;
2313
2314                         if ( sortable._intersectsWith( sortable.containerCache ) ) {
2315                                 innermostIntersecting = true;
2316
2317                                 $.each( draggable.sortables, function() {
2318                                         // Copy over variables that sortable's _intersectsWith uses
2319                                         this.positionAbs = draggable.positionAbs;
2320                                         this.helperProportions = draggable.helperProportions;
2321                                         this.offset.click = draggable.offset.click;
2322
2323                                         if ( this !== sortable &&
2324                                                         this._intersectsWith( this.containerCache ) &&
2325                                                         $.contains( sortable.element[ 0 ], this.element[ 0 ] ) ) {
2326                                                 innermostIntersecting = false;
2327                                         }
2328
2329                                         return innermostIntersecting;
2330                                 });
2331                         }
2332
2333                         if ( innermostIntersecting ) {
2334                                 // If it intersects, we use a little isOver variable and set it once,
2335                                 // so that the move-in stuff gets fired only once.
2336                                 if ( !sortable.isOver ) {
2337                                         sortable.isOver = 1;
2338
2339                                         // Store draggable's parent in case we need to reappend to it later.
2340                                         draggable._parent = ui.helper.parent();
2341
2342                                         sortable.currentItem = ui.helper
2343                                                 .appendTo( sortable.element )
2344                                                 .data( "ui-sortable-item", true );
2345
2346                                         // Store helper option to later restore it
2347                                         sortable.options._helper = sortable.options.helper;
2348
2349                                         sortable.options.helper = function() {
2350                                                 return ui.helper[ 0 ];
2351                                         };
2352
2353                                         // Fire the start events of the sortable with our passed browser event,
2354                                         // and our own helper (so it doesn't create a new one)
2355                                         event.target = sortable.currentItem[ 0 ];
2356                                         sortable._mouseCapture( event, true );
2357                                         sortable._mouseStart( event, true, true );
2358
2359                                         // Because the browser event is way off the new appended portlet,
2360                                         // modify necessary variables to reflect the changes
2361                                         sortable.offset.click.top = draggable.offset.click.top;
2362                                         sortable.offset.click.left = draggable.offset.click.left;
2363                                         sortable.offset.parent.left -= draggable.offset.parent.left -
2364                                                 sortable.offset.parent.left;
2365                                         sortable.offset.parent.top -= draggable.offset.parent.top -
2366                                                 sortable.offset.parent.top;
2367
2368                                         draggable._trigger( "toSortable", event );
2369
2370                                         // Inform draggable that the helper is in a valid drop zone,
2371                                         // used solely in the revert option to handle "valid/invalid".
2372                                         draggable.dropped = sortable.element;
2373
2374                                         // Need to refreshPositions of all sortables in the case that
2375                                         // adding to one sortable changes the location of the other sortables (#9675)
2376                                         $.each( draggable.sortables, function() {
2377                                                 this.refreshPositions();
2378                                         });
2379
2380                                         // hack so receive/update callbacks work (mostly)
2381                                         draggable.currentItem = draggable.element;
2382                                         sortable.fromOutside = draggable;
2383                                 }
2384
2385                                 if ( sortable.currentItem ) {
2386                                         sortable._mouseDrag( event );
2387                                         // Copy the sortable's position because the draggable's can potentially reflect
2388                                         // a relative position, while sortable is always absolute, which the dragged
2389                                         // element has now become. (#8809)
2390                                         ui.position = sortable.position;
2391                                 }
2392                         } else {
2393                                 // If it doesn't intersect with the sortable, and it intersected before,
2394                                 // we fake the drag stop of the sortable, but make sure it doesn't remove
2395                                 // the helper by using cancelHelperRemoval.
2396                                 if ( sortable.isOver ) {
2397
2398                                         sortable.isOver = 0;
2399                                         sortable.cancelHelperRemoval = true;
2400
2401                                         // Calling sortable's mouseStop would trigger a revert,
2402                                         // so revert must be temporarily false until after mouseStop is called.
2403                                         sortable.options._revert = sortable.options.revert;
2404                                         sortable.options.revert = false;
2405
2406                                         sortable._trigger( "out", event, sortable._uiHash( sortable ) );
2407                                         sortable._mouseStop( event, true );
2408
2409                                         // restore sortable behaviors that were modfied
2410                                         // when the draggable entered the sortable area (#9481)
2411                                         sortable.options.revert = sortable.options._revert;
2412                                         sortable.options.helper = sortable.options._helper;
2413
2414                                         if ( sortable.placeholder ) {
2415                                                 sortable.placeholder.remove();
2416                                         }
2417
2418                                         // Restore and recalculate the draggable's offset considering the sortable
2419                                         // may have modified them in unexpected ways. (#8809, #10669)
2420                                         ui.helper.appendTo( draggable._parent );
2421                                         draggable._refreshOffsets( event );
2422                                         ui.position = draggable._generatePosition( event, true );
2423
2424                                         draggable._trigger( "fromSortable", event );
2425
2426                                         // Inform draggable that the helper is no longer in a valid drop zone
2427                                         draggable.dropped = false;
2428
2429                                         // Need to refreshPositions of all sortables just in case removing
2430                                         // from one sortable changes the location of other sortables (#9675)
2431                                         $.each( draggable.sortables, function() {
2432                                                 this.refreshPositions();
2433                                         });
2434                                 }
2435                         }
2436                 });
2437         }
2438 });
2439
2440 $.ui.plugin.add("draggable", "cursor", {
2441         start: function( event, ui, instance ) {
2442                 var t = $( "body" ),
2443                         o = instance.options;
2444
2445                 if (t.css("cursor")) {
2446                         o._cursor = t.css("cursor");
2447                 }
2448                 t.css("cursor", o.cursor);
2449         },
2450         stop: function( event, ui, instance ) {
2451                 var o = instance.options;
2452                 if (o._cursor) {
2453                         $("body").css("cursor", o._cursor);
2454                 }
2455         }
2456 });
2457
2458 $.ui.plugin.add("draggable", "opacity", {
2459         start: function( event, ui, instance ) {
2460                 var t = $( ui.helper ),
2461                         o = instance.options;
2462                 if (t.css("opacity")) {
2463                         o._opacity = t.css("opacity");
2464                 }
2465                 t.css("opacity", o.opacity);
2466         },
2467         stop: function( event, ui, instance ) {
2468                 var o = instance.options;
2469                 if (o._opacity) {
2470                         $(ui.helper).css("opacity", o._opacity);
2471                 }
2472         }
2473 });
2474
2475 $.ui.plugin.add("draggable", "scroll", {
2476         start: function( event, ui, i ) {
2477                 if ( !i.scrollParentNotHidden ) {
2478                         i.scrollParentNotHidden = i.helper.scrollParent( false );
2479                 }
2480
2481                 if ( i.scrollParentNotHidden[ 0 ] !== i.document[ 0 ] && i.scrollParentNotHidden[ 0 ].tagName !== "HTML" ) {
2482                         i.overflowOffset = i.scrollParentNotHidden.offset();
2483                 }
2484         },
2485         drag: function( event, ui, i  ) {
2486
2487                 var o = i.options,
2488                         scrolled = false,
2489                         scrollParent = i.scrollParentNotHidden[ 0 ],
2490                         document = i.document[ 0 ];
2491
2492                 if ( scrollParent !== document && scrollParent.tagName !== "HTML" ) {
2493                         if ( !o.axis || o.axis !== "x" ) {
2494                                 if ( ( i.overflowOffset.top + scrollParent.offsetHeight ) - event.pageY < o.scrollSensitivity ) {
2495                                         scrollParent.scrollTop = scrolled = scrollParent.scrollTop + o.scrollSpeed;
2496                                 } else if ( event.pageY - i.overflowOffset.top < o.scrollSensitivity ) {
2497                                         scrollParent.scrollTop = scrolled = scrollParent.scrollTop - o.scrollSpeed;
2498                                 }
2499                         }
2500
2501                         if ( !o.axis || o.axis !== "y" ) {
2502                                 if ( ( i.overflowOffset.left + scrollParent.offsetWidth ) - event.pageX < o.scrollSensitivity ) {
2503                                         scrollParent.scrollLeft = scrolled = scrollParent.scrollLeft + o.scrollSpeed;
2504                                 } else if ( event.pageX - i.overflowOffset.left < o.scrollSensitivity ) {
2505                                         scrollParent.scrollLeft = scrolled = scrollParent.scrollLeft - o.scrollSpeed;
2506                                 }
2507                         }
2508
2509                 } else {
2510
2511                         if (!o.axis || o.axis !== "x") {
2512                                 if (event.pageY - $(document).scrollTop() < o.scrollSensitivity) {
2513                                         scrolled = $(document).scrollTop($(document).scrollTop() - o.scrollSpeed);
2514                                 } else if ($(window).height() - (event.pageY - $(document).scrollTop()) < o.scrollSensitivity) {
2515                                         scrolled = $(document).scrollTop($(document).scrollTop() + o.scrollSpeed);
2516                                 }
2517                         }
2518
2519                         if (!o.axis || o.axis !== "y") {
2520                                 if (event.pageX - $(document).scrollLeft() < o.scrollSensitivity) {
2521                                         scrolled = $(document).scrollLeft($(document).scrollLeft() - o.scrollSpeed);
2522                                 } else if ($(window).width() - (event.pageX - $(document).scrollLeft()) < o.scrollSensitivity) {
2523                                         scrolled = $(document).scrollLeft($(document).scrollLeft() + o.scrollSpeed);
2524                                 }
2525                         }
2526
2527                 }
2528
2529                 if (scrolled !== false && $.ui.ddmanager && !o.dropBehaviour) {
2530                         $.ui.ddmanager.prepareOffsets(i, event);
2531                 }
2532
2533         }
2534 });
2535
2536 $.ui.plugin.add("draggable", "snap", {
2537         start: function( event, ui, i ) {
2538
2539                 var o = i.options;
2540
2541                 i.snapElements = [];
2542
2543                 $(o.snap.constructor !== String ? ( o.snap.items || ":data(ui-draggable)" ) : o.snap).each(function() {
2544                         var $t = $(this),
2545                                 $o = $t.offset();
2546                         if (this !== i.element[0]) {
2547                                 i.snapElements.push({
2548                                         item: this,
2549                                         width: $t.outerWidth(), height: $t.outerHeight(),
2550                                         top: $o.top, left: $o.left
2551                                 });
2552                         }
2553                 });
2554
2555         },
2556         drag: function( event, ui, inst ) {
2557
2558                 var ts, bs, ls, rs, l, r, t, b, i, first,
2559                         o = inst.options,
2560                         d = o.snapTolerance,
2561                         x1 = ui.offset.left, x2 = x1 + inst.helperProportions.width,
2562                         y1 = ui.offset.top, y2 = y1 + inst.helperProportions.height;
2563
2564                 for (i = inst.snapElements.length - 1; i >= 0; i--){
2565
2566                         l = inst.snapElements[i].left - inst.margins.left;
2567                         r = l + inst.snapElements[i].width;
2568                         t = inst.snapElements[i].top - inst.margins.top;
2569                         b = t + inst.snapElements[i].height;
2570
2571                         if ( x2 < l - d || x1 > r + d || y2 < t - d || y1 > b + d || !$.contains( inst.snapElements[ i ].item.ownerDocument, inst.snapElements[ i ].item ) ) {
2572                                 if (inst.snapElements[i].snapping) {
2573                                         (inst.options.snap.release && inst.options.snap.release.call(inst.element, event, $.extend(inst._uiHash(), { snapItem: inst.snapElements[i].item })));
2574                                 }
2575                                 inst.snapElements[i].snapping = false;
2576                                 continue;
2577                         }
2578
2579                         if (o.snapMode !== "inner") {
2580                                 ts = Math.abs(t - y2) <= d;
2581                                 bs = Math.abs(b - y1) <= d;
2582                                 ls = Math.abs(l - x2) <= d;
2583                                 rs = Math.abs(r - x1) <= d;
2584                                 if (ts) {
2585                                         ui.position.top = inst._convertPositionTo("relative", { top: t - inst.helperProportions.height, left: 0 }).top;
2586                                 }
2587                                 if (bs) {
2588                                         ui.position.top = inst._convertPositionTo("relative", { top: b, left: 0 }).top;
2589                                 }
2590                                 if (ls) {
2591                                         ui.position.left = inst._convertPositionTo("relative", { top: 0, left: l - inst.helperProportions.width }).left;
2592                                 }
2593                                 if (rs) {
2594                                         ui.position.left = inst._convertPositionTo("relative", { top: 0, left: r }).left;
2595                                 }
2596                         }
2597
2598                         first = (ts || bs || ls || rs);
2599
2600                         if (o.snapMode !== "outer") {
2601                                 ts = Math.abs(t - y1) <= d;
2602                                 bs = Math.abs(b - y2) <= d;
2603                                 ls = Math.abs(l - x1) <= d;
2604                                 rs = Math.abs(r - x2) <= d;
2605                                 if (ts) {
2606                                         ui.position.top = inst._convertPositionTo("relative", { top: t, left: 0 }).top;
2607                                 }
2608                                 if (bs) {
2609                                         ui.position.top = inst._convertPositionTo("relative", { top: b - inst.helperProportions.height, left: 0 }).top;
2610                                 }
2611                                 if (ls) {
2612                                         ui.position.left = inst._convertPositionTo("relative", { top: 0, left: l }).left;
2613                                 }
2614                                 if (rs) {
2615                                         ui.position.left = inst._convertPositionTo("relative", { top: 0, left: r - inst.helperProportions.width }).left;
2616                                 }
2617                         }
2618
2619                         if (!inst.snapElements[i].snapping && (ts || bs || ls || rs || first)) {
2620                                 (inst.options.snap.snap && inst.options.snap.snap.call(inst.element, event, $.extend(inst._uiHash(), { snapItem: inst.snapElements[i].item })));
2621                         }
2622                         inst.snapElements[i].snapping = (ts || bs || ls || rs || first);
2623
2624                 }
2625
2626         }
2627 });
2628
2629 $.ui.plugin.add("draggable", "stack", {
2630         start: function( event, ui, instance ) {
2631                 var min,
2632                         o = instance.options,
2633                         group = $.makeArray($(o.stack)).sort(function(a, b) {
2634                                 return (parseInt($(a).css("zIndex"), 10) || 0) - (parseInt($(b).css("zIndex"), 10) || 0);
2635                         });
2636
2637                 if (!group.length) { return; }
2638
2639                 min = parseInt($(group[0]).css("zIndex"), 10) || 0;
2640                 $(group).each(function(i) {
2641                         $(this).css("zIndex", min + i);
2642                 });
2643                 this.css("zIndex", (min + group.length));
2644         }
2645 });
2646
2647 $.ui.plugin.add("draggable", "zIndex", {
2648         start: function( event, ui, instance ) {
2649                 var t = $( ui.helper ),
2650                         o = instance.options;
2651
2652                 if (t.css("zIndex")) {
2653                         o._zIndex = t.css("zIndex");
2654                 }
2655                 t.css("zIndex", o.zIndex);
2656         },
2657         stop: function( event, ui, instance ) {
2658                 var o = instance.options;
2659
2660                 if (o._zIndex) {
2661                         $(ui.helper).css("zIndex", o._zIndex);
2662                 }
2663         }
2664 });
2665
2666 var draggable = $.ui.draggable;
2667
2668
2669 /*!
2670  * jQuery UI Droppable 1.11.4
2671  * http://jqueryui.com
2672  *
2673  * Copyright jQuery Foundation and other contributors
2674  * Released under the MIT license.
2675  * http://jquery.org/license
2676  *
2677  * http://api.jqueryui.com/droppable/
2678  */
2679
2680
2681 $.widget( "ui.droppable", {
2682         version: "1.11.4",
2683         widgetEventPrefix: "drop",
2684         options: {
2685                 accept: "*",
2686                 activeClass: false,
2687                 addClasses: true,
2688                 greedy: false,
2689                 hoverClass: false,
2690                 scope: "default",
2691                 tolerance: "intersect",
2692
2693                 // callbacks
2694                 activate: null,
2695                 deactivate: null,
2696                 drop: null,
2697                 out: null,
2698                 over: null
2699         },
2700         _create: function() {
2701
2702                 var proportions,
2703                         o = this.options,
2704                         accept = o.accept;
2705
2706                 this.isover = false;
2707                 this.isout = true;
2708
2709                 this.accept = $.isFunction( accept ) ? accept : function( d ) {
2710                         return d.is( accept );
2711                 };
2712
2713                 this.proportions = function( /* valueToWrite */ ) {
2714                         if ( arguments.length ) {
2715                                 // Store the droppable's proportions
2716                                 proportions = arguments[ 0 ];
2717                         } else {
2718                                 // Retrieve or derive the droppable's proportions
2719                                 return proportions ?
2720                                         proportions :
2721                                         proportions = {
2722                                                 width: this.element[ 0 ].offsetWidth,
2723                                                 height: this.element[ 0 ].offsetHeight
2724                                         };
2725                         }
2726                 };
2727
2728                 this._addToManager( o.scope );
2729
2730                 o.addClasses && this.element.addClass( "ui-droppable" );
2731
2732         },
2733
2734         _addToManager: function( scope ) {
2735                 // Add the reference and positions to the manager
2736                 $.ui.ddmanager.droppables[ scope ] = $.ui.ddmanager.droppables[ scope ] || [];
2737                 $.ui.ddmanager.droppables[ scope ].push( this );
2738         },
2739
2740         _splice: function( drop ) {
2741                 var i = 0;
2742                 for ( ; i < drop.length; i++ ) {
2743                         if ( drop[ i ] === this ) {
2744                                 drop.splice( i, 1 );
2745                         }
2746                 }
2747         },
2748
2749         _destroy: function() {
2750                 var drop = $.ui.ddmanager.droppables[ this.options.scope ];
2751
2752                 this._splice( drop );
2753
2754                 this.element.removeClass( "ui-droppable ui-droppable-disabled" );
2755         },
2756
2757         _setOption: function( key, value ) {
2758
2759                 if ( key === "accept" ) {
2760                         this.accept = $.isFunction( value ) ? value : function( d ) {
2761                                 return d.is( value );
2762                         };
2763                 } else if ( key === "scope" ) {
2764                         var drop = $.ui.ddmanager.droppables[ this.options.scope ];
2765
2766                         this._splice( drop );
2767                         this._addToManager( value );
2768                 }
2769
2770                 this._super( key, value );
2771         },
2772
2773         _activate: function( event ) {
2774                 var draggable = $.ui.ddmanager.current;
2775                 if ( this.options.activeClass ) {
2776                         this.element.addClass( this.options.activeClass );
2777                 }
2778                 if ( draggable ){
2779                         this._trigger( "activate", event, this.ui( draggable ) );
2780                 }
2781         },
2782
2783         _deactivate: function( event ) {
2784                 var draggable = $.ui.ddmanager.current;
2785                 if ( this.options.activeClass ) {
2786                         this.element.removeClass( this.options.activeClass );
2787                 }
2788                 if ( draggable ){
2789                         this._trigger( "deactivate", event, this.ui( draggable ) );
2790                 }
2791         },
2792
2793         _over: function( event ) {
2794
2795                 var draggable = $.ui.ddmanager.current;
2796
2797                 // Bail if draggable and droppable are same element
2798                 if ( !draggable || ( draggable.currentItem || draggable.element )[ 0 ] === this.element[ 0 ] ) {
2799                         return;
2800                 }
2801
2802                 if ( this.accept.call( this.element[ 0 ], ( draggable.currentItem || draggable.element ) ) ) {
2803                         if ( this.options.hoverClass ) {
2804                                 this.element.addClass( this.options.hoverClass );
2805                         }
2806                         this._trigger( "over", event, this.ui( draggable ) );
2807                 }
2808
2809         },
2810
2811         _out: function( event ) {
2812
2813                 var draggable = $.ui.ddmanager.current;
2814
2815                 // Bail if draggable and droppable are same element
2816                 if ( !draggable || ( draggable.currentItem || draggable.element )[ 0 ] === this.element[ 0 ] ) {
2817                         return;
2818                 }
2819
2820                 if ( this.accept.call( this.element[ 0 ], ( draggable.currentItem || draggable.element ) ) ) {
2821                         if ( this.options.hoverClass ) {
2822                                 this.element.removeClass( this.options.hoverClass );
2823                         }
2824                         this._trigger( "out", event, this.ui( draggable ) );
2825                 }
2826
2827         },
2828
2829         _drop: function( event, custom ) {
2830
2831                 var draggable = custom || $.ui.ddmanager.current,
2832                         childrenIntersection = false;
2833
2834                 // Bail if draggable and droppable are same element
2835                 if ( !draggable || ( draggable.currentItem || draggable.element )[ 0 ] === this.element[ 0 ] ) {
2836                         return false;
2837                 }
2838
2839                 this.element.find( ":data(ui-droppable)" ).not( ".ui-draggable-dragging" ).each(function() {
2840                         var inst = $( this ).droppable( "instance" );
2841                         if (
2842                                 inst.options.greedy &&
2843                                 !inst.options.disabled &&
2844                                 inst.options.scope === draggable.options.scope &&
2845                                 inst.accept.call( inst.element[ 0 ], ( draggable.currentItem || draggable.element ) ) &&
2846                                 $.ui.intersect( draggable, $.extend( inst, { offset: inst.element.offset() } ), inst.options.tolerance, event )
2847                         ) { childrenIntersection = true; return false; }
2848                 });
2849                 if ( childrenIntersection ) {
2850                         return false;
2851                 }
2852
2853                 if ( this.accept.call( this.element[ 0 ], ( draggable.currentItem || draggable.element ) ) ) {
2854                         if ( this.options.activeClass ) {
2855                                 this.element.removeClass( this.options.activeClass );
2856                         }
2857                         if ( this.options.hoverClass ) {
2858                                 this.element.removeClass( this.options.hoverClass );
2859                         }
2860                         this._trigger( "drop", event, this.ui( draggable ) );
2861                         return this.element;
2862                 }
2863
2864                 return false;
2865
2866         },
2867
2868         ui: function( c ) {
2869                 return {
2870                         draggable: ( c.currentItem || c.element ),
2871                         helper: c.helper,
2872                         position: c.position,
2873                         offset: c.positionAbs
2874                 };
2875         }
2876
2877 });
2878
2879 $.ui.intersect = (function() {
2880         function isOverAxis( x, reference, size ) {
2881                 return ( x >= reference ) && ( x < ( reference + size ) );
2882         }
2883
2884         return function( draggable, droppable, toleranceMode, event ) {
2885
2886                 if ( !droppable.offset ) {
2887                         return false;
2888                 }
2889
2890                 var x1 = ( draggable.positionAbs || draggable.position.absolute ).left + draggable.margins.left,
2891                         y1 = ( draggable.positionAbs || draggable.position.absolute ).top + draggable.margins.top,
2892                         x2 = x1 + draggable.helperProportions.width,
2893                         y2 = y1 + draggable.helperProportions.height,
2894                         l = droppable.offset.left,
2895                         t = droppable.offset.top,
2896                         r = l + droppable.proportions().width,
2897                         b = t + droppable.proportions().height;
2898
2899                 switch ( toleranceMode ) {
2900                 case "fit":
2901                         return ( l <= x1 && x2 <= r && t <= y1 && y2 <= b );
2902                 case "intersect":
2903                         return ( l < x1 + ( draggable.helperProportions.width / 2 ) && // Right Half
2904                                 x2 - ( draggable.helperProportions.width / 2 ) < r && // Left Half
2905                                 t < y1 + ( draggable.helperProportions.height / 2 ) && // Bottom Half
2906                                 y2 - ( draggable.helperProportions.height / 2 ) < b ); // Top Half
2907                 case "pointer":
2908                         return isOverAxis( event.pageY, t, droppable.proportions().height ) && isOverAxis( event.pageX, l, droppable.proportions().width );
2909                 case "touch":
2910                         return (
2911                                 ( y1 >= t && y1 <= b ) || // Top edge touching
2912                                 ( y2 >= t && y2 <= b ) || // Bottom edge touching
2913                                 ( y1 < t && y2 > b ) // Surrounded vertically
2914                         ) && (
2915                                 ( x1 >= l && x1 <= r ) || // Left edge touching
2916                                 ( x2 >= l && x2 <= r ) || // Right edge touching
2917                                 ( x1 < l && x2 > r ) // Surrounded horizontally
2918                         );
2919                 default:
2920                         return false;
2921                 }
2922         };
2923 })();
2924
2925 /*
2926         This manager tracks offsets of draggables and droppables
2927 */
2928 $.ui.ddmanager = {
2929         current: null,
2930         droppables: { "default": [] },
2931         prepareOffsets: function( t, event ) {
2932
2933                 var i, j,
2934                         m = $.ui.ddmanager.droppables[ t.options.scope ] || [],
2935                         type = event ? event.type : null, // workaround for #2317
2936                         list = ( t.currentItem || t.element ).find( ":data(ui-droppable)" ).addBack();
2937
2938                 droppablesLoop: for ( i = 0; i < m.length; i++ ) {
2939
2940                         // No disabled and non-accepted
2941                         if ( m[ i ].options.disabled || ( t && !m[ i ].accept.call( m[ i ].element[ 0 ], ( t.currentItem || t.element ) ) ) ) {
2942                                 continue;
2943                         }
2944
2945                         // Filter out elements in the current dragged item
2946                         for ( j = 0; j < list.length; j++ ) {
2947                                 if ( list[ j ] === m[ i ].element[ 0 ] ) {
2948                                         m[ i ].proportions().height = 0;
2949                                         continue droppablesLoop;
2950                                 }
2951                         }
2952
2953                         m[ i ].visible = m[ i ].element.css( "display" ) !== "none";
2954                         if ( !m[ i ].visible ) {
2955                                 continue;
2956                         }
2957
2958                         // Activate the droppable if used directly from draggables
2959                         if ( type === "mousedown" ) {
2960                                 m[ i ]._activate.call( m[ i ], event );
2961                         }
2962
2963                         m[ i ].offset = m[ i ].element.offset();
2964                         m[ i ].proportions({ width: m[ i ].element[ 0 ].offsetWidth, height: m[ i ].element[ 0 ].offsetHeight });
2965
2966                 }
2967
2968         },
2969         drop: function( draggable, event ) {
2970
2971                 var dropped = false;
2972                 // Create a copy of the droppables in case the list changes during the drop (#9116)
2973                 $.each( ( $.ui.ddmanager.droppables[ draggable.options.scope ] || [] ).slice(), function() {
2974
2975                         if ( !this.options ) {
2976                                 return;
2977                         }
2978                         if ( !this.options.disabled && this.visible && $.ui.intersect( draggable, this, this.options.tolerance, event ) ) {
2979                                 dropped = this._drop.call( this, event ) || dropped;
2980                         }
2981
2982                         if ( !this.options.disabled && this.visible && this.accept.call( this.element[ 0 ], ( draggable.currentItem || draggable.element ) ) ) {
2983                                 this.isout = true;
2984                                 this.isover = false;
2985                                 this._deactivate.call( this, event );
2986                         }
2987
2988                 });
2989                 return dropped;
2990
2991         },
2992         dragStart: function( draggable, event ) {
2993                 // Listen for scrolling so that if the dragging causes scrolling the position of the droppables can be recalculated (see #5003)
2994                 draggable.element.parentsUntil( "body" ).bind( "scroll.droppable", function() {
2995                         if ( !draggable.options.refreshPositions ) {
2996                                 $.ui.ddmanager.prepareOffsets( draggable, event );
2997                         }
2998                 });
2999         },
3000         drag: function( draggable, event ) {
3001
3002                 // If you have a highly dynamic page, you might try this option. It renders positions every time you move the mouse.
3003                 if ( draggable.options.refreshPositions ) {
3004                         $.ui.ddmanager.prepareOffsets( draggable, event );
3005                 }
3006
3007                 // Run through all droppables and check their positions based on specific tolerance options
3008                 $.each( $.ui.ddmanager.droppables[ draggable.options.scope ] || [], function() {
3009
3010                         if ( this.options.disabled || this.greedyChild || !this.visible ) {
3011                                 return;
3012                         }
3013
3014                         var parentInstance, scope, parent,
3015                                 intersects = $.ui.intersect( draggable, this, this.options.tolerance, event ),
3016                                 c = !intersects && this.isover ? "isout" : ( intersects && !this.isover ? "isover" : null );
3017                         if ( !c ) {
3018                                 return;
3019                         }
3020
3021                         if ( this.options.greedy ) {
3022                                 // find droppable parents with same scope
3023                                 scope = this.options.scope;
3024                                 parent = this.element.parents( ":data(ui-droppable)" ).filter(function() {
3025                                         return $( this ).droppable( "instance" ).options.scope === scope;
3026                                 });
3027
3028                                 if ( parent.length ) {
3029                                         parentInstance = $( parent[ 0 ] ).droppable( "instance" );
3030                                         parentInstance.greedyChild = ( c === "isover" );
3031                                 }
3032                         }
3033
3034                         // we just moved into a greedy child
3035                         if ( parentInstance && c === "isover" ) {
3036                                 parentInstance.isover = false;
3037                                 parentInstance.isout = true;
3038                                 parentInstance._out.call( parentInstance, event );
3039                         }
3040
3041                         this[ c ] = true;
3042                         this[c === "isout" ? "isover" : "isout"] = false;
3043                         this[c === "isover" ? "_over" : "_out"].call( this, event );
3044
3045                         // we just moved out of a greedy child
3046                         if ( parentInstance && c === "isout" ) {
3047                                 parentInstance.isout = false;
3048                                 parentInstance.isover = true;
3049                                 parentInstance._over.call( parentInstance, event );
3050                         }
3051                 });
3052
3053         },
3054         dragStop: function( draggable, event ) {
3055                 draggable.element.parentsUntil( "body" ).unbind( "scroll.droppable" );
3056                 // Call prepareOffsets one final time since IE does not fire return scroll events when overflow was caused by drag (see #5003)
3057                 if ( !draggable.options.refreshPositions ) {
3058                         $.ui.ddmanager.prepareOffsets( draggable, event );
3059                 }
3060         }
3061 };
3062
3063 var droppable = $.ui.droppable;
3064
3065
3066 /*!
3067  * jQuery UI Sortable 1.11.4
3068  * http://jqueryui.com
3069  *
3070  * Copyright jQuery Foundation and other contributors
3071  * Released under the MIT license.
3072  * http://jquery.org/license
3073  *
3074  * http://api.jqueryui.com/sortable/
3075  */
3076
3077
3078 var sortable = $.widget("ui.sortable", $.ui.mouse, {
3079         version: "1.11.4",
3080         widgetEventPrefix: "sort",
3081         ready: false,
3082         options: {
3083                 appendTo: "parent",
3084                 axis: false,
3085                 connectWith: false,
3086                 containment: false,
3087                 cursor: "auto",
3088                 cursorAt: false,
3089                 dropOnEmpty: true,
3090                 forcePlaceholderSize: false,
3091                 forceHelperSize: false,
3092                 grid: false,
3093                 handle: false,
3094                 helper: "original",
3095                 items: "> *",
3096                 opacity: false,
3097                 placeholder: false,
3098                 revert: false,
3099                 scroll: true,
3100                 scrollSensitivity: 20,
3101                 scrollSpeed: 20,
3102                 scope: "default",
3103                 tolerance: "intersect",
3104                 zIndex: 1000,
3105
3106                 // callbacks
3107                 activate: null,
3108                 beforeStop: null,
3109                 change: null,
3110                 deactivate: null,
3111                 out: null,
3112                 over: null,
3113                 receive: null,
3114                 remove: null,
3115                 sort: null,
3116                 start: null,
3117                 stop: null,
3118                 update: null
3119         },
3120
3121         _isOverAxis: function( x, reference, size ) {
3122                 return ( x >= reference ) && ( x < ( reference + size ) );
3123         },
3124
3125         _isFloating: function( item ) {
3126                 return (/left|right/).test(item.css("float")) || (/inline|table-cell/).test(item.css("display"));
3127         },
3128
3129         _create: function() {
3130                 this.containerCache = {};
3131                 this.element.addClass("ui-sortable");
3132
3133                 //Get the items
3134                 this.refresh();
3135
3136                 //Let's determine the parent's offset
3137                 this.offset = this.element.offset();
3138
3139                 //Initialize mouse events for interaction
3140                 this._mouseInit();
3141
3142                 this._setHandleClassName();
3143
3144                 //We're ready to go
3145                 this.ready = true;
3146
3147         },
3148
3149         _setOption: function( key, value ) {
3150                 this._super( key, value );
3151
3152                 if ( key === "handle" ) {
3153                         this._setHandleClassName();
3154                 }
3155         },
3156
3157         _setHandleClassName: function() {
3158                 this.element.find( ".ui-sortable-handle" ).removeClass( "ui-sortable-handle" );
3159                 $.each( this.items, function() {
3160                         ( this.instance.options.handle ?
3161                                 this.item.find( this.instance.options.handle ) : this.item )
3162                                 .addClass( "ui-sortable-handle" );
3163                 });
3164         },
3165
3166         _destroy: function() {
3167                 this.element
3168                         .removeClass( "ui-sortable ui-sortable-disabled" )
3169                         .find( ".ui-sortable-handle" )
3170                                 .removeClass( "ui-sortable-handle" );
3171                 this._mouseDestroy();
3172
3173                 for ( var i = this.items.length - 1; i >= 0; i-- ) {
3174                         this.items[i].item.removeData(this.widgetName + "-item");
3175                 }
3176
3177                 return this;
3178         },
3179
3180         _mouseCapture: function(event, overrideHandle) {
3181                 var currentItem = null,
3182                         validHandle = false,
3183                         that = this;
3184
3185                 if (this.reverting) {
3186                         return false;
3187                 }
3188
3189                 if(this.options.disabled || this.options.type === "static") {
3190                         return false;
3191                 }
3192
3193                 //We have to refresh the items data once first
3194                 this._refreshItems(event);
3195
3196                 //Find out if the clicked node (or one of its parents) is a actual item in this.items
3197                 $(event.target).parents().each(function() {
3198                         if($.data(this, that.widgetName + "-item") === that) {
3199                                 currentItem = $(this);
3200                                 return false;
3201                         }
3202                 });
3203                 if($.data(event.target, that.widgetName + "-item") === that) {
3204                         currentItem = $(event.target);
3205                 }
3206
3207                 if(!currentItem) {
3208                         return false;
3209                 }
3210                 if(this.options.handle && !overrideHandle) {
3211                         $(this.options.handle, currentItem).find("*").addBack().each(function() {
3212                                 if(this === event.target) {
3213                                         validHandle = true;
3214                                 }
3215                         });
3216                         if(!validHandle) {
3217                                 return false;
3218                         }
3219                 }
3220
3221                 this.currentItem = currentItem;
3222                 this._removeCurrentsFromItems();
3223                 return true;
3224
3225         },
3226
3227         _mouseStart: function(event, overrideHandle, noActivation) {
3228
3229                 var i, body,
3230                         o = this.options;
3231
3232                 this.currentContainer = this;
3233
3234                 //We only need to call refreshPositions, because the refreshItems call has been moved to mouseCapture
3235                 this.refreshPositions();
3236
3237                 //Create and append the visible helper
3238                 this.helper = this._createHelper(event);
3239
3240                 //Cache the helper size
3241                 this._cacheHelperProportions();
3242
3243                 /*
3244                  * - Position generation -
3245                  * This block generates everything position related - it's the core of draggables.
3246                  */
3247
3248                 //Cache the margins of the original element
3249                 this._cacheMargins();
3250
3251                 //Get the next scrolling parent
3252                 this.scrollParent = this.helper.scrollParent();
3253
3254                 //The element's absolute position on the page minus margins
3255                 this.offset = this.currentItem.offset();
3256                 this.offset = {
3257                         top: this.offset.top - this.margins.top,
3258                         left: this.offset.left - this.margins.left
3259                 };
3260
3261                 $.extend(this.offset, {
3262                         click: { //Where the click happened, relative to the element
3263                                 left: event.pageX - this.offset.left,
3264                                 top: event.pageY - this.offset.top
3265                         },
3266                         parent: this._getParentOffset(),
3267                         relative: this._getRelativeOffset() //This is a relative to absolute position minus the actual position calculation - only used for relative positioned helper
3268                 });
3269
3270                 // Only after we got the offset, we can change the helper's position to absolute
3271                 // TODO: Still need to figure out a way to make relative sorting possible
3272                 this.helper.css("position", "absolute");
3273                 this.cssPosition = this.helper.css("position");
3274
3275                 //Generate the original position
3276                 this.originalPosition = this._generatePosition(event);
3277                 this.originalPageX = event.pageX;
3278                 this.originalPageY = event.pageY;
3279
3280                 //Adjust the mouse offset relative to the helper if "cursorAt" is supplied
3281                 (o.cursorAt && this._adjustOffsetFromHelper(o.cursorAt));
3282
3283                 //Cache the former DOM position
3284                 this.domPosition = { prev: this.currentItem.prev()[0], parent: this.currentItem.parent()[0] };
3285
3286                 //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
3287                 if(this.helper[0] !== this.currentItem[0]) {
3288                         this.currentItem.hide();
3289                 }
3290
3291                 //Create the placeholder
3292                 this._createPlaceholder();
3293
3294                 //Set a containment if given in the options
3295                 if(o.containment) {
3296                         this._setContainment();
3297                 }
3298
3299                 if( o.cursor && o.cursor !== "auto" ) { // cursor option
3300                         body = this.document.find( "body" );
3301
3302                         // support: IE
3303                         this.storedCursor = body.css( "cursor" );
3304                         body.css( "cursor", o.cursor );
3305
3306                         this.storedStylesheet = $( "<style>*{ cursor: "+o.cursor+" !important; }</style>" ).appendTo( body );
3307                 }
3308
3309                 if(o.opacity) { // opacity option
3310                         if (this.helper.css("opacity")) {
3311                                 this._storedOpacity = this.helper.css("opacity");
3312                         }
3313                         this.helper.css("opacity", o.opacity);
3314                 }
3315
3316                 if(o.zIndex) { // zIndex option
3317                         if (this.helper.css("zIndex")) {
3318                                 this._storedZIndex = this.helper.css("zIndex");
3319                         }
3320                         this.helper.css("zIndex", o.zIndex);
3321                 }
3322
3323                 //Prepare scrolling
3324                 if(this.scrollParent[0] !== this.document[0] && this.scrollParent[0].tagName !== "HTML") {
3325                         this.overflowOffset = this.scrollParent.offset();
3326                 }
3327
3328                 //Call callbacks
3329                 this._trigger("start", event, this._uiHash());
3330
3331                 //Recache the helper size
3332                 if(!this._preserveHelperProportions) {
3333                         this._cacheHelperProportions();
3334                 }
3335
3336
3337                 //Post "activate" events to possible containers
3338                 if( !noActivation ) {
3339                         for ( i = this.containers.length - 1; i >= 0; i-- ) {
3340                                 this.containers[ i ]._trigger( "activate", event, this._uiHash( this ) );
3341                         }
3342                 }
3343
3344                 //Prepare possible droppables
3345                 if($.ui.ddmanager) {
3346                         $.ui.ddmanager.current = this;
3347                 }
3348
3349                 if ($.ui.ddmanager && !o.dropBehaviour) {
3350                         $.ui.ddmanager.prepareOffsets(this, event);
3351                 }
3352
3353                 this.dragging = true;
3354
3355                 this.helper.addClass("ui-sortable-helper");
3356                 this._mouseDrag(event); //Execute the drag once - this causes the helper not to be visible before getting its correct position
3357                 return true;
3358
3359         },
3360
3361         _mouseDrag: function(event) {
3362                 var i, item, itemElement, intersection,
3363                         o = this.options,
3364                         scrolled = false;
3365
3366                 //Compute the helpers position
3367                 this.position = this._generatePosition(event);
3368                 this.positionAbs = this._convertPositionTo("absolute");
3369
3370                 if (!this.lastPositionAbs) {
3371                         this.lastPositionAbs = this.positionAbs;
3372                 }
3373
3374                 //Do scrolling
3375                 if(this.options.scroll) {
3376                         if(this.scrollParent[0] !== this.document[0] && this.scrollParent[0].tagName !== "HTML") {
3377
3378                                 if((this.overflowOffset.top + this.scrollParent[0].offsetHeight) - event.pageY < o.scrollSensitivity) {
3379                                         this.scrollParent[0].scrollTop = scrolled = this.scrollParent[0].scrollTop + o.scrollSpeed;
3380                                 } else if(event.pageY - this.overflowOffset.top < o.scrollSensitivity) {
3381                                         this.scrollParent[0].scrollTop = scrolled = this.scrollParent[0].scrollTop - o.scrollSpeed;
3382                                 }
3383
3384                                 if((this.overflowOffset.left + this.scrollParent[0].offsetWidth) - event.pageX < o.scrollSensitivity) {
3385                                         this.scrollParent[0].scrollLeft = scrolled = this.scrollParent[0].scrollLeft + o.scrollSpeed;
3386                                 } else if(event.pageX - this.overflowOffset.left < o.scrollSensitivity) {
3387                                         this.scrollParent[0].scrollLeft = scrolled = this.scrollParent[0].scrollLeft - o.scrollSpeed;
3388                                 }
3389
3390                         } else {
3391
3392                                 if(event.pageY - this.document.scrollTop() < o.scrollSensitivity) {
3393                                         scrolled = this.document.scrollTop(this.document.scrollTop() - o.scrollSpeed);
3394                                 } else if(this.window.height() - (event.pageY - this.document.scrollTop()) < o.scrollSensitivity) {
3395                                         scrolled = this.document.scrollTop(this.document.scrollTop() + o.scrollSpeed);
3396                                 }
3397
3398                                 if(event.pageX - this.document.scrollLeft() < o.scrollSensitivity) {
3399                                         scrolled = this.document.scrollLeft(this.document.scrollLeft() - o.scrollSpeed);
3400                                 } else if(this.window.width() - (event.pageX - this.document.scrollLeft()) < o.scrollSensitivity) {
3401                                         scrolled = this.document.scrollLeft(this.document.scrollLeft() + o.scrollSpeed);
3402                                 }
3403
3404                         }
3405
3406                         if(scrolled !== false && $.ui.ddmanager && !o.dropBehaviour) {
3407                                 $.ui.ddmanager.prepareOffsets(this, event);
3408                         }
3409                 }
3410
3411                 //Regenerate the absolute position used for position checks
3412                 this.positionAbs = this._convertPositionTo("absolute");
3413
3414                 //Set the helper position
3415                 if(!this.options.axis || this.options.axis !== "y") {
3416                         this.helper[0].style.left = this.position.left+"px";
3417                 }
3418                 if(!this.options.axis || this.options.axis !== "x") {
3419                         this.helper[0].style.top = this.position.top+"px";
3420                 }
3421
3422                 //Rearrange
3423                 for (i = this.items.length - 1; i >= 0; i--) {
3424
3425                         //Cache variables and intersection, continue if no intersection
3426                         item = this.items[i];
3427                         itemElement = item.item[0];
3428                         intersection = this._intersectsWithPointer(item);
3429                         if (!intersection) {
3430                                 continue;
3431                         }
3432
3433                         // Only put the placeholder inside the current Container, skip all
3434                         // items from other containers. This works because when moving
3435                         // an item from one container to another the
3436                         // currentContainer is switched before the placeholder is moved.
3437                         //
3438                         // Without this, moving items in "sub-sortables" can cause
3439                         // the placeholder to jitter between the outer and inner container.
3440                         if (item.instance !== this.currentContainer) {
3441                                 continue;
3442                         }
3443
3444                         // cannot intersect with itself
3445                         // no useless actions that have been done before
3446                         // no action if the item moved is the parent of the item checked
3447                         if (itemElement !== this.currentItem[0] &&
3448                                 this.placeholder[intersection === 1 ? "next" : "prev"]()[0] !== itemElement &&
3449                                 !$.contains(this.placeholder[0], itemElement) &&
3450                                 (this.options.type === "semi-dynamic" ? !$.contains(this.element[0], itemElement) : true)
3451                         ) {
3452
3453                                 this.direction = intersection === 1 ? "down" : "up";
3454
3455                                 if (this.options.tolerance === "pointer" || this._intersectsWithSides(item)) {
3456                                         this._rearrange(event, item);
3457                                 } else {
3458                                         break;
3459                                 }
3460
3461                                 this._trigger("change", event, this._uiHash());
3462                                 break;
3463                         }
3464                 }
3465
3466                 //Post events to containers
3467                 this._contactContainers(event);
3468
3469                 //Interconnect with droppables
3470                 if($.ui.ddmanager) {
3471                         $.ui.ddmanager.drag(this, event);
3472                 }
3473
3474                 //Call callbacks
3475                 this._trigger("sort", event, this._uiHash());
3476
3477                 this.lastPositionAbs = this.positionAbs;
3478                 return false;
3479
3480         },
3481
3482         _mouseStop: function(event, noPropagation) {
3483
3484                 if(!event) {
3485                         return;
3486                 }
3487
3488                 //If we are using droppables, inform the manager about the drop
3489                 if ($.ui.ddmanager && !this.options.dropBehaviour) {
3490                         $.ui.ddmanager.drop(this, event);
3491                 }
3492
3493                 if(this.options.revert) {
3494                         var that = this,
3495                                 cur = this.placeholder.offset(),
3496                                 axis = this.options.axis,
3497                                 animation = {};
3498
3499                         if ( !axis || axis === "x" ) {
3500                                 animation.left = cur.left - this.offset.parent.left - this.margins.left + (this.offsetParent[0] === this.document[0].body ? 0 : this.offsetParent[0].scrollLeft);
3501                         }
3502                         if ( !axis || axis === "y" ) {
3503                                 animation.top = cur.top - this.offset.parent.top - this.margins.top + (this.offsetParent[0] === this.document[0].body ? 0 : this.offsetParent[0].scrollTop);
3504                         }
3505                         this.reverting = true;
3506                         $(this.helper).animate( animation, parseInt(this.options.revert, 10) || 500, function() {
3507                                 that._clear(event);
3508                         });
3509                 } else {
3510                         this._clear(event, noPropagation);
3511                 }
3512
3513                 return false;
3514
3515         },
3516
3517         cancel: function() {
3518
3519                 if(this.dragging) {
3520
3521                         this._mouseUp({ target: null });
3522
3523                         if(this.options.helper === "original") {
3524                                 this.currentItem.css(this._storedCSS).removeClass("ui-sortable-helper");
3525                         } else {
3526                                 this.currentItem.show();
3527                         }
3528
3529                         //Post deactivating events to containers
3530                         for (var i = this.containers.length - 1; i >= 0; i--){
3531                                 this.containers[i]._trigger("deactivate", null, this._uiHash(this));
3532                                 if(this.containers[i].containerCache.over) {
3533                                         this.containers[i]._trigger("out", null, this._uiHash(this));
3534                                         this.containers[i].containerCache.over = 0;
3535                                 }
3536                         }
3537
3538                 }
3539
3540                 if (this.placeholder) {
3541                         //$(this.placeholder[0]).remove(); would have been the jQuery way - unfortunately, it unbinds ALL events from the original node!
3542                         if(this.placeholder[0].parentNode) {
3543                                 this.placeholder[0].parentNode.removeChild(this.placeholder[0]);
3544                         }
3545                         if(this.options.helper !== "original" && this.helper && this.helper[0].parentNode) {
3546                                 this.helper.remove();
3547                         }
3548
3549                         $.extend(this, {
3550                                 helper: null,
3551                                 dragging: false,
3552                                 reverting: false,
3553                                 _noFinalSort: null
3554                         });
3555
3556                         if(this.domPosition.prev) {
3557                                 $(this.domPosition.prev).after(this.currentItem);
3558                         } else {
3559                                 $(this.domPosition.parent).prepend(this.currentItem);
3560                         }
3561                 }
3562
3563                 return this;
3564
3565         },
3566
3567         serialize: function(o) {
3568
3569                 var items = this._getItemsAsjQuery(o && o.connected),
3570                         str = [];
3571                 o = o || {};
3572
3573                 $(items).each(function() {
3574                         var res = ($(o.item || this).attr(o.attribute || "id") || "").match(o.expression || (/(.+)[\-=_](.+)/));
3575                         if (res) {
3576                                 str.push((o.key || res[1]+"[]")+"="+(o.key && o.expression ? res[1] : res[2]));
3577                         }
3578                 });
3579
3580                 if(!str.length && o.key) {
3581                         str.push(o.key + "=");
3582                 }
3583
3584                 return str.join("&");
3585
3586         },
3587
3588         toArray: function(o) {
3589
3590                 var items = this._getItemsAsjQuery(o && o.connected),
3591                         ret = [];
3592
3593                 o = o || {};
3594
3595                 items.each(function() { ret.push($(o.item || this).attr(o.attribute || "id") || ""); });
3596                 return ret;
3597
3598         },
3599
3600         /* Be careful with the following core functions */
3601         _intersectsWith: function(item) {
3602
3603                 var x1 = this.positionAbs.left,
3604                         x2 = x1 + this.helperProportions.width,
3605                         y1 = this.positionAbs.top,
3606                         y2 = y1 + this.helperProportions.height,
3607                         l = item.left,
3608                         r = l + item.width,
3609                         t = item.top,
3610                         b = t + item.height,
3611                         dyClick = this.offset.click.top,
3612                         dxClick = this.offset.click.left,
3613                         isOverElementHeight = ( this.options.axis === "x" ) || ( ( y1 + dyClick ) > t && ( y1 + dyClick ) < b ),
3614                         isOverElementWidth = ( this.options.axis === "y" ) || ( ( x1 + dxClick ) > l && ( x1 + dxClick ) < r ),
3615                         isOverElement = isOverElementHeight && isOverElementWidth;
3616
3617                 if ( this.options.tolerance === "pointer" ||
3618                         this.options.forcePointerForContainers ||
3619                         (this.options.tolerance !== "pointer" && this.helperProportions[this.floating ? "width" : "height"] > item[this.floating ? "width" : "height"])
3620                 ) {
3621                         return isOverElement;
3622                 } else {
3623
3624                         return (l < x1 + (this.helperProportions.width / 2) && // Right Half
3625                                 x2 - (this.helperProportions.width / 2) < r && // Left Half
3626                                 t < y1 + (this.helperProportions.height / 2) && // Bottom Half
3627                                 y2 - (this.helperProportions.height / 2) < b ); // Top Half
3628
3629                 }
3630         },
3631
3632         _intersectsWithPointer: function(item) {
3633
3634                 var isOverElementHeight = (this.options.axis === "x") || this._isOverAxis(this.positionAbs.top + this.offset.click.top, item.top, item.height),
3635                         isOverElementWidth = (this.options.axis === "y") || this._isOverAxis(this.positionAbs.left + this.offset.click.left, item.left, item.width),
3636                         isOverElement = isOverElementHeight && isOverElementWidth,
3637                         verticalDirection = this._getDragVerticalDirection(),
3638                         horizontalDirection = this._getDragHorizontalDirection();
3639
3640                 if (!isOverElement) {
3641                         return false;
3642                 }
3643
3644                 return this.floating ?
3645                         ( ((horizontalDirection && horizontalDirection === "right") || verticalDirection === "down") ? 2 : 1 )
3646                         : ( verticalDirection && (verticalDirection === "down" ? 2 : 1) );
3647
3648         },
3649
3650         _intersectsWithSides: function(item) {
3651
3652                 var isOverBottomHalf = this._isOverAxis(this.positionAbs.top + this.offset.click.top, item.top + (item.height/2), item.height),
3653                         isOverRightHalf = this._isOverAxis(this.positionAbs.left + this.offset.click.left, item.left + (item.width/2), item.width),
3654                         verticalDirection = this._getDragVerticalDirection(),
3655                         horizontalDirection = this._getDragHorizontalDirection();
3656
3657                 if (this.floating && horizontalDirection) {
3658                         return ((horizontalDirection === "right" && isOverRightHalf) || (horizontalDirection === "left" && !isOverRightHalf));
3659                 } else {
3660                         return verticalDirection && ((verticalDirection === "down" && isOverBottomHalf) || (verticalDirection === "up" && !isOverBottomHalf));
3661                 }
3662
3663         },
3664
3665         _getDragVerticalDirection: function() {
3666                 var delta = this.positionAbs.top - this.lastPositionAbs.top;
3667                 return delta !== 0 && (delta > 0 ? "down" : "up");
3668         },
3669
3670         _getDragHorizontalDirection: function() {
3671                 var delta = this.positionAbs.left - this.lastPositionAbs.left;
3672                 return delta !== 0 && (delta > 0 ? "right" : "left");
3673         },
3674
3675         refresh: function(event) {
3676                 this._refreshItems(event);
3677                 this._setHandleClassName();
3678                 this.refreshPositions();
3679                 return this;
3680         },
3681
3682         _connectWith: function() {
3683                 var options = this.options;
3684                 return options.connectWith.constructor === String ? [options.connectWith] : options.connectWith;
3685         },
3686
3687         _getItemsAsjQuery: function(connected) {
3688
3689                 var i, j, cur, inst,
3690                         items = [],
3691                         queries = [],
3692                         connectWith = this._connectWith();
3693
3694                 if(connectWith && connected) {
3695                         for (i = connectWith.length - 1; i >= 0; i--){
3696                                 cur = $(connectWith[i], this.document[0]);
3697                                 for ( j = cur.length - 1; j >= 0; j--){
3698                                         inst = $.data(cur[j], this.widgetFullName);
3699                                         if(inst && inst !== this && !inst.options.disabled) {
3700                                                 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]);
3701                                         }
3702                                 }
3703                         }
3704                 }
3705
3706                 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]);
3707
3708                 function addItems() {
3709                         items.push( this );
3710                 }
3711                 for (i = queries.length - 1; i >= 0; i--){
3712                         queries[i][0].each( addItems );
3713                 }
3714
3715                 return $(items);
3716
3717         },
3718
3719         _removeCurrentsFromItems: function() {
3720
3721                 var list = this.currentItem.find(":data(" + this.widgetName + "-item)");
3722
3723                 this.items = $.grep(this.items, function (item) {
3724                         for (var j=0; j < list.length; j++) {
3725                                 if(list[j] === item.item[0]) {
3726                                         return false;
3727                                 }
3728                         }
3729                         return true;
3730                 });
3731
3732         },
3733
3734         _refreshItems: function(event) {
3735
3736                 this.items = [];
3737                 this.containers = [this];
3738
3739                 var i, j, cur, inst, targetData, _queries, item, queriesLength,
3740                         items = this.items,
3741                         queries = [[$.isFunction(this.options.items) ? this.options.items.call(this.element[0], event, { item: this.currentItem }) : $(this.options.items, this.element), this]],
3742                         connectWith = this._connectWith();
3743
3744                 if(connectWith && this.ready) { //Shouldn't be run the first time through due to massive slow-down
3745                         for (i = connectWith.length - 1; i >= 0; i--){
3746                                 cur = $(connectWith[i], this.document[0]);
3747                                 for (j = cur.length - 1; j >= 0; j--){
3748                                         inst = $.data(cur[j], this.widgetFullName);
3749                                         if(inst && inst !== this && !inst.options.disabled) {
3750                                                 queries.push([$.isFunction(inst.options.items) ? inst.options.items.call(inst.element[0], event, { item: this.currentItem }) : $(inst.options.items, inst.element), inst]);
3751                                                 this.containers.push(inst);
3752                                         }
3753                                 }
3754                         }
3755                 }
3756
3757                 for (i = queries.length - 1; i >= 0; i--) {
3758                         targetData = queries[i][1];
3759                         _queries = queries[i][0];
3760
3761                         for (j=0, queriesLength = _queries.length; j < queriesLength; j++) {
3762                                 item = $(_queries[j]);
3763
3764                                 item.data(this.widgetName + "-item", targetData); // Data for target checking (mouse manager)
3765
3766                                 items.push({
3767                                         item: item,
3768                                         instance: targetData,
3769                                         width: 0, height: 0,
3770                                         left: 0, top: 0
3771                                 });
3772                         }
3773                 }
3774
3775         },
3776
3777         refreshPositions: function(fast) {
3778
3779                 // Determine whether items are being displayed horizontally
3780                 this.floating = this.items.length ?
3781                         this.options.axis === "x" || this._isFloating( this.items[ 0 ].item ) :
3782                         false;
3783
3784                 //This has to be redone because due to the item being moved out/into the offsetParent, the offsetParent's position will change
3785                 if(this.offsetParent && this.helper) {
3786                         this.offset.parent = this._getParentOffset();
3787                 }
3788
3789                 var i, item, t, p;
3790
3791                 for (i = this.items.length - 1; i >= 0; i--){
3792                         item = this.items[i];
3793
3794                         //We ignore calculating positions of all connected containers when we're not over them
3795                         if(item.instance !== this.currentContainer && this.currentContainer && item.item[0] !== this.currentItem[0]) {
3796                                 continue;
3797                         }
3798
3799                         t = this.options.toleranceElement ? $(this.options.toleranceElement, item.item) : item.item;
3800
3801                         if (!fast) {
3802                                 item.width = t.outerWidth();
3803                                 item.height = t.outerHeight();
3804                         }
3805
3806                         p = t.offset();
3807                         item.left = p.left;
3808                         item.top = p.top;
3809                 }
3810
3811                 if(this.options.custom && this.options.custom.refreshContainers) {
3812                         this.options.custom.refreshContainers.call(this);
3813                 } else {
3814                         for (i = this.containers.length - 1; i >= 0; i--){
3815                                 p = this.containers[i].element.offset();
3816                                 this.containers[i].containerCache.left = p.left;
3817                                 this.containers[i].containerCache.top = p.top;
3818                                 this.containers[i].containerCache.width = this.containers[i].element.outerWidth();
3819                                 this.containers[i].containerCache.height = this.containers[i].element.outerHeight();
3820                         }
3821                 }
3822
3823                 return this;
3824         },
3825
3826         _createPlaceholder: function(that) {
3827                 that = that || this;
3828                 var className,
3829                         o = that.options;
3830
3831                 if(!o.placeholder || o.placeholder.constructor === String) {
3832                         className = o.placeholder;
3833                         o.placeholder = {
3834                                 element: function() {
3835
3836                                         var nodeName = that.currentItem[0].nodeName.toLowerCase(),
3837                                                 element = $( "<" + nodeName + ">", that.document[0] )
3838                                                         .addClass(className || that.currentItem[0].className+" ui-sortable-placeholder")
3839                                                         .removeClass("ui-sortable-helper");
3840
3841                                         if ( nodeName === "tbody" ) {
3842                                                 that._createTrPlaceholder(
3843                                                         that.currentItem.find( "tr" ).eq( 0 ),
3844                                                         $( "<tr>", that.document[ 0 ] ).appendTo( element )
3845                                                 );
3846                                         } else if ( nodeName === "tr" ) {
3847                                                 that._createTrPlaceholder( that.currentItem, element );
3848                                         } else if ( nodeName === "img" ) {
3849                                                 element.attr( "src", that.currentItem.attr( "src" ) );
3850                                         }
3851
3852                                         if ( !className ) {
3853                                                 element.css( "visibility", "hidden" );
3854                                         }
3855
3856                                         return element;
3857                                 },
3858                                 update: function(container, p) {
3859
3860                                         // 1. If a className is set as 'placeholder option, we don't force sizes - the class is responsible for that
3861                                         // 2. The option 'forcePlaceholderSize can be enabled to force it even if a class name is specified
3862                                         if(className && !o.forcePlaceholderSize) {
3863                                                 return;
3864                                         }
3865
3866                                         //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
3867                                         if(!p.height()) { p.height(that.currentItem.innerHeight() - parseInt(that.currentItem.css("paddingTop")||0, 10) - parseInt(that.currentItem.css("paddingBottom")||0, 10)); }
3868                                         if(!p.width()) { p.width(that.currentItem.innerWidth() - parseInt(that.currentItem.css("paddingLeft")||0, 10) - parseInt(that.currentItem.css("paddingRight")||0, 10)); }
3869                                 }
3870                         };
3871                 }
3872
3873                 //Create the placeholder
3874                 that.placeholder = $(o.placeholder.element.call(that.element, that.currentItem));
3875
3876                 //Append it after the actual current item
3877                 that.currentItem.after(that.placeholder);
3878
3879                 //Update the size of the placeholder (TODO: Logic to fuzzy, see line 316/317)
3880                 o.placeholder.update(that, that.placeholder);
3881
3882         },
3883
3884         _createTrPlaceholder: function( sourceTr, targetTr ) {
3885                 var that = this;
3886
3887                 sourceTr.children().each(function() {
3888                         $( "<td>&#160;</td>", that.document[ 0 ] )
3889                                 .attr( "colspan", $( this ).attr( "colspan" ) || 1 )
3890                                 .appendTo( targetTr );
3891                 });
3892         },
3893
3894         _contactContainers: function(event) {
3895                 var i, j, dist, itemWithLeastDistance, posProperty, sizeProperty, cur, nearBottom, floating, axis,
3896                         innermostContainer = null,
3897                         innermostIndex = null;
3898
3899                 // get innermost container that intersects with item
3900                 for (i = this.containers.length - 1; i >= 0; i--) {
3901
3902                         // never consider a container that's located within the item itself
3903                         if($.contains(this.currentItem[0], this.containers[i].element[0])) {
3904                                 continue;
3905                         }
3906
3907                         if(this._intersectsWith(this.containers[i].containerCache)) {
3908
3909                                 // if we've already found a container and it's more "inner" than this, then continue
3910                                 if(innermostContainer && $.contains(this.containers[i].element[0], innermostContainer.element[0])) {
3911                                         continue;
3912                                 }
3913
3914                                 innermostContainer = this.containers[i];
3915                                 innermostIndex = i;
3916
3917                         } else {
3918                                 // container doesn't intersect. trigger "out" event if necessary
3919                                 if(this.containers[i].containerCache.over) {
3920                                         this.containers[i]._trigger("out", event, this._uiHash(this));
3921                                         this.containers[i].containerCache.over = 0;
3922                                 }
3923                         }
3924
3925                 }
3926
3927                 // if no intersecting containers found, return
3928                 if(!innermostContainer) {
3929                         return;
3930                 }
3931
3932                 // move the item into the container if it's not there already
3933                 if(this.containers.length === 1) {
3934                         if (!this.containers[innermostIndex].containerCache.over) {
3935                                 this.containers[innermostIndex]._trigger("over", event, this._uiHash(this));
3936                                 this.containers[innermostIndex].containerCache.over = 1;
3937                         }
3938                 } else {
3939
3940                         //When entering a new container, we will find the item with the least distance and append our item near it
3941                         dist = 10000;
3942                         itemWithLeastDistance = null;
3943                         floating = innermostContainer.floating || this._isFloating(this.currentItem);
3944                         posProperty = floating ? "left" : "top";
3945                         sizeProperty = floating ? "width" : "height";
3946                         axis = floating ? "clientX" : "clientY";
3947
3948                         for (j = this.items.length - 1; j >= 0; j--) {
3949                                 if(!$.contains(this.containers[innermostIndex].element[0], this.items[j].item[0])) {
3950                                         continue;
3951                                 }
3952                                 if(this.items[j].item[0] === this.currentItem[0]) {
3953                                         continue;
3954                                 }
3955
3956                                 cur = this.items[j].item.offset()[posProperty];
3957                                 nearBottom = false;
3958                                 if ( event[ axis ] - cur > this.items[ j ][ sizeProperty ] / 2 ) {
3959                                         nearBottom = true;
3960                                 }
3961
3962                                 if ( Math.abs( event[ axis ] - cur ) < dist ) {
3963                                         dist = Math.abs( event[ axis ] - cur );
3964                                         itemWithLeastDistance = this.items[ j ];
3965                                         this.direction = nearBottom ? "up": "down";
3966                                 }
3967                         }
3968
3969                         //Check if dropOnEmpty is enabled
3970                         if(!itemWithLeastDistance && !this.options.dropOnEmpty) {
3971                                 return;
3972                         }
3973
3974                         if(this.currentContainer === this.containers[innermostIndex]) {
3975                                 if ( !this.currentContainer.containerCache.over ) {
3976                                         this.containers[ innermostIndex ]._trigger( "over", event, this._uiHash() );
3977                                         this.currentContainer.containerCache.over = 1;
3978                                 }
3979                                 return;
3980                         }
3981
3982                         itemWithLeastDistance ? this._rearrange(event, itemWithLeastDistance, null, true) : this._rearrange(event, null, this.containers[innermostIndex].element, true);
3983                         this._trigger("change", event, this._uiHash());
3984                         this.containers[innermostIndex]._trigger("change", event, this._uiHash(this));
3985                         this.currentContainer = this.containers[innermostIndex];
3986
3987                         //Update the placeholder
3988                         this.options.placeholder.update(this.currentContainer, this.placeholder);
3989
3990                         this.containers[innermostIndex]._trigger("over", event, this._uiHash(this));
3991                         this.containers[innermostIndex].containerCache.over = 1;
3992                 }
3993
3994
3995         },
3996
3997         _createHelper: function(event) {
3998
3999                 var o = this.options,
4000                         helper = $.isFunction(o.helper) ? $(o.helper.apply(this.element[0], [event, this.currentItem])) : (o.helper === "clone" ? this.currentItem.clone() : this.currentItem);
4001
4002                 //Add the helper to the DOM if that didn't happen already
4003                 if(!helper.parents("body").length) {
4004                         $(o.appendTo !== "parent" ? o.appendTo : this.currentItem[0].parentNode)[0].appendChild(helper[0]);
4005                 }
4006
4007                 if(helper[0] === this.currentItem[0]) {
4008                         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") };
4009                 }
4010
4011                 if(!helper[0].style.width || o.forceHelperSize) {
4012                         helper.width(this.currentItem.width());
4013                 }
4014                 if(!helper[0].style.height || o.forceHelperSize) {
4015                         helper.height(this.currentItem.height());
4016                 }
4017
4018                 return helper;
4019
4020         },
4021
4022         _adjustOffsetFromHelper: function(obj) {
4023                 if (typeof obj === "string") {
4024                         obj = obj.split(" ");
4025                 }
4026                 if ($.isArray(obj)) {
4027                         obj = {left: +obj[0], top: +obj[1] || 0};
4028                 }
4029                 if ("left" in obj) {
4030                         this.offset.click.left = obj.left + this.margins.left;
4031                 }
4032                 if ("right" in obj) {
4033                         this.offset.click.left = this.helperProportions.width - obj.right + this.margins.left;
4034                 }
4035                 if ("top" in obj) {
4036                         this.offset.click.top = obj.top + this.margins.top;
4037                 }
4038                 if ("bottom" in obj) {
4039                         this.offset.click.top = this.helperProportions.height - obj.bottom + this.margins.top;
4040                 }
4041         },
4042
4043         _getParentOffset: function() {
4044
4045
4046                 //Get the offsetParent and cache its position
4047                 this.offsetParent = this.helper.offsetParent();
4048                 var po = this.offsetParent.offset();
4049
4050                 // This is a special case where we need to modify a offset calculated on start, since the following happened:
4051                 // 1. The position of the helper is absolute, so it's position is calculated based on the next positioned parent
4052                 // 2. The actual offset parent is a child of the scroll parent, and the scroll parent isn't the document, which means that
4053                 //    the scroll is included in the initial calculation of the offset of the parent, and never recalculated upon drag
4054                 if(this.cssPosition === "absolute" && this.scrollParent[0] !== this.document[0] && $.contains(this.scrollParent[0], this.offsetParent[0])) {
4055                         po.left += this.scrollParent.scrollLeft();
4056                         po.top += this.scrollParent.scrollTop();
4057                 }
4058
4059                 // This needs to be actually done for all browsers, since pageX/pageY includes this information
4060                 // with an ugly IE fix
4061                 if( this.offsetParent[0] === this.document[0].body || (this.offsetParent[0].tagName && this.offsetParent[0].tagName.toLowerCase() === "html" && $.ui.ie)) {
4062                         po = { top: 0, left: 0 };
4063                 }
4064
4065                 return {
4066                         top: po.top + (parseInt(this.offsetParent.css("borderTopWidth"),10) || 0),
4067                         left: po.left + (parseInt(this.offsetParent.css("borderLeftWidth"),10) || 0)
4068                 };
4069
4070         },
4071
4072         _getRelativeOffset: function() {
4073
4074                 if(this.cssPosition === "relative") {
4075                         var p = this.currentItem.position();
4076                         return {
4077                                 top: p.top - (parseInt(this.helper.css("top"),10) || 0) + this.scrollParent.scrollTop(),
4078                                 left: p.left - (parseInt(this.helper.css("left"),10) || 0) + this.scrollParent.scrollLeft()
4079                         };
4080                 } else {
4081                         return { top: 0, left: 0 };
4082                 }
4083
4084         },
4085
4086         _cacheMargins: function() {
4087                 this.margins = {
4088                         left: (parseInt(this.currentItem.css("marginLeft"),10) || 0),
4089                         top: (parseInt(this.currentItem.css("marginTop"),10) || 0)
4090                 };
4091         },
4092
4093         _cacheHelperProportions: function() {
4094                 this.helperProportions = {
4095                         width: this.helper.outerWidth(),
4096                         height: this.helper.outerHeight()
4097                 };
4098         },
4099
4100         _setContainment: function() {
4101
4102                 var ce, co, over,
4103                         o = this.options;
4104                 if(o.containment === "parent") {
4105                         o.containment = this.helper[0].parentNode;
4106                 }
4107                 if(o.containment === "document" || o.containment === "window") {
4108                         this.containment = [
4109                                 0 - this.offset.relative.left - this.offset.parent.left,
4110                                 0 - this.offset.relative.top - this.offset.parent.top,
4111                                 o.containment === "document" ? this.document.width() : this.window.width() - this.helperProportions.width - this.margins.left,
4112                                 (o.containment === "document" ? this.document.width() : this.window.height() || this.document[0].body.parentNode.scrollHeight) - this.helperProportions.height - this.margins.top
4113                         ];
4114                 }
4115
4116                 if(!(/^(document|window|parent)$/).test(o.containment)) {
4117                         ce = $(o.containment)[0];
4118                         co = $(o.containment).offset();
4119                         over = ($(ce).css("overflow") !== "hidden");
4120
4121                         this.containment = [
4122                                 co.left + (parseInt($(ce).css("borderLeftWidth"),10) || 0) + (parseInt($(ce).css("paddingLeft"),10) || 0) - this.margins.left,
4123                                 co.top + (parseInt($(ce).css("borderTopWidth"),10) || 0) + (parseInt($(ce).css("paddingTop"),10) || 0) - this.margins.top,
4124                                 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,
4125                                 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
4126                         ];
4127                 }
4128
4129         },
4130
4131         _convertPositionTo: function(d, pos) {
4132
4133                 if(!pos) {
4134                         pos = this.position;
4135                 }
4136                 var mod = d === "absolute" ? 1 : -1,
4137                         scroll = this.cssPosition === "absolute" && !(this.scrollParent[0] !== this.document[0] && $.contains(this.scrollParent[0], this.offsetParent[0])) ? this.offsetParent : this.scrollParent,
4138                         scrollIsRootNode = (/(html|body)/i).test(scroll[0].tagName);
4139
4140                 return {
4141                         top: (
4142                                 pos.top +                                                                                                                               // The absolute mouse position
4143                                 this.offset.relative.top * mod +                                                                                // Only for relative positioned nodes: Relative offset from element to offset parent
4144                                 this.offset.parent.top * mod -                                                                                  // The offsetParent's offset without borders (offset + border)
4145                                 ( ( this.cssPosition === "fixed" ? -this.scrollParent.scrollTop() : ( scrollIsRootNode ? 0 : scroll.scrollTop() ) ) * mod)
4146                         ),
4147                         left: (
4148                                 pos.left +                                                                                                                              // The absolute mouse position
4149                                 this.offset.relative.left * mod +                                                                               // Only for relative positioned nodes: Relative offset from element to offset parent
4150                                 this.offset.parent.left * mod   -                                                                               // The offsetParent's offset without borders (offset + border)
4151                                 ( ( this.cssPosition === "fixed" ? -this.scrollParent.scrollLeft() : scrollIsRootNode ? 0 : scroll.scrollLeft() ) * mod)
4152                         )
4153                 };
4154
4155         },
4156
4157         _generatePosition: function(event) {
4158
4159                 var top, left,
4160                         o = this.options,
4161                         pageX = event.pageX,
4162                         pageY = event.pageY,
4163                         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);
4164
4165                 // This is another very weird special case that only happens for relative elements:
4166                 // 1. If the css position is relative
4167                 // 2. and the scroll parent is the document or similar to the offset parent
4168                 // we have to refresh the relative offset during the scroll so there are no jumps
4169                 if(this.cssPosition === "relative" && !(this.scrollParent[0] !== this.document[0] && this.scrollParent[0] !== this.offsetParent[0])) {
4170                         this.offset.relative = this._getRelativeOffset();
4171                 }
4172
4173                 /*
4174                  * - Position constraining -
4175                  * Constrain the position to a mix of grid, containment.
4176                  */
4177
4178                 if(this.originalPosition) { //If we are not dragging yet, we won't check for options
4179
4180                         if(this.containment) {
4181                                 if(event.pageX - this.offset.click.left < this.containment[0]) {
4182                                         pageX = this.containment[0] + this.offset.click.left;
4183                                 }
4184                                 if(event.pageY - this.offset.click.top < this.containment[1]) {
4185                                         pageY = this.containment[1] + this.offset.click.top;
4186                                 }
4187                                 if(event.pageX - this.offset.click.left > this.containment[2]) {
4188                                         pageX = this.containment[2] + this.offset.click.left;
4189                                 }
4190                                 if(event.pageY - this.offset.click.top > this.containment[3]) {
4191                                         pageY = this.containment[3] + this.offset.click.top;
4192                                 }
4193                         }
4194
4195                         if(o.grid) {
4196                                 top = this.originalPageY + Math.round((pageY - this.originalPageY) / o.grid[1]) * o.grid[1];
4197                                 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;
4198
4199                                 left = this.originalPageX + Math.round((pageX - this.originalPageX) / o.grid[0]) * o.grid[0];
4200                                 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;
4201                         }
4202
4203                 }
4204
4205                 return {
4206                         top: (
4207                                 pageY -                                                                                                                         // The absolute mouse position
4208                                 this.offset.click.top -                                                                                                 // Click offset (relative to the element)
4209                                 this.offset.relative.top        -                                                                                       // Only for relative positioned nodes: Relative offset from element to offset parent
4210                                 this.offset.parent.top +                                                                                                // The offsetParent's offset without borders (offset + border)
4211                                 ( ( this.cssPosition === "fixed" ? -this.scrollParent.scrollTop() : ( scrollIsRootNode ? 0 : scroll.scrollTop() ) ))
4212                         ),
4213                         left: (
4214                                 pageX -                                                                                                                         // The absolute mouse position
4215                                 this.offset.click.left -                                                                                                // Click offset (relative to the element)
4216                                 this.offset.relative.left       -                                                                                       // Only for relative positioned nodes: Relative offset from element to offset parent
4217                                 this.offset.parent.left +                                                                                               // The offsetParent's offset without borders (offset + border)
4218                                 ( ( this.cssPosition === "fixed" ? -this.scrollParent.scrollLeft() : scrollIsRootNode ? 0 : scroll.scrollLeft() ))
4219                         )
4220                 };
4221
4222         },
4223
4224         _rearrange: function(event, i, a, hardRefresh) {
4225
4226                 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));
4227
4228                 //Various things done here to improve the performance:
4229                 // 1. we create a setTimeout, that calls refreshPositions
4230                 // 2. on the instance, we have a counter variable, that get's higher after every append
4231                 // 3. on the local scope, we copy the counter variable, and check in the timeout, if it's still the same
4232                 // 4. this lets only the last addition to the timeout stack through
4233                 this.counter = this.counter ? ++this.counter : 1;
4234                 var counter = this.counter;
4235
4236                 this._delay(function() {
4237                         if(counter === this.counter) {
4238                                 this.refreshPositions(!hardRefresh); //Precompute after each DOM insertion, NOT on mousemove
4239                         }
4240                 });
4241
4242         },
4243
4244         _clear: function(event, noPropagation) {
4245
4246                 this.reverting = false;
4247                 // We delay all events that have to be triggered to after the point where the placeholder has been removed and
4248                 // everything else normalized again
4249                 var i,
4250                         delayedTriggers = [];
4251
4252                 // We first have to update the dom position of the actual currentItem
4253                 // Note: don't do it if the current item is already removed (by a user), or it gets reappended (see #4088)
4254                 if(!this._noFinalSort && this.currentItem.parent().length) {
4255                         this.placeholder.before(this.currentItem);
4256                 }
4257                 this._noFinalSort = null;
4258
4259                 if(this.helper[0] === this.currentItem[0]) {
4260                         for(i in this._storedCSS) {
4261                                 if(this._storedCSS[i] === "auto" || this._storedCSS[i] === "static") {
4262                                         this._storedCSS[i] = "";
4263                                 }
4264                         }
4265                         this.currentItem.css(this._storedCSS).removeClass("ui-sortable-helper");
4266                 } else {
4267                         this.currentItem.show();
4268                 }
4269
4270                 if(this.fromOutside && !noPropagation) {
4271                         delayedTriggers.push(function(event) { this._trigger("receive", event, this._uiHash(this.fromOutside)); });
4272                 }
4273                 if((this.fromOutside || this.domPosition.prev !== this.currentItem.prev().not(".ui-sortable-helper")[0] || this.domPosition.parent !== this.currentItem.parent()[0]) && !noPropagation) {
4274                         delayedTriggers.push(function(event) { this._trigger("update", event, this._uiHash()); }); //Trigger update callback if the DOM position has changed
4275                 }
4276
4277                 // Check if the items Container has Changed and trigger appropriate
4278                 // events.
4279                 if (this !== this.currentContainer) {
4280                         if(!noPropagation) {
4281                                 delayedTriggers.push(function(event) { this._trigger("remove", event, this._uiHash()); });
4282                                 delayedTriggers.push((function(c) { return function(event) { c._trigger("receive", event, this._uiHash(this)); };  }).call(this, this.currentContainer));
4283                                 delayedTriggers.push((function(c) { return function(event) { c._trigger("update", event, this._uiHash(this));  }; }).call(this, this.currentContainer));
4284                         }
4285                 }
4286
4287
4288                 //Post events to containers
4289                 function delayEvent( type, instance, container ) {
4290                         return function( event ) {
4291                                 container._trigger( type, event, instance._uiHash( instance ) );
4292                         };
4293                 }
4294                 for (i = this.containers.length - 1; i >= 0; i--){
4295                         if (!noPropagation) {
4296                                 delayedTriggers.push( delayEvent( "deactivate", this, this.containers[ i ] ) );
4297                         }
4298                         if(this.containers[i].containerCache.over) {
4299                                 delayedTriggers.push( delayEvent( "out", this, this.containers[ i ] ) );
4300                                 this.containers[i].containerCache.over = 0;
4301                         }
4302                 }
4303
4304                 //Do what was originally in plugins
4305                 if ( this.storedCursor ) {
4306                         this.document.find( "body" ).css( "cursor", this.storedCursor );
4307                         this.storedStylesheet.remove();
4308                 }
4309                 if(this._storedOpacity) {
4310                         this.helper.css("opacity", this._storedOpacity);
4311                 }
4312                 if(this._storedZIndex) {
4313                         this.helper.css("zIndex", this._storedZIndex === "auto" ? "" : this._storedZIndex);
4314                 }
4315
4316                 this.dragging = false;
4317
4318                 if(!noPropagation) {
4319                         this._trigger("beforeStop", event, this._uiHash());
4320                 }
4321
4322                 //$(this.placeholder[0]).remove(); would have been the jQuery way - unfortunately, it unbinds ALL events from the original node!
4323                 this.placeholder[0].parentNode.removeChild(this.placeholder[0]);
4324
4325                 if ( !this.cancelHelperRemoval ) {
4326                         if ( this.helper[ 0 ] !== this.currentItem[ 0 ] ) {
4327                                 this.helper.remove();
4328                         }
4329                         this.helper = null;
4330                 }
4331
4332                 if(!noPropagation) {
4333                         for (i=0; i < delayedTriggers.length; i++) {
4334                                 delayedTriggers[i].call(this, event);
4335                         } //Trigger all delayed events
4336                         this._trigger("stop", event, this._uiHash());
4337                 }
4338
4339                 this.fromOutside = false;
4340                 return !this.cancelHelperRemoval;
4341
4342         },
4343
4344         _trigger: function() {
4345                 if ($.Widget.prototype._trigger.apply(this, arguments) === false) {
4346                         this.cancel();
4347                 }
4348         },
4349
4350         _uiHash: function(_inst) {
4351                 var inst = _inst || this;
4352                 return {
4353                         helper: inst.helper,
4354                         placeholder: inst.placeholder || $([]),
4355                         position: inst.position,
4356                         originalPosition: inst.originalPosition,
4357                         offset: inst.positionAbs,
4358                         item: inst.currentItem,
4359                         sender: _inst ? _inst.element : null
4360                 };
4361         }
4362
4363 });
4364
4365
4366 /*!
4367  * jQuery UI Accordion 1.11.4
4368  * http://jqueryui.com
4369  *
4370  * Copyright jQuery Foundation and other contributors
4371  * Released under the MIT license.
4372  * http://jquery.org/license
4373  *
4374  * http://api.jqueryui.com/accordion/
4375  */
4376
4377
4378 var accordion = $.widget( "ui.accordion", {
4379         version: "1.11.4",
4380         options: {
4381                 active: 0,
4382                 animate: {},
4383                 collapsible: false,
4384                 event: "click",
4385                 header: "> li > :first-child,> :not(li):even",
4386                 heightStyle: "auto",
4387                 icons: {
4388                         activeHeader: "ui-icon-triangle-1-s",
4389                         header: "ui-icon-triangle-1-e"
4390                 },
4391
4392                 // callbacks
4393                 activate: null,
4394                 beforeActivate: null
4395         },
4396
4397         hideProps: {
4398                 borderTopWidth: "hide",
4399                 borderBottomWidth: "hide",
4400                 paddingTop: "hide",
4401                 paddingBottom: "hide",
4402                 height: "hide"
4403         },
4404
4405         showProps: {
4406                 borderTopWidth: "show",
4407                 borderBottomWidth: "show",
4408                 paddingTop: "show",
4409                 paddingBottom: "show",
4410                 height: "show"
4411         },
4412
4413         _create: function() {
4414                 var options = this.options;
4415                 this.prevShow = this.prevHide = $();
4416                 this.element.addClass( "ui-accordion ui-widget ui-helper-reset" )
4417                         // ARIA
4418                         .attr( "role", "tablist" );
4419
4420                 // don't allow collapsible: false and active: false / null
4421                 if ( !options.collapsible && (options.active === false || options.active == null) ) {
4422                         options.active = 0;
4423                 }
4424
4425                 this._processPanels();
4426                 // handle negative values
4427                 if ( options.active < 0 ) {
4428                         options.active += this.headers.length;
4429                 }
4430                 this._refresh();
4431         },
4432
4433         _getCreateEventData: function() {
4434                 return {
4435                         header: this.active,
4436                         panel: !this.active.length ? $() : this.active.next()
4437                 };
4438         },
4439
4440         _createIcons: function() {
4441                 var icons = this.options.icons;
4442                 if ( icons ) {
4443                         $( "<span>" )
4444                                 .addClass( "ui-accordion-header-icon ui-icon " + icons.header )
4445                                 .prependTo( this.headers );
4446                         this.active.children( ".ui-accordion-header-icon" )
4447                                 .removeClass( icons.header )
4448                                 .addClass( icons.activeHeader );
4449                         this.headers.addClass( "ui-accordion-icons" );
4450                 }
4451         },
4452
4453         _destroyIcons: function() {
4454                 this.headers
4455                         .removeClass( "ui-accordion-icons" )
4456                         .children( ".ui-accordion-header-icon" )
4457                                 .remove();
4458         },
4459
4460         _destroy: function() {
4461                 var contents;
4462
4463                 // clean up main element
4464                 this.element
4465                         .removeClass( "ui-accordion ui-widget ui-helper-reset" )
4466                         .removeAttr( "role" );
4467
4468                 // clean up headers
4469                 this.headers
4470                         .removeClass( "ui-accordion-header ui-accordion-header-active ui-state-default " +
4471                                 "ui-corner-all ui-state-active ui-state-disabled ui-corner-top" )
4472                         .removeAttr( "role" )
4473                         .removeAttr( "aria-expanded" )
4474                         .removeAttr( "aria-selected" )
4475                         .removeAttr( "aria-controls" )
4476                         .removeAttr( "tabIndex" )
4477                         .removeUniqueId();
4478
4479                 this._destroyIcons();
4480
4481                 // clean up content panels
4482                 contents = this.headers.next()
4483                         .removeClass( "ui-helper-reset ui-widget-content ui-corner-bottom " +
4484                                 "ui-accordion-content ui-accordion-content-active ui-state-disabled" )
4485                         .css( "display", "" )
4486                         .removeAttr( "role" )
4487                         .removeAttr( "aria-hidden" )
4488                         .removeAttr( "aria-labelledby" )
4489                         .removeUniqueId();
4490
4491                 if ( this.options.heightStyle !== "content" ) {
4492                         contents.css( "height", "" );
4493                 }
4494         },
4495
4496         _setOption: function( key, value ) {
4497                 if ( key === "active" ) {
4498                         // _activate() will handle invalid values and update this.options
4499                         this._activate( value );
4500                         return;
4501                 }
4502
4503                 if ( key === "event" ) {
4504                         if ( this.options.event ) {
4505                                 this._off( this.headers, this.options.event );
4506                         }
4507                         this._setupEvents( value );
4508                 }
4509
4510                 this._super( key, value );
4511
4512                 // setting collapsible: false while collapsed; open first panel
4513                 if ( key === "collapsible" && !value && this.options.active === false ) {
4514                         this._activate( 0 );
4515                 }
4516
4517                 if ( key === "icons" ) {
4518                         this._destroyIcons();
4519                         if ( value ) {
4520                                 this._createIcons();
4521                         }
4522                 }
4523
4524                 // #5332 - opacity doesn't cascade to positioned elements in IE
4525                 // so we need to add the disabled class to the headers and panels
4526                 if ( key === "disabled" ) {
4527                         this.element
4528                                 .toggleClass( "ui-state-disabled", !!value )
4529                                 .attr( "aria-disabled", value );
4530                         this.headers.add( this.headers.next() )
4531                                 .toggleClass( "ui-state-disabled", !!value );
4532                 }
4533         },
4534
4535         _keydown: function( event ) {
4536                 if ( event.altKey || event.ctrlKey ) {
4537                         return;
4538                 }
4539
4540                 var keyCode = $.ui.keyCode,
4541                         length = this.headers.length,
4542                         currentIndex = this.headers.index( event.target ),
4543                         toFocus = false;
4544
4545                 switch ( event.keyCode ) {
4546                         case keyCode.RIGHT:
4547                         case keyCode.DOWN:
4548                                 toFocus = this.headers[ ( currentIndex + 1 ) % length ];
4549                                 break;
4550                         case keyCode.LEFT:
4551                         case keyCode.UP:
4552                                 toFocus = this.headers[ ( currentIndex - 1 + length ) % length ];
4553                                 break;
4554                         case keyCode.SPACE:
4555                         case keyCode.ENTER:
4556                                 this._eventHandler( event );
4557                                 break;
4558                         case keyCode.HOME:
4559                                 toFocus = this.headers[ 0 ];
4560                                 break;
4561                         case keyCode.END:
4562                                 toFocus = this.headers[ length - 1 ];
4563                                 break;
4564                 }
4565
4566                 if ( toFocus ) {
4567                         $( event.target ).attr( "tabIndex", -1 );
4568                         $( toFocus ).attr( "tabIndex", 0 );
4569                         toFocus.focus();
4570                         event.preventDefault();
4571                 }
4572         },
4573
4574         _panelKeyDown: function( event ) {
4575                 if ( event.keyCode === $.ui.keyCode.UP && event.ctrlKey ) {
4576                         $( event.currentTarget ).prev().focus();
4577                 }
4578         },
4579
4580         refresh: function() {
4581                 var options = this.options;
4582                 this._processPanels();
4583
4584                 // was collapsed or no panel
4585                 if ( ( options.active === false && options.collapsible === true ) || !this.headers.length ) {
4586                         options.active = false;
4587                         this.active = $();
4588                 // active false only when collapsible is true
4589                 } else if ( options.active === false ) {
4590                         this._activate( 0 );
4591                 // was active, but active panel is gone
4592                 } else if ( this.active.length && !$.contains( this.element[ 0 ], this.active[ 0 ] ) ) {
4593                         // all remaining panel are disabled
4594                         if ( this.headers.length === this.headers.find(".ui-state-disabled").length ) {
4595                                 options.active = false;
4596                                 this.active = $();
4597                         // activate previous panel
4598                         } else {
4599                                 this._activate( Math.max( 0, options.active - 1 ) );
4600                         }
4601                 // was active, active panel still exists
4602                 } else {
4603                         // make sure active index is correct
4604                         options.active = this.headers.index( this.active );
4605                 }
4606
4607                 this._destroyIcons();
4608
4609                 this._refresh();
4610         },
4611
4612         _processPanels: function() {
4613                 var prevHeaders = this.headers,
4614                         prevPanels = this.panels;
4615
4616                 this.headers = this.element.find( this.options.header )
4617                         .addClass( "ui-accordion-header ui-state-default ui-corner-all" );
4618
4619                 this.panels = this.headers.next()
4620                         .addClass( "ui-accordion-content ui-helper-reset ui-widget-content ui-corner-bottom" )
4621                         .filter( ":not(.ui-accordion-content-active)" )
4622                         .hide();
4623
4624                 // Avoid memory leaks (#10056)
4625                 if ( prevPanels ) {
4626                         this._off( prevHeaders.not( this.headers ) );
4627                         this._off( prevPanels.not( this.panels ) );
4628                 }
4629         },
4630
4631         _refresh: function() {
4632                 var maxHeight,
4633                         options = this.options,
4634                         heightStyle = options.heightStyle,
4635                         parent = this.element.parent();
4636
4637                 this.active = this._findActive( options.active )
4638                         .addClass( "ui-accordion-header-active ui-state-active ui-corner-top" )
4639                         .removeClass( "ui-corner-all" );
4640                 this.active.next()
4641                         .addClass( "ui-accordion-content-active" )
4642                         .show();
4643
4644                 this.headers
4645                         .attr( "role", "tab" )
4646                         .each(function() {
4647                                 var header = $( this ),
4648                                         headerId = header.uniqueId().attr( "id" ),
4649                                         panel = header.next(),
4650                                         panelId = panel.uniqueId().attr( "id" );
4651                                 header.attr( "aria-controls", panelId );
4652                                 panel.attr( "aria-labelledby", headerId );
4653                         })
4654                         .next()
4655                                 .attr( "role", "tabpanel" );
4656
4657                 this.headers
4658                         .not( this.active )
4659                         .attr({
4660                                 "aria-selected": "false",
4661                                 "aria-expanded": "false",
4662                                 tabIndex: -1
4663                         })
4664                         .next()
4665                                 .attr({
4666                                         "aria-hidden": "true"
4667                                 })
4668                                 .hide();
4669
4670                 // make sure at least one header is in the tab order
4671                 if ( !this.active.length ) {
4672                         this.headers.eq( 0 ).attr( "tabIndex", 0 );
4673                 } else {
4674                         this.active.attr({
4675                                 "aria-selected": "true",
4676                                 "aria-expanded": "true",
4677                                 tabIndex: 0
4678                         })
4679                         .next()
4680                                 .attr({
4681                                         "aria-hidden": "false"
4682                                 });
4683                 }
4684
4685                 this._createIcons();
4686
4687                 this._setupEvents( options.event );
4688
4689                 if ( heightStyle === "fill" ) {
4690                         maxHeight = parent.height();
4691                         this.element.siblings( ":visible" ).each(function() {
4692                                 var elem = $( this ),
4693                                         position = elem.css( "position" );
4694
4695                                 if ( position === "absolute" || position === "fixed" ) {
4696                                         return;
4697                                 }
4698                                 maxHeight -= elem.outerHeight( true );
4699                         });
4700
4701                         this.headers.each(function() {
4702                                 maxHeight -= $( this ).outerHeight( true );
4703                         });
4704
4705                         this.headers.next()
4706                                 .each(function() {
4707                                         $( this ).height( Math.max( 0, maxHeight -
4708                                                 $( this ).innerHeight() + $( this ).height() ) );
4709                                 })
4710                                 .css( "overflow", "auto" );
4711                 } else if ( heightStyle === "auto" ) {
4712                         maxHeight = 0;
4713                         this.headers.next()
4714                                 .each(function() {
4715                                         maxHeight = Math.max( maxHeight, $( this ).css( "height", "" ).height() );
4716                                 })
4717                                 .height( maxHeight );
4718                 }
4719         },
4720
4721         _activate: function( index ) {
4722                 var active = this._findActive( index )[ 0 ];
4723
4724                 // trying to activate the already active panel
4725                 if ( active === this.active[ 0 ] ) {
4726                         return;
4727                 }
4728
4729                 // trying to collapse, simulate a click on the currently active header
4730                 active = active || this.active[ 0 ];
4731
4732                 this._eventHandler({
4733                         target: active,
4734                         currentTarget: active,
4735                         preventDefault: $.noop
4736                 });
4737         },
4738
4739         _findActive: function( selector ) {
4740                 return typeof selector === "number" ? this.headers.eq( selector ) : $();
4741         },
4742
4743         _setupEvents: function( event ) {
4744                 var events = {
4745                         keydown: "_keydown"
4746                 };
4747                 if ( event ) {
4748                         $.each( event.split( " " ), function( index, eventName ) {
4749                                 events[ eventName ] = "_eventHandler";
4750                         });
4751                 }
4752
4753                 this._off( this.headers.add( this.headers.next() ) );
4754                 this._on( this.headers, events );
4755                 this._on( this.headers.next(), { keydown: "_panelKeyDown" });
4756                 this._hoverable( this.headers );
4757                 this._focusable( this.headers );
4758         },
4759
4760         _eventHandler: function( event ) {
4761                 var options = this.options,
4762                         active = this.active,
4763                         clicked = $( event.currentTarget ),
4764                         clickedIsActive = clicked[ 0 ] === active[ 0 ],
4765                         collapsing = clickedIsActive && options.collapsible,
4766                         toShow = collapsing ? $() : clicked.next(),
4767                         toHide = active.next(),
4768                         eventData = {
4769                                 oldHeader: active,
4770                                 oldPanel: toHide,
4771                                 newHeader: collapsing ? $() : clicked,
4772                                 newPanel: toShow
4773                         };
4774
4775                 event.preventDefault();
4776
4777                 if (
4778                                 // click on active header, but not collapsible
4779                                 ( clickedIsActive && !options.collapsible ) ||
4780                                 // allow canceling activation
4781                                 ( this._trigger( "beforeActivate", event, eventData ) === false ) ) {
4782                         return;
4783                 }
4784
4785                 options.active = collapsing ? false : this.headers.index( clicked );
4786
4787                 // when the call to ._toggle() comes after the class changes
4788                 // it causes a very odd bug in IE 8 (see #6720)
4789                 this.active = clickedIsActive ? $() : clicked;
4790                 this._toggle( eventData );
4791
4792                 // switch classes
4793                 // corner classes on the previously active header stay after the animation
4794                 active.removeClass( "ui-accordion-header-active ui-state-active" );
4795                 if ( options.icons ) {
4796                         active.children( ".ui-accordion-header-icon" )
4797                                 .removeClass( options.icons.activeHeader )
4798                                 .addClass( options.icons.header );
4799                 }
4800
4801                 if ( !clickedIsActive ) {
4802                         clicked
4803                                 .removeClass( "ui-corner-all" )
4804                                 .addClass( "ui-accordion-header-active ui-state-active ui-corner-top" );
4805                         if ( options.icons ) {
4806                                 clicked.children( ".ui-accordion-header-icon" )
4807                                         .removeClass( options.icons.header )
4808                                         .addClass( options.icons.activeHeader );
4809                         }
4810
4811                         clicked
4812                                 .next()
4813                                 .addClass( "ui-accordion-content-active" );
4814                 }
4815         },
4816
4817         _toggle: function( data ) {
4818                 var toShow = data.newPanel,
4819                         toHide = this.prevShow.length ? this.prevShow : data.oldPanel;
4820
4821                 // handle activating a panel during the animation for another activation
4822                 this.prevShow.add( this.prevHide ).stop( true, true );
4823                 this.prevShow = toShow;
4824                 this.prevHide = toHide;
4825
4826                 if ( this.options.animate ) {
4827                         this._animate( toShow, toHide, data );
4828                 } else {
4829                         toHide.hide();
4830                         toShow.show();
4831                         this._toggleComplete( data );
4832                 }
4833
4834                 toHide.attr({
4835                         "aria-hidden": "true"
4836                 });
4837                 toHide.prev().attr({
4838                         "aria-selected": "false",
4839                         "aria-expanded": "false"
4840                 });
4841                 // if we're switching panels, remove the old header from the tab order
4842                 // if we're opening from collapsed state, remove the previous header from the tab order
4843                 // if we're collapsing, then keep the collapsing header in the tab order
4844                 if ( toShow.length && toHide.length ) {
4845                         toHide.prev().attr({
4846                                 "tabIndex": -1,
4847                                 "aria-expanded": "false"
4848                         });
4849                 } else if ( toShow.length ) {
4850                         this.headers.filter(function() {
4851                                 return parseInt( $( this ).attr( "tabIndex" ), 10 ) === 0;
4852                         })
4853                         .attr( "tabIndex", -1 );
4854                 }
4855
4856                 toShow
4857                         .attr( "aria-hidden", "false" )
4858                         .prev()
4859                                 .attr({
4860                                         "aria-selected": "true",
4861                                         "aria-expanded": "true",
4862                                         tabIndex: 0
4863                                 });
4864         },
4865
4866         _animate: function( toShow, toHide, data ) {
4867                 var total, easing, duration,
4868                         that = this,
4869                         adjust = 0,
4870                         boxSizing = toShow.css( "box-sizing" ),
4871                         down = toShow.length &&
4872                                 ( !toHide.length || ( toShow.index() < toHide.index() ) ),
4873                         animate = this.options.animate || {},
4874                         options = down && animate.down || animate,
4875                         complete = function() {
4876                                 that._toggleComplete( data );
4877                         };
4878
4879                 if ( typeof options === "number" ) {
4880                         duration = options;
4881                 }
4882                 if ( typeof options === "string" ) {
4883                         easing = options;
4884                 }
4885                 // fall back from options to animation in case of partial down settings
4886                 easing = easing || options.easing || animate.easing;
4887                 duration = duration || options.duration || animate.duration;
4888
4889                 if ( !toHide.length ) {
4890                         return toShow.animate( this.showProps, duration, easing, complete );
4891                 }
4892                 if ( !toShow.length ) {
4893                         return toHide.animate( this.hideProps, duration, easing, complete );
4894                 }
4895
4896                 total = toShow.show().outerHeight();
4897                 toHide.animate( this.hideProps, {
4898                         duration: duration,
4899                         easing: easing,
4900                         step: function( now, fx ) {
4901                                 fx.now = Math.round( now );
4902                         }
4903                 });
4904                 toShow
4905                         .hide()
4906                         .animate( this.showProps, {
4907                                 duration: duration,
4908                                 easing: easing,
4909                                 complete: complete,
4910                                 step: function( now, fx ) {
4911                                         fx.now = Math.round( now );
4912                                         if ( fx.prop !== "height" ) {
4913                                                 if ( boxSizing === "content-box" ) {
4914                                                         adjust += fx.now;
4915                                                 }
4916                                         } else if ( that.options.heightStyle !== "content" ) {
4917                                                 fx.now = Math.round( total - toHide.outerHeight() - adjust );
4918                                                 adjust = 0;
4919                                         }
4920                                 }
4921                         });
4922         },
4923
4924         _toggleComplete: function( data ) {
4925                 var toHide = data.oldPanel;
4926
4927                 toHide
4928                         .removeClass( "ui-accordion-content-active" )
4929                         .prev()
4930                                 .removeClass( "ui-corner-top" )
4931                                 .addClass( "ui-corner-all" );
4932
4933                 // Work around for rendering bug in IE (#5421)
4934                 if ( toHide.length ) {
4935                         toHide.parent()[ 0 ].className = toHide.parent()[ 0 ].className;
4936                 }
4937                 this._trigger( "activate", null, data );
4938         }
4939 });
4940
4941
4942 /*!
4943  * jQuery UI Menu 1.11.4
4944  * http://jqueryui.com
4945  *
4946  * Copyright jQuery Foundation and other contributors
4947  * Released under the MIT license.
4948  * http://jquery.org/license
4949  *
4950  * http://api.jqueryui.com/menu/
4951  */
4952
4953
4954 var menu = $.widget( "ui.menu", {
4955         version: "1.11.4",
4956         defaultElement: "<ul>",
4957         delay: 300,
4958         options: {
4959                 icons: {
4960                         submenu: "ui-icon-carat-1-e"
4961                 },
4962                 items: "> *",
4963                 menus: "ul",
4964                 position: {
4965                         my: "left-1 top",
4966                         at: "right top"
4967                 },
4968                 role: "menu",
4969
4970                 // callbacks
4971                 blur: null,
4972                 focus: null,
4973                 select: null
4974         },
4975
4976         _create: function() {
4977                 this.activeMenu = this.element;
4978
4979                 // Flag used to prevent firing of the click handler
4980                 // as the event bubbles up through nested menus
4981                 this.mouseHandled = false;
4982                 this.element
4983                         .uniqueId()
4984                         .addClass( "ui-menu ui-widget ui-widget-content" )
4985                         .toggleClass( "ui-menu-icons", !!this.element.find( ".ui-icon" ).length )
4986                         .attr({
4987                                 role: this.options.role,
4988                                 tabIndex: 0
4989                         });
4990
4991                 if ( this.options.disabled ) {
4992                         this.element
4993                                 .addClass( "ui-state-disabled" )
4994                                 .attr( "aria-disabled", "true" );
4995                 }
4996
4997                 this._on({
4998                         // Prevent focus from sticking to links inside menu after clicking
4999                         // them (focus should always stay on UL during navigation).
5000                         "mousedown .ui-menu-item": function( event ) {
5001                                 event.preventDefault();
5002                         },
5003                         "click .ui-menu-item": function( event ) {
5004                                 var target = $( event.target );
5005                                 if ( !this.mouseHandled && target.not( ".ui-state-disabled" ).length ) {
5006                                         this.select( event );
5007
5008                                         // Only set the mouseHandled flag if the event will bubble, see #9469.
5009                                         if ( !event.isPropagationStopped() ) {
5010                                                 this.mouseHandled = true;
5011                                         }
5012
5013                                         // Open submenu on click
5014                                         if ( target.has( ".ui-menu" ).length ) {
5015                                                 this.expand( event );
5016                                         } else if ( !this.element.is( ":focus" ) && $( this.document[ 0 ].activeElement ).closest( ".ui-menu" ).length ) {
5017
5018                                                 // Redirect focus to the menu
5019                                                 this.element.trigger( "focus", [ true ] );
5020
5021                                                 // If the active item is on the top level, let it stay active.
5022                                                 // Otherwise, blur the active item since it is no longer visible.
5023                                                 if ( this.active && this.active.parents( ".ui-menu" ).length === 1 ) {
5024                                                         clearTimeout( this.timer );
5025                                                 }
5026                                         }
5027                                 }
5028                         },
5029                         "mouseenter .ui-menu-item": function( event ) {
5030                                 // Ignore mouse events while typeahead is active, see #10458.
5031                                 // Prevents focusing the wrong item when typeahead causes a scroll while the mouse
5032                                 // is over an item in the menu
5033                                 if ( this.previousFilter ) {
5034                                         return;
5035                                 }
5036                                 var target = $( event.currentTarget );
5037                                 // Remove ui-state-active class from siblings of the newly focused menu item
5038                                 // to avoid a jump caused by adjacent elements both having a class with a border
5039                                 target.siblings( ".ui-state-active" ).removeClass( "ui-state-active" );
5040                                 this.focus( event, target );
5041                         },
5042                         mouseleave: "collapseAll",
5043                         "mouseleave .ui-menu": "collapseAll",
5044                         focus: function( event, keepActiveItem ) {
5045                                 // If there's already an active item, keep it active
5046                                 // If not, activate the first item
5047                                 var item = this.active || this.element.find( this.options.items ).eq( 0 );
5048
5049                                 if ( !keepActiveItem ) {
5050                                         this.focus( event, item );
5051                                 }
5052                         },
5053                         blur: function( event ) {
5054                                 this._delay(function() {
5055                                         if ( !$.contains( this.element[0], this.document[0].activeElement ) ) {
5056                                                 this.collapseAll( event );
5057                                         }
5058                                 });
5059                         },
5060                         keydown: "_keydown"
5061                 });
5062
5063                 this.refresh();
5064
5065                 // Clicks outside of a menu collapse any open menus
5066                 this._on( this.document, {
5067                         click: function( event ) {
5068                                 if ( this._closeOnDocumentClick( event ) ) {
5069                                         this.collapseAll( event );
5070                                 }
5071
5072                                 // Reset the mouseHandled flag
5073                                 this.mouseHandled = false;
5074                         }
5075                 });
5076         },
5077
5078         _destroy: function() {
5079                 // Destroy (sub)menus
5080                 this.element
5081                         .removeAttr( "aria-activedescendant" )
5082                         .find( ".ui-menu" ).addBack()
5083                                 .removeClass( "ui-menu ui-widget ui-widget-content ui-menu-icons ui-front" )
5084                                 .removeAttr( "role" )
5085                                 .removeAttr( "tabIndex" )
5086                                 .removeAttr( "aria-labelledby" )
5087                                 .removeAttr( "aria-expanded" )
5088                                 .removeAttr( "aria-hidden" )
5089                                 .removeAttr( "aria-disabled" )
5090                                 .removeUniqueId()
5091                                 .show();
5092
5093                 // Destroy menu items
5094                 this.element.find( ".ui-menu-item" )
5095                         .removeClass( "ui-menu-item" )
5096                         .removeAttr( "role" )
5097                         .removeAttr( "aria-disabled" )
5098                         .removeUniqueId()
5099                         .removeClass( "ui-state-hover" )
5100                         .removeAttr( "tabIndex" )
5101                         .removeAttr( "role" )
5102                         .removeAttr( "aria-haspopup" )
5103                         .children().each( function() {
5104                                 var elem = $( this );
5105                                 if ( elem.data( "ui-menu-submenu-carat" ) ) {
5106                                         elem.remove();
5107                                 }
5108                         });
5109
5110                 // Destroy menu dividers
5111                 this.element.find( ".ui-menu-divider" ).removeClass( "ui-menu-divider ui-widget-content" );
5112         },
5113
5114         _keydown: function( event ) {
5115                 var match, prev, character, skip,
5116                         preventDefault = true;
5117
5118                 switch ( event.keyCode ) {
5119                 case $.ui.keyCode.PAGE_UP:
5120                         this.previousPage( event );
5121                         break;
5122                 case $.ui.keyCode.PAGE_DOWN:
5123                         this.nextPage( event );
5124                         break;
5125                 case $.ui.keyCode.HOME:
5126                         this._move( "first", "first", event );
5127                         break;
5128                 case $.ui.keyCode.END:
5129                         this._move( "last", "last", event );
5130                         break;
5131                 case $.ui.keyCode.UP:
5132                         this.previous( event );
5133                         break;
5134                 case $.ui.keyCode.DOWN:
5135                         this.next( event );
5136                         break;
5137                 case $.ui.keyCode.LEFT:
5138                         this.collapse( event );
5139                         break;
5140                 case $.ui.keyCode.RIGHT:
5141                         if ( this.active && !this.active.is( ".ui-state-disabled" ) ) {
5142                                 this.expand( event );
5143                         }
5144                         break;
5145                 case $.ui.keyCode.ENTER:
5146                 case $.ui.keyCode.SPACE:
5147                         this._activate( event );
5148                         break;
5149                 case $.ui.keyCode.ESCAPE:
5150                         this.collapse( event );
5151                         break;
5152                 default:
5153                         preventDefault = false;
5154                         prev = this.previousFilter || "";
5155                         character = String.fromCharCode( event.keyCode );
5156                         skip = false;
5157
5158                         clearTimeout( this.filterTimer );
5159
5160                         if ( character === prev ) {
5161                                 skip = true;
5162                         } else {
5163                                 character = prev + character;
5164                         }
5165
5166                         match = this._filterMenuItems( character );
5167                         match = skip && match.index( this.active.next() ) !== -1 ?
5168                                 this.active.nextAll( ".ui-menu-item" ) :
5169                                 match;
5170
5171                         // If no matches on the current filter, reset to the last character pressed
5172                         // to move down the menu to the first item that starts with that character
5173                         if ( !match.length ) {
5174                                 character = String.fromCharCode( event.keyCode );
5175                                 match = this._filterMenuItems( character );
5176                         }
5177
5178                         if ( match.length ) {
5179                                 this.focus( event, match );
5180                                 this.previousFilter = character;
5181                                 this.filterTimer = this._delay(function() {
5182                                         delete this.previousFilter;
5183                                 }, 1000 );
5184                         } else {
5185                                 delete this.previousFilter;
5186                         }
5187                 }
5188
5189                 if ( preventDefault ) {
5190                         event.preventDefault();
5191                 }
5192         },
5193
5194         _activate: function( event ) {
5195                 if ( !this.active.is( ".ui-state-disabled" ) ) {
5196                         if ( this.active.is( "[aria-haspopup='true']" ) ) {
5197                                 this.expand( event );
5198                         } else {
5199                                 this.select( event );
5200                         }
5201                 }
5202         },
5203
5204         refresh: function() {
5205                 var menus, items,
5206                         that = this,
5207                         icon = this.options.icons.submenu,
5208                         submenus = this.element.find( this.options.menus );
5209
5210                 this.element.toggleClass( "ui-menu-icons", !!this.element.find( ".ui-icon" ).length );
5211
5212                 // Initialize nested menus
5213                 submenus.filter( ":not(.ui-menu)" )
5214                         .addClass( "ui-menu ui-widget ui-widget-content ui-front" )
5215                         .hide()
5216                         .attr({
5217                                 role: this.options.role,
5218                                 "aria-hidden": "true",
5219                                 "aria-expanded": "false"
5220                         })
5221                         .each(function() {
5222                                 var menu = $( this ),
5223                                         item = menu.parent(),
5224                                         submenuCarat = $( "<span>" )
5225                                                 .addClass( "ui-menu-icon ui-icon " + icon )
5226                                                 .data( "ui-menu-submenu-carat", true );
5227
5228                                 item
5229                                         .attr( "aria-haspopup", "true" )
5230                                         .prepend( submenuCarat );
5231                                 menu.attr( "aria-labelledby", item.attr( "id" ) );
5232                         });
5233
5234                 menus = submenus.add( this.element );
5235                 items = menus.find( this.options.items );
5236
5237                 // Initialize menu-items containing spaces and/or dashes only as dividers
5238                 items.not( ".ui-menu-item" ).each(function() {
5239                         var item = $( this );
5240                         if ( that._isDivider( item ) ) {
5241                                 item.addClass( "ui-widget-content ui-menu-divider" );
5242                         }
5243                 });
5244
5245                 // Don't refresh list items that are already adapted
5246                 items.not( ".ui-menu-item, .ui-menu-divider" )
5247                         .addClass( "ui-menu-item" )
5248                         .uniqueId()
5249                         .attr({
5250                                 tabIndex: -1,
5251                                 role: this._itemRole()
5252                         });
5253
5254                 // Add aria-disabled attribute to any disabled menu item
5255                 items.filter( ".ui-state-disabled" ).attr( "aria-disabled", "true" );
5256
5257                 // If the active item has been removed, blur the menu
5258                 if ( this.active && !$.contains( this.element[ 0 ], this.active[ 0 ] ) ) {
5259                         this.blur();
5260                 }
5261         },
5262
5263         _itemRole: function() {
5264                 return {
5265                         menu: "menuitem",
5266                         listbox: "option"
5267                 }[ this.options.role ];
5268         },
5269
5270         _setOption: function( key, value ) {
5271                 if ( key === "icons" ) {
5272                         this.element.find( ".ui-menu-icon" )
5273                                 .removeClass( this.options.icons.submenu )
5274                                 .addClass( value.submenu );
5275                 }
5276                 if ( key === "disabled" ) {
5277                         this.element
5278                                 .toggleClass( "ui-state-disabled", !!value )
5279                                 .attr( "aria-disabled", value );
5280                 }
5281                 this._super( key, value );
5282         },
5283
5284         focus: function( event, item ) {
5285                 var nested, focused;
5286                 this.blur( event, event && event.type === "focus" );
5287
5288                 this._scrollIntoView( item );
5289
5290                 this.active = item.first();
5291                 focused = this.active.addClass( "ui-state-focus" ).removeClass( "ui-state-active" );
5292                 // Only update aria-activedescendant if there's a role
5293                 // otherwise we assume focus is managed elsewhere
5294                 if ( this.options.role ) {
5295                         this.element.attr( "aria-activedescendant", focused.attr( "id" ) );
5296                 }
5297
5298                 // Highlight active parent menu item, if any
5299                 this.active
5300                         .parent()
5301                         .closest( ".ui-menu-item" )
5302                         .addClass( "ui-state-active" );
5303
5304                 if ( event && event.type === "keydown" ) {
5305                         this._close();
5306                 } else {
5307                         this.timer = this._delay(function() {
5308                                 this._close();
5309                         }, this.delay );
5310                 }
5311
5312                 nested = item.children( ".ui-menu" );
5313                 if ( nested.length && event && ( /^mouse/.test( event.type ) ) ) {
5314                         this._startOpening(nested);
5315                 }
5316                 this.activeMenu = item.parent();
5317
5318                 this._trigger( "focus", event, { item: item } );
5319         },
5320
5321         _scrollIntoView: function( item ) {
5322                 var borderTop, paddingTop, offset, scroll, elementHeight, itemHeight;
5323                 if ( this._hasScroll() ) {
5324                         borderTop = parseFloat( $.css( this.activeMenu[0], "borderTopWidth" ) ) || 0;
5325                         paddingTop = parseFloat( $.css( this.activeMenu[0], "paddingTop" ) ) || 0;
5326                         offset = item.offset().top - this.activeMenu.offset().top - borderTop - paddingTop;
5327                         scroll = this.activeMenu.scrollTop();
5328                         elementHeight = this.activeMenu.height();
5329                         itemHeight = item.outerHeight();
5330
5331                         if ( offset < 0 ) {
5332                                 this.activeMenu.scrollTop( scroll + offset );
5333                         } else if ( offset + itemHeight > elementHeight ) {
5334                                 this.activeMenu.scrollTop( scroll + offset - elementHeight + itemHeight );
5335                         }
5336                 }
5337         },
5338
5339         blur: function( event, fromFocus ) {
5340                 if ( !fromFocus ) {
5341                         clearTimeout( this.timer );
5342                 }
5343
5344                 if ( !this.active ) {
5345                         return;
5346                 }
5347
5348                 this.active.removeClass( "ui-state-focus" );
5349                 this.active = null;
5350
5351                 this._trigger( "blur", event, { item: this.active } );
5352         },
5353
5354         _startOpening: function( submenu ) {
5355                 clearTimeout( this.timer );
5356
5357                 // Don't open if already open fixes a Firefox bug that caused a .5 pixel
5358                 // shift in the submenu position when mousing over the carat icon
5359                 if ( submenu.attr( "aria-hidden" ) !== "true" ) {
5360                         return;
5361                 }
5362
5363                 this.timer = this._delay(function() {
5364                         this._close();
5365                         this._open( submenu );
5366                 }, this.delay );
5367         },
5368
5369         _open: function( submenu ) {
5370                 var position = $.extend({
5371                         of: this.active
5372                 }, this.options.position );
5373
5374                 clearTimeout( this.timer );
5375                 this.element.find( ".ui-menu" ).not( submenu.parents( ".ui-menu" ) )
5376                         .hide()
5377                         .attr( "aria-hidden", "true" );
5378
5379                 submenu
5380                         .show()
5381                         .removeAttr( "aria-hidden" )
5382                         .attr( "aria-expanded", "true" )
5383                         .position( position );
5384         },
5385
5386         collapseAll: function( event, all ) {
5387                 clearTimeout( this.timer );
5388                 this.timer = this._delay(function() {
5389                         // If we were passed an event, look for the submenu that contains the event
5390                         var currentMenu = all ? this.element :
5391                                 $( event && event.target ).closest( this.element.find( ".ui-menu" ) );
5392
5393                         // If we found no valid submenu ancestor, use the main menu to close all sub menus anyway
5394                         if ( !currentMenu.length ) {
5395                                 currentMenu = this.element;
5396                         }
5397
5398                         this._close( currentMenu );
5399
5400                         this.blur( event );
5401                         this.activeMenu = currentMenu;
5402                 }, this.delay );
5403         },
5404
5405         // With no arguments, closes the currently active menu - if nothing is active
5406         // it closes all menus.  If passed an argument, it will search for menus BELOW
5407         _close: function( startMenu ) {
5408                 if ( !startMenu ) {
5409                         startMenu = this.active ? this.active.parent() : this.element;
5410                 }
5411
5412                 startMenu
5413                         .find( ".ui-menu" )
5414                                 .hide()
5415                                 .attr( "aria-hidden", "true" )
5416                                 .attr( "aria-expanded", "false" )
5417                         .end()
5418                         .find( ".ui-state-active" ).not( ".ui-state-focus" )
5419                                 .removeClass( "ui-state-active" );
5420         },
5421
5422         _closeOnDocumentClick: function( event ) {
5423                 return !$( event.target ).closest( ".ui-menu" ).length;
5424         },
5425
5426         _isDivider: function( item ) {
5427
5428                 // Match hyphen, em dash, en dash
5429                 return !/[^\-\u2014\u2013\s]/.test( item.text() );
5430         },
5431
5432         collapse: function( event ) {
5433                 var newItem = this.active &&
5434                         this.active.parent().closest( ".ui-menu-item", this.element );
5435                 if ( newItem && newItem.length ) {
5436                         this._close();
5437                         this.focus( event, newItem );
5438                 }
5439         },
5440
5441         expand: function( event ) {
5442                 var newItem = this.active &&
5443                         this.active
5444                                 .children( ".ui-menu " )
5445                                 .find( this.options.items )
5446                                 .first();
5447
5448                 if ( newItem && newItem.length ) {
5449                         this._open( newItem.parent() );
5450
5451                         // Delay so Firefox will not hide activedescendant change in expanding submenu from AT
5452                         this._delay(function() {
5453                                 this.focus( event, newItem );
5454                         });
5455                 }
5456         },
5457
5458         next: function( event ) {
5459                 this._move( "next", "first", event );
5460         },
5461
5462         previous: function( event ) {
5463                 this._move( "prev", "last", event );
5464         },
5465
5466         isFirstItem: function() {
5467                 return this.active && !this.active.prevAll( ".ui-menu-item" ).length;
5468         },
5469
5470         isLastItem: function() {
5471                 return this.active && !this.active.nextAll( ".ui-menu-item" ).length;
5472         },
5473
5474         _move: function( direction, filter, event ) {
5475                 var next;
5476                 if ( this.active ) {
5477                         if ( direction === "first" || direction === "last" ) {
5478                                 next = this.active
5479                                         [ direction === "first" ? "prevAll" : "nextAll" ]( ".ui-menu-item" )
5480                                         .eq( -1 );
5481                         } else {
5482                                 next = this.active
5483                                         [ direction + "All" ]( ".ui-menu-item" )
5484                                         .eq( 0 );
5485                         }
5486                 }
5487                 if ( !next || !next.length || !this.active ) {
5488                         next = this.activeMenu.find( this.options.items )[ filter ]();
5489                 }
5490
5491                 this.focus( event, next );
5492         },
5493
5494         nextPage: function( event ) {
5495                 var item, base, height;
5496
5497                 if ( !this.active ) {
5498                         this.next( event );
5499                         return;
5500                 }
5501                 if ( this.isLastItem() ) {
5502                         return;
5503                 }
5504                 if ( this._hasScroll() ) {
5505                         base = this.active.offset().top;
5506                         height = this.element.height();
5507                         this.active.nextAll( ".ui-menu-item" ).each(function() {
5508                                 item = $( this );
5509                                 return item.offset().top - base - height < 0;
5510                         });
5511
5512                         this.focus( event, item );
5513                 } else {
5514                         this.focus( event, this.activeMenu.find( this.options.items )
5515                                 [ !this.active ? "first" : "last" ]() );
5516                 }
5517         },
5518
5519         previousPage: function( event ) {
5520                 var item, base, height;
5521                 if ( !this.active ) {
5522                         this.next( event );
5523                         return;
5524                 }
5525                 if ( this.isFirstItem() ) {
5526                         return;
5527                 }
5528                 if ( this._hasScroll() ) {
5529                         base = this.active.offset().top;
5530                         height = this.element.height();
5531                         this.active.prevAll( ".ui-menu-item" ).each(function() {
5532                                 item = $( this );
5533                                 return item.offset().top - base + height > 0;
5534                         });
5535
5536                         this.focus( event, item );
5537                 } else {
5538                         this.focus( event, this.activeMenu.find( this.options.items ).first() );
5539                 }
5540         },
5541
5542         _hasScroll: function() {
5543                 return this.element.outerHeight() < this.element.prop( "scrollHeight" );
5544         },
5545
5546         select: function( event ) {
5547                 // TODO: It should never be possible to not have an active item at this
5548                 // point, but the tests don't trigger mouseenter before click.
5549                 this.active = this.active || $( event.target ).closest( ".ui-menu-item" );
5550                 var ui = { item: this.active };
5551                 if ( !this.active.has( ".ui-menu" ).length ) {
5552                         this.collapseAll( event, true );
5553                 }
5554                 this._trigger( "select", event, ui );
5555         },
5556
5557         _filterMenuItems: function(character) {
5558                 var escapedCharacter = character.replace( /[\-\[\]{}()*+?.,\\\^$|#\s]/g, "\\$&" ),
5559                         regex = new RegExp( "^" + escapedCharacter, "i" );
5560
5561                 return this.activeMenu
5562                         .find( this.options.items )
5563
5564                         // Only match on items, not dividers or other content (#10571)
5565                         .filter( ".ui-menu-item" )
5566                         .filter(function() {
5567                                 return regex.test( $.trim( $( this ).text() ) );
5568                         });
5569         }
5570 });
5571
5572
5573 /*!
5574  * jQuery UI Autocomplete 1.11.4
5575  * http://jqueryui.com
5576  *
5577  * Copyright jQuery Foundation and other contributors
5578  * Released under the MIT license.
5579  * http://jquery.org/license
5580  *
5581  * http://api.jqueryui.com/autocomplete/
5582  */
5583
5584
5585 $.widget( "ui.autocomplete", {
5586         version: "1.11.4",
5587         defaultElement: "<input>",
5588         options: {
5589                 appendTo: null,
5590                 autoFocus: false,
5591                 delay: 300,
5592                 minLength: 1,
5593                 position: {
5594                         my: "left top",
5595                         at: "left bottom",
5596                         collision: "none"
5597                 },
5598                 source: null,
5599
5600                 // callbacks
5601                 change: null,
5602                 close: null,
5603                 focus: null,
5604                 open: null,
5605                 response: null,
5606                 search: null,
5607                 select: null
5608         },
5609
5610         requestIndex: 0,
5611         pending: 0,
5612
5613         _create: function() {
5614                 // Some browsers only repeat keydown events, not keypress events,
5615                 // so we use the suppressKeyPress flag to determine if we've already
5616                 // handled the keydown event. #7269
5617                 // Unfortunately the code for & in keypress is the same as the up arrow,
5618                 // so we use the suppressKeyPressRepeat flag to avoid handling keypress
5619                 // events when we know the keydown event was used to modify the
5620                 // search term. #7799
5621                 var suppressKeyPress, suppressKeyPressRepeat, suppressInput,
5622                         nodeName = this.element[ 0 ].nodeName.toLowerCase(),
5623                         isTextarea = nodeName === "textarea",
5624                         isInput = nodeName === "input";
5625
5626                 this.isMultiLine =
5627                         // Textareas are always multi-line
5628                         isTextarea ? true :
5629                         // Inputs are always single-line, even if inside a contentEditable element
5630                         // IE also treats inputs as contentEditable
5631                         isInput ? false :
5632                         // All other element types are determined by whether or not they're contentEditable
5633                         this.element.prop( "isContentEditable" );
5634
5635                 this.valueMethod = this.element[ isTextarea || isInput ? "val" : "text" ];
5636                 this.isNewMenu = true;
5637
5638                 this.element
5639                         .addClass( "ui-autocomplete-input" )
5640                         .attr( "autocomplete", "off" );
5641
5642                 this._on( this.element, {
5643                         keydown: function( event ) {
5644                                 if ( this.element.prop( "readOnly" ) ) {
5645                                         suppressKeyPress = true;
5646                                         suppressInput = true;
5647                                         suppressKeyPressRepeat = true;
5648                                         return;
5649                                 }
5650
5651                                 suppressKeyPress = false;
5652                                 suppressInput = false;
5653                                 suppressKeyPressRepeat = false;
5654                                 var keyCode = $.ui.keyCode;
5655                                 switch ( event.keyCode ) {
5656                                 case keyCode.PAGE_UP:
5657                                         suppressKeyPress = true;
5658                                         this._move( "previousPage", event );
5659                                         break;
5660                                 case keyCode.PAGE_DOWN:
5661                                         suppressKeyPress = true;
5662                                         this._move( "nextPage", event );
5663                                         break;
5664                                 case keyCode.UP:
5665                                         suppressKeyPress = true;
5666                                         this._keyEvent( "previous", event );
5667                                         break;
5668                                 case keyCode.DOWN:
5669                                         suppressKeyPress = true;
5670                                         this._keyEvent( "next", event );
5671                                         break;
5672                                 case keyCode.ENTER:
5673                                         // when menu is open and has focus
5674                                         if ( this.menu.active ) {
5675                                                 // #6055 - Opera still allows the keypress to occur
5676                                                 // which causes forms to submit
5677                                                 suppressKeyPress = true;
5678                                                 event.preventDefault();
5679                                                 this.menu.select( event );
5680                                         }
5681                                         break;
5682                                 case keyCode.TAB:
5683                                         if ( this.menu.active ) {
5684                                                 this.menu.select( event );
5685                                         }
5686                                         break;
5687                                 case keyCode.ESCAPE:
5688                                         if ( this.menu.element.is( ":visible" ) ) {
5689                                                 if ( !this.isMultiLine ) {
5690                                                         this._value( this.term );
5691                                                 }
5692                                                 this.close( event );
5693                                                 // Different browsers have different default behavior for escape
5694                                                 // Single press can mean undo or clear
5695                                                 // Double press in IE means clear the whole form
5696                                                 event.preventDefault();
5697                                         }
5698                                         break;
5699                                 default:
5700                                         suppressKeyPressRepeat = true;
5701                                         // search timeout should be triggered before the input value is changed
5702                                         this._searchTimeout( event );
5703                                         break;
5704                                 }
5705                         },
5706                         keypress: function( event ) {
5707                                 if ( suppressKeyPress ) {
5708                                         suppressKeyPress = false;
5709                                         if ( !this.isMultiLine || this.menu.element.is( ":visible" ) ) {
5710                                                 event.preventDefault();
5711                                         }
5712                                         return;
5713                                 }
5714                                 if ( suppressKeyPressRepeat ) {
5715                                         return;
5716                                 }
5717
5718                                 // replicate some key handlers to allow them to repeat in Firefox and Opera
5719                                 var keyCode = $.ui.keyCode;
5720                                 switch ( event.keyCode ) {
5721                                 case keyCode.PAGE_UP:
5722                                         this._move( "previousPage", event );
5723                                         break;
5724                                 case keyCode.PAGE_DOWN:
5725                                         this._move( "nextPage", event );
5726                                         break;
5727                                 case keyCode.UP:
5728                                         this._keyEvent( "previous", event );
5729                                         break;
5730                                 case keyCode.DOWN:
5731                                         this._keyEvent( "next", event );
5732                                         break;
5733                                 }
5734                         },
5735                         input: function( event ) {
5736                                 if ( suppressInput ) {
5737                                         suppressInput = false;
5738                                         event.preventDefault();
5739                                         return;
5740                                 }
5741                                 this._searchTimeout( event );
5742                         },
5743                         focus: function() {
5744                                 this.selectedItem = null;
5745                                 this.previous = this._value();
5746                         },
5747                         blur: function( event ) {
5748                                 if ( this.cancelBlur ) {
5749                                         delete this.cancelBlur;
5750                                         return;
5751                                 }
5752
5753                                 clearTimeout( this.searching );
5754                                 this.close( event );
5755                                 this._change( event );
5756                         }
5757                 });
5758
5759                 this._initSource();
5760                 this.menu = $( "<ul>" )
5761                         .addClass( "ui-autocomplete ui-front" )
5762                         .appendTo( this._appendTo() )
5763                         .menu({
5764                                 // disable ARIA support, the live region takes care of that
5765                                 role: null
5766                         })
5767                         .hide()
5768                         .menu( "instance" );
5769
5770                 this._on( this.menu.element, {
5771                         mousedown: function( event ) {
5772                                 // prevent moving focus out of the text field
5773                                 event.preventDefault();
5774
5775                                 // IE doesn't prevent moving focus even with event.preventDefault()
5776                                 // so we set a flag to know when we should ignore the blur event
5777                                 this.cancelBlur = true;
5778                                 this._delay(function() {
5779                                         delete this.cancelBlur;
5780                                 });
5781
5782                                 // clicking on the scrollbar causes focus to shift to the body
5783                                 // but we can't detect a mouseup or a click immediately afterward
5784                                 // so we have to track the next mousedown and close the menu if
5785                                 // the user clicks somewhere outside of the autocomplete
5786                                 var menuElement = this.menu.element[ 0 ];
5787                                 if ( !$( event.target ).closest( ".ui-menu-item" ).length ) {
5788                                         this._delay(function() {
5789                                                 var that = this;
5790                                                 this.document.one( "mousedown", function( event ) {
5791                                                         if ( event.target !== that.element[ 0 ] &&
5792                                                                         event.target !== menuElement &&
5793                                                                         !$.contains( menuElement, event.target ) ) {
5794                                                                 that.close();
5795                                                         }
5796                                                 });
5797                                         });
5798                                 }
5799                         },
5800                         menufocus: function( event, ui ) {
5801                                 var label, item;
5802                                 // support: Firefox
5803                                 // Prevent accidental activation of menu items in Firefox (#7024 #9118)
5804                                 if ( this.isNewMenu ) {
5805                                         this.isNewMenu = false;
5806                                         if ( event.originalEvent && /^mouse/.test( event.originalEvent.type ) ) {
5807                                                 this.menu.blur();
5808
5809                                                 this.document.one( "mousemove", function() {
5810                                                         $( event.target ).trigger( event.originalEvent );
5811                                                 });
5812
5813                                                 return;
5814                                         }
5815                                 }
5816
5817                                 item = ui.item.data( "ui-autocomplete-item" );
5818                                 if ( false !== this._trigger( "focus", event, { item: item } ) ) {
5819                                         // use value to match what will end up in the input, if it was a key event
5820                                         if ( event.originalEvent && /^key/.test( event.originalEvent.type ) ) {
5821                                                 this._value( item.value );
5822                                         }
5823                                 }
5824
5825                                 // Announce the value in the liveRegion
5826                                 label = ui.item.attr( "aria-label" ) || item.value;
5827                                 if ( label && $.trim( label ).length ) {
5828                                         this.liveRegion.children().hide();
5829                                         $( "<div>" ).text( label ).appendTo( this.liveRegion );
5830                                 }
5831                         },
5832                         menuselect: function( event, ui ) {
5833                                 var item = ui.item.data( "ui-autocomplete-item" ),
5834                                         previous = this.previous;
5835
5836                                 // only trigger when focus was lost (click on menu)
5837                                 if ( this.element[ 0 ] !== this.document[ 0 ].activeElement ) {
5838                                         this.element.focus();
5839                                         this.previous = previous;
5840                                         // #6109 - IE triggers two focus events and the second
5841                                         // is asynchronous, so we need to reset the previous
5842                                         // term synchronously and asynchronously :-(
5843                                         this._delay(function() {
5844                                                 this.previous = previous;
5845                                                 this.selectedItem = item;
5846                                         });
5847                                 }
5848
5849                                 if ( false !== this._trigger( "select", event, { item: item } ) ) {
5850                                         this._value( item.value );
5851                                 }
5852                                 // reset the term after the select event
5853                                 // this allows custom select handling to work properly
5854                                 this.term = this._value();
5855
5856                                 this.close( event );
5857                                 this.selectedItem = item;
5858                         }
5859                 });
5860
5861                 this.liveRegion = $( "<span>", {
5862                                 role: "status",
5863                                 "aria-live": "assertive",
5864                                 "aria-relevant": "additions"
5865                         })
5866                         .addClass( "ui-helper-hidden-accessible" )
5867                         .appendTo( this.document[ 0 ].body );
5868
5869                 // turning off autocomplete prevents the browser from remembering the
5870                 // value when navigating through history, so we re-enable autocomplete
5871                 // if the page is unloaded before the widget is destroyed. #7790
5872                 this._on( this.window, {
5873                         beforeunload: function() {
5874                                 this.element.removeAttr( "autocomplete" );
5875                         }
5876                 });
5877         },
5878
5879         _destroy: function() {
5880                 clearTimeout( this.searching );
5881                 this.element
5882                         .removeClass( "ui-autocomplete-input" )
5883                         .removeAttr( "autocomplete" );
5884                 this.menu.element.remove();
5885                 this.liveRegion.remove();
5886         },
5887
5888         _setOption: function( key, value ) {
5889                 this._super( key, value );
5890                 if ( key === "source" ) {
5891                         this._initSource();
5892                 }
5893                 if ( key === "appendTo" ) {
5894                         this.menu.element.appendTo( this._appendTo() );
5895                 }
5896                 if ( key === "disabled" && value && this.xhr ) {
5897                         this.xhr.abort();
5898                 }
5899         },
5900
5901         _appendTo: function() {
5902                 var element = this.options.appendTo;
5903
5904                 if ( element ) {
5905                         element = element.jquery || element.nodeType ?
5906                                 $( element ) :
5907                                 this.document.find( element ).eq( 0 );
5908                 }
5909
5910                 if ( !element || !element[ 0 ] ) {
5911                         element = this.element.closest( ".ui-front" );
5912                 }
5913
5914                 if ( !element.length ) {
5915                         element = this.document[ 0 ].body;
5916                 }
5917
5918                 return element;
5919         },
5920
5921         _initSource: function() {
5922                 var array, url,
5923                         that = this;
5924                 if ( $.isArray( this.options.source ) ) {
5925                         array = this.options.source;
5926                         this.source = function( request, response ) {
5927                                 response( $.ui.autocomplete.filter( array, request.term ) );
5928                         };
5929                 } else if ( typeof this.options.source === "string" ) {
5930                         url = this.options.source;
5931                         this.source = function( request, response ) {
5932                                 if ( that.xhr ) {
5933                                         that.xhr.abort();
5934                                 }
5935                                 that.xhr = $.ajax({
5936                                         url: url,
5937                                         data: request,
5938                                         dataType: "json",
5939                                         success: function( data ) {
5940                                                 response( data );
5941                                         },
5942                                         error: function() {
5943                                                 response([]);
5944                                         }
5945                                 });
5946                         };
5947                 } else {
5948                         this.source = this.options.source;
5949                 }
5950         },
5951
5952         _searchTimeout: function( event ) {
5953                 clearTimeout( this.searching );
5954                 this.searching = this._delay(function() {
5955
5956                         // Search if the value has changed, or if the user retypes the same value (see #7434)
5957                         var equalValues = this.term === this._value(),
5958                                 menuVisible = this.menu.element.is( ":visible" ),
5959                                 modifierKey = event.altKey || event.ctrlKey || event.metaKey || event.shiftKey;
5960
5961                         if ( !equalValues || ( equalValues && !menuVisible && !modifierKey ) ) {
5962                                 this.selectedItem = null;
5963                                 this.search( null, event );
5964                         }
5965                 }, this.options.delay );
5966         },
5967
5968         search: function( value, event ) {
5969                 value = value != null ? value : this._value();
5970
5971                 // always save the actual value, not the one passed as an argument
5972                 this.term = this._value();
5973
5974                 if ( value.length < this.options.minLength ) {
5975                         return this.close( event );
5976                 }
5977
5978                 if ( this._trigger( "search", event ) === false ) {
5979                         return;
5980                 }
5981
5982                 return this._search( value );
5983         },
5984
5985         _search: function( value ) {
5986                 this.pending++;
5987                 this.element.addClass( "ui-autocomplete-loading" );
5988                 this.cancelSearch = false;
5989
5990                 this.source( { term: value }, this._response() );
5991         },
5992
5993         _response: function() {
5994                 var index = ++this.requestIndex;
5995
5996                 return $.proxy(function( content ) {
5997                         if ( index === this.requestIndex ) {
5998                                 this.__response( content );
5999                         }
6000
6001                         this.pending--;
6002                         if ( !this.pending ) {
6003                                 this.element.removeClass( "ui-autocomplete-loading" );
6004                         }
6005                 }, this );
6006         },
6007
6008         __response: function( content ) {
6009                 if ( content ) {
6010                         content = this._normalize( content );
6011                 }
6012                 this._trigger( "response", null, { content: content } );
6013                 if ( !this.options.disabled && content && content.length && !this.cancelSearch ) {
6014                         this._suggest( content );
6015                         this._trigger( "open" );
6016                 } else {
6017                         // use ._close() instead of .close() so we don't cancel future searches
6018                         this._close();
6019                 }
6020         },
6021
6022         close: function( event ) {
6023                 this.cancelSearch = true;
6024                 this._close( event );
6025         },
6026
6027         _close: function( event ) {
6028                 if ( this.menu.element.is( ":visible" ) ) {
6029                         this.menu.element.hide();
6030                         this.menu.blur();
6031                         this.isNewMenu = true;
6032                         this._trigger( "close", event );
6033                 }
6034         },
6035
6036         _change: function( event ) {
6037                 if ( this.previous !== this._value() ) {
6038                         this._trigger( "change", event, { item: this.selectedItem } );
6039                 }
6040         },
6041
6042         _normalize: function( items ) {
6043                 // assume all items have the right format when the first item is complete
6044                 if ( items.length && items[ 0 ].label && items[ 0 ].value ) {
6045                         return items;
6046                 }
6047                 return $.map( items, function( item ) {
6048                         if ( typeof item === "string" ) {
6049                                 return {
6050                                         label: item,
6051                                         value: item
6052                                 };
6053                         }
6054                         return $.extend( {}, item, {
6055                                 label: item.label || item.value,
6056                                 value: item.value || item.label
6057                         });
6058                 });
6059         },
6060
6061         _suggest: function( items ) {
6062                 var ul = this.menu.element.empty();
6063                 this._renderMenu( ul, items );
6064                 this.isNewMenu = true;
6065                 this.menu.refresh();
6066
6067                 // size and position menu
6068                 ul.show();
6069                 this._resizeMenu();
6070                 ul.position( $.extend({
6071                         of: this.element
6072                 }, this.options.position ) );
6073
6074                 if ( this.options.autoFocus ) {
6075                         this.menu.next();
6076                 }
6077         },
6078
6079         _resizeMenu: function() {
6080                 var ul = this.menu.element;
6081                 ul.outerWidth( Math.max(
6082                         // Firefox wraps long text (possibly a rounding bug)
6083                         // so we add 1px to avoid the wrapping (#7513)
6084                         ul.width( "" ).outerWidth() + 1,
6085                         this.element.outerWidth()
6086                 ) );
6087         },
6088
6089         _renderMenu: function( ul, items ) {
6090                 var that = this;
6091                 $.each( items, function( index, item ) {
6092                         that._renderItemData( ul, item );
6093                 });
6094         },
6095
6096         _renderItemData: function( ul, item ) {
6097                 return this._renderItem( ul, item ).data( "ui-autocomplete-item", item );
6098         },
6099
6100         _renderItem: function( ul, item ) {
6101                 return $( "<li>" ).text( item.label ).appendTo( ul );
6102         },
6103
6104         _move: function( direction, event ) {
6105                 if ( !this.menu.element.is( ":visible" ) ) {
6106                         this.search( null, event );
6107                         return;
6108                 }
6109                 if ( this.menu.isFirstItem() && /^previous/.test( direction ) ||
6110                                 this.menu.isLastItem() && /^next/.test( direction ) ) {
6111
6112                         if ( !this.isMultiLine ) {
6113                                 this._value( this.term );
6114                         }
6115
6116                         this.menu.blur();
6117                         return;
6118                 }
6119                 this.menu[ direction ]( event );
6120         },
6121
6122         widget: function() {
6123                 return this.menu.element;
6124         },
6125
6126         _value: function() {
6127                 return this.valueMethod.apply( this.element, arguments );
6128         },
6129
6130         _keyEvent: function( keyEvent, event ) {
6131                 if ( !this.isMultiLine || this.menu.element.is( ":visible" ) ) {
6132                         this._move( keyEvent, event );
6133
6134                         // prevents moving cursor to beginning/end of the text field in some browsers
6135                         event.preventDefault();
6136                 }
6137         }
6138 });
6139
6140 $.extend( $.ui.autocomplete, {
6141         escapeRegex: function( value ) {
6142                 return value.replace( /[\-\[\]{}()*+?.,\\\^$|#\s]/g, "\\$&" );
6143         },
6144         filter: function( array, term ) {
6145                 var matcher = new RegExp( $.ui.autocomplete.escapeRegex( term ), "i" );
6146                 return $.grep( array, function( value ) {
6147                         return matcher.test( value.label || value.value || value );
6148                 });
6149         }
6150 });
6151
6152 // live region extension, adding a `messages` option
6153 // NOTE: This is an experimental API. We are still investigating
6154 // a full solution for string manipulation and internationalization.
6155 $.widget( "ui.autocomplete", $.ui.autocomplete, {
6156         options: {
6157                 messages: {
6158                         noResults: "No search results.",
6159                         results: function( amount ) {
6160                                 return amount + ( amount > 1 ? " results are" : " result is" ) +
6161                                         " available, use up and down arrow keys to navigate.";
6162                         }
6163                 }
6164         },
6165
6166         __response: function( content ) {
6167                 var message;
6168                 this._superApply( arguments );
6169                 if ( this.options.disabled || this.cancelSearch ) {
6170                         return;
6171                 }
6172                 if ( content && content.length ) {
6173                         message = this.options.messages.results( content.length );
6174                 } else {
6175                         message = this.options.messages.noResults;
6176                 }
6177                 this.liveRegion.children().hide();
6178                 $( "<div>" ).text( message ).appendTo( this.liveRegion );
6179         }
6180 });
6181
6182 var autocomplete = $.ui.autocomplete;
6183
6184
6185 /*!
6186  * jQuery UI Button 1.11.4
6187  * http://jqueryui.com
6188  *
6189  * Copyright jQuery Foundation and other contributors
6190  * Released under the MIT license.
6191  * http://jquery.org/license
6192  *
6193  * http://api.jqueryui.com/button/
6194  */
6195
6196
6197 var lastActive,
6198         baseClasses = "ui-button ui-widget ui-state-default ui-corner-all",
6199         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",
6200         formResetHandler = function() {
6201                 var form = $( this );
6202                 setTimeout(function() {
6203                         form.find( ":ui-button" ).button( "refresh" );
6204                 }, 1 );
6205         },
6206         radioGroup = function( radio ) {
6207                 var name = radio.name,
6208                         form = radio.form,
6209                         radios = $( [] );
6210                 if ( name ) {
6211                         name = name.replace( /'/g, "\\'" );
6212                         if ( form ) {
6213                                 radios = $( form ).find( "[name='" + name + "'][type=radio]" );
6214                         } else {
6215                                 radios = $( "[name='" + name + "'][type=radio]", radio.ownerDocument )
6216                                         .filter(function() {
6217                                                 return !this.form;
6218                                         });
6219                         }
6220                 }
6221                 return radios;
6222         };
6223
6224 $.widget( "ui.button", {
6225         version: "1.11.4",
6226         defaultElement: "<button>",
6227         options: {
6228                 disabled: null,
6229                 text: true,
6230                 label: null,
6231                 icons: {
6232                         primary: null,
6233                         secondary: null
6234                 }
6235         },
6236         _create: function() {
6237                 this.element.closest( "form" )
6238                         .unbind( "reset" + this.eventNamespace )
6239                         .bind( "reset" + this.eventNamespace, formResetHandler );
6240
6241                 if ( typeof this.options.disabled !== "boolean" ) {
6242                         this.options.disabled = !!this.element.prop( "disabled" );
6243                 } else {
6244                         this.element.prop( "disabled", this.options.disabled );
6245                 }
6246
6247                 this._determineButtonType();
6248                 this.hasTitle = !!this.buttonElement.attr( "title" );
6249
6250                 var that = this,
6251                         options = this.options,
6252                         toggleButton = this.type === "checkbox" || this.type === "radio",
6253                         activeClass = !toggleButton ? "ui-state-active" : "";
6254
6255                 if ( options.label === null ) {
6256                         options.label = (this.type === "input" ? this.buttonElement.val() : this.buttonElement.html());
6257                 }
6258
6259                 this._hoverable( this.buttonElement );
6260
6261                 this.buttonElement
6262                         .addClass( baseClasses )
6263                         .attr( "role", "button" )
6264                         .bind( "mouseenter" + this.eventNamespace, function() {
6265                                 if ( options.disabled ) {
6266                                         return;
6267                                 }
6268                                 if ( this === lastActive ) {
6269                                         $( this ).addClass( "ui-state-active" );
6270                                 }
6271                         })
6272                         .bind( "mouseleave" + this.eventNamespace, function() {
6273                                 if ( options.disabled ) {
6274                                         return;
6275                                 }
6276                                 $( this ).removeClass( activeClass );
6277                         })
6278                         .bind( "click" + this.eventNamespace, function( event ) {
6279                                 if ( options.disabled ) {
6280                                         event.preventDefault();
6281                                         event.stopImmediatePropagation();
6282                                 }
6283                         });
6284
6285                 // Can't use _focusable() because the element that receives focus
6286                 // and the element that gets the ui-state-focus class are different
6287                 this._on({
6288                         focus: function() {
6289                                 this.buttonElement.addClass( "ui-state-focus" );
6290                         },
6291                         blur: function() {
6292                                 this.buttonElement.removeClass( "ui-state-focus" );
6293                         }
6294                 });
6295
6296                 if ( toggleButton ) {
6297                         this.element.bind( "change" + this.eventNamespace, function() {
6298                                 that.refresh();
6299                         });
6300                 }
6301
6302                 if ( this.type === "checkbox" ) {
6303                         this.buttonElement.bind( "click" + this.eventNamespace, function() {
6304                                 if ( options.disabled ) {
6305                                         return false;
6306                                 }
6307                         });
6308                 } else if ( this.type === "radio" ) {
6309                         this.buttonElement.bind( "click" + this.eventNamespace, function() {
6310                                 if ( options.disabled ) {
6311                                         return false;
6312                                 }
6313                                 $( this ).addClass( "ui-state-active" );
6314                                 that.buttonElement.attr( "aria-pressed", "true" );
6315
6316                                 var radio = that.element[ 0 ];
6317                                 radioGroup( radio )
6318                                         .not( radio )
6319                                         .map(function() {
6320                                                 return $( this ).button( "widget" )[ 0 ];
6321                                         })
6322                                         .removeClass( "ui-state-active" )
6323                                         .attr( "aria-pressed", "false" );
6324                         });
6325                 } else {
6326                         this.buttonElement
6327                                 .bind( "mousedown" + this.eventNamespace, function() {
6328                                         if ( options.disabled ) {
6329                                                 return false;
6330                                         }
6331                                         $( this ).addClass( "ui-state-active" );
6332                                         lastActive = this;
6333                                         that.document.one( "mouseup", function() {
6334                                                 lastActive = null;
6335                                         });
6336                                 })
6337                                 .bind( "mouseup" + this.eventNamespace, function() {
6338                                         if ( options.disabled ) {
6339                                                 return false;
6340                                         }
6341                                         $( this ).removeClass( "ui-state-active" );
6342                                 })
6343                                 .bind( "keydown" + this.eventNamespace, function(event) {
6344                                         if ( options.disabled ) {
6345                                                 return false;
6346                                         }
6347                                         if ( event.keyCode === $.ui.keyCode.SPACE || event.keyCode === $.ui.keyCode.ENTER ) {
6348                                                 $( this ).addClass( "ui-state-active" );
6349                                         }
6350                                 })
6351                                 // see #8559, we bind to blur here in case the button element loses
6352                                 // focus between keydown and keyup, it would be left in an "active" state
6353                                 .bind( "keyup" + this.eventNamespace + " blur" + this.eventNamespace, function() {
6354                                         $( this ).removeClass( "ui-state-active" );
6355                                 });
6356
6357                         if ( this.buttonElement.is("a") ) {
6358                                 this.buttonElement.keyup(function(event) {
6359                                         if ( event.keyCode === $.ui.keyCode.SPACE ) {
6360                                                 // TODO pass through original event correctly (just as 2nd argument doesn't work)
6361                                                 $( this ).click();
6362                                         }
6363                                 });
6364                         }
6365                 }
6366
6367                 this._setOption( "disabled", options.disabled );
6368                 this._resetButton();
6369         },
6370
6371         _determineButtonType: function() {
6372                 var ancestor, labelSelector, checked;
6373
6374                 if ( this.element.is("[type=checkbox]") ) {
6375                         this.type = "checkbox";
6376                 } else if ( this.element.is("[type=radio]") ) {
6377                         this.type = "radio";
6378                 } else if ( this.element.is("input") ) {
6379                         this.type = "input";
6380                 } else {
6381                         this.type = "button";
6382                 }
6383
6384                 if ( this.type === "checkbox" || this.type === "radio" ) {
6385                         // we don't search against the document in case the element
6386                         // is disconnected from the DOM
6387                         ancestor = this.element.parents().last();
6388                         labelSelector = "label[for='" + this.element.attr("id") + "']";
6389                         this.buttonElement = ancestor.find( labelSelector );
6390                         if ( !this.buttonElement.length ) {
6391                                 ancestor = ancestor.length ? ancestor.siblings() : this.element.siblings();
6392                                 this.buttonElement = ancestor.filter( labelSelector );
6393                                 if ( !this.buttonElement.length ) {
6394                                         this.buttonElement = ancestor.find( labelSelector );
6395                                 }
6396                         }
6397                         this.element.addClass( "ui-helper-hidden-accessible" );
6398
6399                         checked = this.element.is( ":checked" );
6400                         if ( checked ) {
6401                                 this.buttonElement.addClass( "ui-state-active" );
6402                         }
6403                         this.buttonElement.prop( "aria-pressed", checked );
6404                 } else {
6405                         this.buttonElement = this.element;
6406                 }
6407         },
6408
6409         widget: function() {
6410                 return this.buttonElement;
6411         },
6412
6413         _destroy: function() {
6414                 this.element
6415                         .removeClass( "ui-helper-hidden-accessible" );
6416                 this.buttonElement
6417                         .removeClass( baseClasses + " ui-state-active " + typeClasses )
6418                         .removeAttr( "role" )
6419                         .removeAttr( "aria-pressed" )
6420                         .html( this.buttonElement.find(".ui-button-text").html() );
6421
6422                 if ( !this.hasTitle ) {
6423                         this.buttonElement.removeAttr( "title" );
6424                 }
6425         },
6426
6427         _setOption: function( key, value ) {
6428                 this._super( key, value );
6429                 if ( key === "disabled" ) {
6430                         this.widget().toggleClass( "ui-state-disabled", !!value );
6431                         this.element.prop( "disabled", !!value );
6432                         if ( value ) {
6433                                 if ( this.type === "checkbox" || this.type === "radio" ) {
6434                                         this.buttonElement.removeClass( "ui-state-focus" );
6435                                 } else {
6436                                         this.buttonElement.removeClass( "ui-state-focus ui-state-active" );
6437                                 }
6438                         }
6439                         return;
6440                 }
6441                 this._resetButton();
6442         },
6443
6444         refresh: function() {
6445                 //See #8237 & #8828
6446                 var isDisabled = this.element.is( "input, button" ) ? this.element.is( ":disabled" ) : this.element.hasClass( "ui-button-disabled" );
6447
6448                 if ( isDisabled !== this.options.disabled ) {
6449                         this._setOption( "disabled", isDisabled );
6450                 }
6451                 if ( this.type === "radio" ) {
6452                         radioGroup( this.element[0] ).each(function() {
6453                                 if ( $( this ).is( ":checked" ) ) {
6454                                         $( this ).button( "widget" )
6455                                                 .addClass( "ui-state-active" )
6456                                                 .attr( "aria-pressed", "true" );
6457                                 } else {
6458                                         $( this ).button( "widget" )
6459                                                 .removeClass( "ui-state-active" )
6460                                                 .attr( "aria-pressed", "false" );
6461                                 }
6462                         });
6463                 } else if ( this.type === "checkbox" ) {
6464                         if ( this.element.is( ":checked" ) ) {
6465                                 this.buttonElement
6466                                         .addClass( "ui-state-active" )
6467                                         .attr( "aria-pressed", "true" );
6468                         } else {
6469                                 this.buttonElement
6470                                         .removeClass( "ui-state-active" )
6471                                         .attr( "aria-pressed", "false" );
6472                         }
6473                 }
6474         },
6475
6476         _resetButton: function() {
6477                 if ( this.type === "input" ) {
6478                         if ( this.options.label ) {
6479                                 this.element.val( this.options.label );
6480                         }
6481                         return;
6482                 }
6483                 var buttonElement = this.buttonElement.removeClass( typeClasses ),
6484                         buttonText = $( "<span></span>", this.document[0] )
6485                                 .addClass( "ui-button-text" )
6486                                 .html( this.options.label )
6487                                 .appendTo( buttonElement.empty() )
6488                                 .text(),
6489                         icons = this.options.icons,
6490                         multipleIcons = icons.primary && icons.secondary,
6491                         buttonClasses = [];
6492
6493                 if ( icons.primary || icons.secondary ) {
6494                         if ( this.options.text ) {
6495                                 buttonClasses.push( "ui-button-text-icon" + ( multipleIcons ? "s" : ( icons.primary ? "-primary" : "-secondary" ) ) );
6496                         }
6497
6498                         if ( icons.primary ) {
6499                                 buttonElement.prepend( "<span class='ui-button-icon-primary ui-icon " + icons.primary + "'></span>" );
6500                         }
6501
6502                         if ( icons.secondary ) {
6503                                 buttonElement.append( "<span class='ui-button-icon-secondary ui-icon " + icons.secondary + "'></span>" );
6504                         }
6505
6506                         if ( !this.options.text ) {
6507                                 buttonClasses.push( multipleIcons ? "ui-button-icons-only" : "ui-button-icon-only" );
6508
6509                                 if ( !this.hasTitle ) {
6510                                         buttonElement.attr( "title", $.trim( buttonText ) );
6511                                 }
6512                         }
6513                 } else {
6514                         buttonClasses.push( "ui-button-text-only" );
6515                 }
6516                 buttonElement.addClass( buttonClasses.join( " " ) );
6517         }
6518 });
6519
6520 $.widget( "ui.buttonset", {
6521         version: "1.11.4",
6522         options: {
6523                 items: "button, input[type=button], input[type=submit], input[type=reset], input[type=checkbox], input[type=radio], a, :data(ui-button)"
6524         },
6525
6526         _create: function() {
6527                 this.element.addClass( "ui-buttonset" );
6528         },
6529
6530         _init: function() {
6531                 this.refresh();
6532         },
6533
6534         _setOption: function( key, value ) {
6535                 if ( key === "disabled" ) {
6536                         this.buttons.button( "option", key, value );
6537                 }
6538
6539                 this._super( key, value );
6540         },
6541
6542         refresh: function() {
6543                 var rtl = this.element.css( "direction" ) === "rtl",
6544                         allButtons = this.element.find( this.options.items ),
6545                         existingButtons = allButtons.filter( ":ui-button" );
6546
6547                 // Initialize new buttons
6548                 allButtons.not( ":ui-button" ).button();
6549
6550                 // Refresh existing buttons
6551                 existingButtons.button( "refresh" );
6552
6553                 this.buttons = allButtons
6554                         .map(function() {
6555                                 return $( this ).button( "widget" )[ 0 ];
6556                         })
6557                                 .removeClass( "ui-corner-all ui-corner-left ui-corner-right" )
6558                                 .filter( ":first" )
6559                                         .addClass( rtl ? "ui-corner-right" : "ui-corner-left" )
6560                                 .end()
6561                                 .filter( ":last" )
6562                                         .addClass( rtl ? "ui-corner-left" : "ui-corner-right" )
6563                                 .end()
6564                         .end();
6565         },
6566
6567         _destroy: function() {
6568                 this.element.removeClass( "ui-buttonset" );
6569                 this.buttons
6570                         .map(function() {
6571                                 return $( this ).button( "widget" )[ 0 ];
6572                         })
6573                                 .removeClass( "ui-corner-left ui-corner-right" )
6574                         .end()
6575                         .button( "destroy" );
6576         }
6577 });
6578
6579 var button = $.ui.button;
6580
6581
6582 /*!
6583  * jQuery UI Datepicker 1.11.4
6584  * http://jqueryui.com
6585  *
6586  * Copyright jQuery Foundation and other contributors
6587  * Released under the MIT license.
6588  * http://jquery.org/license
6589  *
6590  * http://api.jqueryui.com/datepicker/
6591  */
6592
6593
6594 $.extend($.ui, { datepicker: { version: "1.11.4" } });
6595
6596 var datepicker_instActive;
6597
6598 function datepicker_getZindex( elem ) {
6599         var position, value;
6600         while ( elem.length && elem[ 0 ] !== document ) {
6601                 // Ignore z-index if position is set to a value where z-index is ignored by the browser
6602                 // This makes behavior of this function consistent across browsers
6603                 // WebKit always returns auto if the element is positioned
6604                 position = elem.css( "position" );
6605                 if ( position === "absolute" || position === "relative" || position === "fixed" ) {
6606                         // IE returns 0 when zIndex is not specified
6607                         // other browsers return a string
6608                         // we ignore the case of nested elements with an explicit value of 0
6609                         // <div style="z-index: -10;"><div style="z-index: 0;"></div></div>
6610                         value = parseInt( elem.css( "zIndex" ), 10 );
6611                         if ( !isNaN( value ) && value !== 0 ) {
6612                                 return value;
6613                         }
6614                 }
6615                 elem = elem.parent();
6616         }
6617
6618         return 0;
6619 }
6620 /* Date picker manager.
6621    Use the singleton instance of this class, $.datepicker, to interact with the date picker.
6622    Settings for (groups of) date pickers are maintained in an instance object,
6623    allowing multiple different settings on the same page. */
6624
6625 function Datepicker() {
6626         this._curInst = null; // The current instance in use
6627         this._keyEvent = false; // If the last event was a key event
6628         this._disabledInputs = []; // List of date picker inputs that have been disabled
6629         this._datepickerShowing = false; // True if the popup picker is showing , false if not
6630         this._inDialog = false; // True if showing within a "dialog", false if not
6631         this._mainDivId = "ui-datepicker-div"; // The ID of the main datepicker division
6632         this._inlineClass = "ui-datepicker-inline"; // The name of the inline marker class
6633         this._appendClass = "ui-datepicker-append"; // The name of the append marker class
6634         this._triggerClass = "ui-datepicker-trigger"; // The name of the trigger marker class
6635         this._dialogClass = "ui-datepicker-dialog"; // The name of the dialog marker class
6636         this._disableClass = "ui-datepicker-disabled"; // The name of the disabled covering marker class
6637         this._unselectableClass = "ui-datepicker-unselectable"; // The name of the unselectable cell marker class
6638         this._currentClass = "ui-datepicker-current-day"; // The name of the current day marker class
6639         this._dayOverClass = "ui-datepicker-days-cell-over"; // The name of the day hover marker class
6640         this.regional = []; // Available regional settings, indexed by language code
6641         this.regional[""] = { // Default regional settings
6642                 closeText: "Done", // Display text for close link
6643                 prevText: "Prev", // Display text for previous month link
6644                 nextText: "Next", // Display text for next month link
6645                 currentText: "Today", // Display text for current month link
6646                 monthNames: ["January","February","March","April","May","June",
6647                         "July","August","September","October","November","December"], // Names of months for drop-down and formatting
6648                 monthNamesShort: ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"], // For formatting
6649                 dayNames: ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"], // For formatting
6650                 dayNamesShort: ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"], // For formatting
6651                 dayNamesMin: ["Su","Mo","Tu","We","Th","Fr","Sa"], // Column headings for days starting at Sunday
6652                 weekHeader: "Wk", // Column header for week of the year
6653                 dateFormat: "mm/dd/yy", // See format options on parseDate
6654                 firstDay: 0, // The first day of the week, Sun = 0, Mon = 1, ...
6655                 isRTL: false, // True if right-to-left language, false if left-to-right
6656                 showMonthAfterYear: false, // True if the year select precedes month, false for month then year
6657                 yearSuffix: "" // Additional text to append to the year in the month headers
6658         };
6659         this._defaults = { // Global defaults for all the date picker instances
6660                 showOn: "focus", // "focus" for popup on focus,
6661                         // "button" for trigger button, or "both" for either
6662                 showAnim: "fadeIn", // Name of jQuery animation for popup
6663                 showOptions: {}, // Options for enhanced animations
6664                 defaultDate: null, // Used when field is blank: actual date,
6665                         // +/-number for offset from today, null for today
6666                 appendText: "", // Display text following the input box, e.g. showing the format
6667                 buttonText: "...", // Text for trigger button
6668                 buttonImage: "", // URL for trigger button image
6669                 buttonImageOnly: false, // True if the image appears alone, false if it appears on a button
6670                 hideIfNoPrevNext: false, // True to hide next/previous month links
6671                         // if not applicable, false to just disable them
6672                 navigationAsDateFormat: false, // True if date formatting applied to prev/today/next links
6673                 gotoCurrent: false, // True if today link goes back to current selection instead
6674                 changeMonth: false, // True if month can be selected directly, false if only prev/next
6675                 changeYear: false, // True if year can be selected directly, false if only prev/next
6676                 yearRange: "c-10:c+10", // Range of years to display in drop-down,
6677                         // either relative to today's year (-nn:+nn), relative to currently displayed year
6678                         // (c-nn:c+nn), absolute (nnnn:nnnn), or a combination of the above (nnnn:-n)
6679                 showOtherMonths: false, // True to show dates in other months, false to leave blank
6680                 selectOtherMonths: false, // True to allow selection of dates in other months, false for unselectable
6681                 showWeek: false, // True to show week of the year, false to not show it
6682                 calculateWeek: this.iso8601Week, // How to calculate the week of the year,
6683                         // takes a Date and returns the number of the week for it
6684                 shortYearCutoff: "+10", // Short year values < this are in the current century,
6685                         // > this are in the previous century,
6686                         // string value starting with "+" for current year + value
6687                 minDate: null, // The earliest selectable date, or null for no limit
6688                 maxDate: null, // The latest selectable date, or null for no limit
6689                 duration: "fast", // Duration of display/closure
6690                 beforeShowDay: null, // Function that takes a date and returns an array with
6691                         // [0] = true if selectable, false if not, [1] = custom CSS class name(s) or "",
6692                         // [2] = cell title (optional), e.g. $.datepicker.noWeekends
6693                 beforeShow: null, // Function that takes an input field and
6694                         // returns a set of custom settings for the date picker
6695                 onSelect: null, // Define a callback function when a date is selected
6696                 onChangeMonthYear: null, // Define a callback function when the month or year is changed
6697                 onClose: null, // Define a callback function when the datepicker is closed
6698                 numberOfMonths: 1, // Number of months to show at a time
6699                 showCurrentAtPos: 0, // The position in multipe months at which to show the current month (starting at 0)
6700                 stepMonths: 1, // Number of months to step back/forward
6701                 stepBigMonths: 12, // Number of months to step back/forward for the big links
6702                 altField: "", // Selector for an alternate field to store selected dates into
6703                 altFormat: "", // The date format to use for the alternate field
6704                 constrainInput: true, // The input is constrained by the current date format
6705                 showButtonPanel: false, // True to show button panel, false to not show it
6706                 autoSize: false, // True to size the input for the date format, false to leave as is
6707                 disabled: false // The initial disabled state
6708         };
6709         $.extend(this._defaults, this.regional[""]);
6710         this.regional.en = $.extend( true, {}, this.regional[ "" ]);
6711         this.regional[ "en-US" ] = $.extend( true, {}, this.regional.en );
6712         this.dpDiv = datepicker_bindHover($("<div id='" + this._mainDivId + "' class='ui-datepicker ui-widget ui-widget-content ui-helper-clearfix ui-corner-all'></div>"));
6713 }
6714
6715 $.extend(Datepicker.prototype, {
6716         /* Class name added to elements to indicate already configured with a date picker. */
6717         markerClassName: "hasDatepicker",
6718
6719         //Keep track of the maximum number of rows displayed (see #7043)
6720         maxRows: 4,
6721
6722         // TODO rename to "widget" when switching to widget factory
6723         _widgetDatepicker: function() {
6724                 return this.dpDiv;
6725         },
6726
6727         /* Override the default settings for all instances of the date picker.
6728          * @param  settings  object - the new settings to use as defaults (anonymous object)
6729          * @return the manager object
6730          */
6731         setDefaults: function(settings) {
6732                 datepicker_extendRemove(this._defaults, settings || {});
6733                 return this;
6734         },
6735
6736         /* Attach the date picker to a jQuery selection.
6737          * @param  target       element - the target input field or division or span
6738          * @param  settings  object - the new settings to use for this date picker instance (anonymous)
6739          */
6740         _attachDatepicker: function(target, settings) {
6741                 var nodeName, inline, inst;
6742                 nodeName = target.nodeName.toLowerCase();
6743                 inline = (nodeName === "div" || nodeName === "span");
6744                 if (!target.id) {
6745                         this.uuid += 1;
6746                         target.id = "dp" + this.uuid;
6747                 }
6748                 inst = this._newInst($(target), inline);
6749                 inst.settings = $.extend({}, settings || {});
6750                 if (nodeName === "input") {
6751                         this._connectDatepicker(target, inst);
6752                 } else if (inline) {
6753                         this._inlineDatepicker(target, inst);
6754                 }
6755         },
6756
6757         /* Create a new instance object. */
6758         _newInst: function(target, inline) {
6759                 var id = target[0].id.replace(/([^A-Za-z0-9_\-])/g, "\\\\$1"); // escape jQuery meta chars
6760                 return {id: id, input: target, // associated target
6761                         selectedDay: 0, selectedMonth: 0, selectedYear: 0, // current selection
6762                         drawMonth: 0, drawYear: 0, // month being drawn
6763                         inline: inline, // is datepicker inline or not
6764                         dpDiv: (!inline ? this.dpDiv : // presentation div
6765                         datepicker_bindHover($("<div class='" + this._inlineClass + " ui-datepicker ui-widget ui-widget-content ui-helper-clearfix ui-corner-all'></div>")))};
6766         },
6767
6768         /* Attach the date picker to an input field. */
6769         _connectDatepicker: function(target, inst) {
6770                 var input = $(target);
6771                 inst.append = $([]);
6772                 inst.trigger = $([]);
6773                 if (input.hasClass(this.markerClassName)) {
6774                         return;
6775                 }
6776                 this._attachments(input, inst);
6777                 input.addClass(this.markerClassName).keydown(this._doKeyDown).
6778                         keypress(this._doKeyPress).keyup(this._doKeyUp);
6779                 this._autoSize(inst);
6780                 $.data(target, "datepicker", inst);
6781                 //If disabled option is true, disable the datepicker once it has been attached to the input (see ticket #5665)
6782                 if( inst.settings.disabled ) {
6783                         this._disableDatepicker( target );
6784                 }
6785         },
6786
6787         /* Make attachments based on settings. */
6788         _attachments: function(input, inst) {
6789                 var showOn, buttonText, buttonImage,
6790                         appendText = this._get(inst, "appendText"),
6791                         isRTL = this._get(inst, "isRTL");
6792
6793                 if (inst.append) {
6794                         inst.append.remove();
6795                 }
6796                 if (appendText) {
6797                         inst.append = $("<span class='" + this._appendClass + "'>" + appendText + "</span>");
6798                         input[isRTL ? "before" : "after"](inst.append);
6799                 }
6800
6801                 input.unbind("focus", this._showDatepicker);
6802
6803                 if (inst.trigger) {
6804                         inst.trigger.remove();
6805                 }
6806
6807                 showOn = this._get(inst, "showOn");
6808                 if (showOn === "focus" || showOn === "both") { // pop-up date picker when in the marked field
6809                         input.focus(this._showDatepicker);
6810                 }
6811                 if (showOn === "button" || showOn === "both") { // pop-up date picker when button clicked
6812                         buttonText = this._get(inst, "buttonText");
6813                         buttonImage = this._get(inst, "buttonImage");
6814                         inst.trigger = $(this._get(inst, "buttonImageOnly") ?
6815                                 $("<img/>").addClass(this._triggerClass).
6816                                         attr({ src: buttonImage, alt: buttonText, title: buttonText }) :
6817                                 $("<button type='button'></button>").addClass(this._triggerClass).
6818                                         html(!buttonImage ? buttonText : $("<img/>").attr(
6819                                         { src:buttonImage, alt:buttonText, title:buttonText })));
6820                         input[isRTL ? "before" : "after"](inst.trigger);
6821                         inst.trigger.click(function() {
6822                                 if ($.datepicker._datepickerShowing && $.datepicker._lastInput === input[0]) {
6823                                         $.datepicker._hideDatepicker();
6824                                 } else if ($.datepicker._datepickerShowing && $.datepicker._lastInput !== input[0]) {
6825                                         $.datepicker._hideDatepicker();
6826                                         $.datepicker._showDatepicker(input[0]);
6827                                 } else {
6828                                         $.datepicker._showDatepicker(input[0]);
6829                                 }
6830                                 return false;
6831                         });
6832                 }
6833         },
6834
6835         /* Apply the maximum length for the date format. */
6836         _autoSize: function(inst) {
6837                 if (this._get(inst, "autoSize") && !inst.inline) {
6838                         var findMax, max, maxI, i,
6839                                 date = new Date(2009, 12 - 1, 20), // Ensure double digits
6840                                 dateFormat = this._get(inst, "dateFormat");
6841
6842                         if (dateFormat.match(/[DM]/)) {
6843                                 findMax = function(names) {
6844                                         max = 0;
6845                                         maxI = 0;
6846                                         for (i = 0; i < names.length; i++) {
6847                                                 if (names[i].length > max) {
6848                                                         max = names[i].length;
6849                                                         maxI = i;
6850                                                 }
6851                                         }
6852                                         return maxI;
6853                                 };
6854                                 date.setMonth(findMax(this._get(inst, (dateFormat.match(/MM/) ?
6855                                         "monthNames" : "monthNamesShort"))));
6856                                 date.setDate(findMax(this._get(inst, (dateFormat.match(/DD/) ?
6857                                         "dayNames" : "dayNamesShort"))) + 20 - date.getDay());
6858                         }
6859                         inst.input.attr("size", this._formatDate(inst, date).length);
6860                 }
6861         },
6862
6863         /* Attach an inline date picker to a div. */
6864         _inlineDatepicker: function(target, inst) {
6865                 var divSpan = $(target);
6866                 if (divSpan.hasClass(this.markerClassName)) {
6867                         return;
6868                 }
6869                 divSpan.addClass(this.markerClassName).append(inst.dpDiv);
6870                 $.data(target, "datepicker", inst);
6871                 this._setDate(inst, this._getDefaultDate(inst), true);
6872                 this._updateDatepicker(inst);
6873                 this._updateAlternate(inst);
6874                 //If disabled option is true, disable the datepicker before showing it (see ticket #5665)
6875                 if( inst.settings.disabled ) {
6876                         this._disableDatepicker( target );
6877                 }
6878                 // Set display:block in place of inst.dpDiv.show() which won't work on disconnected elements
6879                 // http://bugs.jqueryui.com/ticket/7552 - A Datepicker created on a detached div has zero height
6880                 inst.dpDiv.css( "display", "block" );
6881         },
6882
6883         /* Pop-up the date picker in a "dialog" box.
6884          * @param  input element - ignored
6885          * @param  date string or Date - the initial date to display
6886          * @param  onSelect  function - the function to call when a date is selected
6887          * @param  settings  object - update the dialog date picker instance's settings (anonymous object)
6888          * @param  pos int[2] - coordinates for the dialog's position within the screen or
6889          *                                      event - with x/y coordinates or
6890          *                                      leave empty for default (screen centre)
6891          * @return the manager object
6892          */
6893         _dialogDatepicker: function(input, date, onSelect, settings, pos) {
6894                 var id, browserWidth, browserHeight, scrollX, scrollY,
6895                         inst = this._dialogInst; // internal instance
6896
6897                 if (!inst) {
6898                         this.uuid += 1;
6899                         id = "dp" + this.uuid;
6900                         this._dialogInput = $("<input type='text' id='" + id +
6901                                 "' style='position: absolute; top: -100px; width: 0px;'/>");
6902                         this._dialogInput.keydown(this._doKeyDown);
6903                         $("body").append(this._dialogInput);
6904                         inst = this._dialogInst = this._newInst(this._dialogInput, false);
6905                         inst.settings = {};
6906                         $.data(this._dialogInput[0], "datepicker", inst);
6907                 }
6908                 datepicker_extendRemove(inst.settings, settings || {});
6909                 date = (date && date.constructor === Date ? this._formatDate(inst, date) : date);
6910                 this._dialogInput.val(date);
6911
6912                 this._pos = (pos ? (pos.length ? pos : [pos.pageX, pos.pageY]) : null);
6913                 if (!this._pos) {
6914                         browserWidth = document.documentElement.clientWidth;
6915                         browserHeight = document.documentElement.clientHeight;
6916                         scrollX = document.documentElement.scrollLeft || document.body.scrollLeft;
6917                         scrollY = document.documentElement.scrollTop || document.body.scrollTop;
6918                         this._pos = // should use actual width/height below
6919                                 [(browserWidth / 2) - 100 + scrollX, (browserHeight / 2) - 150 + scrollY];
6920                 }
6921
6922                 // move input on screen for focus, but hidden behind dialog
6923                 this._dialogInput.css("left", (this._pos[0] + 20) + "px").css("top", this._pos[1] + "px");
6924                 inst.settings.onSelect = onSelect;
6925                 this._inDialog = true;
6926                 this.dpDiv.addClass(this._dialogClass);
6927                 this._showDatepicker(this._dialogInput[0]);
6928                 if ($.blockUI) {
6929                         $.blockUI(this.dpDiv);
6930                 }
6931                 $.data(this._dialogInput[0], "datepicker", inst);
6932                 return this;
6933         },
6934
6935         /* Detach a datepicker from its control.
6936          * @param  target       element - the target input field or division or span
6937          */
6938         _destroyDatepicker: function(target) {
6939                 var nodeName,
6940                         $target = $(target),
6941                         inst = $.data(target, "datepicker");
6942
6943                 if (!$target.hasClass(this.markerClassName)) {
6944                         return;
6945                 }
6946
6947                 nodeName = target.nodeName.toLowerCase();
6948                 $.removeData(target, "datepicker");
6949                 if (nodeName === "input") {
6950                         inst.append.remove();
6951                         inst.trigger.remove();
6952                         $target.removeClass(this.markerClassName).
6953                                 unbind("focus", this._showDatepicker).
6954                                 unbind("keydown", this._doKeyDown).
6955                                 unbind("keypress", this._doKeyPress).
6956                                 unbind("keyup", this._doKeyUp);
6957                 } else if (nodeName === "div" || nodeName === "span") {
6958                         $target.removeClass(this.markerClassName).empty();
6959                 }
6960
6961                 if ( datepicker_instActive === inst ) {
6962                         datepicker_instActive = null;
6963                 }
6964         },
6965
6966         /* Enable the date picker to a jQuery selection.
6967          * @param  target       element - the target input field or division or span
6968          */
6969         _enableDatepicker: function(target) {
6970                 var nodeName, inline,
6971                         $target = $(target),
6972                         inst = $.data(target, "datepicker");
6973
6974                 if (!$target.hasClass(this.markerClassName)) {
6975                         return;
6976                 }
6977
6978                 nodeName = target.nodeName.toLowerCase();
6979                 if (nodeName === "input") {
6980                         target.disabled = false;
6981                         inst.trigger.filter("button").
6982                                 each(function() { this.disabled = false; }).end().
6983                                 filter("img").css({opacity: "1.0", cursor: ""});
6984                 } else if (nodeName === "div" || nodeName === "span") {
6985                         inline = $target.children("." + this._inlineClass);
6986                         inline.children().removeClass("ui-state-disabled");
6987                         inline.find("select.ui-datepicker-month, select.ui-datepicker-year").
6988                                 prop("disabled", false);
6989                 }
6990                 this._disabledInputs = $.map(this._disabledInputs,
6991                         function(value) { return (value === target ? null : value); }); // delete entry
6992         },
6993
6994         /* Disable the date picker to a jQuery selection.
6995          * @param  target       element - the target input field or division or span
6996          */
6997         _disableDatepicker: function(target) {
6998                 var nodeName, inline,
6999                         $target = $(target),
7000                         inst = $.data(target, "datepicker");
7001
7002                 if (!$target.hasClass(this.markerClassName)) {
7003                         return;
7004                 }
7005
7006                 nodeName = target.nodeName.toLowerCase();
7007                 if (nodeName === "input") {
7008                         target.disabled = true;
7009                         inst.trigger.filter("button").
7010                                 each(function() { this.disabled = true; }).end().
7011                                 filter("img").css({opacity: "0.5", cursor: "default"});
7012                 } else if (nodeName === "div" || nodeName === "span") {
7013                         inline = $target.children("." + this._inlineClass);
7014                         inline.children().addClass("ui-state-disabled");
7015                         inline.find("select.ui-datepicker-month, select.ui-datepicker-year").
7016                                 prop("disabled", true);
7017                 }
7018                 this._disabledInputs = $.map(this._disabledInputs,
7019                         function(value) { return (value === target ? null : value); }); // delete entry
7020                 this._disabledInputs[this._disabledInputs.length] = target;
7021         },
7022
7023         /* Is the first field in a jQuery collection disabled as a datepicker?
7024          * @param  target       element - the target input field or division or span
7025          * @return boolean - true if disabled, false if enabled
7026          */
7027         _isDisabledDatepicker: function(target) {
7028                 if (!target) {
7029                         return false;
7030                 }
7031                 for (var i = 0; i < this._disabledInputs.length; i++) {
7032                         if (this._disabledInputs[i] === target) {
7033                                 return true;
7034                         }
7035                 }
7036                 return false;
7037         },
7038
7039         /* Retrieve the instance data for the target control.
7040          * @param  target  element - the target input field or division or span
7041          * @return  object - the associated instance data
7042          * @throws  error if a jQuery problem getting data
7043          */
7044         _getInst: function(target) {
7045                 try {
7046                         return $.data(target, "datepicker");
7047                 }
7048                 catch (err) {
7049                         throw "Missing instance data for this datepicker";
7050                 }
7051         },
7052
7053         /* Update or retrieve the settings for a date picker attached to an input field or division.
7054          * @param  target  element - the target input field or division or span
7055          * @param  name object - the new settings to update or
7056          *                              string - the name of the setting to change or retrieve,
7057          *                              when retrieving also "all" for all instance settings or
7058          *                              "defaults" for all global defaults
7059          * @param  value   any - the new value for the setting
7060          *                              (omit if above is an object or to retrieve a value)
7061          */
7062         _optionDatepicker: function(target, name, value) {
7063                 var settings, date, minDate, maxDate,
7064                         inst = this._getInst(target);
7065
7066                 if (arguments.length === 2 && typeof name === "string") {
7067                         return (name === "defaults" ? $.extend({}, $.datepicker._defaults) :
7068                                 (inst ? (name === "all" ? $.extend({}, inst.settings) :
7069                                 this._get(inst, name)) : null));
7070                 }
7071
7072                 settings = name || {};
7073                 if (typeof name === "string") {
7074                         settings = {};
7075                         settings[name] = value;
7076                 }
7077
7078                 if (inst) {
7079                         if (this._curInst === inst) {
7080                                 this._hideDatepicker();
7081                         }
7082
7083                         date = this._getDateDatepicker(target, true);
7084                         minDate = this._getMinMaxDate(inst, "min");
7085                         maxDate = this._getMinMaxDate(inst, "max");
7086                         datepicker_extendRemove(inst.settings, settings);
7087                         // reformat the old minDate/maxDate values if dateFormat changes and a new minDate/maxDate isn't provided
7088                         if (minDate !== null && settings.dateFormat !== undefined && settings.minDate === undefined) {
7089                                 inst.settings.minDate = this._formatDate(inst, minDate);
7090                         }
7091                         if (maxDate !== null && settings.dateFormat !== undefined && settings.maxDate === undefined) {
7092                                 inst.settings.maxDate = this._formatDate(inst, maxDate);
7093                         }
7094                         if ( "disabled" in settings ) {
7095                                 if ( settings.disabled ) {
7096                                         this._disableDatepicker(target);
7097                                 } else {
7098                                         this._enableDatepicker(target);
7099                                 }
7100                         }
7101                         this._attachments($(target), inst);
7102                         this._autoSize(inst);
7103                         this._setDate(inst, date);
7104                         this._updateAlternate(inst);
7105                         this._updateDatepicker(inst);
7106                 }
7107         },
7108
7109         // change method deprecated
7110         _changeDatepicker: function(target, name, value) {
7111                 this._optionDatepicker(target, name, value);
7112         },
7113
7114         /* Redraw the date picker attached to an input field or division.
7115          * @param  target  element - the target input field or division or span
7116          */
7117         _refreshDatepicker: function(target) {
7118                 var inst = this._getInst(target);
7119                 if (inst) {
7120                         this._updateDatepicker(inst);
7121                 }
7122         },
7123
7124         /* Set the dates for a jQuery selection.
7125          * @param  target element - the target input field or division or span
7126          * @param  date Date - the new date
7127          */
7128         _setDateDatepicker: function(target, date) {
7129                 var inst = this._getInst(target);
7130                 if (inst) {
7131                         this._setDate(inst, date);
7132                         this._updateDatepicker(inst);
7133                         this._updateAlternate(inst);
7134                 }
7135         },
7136
7137         /* Get the date(s) for the first entry in a jQuery selection.
7138          * @param  target element - the target input field or division or span
7139          * @param  noDefault boolean - true if no default date is to be used
7140          * @return Date - the current date
7141          */
7142         _getDateDatepicker: function(target, noDefault) {
7143                 var inst = this._getInst(target);
7144                 if (inst && !inst.inline) {
7145                         this._setDateFromField(inst, noDefault);
7146                 }
7147                 return (inst ? this._getDate(inst) : null);
7148         },
7149
7150         /* Handle keystrokes. */
7151         _doKeyDown: function(event) {
7152                 var onSelect, dateStr, sel,
7153                         inst = $.datepicker._getInst(event.target),
7154                         handled = true,
7155                         isRTL = inst.dpDiv.is(".ui-datepicker-rtl");
7156
7157                 inst._keyEvent = true;
7158                 if ($.datepicker._datepickerShowing) {
7159                         switch (event.keyCode) {
7160                                 case 9: $.datepicker._hideDatepicker();
7161                                                 handled = false;
7162                                                 break; // hide on tab out
7163                                 case 13: sel = $("td." + $.datepicker._dayOverClass + ":not(." +
7164                                                                         $.datepicker._currentClass + ")", inst.dpDiv);
7165                                                 if (sel[0]) {
7166                                                         $.datepicker._selectDay(event.target, inst.selectedMonth, inst.selectedYear, sel[0]);
7167                                                 }
7168
7169                                                 onSelect = $.datepicker._get(inst, "onSelect");
7170                                                 if (onSelect) {
7171                                                         dateStr = $.datepicker._formatDate(inst);
7172
7173                                                         // trigger custom callback
7174                                                         onSelect.apply((inst.input ? inst.input[0] : null), [dateStr, inst]);
7175                                                 } else {
7176                                                         $.datepicker._hideDatepicker();
7177                                                 }
7178
7179                                                 return false; // don't submit the form
7180                                 case 27: $.datepicker._hideDatepicker();
7181                                                 break; // hide on escape
7182                                 case 33: $.datepicker._adjustDate(event.target, (event.ctrlKey ?
7183                                                         -$.datepicker._get(inst, "stepBigMonths") :
7184                                                         -$.datepicker._get(inst, "stepMonths")), "M");
7185                                                 break; // previous month/year on page up/+ ctrl
7186                                 case 34: $.datepicker._adjustDate(event.target, (event.ctrlKey ?
7187                                                         +$.datepicker._get(inst, "stepBigMonths") :
7188                                                         +$.datepicker._get(inst, "stepMonths")), "M");
7189                                                 break; // next month/year on page down/+ ctrl
7190                                 case 35: if (event.ctrlKey || event.metaKey) {
7191                                                         $.datepicker._clearDate(event.target);
7192                                                 }
7193                                                 handled = event.ctrlKey || event.metaKey;
7194                                                 break; // clear on ctrl or command +end
7195                                 case 36: if (event.ctrlKey || event.metaKey) {
7196                                                         $.datepicker._gotoToday(event.target);
7197                                                 }
7198                                                 handled = event.ctrlKey || event.metaKey;
7199                                                 break; // current on ctrl or command +home
7200                                 case 37: if (event.ctrlKey || event.metaKey) {
7201                                                         $.datepicker._adjustDate(event.target, (isRTL ? +1 : -1), "D");
7202                                                 }
7203                                                 handled = event.ctrlKey || event.metaKey;
7204                                                 // -1 day on ctrl or command +left
7205                                                 if (event.originalEvent.altKey) {
7206                                                         $.datepicker._adjustDate(event.target, (event.ctrlKey ?
7207                                                                 -$.datepicker._get(inst, "stepBigMonths") :
7208                                                                 -$.datepicker._get(inst, "stepMonths")), "M");
7209                                                 }
7210                                                 // next month/year on alt +left on Mac
7211                                                 break;
7212                                 case 38: if (event.ctrlKey || event.metaKey) {
7213                                                         $.datepicker._adjustDate(event.target, -7, "D");
7214                                                 }
7215                                                 handled = event.ctrlKey || event.metaKey;
7216                                                 break; // -1 week on ctrl or command +up
7217                                 case 39: if (event.ctrlKey || event.metaKey) {
7218                                                         $.datepicker._adjustDate(event.target, (isRTL ? -1 : +1), "D");
7219                                                 }
7220                                                 handled = event.ctrlKey || event.metaKey;
7221                                                 // +1 day on ctrl or command +right
7222                                                 if (event.originalEvent.altKey) {
7223                                                         $.datepicker._adjustDate(event.target, (event.ctrlKey ?
7224                                                                 +$.datepicker._get(inst, "stepBigMonths") :
7225                                                                 +$.datepicker._get(inst, "stepMonths")), "M");
7226                                                 }
7227                                                 // next month/year on alt +right
7228                                                 break;
7229                                 case 40: if (event.ctrlKey || event.metaKey) {
7230                                                         $.datepicker._adjustDate(event.target, +7, "D");
7231                                                 }
7232                                                 handled = event.ctrlKey || event.metaKey;
7233                                                 break; // +1 week on ctrl or command +down
7234                                 default: handled = false;
7235                         }
7236                 } else if (event.keyCode === 36 && event.ctrlKey) { // display the date picker on ctrl+home
7237                         $.datepicker._showDatepicker(this);
7238                 } else {
7239                         handled = false;
7240                 }
7241
7242                 if (handled) {
7243                         event.preventDefault();
7244                         event.stopPropagation();
7245                 }
7246         },
7247
7248         /* Filter entered characters - based on date format. */
7249         _doKeyPress: function(event) {
7250                 var chars, chr,
7251                         inst = $.datepicker._getInst(event.target);
7252
7253                 if ($.datepicker._get(inst, "constrainInput")) {
7254                         chars = $.datepicker._possibleChars($.datepicker._get(inst, "dateFormat"));
7255                         chr = String.fromCharCode(event.charCode == null ? event.keyCode : event.charCode);
7256                         return event.ctrlKey || event.metaKey || (chr < " " || !chars || chars.indexOf(chr) > -1);
7257                 }
7258         },
7259
7260         /* Synchronise manual entry and field/alternate field. */
7261         _doKeyUp: function(event) {
7262                 var date,
7263                         inst = $.datepicker._getInst(event.target);
7264
7265                 if (inst.input.val() !== inst.lastVal) {
7266                         try {
7267                                 date = $.datepicker.parseDate($.datepicker._get(inst, "dateFormat"),
7268                                         (inst.input ? inst.input.val() : null),
7269                                         $.datepicker._getFormatConfig(inst));
7270
7271                                 if (date) { // only if valid
7272                                         $.datepicker._setDateFromField(inst);
7273                                         $.datepicker._updateAlternate(inst);
7274                                         $.datepicker._updateDatepicker(inst);
7275                                 }
7276                         }
7277                         catch (err) {
7278                         }
7279                 }
7280                 return true;
7281         },
7282
7283         /* Pop-up the date picker for a given input field.
7284          * If false returned from beforeShow event handler do not show.
7285          * @param  input  element - the input field attached to the date picker or
7286          *                                      event - if triggered by focus
7287          */
7288         _showDatepicker: function(input) {
7289                 input = input.target || input;
7290                 if (input.nodeName.toLowerCase() !== "input") { // find from button/image trigger
7291                         input = $("input", input.parentNode)[0];
7292                 }
7293
7294                 if ($.datepicker._isDisabledDatepicker(input) || $.datepicker._lastInput === input) { // already here
7295                         return;
7296                 }
7297
7298                 var inst, beforeShow, beforeShowSettings, isFixed,
7299                         offset, showAnim, duration;
7300
7301                 inst = $.datepicker._getInst(input);
7302                 if ($.datepicker._curInst && $.datepicker._curInst !== inst) {
7303                         $.datepicker._curInst.dpDiv.stop(true, true);
7304                         if ( inst && $.datepicker._datepickerShowing ) {
7305                                 $.datepicker._hideDatepicker( $.datepicker._curInst.input[0] );
7306                         }
7307                 }
7308
7309                 beforeShow = $.datepicker._get(inst, "beforeShow");
7310                 beforeShowSettings = beforeShow ? beforeShow.apply(input, [input, inst]) : {};
7311                 if(beforeShowSettings === false){
7312                         return;
7313                 }
7314                 datepicker_extendRemove(inst.settings, beforeShowSettings);
7315
7316                 inst.lastVal = null;
7317                 $.datepicker._lastInput = input;
7318                 $.datepicker._setDateFromField(inst);
7319
7320                 if ($.datepicker._inDialog) { // hide cursor
7321                         input.value = "";
7322                 }
7323                 if (!$.datepicker._pos) { // position below input
7324                         $.datepicker._pos = $.datepicker._findPos(input);
7325                         $.datepicker._pos[1] += input.offsetHeight; // add the height
7326                 }
7327
7328                 isFixed = false;
7329                 $(input).parents().each(function() {
7330                         isFixed |= $(this).css("position") === "fixed";
7331                         return !isFixed;
7332                 });
7333
7334                 offset = {left: $.datepicker._pos[0], top: $.datepicker._pos[1]};
7335                 $.datepicker._pos = null;
7336                 //to avoid flashes on Firefox
7337                 inst.dpDiv.empty();
7338                 // determine sizing offscreen
7339                 inst.dpDiv.css({position: "absolute", display: "block", top: "-1000px"});
7340                 $.datepicker._updateDatepicker(inst);
7341                 // fix width for dynamic number of date pickers
7342                 // and adjust position before showing
7343                 offset = $.datepicker._checkOffset(inst, offset, isFixed);
7344                 inst.dpDiv.css({position: ($.datepicker._inDialog && $.blockUI ?
7345                         "static" : (isFixed ? "fixed" : "absolute")), display: "none",
7346                         left: offset.left + "px", top: offset.top + "px"});
7347
7348                 if (!inst.inline) {
7349                         showAnim = $.datepicker._get(inst, "showAnim");
7350                         duration = $.datepicker._get(inst, "duration");
7351                         inst.dpDiv.css( "z-index", datepicker_getZindex( $( input ) ) + 1 );
7352                         $.datepicker._datepickerShowing = true;
7353
7354                         if ( $.effects && $.effects.effect[ showAnim ] ) {
7355                                 inst.dpDiv.show(showAnim, $.datepicker._get(inst, "showOptions"), duration);
7356                         } else {
7357                                 inst.dpDiv[showAnim || "show"](showAnim ? duration : null);
7358                         }
7359
7360                         if ( $.datepicker._shouldFocusInput( inst ) ) {
7361                                 inst.input.focus();
7362                         }
7363
7364                         $.datepicker._curInst = inst;
7365                 }
7366         },
7367
7368         /* Generate the date picker content. */
7369         _updateDatepicker: function(inst) {
7370                 this.maxRows = 4; //Reset the max number of rows being displayed (see #7043)
7371                 datepicker_instActive = inst; // for delegate hover events
7372                 inst.dpDiv.empty().append(this._generateHTML(inst));
7373                 this._attachHandlers(inst);
7374
7375                 var origyearshtml,
7376                         numMonths = this._getNumberOfMonths(inst),
7377                         cols = numMonths[1],
7378                         width = 17,
7379                         activeCell = inst.dpDiv.find( "." + this._dayOverClass + " a" );
7380
7381                 if ( activeCell.length > 0 ) {
7382                         datepicker_handleMouseover.apply( activeCell.get( 0 ) );
7383                 }
7384
7385                 inst.dpDiv.removeClass("ui-datepicker-multi-2 ui-datepicker-multi-3 ui-datepicker-multi-4").width("");
7386                 if (cols > 1) {
7387                         inst.dpDiv.addClass("ui-datepicker-multi-" + cols).css("width", (width * cols) + "em");
7388                 }
7389                 inst.dpDiv[(numMonths[0] !== 1 || numMonths[1] !== 1 ? "add" : "remove") +
7390                         "Class"]("ui-datepicker-multi");
7391                 inst.dpDiv[(this._get(inst, "isRTL") ? "add" : "remove") +
7392                         "Class"]("ui-datepicker-rtl");
7393
7394                 if (inst === $.datepicker._curInst && $.datepicker._datepickerShowing && $.datepicker._shouldFocusInput( inst ) ) {
7395                         inst.input.focus();
7396                 }
7397
7398                 // deffered render of the years select (to avoid flashes on Firefox)
7399                 if( inst.yearshtml ){
7400                         origyearshtml = inst.yearshtml;
7401                         setTimeout(function(){
7402                                 //assure that inst.yearshtml didn't change.
7403                                 if( origyearshtml === inst.yearshtml && inst.yearshtml ){
7404                                         inst.dpDiv.find("select.ui-datepicker-year:first").replaceWith(inst.yearshtml);
7405                                 }
7406                                 origyearshtml = inst.yearshtml = null;
7407                         }, 0);
7408                 }
7409         },
7410
7411         // #6694 - don't focus the input if it's already focused
7412         // this breaks the change event in IE
7413         // Support: IE and jQuery <1.9
7414         _shouldFocusInput: function( inst ) {
7415                 return inst.input && inst.input.is( ":visible" ) && !inst.input.is( ":disabled" ) && !inst.input.is( ":focus" );
7416         },
7417
7418         /* Check positioning to remain on screen. */
7419         _checkOffset: function(inst, offset, isFixed) {
7420                 var dpWidth = inst.dpDiv.outerWidth(),
7421                         dpHeight = inst.dpDiv.outerHeight(),
7422                         inputWidth = inst.input ? inst.input.outerWidth() : 0,
7423                         inputHeight = inst.input ? inst.input.outerHeight() : 0,
7424                         viewWidth = document.documentElement.clientWidth + (isFixed ? 0 : $(document).scrollLeft()),
7425                         viewHeight = document.documentElement.clientHeight + (isFixed ? 0 : $(document).scrollTop());
7426
7427                 offset.left -= (this._get(inst, "isRTL") ? (dpWidth - inputWidth) : 0);
7428                 offset.left -= (isFixed && offset.left === inst.input.offset().left) ? $(document).scrollLeft() : 0;
7429                 offset.top -= (isFixed && offset.top === (inst.input.offset().top + inputHeight)) ? $(document).scrollTop() : 0;
7430
7431                 // now check if datepicker is showing outside window viewport - move to a better place if so.
7432                 offset.left -= Math.min(offset.left, (offset.left + dpWidth > viewWidth && viewWidth > dpWidth) ?
7433                         Math.abs(offset.left + dpWidth - viewWidth) : 0);
7434                 offset.top -= Math.min(offset.top, (offset.top + dpHeight > viewHeight && viewHeight > dpHeight) ?
7435                         Math.abs(dpHeight + inputHeight) : 0);
7436
7437                 return offset;
7438         },
7439
7440         /* Find an object's position on the screen. */
7441         _findPos: function(obj) {
7442                 var position,
7443                         inst = this._getInst(obj),
7444                         isRTL = this._get(inst, "isRTL");
7445
7446                 while (obj && (obj.type === "hidden" || obj.nodeType !== 1 || $.expr.filters.hidden(obj))) {
7447                         obj = obj[isRTL ? "previousSibling" : "nextSibling"];
7448                 }
7449
7450                 position = $(obj).offset();
7451                 return [position.left, position.top];
7452         },
7453
7454         /* Hide the date picker from view.
7455          * @param  input  element - the input field attached to the date picker
7456          */
7457         _hideDatepicker: function(input) {
7458                 var showAnim, duration, postProcess, onClose,
7459                         inst = this._curInst;
7460
7461                 if (!inst || (input && inst !== $.data(input, "datepicker"))) {
7462                         return;
7463                 }
7464
7465                 if (this._datepickerShowing) {
7466                         showAnim = this._get(inst, "showAnim");
7467                         duration = this._get(inst, "duration");
7468                         postProcess = function() {
7469                                 $.datepicker._tidyDialog(inst);
7470                         };
7471
7472                         // DEPRECATED: after BC for 1.8.x $.effects[ showAnim ] is not needed
7473                         if ( $.effects && ( $.effects.effect[ showAnim ] || $.effects[ showAnim ] ) ) {
7474                                 inst.dpDiv.hide(showAnim, $.datepicker._get(inst, "showOptions"), duration, postProcess);
7475                         } else {
7476                                 inst.dpDiv[(showAnim === "slideDown" ? "slideUp" :
7477                                         (showAnim === "fadeIn" ? "fadeOut" : "hide"))]((showAnim ? duration : null), postProcess);
7478                         }
7479
7480                         if (!showAnim) {
7481                                 postProcess();
7482                         }
7483                         this._datepickerShowing = false;
7484
7485                         onClose = this._get(inst, "onClose");
7486                         if (onClose) {
7487                                 onClose.apply((inst.input ? inst.input[0] : null), [(inst.input ? inst.input.val() : ""), inst]);
7488                         }
7489
7490                         this._lastInput = null;
7491                         if (this._inDialog) {
7492                                 this._dialogInput.css({ position: "absolute", left: "0", top: "-100px" });
7493                                 if ($.blockUI) {
7494                                         $.unblockUI();
7495                                         $("body").append(this.dpDiv);
7496                                 }
7497                         }
7498                         this._inDialog = false;
7499                 }
7500         },
7501
7502         /* Tidy up after a dialog display. */
7503         _tidyDialog: function(inst) {
7504                 inst.dpDiv.removeClass(this._dialogClass).unbind(".ui-datepicker-calendar");
7505         },
7506
7507         /* Close date picker if clicked elsewhere. */
7508         _checkExternalClick: function(event) {
7509                 if (!$.datepicker._curInst) {
7510                         return;
7511                 }
7512
7513                 var $target = $(event.target),
7514                         inst = $.datepicker._getInst($target[0]);
7515
7516                 if ( ( ( $target[0].id !== $.datepicker._mainDivId &&
7517                                 $target.parents("#" + $.datepicker._mainDivId).length === 0 &&
7518                                 !$target.hasClass($.datepicker.markerClassName) &&
7519                                 !$target.closest("." + $.datepicker._triggerClass).length &&
7520                                 $.datepicker._datepickerShowing && !($.datepicker._inDialog && $.blockUI) ) ) ||
7521                         ( $target.hasClass($.datepicker.markerClassName) && $.datepicker._curInst !== inst ) ) {
7522                                 $.datepicker._hideDatepicker();
7523                 }
7524         },
7525
7526         /* Adjust one of the date sub-fields. */
7527         _adjustDate: function(id, offset, period) {
7528                 var target = $(id),
7529                         inst = this._getInst(target[0]);
7530
7531                 if (this._isDisabledDatepicker(target[0])) {
7532                         return;
7533                 }
7534                 this._adjustInstDate(inst, offset +
7535                         (period === "M" ? this._get(inst, "showCurrentAtPos") : 0), // undo positioning
7536                         period);
7537                 this._updateDatepicker(inst);
7538         },
7539
7540         /* Action for current link. */
7541         _gotoToday: function(id) {
7542                 var date,
7543                         target = $(id),
7544                         inst = this._getInst(target[0]);
7545
7546                 if (this._get(inst, "gotoCurrent") && inst.currentDay) {
7547                         inst.selectedDay = inst.currentDay;
7548                         inst.drawMonth = inst.selectedMonth = inst.currentMonth;
7549                         inst.drawYear = inst.selectedYear = inst.currentYear;
7550                 } else {
7551                         date = new Date();
7552                         inst.selectedDay = date.getDate();
7553                         inst.drawMonth = inst.selectedMonth = date.getMonth();
7554                         inst.drawYear = inst.selectedYear = date.getFullYear();
7555                 }
7556                 this._notifyChange(inst);
7557                 this._adjustDate(target);
7558         },
7559
7560         /* Action for selecting a new month/year. */
7561         _selectMonthYear: function(id, select, period) {
7562                 var target = $(id),
7563                         inst = this._getInst(target[0]);
7564
7565                 inst["selected" + (period === "M" ? "Month" : "Year")] =
7566                 inst["draw" + (period === "M" ? "Month" : "Year")] =
7567                         parseInt(select.options[select.selectedIndex].value,10);
7568
7569                 this._notifyChange(inst);
7570                 this._adjustDate(target);
7571         },
7572
7573         /* Action for selecting a day. */
7574         _selectDay: function(id, month, year, td) {
7575                 var inst,
7576                         target = $(id);
7577
7578                 if ($(td).hasClass(this._unselectableClass) || this._isDisabledDatepicker(target[0])) {
7579                         return;
7580                 }
7581
7582                 inst = this._getInst(target[0]);
7583                 inst.selectedDay = inst.currentDay = $("a", td).html();
7584                 inst.selectedMonth = inst.currentMonth = month;
7585                 inst.selectedYear = inst.currentYear = year;
7586                 this._selectDate(id, this._formatDate(inst,
7587                         inst.currentDay, inst.currentMonth, inst.currentYear));
7588         },
7589
7590         /* Erase the input field and hide the date picker. */
7591         _clearDate: function(id) {
7592                 var target = $(id);
7593                 this._selectDate(target, "");
7594         },
7595
7596         /* Update the input field with the selected date. */
7597         _selectDate: function(id, dateStr) {
7598                 var onSelect,
7599                         target = $(id),
7600                         inst = this._getInst(target[0]);
7601
7602                 dateStr = (dateStr != null ? dateStr : this._formatDate(inst));
7603                 if (inst.input) {
7604                         inst.input.val(dateStr);
7605                 }
7606                 this._updateAlternate(inst);
7607
7608                 onSelect = this._get(inst, "onSelect");
7609                 if (onSelect) {
7610                         onSelect.apply((inst.input ? inst.input[0] : null), [dateStr, inst]);  // trigger custom callback
7611                 } else if (inst.input) {
7612                         inst.input.trigger("change"); // fire the change event
7613                 }
7614
7615                 if (inst.inline){
7616                         this._updateDatepicker(inst);
7617                 } else {
7618                         this._hideDatepicker();
7619                         this._lastInput = inst.input[0];
7620                         if (typeof(inst.input[0]) !== "object") {
7621                                 inst.input.focus(); // restore focus
7622                         }
7623                         this._lastInput = null;
7624                 }
7625         },
7626
7627         /* Update any alternate field to synchronise with the main field. */
7628         _updateAlternate: function(inst) {
7629                 var altFormat, date, dateStr,
7630                         altField = this._get(inst, "altField");
7631
7632                 if (altField) { // update alternate field too
7633                         altFormat = this._get(inst, "altFormat") || this._get(inst, "dateFormat");
7634                         date = this._getDate(inst);
7635                         dateStr = this.formatDate(altFormat, date, this._getFormatConfig(inst));
7636                         $(altField).each(function() { $(this).val(dateStr); });
7637                 }
7638         },
7639
7640         /* Set as beforeShowDay function to prevent selection of weekends.
7641          * @param  date  Date - the date to customise
7642          * @return [boolean, string] - is this date selectable?, what is its CSS class?
7643          */
7644         noWeekends: function(date) {
7645                 var day = date.getDay();
7646                 return [(day > 0 && day < 6), ""];
7647         },
7648
7649         /* Set as calculateWeek to determine the week of the year based on the ISO 8601 definition.
7650          * @param  date  Date - the date to get the week for
7651          * @return  number - the number of the week within the year that contains this date
7652          */
7653         iso8601Week: function(date) {
7654                 var time,
7655                         checkDate = new Date(date.getTime());
7656
7657                 // Find Thursday of this week starting on Monday
7658                 checkDate.setDate(checkDate.getDate() + 4 - (checkDate.getDay() || 7));
7659
7660                 time = checkDate.getTime();
7661                 checkDate.setMonth(0); // Compare with Jan 1
7662                 checkDate.setDate(1);
7663                 return Math.floor(Math.round((time - checkDate) / 86400000) / 7) + 1;
7664         },
7665
7666         /* Parse a string value into a date object.
7667          * See formatDate below for the possible formats.
7668          *
7669          * @param  format string - the expected format of the date
7670          * @param  value string - the date in the above format
7671          * @param  settings Object - attributes include:
7672          *                                      shortYearCutoff  number - the cutoff year for determining the century (optional)
7673          *                                      dayNamesShort   string[7] - abbreviated names of the days from Sunday (optional)
7674          *                                      dayNames                string[7] - names of the days from Sunday (optional)
7675          *                                      monthNamesShort string[12] - abbreviated names of the months (optional)
7676          *                                      monthNames              string[12] - names of the months (optional)
7677          * @return  Date - the extracted date value or null if value is blank
7678          */
7679         parseDate: function (format, value, settings) {
7680                 if (format == null || value == null) {
7681                         throw "Invalid arguments";
7682                 }
7683
7684                 value = (typeof value === "object" ? value.toString() : value + "");
7685                 if (value === "") {
7686                         return null;
7687                 }
7688
7689                 var iFormat, dim, extra,
7690                         iValue = 0,
7691                         shortYearCutoffTemp = (settings ? settings.shortYearCutoff : null) || this._defaults.shortYearCutoff,
7692                         shortYearCutoff = (typeof shortYearCutoffTemp !== "string" ? shortYearCutoffTemp :
7693                                 new Date().getFullYear() % 100 + parseInt(shortYearCutoffTemp, 10)),
7694                         dayNamesShort = (settings ? settings.dayNamesShort : null) || this._defaults.dayNamesShort,
7695                         dayNames = (settings ? settings.dayNames : null) || this._defaults.dayNames,
7696                         monthNamesShort = (settings ? settings.monthNamesShort : null) || this._defaults.monthNamesShort,
7697                         monthNames = (settings ? settings.monthNames : null) || this._defaults.monthNames,
7698                         year = -1,
7699                         month = -1,
7700                         day = -1,
7701                         doy = -1,
7702                         literal = false,
7703                         date,
7704                         // Check whether a format character is doubled
7705                         lookAhead = function(match) {
7706                                 var matches = (iFormat + 1 < format.length && format.charAt(iFormat + 1) === match);
7707                                 if (matches) {
7708                                         iFormat++;
7709                                 }
7710                                 return matches;
7711                         },
7712                         // Extract a number from the string value
7713                         getNumber = function(match) {
7714                                 var isDoubled = lookAhead(match),
7715                                         size = (match === "@" ? 14 : (match === "!" ? 20 :
7716                                         (match === "y" && isDoubled ? 4 : (match === "o" ? 3 : 2)))),
7717                                         minSize = (match === "y" ? size : 1),
7718                                         digits = new RegExp("^\\d{" + minSize + "," + size + "}"),
7719                                         num = value.substring(iValue).match(digits);
7720                                 if (!num) {
7721                                         throw "Missing number at position " + iValue;
7722                                 }
7723                                 iValue += num[0].length;
7724                                 return parseInt(num[0], 10);
7725                         },
7726                         // Extract a name from the string value and convert to an index
7727                         getName = function(match, shortNames, longNames) {
7728                                 var index = -1,
7729                                         names = $.map(lookAhead(match) ? longNames : shortNames, function (v, k) {
7730                                                 return [ [k, v] ];
7731                                         }).sort(function (a, b) {
7732                                                 return -(a[1].length - b[1].length);
7733                                         });
7734
7735                                 $.each(names, function (i, pair) {
7736                                         var name = pair[1];
7737                                         if (value.substr(iValue, name.length).toLowerCase() === name.toLowerCase()) {
7738                                                 index = pair[0];
7739                                                 iValue += name.length;
7740                                                 return false;
7741                                         }
7742                                 });
7743                                 if (index !== -1) {
7744                                         return index + 1;
7745                                 } else {
7746                                         throw "Unknown name at position " + iValue;
7747                                 }
7748                         },
7749                         // Confirm that a literal character matches the string value
7750                         checkLiteral = function() {
7751                                 if (value.charAt(iValue) !== format.charAt(iFormat)) {
7752                                         throw "Unexpected literal at position " + iValue;
7753                                 }
7754                                 iValue++;
7755                         };
7756
7757                 for (iFormat = 0; iFormat < format.length; iFormat++) {
7758                         if (literal) {
7759                                 if (format.charAt(iFormat) === "'" && !lookAhead("'")) {
7760                                         literal = false;
7761                                 } else {
7762                                         checkLiteral();
7763                                 }
7764                         } else {
7765                                 switch (format.charAt(iFormat)) {
7766                                         case "d":
7767                                                 day = getNumber("d");
7768                                                 break;
7769                                         case "D":
7770                                                 getName("D", dayNamesShort, dayNames);
7771                                                 break;
7772                                         case "o":
7773                                                 doy = getNumber("o");
7774                                                 break;
7775                                         case "m":
7776                                                 month = getNumber("m");
7777                                                 break;
7778                                         case "M":
7779                                                 month = getName("M", monthNamesShort, monthNames);
7780                                                 break;
7781                                         case "y":
7782                                                 year = getNumber("y");
7783                                                 break;
7784                                         case "@":
7785                                                 date = new Date(getNumber("@"));
7786                                                 year = date.getFullYear();
7787                                                 month = date.getMonth() + 1;
7788                                                 day = date.getDate();
7789                                                 break;
7790                                         case "!":
7791                                                 date = new Date((getNumber("!") - this._ticksTo1970) / 10000);
7792                                                 year = date.getFullYear();
7793                                                 month = date.getMonth() + 1;
7794                                                 day = date.getDate();
7795                                                 break;
7796                                         case "'":
7797                                                 if (lookAhead("'")){
7798                                                         checkLiteral();
7799                                                 } else {
7800                                                         literal = true;
7801                                                 }
7802                                                 break;
7803                                         default:
7804                                                 checkLiteral();
7805                                 }
7806                         }
7807                 }
7808
7809                 if (iValue < value.length){
7810                         extra = value.substr(iValue);
7811                         if (!/^\s+/.test(extra)) {
7812                                 throw "Extra/unparsed characters found in date: " + extra;
7813                         }
7814                 }
7815
7816                 if (year === -1) {
7817                         year = new Date().getFullYear();
7818                 } else if (year < 100) {
7819                         year += new Date().getFullYear() - new Date().getFullYear() % 100 +
7820                                 (year <= shortYearCutoff ? 0 : -100);
7821                 }
7822
7823                 if (doy > -1) {
7824                         month = 1;
7825                         day = doy;
7826                         do {
7827                                 dim = this._getDaysInMonth(year, month - 1);
7828                                 if (day <= dim) {
7829                                         break;
7830                                 }
7831                                 month++;
7832                                 day -= dim;
7833                         } while (true);
7834                 }
7835
7836                 date = this._daylightSavingAdjust(new Date(year, month - 1, day));
7837                 if (date.getFullYear() !== year || date.getMonth() + 1 !== month || date.getDate() !== day) {
7838                         throw "Invalid date"; // E.g. 31/02/00
7839                 }
7840                 return date;
7841         },
7842
7843         /* Standard date formats. */
7844         ATOM: "yy-mm-dd", // RFC 3339 (ISO 8601)
7845         COOKIE: "D, dd M yy",
7846         ISO_8601: "yy-mm-dd",
7847         RFC_822: "D, d M y",
7848         RFC_850: "DD, dd-M-y",
7849         RFC_1036: "D, d M y",
7850         RFC_1123: "D, d M yy",
7851         RFC_2822: "D, d M yy",
7852         RSS: "D, d M y", // RFC 822
7853         TICKS: "!",
7854         TIMESTAMP: "@",
7855         W3C: "yy-mm-dd", // ISO 8601
7856
7857         _ticksTo1970: (((1970 - 1) * 365 + Math.floor(1970 / 4) - Math.floor(1970 / 100) +
7858                 Math.floor(1970 / 400)) * 24 * 60 * 60 * 10000000),
7859
7860         /* Format a date object into a string value.
7861          * The format can be combinations of the following:
7862          * d  - day of month (no leading zero)
7863          * dd - day of month (two digit)
7864          * o  - day of year (no leading zeros)
7865          * oo - day of year (three digit)
7866          * D  - day name short
7867          * DD - day name long
7868          * m  - month of year (no leading zero)
7869          * mm - month of year (two digit)
7870          * M  - month name short
7871          * MM - month name long
7872          * y  - year (two digit)
7873          * yy - year (four digit)
7874          * @ - Unix timestamp (ms since 01/01/1970)
7875          * ! - Windows ticks (100ns since 01/01/0001)
7876          * "..." - literal text
7877          * '' - single quote
7878          *
7879          * @param  format string - the desired format of the date
7880          * @param  date Date - the date value to format
7881          * @param  settings Object - attributes include:
7882          *                                      dayNamesShort   string[7] - abbreviated names of the days from Sunday (optional)
7883          *                                      dayNames                string[7] - names of the days from Sunday (optional)
7884          *                                      monthNamesShort string[12] - abbreviated names of the months (optional)
7885          *                                      monthNames              string[12] - names of the months (optional)
7886          * @return  string - the date in the above format
7887          */
7888         formatDate: function (format, date, settings) {
7889                 if (!date) {
7890                         return "";
7891                 }
7892
7893                 var iFormat,
7894                         dayNamesShort = (settings ? settings.dayNamesShort : null) || this._defaults.dayNamesShort,
7895                         dayNames = (settings ? settings.dayNames : null) || this._defaults.dayNames,
7896                         monthNamesShort = (settings ? settings.monthNamesShort : null) || this._defaults.monthNamesShort,
7897                         monthNames = (settings ? settings.monthNames : null) || this._defaults.monthNames,
7898                         // Check whether a format character is doubled
7899                         lookAhead = function(match) {
7900                                 var matches = (iFormat + 1 < format.length && format.charAt(iFormat + 1) === match);
7901                                 if (matches) {
7902                                         iFormat++;
7903                                 }
7904                                 return matches;
7905                         },
7906                         // Format a number, with leading zero if necessary
7907                         formatNumber = function(match, value, len) {
7908                                 var num = "" + value;
7909                                 if (lookAhead(match)) {
7910                                         while (num.length < len) {
7911                                                 num = "0" + num;
7912                                         }
7913                                 }
7914                                 return num;
7915                         },
7916                         // Format a name, short or long as requested
7917                         formatName = function(match, value, shortNames, longNames) {
7918                                 return (lookAhead(match) ? longNames[value] : shortNames[value]);
7919                         },
7920                         output = "",
7921                         literal = false;
7922
7923                 if (date) {
7924                         for (iFormat = 0; iFormat < format.length; iFormat++) {
7925                                 if (literal) {
7926                                         if (format.charAt(iFormat) === "'" && !lookAhead("'")) {
7927                                                 literal = false;
7928                                         } else {
7929                                                 output += format.charAt(iFormat);
7930                                         }
7931                                 } else {
7932                                         switch (format.charAt(iFormat)) {
7933                                                 case "d":
7934                                                         output += formatNumber("d", date.getDate(), 2);
7935                                                         break;
7936                                                 case "D":
7937                                                         output += formatName("D", date.getDay(), dayNamesShort, dayNames);
7938                                                         break;
7939                                                 case "o":
7940                                                         output += formatNumber("o",
7941                                                                 Math.round((new Date(date.getFullYear(), date.getMonth(), date.getDate()).getTime() - new Date(date.getFullYear(), 0, 0).getTime()) / 86400000), 3);
7942                                                         break;
7943                                                 case "m":
7944                                                         output += formatNumber("m", date.getMonth() + 1, 2);
7945                                                         break;
7946                                                 case "M":
7947                                                         output += formatName("M", date.getMonth(), monthNamesShort, monthNames);
7948                                                         break;
7949                                                 case "y":
7950                                                         output += (lookAhead("y") ? date.getFullYear() :
7951                                                                 (date.getYear() % 100 < 10 ? "0" : "") + date.getYear() % 100);
7952                                                         break;
7953                                                 case "@":
7954                                                         output += date.getTime();
7955                                                         break;
7956                                                 case "!":
7957                                                         output += date.getTime() * 10000 + this._ticksTo1970;
7958                                                         break;
7959                                                 case "'":
7960                                                         if (lookAhead("'")) {
7961                                                                 output += "'";
7962                                                         } else {
7963                                                                 literal = true;
7964                                                         }
7965                                                         break;
7966                                                 default:
7967                                                         output += format.charAt(iFormat);
7968                                         }
7969                                 }
7970                         }
7971                 }
7972                 return output;
7973         },
7974
7975         /* Extract all possible characters from the date format. */
7976         _possibleChars: function (format) {
7977                 var iFormat,
7978                         chars = "",
7979                         literal = false,
7980                         // Check whether a format character is doubled
7981                         lookAhead = function(match) {
7982                                 var matches = (iFormat + 1 < format.length && format.charAt(iFormat + 1) === match);
7983                                 if (matches) {
7984                                         iFormat++;
7985                                 }
7986                                 return matches;
7987                         };
7988
7989                 for (iFormat = 0; iFormat < format.length; iFormat++) {
7990                         if (literal) {
7991                                 if (format.charAt(iFormat) === "'" && !lookAhead("'")) {
7992                                         literal = false;
7993                                 } else {
7994                                         chars += format.charAt(iFormat);
7995                                 }
7996                         } else {
7997                                 switch (format.charAt(iFormat)) {
7998                                         case "d": case "m": case "y": case "@":
7999                                                 chars += "0123456789";
8000                                                 break;
8001                                         case "D": case "M":
8002                                                 return null; // Accept anything
8003                                         case "'":
8004                                                 if (lookAhead("'")) {
8005                                                         chars += "'";
8006                                                 } else {
8007                                                         literal = true;
8008                                                 }
8009                                                 break;
8010                                         default:
8011                                                 chars += format.charAt(iFormat);
8012                                 }
8013                         }
8014                 }
8015                 return chars;
8016         },
8017
8018         /* Get a setting value, defaulting if necessary. */
8019         _get: function(inst, name) {
8020                 return inst.settings[name] !== undefined ?
8021                         inst.settings[name] : this._defaults[name];
8022         },
8023
8024         /* Parse existing date and initialise date picker. */
8025         _setDateFromField: function(inst, noDefault) {
8026                 if (inst.input.val() === inst.lastVal) {
8027                         return;
8028                 }
8029
8030                 var dateFormat = this._get(inst, "dateFormat"),
8031                         dates = inst.lastVal = inst.input ? inst.input.val() : null,
8032                         defaultDate = this._getDefaultDate(inst),
8033                         date = defaultDate,
8034                         settings = this._getFormatConfig(inst);
8035
8036                 try {
8037                         date = this.parseDate(dateFormat, dates, settings) || defaultDate;
8038                 } catch (event) {
8039                         dates = (noDefault ? "" : dates);
8040                 }
8041                 inst.selectedDay = date.getDate();
8042                 inst.drawMonth = inst.selectedMonth = date.getMonth();
8043                 inst.drawYear = inst.selectedYear = date.getFullYear();
8044                 inst.currentDay = (dates ? date.getDate() : 0);
8045                 inst.currentMonth = (dates ? date.getMonth() : 0);
8046                 inst.currentYear = (dates ? date.getFullYear() : 0);
8047                 this._adjustInstDate(inst);
8048         },
8049
8050         /* Retrieve the default date shown on opening. */
8051         _getDefaultDate: function(inst) {
8052                 return this._restrictMinMax(inst,
8053                         this._determineDate(inst, this._get(inst, "defaultDate"), new Date()));
8054         },
8055
8056         /* A date may be specified as an exact value or a relative one. */
8057         _determineDate: function(inst, date, defaultDate) {
8058                 var offsetNumeric = function(offset) {
8059                                 var date = new Date();
8060                                 date.setDate(date.getDate() + offset);
8061                                 return date;
8062                         },
8063                         offsetString = function(offset) {
8064                                 try {
8065                                         return $.datepicker.parseDate($.datepicker._get(inst, "dateFormat"),
8066                                                 offset, $.datepicker._getFormatConfig(inst));
8067                                 }
8068                                 catch (e) {
8069                                         // Ignore
8070                                 }
8071
8072                                 var date = (offset.toLowerCase().match(/^c/) ?
8073                                         $.datepicker._getDate(inst) : null) || new Date(),
8074                                         year = date.getFullYear(),
8075                                         month = date.getMonth(),
8076                                         day = date.getDate(),
8077                                         pattern = /([+\-]?[0-9]+)\s*(d|D|w|W|m|M|y|Y)?/g,
8078                                         matches = pattern.exec(offset);
8079
8080                                 while (matches) {
8081                                         switch (matches[2] || "d") {
8082                                                 case "d" : case "D" :
8083                                                         day += parseInt(matches[1],10); break;
8084                                                 case "w" : case "W" :
8085                                                         day += parseInt(matches[1],10) * 7; break;
8086                                                 case "m" : case "M" :
8087                                                         month += parseInt(matches[1],10);
8088                                                         day = Math.min(day, $.datepicker._getDaysInMonth(year, month));
8089                                                         break;
8090                                                 case "y": case "Y" :
8091                                                         year += parseInt(matches[1],10);
8092                                                         day = Math.min(day, $.datepicker._getDaysInMonth(year, month));
8093                                                         break;
8094                                         }
8095                                         matches = pattern.exec(offset);
8096                                 }
8097                                 return new Date(year, month, day);
8098                         },
8099                         newDate = (date == null || date === "" ? defaultDate : (typeof date === "string" ? offsetString(date) :
8100                                 (typeof date === "number" ? (isNaN(date) ? defaultDate : offsetNumeric(date)) : new Date(date.getTime()))));
8101
8102                 newDate = (newDate && newDate.toString() === "Invalid Date" ? defaultDate : newDate);
8103                 if (newDate) {
8104                         newDate.setHours(0);
8105                         newDate.setMinutes(0);
8106                         newDate.setSeconds(0);
8107                         newDate.setMilliseconds(0);
8108                 }
8109                 return this._daylightSavingAdjust(newDate);
8110         },
8111
8112         /* Handle switch to/from daylight saving.
8113          * Hours may be non-zero on daylight saving cut-over:
8114          * > 12 when midnight changeover, but then cannot generate
8115          * midnight datetime, so jump to 1AM, otherwise reset.
8116          * @param  date  (Date) the date to check
8117          * @return  (Date) the corrected date
8118          */
8119         _daylightSavingAdjust: function(date) {
8120                 if (!date) {
8121                         return null;
8122                 }
8123                 date.setHours(date.getHours() > 12 ? date.getHours() + 2 : 0);
8124                 return date;
8125         },
8126
8127         /* Set the date(s) directly. */
8128         _setDate: function(inst, date, noChange) {
8129                 var clear = !date,
8130                         origMonth = inst.selectedMonth,
8131                         origYear = inst.selectedYear,
8132                         newDate = this._restrictMinMax(inst, this._determineDate(inst, date, new Date()));
8133
8134                 inst.selectedDay = inst.currentDay = newDate.getDate();
8135                 inst.drawMonth = inst.selectedMonth = inst.currentMonth = newDate.getMonth();
8136                 inst.drawYear = inst.selectedYear = inst.currentYear = newDate.getFullYear();
8137                 if ((origMonth !== inst.selectedMonth || origYear !== inst.selectedYear) && !noChange) {
8138                         this._notifyChange(inst);
8139                 }
8140                 this._adjustInstDate(inst);
8141                 if (inst.input) {
8142                         inst.input.val(clear ? "" : this._formatDate(inst));
8143                 }
8144         },
8145
8146         /* Retrieve the date(s) directly. */
8147         _getDate: function(inst) {
8148                 var startDate = (!inst.currentYear || (inst.input && inst.input.val() === "") ? null :
8149                         this._daylightSavingAdjust(new Date(
8150                         inst.currentYear, inst.currentMonth, inst.currentDay)));
8151                         return startDate;
8152         },
8153
8154         /* Attach the onxxx handlers.  These are declared statically so
8155          * they work with static code transformers like Caja.
8156          */
8157         _attachHandlers: function(inst) {
8158                 var stepMonths = this._get(inst, "stepMonths"),
8159                         id = "#" + inst.id.replace( /\\\\/g, "\\" );
8160                 inst.dpDiv.find("[data-handler]").map(function () {
8161                         var handler = {
8162                                 prev: function () {
8163                                         $.datepicker._adjustDate(id, -stepMonths, "M");
8164                                 },
8165                                 next: function () {
8166                                         $.datepicker._adjustDate(id, +stepMonths, "M");
8167                                 },
8168                                 hide: function () {
8169                                         $.datepicker._hideDatepicker();
8170                                 },
8171                                 today: function () {
8172                                         $.datepicker._gotoToday(id);
8173                                 },
8174                                 selectDay: function () {
8175                                         $.datepicker._selectDay(id, +this.getAttribute("data-month"), +this.getAttribute("data-year"), this);
8176                                         return false;
8177                                 },
8178                                 selectMonth: function () {
8179                                         $.datepicker._selectMonthYear(id, this, "M");
8180                                         return false;
8181                                 },
8182                                 selectYear: function () {
8183                                         $.datepicker._selectMonthYear(id, this, "Y");
8184                                         return false;
8185                                 }
8186                         };
8187                         $(this).bind(this.getAttribute("data-event"), handler[this.getAttribute("data-handler")]);
8188                 });
8189         },
8190
8191         /* Generate the HTML for the current state of the date picker. */
8192         _generateHTML: function(inst) {
8193                 var maxDraw, prevText, prev, nextText, next, currentText, gotoDate,
8194                         controls, buttonPanel, firstDay, showWeek, dayNames, dayNamesMin,
8195                         monthNames, monthNamesShort, beforeShowDay, showOtherMonths,
8196                         selectOtherMonths, defaultDate, html, dow, row, group, col, selectedDate,
8197                         cornerClass, calender, thead, day, daysInMonth, leadDays, curRows, numRows,
8198                         printDate, dRow, tbody, daySettings, otherMonth, unselectable,
8199                         tempDate = new Date(),
8200                         today = this._daylightSavingAdjust(
8201                                 new Date(tempDate.getFullYear(), tempDate.getMonth(), tempDate.getDate())), // clear time
8202                         isRTL = this._get(inst, "isRTL"),
8203                         showButtonPanel = this._get(inst, "showButtonPanel"),
8204                         hideIfNoPrevNext = this._get(inst, "hideIfNoPrevNext"),
8205                         navigationAsDateFormat = this._get(inst, "navigationAsDateFormat"),
8206                         numMonths = this._getNumberOfMonths(inst),
8207                         showCurrentAtPos = this._get(inst, "showCurrentAtPos"),
8208                         stepMonths = this._get(inst, "stepMonths"),
8209                         isMultiMonth = (numMonths[0] !== 1 || numMonths[1] !== 1),
8210                         currentDate = this._daylightSavingAdjust((!inst.currentDay ? new Date(9999, 9, 9) :
8211                                 new Date(inst.currentYear, inst.currentMonth, inst.currentDay))),
8212                         minDate = this._getMinMaxDate(inst, "min"),
8213                         maxDate = this._getMinMaxDate(inst, "max"),
8214                         drawMonth = inst.drawMonth - showCurrentAtPos,
8215                         drawYear = inst.drawYear;
8216
8217                 if (drawMonth < 0) {
8218                         drawMonth += 12;
8219                         drawYear--;
8220                 }
8221                 if (maxDate) {
8222                         maxDraw = this._daylightSavingAdjust(new Date(maxDate.getFullYear(),
8223                                 maxDate.getMonth() - (numMonths[0] * numMonths[1]) + 1, maxDate.getDate()));
8224                         maxDraw = (minDate && maxDraw < minDate ? minDate : maxDraw);
8225                         while (this._daylightSavingAdjust(new Date(drawYear, drawMonth, 1)) > maxDraw) {
8226                                 drawMonth--;
8227                                 if (drawMonth < 0) {
8228                                         drawMonth = 11;
8229                                         drawYear--;
8230                                 }
8231                         }
8232                 }
8233                 inst.drawMonth = drawMonth;
8234                 inst.drawYear = drawYear;
8235
8236                 prevText = this._get(inst, "prevText");
8237                 prevText = (!navigationAsDateFormat ? prevText : this.formatDate(prevText,
8238                         this._daylightSavingAdjust(new Date(drawYear, drawMonth - stepMonths, 1)),
8239                         this._getFormatConfig(inst)));
8240
8241                 prev = (this._canAdjustMonth(inst, -1, drawYear, drawMonth) ?
8242                         "<a class='ui-datepicker-prev ui-corner-all' data-handler='prev' data-event='click'" +
8243                         " title='" + prevText + "'><span class='ui-icon ui-icon-circle-triangle-" + ( isRTL ? "e" : "w") + "'>" + prevText + "</span></a>" :
8244                         (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>"));
8245
8246                 nextText = this._get(inst, "nextText");
8247                 nextText = (!navigationAsDateFormat ? nextText : this.formatDate(nextText,
8248                         this._daylightSavingAdjust(new Date(drawYear, drawMonth + stepMonths, 1)),
8249                         this._getFormatConfig(inst)));
8250
8251                 next = (this._canAdjustMonth(inst, +1, drawYear, drawMonth) ?
8252                         "<a class='ui-datepicker-next ui-corner-all' data-handler='next' data-event='click'" +
8253                         " title='" + nextText + "'><span class='ui-icon ui-icon-circle-triangle-" + ( isRTL ? "w" : "e") + "'>" + nextText + "</span></a>" :
8254                         (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>"));
8255
8256                 currentText = this._get(inst, "currentText");
8257                 gotoDate = (this._get(inst, "gotoCurrent") && inst.currentDay ? currentDate : today);
8258                 currentText = (!navigationAsDateFormat ? currentText :
8259                         this.formatDate(currentText, gotoDate, this._getFormatConfig(inst)));
8260
8261                 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'>" +
8262                         this._get(inst, "closeText") + "</button>" : "");
8263
8264                 buttonPanel = (showButtonPanel) ? "<div class='ui-datepicker-buttonpane ui-widget-content'>" + (isRTL ? controls : "") +
8265                         (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'" +
8266                         ">" + currentText + "</button>" : "") + (isRTL ? "" : controls) + "</div>" : "";
8267
8268                 firstDay = parseInt(this._get(inst, "firstDay"),10);
8269                 firstDay = (isNaN(firstDay) ? 0 : firstDay);
8270
8271                 showWeek = this._get(inst, "showWeek");
8272                 dayNames = this._get(inst, "dayNames");
8273                 dayNamesMin = this._get(inst, "dayNamesMin");
8274                 monthNames = this._get(inst, "monthNames");
8275                 monthNamesShort = this._get(inst, "monthNamesShort");
8276                 beforeShowDay = this._get(inst, "beforeShowDay");
8277                 showOtherMonths = this._get(inst, "showOtherMonths");
8278                 selectOtherMonths = this._get(inst, "selectOtherMonths");
8279                 defaultDate = this._getDefaultDate(inst);
8280                 html = "";
8281                 dow;
8282                 for (row = 0; row < numMonths[0]; row++) {
8283                         group = "";
8284                         this.maxRows = 4;
8285                         for (col = 0; col < numMonths[1]; col++) {
8286                                 selectedDate = this._daylightSavingAdjust(new Date(drawYear, drawMonth, inst.selectedDay));
8287                                 cornerClass = " ui-corner-all";
8288                                 calender = "";
8289                                 if (isMultiMonth) {
8290                                         calender += "<div class='ui-datepicker-group";
8291                                         if (numMonths[1] > 1) {
8292                                                 switch (col) {
8293                                                         case 0: calender += " ui-datepicker-group-first";
8294                                                                 cornerClass = " ui-corner-" + (isRTL ? "right" : "left"); break;
8295                                                         case numMonths[1]-1: calender += " ui-datepicker-group-last";
8296                                                                 cornerClass = " ui-corner-" + (isRTL ? "left" : "right"); break;
8297                                                         default: calender += " ui-datepicker-group-middle"; cornerClass = ""; break;
8298                                                 }
8299                                         }
8300                                         calender += "'>";
8301                                 }
8302                                 calender += "<div class='ui-datepicker-header ui-widget-header ui-helper-clearfix" + cornerClass + "'>" +
8303                                         (/all|left/.test(cornerClass) && row === 0 ? (isRTL ? next : prev) : "") +
8304                                         (/all|right/.test(cornerClass) && row === 0 ? (isRTL ? prev : next) : "") +
8305                                         this._generateMonthYearHeader(inst, drawMonth, drawYear, minDate, maxDate,
8306                                         row > 0 || col > 0, monthNames, monthNamesShort) + // draw month headers
8307                                         "</div><table class='ui-datepicker-calendar'><thead>" +
8308                                         "<tr>";
8309                                 thead = (showWeek ? "<th class='ui-datepicker-week-col'>" + this._get(inst, "weekHeader") + "</th>" : "");
8310                                 for (dow = 0; dow < 7; dow++) { // days of the week
8311                                         day = (dow + firstDay) % 7;
8312                                         thead += "<th scope='col'" + ((dow + firstDay + 6) % 7 >= 5 ? " class='ui-datepicker-week-end'" : "") + ">" +
8313                                                 "<span title='" + dayNames[day] + "'>" + dayNamesMin[day] + "</span></th>";
8314                                 }
8315                                 calender += thead + "</tr></thead><tbody>";
8316                                 daysInMonth = this._getDaysInMonth(drawYear, drawMonth);
8317                                 if (drawYear === inst.selectedYear && drawMonth === inst.selectedMonth) {
8318                                         inst.selectedDay = Math.min(inst.selectedDay, daysInMonth);
8319                                 }
8320                                 leadDays = (this._getFirstDayOfMonth(drawYear, drawMonth) - firstDay + 7) % 7;
8321                                 curRows = Math.ceil((leadDays + daysInMonth) / 7); // calculate the number of rows to generate
8322                                 numRows = (isMultiMonth ? this.maxRows > curRows ? this.maxRows : curRows : curRows); //If multiple months, use the higher number of rows (see #7043)
8323                                 this.maxRows = numRows;
8324                                 printDate = this._daylightSavingAdjust(new Date(drawYear, drawMonth, 1 - leadDays));
8325                                 for (dRow = 0; dRow < numRows; dRow++) { // create date picker rows
8326                                         calender += "<tr>";
8327                                         tbody = (!showWeek ? "" : "<td class='ui-datepicker-week-col'>" +
8328                                                 this._get(inst, "calculateWeek")(printDate) + "</td>");
8329                                         for (dow = 0; dow < 7; dow++) { // create date picker days
8330                                                 daySettings = (beforeShowDay ?
8331                                                         beforeShowDay.apply((inst.input ? inst.input[0] : null), [printDate]) : [true, ""]);
8332                                                 otherMonth = (printDate.getMonth() !== drawMonth);
8333                                                 unselectable = (otherMonth && !selectOtherMonths) || !daySettings[0] ||
8334                                                         (minDate && printDate < minDate) || (maxDate && printDate > maxDate);
8335                                                 tbody += "<td class='" +
8336                                                         ((dow + firstDay + 6) % 7 >= 5 ? " ui-datepicker-week-end" : "") + // highlight weekends
8337                                                         (otherMonth ? " ui-datepicker-other-month" : "") + // highlight days from other months
8338                                                         ((printDate.getTime() === selectedDate.getTime() && drawMonth === inst.selectedMonth && inst._keyEvent) || // user pressed key
8339                                                         (defaultDate.getTime() === printDate.getTime() && defaultDate.getTime() === selectedDate.getTime()) ?
8340                                                         // or defaultDate is current printedDate and defaultDate is selectedDate
8341                                                         " " + this._dayOverClass : "") + // highlight selected day
8342                                                         (unselectable ? " " + this._unselectableClass + " ui-state-disabled": "") +  // highlight unselectable days
8343                                                         (otherMonth && !showOtherMonths ? "" : " " + daySettings[1] + // highlight custom dates
8344                                                         (printDate.getTime() === currentDate.getTime() ? " " + this._currentClass : "") + // highlight selected day
8345                                                         (printDate.getTime() === today.getTime() ? " ui-datepicker-today" : "")) + "'" + // highlight today (if different)
8346                                                         ((!otherMonth || showOtherMonths) && daySettings[2] ? " title='" + daySettings[2].replace(/'/g, "&#39;") + "'" : "") + // cell title
8347                                                         (unselectable ? "" : " data-handler='selectDay' data-event='click' data-month='" + printDate.getMonth() + "' data-year='" + printDate.getFullYear() + "'") + ">" + // actions
8348                                                         (otherMonth && !showOtherMonths ? "&#xa0;" : // display for other months
8349                                                         (unselectable ? "<span class='ui-state-default'>" + printDate.getDate() + "</span>" : "<a class='ui-state-default" +
8350                                                         (printDate.getTime() === today.getTime() ? " ui-state-highlight" : "") +
8351                                                         (printDate.getTime() === currentDate.getTime() ? " ui-state-active" : "") + // highlight selected day
8352                                                         (otherMonth ? " ui-priority-secondary" : "") + // distinguish dates from other months
8353                                                         "' href='#'>" + printDate.getDate() + "</a>")) + "</td>"; // display selectable date
8354                                                 printDate.setDate(printDate.getDate() + 1);
8355                                                 printDate = this._daylightSavingAdjust(printDate);
8356                                         }
8357                                         calender += tbody + "</tr>";
8358                                 }
8359                                 drawMonth++;
8360                                 if (drawMonth > 11) {
8361                                         drawMonth = 0;
8362                                         drawYear++;
8363                                 }
8364                                 calender += "</tbody></table>" + (isMultiMonth ? "</div>" +
8365                                                         ((numMonths[0] > 0 && col === numMonths[1]-1) ? "<div class='ui-datepicker-row-break'></div>" : "") : "");
8366                                 group += calender;
8367                         }
8368                         html += group;
8369                 }
8370                 html += buttonPanel;
8371                 inst._keyEvent = false;
8372                 return html;
8373         },
8374
8375         /* Generate the month and year header. */
8376         _generateMonthYearHeader: function(inst, drawMonth, drawYear, minDate, maxDate,
8377                         secondary, monthNames, monthNamesShort) {
8378
8379                 var inMinYear, inMaxYear, month, years, thisYear, determineYear, year, endYear,
8380                         changeMonth = this._get(inst, "changeMonth"),
8381                         changeYear = this._get(inst, "changeYear"),
8382                         showMonthAfterYear = this._get(inst, "showMonthAfterYear"),
8383                         html = "<div class='ui-datepicker-title'>",
8384                         monthHtml = "";
8385
8386                 // month selection
8387                 if (secondary || !changeMonth) {
8388                         monthHtml += "<span class='ui-datepicker-month'>" + monthNames[drawMonth] + "</span>";
8389                 } else {
8390                         inMinYear = (minDate && minDate.getFullYear() === drawYear);
8391                         inMaxYear = (maxDate && maxDate.getFullYear() === drawYear);
8392                         monthHtml += "<select class='ui-datepicker-month' data-handler='selectMonth' data-event='change'>";
8393                         for ( month = 0; month < 12; month++) {
8394                                 if ((!inMinYear || month >= minDate.getMonth()) && (!inMaxYear || month <= maxDate.getMonth())) {
8395                                         monthHtml += "<option value='" + month + "'" +
8396                                                 (month === drawMonth ? " selected='selected'" : "") +
8397                                                 ">" + monthNamesShort[month] + "</option>";
8398                                 }
8399                         }
8400                         monthHtml += "</select>";
8401                 }
8402
8403                 if (!showMonthAfterYear) {
8404                         html += monthHtml + (secondary || !(changeMonth && changeYear) ? "&#xa0;" : "");
8405                 }
8406
8407                 // year selection
8408                 if ( !inst.yearshtml ) {
8409                         inst.yearshtml = "";
8410                         if (secondary || !changeYear) {
8411                                 html += "<span class='ui-datepicker-year'>" + drawYear + "</span>";
8412                         } else {
8413                                 // determine range of years to display
8414                                 years = this._get(inst, "yearRange").split(":");
8415                                 thisYear = new Date().getFullYear();
8416                                 determineYear = function(value) {
8417                                         var year = (value.match(/c[+\-].*/) ? drawYear + parseInt(value.substring(1), 10) :
8418                                                 (value.match(/[+\-].*/) ? thisYear + parseInt(value, 10) :
8419                                                 parseInt(value, 10)));
8420                                         return (isNaN(year) ? thisYear : year);
8421                                 };
8422                                 year = determineYear(years[0]);
8423                                 endYear = Math.max(year, determineYear(years[1] || ""));
8424                                 year = (minDate ? Math.max(year, minDate.getFullYear()) : year);
8425                                 endYear = (maxDate ? Math.min(endYear, maxDate.getFullYear()) : endYear);
8426                                 inst.yearshtml += "<select class='ui-datepicker-year' data-handler='selectYear' data-event='change'>";
8427                                 for (; year <= endYear; year++) {
8428                                         inst.yearshtml += "<option value='" + year + "'" +
8429                                                 (year === drawYear ? " selected='selected'" : "") +
8430                                                 ">" + year + "</option>";
8431                                 }
8432                                 inst.yearshtml += "</select>";
8433
8434                                 html += inst.yearshtml;
8435                                 inst.yearshtml = null;
8436                         }
8437                 }
8438
8439                 html += this._get(inst, "yearSuffix");
8440                 if (showMonthAfterYear) {
8441                         html += (secondary || !(changeMonth && changeYear) ? "&#xa0;" : "") + monthHtml;
8442                 }
8443                 html += "</div>"; // Close datepicker_header
8444                 return html;
8445         },
8446
8447         /* Adjust one of the date sub-fields. */
8448         _adjustInstDate: function(inst, offset, period) {
8449                 var year = inst.drawYear + (period === "Y" ? offset : 0),
8450                         month = inst.drawMonth + (period === "M" ? offset : 0),
8451                         day = Math.min(inst.selectedDay, this._getDaysInMonth(year, month)) + (period === "D" ? offset : 0),
8452                         date = this._restrictMinMax(inst, this._daylightSavingAdjust(new Date(year, month, day)));
8453
8454                 inst.selectedDay = date.getDate();
8455                 inst.drawMonth = inst.selectedMonth = date.getMonth();
8456                 inst.drawYear = inst.selectedYear = date.getFullYear();
8457                 if (period === "M" || period === "Y") {
8458                         this._notifyChange(inst);
8459                 }
8460         },
8461
8462         /* Ensure a date is within any min/max bounds. */
8463         _restrictMinMax: function(inst, date) {
8464                 var minDate = this._getMinMaxDate(inst, "min"),
8465                         maxDate = this._getMinMaxDate(inst, "max"),
8466                         newDate = (minDate && date < minDate ? minDate : date);
8467                 return (maxDate && newDate > maxDate ? maxDate : newDate);
8468         },
8469
8470         /* Notify change of month/year. */
8471         _notifyChange: function(inst) {
8472                 var onChange = this._get(inst, "onChangeMonthYear");
8473                 if (onChange) {
8474                         onChange.apply((inst.input ? inst.input[0] : null),
8475                                 [inst.selectedYear, inst.selectedMonth + 1, inst]);
8476                 }
8477         },
8478
8479         /* Determine the number of months to show. */
8480         _getNumberOfMonths: function(inst) {
8481                 var numMonths = this._get(inst, "numberOfMonths");
8482                 return (numMonths == null ? [1, 1] : (typeof numMonths === "number" ? [1, numMonths] : numMonths));
8483         },
8484
8485         /* Determine the current maximum date - ensure no time components are set. */
8486         _getMinMaxDate: function(inst, minMax) {
8487                 return this._determineDate(inst, this._get(inst, minMax + "Date"), null);
8488         },
8489
8490         /* Find the number of days in a given month. */
8491         _getDaysInMonth: function(year, month) {
8492                 return 32 - this._daylightSavingAdjust(new Date(year, month, 32)).getDate();
8493         },
8494
8495         /* Find the day of the week of the first of a month. */
8496         _getFirstDayOfMonth: function(year, month) {
8497                 return new Date(year, month, 1).getDay();
8498         },
8499
8500         /* Determines if we should allow a "next/prev" month display change. */
8501         _canAdjustMonth: function(inst, offset, curYear, curMonth) {
8502                 var numMonths = this._getNumberOfMonths(inst),
8503                         date = this._daylightSavingAdjust(new Date(curYear,
8504                         curMonth + (offset < 0 ? offset : numMonths[0] * numMonths[1]), 1));
8505
8506                 if (offset < 0) {
8507                         date.setDate(this._getDaysInMonth(date.getFullYear(), date.getMonth()));
8508                 }
8509                 return this._isInRange(inst, date);
8510         },
8511
8512         /* Is the given date in the accepted range? */
8513         _isInRange: function(inst, date) {
8514                 var yearSplit, currentYear,
8515                         minDate = this._getMinMaxDate(inst, "min"),
8516                         maxDate = this._getMinMaxDate(inst, "max"),
8517                         minYear = null,
8518                         maxYear = null,
8519                         years = this._get(inst, "yearRange");
8520                         if (years){
8521                                 yearSplit = years.split(":");
8522                                 currentYear = new Date().getFullYear();
8523                                 minYear = parseInt(yearSplit[0], 10);
8524                                 maxYear = parseInt(yearSplit[1], 10);
8525                                 if ( yearSplit[0].match(/[+\-].*/) ) {
8526                                         minYear += currentYear;
8527                                 }
8528                                 if ( yearSplit[1].match(/[+\-].*/) ) {
8529                                         maxYear += currentYear;
8530                                 }
8531                         }
8532
8533                 return ((!minDate || date.getTime() >= minDate.getTime()) &&
8534                         (!maxDate || date.getTime() <= maxDate.getTime()) &&
8535                         (!minYear || date.getFullYear() >= minYear) &&
8536                         (!maxYear || date.getFullYear() <= maxYear));
8537         },
8538
8539         /* Provide the configuration settings for formatting/parsing. */
8540         _getFormatConfig: function(inst) {
8541                 var shortYearCutoff = this._get(inst, "shortYearCutoff");
8542                 shortYearCutoff = (typeof shortYearCutoff !== "string" ? shortYearCutoff :
8543                         new Date().getFullYear() % 100 + parseInt(shortYearCutoff, 10));
8544                 return {shortYearCutoff: shortYearCutoff,
8545                         dayNamesShort: this._get(inst, "dayNamesShort"), dayNames: this._get(inst, "dayNames"),
8546                         monthNamesShort: this._get(inst, "monthNamesShort"), monthNames: this._get(inst, "monthNames")};
8547         },
8548
8549         /* Format the given date for display. */
8550         _formatDate: function(inst, day, month, year) {
8551                 if (!day) {
8552                         inst.currentDay = inst.selectedDay;
8553                         inst.currentMonth = inst.selectedMonth;
8554                         inst.currentYear = inst.selectedYear;
8555                 }
8556                 var date = (day ? (typeof day === "object" ? day :
8557                         this._daylightSavingAdjust(new Date(year, month, day))) :
8558                         this._daylightSavingAdjust(new Date(inst.currentYear, inst.currentMonth, inst.currentDay)));
8559                 return this.formatDate(this._get(inst, "dateFormat"), date, this._getFormatConfig(inst));
8560         }
8561 });
8562
8563 /*
8564  * Bind hover events for datepicker elements.
8565  * Done via delegate so the binding only occurs once in the lifetime of the parent div.
8566  * Global datepicker_instActive, set by _updateDatepicker allows the handlers to find their way back to the active picker.
8567  */
8568 function datepicker_bindHover(dpDiv) {
8569         var selector = "button, .ui-datepicker-prev, .ui-datepicker-next, .ui-datepicker-calendar td a";
8570         return dpDiv.delegate(selector, "mouseout", function() {
8571                         $(this).removeClass("ui-state-hover");
8572                         if (this.className.indexOf("ui-datepicker-prev") !== -1) {
8573                                 $(this).removeClass("ui-datepicker-prev-hover");
8574                         }
8575                         if (this.className.indexOf("ui-datepicker-next") !== -1) {
8576                                 $(this).removeClass("ui-datepicker-next-hover");
8577                         }
8578                 })
8579                 .delegate( selector, "mouseover", datepicker_handleMouseover );
8580 }
8581
8582 function datepicker_handleMouseover() {
8583         if (!$.datepicker._isDisabledDatepicker( datepicker_instActive.inline? datepicker_instActive.dpDiv.parent()[0] : datepicker_instActive.input[0])) {
8584                 $(this).parents(".ui-datepicker-calendar").find("a").removeClass("ui-state-hover");
8585                 $(this).addClass("ui-state-hover");
8586                 if (this.className.indexOf("ui-datepicker-prev") !== -1) {
8587                         $(this).addClass("ui-datepicker-prev-hover");
8588                 }
8589                 if (this.className.indexOf("ui-datepicker-next") !== -1) {
8590                         $(this).addClass("ui-datepicker-next-hover");
8591                 }
8592         }
8593 }
8594
8595 /* jQuery extend now ignores nulls! */
8596 function datepicker_extendRemove(target, props) {
8597         $.extend(target, props);
8598         for (var name in props) {
8599                 if (props[name] == null) {
8600                         target[name] = props[name];
8601                 }
8602         }
8603         return target;
8604 }
8605
8606 /* Invoke the datepicker functionality.
8607    @param  options  string - a command, optionally followed by additional parameters or
8608                                         Object - settings for attaching new datepicker functionality
8609    @return  jQuery object */
8610 $.fn.datepicker = function(options){
8611
8612         /* Verify an empty collection wasn't passed - Fixes #6976 */
8613         if ( !this.length ) {
8614                 return this;
8615         }
8616
8617         /* Initialise the date picker. */
8618         if (!$.datepicker.initialized) {
8619                 $(document).mousedown($.datepicker._checkExternalClick);
8620                 $.datepicker.initialized = true;
8621         }
8622
8623         /* Append datepicker main container to body if not exist. */
8624         if ($("#"+$.datepicker._mainDivId).length === 0) {
8625                 $("body").append($.datepicker.dpDiv);
8626         }
8627
8628         var otherArgs = Array.prototype.slice.call(arguments, 1);
8629         if (typeof options === "string" && (options === "isDisabled" || options === "getDate" || options === "widget")) {
8630                 return $.datepicker["_" + options + "Datepicker"].
8631                         apply($.datepicker, [this[0]].concat(otherArgs));
8632         }
8633         if (options === "option" && arguments.length === 2 && typeof arguments[1] === "string") {
8634                 return $.datepicker["_" + options + "Datepicker"].
8635                         apply($.datepicker, [this[0]].concat(otherArgs));
8636         }
8637         return this.each(function() {
8638                 typeof options === "string" ?
8639                         $.datepicker["_" + options + "Datepicker"].
8640                                 apply($.datepicker, [this].concat(otherArgs)) :
8641                         $.datepicker._attachDatepicker(this, options);
8642         });
8643 };
8644
8645 $.datepicker = new Datepicker(); // singleton instance
8646 $.datepicker.initialized = false;
8647 $.datepicker.uuid = new Date().getTime();
8648 $.datepicker.version = "1.11.4";
8649
8650 var datepicker = $.datepicker;
8651
8652
8653 /*!
8654  * jQuery UI Progressbar 1.11.4
8655  * http://jqueryui.com
8656  *
8657  * Copyright jQuery Foundation and other contributors
8658  * Released under the MIT license.
8659  * http://jquery.org/license
8660  *
8661  * http://api.jqueryui.com/progressbar/
8662  */
8663
8664
8665 var progressbar = $.widget( "ui.progressbar", {
8666         version: "1.11.4",
8667         options: {
8668                 max: 100,
8669                 value: 0,
8670
8671                 change: null,
8672                 complete: null
8673         },
8674
8675         min: 0,
8676
8677         _create: function() {
8678                 // Constrain initial value
8679                 this.oldValue = this.options.value = this._constrainedValue();
8680
8681                 this.element
8682                         .addClass( "ui-progressbar ui-widget ui-widget-content ui-corner-all" )
8683                         .attr({
8684                                 // Only set static values, aria-valuenow and aria-valuemax are
8685                                 // set inside _refreshValue()
8686                                 role: "progressbar",
8687                                 "aria-valuemin": this.min
8688                         });
8689
8690                 this.valueDiv = $( "<div class='ui-progressbar-value ui-widget-header ui-corner-left'></div>" )
8691                         .appendTo( this.element );
8692
8693                 this._refreshValue();
8694         },
8695
8696         _destroy: function() {
8697                 this.element
8698                         .removeClass( "ui-progressbar ui-widget ui-widget-content ui-corner-all" )
8699                         .removeAttr( "role" )
8700                         .removeAttr( "aria-valuemin" )
8701                         .removeAttr( "aria-valuemax" )
8702                         .removeAttr( "aria-valuenow" );
8703
8704                 this.valueDiv.remove();
8705         },
8706
8707         value: function( newValue ) {
8708                 if ( newValue === undefined ) {
8709                         return this.options.value;
8710                 }
8711
8712                 this.options.value = this._constrainedValue( newValue );
8713                 this._refreshValue();
8714         },
8715
8716         _constrainedValue: function( newValue ) {
8717                 if ( newValue === undefined ) {
8718                         newValue = this.options.value;
8719                 }
8720
8721                 this.indeterminate = newValue === false;
8722
8723                 // sanitize value
8724                 if ( typeof newValue !== "number" ) {
8725                         newValue = 0;
8726                 }
8727
8728                 return this.indeterminate ? false :
8729                         Math.min( this.options.max, Math.max( this.min, newValue ) );
8730         },
8731
8732         _setOptions: function( options ) {
8733                 // Ensure "value" option is set after other values (like max)
8734                 var value = options.value;
8735                 delete options.value;
8736
8737                 this._super( options );
8738
8739                 this.options.value = this._constrainedValue( value );
8740                 this._refreshValue();
8741         },
8742
8743         _setOption: function( key, value ) {
8744                 if ( key === "max" ) {
8745                         // Don't allow a max less than min
8746                         value = Math.max( this.min, value );
8747                 }
8748                 if ( key === "disabled" ) {
8749                         this.element
8750                                 .toggleClass( "ui-state-disabled", !!value )
8751                                 .attr( "aria-disabled", value );
8752                 }
8753                 this._super( key, value );
8754         },
8755
8756         _percentage: function() {
8757                 return this.indeterminate ? 100 : 100 * ( this.options.value - this.min ) / ( this.options.max - this.min );
8758         },
8759
8760         _refreshValue: function() {
8761                 var value = this.options.value,
8762                         percentage = this._percentage();
8763
8764                 this.valueDiv
8765                         .toggle( this.indeterminate || value > this.min )
8766                         .toggleClass( "ui-corner-right", value === this.options.max )
8767                         .width( percentage.toFixed(0) + "%" );
8768
8769                 this.element.toggleClass( "ui-progressbar-indeterminate", this.indeterminate );
8770
8771                 if ( this.indeterminate ) {
8772                         this.element.removeAttr( "aria-valuenow" );
8773                         if ( !this.overlayDiv ) {
8774                                 this.overlayDiv = $( "<div class='ui-progressbar-overlay'></div>" ).appendTo( this.valueDiv );
8775                         }
8776                 } else {
8777                         this.element.attr({
8778                                 "aria-valuemax": this.options.max,
8779                                 "aria-valuenow": value
8780                         });
8781                         if ( this.overlayDiv ) {
8782                                 this.overlayDiv.remove();
8783                                 this.overlayDiv = null;
8784                         }
8785                 }
8786
8787                 if ( this.oldValue !== value ) {
8788                         this.oldValue = value;
8789                         this._trigger( "change" );
8790                 }
8791                 if ( value === this.options.max ) {
8792                         this._trigger( "complete" );
8793                 }
8794         }
8795 });
8796
8797
8798 /*!
8799  * jQuery UI Slider 1.11.4
8800  * http://jqueryui.com
8801  *
8802  * Copyright jQuery Foundation and other contributors
8803  * Released under the MIT license.
8804  * http://jquery.org/license
8805  *
8806  * http://api.jqueryui.com/slider/
8807  */
8808
8809
8810 var slider = $.widget( "ui.slider", $.ui.mouse, {
8811         version: "1.11.4",
8812         widgetEventPrefix: "slide",
8813
8814         options: {
8815                 animate: false,
8816                 distance: 0,
8817                 max: 100,
8818                 min: 0,
8819                 orientation: "horizontal",
8820                 range: false,
8821                 step: 1,
8822                 value: 0,
8823                 values: null,
8824
8825                 // callbacks
8826                 change: null,
8827                 slide: null,
8828                 start: null,
8829                 stop: null
8830         },
8831
8832         // number of pages in a slider
8833         // (how many times can you page up/down to go through the whole range)
8834         numPages: 5,
8835
8836         _create: function() {
8837                 this._keySliding = false;
8838                 this._mouseSliding = false;
8839                 this._animateOff = true;
8840                 this._handleIndex = null;
8841                 this._detectOrientation();
8842                 this._mouseInit();
8843                 this._calculateNewMax();
8844
8845                 this.element
8846                         .addClass( "ui-slider" +
8847                                 " ui-slider-" + this.orientation +
8848                                 " ui-widget" +
8849                                 " ui-widget-content" +
8850                                 " ui-corner-all");
8851
8852                 this._refresh();
8853                 this._setOption( "disabled", this.options.disabled );
8854
8855                 this._animateOff = false;
8856         },
8857
8858         _refresh: function() {
8859                 this._createRange();
8860                 this._createHandles();
8861                 this._setupEvents();
8862                 this._refreshValue();
8863         },
8864
8865         _createHandles: function() {
8866                 var i, handleCount,
8867                         options = this.options,
8868                         existingHandles = this.element.find( ".ui-slider-handle" ).addClass( "ui-state-default ui-corner-all" ),
8869                         handle = "<span class='ui-slider-handle ui-state-default ui-corner-all' tabindex='0'></span>",
8870                         handles = [];
8871
8872                 handleCount = ( options.values && options.values.length ) || 1;
8873
8874                 if ( existingHandles.length > handleCount ) {
8875                         existingHandles.slice( handleCount ).remove();
8876                         existingHandles = existingHandles.slice( 0, handleCount );
8877                 }
8878
8879                 for ( i = existingHandles.length; i < handleCount; i++ ) {
8880                         handles.push( handle );
8881                 }
8882
8883                 this.handles = existingHandles.add( $( handles.join( "" ) ).appendTo( this.element ) );
8884
8885                 this.handle = this.handles.eq( 0 );
8886
8887                 this.handles.each(function( i ) {
8888                         $( this ).data( "ui-slider-handle-index", i );
8889                 });
8890         },
8891
8892         _createRange: function() {
8893                 var options = this.options,
8894                         classes = "";
8895
8896                 if ( options.range ) {
8897                         if ( options.range === true ) {
8898                                 if ( !options.values ) {
8899                                         options.values = [ this._valueMin(), this._valueMin() ];
8900                                 } else if ( options.values.length && options.values.length !== 2 ) {
8901                                         options.values = [ options.values[0], options.values[0] ];
8902                                 } else if ( $.isArray( options.values ) ) {
8903                                         options.values = options.values.slice(0);
8904                                 }
8905                         }
8906
8907                         if ( !this.range || !this.range.length ) {
8908                                 this.range = $( "<div></div>" )
8909                                         .appendTo( this.element );
8910
8911                                 classes = "ui-slider-range" +
8912                                 // note: this isn't the most fittingly semantic framework class for this element,
8913                                 // but worked best visually with a variety of themes
8914                                 " ui-widget-header ui-corner-all";
8915                         } else {
8916                                 this.range.removeClass( "ui-slider-range-min ui-slider-range-max" )
8917                                         // Handle range switching from true to min/max
8918                                         .css({
8919                                                 "left": "",
8920                                                 "bottom": ""
8921                                         });
8922                         }
8923
8924                         this.range.addClass( classes +
8925                                 ( ( options.range === "min" || options.range === "max" ) ? " ui-slider-range-" + options.range : "" ) );
8926                 } else {
8927                         if ( this.range ) {
8928                                 this.range.remove();
8929                         }
8930                         this.range = null;
8931                 }
8932         },
8933
8934         _setupEvents: function() {
8935                 this._off( this.handles );
8936                 this._on( this.handles, this._handleEvents );
8937                 this._hoverable( this.handles );
8938                 this._focusable( this.handles );
8939         },
8940
8941         _destroy: function() {
8942                 this.handles.remove();
8943                 if ( this.range ) {
8944                         this.range.remove();
8945                 }
8946
8947                 this.element
8948                         .removeClass( "ui-slider" +
8949                                 " ui-slider-horizontal" +
8950                                 " ui-slider-vertical" +
8951                                 " ui-widget" +
8952                                 " ui-widget-content" +
8953                                 " ui-corner-all" );
8954
8955                 this._mouseDestroy();
8956         },
8957
8958         _mouseCapture: function( event ) {
8959                 var position, normValue, distance, closestHandle, index, allowed, offset, mouseOverHandle,
8960                         that = this,
8961                         o = this.options;
8962
8963                 if ( o.disabled ) {
8964                         return false;
8965                 }
8966
8967                 this.elementSize = {
8968                         width: this.element.outerWidth(),
8969                         height: this.element.outerHeight()
8970                 };
8971                 this.elementOffset = this.element.offset();
8972
8973                 position = { x: event.pageX, y: event.pageY };
8974                 normValue = this._normValueFromMouse( position );
8975                 distance = this._valueMax() - this._valueMin() + 1;
8976                 this.handles.each(function( i ) {
8977                         var thisDistance = Math.abs( normValue - that.values(i) );
8978                         if (( distance > thisDistance ) ||
8979                                 ( distance === thisDistance &&
8980                                         (i === that._lastChangedValue || that.values(i) === o.min ))) {
8981                                 distance = thisDistance;
8982                                 closestHandle = $( this );
8983                                 index = i;
8984                         }
8985                 });
8986
8987                 allowed = this._start( event, index );
8988                 if ( allowed === false ) {
8989                         return false;
8990                 }
8991                 this._mouseSliding = true;
8992
8993                 this._handleIndex = index;
8994
8995                 closestHandle
8996                         .addClass( "ui-state-active" )
8997                         .focus();
8998
8999                 offset = closestHandle.offset();
9000                 mouseOverHandle = !$( event.target ).parents().addBack().is( ".ui-slider-handle" );
9001                 this._clickOffset = mouseOverHandle ? { left: 0, top: 0 } : {
9002                         left: event.pageX - offset.left - ( closestHandle.width() / 2 ),
9003                         top: event.pageY - offset.top -
9004                                 ( closestHandle.height() / 2 ) -
9005                                 ( parseInt( closestHandle.css("borderTopWidth"), 10 ) || 0 ) -
9006                                 ( parseInt( closestHandle.css("borderBottomWidth"), 10 ) || 0) +
9007                                 ( parseInt( closestHandle.css("marginTop"), 10 ) || 0)
9008                 };
9009
9010                 if ( !this.handles.hasClass( "ui-state-hover" ) ) {
9011                         this._slide( event, index, normValue );
9012                 }
9013                 this._animateOff = true;
9014                 return true;
9015         },
9016
9017         _mouseStart: function() {
9018                 return true;
9019         },
9020
9021         _mouseDrag: function( event ) {
9022                 var position = { x: event.pageX, y: event.pageY },
9023                         normValue = this._normValueFromMouse( position );
9024
9025                 this._slide( event, this._handleIndex, normValue );
9026
9027                 return false;
9028         },
9029
9030         _mouseStop: function( event ) {
9031                 this.handles.removeClass( "ui-state-active" );
9032                 this._mouseSliding = false;
9033
9034                 this._stop( event, this._handleIndex );
9035                 this._change( event, this._handleIndex );
9036
9037                 this._handleIndex = null;
9038                 this._clickOffset = null;
9039                 this._animateOff = false;
9040
9041                 return false;
9042         },
9043
9044         _detectOrientation: function() {
9045                 this.orientation = ( this.options.orientation === "vertical" ) ? "vertical" : "horizontal";
9046         },
9047
9048         _normValueFromMouse: function( position ) {
9049                 var pixelTotal,
9050                         pixelMouse,
9051                         percentMouse,
9052                         valueTotal,
9053                         valueMouse;
9054
9055                 if ( this.orientation === "horizontal" ) {
9056                         pixelTotal = this.elementSize.width;
9057                         pixelMouse = position.x - this.elementOffset.left - ( this._clickOffset ? this._clickOffset.left : 0 );
9058                 } else {
9059                         pixelTotal = this.elementSize.height;
9060                         pixelMouse = position.y - this.elementOffset.top - ( this._clickOffset ? this._clickOffset.top : 0 );
9061                 }
9062
9063                 percentMouse = ( pixelMouse / pixelTotal );
9064                 if ( percentMouse > 1 ) {
9065                         percentMouse = 1;
9066                 }
9067                 if ( percentMouse < 0 ) {
9068                         percentMouse = 0;
9069                 }
9070                 if ( this.orientation === "vertical" ) {
9071                         percentMouse = 1 - percentMouse;
9072                 }
9073
9074                 valueTotal = this._valueMax() - this._valueMin();
9075                 valueMouse = this._valueMin() + percentMouse * valueTotal;
9076
9077                 return this._trimAlignValue( valueMouse );
9078         },
9079
9080         _start: function( event, index ) {
9081                 var uiHash = {
9082                         handle: this.handles[ index ],
9083                         value: this.value()
9084                 };
9085                 if ( this.options.values && this.options.values.length ) {
9086                         uiHash.value = this.values( index );
9087                         uiHash.values = this.values();
9088                 }
9089                 return this._trigger( "start", event, uiHash );
9090         },
9091
9092         _slide: function( event, index, newVal ) {
9093                 var otherVal,
9094                         newValues,
9095                         allowed;
9096
9097                 if ( this.options.values && this.options.values.length ) {
9098                         otherVal = this.values( index ? 0 : 1 );
9099
9100                         if ( ( this.options.values.length === 2 && this.options.range === true ) &&
9101                                         ( ( index === 0 && newVal > otherVal) || ( index === 1 && newVal < otherVal ) )
9102                                 ) {
9103                                 newVal = otherVal;
9104                         }
9105
9106                         if ( newVal !== this.values( index ) ) {
9107                                 newValues = this.values();
9108                                 newValues[ index ] = newVal;
9109                                 // A slide can be canceled by returning false from the slide callback
9110                                 allowed = this._trigger( "slide", event, {
9111                                         handle: this.handles[ index ],
9112                                         value: newVal,
9113                                         values: newValues
9114                                 } );
9115                                 otherVal = this.values( index ? 0 : 1 );
9116                                 if ( allowed !== false ) {
9117                                         this.values( index, newVal );
9118                                 }
9119                         }
9120                 } else {
9121                         if ( newVal !== this.value() ) {
9122                                 // A slide can be canceled by returning false from the slide callback
9123                                 allowed = this._trigger( "slide", event, {
9124                                         handle: this.handles[ index ],
9125                                         value: newVal
9126                                 } );
9127                                 if ( allowed !== false ) {
9128                                         this.value( newVal );
9129                                 }
9130                         }
9131                 }
9132         },
9133
9134         _stop: function( event, index ) {
9135                 var uiHash = {
9136                         handle: this.handles[ index ],
9137                         value: this.value()
9138                 };
9139                 if ( this.options.values && this.options.values.length ) {
9140                         uiHash.value = this.values( index );
9141                         uiHash.values = this.values();
9142                 }
9143
9144                 this._trigger( "stop", event, uiHash );
9145         },
9146
9147         _change: function( event, index ) {
9148                 if ( !this._keySliding && !this._mouseSliding ) {
9149                         var uiHash = {
9150                                 handle: this.handles[ index ],
9151                                 value: this.value()
9152                         };
9153                         if ( this.options.values && this.options.values.length ) {
9154                                 uiHash.value = this.values( index );
9155                                 uiHash.values = this.values();
9156                         }
9157
9158                         //store the last changed value index for reference when handles overlap
9159                         this._lastChangedValue = index;
9160
9161                         this._trigger( "change", event, uiHash );
9162                 }
9163         },
9164
9165         value: function( newValue ) {
9166                 if ( arguments.length ) {
9167                         this.options.value = this._trimAlignValue( newValue );
9168                         this._refreshValue();
9169                         this._change( null, 0 );
9170                         return;
9171                 }
9172
9173                 return this._value();
9174         },
9175
9176         values: function( index, newValue ) {
9177                 var vals,
9178                         newValues,
9179                         i;
9180
9181                 if ( arguments.length > 1 ) {
9182                         this.options.values[ index ] = this._trimAlignValue( newValue );
9183                         this._refreshValue();
9184                         this._change( null, index );
9185                         return;
9186                 }
9187
9188                 if ( arguments.length ) {
9189                         if ( $.isArray( arguments[ 0 ] ) ) {
9190                                 vals = this.options.values;
9191                                 newValues = arguments[ 0 ];
9192                                 for ( i = 0; i < vals.length; i += 1 ) {
9193                                         vals[ i ] = this._trimAlignValue( newValues[ i ] );
9194                                         this._change( null, i );
9195                                 }
9196                                 this._refreshValue();
9197                         } else {
9198                                 if ( this.options.values && this.options.values.length ) {
9199                                         return this._values( index );
9200                                 } else {
9201                                         return this.value();
9202                                 }
9203                         }
9204                 } else {
9205                         return this._values();
9206                 }
9207         },
9208
9209         _setOption: function( key, value ) {
9210                 var i,
9211                         valsLength = 0;
9212
9213                 if ( key === "range" && this.options.range === true ) {
9214                         if ( value === "min" ) {
9215                                 this.options.value = this._values( 0 );
9216                                 this.options.values = null;
9217                         } else if ( value === "max" ) {
9218                                 this.options.value = this._values( this.options.values.length - 1 );
9219                                 this.options.values = null;
9220                         }
9221                 }
9222
9223                 if ( $.isArray( this.options.values ) ) {
9224                         valsLength = this.options.values.length;
9225                 }
9226
9227                 if ( key === "disabled" ) {
9228                         this.element.toggleClass( "ui-state-disabled", !!value );
9229                 }
9230
9231                 this._super( key, value );
9232
9233                 switch ( key ) {
9234                         case "orientation":
9235                                 this._detectOrientation();
9236                                 this.element
9237                                         .removeClass( "ui-slider-horizontal ui-slider-vertical" )
9238                                         .addClass( "ui-slider-" + this.orientation );
9239                                 this._refreshValue();
9240
9241                                 // Reset positioning from previous orientation
9242                                 this.handles.css( value === "horizontal" ? "bottom" : "left", "" );
9243                                 break;
9244                         case "value":
9245                                 this._animateOff = true;
9246                                 this._refreshValue();
9247                                 this._change( null, 0 );
9248                                 this._animateOff = false;
9249                                 break;
9250                         case "values":
9251                                 this._animateOff = true;
9252                                 this._refreshValue();
9253                                 for ( i = 0; i < valsLength; i += 1 ) {
9254                                         this._change( null, i );
9255                                 }
9256                                 this._animateOff = false;
9257                                 break;
9258                         case "step":
9259                         case "min":
9260                         case "max":
9261                                 this._animateOff = true;
9262                                 this._calculateNewMax();
9263                                 this._refreshValue();
9264                                 this._animateOff = false;
9265                                 break;
9266                         case "range":
9267                                 this._animateOff = true;
9268                                 this._refresh();
9269                                 this._animateOff = false;
9270                                 break;
9271                 }
9272         },
9273
9274         //internal value getter
9275         // _value() returns value trimmed by min and max, aligned by step
9276         _value: function() {
9277                 var val = this.options.value;
9278                 val = this._trimAlignValue( val );
9279
9280                 return val;
9281         },
9282
9283         //internal values getter
9284         // _values() returns array of values trimmed by min and max, aligned by step
9285         // _values( index ) returns single value trimmed by min and max, aligned by step
9286         _values: function( index ) {
9287                 var val,
9288                         vals,
9289                         i;
9290
9291                 if ( arguments.length ) {
9292                         val = this.options.values[ index ];
9293                         val = this._trimAlignValue( val );
9294
9295                         return val;
9296                 } else if ( this.options.values && this.options.values.length ) {
9297                         // .slice() creates a copy of the array
9298                         // this copy gets trimmed by min and max and then returned
9299                         vals = this.options.values.slice();
9300                         for ( i = 0; i < vals.length; i += 1) {
9301                                 vals[ i ] = this._trimAlignValue( vals[ i ] );
9302                         }
9303
9304                         return vals;
9305                 } else {
9306                         return [];
9307                 }
9308         },
9309
9310         // returns the step-aligned value that val is closest to, between (inclusive) min and max
9311         _trimAlignValue: function( val ) {
9312                 if ( val <= this._valueMin() ) {
9313                         return this._valueMin();
9314                 }
9315                 if ( val >= this._valueMax() ) {
9316                         return this._valueMax();
9317                 }
9318                 var step = ( this.options.step > 0 ) ? this.options.step : 1,
9319                         valModStep = (val - this._valueMin()) % step,
9320                         alignValue = val - valModStep;
9321
9322                 if ( Math.abs(valModStep) * 2 >= step ) {
9323                         alignValue += ( valModStep > 0 ) ? step : ( -step );
9324                 }
9325
9326                 // Since JavaScript has problems with large floats, round
9327                 // the final value to 5 digits after the decimal point (see #4124)
9328                 return parseFloat( alignValue.toFixed(5) );
9329         },
9330
9331         _calculateNewMax: function() {
9332                 var max = this.options.max,
9333                         min = this._valueMin(),
9334                         step = this.options.step,
9335                         aboveMin = Math.floor( ( +( max - min ).toFixed( this._precision() ) ) / step ) * step;
9336                 max = aboveMin + min;
9337                 this.max = parseFloat( max.toFixed( this._precision() ) );
9338         },
9339
9340         _precision: function() {
9341                 var precision = this._precisionOf( this.options.step );
9342                 if ( this.options.min !== null ) {
9343                         precision = Math.max( precision, this._precisionOf( this.options.min ) );
9344                 }
9345                 return precision;
9346         },
9347
9348         _precisionOf: function( num ) {
9349                 var str = num.toString(),
9350                         decimal = str.indexOf( "." );
9351                 return decimal === -1 ? 0 : str.length - decimal - 1;
9352         },
9353
9354         _valueMin: function() {
9355                 return this.options.min;
9356         },
9357
9358         _valueMax: function() {
9359                 return this.max;
9360         },
9361
9362         _refreshValue: function() {
9363                 var lastValPercent, valPercent, value, valueMin, valueMax,
9364                         oRange = this.options.range,
9365                         o = this.options,
9366                         that = this,
9367                         animate = ( !this._animateOff ) ? o.animate : false,
9368                         _set = {};
9369
9370                 if ( this.options.values && this.options.values.length ) {
9371                         this.handles.each(function( i ) {
9372                                 valPercent = ( that.values(i) - that._valueMin() ) / ( that._valueMax() - that._valueMin() ) * 100;
9373                                 _set[ that.orientation === "horizontal" ? "left" : "bottom" ] = valPercent + "%";
9374                                 $( this ).stop( 1, 1 )[ animate ? "animate" : "css" ]( _set, o.animate );
9375                                 if ( that.options.range === true ) {
9376                                         if ( that.orientation === "horizontal" ) {
9377                                                 if ( i === 0 ) {
9378                                                         that.range.stop( 1, 1 )[ animate ? "animate" : "css" ]( { left: valPercent + "%" }, o.animate );
9379                                                 }
9380                                                 if ( i === 1 ) {
9381                                                         that.range[ animate ? "animate" : "css" ]( { width: ( valPercent - lastValPercent ) + "%" }, { queue: false, duration: o.animate } );
9382                                                 }
9383                                         } else {
9384                                                 if ( i === 0 ) {
9385                                                         that.range.stop( 1, 1 )[ animate ? "animate" : "css" ]( { bottom: ( valPercent ) + "%" }, o.animate );
9386                                                 }
9387                                                 if ( i === 1 ) {
9388                                                         that.range[ animate ? "animate" : "css" ]( { height: ( valPercent - lastValPercent ) + "%" }, { queue: false, duration: o.animate } );
9389                                                 }
9390                                         }
9391                                 }
9392                                 lastValPercent = valPercent;
9393                         });
9394                 } else {
9395                         value = this.value();
9396                         valueMin = this._valueMin();
9397                         valueMax = this._valueMax();
9398                         valPercent = ( valueMax !== valueMin ) ?
9399                                         ( value - valueMin ) / ( valueMax - valueMin ) * 100 :
9400                                         0;
9401                         _set[ this.orientation === "horizontal" ? "left" : "bottom" ] = valPercent + "%";
9402                         this.handle.stop( 1, 1 )[ animate ? "animate" : "css" ]( _set, o.animate );
9403
9404                         if ( oRange === "min" && this.orientation === "horizontal" ) {
9405                                 this.range.stop( 1, 1 )[ animate ? "animate" : "css" ]( { width: valPercent + "%" }, o.animate );
9406                         }
9407                         if ( oRange === "max" && this.orientation === "horizontal" ) {
9408                                 this.range[ animate ? "animate" : "css" ]( { width: ( 100 - valPercent ) + "%" }, { queue: false, duration: o.animate } );
9409                         }
9410                         if ( oRange === "min" && this.orientation === "vertical" ) {
9411                                 this.range.stop( 1, 1 )[ animate ? "animate" : "css" ]( { height: valPercent + "%" }, o.animate );
9412                         }
9413                         if ( oRange === "max" && this.orientation === "vertical" ) {
9414                                 this.range[ animate ? "animate" : "css" ]( { height: ( 100 - valPercent ) + "%" }, { queue: false, duration: o.animate } );
9415                         }
9416                 }
9417         },
9418
9419         _handleEvents: {
9420                 keydown: function( event ) {
9421                         var allowed, curVal, newVal, step,
9422                                 index = $( event.target ).data( "ui-slider-handle-index" );
9423
9424                         switch ( event.keyCode ) {
9425                                 case $.ui.keyCode.HOME:
9426                                 case $.ui.keyCode.END:
9427                                 case $.ui.keyCode.PAGE_UP:
9428                                 case $.ui.keyCode.PAGE_DOWN:
9429                                 case $.ui.keyCode.UP:
9430                                 case $.ui.keyCode.RIGHT:
9431                                 case $.ui.keyCode.DOWN:
9432                                 case $.ui.keyCode.LEFT:
9433                                         event.preventDefault();
9434                                         if ( !this._keySliding ) {
9435                                                 this._keySliding = true;
9436                                                 $( event.target ).addClass( "ui-state-active" );
9437                                                 allowed = this._start( event, index );
9438                                                 if ( allowed === false ) {
9439                                                         return;
9440                                                 }
9441                                         }
9442                                         break;
9443                         }
9444
9445                         step = this.options.step;
9446                         if ( this.options.values && this.options.values.length ) {
9447                                 curVal = newVal = this.values( index );
9448                         } else {
9449                                 curVal = newVal = this.value();
9450                         }
9451
9452                         switch ( event.keyCode ) {
9453                                 case $.ui.keyCode.HOME:
9454                                         newVal = this._valueMin();
9455                                         break;
9456                                 case $.ui.keyCode.END:
9457                                         newVal = this._valueMax();
9458                                         break;
9459                                 case $.ui.keyCode.PAGE_UP:
9460                                         newVal = this._trimAlignValue(
9461                                                 curVal + ( ( this._valueMax() - this._valueMin() ) / this.numPages )
9462                                         );
9463                                         break;
9464                                 case $.ui.keyCode.PAGE_DOWN:
9465                                         newVal = this._trimAlignValue(
9466                                                 curVal - ( (this._valueMax() - this._valueMin()) / this.numPages ) );
9467                                         break;
9468                                 case $.ui.keyCode.UP:
9469                                 case $.ui.keyCode.RIGHT:
9470                                         if ( curVal === this._valueMax() ) {
9471                                                 return;
9472                                         }
9473                                         newVal = this._trimAlignValue( curVal + step );
9474                                         break;
9475                                 case $.ui.keyCode.DOWN:
9476                                 case $.ui.keyCode.LEFT:
9477                                         if ( curVal === this._valueMin() ) {
9478                                                 return;
9479                                         }
9480                                         newVal = this._trimAlignValue( curVal - step );
9481                                         break;
9482                         }
9483
9484                         this._slide( event, index, newVal );
9485                 },
9486                 keyup: function( event ) {
9487                         var index = $( event.target ).data( "ui-slider-handle-index" );
9488
9489                         if ( this._keySliding ) {
9490                                 this._keySliding = false;
9491                                 this._stop( event, index );
9492                                 this._change( event, index );
9493                                 $( event.target ).removeClass( "ui-state-active" );
9494                         }
9495                 }
9496         }
9497 });
9498
9499
9500 /*!
9501  * jQuery UI Tabs 1.11.4
9502  * http://jqueryui.com
9503  *
9504  * Copyright jQuery Foundation and other contributors
9505  * Released under the MIT license.
9506  * http://jquery.org/license
9507  *
9508  * http://api.jqueryui.com/tabs/
9509  */
9510
9511
9512 var tabs = $.widget( "ui.tabs", {
9513         version: "1.11.4",
9514         delay: 300,
9515         options: {
9516                 active: null,
9517                 collapsible: false,
9518                 event: "click",
9519                 heightStyle: "content",
9520                 hide: null,
9521                 show: null,
9522
9523                 // callbacks
9524                 activate: null,
9525                 beforeActivate: null,
9526                 beforeLoad: null,
9527                 load: null
9528         },
9529
9530         _isLocal: (function() {
9531                 var rhash = /#.*$/;
9532
9533                 return function( anchor ) {
9534                         var anchorUrl, locationUrl;
9535
9536                         // support: IE7
9537                         // IE7 doesn't normalize the href property when set via script (#9317)
9538                         anchor = anchor.cloneNode( false );
9539
9540                         anchorUrl = anchor.href.replace( rhash, "" );
9541                         locationUrl = location.href.replace( rhash, "" );
9542
9543                         // decoding may throw an error if the URL isn't UTF-8 (#9518)
9544                         try {
9545                                 anchorUrl = decodeURIComponent( anchorUrl );
9546                         } catch ( error ) {}
9547                         try {
9548                                 locationUrl = decodeURIComponent( locationUrl );
9549                         } catch ( error ) {}
9550
9551                         return anchor.hash.length > 1 && anchorUrl === locationUrl;
9552                 };
9553         })(),
9554
9555         _create: function() {
9556                 var that = this,
9557                         options = this.options;
9558
9559                 this.running = false;
9560
9561                 this.element
9562                         .addClass( "ui-tabs ui-widget ui-widget-content ui-corner-all" )
9563                         .toggleClass( "ui-tabs-collapsible", options.collapsible );
9564
9565                 this._processTabs();
9566                 options.active = this._initialActive();
9567
9568                 // Take disabling tabs via class attribute from HTML
9569                 // into account and update option properly.
9570                 if ( $.isArray( options.disabled ) ) {
9571                         options.disabled = $.unique( options.disabled.concat(
9572                                 $.map( this.tabs.filter( ".ui-state-disabled" ), function( li ) {
9573                                         return that.tabs.index( li );
9574                                 })
9575                         ) ).sort();
9576                 }
9577
9578                 // check for length avoids error when initializing empty list
9579                 if ( this.options.active !== false && this.anchors.length ) {
9580                         this.active = this._findActive( options.active );
9581                 } else {
9582                         this.active = $();
9583                 }
9584
9585                 this._refresh();
9586
9587                 if ( this.active.length ) {
9588                         this.load( options.active );
9589                 }
9590         },
9591
9592         _initialActive: function() {
9593                 var active = this.options.active,
9594                         collapsible = this.options.collapsible,
9595                         locationHash = location.hash.substring( 1 );
9596
9597                 if ( active === null ) {
9598                         // check the fragment identifier in the URL
9599                         if ( locationHash ) {
9600                                 this.tabs.each(function( i, tab ) {
9601                                         if ( $( tab ).attr( "aria-controls" ) === locationHash ) {
9602                                                 active = i;
9603                                                 return false;
9604                                         }
9605                                 });
9606                         }
9607
9608                         // check for a tab marked active via a class
9609                         if ( active === null ) {
9610                                 active = this.tabs.index( this.tabs.filter( ".ui-tabs-active" ) );
9611                         }
9612
9613                         // no active tab, set to false
9614                         if ( active === null || active === -1 ) {
9615                                 active = this.tabs.length ? 0 : false;
9616                         }
9617                 }
9618
9619                 // handle numbers: negative, out of range
9620                 if ( active !== false ) {
9621                         active = this.tabs.index( this.tabs.eq( active ) );
9622                         if ( active === -1 ) {
9623                                 active = collapsible ? false : 0;
9624                         }
9625                 }
9626
9627                 // don't allow collapsible: false and active: false
9628                 if ( !collapsible && active === false && this.anchors.length ) {
9629                         active = 0;
9630                 }
9631
9632                 return active;
9633         },
9634
9635         _getCreateEventData: function() {
9636                 return {
9637                         tab: this.active,
9638                         panel: !this.active.length ? $() : this._getPanelForTab( this.active )
9639                 };
9640         },
9641
9642         _tabKeydown: function( event ) {
9643                 var focusedTab = $( this.document[0].activeElement ).closest( "li" ),
9644                         selectedIndex = this.tabs.index( focusedTab ),
9645                         goingForward = true;
9646
9647                 if ( this._handlePageNav( event ) ) {
9648                         return;
9649                 }
9650
9651                 switch ( event.keyCode ) {
9652                         case $.ui.keyCode.RIGHT:
9653                         case $.ui.keyCode.DOWN:
9654                                 selectedIndex++;
9655                                 break;
9656                         case $.ui.keyCode.UP:
9657                         case $.ui.keyCode.LEFT:
9658                                 goingForward = false;
9659                                 selectedIndex--;
9660                                 break;
9661                         case $.ui.keyCode.END:
9662                                 selectedIndex = this.anchors.length - 1;
9663                                 break;
9664                         case $.ui.keyCode.HOME:
9665                                 selectedIndex = 0;
9666                                 break;
9667                         case $.ui.keyCode.SPACE:
9668                                 // Activate only, no collapsing
9669                                 event.preventDefault();
9670                                 clearTimeout( this.activating );
9671                                 this._activate( selectedIndex );
9672                                 return;
9673                         case $.ui.keyCode.ENTER:
9674                                 // Toggle (cancel delayed activation, allow collapsing)
9675                                 event.preventDefault();
9676                                 clearTimeout( this.activating );
9677                                 // Determine if we should collapse or activate
9678                                 this._activate( selectedIndex === this.options.active ? false : selectedIndex );
9679                                 return;
9680                         default:
9681                                 return;
9682                 }
9683
9684                 // Focus the appropriate tab, based on which key was pressed
9685                 event.preventDefault();
9686                 clearTimeout( this.activating );
9687                 selectedIndex = this._focusNextTab( selectedIndex, goingForward );
9688
9689                 // Navigating with control/command key will prevent automatic activation
9690                 if ( !event.ctrlKey && !event.metaKey ) {
9691
9692                         // Update aria-selected immediately so that AT think the tab is already selected.
9693                         // Otherwise AT may confuse the user by stating that they need to activate the tab,
9694                         // but the tab will already be activated by the time the announcement finishes.
9695                         focusedTab.attr( "aria-selected", "false" );
9696                         this.tabs.eq( selectedIndex ).attr( "aria-selected", "true" );
9697
9698                         this.activating = this._delay(function() {
9699                                 this.option( "active", selectedIndex );
9700                         }, this.delay );
9701                 }
9702         },
9703
9704         _panelKeydown: function( event ) {
9705                 if ( this._handlePageNav( event ) ) {
9706                         return;
9707                 }
9708
9709                 // Ctrl+up moves focus to the current tab
9710                 if ( event.ctrlKey && event.keyCode === $.ui.keyCode.UP ) {
9711                         event.preventDefault();
9712                         this.active.focus();
9713                 }
9714         },
9715
9716         // Alt+page up/down moves focus to the previous/next tab (and activates)
9717         _handlePageNav: function( event ) {
9718                 if ( event.altKey && event.keyCode === $.ui.keyCode.PAGE_UP ) {
9719                         this._activate( this._focusNextTab( this.options.active - 1, false ) );
9720                         return true;
9721                 }
9722                 if ( event.altKey && event.keyCode === $.ui.keyCode.PAGE_DOWN ) {
9723                         this._activate( this._focusNextTab( this.options.active + 1, true ) );
9724                         return true;
9725                 }
9726         },
9727
9728         _findNextTab: function( index, goingForward ) {
9729                 var lastTabIndex = this.tabs.length - 1;
9730
9731                 function constrain() {
9732                         if ( index > lastTabIndex ) {
9733                                 index = 0;
9734                         }
9735                         if ( index < 0 ) {
9736                                 index = lastTabIndex;
9737                         }
9738                         return index;
9739                 }
9740
9741                 while ( $.inArray( constrain(), this.options.disabled ) !== -1 ) {
9742                         index = goingForward ? index + 1 : index - 1;
9743                 }
9744
9745                 return index;
9746         },
9747
9748         _focusNextTab: function( index, goingForward ) {
9749                 index = this._findNextTab( index, goingForward );
9750                 this.tabs.eq( index ).focus();
9751                 return index;
9752         },
9753
9754         _setOption: function( key, value ) {
9755                 if ( key === "active" ) {
9756                         // _activate() will handle invalid values and update this.options
9757                         this._activate( value );
9758                         return;
9759                 }
9760
9761                 if ( key === "disabled" ) {
9762                         // don't use the widget factory's disabled handling
9763                         this._setupDisabled( value );
9764                         return;
9765                 }
9766
9767                 this._super( key, value);
9768
9769                 if ( key === "collapsible" ) {
9770                         this.element.toggleClass( "ui-tabs-collapsible", value );
9771                         // Setting collapsible: false while collapsed; open first panel
9772                         if ( !value && this.options.active === false ) {
9773                                 this._activate( 0 );
9774                         }
9775                 }
9776
9777                 if ( key === "event" ) {
9778                         this._setupEvents( value );
9779                 }
9780
9781                 if ( key === "heightStyle" ) {
9782                         this._setupHeightStyle( value );
9783                 }
9784         },
9785
9786         _sanitizeSelector: function( hash ) {
9787                 return hash ? hash.replace( /[!"$%&'()*+,.\/:;<=>?@\[\]\^`{|}~]/g, "\\$&" ) : "";
9788         },
9789
9790         refresh: function() {
9791                 var options = this.options,
9792                         lis = this.tablist.children( ":has(a[href])" );
9793
9794                 // get disabled tabs from class attribute from HTML
9795                 // this will get converted to a boolean if needed in _refresh()
9796                 options.disabled = $.map( lis.filter( ".ui-state-disabled" ), function( tab ) {
9797                         return lis.index( tab );
9798                 });
9799
9800                 this._processTabs();
9801
9802                 // was collapsed or no tabs
9803                 if ( options.active === false || !this.anchors.length ) {
9804                         options.active = false;
9805                         this.active = $();
9806                 // was active, but active tab is gone
9807                 } else if ( this.active.length && !$.contains( this.tablist[ 0 ], this.active[ 0 ] ) ) {
9808                         // all remaining tabs are disabled
9809                         if ( this.tabs.length === options.disabled.length ) {
9810                                 options.active = false;
9811                                 this.active = $();
9812                         // activate previous tab
9813                         } else {
9814                                 this._activate( this._findNextTab( Math.max( 0, options.active - 1 ), false ) );
9815                         }
9816                 // was active, active tab still exists
9817                 } else {
9818                         // make sure active index is correct
9819                         options.active = this.tabs.index( this.active );
9820                 }
9821
9822                 this._refresh();
9823         },
9824
9825         _refresh: function() {
9826                 this._setupDisabled( this.options.disabled );
9827                 this._setupEvents( this.options.event );
9828                 this._setupHeightStyle( this.options.heightStyle );
9829
9830                 this.tabs.not( this.active ).attr({
9831                         "aria-selected": "false",
9832                         "aria-expanded": "false",
9833                         tabIndex: -1
9834                 });
9835                 this.panels.not( this._getPanelForTab( this.active ) )
9836                         .hide()
9837                         .attr({
9838                                 "aria-hidden": "true"
9839                         });
9840
9841                 // Make sure one tab is in the tab order
9842                 if ( !this.active.length ) {
9843                         this.tabs.eq( 0 ).attr( "tabIndex", 0 );
9844                 } else {
9845                         this.active
9846                                 .addClass( "ui-tabs-active ui-state-active" )
9847                                 .attr({
9848                                         "aria-selected": "true",
9849                                         "aria-expanded": "true",
9850                                         tabIndex: 0
9851                                 });
9852                         this._getPanelForTab( this.active )
9853                                 .show()
9854                                 .attr({
9855                                         "aria-hidden": "false"
9856                                 });
9857                 }
9858         },
9859
9860         _processTabs: function() {
9861                 var that = this,
9862                         prevTabs = this.tabs,
9863                         prevAnchors = this.anchors,
9864                         prevPanels = this.panels;
9865
9866                 this.tablist = this._getList()
9867                         .addClass( "ui-tabs-nav ui-helper-reset ui-helper-clearfix ui-widget-header ui-corner-all" )
9868                         .attr( "role", "tablist" )
9869
9870                         // Prevent users from focusing disabled tabs via click
9871                         .delegate( "> li", "mousedown" + this.eventNamespace, function( event ) {
9872                                 if ( $( this ).is( ".ui-state-disabled" ) ) {
9873                                         event.preventDefault();
9874                                 }
9875                         })
9876
9877                         // support: IE <9
9878                         // Preventing the default action in mousedown doesn't prevent IE
9879                         // from focusing the element, so if the anchor gets focused, blur.
9880                         // We don't have to worry about focusing the previously focused
9881                         // element since clicking on a non-focusable element should focus
9882                         // the body anyway.
9883                         .delegate( ".ui-tabs-anchor", "focus" + this.eventNamespace, function() {
9884                                 if ( $( this ).closest( "li" ).is( ".ui-state-disabled" ) ) {
9885                                         this.blur();
9886                                 }
9887                         });
9888
9889                 this.tabs = this.tablist.find( "> li:has(a[href])" )
9890                         .addClass( "ui-state-default ui-corner-top" )
9891                         .attr({
9892                                 role: "tab",
9893                                 tabIndex: -1
9894                         });
9895
9896                 this.anchors = this.tabs.map(function() {
9897                                 return $( "a", this )[ 0 ];
9898                         })
9899                         .addClass( "ui-tabs-anchor" )
9900                         .attr({
9901                                 role: "presentation",
9902                                 tabIndex: -1
9903                         });
9904
9905                 this.panels = $();
9906
9907                 this.anchors.each(function( i, anchor ) {
9908                         var selector, panel, panelId,
9909                                 anchorId = $( anchor ).uniqueId().attr( "id" ),
9910                                 tab = $( anchor ).closest( "li" ),
9911                                 originalAriaControls = tab.attr( "aria-controls" );
9912
9913                         // inline tab
9914                         if ( that._isLocal( anchor ) ) {
9915                                 selector = anchor.hash;
9916                                 panelId = selector.substring( 1 );
9917                                 panel = that.element.find( that._sanitizeSelector( selector ) );
9918                         // remote tab
9919                         } else {
9920                                 // If the tab doesn't already have aria-controls,
9921                                 // generate an id by using a throw-away element
9922                                 panelId = tab.attr( "aria-controls" ) || $( {} ).uniqueId()[ 0 ].id;
9923                                 selector = "#" + panelId;
9924                                 panel = that.element.find( selector );
9925                                 if ( !panel.length ) {
9926                                         panel = that._createPanel( panelId );
9927                                         panel.insertAfter( that.panels[ i - 1 ] || that.tablist );
9928                                 }
9929                                 panel.attr( "aria-live", "polite" );
9930                         }
9931
9932                         if ( panel.length) {
9933                                 that.panels = that.panels.add( panel );
9934                         }
9935                         if ( originalAriaControls ) {
9936                                 tab.data( "ui-tabs-aria-controls", originalAriaControls );
9937                         }
9938                         tab.attr({
9939                                 "aria-controls": panelId,
9940                                 "aria-labelledby": anchorId
9941                         });
9942                         panel.attr( "aria-labelledby", anchorId );
9943                 });
9944
9945                 this.panels
9946                         .addClass( "ui-tabs-panel ui-widget-content ui-corner-bottom" )
9947                         .attr( "role", "tabpanel" );
9948
9949                 // Avoid memory leaks (#10056)
9950                 if ( prevTabs ) {
9951                         this._off( prevTabs.not( this.tabs ) );
9952                         this._off( prevAnchors.not( this.anchors ) );
9953                         this._off( prevPanels.not( this.panels ) );
9954                 }
9955         },
9956
9957         // allow overriding how to find the list for rare usage scenarios (#7715)
9958         _getList: function() {
9959                 return this.tablist || this.element.find( "ol,ul" ).eq( 0 );
9960         },
9961
9962         _createPanel: function( id ) {
9963                 return $( "<div>" )
9964                         .attr( "id", id )
9965                         .addClass( "ui-tabs-panel ui-widget-content ui-corner-bottom" )
9966                         .data( "ui-tabs-destroy", true );
9967         },
9968
9969         _setupDisabled: function( disabled ) {
9970                 if ( $.isArray( disabled ) ) {
9971                         if ( !disabled.length ) {
9972                                 disabled = false;
9973                         } else if ( disabled.length === this.anchors.length ) {
9974                                 disabled = true;
9975                         }
9976                 }
9977
9978                 // disable tabs
9979                 for ( var i = 0, li; ( li = this.tabs[ i ] ); i++ ) {
9980                         if ( disabled === true || $.inArray( i, disabled ) !== -1 ) {
9981                                 $( li )
9982                                         .addClass( "ui-state-disabled" )
9983                                         .attr( "aria-disabled", "true" );
9984                         } else {
9985                                 $( li )
9986                                         .removeClass( "ui-state-disabled" )
9987                                         .removeAttr( "aria-disabled" );
9988                         }
9989                 }
9990
9991                 this.options.disabled = disabled;
9992         },
9993
9994         _setupEvents: function( event ) {
9995                 var events = {};
9996                 if ( event ) {
9997                         $.each( event.split(" "), function( index, eventName ) {
9998                                 events[ eventName ] = "_eventHandler";
9999                         });
10000                 }
10001
10002                 this._off( this.anchors.add( this.tabs ).add( this.panels ) );
10003                 // Always prevent the default action, even when disabled
10004                 this._on( true, this.anchors, {
10005                         click: function( event ) {
10006                                 event.preventDefault();
10007                         }
10008                 });
10009                 this._on( this.anchors, events );
10010                 this._on( this.tabs, { keydown: "_tabKeydown" } );
10011                 this._on( this.panels, { keydown: "_panelKeydown" } );
10012
10013                 this._focusable( this.tabs );
10014                 this._hoverable( this.tabs );
10015         },
10016
10017         _setupHeightStyle: function( heightStyle ) {
10018                 var maxHeight,
10019                         parent = this.element.parent();
10020
10021                 if ( heightStyle === "fill" ) {
10022                         maxHeight = parent.height();
10023                         maxHeight -= this.element.outerHeight() - this.element.height();
10024
10025                         this.element.siblings( ":visible" ).each(function() {
10026                                 var elem = $( this ),
10027                                         position = elem.css( "position" );
10028
10029                                 if ( position === "absolute" || position === "fixed" ) {
10030                                         return;
10031                                 }
10032                                 maxHeight -= elem.outerHeight( true );
10033                         });
10034
10035                         this.element.children().not( this.panels ).each(function() {
10036                                 maxHeight -= $( this ).outerHeight( true );
10037                         });
10038
10039                         this.panels.each(function() {
10040                                 $( this ).height( Math.max( 0, maxHeight -
10041                                         $( this ).innerHeight() + $( this ).height() ) );
10042                         })
10043                         .css( "overflow", "auto" );
10044                 } else if ( heightStyle === "auto" ) {
10045                         maxHeight = 0;
10046                         this.panels.each(function() {
10047                                 maxHeight = Math.max( maxHeight, $( this ).height( "" ).height() );
10048                         }).height( maxHeight );
10049                 }
10050         },
10051
10052         _eventHandler: function( event ) {
10053                 var options = this.options,
10054                         active = this.active,
10055                         anchor = $( event.currentTarget ),
10056                         tab = anchor.closest( "li" ),
10057                         clickedIsActive = tab[ 0 ] === active[ 0 ],
10058                         collapsing = clickedIsActive && options.collapsible,
10059                         toShow = collapsing ? $() : this._getPanelForTab( tab ),
10060                         toHide = !active.length ? $() : this._getPanelForTab( active ),
10061                         eventData = {
10062                                 oldTab: active,
10063                                 oldPanel: toHide,
10064                                 newTab: collapsing ? $() : tab,
10065                                 newPanel: toShow
10066                         };
10067
10068                 event.preventDefault();
10069
10070                 if ( tab.hasClass( "ui-state-disabled" ) ||
10071                                 // tab is already loading
10072                                 tab.hasClass( "ui-tabs-loading" ) ||
10073                                 // can't switch durning an animation
10074                                 this.running ||
10075                                 // click on active header, but not collapsible
10076                                 ( clickedIsActive && !options.collapsible ) ||
10077                                 // allow canceling activation
10078                                 ( this._trigger( "beforeActivate", event, eventData ) === false ) ) {
10079                         return;
10080                 }
10081
10082                 options.active = collapsing ? false : this.tabs.index( tab );
10083
10084                 this.active = clickedIsActive ? $() : tab;
10085                 if ( this.xhr ) {
10086                         this.xhr.abort();
10087                 }
10088
10089                 if ( !toHide.length && !toShow.length ) {
10090                         $.error( "jQuery UI Tabs: Mismatching fragment identifier." );
10091                 }
10092
10093                 if ( toShow.length ) {
10094                         this.load( this.tabs.index( tab ), event );
10095                 }
10096                 this._toggle( event, eventData );
10097         },
10098
10099         // handles show/hide for selecting tabs
10100         _toggle: function( event, eventData ) {
10101                 var that = this,
10102                         toShow = eventData.newPanel,
10103                         toHide = eventData.oldPanel;
10104
10105                 this.running = true;
10106
10107                 function complete() {
10108                         that.running = false;
10109                         that._trigger( "activate", event, eventData );
10110                 }
10111
10112                 function show() {
10113                         eventData.newTab.closest( "li" ).addClass( "ui-tabs-active ui-state-active" );
10114
10115                         if ( toShow.length && that.options.show ) {
10116                                 that._show( toShow, that.options.show, complete );
10117                         } else {
10118                                 toShow.show();
10119                                 complete();
10120                         }
10121                 }
10122
10123                 // start out by hiding, then showing, then completing
10124                 if ( toHide.length && this.options.hide ) {
10125                         this._hide( toHide, this.options.hide, function() {
10126                                 eventData.oldTab.closest( "li" ).removeClass( "ui-tabs-active ui-state-active" );
10127                                 show();
10128                         });
10129                 } else {
10130                         eventData.oldTab.closest( "li" ).removeClass( "ui-tabs-active ui-state-active" );
10131                         toHide.hide();
10132                         show();
10133                 }
10134
10135                 toHide.attr( "aria-hidden", "true" );
10136                 eventData.oldTab.attr({
10137                         "aria-selected": "false",
10138                         "aria-expanded": "false"
10139                 });
10140                 // If we're switching tabs, remove the old tab from the tab order.
10141                 // If we're opening from collapsed state, remove the previous tab from the tab order.
10142                 // If we're collapsing, then keep the collapsing tab in the tab order.
10143                 if ( toShow.length && toHide.length ) {
10144                         eventData.oldTab.attr( "tabIndex", -1 );
10145                 } else if ( toShow.length ) {
10146                         this.tabs.filter(function() {
10147                                 return $( this ).attr( "tabIndex" ) === 0;
10148                         })
10149                         .attr( "tabIndex", -1 );
10150                 }
10151
10152                 toShow.attr( "aria-hidden", "false" );
10153                 eventData.newTab.attr({
10154                         "aria-selected": "true",
10155                         "aria-expanded": "true",
10156                         tabIndex: 0
10157                 });
10158         },
10159
10160         _activate: function( index ) {
10161                 var anchor,
10162                         active = this._findActive( index );
10163
10164                 // trying to activate the already active panel
10165                 if ( active[ 0 ] === this.active[ 0 ] ) {
10166                         return;
10167                 }
10168
10169                 // trying to collapse, simulate a click on the current active header
10170                 if ( !active.length ) {
10171                         active = this.active;
10172                 }
10173
10174                 anchor = active.find( ".ui-tabs-anchor" )[ 0 ];
10175                 this._eventHandler({
10176                         target: anchor,
10177                         currentTarget: anchor,
10178                         preventDefault: $.noop
10179                 });
10180         },
10181
10182         _findActive: function( index ) {
10183                 return index === false ? $() : this.tabs.eq( index );
10184         },
10185
10186         _getIndex: function( index ) {
10187                 // meta-function to give users option to provide a href string instead of a numerical index.
10188                 if ( typeof index === "string" ) {
10189                         index = this.anchors.index( this.anchors.filter( "[href$='" + index + "']" ) );
10190                 }
10191
10192                 return index;
10193         },
10194
10195         _destroy: function() {
10196                 if ( this.xhr ) {
10197                         this.xhr.abort();
10198                 }
10199
10200                 this.element.removeClass( "ui-tabs ui-widget ui-widget-content ui-corner-all ui-tabs-collapsible" );
10201
10202                 this.tablist
10203                         .removeClass( "ui-tabs-nav ui-helper-reset ui-helper-clearfix ui-widget-header ui-corner-all" )
10204                         .removeAttr( "role" );
10205
10206                 this.anchors
10207                         .removeClass( "ui-tabs-anchor" )
10208                         .removeAttr( "role" )
10209                         .removeAttr( "tabIndex" )
10210                         .removeUniqueId();
10211
10212                 this.tablist.unbind( this.eventNamespace );
10213
10214                 this.tabs.add( this.panels ).each(function() {
10215                         if ( $.data( this, "ui-tabs-destroy" ) ) {
10216                                 $( this ).remove();
10217                         } else {
10218                                 $( this )
10219                                         .removeClass( "ui-state-default ui-state-active ui-state-disabled " +
10220                                                 "ui-corner-top ui-corner-bottom ui-widget-content ui-tabs-active ui-tabs-panel" )
10221                                         .removeAttr( "tabIndex" )
10222                                         .removeAttr( "aria-live" )
10223                                         .removeAttr( "aria-busy" )
10224                                         .removeAttr( "aria-selected" )
10225                                         .removeAttr( "aria-labelledby" )
10226                                         .removeAttr( "aria-hidden" )
10227                                         .removeAttr( "aria-expanded" )
10228                                         .removeAttr( "role" );
10229                         }
10230                 });
10231
10232                 this.tabs.each(function() {
10233                         var li = $( this ),
10234                                 prev = li.data( "ui-tabs-aria-controls" );
10235                         if ( prev ) {
10236                                 li
10237                                         .attr( "aria-controls", prev )
10238                                         .removeData( "ui-tabs-aria-controls" );
10239                         } else {
10240                                 li.removeAttr( "aria-controls" );
10241                         }
10242                 });
10243
10244                 this.panels.show();
10245
10246                 if ( this.options.heightStyle !== "content" ) {
10247                         this.panels.css( "height", "" );
10248                 }
10249         },
10250
10251         enable: function( index ) {
10252                 var disabled = this.options.disabled;
10253                 if ( disabled === false ) {
10254                         return;
10255                 }
10256
10257                 if ( index === undefined ) {
10258                         disabled = false;
10259                 } else {
10260                         index = this._getIndex( index );
10261                         if ( $.isArray( disabled ) ) {
10262                                 disabled = $.map( disabled, function( num ) {
10263                                         return num !== index ? num : null;
10264                                 });
10265                         } else {
10266                                 disabled = $.map( this.tabs, function( li, num ) {
10267                                         return num !== index ? num : null;
10268                                 });
10269                         }
10270                 }
10271                 this._setupDisabled( disabled );
10272         },
10273
10274         disable: function( index ) {
10275                 var disabled = this.options.disabled;
10276                 if ( disabled === true ) {
10277                         return;
10278                 }
10279
10280                 if ( index === undefined ) {
10281                         disabled = true;
10282                 } else {
10283                         index = this._getIndex( index );
10284                         if ( $.inArray( index, disabled ) !== -1 ) {
10285                                 return;
10286                         }
10287                         if ( $.isArray( disabled ) ) {
10288                                 disabled = $.merge( [ index ], disabled ).sort();
10289                         } else {
10290                                 disabled = [ index ];
10291                         }
10292                 }
10293                 this._setupDisabled( disabled );
10294         },
10295
10296         load: function( index, event ) {
10297                 index = this._getIndex( index );
10298                 var that = this,
10299                         tab = this.tabs.eq( index ),
10300                         anchor = tab.find( ".ui-tabs-anchor" ),
10301                         panel = this._getPanelForTab( tab ),
10302                         eventData = {
10303                                 tab: tab,
10304                                 panel: panel
10305                         },
10306                         complete = function( jqXHR, status ) {
10307                                 if ( status === "abort" ) {
10308                                         that.panels.stop( false, true );
10309                                 }
10310
10311                                 tab.removeClass( "ui-tabs-loading" );
10312                                 panel.removeAttr( "aria-busy" );
10313
10314                                 if ( jqXHR === that.xhr ) {
10315                                         delete that.xhr;
10316                                 }
10317                         };
10318
10319                 // not remote
10320                 if ( this._isLocal( anchor[ 0 ] ) ) {
10321                         return;
10322                 }
10323
10324                 this.xhr = $.ajax( this._ajaxSettings( anchor, event, eventData ) );
10325
10326                 // support: jQuery <1.8
10327                 // jQuery <1.8 returns false if the request is canceled in beforeSend,
10328                 // but as of 1.8, $.ajax() always returns a jqXHR object.
10329                 if ( this.xhr && this.xhr.statusText !== "canceled" ) {
10330                         tab.addClass( "ui-tabs-loading" );
10331                         panel.attr( "aria-busy", "true" );
10332
10333                         this.xhr
10334                                 .done(function( response, status, jqXHR ) {
10335                                         // support: jQuery <1.8
10336                                         // http://bugs.jquery.com/ticket/11778
10337                                         setTimeout(function() {
10338                                                 panel.html( response );
10339                                                 that._trigger( "load", event, eventData );
10340
10341                                                 complete( jqXHR, status );
10342                                         }, 1 );
10343                                 })
10344                                 .fail(function( jqXHR, status ) {
10345                                         // support: jQuery <1.8
10346                                         // http://bugs.jquery.com/ticket/11778
10347                                         setTimeout(function() {
10348                                                 complete( jqXHR, status );
10349                                         }, 1 );
10350                                 });
10351                 }
10352         },
10353
10354         _ajaxSettings: function( anchor, event, eventData ) {
10355                 var that = this;
10356                 return {
10357                         url: anchor.attr( "href" ),
10358                         beforeSend: function( jqXHR, settings ) {
10359                                 return that._trigger( "beforeLoad", event,
10360                                         $.extend( { jqXHR: jqXHR, ajaxSettings: settings }, eventData ) );
10361                         }
10362                 };
10363         },
10364
10365         _getPanelForTab: function( tab ) {
10366                 var id = $( tab ).attr( "aria-controls" );
10367                 return this.element.find( this._sanitizeSelector( "#" + id ) );
10368         }
10369 });
10370
10371
10372 /*!
10373  * jQuery UI Effects 1.11.4
10374  * http://jqueryui.com
10375  *
10376  * Copyright jQuery Foundation and other contributors
10377  * Released under the MIT license.
10378  * http://jquery.org/license
10379  *
10380  * http://api.jqueryui.com/category/effects-core/
10381  */
10382
10383
10384 var dataSpace = "ui-effects-",
10385
10386         // Create a local jQuery because jQuery Color relies on it and the
10387         // global may not exist with AMD and a custom build (#10199)
10388         jQuery = $;
10389
10390 $.effects = {
10391         effect: {}
10392 };
10393
10394 /*!
10395  * jQuery Color Animations v2.1.2
10396  * https://github.com/jquery/jquery-color
10397  *
10398  * Copyright 2014 jQuery Foundation and other contributors
10399  * Released under the MIT license.
10400  * http://jquery.org/license
10401  *
10402  * Date: Wed Jan 16 08:47:09 2013 -0600
10403  */
10404 (function( jQuery, undefined ) {
10405
10406         var stepHooks = "backgroundColor borderBottomColor borderLeftColor borderRightColor borderTopColor color columnRuleColor outlineColor textDecorationColor textEmphasisColor",
10407
10408         // plusequals test for += 100 -= 100
10409         rplusequals = /^([\-+])=\s*(\d+\.?\d*)/,
10410         // a set of RE's that can match strings and generate color tuples.
10411         stringParsers = [ {
10412                         re: /rgba?\(\s*(\d{1,3})\s*,\s*(\d{1,3})\s*,\s*(\d{1,3})\s*(?:,\s*(\d?(?:\.\d+)?)\s*)?\)/,
10413                         parse: function( execResult ) {
10414                                 return [
10415                                         execResult[ 1 ],
10416                                         execResult[ 2 ],
10417                                         execResult[ 3 ],
10418                                         execResult[ 4 ]
10419                                 ];
10420                         }
10421                 }, {
10422                         re: /rgba?\(\s*(\d+(?:\.\d+)?)\%\s*,\s*(\d+(?:\.\d+)?)\%\s*,\s*(\d+(?:\.\d+)?)\%\s*(?:,\s*(\d?(?:\.\d+)?)\s*)?\)/,
10423                         parse: function( execResult ) {
10424                                 return [
10425                                         execResult[ 1 ] * 2.55,
10426                                         execResult[ 2 ] * 2.55,
10427                                         execResult[ 3 ] * 2.55,
10428                                         execResult[ 4 ]
10429                                 ];
10430                         }
10431                 }, {
10432                         // this regex ignores A-F because it's compared against an already lowercased string
10433                         re: /#([a-f0-9]{2})([a-f0-9]{2})([a-f0-9]{2})/,
10434                         parse: function( execResult ) {
10435                                 return [
10436                                         parseInt( execResult[ 1 ], 16 ),
10437                                         parseInt( execResult[ 2 ], 16 ),
10438                                         parseInt( execResult[ 3 ], 16 )
10439                                 ];
10440                         }
10441                 }, {
10442                         // this regex ignores A-F because it's compared against an already lowercased string
10443                         re: /#([a-f0-9])([a-f0-9])([a-f0-9])/,
10444                         parse: function( execResult ) {
10445                                 return [
10446                                         parseInt( execResult[ 1 ] + execResult[ 1 ], 16 ),
10447                                         parseInt( execResult[ 2 ] + execResult[ 2 ], 16 ),
10448                                         parseInt( execResult[ 3 ] + execResult[ 3 ], 16 )
10449                                 ];
10450                         }
10451                 }, {
10452                         re: /hsla?\(\s*(\d+(?:\.\d+)?)\s*,\s*(\d+(?:\.\d+)?)\%\s*,\s*(\d+(?:\.\d+)?)\%\s*(?:,\s*(\d?(?:\.\d+)?)\s*)?\)/,
10453                         space: "hsla",
10454                         parse: function( execResult ) {
10455                                 return [
10456                                         execResult[ 1 ],
10457                                         execResult[ 2 ] / 100,
10458                                         execResult[ 3 ] / 100,
10459                                         execResult[ 4 ]
10460                                 ];
10461                         }
10462                 } ],
10463
10464         // jQuery.Color( )
10465         color = jQuery.Color = function( color, green, blue, alpha ) {
10466                 return new jQuery.Color.fn.parse( color, green, blue, alpha );
10467         },
10468         spaces = {
10469                 rgba: {
10470                         props: {
10471                                 red: {
10472                                         idx: 0,
10473                                         type: "byte"
10474                                 },
10475                                 green: {
10476                                         idx: 1,
10477                                         type: "byte"
10478                                 },
10479                                 blue: {
10480                                         idx: 2,
10481                                         type: "byte"
10482                                 }
10483                         }
10484                 },
10485
10486                 hsla: {
10487                         props: {
10488                                 hue: {
10489                                         idx: 0,
10490                                         type: "degrees"
10491                                 },
10492                                 saturation: {
10493                                         idx: 1,
10494                                         type: "percent"
10495                                 },
10496                                 lightness: {
10497                                         idx: 2,
10498                                         type: "percent"
10499                                 }
10500                         }
10501                 }
10502         },
10503         propTypes = {
10504                 "byte": {
10505                         floor: true,
10506                         max: 255
10507                 },
10508                 "percent": {
10509                         max: 1
10510                 },
10511                 "degrees": {
10512                         mod: 360,
10513                         floor: true
10514                 }
10515         },
10516         support = color.support = {},
10517
10518         // element for support tests
10519         supportElem = jQuery( "<p>" )[ 0 ],
10520
10521         // colors = jQuery.Color.names
10522         colors,
10523
10524         // local aliases of functions called often
10525         each = jQuery.each;
10526
10527 // determine rgba support immediately
10528 supportElem.style.cssText = "background-color:rgba(1,1,1,.5)";
10529 support.rgba = supportElem.style.backgroundColor.indexOf( "rgba" ) > -1;
10530
10531 // define cache name and alpha properties
10532 // for rgba and hsla spaces
10533 each( spaces, function( spaceName, space ) {
10534         space.cache = "_" + spaceName;
10535         space.props.alpha = {
10536                 idx: 3,
10537                 type: "percent",
10538                 def: 1
10539         };
10540 });
10541
10542 function clamp( value, prop, allowEmpty ) {
10543         var type = propTypes[ prop.type ] || {};
10544
10545         if ( value == null ) {
10546                 return (allowEmpty || !prop.def) ? null : prop.def;
10547         }
10548
10549         // ~~ is an short way of doing floor for positive numbers
10550         value = type.floor ? ~~value : parseFloat( value );
10551
10552         // IE will pass in empty strings as value for alpha,
10553         // which will hit this case
10554         if ( isNaN( value ) ) {
10555                 return prop.def;
10556         }
10557
10558         if ( type.mod ) {
10559                 // we add mod before modding to make sure that negatives values
10560                 // get converted properly: -10 -> 350
10561                 return (value + type.mod) % type.mod;
10562         }
10563
10564         // for now all property types without mod have min and max
10565         return 0 > value ? 0 : type.max < value ? type.max : value;
10566 }
10567
10568 function stringParse( string ) {
10569         var inst = color(),
10570                 rgba = inst._rgba = [];
10571
10572         string = string.toLowerCase();
10573
10574         each( stringParsers, function( i, parser ) {
10575                 var parsed,
10576                         match = parser.re.exec( string ),
10577                         values = match && parser.parse( match ),
10578                         spaceName = parser.space || "rgba";
10579
10580                 if ( values ) {
10581                         parsed = inst[ spaceName ]( values );
10582
10583                         // if this was an rgba parse the assignment might happen twice
10584                         // oh well....
10585                         inst[ spaces[ spaceName ].cache ] = parsed[ spaces[ spaceName ].cache ];
10586                         rgba = inst._rgba = parsed._rgba;
10587
10588                         // exit each( stringParsers ) here because we matched
10589                         return false;
10590                 }
10591         });
10592
10593         // Found a stringParser that handled it
10594         if ( rgba.length ) {
10595
10596                 // if this came from a parsed string, force "transparent" when alpha is 0
10597                 // chrome, (and maybe others) return "transparent" as rgba(0,0,0,0)
10598                 if ( rgba.join() === "0,0,0,0" ) {
10599                         jQuery.extend( rgba, colors.transparent );
10600                 }
10601                 return inst;
10602         }
10603
10604         // named colors
10605         return colors[ string ];
10606 }
10607
10608 color.fn = jQuery.extend( color.prototype, {
10609         parse: function( red, green, blue, alpha ) {
10610                 if ( red === undefined ) {
10611                         this._rgba = [ null, null, null, null ];
10612                         return this;
10613                 }
10614                 if ( red.jquery || red.nodeType ) {
10615                         red = jQuery( red ).css( green );
10616                         green = undefined;
10617                 }
10618
10619                 var inst = this,
10620                         type = jQuery.type( red ),
10621                         rgba = this._rgba = [];
10622
10623                 // more than 1 argument specified - assume ( red, green, blue, alpha )
10624                 if ( green !== undefined ) {
10625                         red = [ red, green, blue, alpha ];
10626                         type = "array";
10627                 }
10628
10629                 if ( type === "string" ) {
10630                         return this.parse( stringParse( red ) || colors._default );
10631                 }
10632
10633                 if ( type === "array" ) {
10634                         each( spaces.rgba.props, function( key, prop ) {
10635                                 rgba[ prop.idx ] = clamp( red[ prop.idx ], prop );
10636                         });
10637                         return this;
10638                 }
10639
10640                 if ( type === "object" ) {
10641                         if ( red instanceof color ) {
10642                                 each( spaces, function( spaceName, space ) {
10643                                         if ( red[ space.cache ] ) {
10644                                                 inst[ space.cache ] = red[ space.cache ].slice();
10645                                         }
10646                                 });
10647                         } else {
10648                                 each( spaces, function( spaceName, space ) {
10649                                         var cache = space.cache;
10650                                         each( space.props, function( key, prop ) {
10651
10652                                                 // if the cache doesn't exist, and we know how to convert
10653                                                 if ( !inst[ cache ] && space.to ) {
10654
10655                                                         // if the value was null, we don't need to copy it
10656                                                         // if the key was alpha, we don't need to copy it either
10657                                                         if ( key === "alpha" || red[ key ] == null ) {
10658                                                                 return;
10659                                                         }
10660                                                         inst[ cache ] = space.to( inst._rgba );
10661                                                 }
10662
10663                                                 // this is the only case where we allow nulls for ALL properties.
10664                                                 // call clamp with alwaysAllowEmpty
10665                                                 inst[ cache ][ prop.idx ] = clamp( red[ key ], prop, true );
10666                                         });
10667
10668                                         // everything defined but alpha?
10669                                         if ( inst[ cache ] && jQuery.inArray( null, inst[ cache ].slice( 0, 3 ) ) < 0 ) {
10670                                                 // use the default of 1
10671                                                 inst[ cache ][ 3 ] = 1;
10672                                                 if ( space.from ) {
10673                                                         inst._rgba = space.from( inst[ cache ] );
10674                                                 }
10675                                         }
10676                                 });
10677                         }
10678                         return this;
10679                 }
10680         },
10681         is: function( compare ) {
10682                 var is = color( compare ),
10683                         same = true,
10684                         inst = this;
10685
10686                 each( spaces, function( _, space ) {
10687                         var localCache,
10688                                 isCache = is[ space.cache ];
10689                         if (isCache) {
10690                                 localCache = inst[ space.cache ] || space.to && space.to( inst._rgba ) || [];
10691                                 each( space.props, function( _, prop ) {
10692                                         if ( isCache[ prop.idx ] != null ) {
10693                                                 same = ( isCache[ prop.idx ] === localCache[ prop.idx ] );
10694                                                 return same;
10695                                         }
10696                                 });
10697                         }
10698                         return same;
10699                 });
10700                 return same;
10701         },
10702         _space: function() {
10703                 var used = [],
10704                         inst = this;
10705                 each( spaces, function( spaceName, space ) {
10706                         if ( inst[ space.cache ] ) {
10707                                 used.push( spaceName );
10708                         }
10709                 });
10710                 return used.pop();
10711         },
10712         transition: function( other, distance ) {
10713                 var end = color( other ),
10714                         spaceName = end._space(),
10715                         space = spaces[ spaceName ],
10716                         startColor = this.alpha() === 0 ? color( "transparent" ) : this,
10717                         start = startColor[ space.cache ] || space.to( startColor._rgba ),
10718                         result = start.slice();
10719
10720                 end = end[ space.cache ];
10721                 each( space.props, function( key, prop ) {
10722                         var index = prop.idx,
10723                                 startValue = start[ index ],
10724                                 endValue = end[ index ],
10725                                 type = propTypes[ prop.type ] || {};
10726
10727                         // if null, don't override start value
10728                         if ( endValue === null ) {
10729                                 return;
10730                         }
10731                         // if null - use end
10732                         if ( startValue === null ) {
10733                                 result[ index ] = endValue;
10734                         } else {
10735                                 if ( type.mod ) {
10736                                         if ( endValue - startValue > type.mod / 2 ) {
10737                                                 startValue += type.mod;
10738                                         } else if ( startValue - endValue > type.mod / 2 ) {
10739                                                 startValue -= type.mod;
10740                                         }
10741                                 }
10742                                 result[ index ] = clamp( ( endValue - startValue ) * distance + startValue, prop );
10743                         }
10744                 });
10745                 return this[ spaceName ]( result );
10746         },
10747         blend: function( opaque ) {
10748                 // if we are already opaque - return ourself
10749                 if ( this._rgba[ 3 ] === 1 ) {
10750                         return this;
10751                 }
10752
10753                 var rgb = this._rgba.slice(),
10754                         a = rgb.pop(),
10755                         blend = color( opaque )._rgba;
10756
10757                 return color( jQuery.map( rgb, function( v, i ) {
10758                         return ( 1 - a ) * blend[ i ] + a * v;
10759                 }));
10760         },
10761         toRgbaString: function() {
10762                 var prefix = "rgba(",
10763                         rgba = jQuery.map( this._rgba, function( v, i ) {
10764                                 return v == null ? ( i > 2 ? 1 : 0 ) : v;
10765                         });
10766
10767                 if ( rgba[ 3 ] === 1 ) {
10768                         rgba.pop();
10769                         prefix = "rgb(";
10770                 }
10771
10772                 return prefix + rgba.join() + ")";
10773         },
10774         toHslaString: function() {
10775                 var prefix = "hsla(",
10776                         hsla = jQuery.map( this.hsla(), function( v, i ) {
10777                                 if ( v == null ) {
10778                                         v = i > 2 ? 1 : 0;
10779                                 }
10780
10781                                 // catch 1 and 2
10782                                 if ( i && i < 3 ) {
10783                                         v = Math.round( v * 100 ) + "%";
10784                                 }
10785                                 return v;
10786                         });
10787
10788                 if ( hsla[ 3 ] === 1 ) {
10789                         hsla.pop();
10790                         prefix = "hsl(";
10791                 }
10792                 return prefix + hsla.join() + ")";
10793         },
10794         toHexString: function( includeAlpha ) {
10795                 var rgba = this._rgba.slice(),
10796                         alpha = rgba.pop();
10797
10798                 if ( includeAlpha ) {
10799                         rgba.push( ~~( alpha * 255 ) );
10800                 }
10801
10802                 return "#" + jQuery.map( rgba, function( v ) {
10803
10804                         // default to 0 when nulls exist
10805                         v = ( v || 0 ).toString( 16 );
10806                         return v.length === 1 ? "0" + v : v;
10807                 }).join("");
10808         },
10809         toString: function() {
10810                 return this._rgba[ 3 ] === 0 ? "transparent" : this.toRgbaString();
10811         }
10812 });
10813 color.fn.parse.prototype = color.fn;
10814
10815 // hsla conversions adapted from:
10816 // https://code.google.com/p/maashaack/source/browse/packages/graphics/trunk/src/graphics/colors/HUE2RGB.as?r=5021
10817
10818 function hue2rgb( p, q, h ) {
10819         h = ( h + 1 ) % 1;
10820         if ( h * 6 < 1 ) {
10821                 return p + ( q - p ) * h * 6;
10822         }
10823         if ( h * 2 < 1) {
10824                 return q;
10825         }
10826         if ( h * 3 < 2 ) {
10827                 return p + ( q - p ) * ( ( 2 / 3 ) - h ) * 6;
10828         }
10829         return p;
10830 }
10831
10832 spaces.hsla.to = function( rgba ) {
10833         if ( rgba[ 0 ] == null || rgba[ 1 ] == null || rgba[ 2 ] == null ) {
10834                 return [ null, null, null, rgba[ 3 ] ];
10835         }
10836         var r = rgba[ 0 ] / 255,
10837                 g = rgba[ 1 ] / 255,
10838                 b = rgba[ 2 ] / 255,
10839                 a = rgba[ 3 ],
10840                 max = Math.max( r, g, b ),
10841                 min = Math.min( r, g, b ),
10842                 diff = max - min,
10843                 add = max + min,
10844                 l = add * 0.5,
10845                 h, s;
10846
10847         if ( min === max ) {
10848                 h = 0;
10849         } else if ( r === max ) {
10850                 h = ( 60 * ( g - b ) / diff ) + 360;
10851         } else if ( g === max ) {
10852                 h = ( 60 * ( b - r ) / diff ) + 120;
10853         } else {
10854                 h = ( 60 * ( r - g ) / diff ) + 240;
10855         }
10856
10857         // chroma (diff) == 0 means greyscale which, by definition, saturation = 0%
10858         // otherwise, saturation is based on the ratio of chroma (diff) to lightness (add)
10859         if ( diff === 0 ) {
10860                 s = 0;
10861         } else if ( l <= 0.5 ) {
10862                 s = diff / add;
10863         } else {
10864                 s = diff / ( 2 - add );
10865         }
10866         return [ Math.round(h) % 360, s, l, a == null ? 1 : a ];
10867 };
10868
10869 spaces.hsla.from = function( hsla ) {
10870         if ( hsla[ 0 ] == null || hsla[ 1 ] == null || hsla[ 2 ] == null ) {
10871                 return [ null, null, null, hsla[ 3 ] ];
10872         }
10873         var h = hsla[ 0 ] / 360,
10874                 s = hsla[ 1 ],
10875                 l = hsla[ 2 ],
10876                 a = hsla[ 3 ],
10877                 q = l <= 0.5 ? l * ( 1 + s ) : l + s - l * s,
10878                 p = 2 * l - q;
10879
10880         return [
10881                 Math.round( hue2rgb( p, q, h + ( 1 / 3 ) ) * 255 ),
10882                 Math.round( hue2rgb( p, q, h ) * 255 ),
10883                 Math.round( hue2rgb( p, q, h - ( 1 / 3 ) ) * 255 ),
10884                 a
10885         ];
10886 };
10887
10888 each( spaces, function( spaceName, space ) {
10889         var props = space.props,
10890                 cache = space.cache,
10891                 to = space.to,
10892                 from = space.from;
10893
10894         // makes rgba() and hsla()
10895         color.fn[ spaceName ] = function( value ) {
10896
10897                 // generate a cache for this space if it doesn't exist
10898                 if ( to && !this[ cache ] ) {
10899                         this[ cache ] = to( this._rgba );
10900                 }
10901                 if ( value === undefined ) {
10902                         return this[ cache ].slice();
10903                 }
10904
10905                 var ret,
10906                         type = jQuery.type( value ),
10907                         arr = ( type === "array" || type === "object" ) ? value : arguments,
10908                         local = this[ cache ].slice();
10909
10910                 each( props, function( key, prop ) {
10911                         var val = arr[ type === "object" ? key : prop.idx ];
10912                         if ( val == null ) {
10913                                 val = local[ prop.idx ];
10914                         }
10915                         local[ prop.idx ] = clamp( val, prop );
10916                 });
10917
10918                 if ( from ) {
10919                         ret = color( from( local ) );
10920                         ret[ cache ] = local;
10921                         return ret;
10922                 } else {
10923                         return color( local );
10924                 }
10925         };
10926
10927         // makes red() green() blue() alpha() hue() saturation() lightness()
10928         each( props, function( key, prop ) {
10929                 // alpha is included in more than one space
10930                 if ( color.fn[ key ] ) {
10931                         return;
10932                 }
10933                 color.fn[ key ] = function( value ) {
10934                         var vtype = jQuery.type( value ),
10935                                 fn = ( key === "alpha" ? ( this._hsla ? "hsla" : "rgba" ) : spaceName ),
10936                                 local = this[ fn ](),
10937                                 cur = local[ prop.idx ],
10938                                 match;
10939
10940                         if ( vtype === "undefined" ) {
10941                                 return cur;
10942                         }
10943
10944                         if ( vtype === "function" ) {
10945                                 value = value.call( this, cur );
10946                                 vtype = jQuery.type( value );
10947                         }
10948                         if ( value == null && prop.empty ) {
10949                                 return this;
10950                         }
10951                         if ( vtype === "string" ) {
10952                                 match = rplusequals.exec( value );
10953                                 if ( match ) {
10954                                         value = cur + parseFloat( match[ 2 ] ) * ( match[ 1 ] === "+" ? 1 : -1 );
10955                                 }
10956                         }
10957                         local[ prop.idx ] = value;
10958                         return this[ fn ]( local );
10959                 };
10960         });
10961 });
10962
10963 // add cssHook and .fx.step function for each named hook.
10964 // accept a space separated string of properties
10965 color.hook = function( hook ) {
10966         var hooks = hook.split( " " );
10967         each( hooks, function( i, hook ) {
10968                 jQuery.cssHooks[ hook ] = {
10969                         set: function( elem, value ) {
10970                                 var parsed, curElem,
10971                                         backgroundColor = "";
10972
10973                                 if ( value !== "transparent" && ( jQuery.type( value ) !== "string" || ( parsed = stringParse( value ) ) ) ) {
10974                                         value = color( parsed || value );
10975                                         if ( !support.rgba && value._rgba[ 3 ] !== 1 ) {
10976                                                 curElem = hook === "backgroundColor" ? elem.parentNode : elem;
10977                                                 while (
10978                                                         (backgroundColor === "" || backgroundColor === "transparent") &&
10979                                                         curElem && curElem.style
10980                                                 ) {
10981                                                         try {
10982                                                                 backgroundColor = jQuery.css( curElem, "backgroundColor" );
10983                                                                 curElem = curElem.parentNode;
10984                                                         } catch ( e ) {
10985                                                         }
10986                                                 }
10987
10988                                                 value = value.blend( backgroundColor && backgroundColor !== "transparent" ?
10989                                                         backgroundColor :
10990                                                         "_default" );
10991                                         }
10992
10993                                         value = value.toRgbaString();
10994                                 }
10995                                 try {
10996                                         elem.style[ hook ] = value;
10997                                 } catch ( e ) {
10998                                         // wrapped to prevent IE from throwing errors on "invalid" values like 'auto' or 'inherit'
10999                                 }
11000                         }
11001                 };
11002                 jQuery.fx.step[ hook ] = function( fx ) {
11003                         if ( !fx.colorInit ) {
11004                                 fx.start = color( fx.elem, hook );
11005                                 fx.end = color( fx.end );
11006                                 fx.colorInit = true;
11007                         }
11008                         jQuery.cssHooks[ hook ].set( fx.elem, fx.start.transition( fx.end, fx.pos ) );
11009                 };
11010         });
11011
11012 };
11013
11014 color.hook( stepHooks );
11015
11016 jQuery.cssHooks.borderColor = {
11017         expand: function( value ) {
11018                 var expanded = {};
11019
11020                 each( [ "Top", "Right", "Bottom", "Left" ], function( i, part ) {
11021                         expanded[ "border" + part + "Color" ] = value;
11022                 });
11023                 return expanded;
11024         }
11025 };
11026
11027 // Basic color names only.
11028 // Usage of any of the other color names requires adding yourself or including
11029 // jquery.color.svg-names.js.
11030 colors = jQuery.Color.names = {
11031         // 4.1. Basic color keywords
11032         aqua: "#00ffff",
11033         black: "#000000",
11034         blue: "#0000ff",
11035         fuchsia: "#ff00ff",
11036         gray: "#808080",
11037         green: "#008000",
11038         lime: "#00ff00",
11039         maroon: "#800000",
11040         navy: "#000080",
11041         olive: "#808000",
11042         purple: "#800080",
11043         red: "#ff0000",
11044         silver: "#c0c0c0",
11045         teal: "#008080",
11046         white: "#ffffff",
11047         yellow: "#ffff00",
11048
11049         // 4.2.3. "transparent" color keyword
11050         transparent: [ null, null, null, 0 ],
11051
11052         _default: "#ffffff"
11053 };
11054
11055 })( jQuery );
11056
11057 /******************************************************************************/
11058 /****************************** CLASS ANIMATIONS ******************************/
11059 /******************************************************************************/
11060 (function() {
11061
11062 var classAnimationActions = [ "add", "remove", "toggle" ],
11063         shorthandStyles = {
11064                 border: 1,
11065                 borderBottom: 1,
11066                 borderColor: 1,
11067                 borderLeft: 1,
11068                 borderRight: 1,
11069                 borderTop: 1,
11070                 borderWidth: 1,
11071                 margin: 1,
11072                 padding: 1
11073         };
11074
11075 $.each([ "borderLeftStyle", "borderRightStyle", "borderBottomStyle", "borderTopStyle" ], function( _, prop ) {
11076         $.fx.step[ prop ] = function( fx ) {
11077                 if ( fx.end !== "none" && !fx.setAttr || fx.pos === 1 && !fx.setAttr ) {
11078                         jQuery.style( fx.elem, prop, fx.end );
11079                         fx.setAttr = true;
11080                 }
11081         };
11082 });
11083
11084 function getElementStyles( elem ) {
11085         var key, len,
11086                 style = elem.ownerDocument.defaultView ?
11087                         elem.ownerDocument.defaultView.getComputedStyle( elem, null ) :
11088                         elem.currentStyle,
11089                 styles = {};
11090
11091         if ( style && style.length && style[ 0 ] && style[ style[ 0 ] ] ) {
11092                 len = style.length;
11093                 while ( len-- ) {
11094                         key = style[ len ];
11095                         if ( typeof style[ key ] === "string" ) {
11096                                 styles[ $.camelCase( key ) ] = style[ key ];
11097                         }
11098                 }
11099         // support: Opera, IE <9
11100         } else {
11101                 for ( key in style ) {
11102                         if ( typeof style[ key ] === "string" ) {
11103                                 styles[ key ] = style[ key ];
11104                         }
11105                 }
11106         }
11107
11108         return styles;
11109 }
11110
11111 function styleDifference( oldStyle, newStyle ) {
11112         var diff = {},
11113                 name, value;
11114
11115         for ( name in newStyle ) {
11116                 value = newStyle[ name ];
11117                 if ( oldStyle[ name ] !== value ) {
11118                         if ( !shorthandStyles[ name ] ) {
11119                                 if ( $.fx.step[ name ] || !isNaN( parseFloat( value ) ) ) {
11120                                         diff[ name ] = value;
11121                                 }
11122                         }
11123                 }
11124         }
11125
11126         return diff;
11127 }
11128
11129 // support: jQuery <1.8
11130 if ( !$.fn.addBack ) {
11131         $.fn.addBack = function( selector ) {
11132                 return this.add( selector == null ?
11133                         this.prevObject : this.prevObject.filter( selector )
11134                 );
11135         };
11136 }
11137
11138 $.effects.animateClass = function( value, duration, easing, callback ) {
11139         var o = $.speed( duration, easing, callback );
11140
11141         return this.queue( function() {
11142                 var animated = $( this ),
11143                         baseClass = animated.attr( "class" ) || "",
11144                         applyClassChange,
11145                         allAnimations = o.children ? animated.find( "*" ).addBack() : animated;
11146
11147                 // map the animated objects to store the original styles.
11148                 allAnimations = allAnimations.map(function() {
11149                         var el = $( this );
11150                         return {
11151                                 el: el,
11152                                 start: getElementStyles( this )
11153                         };
11154                 });
11155
11156                 // apply class change
11157                 applyClassChange = function() {
11158                         $.each( classAnimationActions, function(i, action) {
11159                                 if ( value[ action ] ) {
11160                                         animated[ action + "Class" ]( value[ action ] );
11161                                 }
11162                         });
11163                 };
11164                 applyClassChange();
11165
11166                 // map all animated objects again - calculate new styles and diff
11167                 allAnimations = allAnimations.map(function() {
11168                         this.end = getElementStyles( this.el[ 0 ] );
11169                         this.diff = styleDifference( this.start, this.end );
11170                         return this;
11171                 });
11172
11173                 // apply original class
11174                 animated.attr( "class", baseClass );
11175
11176                 // map all animated objects again - this time collecting a promise
11177                 allAnimations = allAnimations.map(function() {
11178                         var styleInfo = this,
11179                                 dfd = $.Deferred(),
11180                                 opts = $.extend({}, o, {
11181                                         queue: false,
11182                                         complete: function() {
11183                                                 dfd.resolve( styleInfo );
11184                                         }
11185                                 });
11186
11187                         this.el.animate( this.diff, opts );
11188                         return dfd.promise();
11189                 });
11190
11191                 // once all animations have completed:
11192                 $.when.apply( $, allAnimations.get() ).done(function() {
11193
11194                         // set the final class
11195                         applyClassChange();
11196
11197                         // for each animated element,
11198                         // clear all css properties that were animated
11199                         $.each( arguments, function() {
11200                                 var el = this.el;
11201                                 $.each( this.diff, function(key) {
11202                                         el.css( key, "" );
11203                                 });
11204                         });
11205
11206                         // this is guarnteed to be there if you use jQuery.speed()
11207                         // it also handles dequeuing the next anim...
11208                         o.complete.call( animated[ 0 ] );
11209                 });
11210         });
11211 };
11212
11213 $.fn.extend({
11214         addClass: (function( orig ) {
11215                 return function( classNames, speed, easing, callback ) {
11216                         return speed ?
11217                                 $.effects.animateClass.call( this,
11218                                         { add: classNames }, speed, easing, callback ) :
11219                                 orig.apply( this, arguments );
11220                 };
11221         })( $.fn.addClass ),
11222
11223         removeClass: (function( orig ) {
11224                 return function( classNames, speed, easing, callback ) {
11225                         return arguments.length > 1 ?
11226                                 $.effects.animateClass.call( this,
11227                                         { remove: classNames }, speed, easing, callback ) :
11228                                 orig.apply( this, arguments );
11229                 };
11230         })( $.fn.removeClass ),
11231
11232         toggleClass: (function( orig ) {
11233                 return function( classNames, force, speed, easing, callback ) {
11234                         if ( typeof force === "boolean" || force === undefined ) {
11235                                 if ( !speed ) {
11236                                         // without speed parameter
11237                                         return orig.apply( this, arguments );
11238                                 } else {
11239                                         return $.effects.animateClass.call( this,
11240                                                 (force ? { add: classNames } : { remove: classNames }),
11241                                                 speed, easing, callback );
11242                                 }
11243                         } else {
11244                                 // without force parameter
11245                                 return $.effects.animateClass.call( this,
11246                                         { toggle: classNames }, force, speed, easing );
11247                         }
11248                 };
11249         })( $.fn.toggleClass ),
11250
11251         switchClass: function( remove, add, speed, easing, callback) {
11252                 return $.effects.animateClass.call( this, {
11253                         add: add,
11254                         remove: remove
11255                 }, speed, easing, callback );
11256         }
11257 });
11258
11259 })();
11260
11261 /******************************************************************************/
11262 /*********************************** EFFECTS **********************************/
11263 /******************************************************************************/
11264
11265 (function() {
11266
11267 $.extend( $.effects, {
11268         version: "1.11.4",
11269
11270         // Saves a set of properties in a data storage
11271         save: function( element, set ) {
11272                 for ( var i = 0; i < set.length; i++ ) {
11273                         if ( set[ i ] !== null ) {
11274                                 element.data( dataSpace + set[ i ], element[ 0 ].style[ set[ i ] ] );
11275                         }
11276                 }
11277         },
11278
11279         // Restores a set of previously saved properties from a data storage
11280         restore: function( element, set ) {
11281                 var val, i;
11282                 for ( i = 0; i < set.length; i++ ) {
11283                         if ( set[ i ] !== null ) {
11284                                 val = element.data( dataSpace + set[ i ] );
11285                                 // support: jQuery 1.6.2
11286                                 // http://bugs.jquery.com/ticket/9917
11287                                 // jQuery 1.6.2 incorrectly returns undefined for any falsy value.
11288                                 // We can't differentiate between "" and 0 here, so we just assume
11289                                 // empty string since it's likely to be a more common value...
11290                                 if ( val === undefined ) {
11291                                         val = "";
11292                                 }
11293                                 element.css( set[ i ], val );
11294                         }
11295                 }
11296         },
11297
11298         setMode: function( el, mode ) {
11299                 if (mode === "toggle") {
11300                         mode = el.is( ":hidden" ) ? "show" : "hide";
11301                 }
11302                 return mode;
11303         },
11304
11305         // Translates a [top,left] array into a baseline value
11306         // this should be a little more flexible in the future to handle a string & hash
11307         getBaseline: function( origin, original ) {
11308                 var y, x;
11309                 switch ( origin[ 0 ] ) {
11310                         case "top": y = 0; break;
11311                         case "middle": y = 0.5; break;
11312                         case "bottom": y = 1; break;
11313                         default: y = origin[ 0 ] / original.height;
11314                 }
11315                 switch ( origin[ 1 ] ) {
11316                         case "left": x = 0; break;
11317                         case "center": x = 0.5; break;
11318                         case "right": x = 1; break;
11319                         default: x = origin[ 1 ] / original.width;
11320                 }
11321                 return {
11322                         x: x,
11323                         y: y
11324                 };
11325         },
11326
11327         // Wraps the element around a wrapper that copies position properties
11328         createWrapper: function( element ) {
11329
11330                 // if the element is already wrapped, return it
11331                 if ( element.parent().is( ".ui-effects-wrapper" )) {
11332                         return element.parent();
11333                 }
11334
11335                 // wrap the element
11336                 var props = {
11337                                 width: element.outerWidth(true),
11338                                 height: element.outerHeight(true),
11339                                 "float": element.css( "float" )
11340                         },
11341                         wrapper = $( "<div></div>" )
11342                                 .addClass( "ui-effects-wrapper" )
11343                                 .css({
11344                                         fontSize: "100%",
11345                                         background: "transparent",
11346                                         border: "none",
11347                                         margin: 0,
11348                                         padding: 0
11349                                 }),
11350                         // Store the size in case width/height are defined in % - Fixes #5245
11351                         size = {
11352                                 width: element.width(),
11353                                 height: element.height()
11354                         },
11355                         active = document.activeElement;
11356
11357                 // support: Firefox
11358                 // Firefox incorrectly exposes anonymous content
11359                 // https://bugzilla.mozilla.org/show_bug.cgi?id=561664
11360                 try {
11361                         active.id;
11362                 } catch ( e ) {
11363                         active = document.body;
11364                 }
11365
11366                 element.wrap( wrapper );
11367
11368                 // Fixes #7595 - Elements lose focus when wrapped.
11369                 if ( element[ 0 ] === active || $.contains( element[ 0 ], active ) ) {
11370                         $( active ).focus();
11371                 }
11372
11373                 wrapper = element.parent(); //Hotfix for jQuery 1.4 since some change in wrap() seems to actually lose the reference to the wrapped element
11374
11375                 // transfer positioning properties to the wrapper
11376                 if ( element.css( "position" ) === "static" ) {
11377                         wrapper.css({ position: "relative" });
11378                         element.css({ position: "relative" });
11379                 } else {
11380                         $.extend( props, {
11381                                 position: element.css( "position" ),
11382                                 zIndex: element.css( "z-index" )
11383                         });
11384                         $.each([ "top", "left", "bottom", "right" ], function(i, pos) {
11385                                 props[ pos ] = element.css( pos );
11386                                 if ( isNaN( parseInt( props[ pos ], 10 ) ) ) {
11387                                         props[ pos ] = "auto";
11388                                 }
11389                         });
11390                         element.css({
11391                                 position: "relative",
11392                                 top: 0,
11393                                 left: 0,
11394                                 right: "auto",
11395                                 bottom: "auto"
11396                         });
11397                 }
11398                 element.css(size);
11399
11400                 return wrapper.css( props ).show();
11401         },
11402
11403         removeWrapper: function( element ) {
11404                 var active = document.activeElement;
11405
11406                 if ( element.parent().is( ".ui-effects-wrapper" ) ) {
11407                         element.parent().replaceWith( element );
11408
11409                         // Fixes #7595 - Elements lose focus when wrapped.
11410                         if ( element[ 0 ] === active || $.contains( element[ 0 ], active ) ) {
11411                                 $( active ).focus();
11412                         }
11413                 }
11414
11415                 return element;
11416         },
11417
11418         setTransition: function( element, list, factor, value ) {
11419                 value = value || {};
11420                 $.each( list, function( i, x ) {
11421                         var unit = element.cssUnit( x );
11422                         if ( unit[ 0 ] > 0 ) {
11423                                 value[ x ] = unit[ 0 ] * factor + unit[ 1 ];
11424                         }
11425                 });
11426                 return value;
11427         }
11428 });
11429
11430 // return an effect options object for the given parameters:
11431 function _normalizeArguments( effect, options, speed, callback ) {
11432
11433         // allow passing all options as the first parameter
11434         if ( $.isPlainObject( effect ) ) {
11435                 options = effect;
11436                 effect = effect.effect;
11437         }
11438
11439         // convert to an object
11440         effect = { effect: effect };
11441
11442         // catch (effect, null, ...)
11443         if ( options == null ) {
11444                 options = {};
11445         }
11446
11447         // catch (effect, callback)
11448         if ( $.isFunction( options ) ) {
11449                 callback = options;
11450                 speed = null;
11451                 options = {};
11452         }
11453
11454         // catch (effect, speed, ?)
11455         if ( typeof options === "number" || $.fx.speeds[ options ] ) {
11456                 callback = speed;
11457                 speed = options;
11458                 options = {};
11459         }
11460
11461         // catch (effect, options, callback)
11462         if ( $.isFunction( speed ) ) {
11463                 callback = speed;
11464                 speed = null;
11465         }
11466
11467         // add options to effect
11468         if ( options ) {
11469                 $.extend( effect, options );
11470         }
11471
11472         speed = speed || options.duration;
11473         effect.duration = $.fx.off ? 0 :
11474                 typeof speed === "number" ? speed :
11475                 speed in $.fx.speeds ? $.fx.speeds[ speed ] :
11476                 $.fx.speeds._default;
11477
11478         effect.complete = callback || options.complete;
11479
11480         return effect;
11481 }
11482
11483 function standardAnimationOption( option ) {
11484         // Valid standard speeds (nothing, number, named speed)
11485         if ( !option || typeof option === "number" || $.fx.speeds[ option ] ) {
11486                 return true;
11487         }
11488
11489         // Invalid strings - treat as "normal" speed
11490         if ( typeof option === "string" && !$.effects.effect[ option ] ) {
11491                 return true;
11492         }
11493
11494         // Complete callback
11495         if ( $.isFunction( option ) ) {
11496                 return true;
11497         }
11498
11499         // Options hash (but not naming an effect)
11500         if ( typeof option === "object" && !option.effect ) {
11501                 return true;
11502         }
11503
11504         // Didn't match any standard API
11505         return false;
11506 }
11507
11508 $.fn.extend({
11509         effect: function( /* effect, options, speed, callback */ ) {
11510                 var args = _normalizeArguments.apply( this, arguments ),
11511                         mode = args.mode,
11512                         queue = args.queue,
11513                         effectMethod = $.effects.effect[ args.effect ];
11514
11515                 if ( $.fx.off || !effectMethod ) {
11516                         // delegate to the original method (e.g., .show()) if possible
11517                         if ( mode ) {
11518                                 return this[ mode ]( args.duration, args.complete );
11519                         } else {
11520                                 return this.each( function() {
11521                                         if ( args.complete ) {
11522                                                 args.complete.call( this );
11523                                         }
11524                                 });
11525                         }
11526                 }
11527
11528                 function run( next ) {
11529                         var elem = $( this ),
11530                                 complete = args.complete,
11531                                 mode = args.mode;
11532
11533                         function done() {
11534                                 if ( $.isFunction( complete ) ) {
11535                                         complete.call( elem[0] );
11536                                 }
11537                                 if ( $.isFunction( next ) ) {
11538                                         next();
11539                                 }
11540                         }
11541
11542                         // If the element already has the correct final state, delegate to
11543                         // the core methods so the internal tracking of "olddisplay" works.
11544                         if ( elem.is( ":hidden" ) ? mode === "hide" : mode === "show" ) {
11545                                 elem[ mode ]();
11546                                 done();
11547                         } else {
11548                                 effectMethod.call( elem[0], args, done );
11549                         }
11550                 }
11551
11552                 return queue === false ? this.each( run ) : this.queue( queue || "fx", run );
11553         },
11554
11555         show: (function( orig ) {
11556                 return function( option ) {
11557                         if ( standardAnimationOption( option ) ) {
11558                                 return orig.apply( this, arguments );
11559                         } else {
11560                                 var args = _normalizeArguments.apply( this, arguments );
11561                                 args.mode = "show";
11562                                 return this.effect.call( this, args );
11563                         }
11564                 };
11565         })( $.fn.show ),
11566
11567         hide: (function( orig ) {
11568                 return function( option ) {
11569                         if ( standardAnimationOption( option ) ) {
11570                                 return orig.apply( this, arguments );
11571                         } else {
11572                                 var args = _normalizeArguments.apply( this, arguments );
11573                                 args.mode = "hide";
11574                                 return this.effect.call( this, args );
11575                         }
11576                 };
11577         })( $.fn.hide ),
11578
11579         toggle: (function( orig ) {
11580                 return function( option ) {
11581                         if ( standardAnimationOption( option ) || typeof option === "boolean" ) {
11582                                 return orig.apply( this, arguments );
11583                         } else {
11584                                 var args = _normalizeArguments.apply( this, arguments );
11585                                 args.mode = "toggle";
11586                                 return this.effect.call( this, args );
11587                         }
11588                 };
11589         })( $.fn.toggle ),
11590
11591         // helper functions
11592         cssUnit: function(key) {
11593                 var style = this.css( key ),
11594                         val = [];
11595
11596                 $.each( [ "em", "px", "%", "pt" ], function( i, unit ) {
11597                         if ( style.indexOf( unit ) > 0 ) {
11598                                 val = [ parseFloat( style ), unit ];
11599                         }
11600                 });
11601                 return val;
11602         }
11603 });
11604
11605 })();
11606
11607 /******************************************************************************/
11608 /*********************************** EASING ***********************************/
11609 /******************************************************************************/
11610
11611 (function() {
11612
11613 // based on easing equations from Robert Penner (http://www.robertpenner.com/easing)
11614
11615 var baseEasings = {};
11616
11617 $.each( [ "Quad", "Cubic", "Quart", "Quint", "Expo" ], function( i, name ) {
11618         baseEasings[ name ] = function( p ) {
11619                 return Math.pow( p, i + 2 );
11620         };
11621 });
11622
11623 $.extend( baseEasings, {
11624         Sine: function( p ) {
11625                 return 1 - Math.cos( p * Math.PI / 2 );
11626         },
11627         Circ: function( p ) {
11628                 return 1 - Math.sqrt( 1 - p * p );
11629         },
11630         Elastic: function( p ) {
11631                 return p === 0 || p === 1 ? p :
11632                         -Math.pow( 2, 8 * (p - 1) ) * Math.sin( ( (p - 1) * 80 - 7.5 ) * Math.PI / 15 );
11633         },
11634         Back: function( p ) {
11635                 return p * p * ( 3 * p - 2 );
11636         },
11637         Bounce: function( p ) {
11638                 var pow2,
11639                         bounce = 4;
11640
11641                 while ( p < ( ( pow2 = Math.pow( 2, --bounce ) ) - 1 ) / 11 ) {}
11642                 return 1 / Math.pow( 4, 3 - bounce ) - 7.5625 * Math.pow( ( pow2 * 3 - 2 ) / 22 - p, 2 );
11643         }
11644 });
11645
11646 $.each( baseEasings, function( name, easeIn ) {
11647         $.easing[ "easeIn" + name ] = easeIn;
11648         $.easing[ "easeOut" + name ] = function( p ) {
11649                 return 1 - easeIn( 1 - p );
11650         };
11651         $.easing[ "easeInOut" + name ] = function( p ) {
11652                 return p < 0.5 ?
11653                         easeIn( p * 2 ) / 2 :
11654                         1 - easeIn( p * -2 + 2 ) / 2;
11655         };
11656 });
11657
11658 })();
11659
11660 var effect = $.effects;
11661
11662
11663 /*!
11664  * jQuery UI Effects Highlight 1.11.4
11665  * http://jqueryui.com
11666  *
11667  * Copyright jQuery Foundation and other contributors
11668  * Released under the MIT license.
11669  * http://jquery.org/license
11670  *
11671  * http://api.jqueryui.com/highlight-effect/
11672  */
11673
11674
11675 var effectHighlight = $.effects.effect.highlight = function( o, done ) {
11676         var elem = $( this ),
11677                 props = [ "backgroundImage", "backgroundColor", "opacity" ],
11678                 mode = $.effects.setMode( elem, o.mode || "show" ),
11679                 animation = {
11680                         backgroundColor: elem.css( "backgroundColor" )
11681                 };
11682
11683         if (mode === "hide") {
11684                 animation.opacity = 0;
11685         }
11686
11687         $.effects.save( elem, props );
11688
11689         elem
11690                 .show()
11691                 .css({
11692                         backgroundImage: "none",
11693                         backgroundColor: o.color || "#ffff99"
11694                 })
11695                 .animate( animation, {
11696                         queue: false,
11697                         duration: o.duration,
11698                         easing: o.easing,
11699                         complete: function() {
11700                                 if ( mode === "hide" ) {
11701                                         elem.hide();
11702                                 }
11703                                 $.effects.restore( elem, props );
11704                                 done();
11705                         }
11706                 });
11707 };
11708
11709
11710
11711 }));